public void Authorize(UserId user, object message)
 {
     var decider = GetDeciderForMessage(user);
       if (!decider.AreAllAllowed(_resolver.ResolvePermission(message))) {
     throw new SecurityException(string.Format("Yo bro, u do not have permission to {0}", message.GetType().Name.ToLowerInvariant()));
       }
 }

		public static IObservable<StatusCollection> GetUserTimeline(
			this TwitterAccount account,
			UserId? userId = null,
			int? count = null,
			StatusId? sinceId = null,
			StatusId? maxId = null,
			bool? trimUser = null,
			bool? excludeReplies = null,
			bool? contributorDetails = null,
			bool? includeRts = null,
			bool isStartup = false)
		{
			const string endpoint = "statuses/user_timeline";
			var source = isStartup
				? StatusSource.RestApi | StatusSource.Startup
				: StatusSource.RestApi;
			var client = account.ToOAuthClient(endpoint);

			if (userId.HasValue) client.Parameters.Add("user_id", userId.Value);
			if (count.HasValue) client.Parameters.Add("count", count.Value);
			if (sinceId.HasValue) client.Parameters.Add("since_id", sinceId.Value);
			if (maxId.HasValue) client.Parameters.Add("max_id", maxId.Value);
			if (trimUser.HasValue) client.Parameters.Add("trim_user", trimUser.Value);
			if (excludeReplies.HasValue) client.Parameters.Add("exclude_replies", excludeReplies.Value);
			if (contributorDetails.HasValue) client.Parameters.Add("contributor_details", contributorDetails.Value);
			if (includeRts.HasValue) client.Parameters.Add("include_rts", includeRts.Value);

			return Observable
				.Defer(client.GetResponseText)
				.Select(json => StatusCollection.Parse(json, source))
				.OnErrorRetry(3)
				.WriteLine(endpoint);
		}

 public Invite(string email, string displayName, UserId userId, string token)
 {
     Email = email;
     DisplayName = displayName;
     FutureUserId = userId;
     FutureToken = token;
 }

            public User GetUser(UserId userId)
            {
                Guard.IsTrue("userId", () => userId.ToString().Length>0);

                var request = AsanaRequest.Get(string.Format("users/{0}", userId));
                return ExecuteRequest<User>(request);
            }

        public void Create(UserId userId, SecurityId securityId)
        {
            if (_state.Version != 0)
                throw new DomainError("User already has non-zero version");

            Apply(new UserCreated(userId, securityId, DefaultLoginActivityThreshold));
        }

 IAccessDecider GetDeciderForMessage(UserId userId)
 {
     var combinator = new AccessDecisionCombinator();
       var user = _userRepository.Get(userId);
       user.CombineDecisions(combinator, _roleRepository);
       return combinator.BuildDecider();
 }

        public AuthenticationResult PerformIdentityAuth(string identity)
        {
            long userId;
            var logins = _webEndpoint.GetSingleton<LoginsIndexView>().Identities;
            if (!logins.TryGetValue(identity, out userId))
            {
                // login not found
                return AuthenticationResult.UnknownIdentity;
            }
            var id = new UserId(userId);

            var maybe = _webEndpoint.GetView<LoginView>(id);

            if (!maybe.HasValue)
            {
                // we haven't created view, yet
                return AuthenticationResult.UnknownIdentity;
            }

            var view = maybe.Value;

            // ok, the view is locked.
            if (view.LockedOutTillUtc > DateTime.UtcNow.AddSeconds(2))
            {
                return new AuthenticationResult(ComposeLockoutMessage(view));
            }

            // direct conversion, will be updated to hashes

            ReportLoginSuccess(id, view);
            return ViewToResult(id, view);
        }

		public List this[ListId id, UserId ownerId]
		{
			get
			{
				var key = Tuple.Create(id, ownerId);
				return this.DoReadLockAction(() => this.lists.ContainsKey(key) ? this.lists[key] : null);
			}
		}

 public void AddIdentity(IDomainIdentityService ids, PasswordGenerator pwds, string display, string identity)
 {
     if (_state.ContainsIdentity(identity))
         return;
     var user = new UserId(ids.GetId());
     var token = pwds.CreateToken();
     Apply(new SecurityIdentityAdded(_state.Id, user, display, identity, token));
 }

		public void SetFallbackToken(UserId userId, Guid applicationId)
		{
			this.fallbackToken = null;
			this.FallbackUserId = userId;
			this.FallbackApplicationId = applicationId;

			this.RaisePropertyChanged("FallbackToken");
		}

 public User(InMemoryDomainEvents domainEvents, UserId id, string name, string email)
     : base(domainEvents)
 {
     Id = id;
     Name = name;
     _email = email;
     TryRaiseEvent(new UserCreated() { UserId = Id, UserName = Name, UserEmail = Email, Version = Version });
 }

 public void UpdateLogin(UserId id, DateTime timeUtc)
 {
     var item = Items[id.Id];
     if (item.LastLoginUtc < timeUtc)
     {
         item.LastLoginUtc = timeUtc;
     }
 }

		private static IObservable<List> ShowListCore(OAuthClient client, string endpoint, UserId ownerId)
		{
			return Observable
				.Defer(() => client.GetResponseText())
				.Select(json => List.Parse(json, ownerId))
				.OnErrorRetry(3)
				.WriteLine(endpoint, list => list.FullName);
		}

        public ActionResult VkontakteLogin(string uid, string firstName, string lastName, string photo, string returnUrl)
        {
            var userId = new UserId(uid);
            _bus.Send(new ReportUserLoggedIn(userId, firstName + " " + lastName, photo));

            FormsAuthentication.SetAuthCookie(uid, true);
            return SuccessfullLoginRedirect(returnUrl);
        }

        private void SetUserEmailIfNeeded(UserId userId, EmailAddress email)
        {
            UserDetails userDetails = _readModel.GetUserDetails(userId);

            if (String.IsNullOrWhiteSpace(userDetails.Email))
            {
                _bus.Send(new SetUserEmail(userId, email));
            }
        }

        public void UpdateDisplayName(UserId userId, string displayName)
        {
            var user = _state.GetUser(userId);

            if (user.DisplayName == displayName)
                return;

            Apply(new SecurityItemDisplayNameUpdated(_state.Id, userId, displayName));
        }

		public static IObservable<List> ShowList(this TwitterAccount account, UserId owner, string slug)
		{
			const string endpoint = "lists/show";
			var client = account.ToOAuthClient(endpoint);
			client.Parameters.Add("slug", slug);
			client.Parameters.Add("owner_id", owner);

			return ShowListCore(client, endpoint, account.UserId);
		}

 /// <summary>
 /// Gets the file name of the given user id.
 /// </summary>
 /// <param name="userId">the user id.</param>
 /// <returns>the file name.</returns>
 static string GetFileName(UserId userId)
 {
     if (userId == UserId.User1)
         return @"Assets\Data\User1Contacts.xml";
     else if (userId == UserId.User2)
         return @"Assets\Data\User2Contacts.xml";
     else
         throw new NotSupportedException($"{userId} is not supported");
 }

 public AccountManagement.User GetUser(UserId userId)
 {
     using (var db = new THCard()) {
         Guid userIdAsGuid = userId.ToGuid();
         User dbUser = db.Users.SingleOrDefault(u => u.UserId == userIdAsGuid);
         AccountManagement.User user = MapToUser(dbUser);
         return user;
     }
 }

 public void AddItem(UserId userId, SecurityItemType type, string displayName, string value)
 {
     Items[userId.Id] = new SecurityItem
         {
             Display = displayName,
             Type = type,
             Value = value,
             UserId = userId.Id
         };
 }