public ICommand GetCommand(CommandType commandType, UserContext userContext, ResourceType entityType, EntityMetadata entityMetadata, string membershipId)
		{
			if (entityType.Name == "CommandInvocation")
			{
				CommandType commandType1 = commandType;
				switch (commandType1)
				{
					case CommandType.Create:
					case CommandType.Read:
					case CommandType.Delete:
					{
						return new GICommand(commandType, this.runspaceStore, entityType, userContext, membershipId);
					}
					case CommandType.Update:
					{
						throw new NotImplementedException();
					}
					default:
					{
						throw new NotImplementedException();
					}
				}
			}
			else
			{
				throw new NotImplementedException();
			}
		}

        private void OnReceive(UserContext context)
        {
            Console.WriteLine("Received Data From :" + context.ClientAddress);

            string jsonString = context.DataFrame.ToString();
            ParseIncoming(new AlchemySession(context), jsonString);
        }

		public static void ProcessedRequestHandler(object source, DataServiceProcessingPipelineEventArgs args)
		{
			TraceHelper.Current.DebugMessage("QuotaSystem.ProcessedRequestHandler entered");
			if (args != null)
			{
				args.OperationContext.Trace();
			}
			UserContext userContext = new UserContext(CurrentRequestHelper.Identity, CurrentRequestHelper.Certificate);
			if (DataServiceController.Current.IsRequestProcessingStarted(userContext))
			{
				try
				{
					DataServiceController.Current.SetRequestProcessingState(userContext, false);
					UserDataCache.UserDataEnvelope userDataEnvelope = DataServiceController.Current.UserDataCache.Get(userContext);
					using (userDataEnvelope)
					{
						userDataEnvelope.Data.Usage.RequestProcessed();
					}
					TraceHelper.Current.RequestProcessingEnd();
				}
				finally
				{
					DataServiceController.Current.UserDataCache.TryUnlockKey(userContext);
					TraceHelper.Current.DebugMessage("QuotaSystem.ProcessedRequestHandler exited");
				}
				return;
			}
			else
			{
				TraceHelper.Current.DebugMessage("QuotaSystem.ProcessedRequestHandler IsRequestProcessingStarted returned false");
				return;
			}
		}

        private void ReceivedMsg(UserContext context)
        {
            string message = context.DataFrame.ToString();
            if (message.Contains("left"))
            {
                bool dblClick = false;
                if (message.Contains("dbl"))
                {
                    dblClick = true;
                }
                MouseController.MouseLeft(dblClick);
            }
            else if (message.Contains("right"))
            {
                MouseController.MouseRight();
            }
            else if (message.Contains("key"))
            {
                HandleKeyIn(message);
            }
            else
            {
                string move = context.DataFrame.ToString();
                string[] XandY = move.Split(',');
                int mX = Int32.Parse(XandY[0]);
                int mY = Int32.Parse(XandY[1]);

                int[] mousePos = MouseController.GetMousePosition();
                mX = mousePos[0] + mX;
                mY = mousePos[1] + mY;

                MouseController.moveMouse(mX, mY);
            }
        }

        public virtual void SignIn(User user, bool createPersistentCookie) {
            var now = DateTime.UtcNow.ToLocalTime();

            var ticket = new FormsAuthenticationTicket(
                1,
                user.Username,
                now,
                now.Add(_expirationTimeSpan),
                createPersistentCookie, user.Username,
                FormsAuthentication.FormsCookiePath);

            var encryptedTicket = FormsAuthentication.Encrypt(ticket);

            var cookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
            cookie.HttpOnly = true;
            if (ticket.IsPersistent) {
                cookie.Expires = ticket.Expiration;
            }
            cookie.Secure = FormsAuthentication.RequireSSL;
            cookie.Path = FormsAuthentication.FormsCookiePath;
            if (FormsAuthentication.CookieDomain != null) {
                cookie.Domain = FormsAuthentication.CookieDomain;
            }

            _httpContext.Response.Cookies.Add(cookie);
            _cachedUser = user;

            var userContext = new UserContext { User = user };
            foreach(var authenticationEventHandler in _authenticationEventHandlers) {
                authenticationEventHandler.SignIn(userContext);
            }

        }

		public bool QuotaCheckAndUpdate(UserContext userContext, UserQuota quota)
		{
			bool flag;
			lock (this.syncObject)
			{
				if (this.CheckConcurrentRequestQuota(quota.MaxConcurrentRequests))
				{
					if (this.CheckRequestPerTimeSlotQuota(quota.MaxRequestsPerTimeSlot, quota.TimeSlotSize))
					{
						Usage usage = this;
						usage.concurrentRequests = usage.concurrentRequests + 1;
						this.requests.Increment(quota.TimeSlotSize);
						TraceHelper.Current.UserQuotaSucceeded(userContext.Name);
						TraceHelper.Current.DebugMessage(string.Concat("Usage.QuotaCheckAndUpdate called. Concurrent requests = ", this.concurrentRequests));
						flag = true;
					}
					else
					{
						DataServiceController.Current.QuotaSystem.UserQuotaViolation.Increment();
						TraceHelper.Current.UserQuotaViolation(userContext.Name, "MaxRequestPerTimeSlot quota violation");
						DataServiceController.Current.PerfCounters.UserQuotaViolationsPerSec.Increment();
						flag = false;
					}
				}
				else
				{
					DataServiceController.Current.QuotaSystem.UserQuotaViolation.Increment();
					TraceHelper.Current.UserQuotaViolation(userContext.Name, "MaxConcurrentRequest quota violation");
					DataServiceController.Current.PerfCounters.UserQuotaViolationsPerSec.Increment();
					flag = false;
				}
			}
			return flag;
		}

        public static void OnDisconnect(UserContext context)
        {
            Console.WriteLine("Client Disconnection From : " + context.ClientAddress);

            if (presenter != null && presenter.ClientAddress == context.ClientAddress)
            {
                Console.WriteLine("Oh shit we lost the tv.");

                // Reset everything.
                // Fuck this whole thing needs to be rewritten
                presenter = null;
                acceptingPlayers = true;
                players.ForEach(x => x.Send(JsonConvert.SerializeObject(new { Type = CommandType.End }), false, true));
                players.Clear();
            }

            //throw new Exception("Yeah nar we don't handle disconnects");

            /*var remove = players.FirstOrDefault(x => x.ClientAddress.Equals(context.ClientAddress));
            if (remove != null)
            {
                players.Remove(remove);
                Console.WriteLine(context.ClientAddress);
            }*/
        }

        public static void OnReceive(UserContext context)
        {
            string data = string.Empty;

            try
            {
                mCounter++;
                data = context.DataFrame.ToString();
                Console.WriteLine("Data Received From [" + context.ClientAddress.ToString() + "] - " + data + " (" + data.Length.ToString() + " - " + mCounter.ToString() + ")");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message.ToString());
            }

            //context.Send("Hello2");
            if (data == "PING")
            {
                context.Send("PONG!");
            }
            else if (data == "abc")
            {
                string sendData = new string('x', 32768);
                context.Send(sendData);
            }
            else
            {
                //context.Send("Echo back: " + data);
            }
        }

 public PresentationRepository()
 {
     this.context = new UserContext();
     this.dbSet = context.Set<PresentationModel>();
     this.dbSetTag = context.Set<Tag>();
     this.dbRatings = context.Set<RatingsModel>();
 }

 public static XElement exportUploadSettingsToXml(this IUserSettings settings, UserContext context)
 {
     return new XElement("uploadSettings",
         new XElement("maxWidth", settings.maxUploadImageWidth),
         new XElement("maxHeight", settings.maxUploadImageHeight)
     );
 }

		public ReferredEntityInstance(DSResource resource, UserContext userContext, ResourceType type, EntityMetadata metadata, string membershipId)
		{
			this.userContext = userContext;
			this.resourceType = type;
			this.metadata = metadata;
			this.membershipId = membershipId;
			this.resource = resource;
		}

 public void SaveOrUpdateUser(User user)
 {
     using (var db = new UserContext())
     {
         db.Users.AddOrUpdate(user);
         db.SaveChanges();
     }
 }

		public void Build(Microsoft.Management.Odata.Schema.Schema logicalSchema, Microsoft.Management.Odata.Schema.Schema userSchema, UserContext userContext, string membershipId)
		{
			Envelope<PSRunspace, UserContext> envelope = this.runspaceStore.Borrow(userContext, membershipId);
			using (envelope)
			{
				this.Build(logicalSchema, userSchema, envelope.Item.Runspace);
			}
		}

        public static void OnDisconnect(UserContext context)
        {
            Console.WriteLine("Client Disconnected : " + context.ClientAddress.ToString());

            // Remove the connection Object from the thread-safe collection
            UserContext uc;
            UserContexts.TryRemove(context.ClientAddress.ToString(), out uc);
        }

        /// <summary>
        /// Event fired when a client connects to the Alchemy Websockets server instance.
        /// Adds the client to the online users list.
        /// </summary>
        /// <param name="context">The user's connection context</param>
        public static void OnConnect(UserContext context)
        {
            Console.WriteLine("Client Connection From : " + context.ClientAddress);

            var me = new User {Context = context};

            OnlineUsers.TryAdd(me, String.Empty);
        }

 static void OnDisconnect(UserContext context)
 {
     lock (ActiveContexts)
     {
         Write("Disconnected", context);
         ActiveContexts.Remove(context);
     }
 }

        public PlayerController(

            IPlayerQueries playerQueries, IPlayerCommands playerCommands, IPlayerActions playerActions, UserContext userContext)
            : base(userContext)
        {
            _playerQueries = playerQueries;
            _playerCommands = playerCommands;
            _playerActions = playerActions;
        }

 public static void OnConnected(UserContext context)
 {
     Utilities.Logger.Debug("New websocket connection : " + context.ClientAddress.ToString());
     var client = new WebClientConnection(context);
     lock (Clients)
     {
         Clients.Add(new WebClientConnection(context));
     }
 }

 static void OnConnect(UserContext context)
 {
     lock (ActiveContexts)
     {
         Write("Connected", context);
         ActiveContexts.Add(context);
         new Thread(() => HandleClient(context)).Start();
     }
 }

 public override void CreateRole(string roleName)
 {
     var newRole = new Role() { Name = roleName };
     using (var context = new UserContext())
     {
         context.Roles.Add(newRole);
         context.SaveChanges();
     }
 }