public JobBuilder(OrderModel order, UserModel userModel, IHRIDService hridService, Vendor vendor = null)
 {
     job = new Job(order, hridService.NextId("Job"));
     job.User = userModel;
     job.Vendor = vendor;
     job.ProfitShareResult = vendor?.Strategy?.Calculate(order.OrderCart.TotalToPay.Value);
 }

 // user entity => user model
 public static UserModel ToModel(this User entity)
 {
     var model = new UserModel();
     AutoMapper.Mapper.CreateMap<User, UserModel>();
     AutoMapper.Mapper.Map(entity, model);
     return model;
 }

            public RedirectToRouteResult LogIn(UserModel log)
            {
                Diagnostics.Debug.WriteLine("LogIn");
                Diagnostics.Debug.WriteLine(log.Nombre);
                Diagnostics.Debug.WriteLine(log.Apellido);
                Diagnostics.Debug.WriteLine(log.User);
                Diagnostics.Debug.WriteLine(log.Password);
                Diagnostics.Debug.WriteLine(log.Correo);
                Diagnostics.Debug.WriteLine(log.Genero);
                Diagnostics.Debug.WriteLine(log.Celular);

                Sesion li = new Sesion();
                if (li.user == null)
                {
                    string usuario = log.User;
                    string clave = log.Password;

                    if (li.IniciarSesion(usuario, clave))
                        return RedirectToAction("Index", "Dashboard");

                    else
                        return RedirectToAction("LogIn", "LogIn");
                }
                else
                {
                    li.user = log.User;
                    li.key = log.Password;

                    return RedirectToAction("LogIn", "LogIn");
                }
            }

        public ActionResult Lock(UserModel usersModel)
        {
            try
            {
                if (usersModel != null)
                {
                    var user = _userRepository.GetUsersModelByUserNameAndPassword(usersModel.UserName,
                        usersModel.Password);
                    if (user != null)
                    {
                        Session["User"] = user;
                        return RedirectToAction("Index", "Home");
                    }
                    else
                    {

                        return RedirectToAction("Login", "Account");
                    }

                }
            }
            catch (Exception)
            {

                throw;
            }
            return RedirectToAction("Login", "Account");
        }

        public void TestWithValidPost_ShouldCreatePostInDatabase()
        {
            var testPost = new Post()
                {
                    Title = "Test post",
                    Tags = new List<Tag>() { new Tag()
                        {
                            Name = "technology"
                        },
                       
                },
                    Text = "this is just a test post"
                };

            var testUser = new UserModel()
            {
                Username = "VALIDUSER",
                DisplayName = "VALIDNICK",
                AuthCode = new string('b', 40)
            };
            LoggedUserModel userModel = RegisterTestUser(httpServer, testUser);

            var headers = new Dictionary<string, string>();
            headers["X-sessionKey"] = userModel.SessionKey;

            var response = httpServer.Post("api/posts", testPost, headers);
            Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
        }

        /// <summary>
        /// 增加一条数据
        /// </summary>
        public bool Add(UserModel model)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("insert into UserInfo(");
            strSql.Append("Id,UserName,PassWord,AddTime)");
            strSql.Append(" values (");
            strSql.Append("@Id,@UserName,@PassWord,@AddTime)");
            SqlParameter[] parameters = {
                    new SqlParameter("@Id", SqlDbType.UniqueIdentifier,16),
                    new SqlParameter("@UserName", SqlDbType.VarChar,50),
                    new SqlParameter("@PassWord", SqlDbType.VarChar,50),
                    new SqlParameter("@AddTime", SqlDbType.DateTime)};
            parameters[0].Value = Guid.NewGuid();
            parameters[1].Value = model.UserName;
            parameters[2].Value = model.PassWord;
            parameters[3].Value = model.AddTime;

            int rows = DbHelperSQL.ExecuteSql(strSql.ToString(), parameters);
            if (rows > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public HttpResponseMessage Post(UserModel model)
        {
            HttpResponseMessage response = new HttpResponseMessage();
            var user = model.ToEntity();
            int userId = userService.UserRegistrationAndUpdation("insert",user);
            if (model.Image != null)
            {
                if (HttpContext.Current.Request.Files.AllKeys.Any())
                {
                    // Get the uploaded image from the Files collection
                    var httpPostedFile = HttpContext.Current.Request.Files["UploadedImage"];

                    if (httpPostedFile != null)
                    {
                        string lastPart = Path.GetExtension(httpPostedFile.FileName);
                        string fileName = string.Format("{0}_{1}.{2}", httpPostedFile.FileName, userId, lastPart);
                        // Get the complete file path
                        var fileSavePath = Path.Combine(HttpContext.Current.Server.MapPath("~/Images/User"), httpPostedFile.FileName);

                        // Save the uploaded file to "UploadedFiles" folder
                        httpPostedFile.SaveAs(fileSavePath);
                    }
                }
            }
            response.Content = new StringContent("Registration Successfully", Encoding.Unicode);
            return response;
        }

 public void Update(UserModel updatedUser)
 {
     var existing = Get(updatedUser.Id.GetValueOrDefault());
     if (existing != null)
     {
         existing.DisplayName = updatedUser.DisplayName;
         existing.UserName = updatedUser.UserName;
         existing.ExternalId = updatedUser.ExternalId;
         existing.Name = updatedUser.Name;
         existing.DisplayName = updatedUser.DisplayName;
         existing.NickName = updatedUser.NickName;
         existing.ProfileUrl = updatedUser.ProfileUrl;
         existing.Emails = updatedUser.Emails;
         existing.Addresses = updatedUser.Addresses;
         existing.PhoneNumbers = updatedUser.PhoneNumbers;
         existing.Ims = updatedUser.Ims;
         existing.Photos = updatedUser.Photos;
         existing.UserType = updatedUser.UserType;
         existing.Title = updatedUser.Title;
         existing.PreferredLanguage = updatedUser.PreferredLanguage;
         existing.Locale = updatedUser.Locale;
         existing.Timezonoe = updatedUser.Timezonoe;
         existing.Active = updatedUser.Active;
         existing.Password = updatedUser.Password;
         existing.Groups = updatedUser.Groups;
         existing.X509Certificates = updatedUser.X509Certificates;
         existing.Meta = updatedUser.Meta;
     }
 }

        /// <summary>
        /// Adds a login attempt to a user's log.
        /// </summary>
        /// <param name="userModel">UserModel with new Data.</param>
        /// <returns>Number of affected rows, should be 1.</returns>
        public LoginLog AddLogEntry(UserModel userModel)
        {
            ClientIdentifier clientIdentifier = Entities.ClientIdentifier.FirstOrDefault(x => x.UserName == userModel.UserName);

            LoginLog loginLog = new LoginLog
                {
                    IpAdress = userModel.IpAdress,
                    TimeStamp = DateTime.Now,
                    UserAgent = userModel.UserAgent,
                    Success = 0

                };

            if (clientIdentifier != null)
            {
                clientIdentifier.LastLogin = DateTime.Now;

                if (clientIdentifier.LoginLog == null)
                           clientIdentifier.LoginLog = new Collection<LoginLog>();

                clientIdentifier.LoginLog.Add(loginLog);
            }

            Entities.SaveChanges();

            return loginLog;
        }

        // Update is called once per frame
        public void UpdateInfo(UserModel userModel)
        {
            if (userModel != null) {
                username.text = "Username: " + userModel.info.username;
                if (userModel.info.gender == "m") {
                    gender.text = "Gender: Male";
                } else if (userModel.info.gender == "f") {
                    gender.text = "Gender: Female";
                } else {
                    gender.text = "Gender: " + userModel.info.gender;
                }
                country.text = "Country: " + userModel.info.country;
                state.text = "State: " + userModel.info.state;

                if (userModel.info.thumbnailUrl != null) {
                    GetUserPic(userModel.info.thumbnailUrl);
                }
            } else {
                username.text = "";
                gender.text = "";
                country.text = "";
                state.text = "";
                userPic.sprite = null;
            }
        }

	    private async Task GetOrCreateUser()
	    {
            using (var scope = Container.BeginLifetimeScope())
            {
                var userService = scope.Resolve<IUserService>();
                var user = await userService.GetByIdAsync(User.Id);
                if (user == null)
                {
                    var result = await userService.AddUserAsync(new UserModelAdd { DeviceId = User.DeviceId });
                    if (result.IsSuccess)
                    {
                        User = result.Model;
                        SavePreference(SipperPreference.UserId, User.Id.ToString());
                        SavePreference(SipperPreference.DeviceId, User.DeviceId.ToString());
                    }
                    else
                    {
                        Log.Debug("@string/log_prefix", "User cannot be registered");
                    }
                }
                else
                {
                    User = user;
                }
            }
	    }

        public ActionResult SaveChanges(UserModel model)
        {
            if (!ModelState.IsValid)
                return null;

            T_User entity = UserModel.ModelToEntity(model);

            // Save add action
            if (model.user_id <= 0)
            {
                entity.user_password = "soft";
                entity.user_date_subscription = DateTime.Now;

                _context.Add(entity);
                _context.SaveChanges();
                Log.Info(string.Format("Edit user id={0} name={1}", entity.user_id, entity.user_name));

                return GenerateJson(entity, true, "Nouveau utilisateur ajouté.");
            }
            // Save edit action
            else
            {
                _context.Edit(entity);
                _context.SaveChanges();
                Log.Info(string.Format("Create user id={0} name={1}", entity.user_id, entity.user_name));

                return GenerateJson(entity, false, "Utilisateur modifié.");
            }
        }

 private LoggedUserModel RegisterTestUser(InMemoryHttpServer httpServer, UserModel testUser)
 {
     var response = httpServer.Post("api/users/register", testUser);
     var contentString = response.Content.ReadAsStringAsync().Result;
     var userModel = JsonConvert.DeserializeObject<LoggedUserModel>(contentString);
     return userModel;
 }

        public HttpResponseMessage LoginUser(UserModel user)
        {
            IQueryable<User> users = this.userRepository.GetAll();

            var result = from u in users
                         where u.Username == user.Username && u.Password == user.Password
                         select u;

            User newUser = result.FirstOrDefault();
            if (newUser != null)
            {
                var rep = new DbUsersRepository(db);
                var sessionKey = rep.LoginUser(user.Username, user.Password);
                UserLoggedModel userModel = new UserLoggedModel()
                {
                    UserID = newUser.UserID,
                    Username = newUser.Username,
                    SessionKey = sessionKey
                };
                var responseMsg = Request.CreateResponse(HttpStatusCode.OK, userModel);
                return responseMsg;
            }
            else
            {
                var responseMsg = Request.CreateResponse(HttpStatusCode.NotFound);
                return responseMsg;
            }
        }

        public string Add(AddUserModel model)
        {
            if (ModelState.IsValid)
            {
                UserModel user = new UserModel();
                user.Code = model.Code;                             //登录名
                user.Password = "123456".VariationMd5();            //默认密码

                user.Name = model.Name;                             //姓名
                user.Phone = model.Phone;                           //电话
                user.No = model.No;                                 //用户编号

                user.Departmentid = model.Departmentid.ToInt();     //部门
                user.Gender = model.Gender;                         //性别
                user.Age = model.Age;                               //年龄

                user.Status = model.Status;                         //用户状态
                user.Email = model.Email;                           //邮箱

                user.DelFlag = 0;                                   //有效状态
                user.CreateMan = SysConfig.CurrentUser.Id;          //创建人
                user.CreateTime = DateTime.Now;                     //创建时间
                int result = user.Insert().ToInt();

                if (result > 0)
                {
                    //记录操作日志
                    CommonMethod.Log(SysConfig.CurrentUser.Id, "Insert", "Sys_User");
                    return "1";
                }
            }
            return "0";
        }

        public HttpResponseMessage LoginUser(UserModel model)
        {
            var baseResponse = this.TryToExecuteOperation(() =>
            {
                this.ValidateUsername(model.Username);
                this.ValidateAuthCode(model.AuthCode);
                var usernameToLower = model.Username.ToLower();
                var user = repository.All()
                    .FirstOrDefault(usr => usr.Username == usernameToLower && usr.AuthCode == model.AuthCode);

                if (user == null)
                {
                    throw new InvalidOperationException("Username is not exist!");
                }

                if (user.SessionKey == null)
                {
                    user.SessionKey = this.GenerateSessionKey(user.UserId);
                    repository.Update(user.UserId, user);
                }

                var userModel = new LoggedUserModel()
                {
                    DisplayName = user.DisplayName,
                    SessionKey = user.SessionKey
                };

                var response = this.Request.CreateResponse(HttpStatusCode.Created, userModel);
                return response;
            });
            return baseResponse;
        }

        // GET: UserMgt
        public ActionResult Index()
        {
            UserModel model = new UserModel();
            string code = Request.QueryString["code"];
            string state = Request.QueryString["state"];
            if (!string.IsNullOrEmpty(code))
            {
                model.OpenId = HttpHelper.GetOpenIdByAuthCode(code, state);
            }
            try
            {
                ViewBag.GenderList = EnumHelper.GetEnumList(typeof(PublicEnum.Gender));
                ViewBag.IdTypeList = EnumHelper.GetEnumList(typeof(PublicEnum.IdType));
                ViewBag.ProvinceList = this.GetProvince();
                ViewBag.CityList = this.GetCities(DefaultProvinceId);
                ViewBag.DistrictList = this.GetDistricts(DefaultCityId);
            }
            catch (Exception exp)
            {

                ViewBag.Message = exp.Message;
            }

            return View("Index", model);
        }

        public UcPassAtt(WPro aPro, UserModel userModel)
        {
            _APro = aPro;
            _UserModel = userModel;

            InitializeComponent();
        }

        public UserModel GetUser(int userId)
        {
            UserModel model = new UserModel();

            User user = session.Load<User>(userId);
            return model.FilledBy(user);
        }

        public static void WriteDefaultLogin(UserModel user,bool isEnableDomain,bool isFirst=true)
        {
            try
            {
                if (isFirst)
                {
                    RegistryKey rekey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon", true);
                    if (rekey == null) return;
                    else
                    {
                        rekey.SetValue("AutoAdminLogon", "1");
                        rekey.SetValue("DefaultUserName", user.UserName);
                        rekey.SetValue("DefaultPassword", user.Password);
                        if (isEnableDomain)
                            rekey.SetValue("DefaultDomainName", user.Domain);
                        LogHelper.WriteLog("用户" + user.UserName + "自动登录，登录密码为：" + user.Password);
                    }
                    rekey.Close();
                }
                else
                {

                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLog("设置自动登录错误",ex);
            }
        }