public Task Connect()
        {
            UserAccount ua = new UserAccount(Context.User.Identity.Name);

            ChatRoomUser cru = new ChatRoomUser();

            cru.GetChatRoomUserByUserAccountID(ua.UserAccountID);

            if (cru.ChatRoomUserID == 0)
            {
                cru.CreatedByUserID = ua.UserAccountID;
                cru.ConnectionCode = Context.ConnectionId;
                cru.Create();
            }
            else
            {
                cru.ConnectionCode = Context.ConnectionId;
                cru.UpdatedByUserID = ua.UserAccountID;
                cru.Update();
            }

            Send(@"<i style=""color:yellow;font-size:10px;font-style: italic;"">CONNECTION OPENED</i>", ua.UserAccountID);

            return Clients.joined(Context.ConnectionId, DateTime.UtcNow.ToString());
        }

        /// <summary>
        /// Updates session from DB object
        /// </summary>
        /// <param name="user"></param>
        public void UpdateFrom(UserAccount user)
        {
            UpdatedOn = DateTime.UtcNow;
            UserId = user.Id;

            OnUpdate(user);
        }

        public static UserAccounts GetUsersInRole(int roleID)
        {
            UserAccounts uars = null;

            // get a configured DbCommand object
            DbCommand comm = DbAct.CreateCommand();
            // set the stored procedure name
            comm.CommandText = "up_GetUsersInRole";

            ADOExtenstion.AddParameter(comm, "roleID", roleID);

            // execute the stored procedure
            DataTable dt = DbAct.ExecuteSelectCommand(comm);

            // was something returned?
            if (dt != null && dt.Rows.Count > 0)
            {
                uars = new UserAccounts();
                UserAccount art = null;
                foreach (DataRow dr in dt.Rows)
                {
                    art = new UserAccount(dr);
                    uars.Add(art);
                }
            }
            return uars;
        }

        public UserCreateStatus CreateAccount(string username, string password, string fullname, string email)
        {
            bool exists = Repository.FirstOrDefault(u => u.LocalCredentials != null && u.LocalCredentials.Username == username) != null;
            if (!exists)
            {
                if (!Validator.CheckPassword(password))
                    return UserCreateStatus.InsufficientPassword;

                UserAccount user = new UserAccount
                {
                    PublicIdentifier = HashHelper.ComputePublicIdentifier(typeof(UserAccount).Name, username),
                    LocalCredentials = new LocalCredentials
                    {
                        Username = username,
                        Password = HashHelper.ComputePassword(username, password)
                    },
                    Enabled = true,
                    Created = DateTime.Now,
                    Fullname = fullname,
                    Email = email,
                    UserRole = UserRole.User
                };
                Repository.Insert(user);
                return UserCreateStatus.Created;
            }
            ActivityService.UserRegistered(username);
            return UserCreateStatus.UsernameUsed;
        }

        public ProfileController(IMailService mail)
        {
            _mail = mail;
            _mu = MembershipWrapper.GetUser();

            if (_mu != null) _ua = new UserAccount(_mu.UserName);
        }

    private void SaveToken(string token, string shopName)
    {
        string isExistingShop = Request.QueryString["isES"];

        // save token in database
        DataModelEntities context = new DataModelEntities();

        if (isExistingShop == "0") // new user
        {
            UserAccount userAccount = new UserAccount();

            userAccount.User_Code = UserKey;
            userAccount.Account_Code = (int)Constant.Accounts.Shopify;
            userAccount.Application_Name = shopName;
            userAccount.Config_Value1 = token;
            userAccount.Created_Date = DateTime.Now;
            userAccount.Is_Active = true;

            context.UserAccounts.AddObject(userAccount);
        }
        else
        {
            UserAccount userAccount = context.UserAccounts.First(u => u.User_Code == UserKey && u.Is_Active == true && u.Account_Code == (int)Constant.Accounts.Shopify);
            userAccount.Application_Name = shopName;
            userAccount.Config_Value1 = token;
            userAccount.Modified_Date = DateTime.Now;
            userAccount.User_IP = Request.UserHostAddress;
        }

        context.SaveChanges();
        context = null;
    }

 public void CallsUpdateOnRepository()
 {
     var repo = new Mock<IUserAccountRepository>();
     var sub = new UserAccountService(repo.Object, null, null);
     var ua = new UserAccount();
     sub.Update(ua);
     repo.Verify(x => x.Update(ua));
 }

 /// <summary>
 /// Posts the specified user account.
 /// </summary>
 /// <param name="userAccount">The user account.</param>
 /// <returns>
 /// The Task.
 /// </returns>
 /// <remarks>
 /// This operation allows to authenticate user account.
 /// </remarks>
 /// <response code="400">Bad request</response>
 /// <response code="401">Unauthorized</response>
 /// <response code="404">Account not found</response>
 /// <response code="500">Internal Server Error</response>
 /// <response code="200">Successful</response>
 public async Task<IHttpActionResult> Post(UserAccount userAccount)
 {
     return await this.CreateAsync<User>(async operationResult =>
     {
         await this.AuthenticateUser(operationResult, userAccount);
         return string.Empty;
     });
 }

 public void Update(UserAccount item)
 {
     var other = Get(item.ID);
     if (other != item)
     {
         Remove(other);
         Add(item);
     }
 }

 /// <summary>
 ///  TODO Update Custom Session fields here
 /// </summary>
 /// <param name="user"></param>
 protected void OnUpdate(UserAccount user)
 {
     Email = user.Email;
     if (user.UserFacebookClaims != null && user.UserFacebookClaims.Any())
     {
         var social = user.UserFacebookClaims.First();
         FacebookId = social.Id;
     }
 }

        protected void btnSearch_Click(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(txtSearch.Text))
            {
                ua = new UserAccount(txtSearch.Text);

                LoadUserAddress(ua.UserAccountID);
            }
        }

        public List<Notification> CheckNewNotifications(UserAccount user, bool isRead)
        {
            List<Notification> notificationList =
                Translators.Notification.ToBusinessObject(
                    _dataAccessObjects.GetNotificationByJobRoleAndIsRead(
                        user.HighestPermission.ToString(), isRead));

            return notificationList;
        }

 public ValidationResult Validate(UserAccountService service, UserAccount account, string value)
 {
     if (value.Length < 4)
     {
         return new ValidationResult("Password must be at least 4 characters long");
     }
     
     return null;
 }

        public List<Notification> CheckAllNotifications(UserAccount user)
        {
            List<Notification> notificationList =
                Translators.Notification.ToBusinessObject(
                    _dataAccessObjects.GetNotificationByJobRole(
                        user.HighestPermission.ToString()));

            return notificationList;
        }

        public void Register(string account, string password)
        {
            var userAccount = new UserAccount();
            userAccount.Account = account;
            userAccount.Password = password.ToBinary();
            userAccount.DelFlag = 0;

            UserAccountDao.Save(userAccount);
        }

        public ActionResult CreateForum()
        {
            if (_mu == null) return View();

            var ua = new UserAccount(Convert.ToInt32(_mu.ProviderUserKey));
            if (!ua.IsAdmin) return new EmptyResult();

            return View();
        }

 public UserAccountViewModel(UserAccount user, UrlHelper url)
 {
     Name = user.Name;
     Email = user.Email;
     CreatedDateTime = user.InsertedDateTime.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
     LastSeenDateTime = user.LastSeenDateTime?.ToString("yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture);
     IsContributor = user.IsContributor;
     IsArchivist = user.IsArchivist;
     IsAdmin = user.IsAdmin;
     EditURL = url.GetURL<UserAdminController>(c => c.EditUser(user.UserAccountId));
 }

 public void UpdateAccount(UserAccount account)
 {
     try
     {
          new UserAccountDb().UpdateAccount(account);
     }
     catch (Exception ex)
     {
         LogServer.WriteLog(ex, "DBError");
     }
 }

 public override void AllowGroupMembershipRequestTo(UserAccount contactToAllow)
 {
     if (CanAllowGroupMembershipRequestTo(contactToAllow))
     {
         DomainEvents.Raise(new GroupMembershipAllowedEvent { MembershipAllowedBy = _requestedGroup, DateTime = DateTime.Now, MembershipAllowedTo = contactToAllow });
     }
     else
     {
         throw new InvalidOperationException("Membership cannot be allowed");
     }
 }

 private ForumController(IForumCategoryRepository forumcategoryRepository, IMailService mail)
 {
     ViewBag.IsAdmin = false;
     _mail = mail;
     _forumcategoryRepository = forumcategoryRepository;
     _mu = MembershipWrapper.GetUser();
     if (_mu != null)
     {
         _ua = new UserAccount(Convert.ToInt32(_mu.ProviderUserKey));
     }
 }