Esempio n. 1
0
        public override IEnumerable <ModelValidationResult> Validate(object container)
        {
            var model   = container ?? Metadata.Model;
            var results = new List <ModelValidationResult>();

            if (model is User)
            {
                var model2 = model as User;
                if (string.IsNullOrEmpty(model2.email) && string.IsNullOrEmpty(model2.phone))
                {
                    results.Add(new ModelValidationResult()
                    {
                        MemberName = nameof(model2.email), Message = "Должен быть указан один из реквизитов - e-mail или телефон."
                    });
                    results.Add(new ModelValidationResult()
                    {
                        MemberName = nameof(model2.phone), Message = "Должен быть указан один из реквизитов - e-mail или телефон."
                    });
                }
                else
                {
                    using (var db = new CoreContext())
                    {
                        if (!string.IsNullOrEmpty(model2.email))
                        {
                            if (db.Users.Where(x => x.email == model2.email && x.IdUser != model2.IdUser).Count() > 0)
                            {
                                results.Add(new ModelValidationResult()
                                {
                                    MemberName = nameof(model2.email),
                                    //Message = string.Format("Значение '{0}' для уникального поля '{1}' уже существует в базе.", model2.email, metadata.PropertyDisplayName(nameof(model2.email)))
                                    Message = string.Format("{1} '{0}' уже занят.", model2.email, Metadata.PropertyDisplayName(nameof(model2.email)))
                                });
                            }
                        }
                        if (!string.IsNullOrEmpty(model2.phone))
                        {
                            var phone = UsersExtensions.preparePhone(model2.phone);
                            if (db.Users.Where(x => x.phone == phone && x.IdUser != model2.IdUser).Count() > 0)
                            {
                                results.Add(new ModelValidationResult()
                                {
                                    MemberName = nameof(model2.phone),
                                    //Message = string.Format("Значение '{0}' для уникального поля '{1}' уже существует в базе.", model2.phone, metadata.PropertyDisplayName(nameof(model2.phone)))
                                    Message = string.Format("{1} '{0}' уже занят.", model2.phone, Metadata.PropertyDisplayName(nameof(model2.phone)))
                                });
                            }
                        }
                    }
                }
            }

            return(results);
        }
Esempio n. 2
0
        public virtual ActionResult UserSave(int IdUser = 0, Model.AdminUserEdit model = null)
        {
            var result = JsonAnswer <int>();

            try
            {
                if (IdUser < 0)
                {
                    throw new Exception("Не указан пользователь!");
                }
                else
                {
                    using (var db = this.CreateUnitOfWork())
                    {
                        int id = 0;

                        User      data     = null;
                        UserState oldState = 0;

                        if (IdUser > 0)
                        {
                            data = db.Users.Where(u => u.IdUser == IdUser).FirstOrDefault();
                            if (data == null)
                            {
                                ModelState.AddModelError("IdUser", "Неправильно указан пользователь!");
                            }
                            else if (data.Superuser != 0 && AppCore.GetUserContextManager().GetCurrentUserContext().IsSuperuser)
                            {
                                ModelState.AddModelError("IdUser", "У вас нет прав на редактирование суперпользователей - это могут делать только другие суперпользователи!");
                            }
                            else
                            {
                                oldState = data.State;
                                id       = IdUser;
                            }
                        }
                        else
                        {
                            data = new User()
                            {
                                salt    = "",
                                DateReg = DateTime.Now.Timestamp(),
                                IP_reg  = Request.ServerVariables["HTTP_X_FORWARDED_FOR"] ?? Request.ServerVariables["REMOTE_ADDR"]
                            };
                        }

                        var errors = new List <string>();

                        if (ModelState.ContainsKeyCorrect("User.email"))
                        {
                            data.email = model.User.email?.ToLower();
                        }
                        if (ModelState.ContainsKeyCorrect("User.phone"))
                        {
                            data.phone = UsersExtensions.preparePhone(model.User.phone);
                        }

                        if (ModelState.ContainsKeyCorrect("User.name"))
                        {
                            data.name = model.User.name;
                        }
                        if (Request.Form.HasKey("login") && !string.IsNullOrEmpty(Request.Form["login"]))
                        {
                            if (!Request.Form["login"].isOneStringTextOnly()
                                // todo переработать этот участок в нормальную модель || DataManager.check(Request.Form["login"])
                                )
                            {
                                errors.Add("Некорректный ввод поля login!");
                            }
                            else
                            {
                                data.name = Request.Form["login"];
                            }
                        }

                        if (ModelState.ContainsKeyCorrect("User.name"))
                        {
                            data.name = model.User.name;
                        }
                        if (ModelState.ContainsKeyCorrect("User.about"))
                        {
                            data.about = model.User.about;
                        }

                        if (ModelState.ContainsKeyCorrect("User.Superuser"))
                        {
                            if (!AppCore.GetUserContextManager().GetCurrentUserContext().IsSuperuser)
                            {
                                errors.Add("Недостаточно прав для установки или снятия признака суперпользователя!");
                            }
                            data.Superuser = (byte)(model.User.Superuser == 0 ? 0 : 1);
                        }

                        if (ModelState.ContainsKeyCorrect("User.State"))
                        {
                            switch (model.User.State)
                            {
                            case UserState.Active:
                            case UserState.RegisterNeedConfirmation:
                            case UserState.RegisterWaitForModerate:
                            case UserState.RegisterDecline:
                            case UserState.Disabled:
                                data.State = model.User.State;
                                break;

                            default:
                                ModelState.AddModelError("User.State", "Неизвестное состояние пользователя.");
                                break;
                            }
                        }

                        if (ModelState.ContainsKeyCorrect("User.password"))
                        {
                            if (data.IdUser > 0 && Request.Form.HasKey("changepass") && Request.Form["changepass"] == "2")
                            {
                                data.password = UsersExtensions.hashPassword(model.User.password);
                            }
                            else if (data.IdUser == 0)
                            {
                                data.password = UsersExtensions.hashPassword(model.User.password);
                            }
                        }

                        if (ModelState.ContainsKeyCorrect("User.Comment"))
                        {
                            data.Comment = model.User.Comment;
                        }
                        if (ModelState.ContainsKeyCorrect("User.CommentAdmin"))
                        {
                            data.CommentAdmin = model.User.CommentAdmin;
                        }
                        if (Request.Form.HasKey("adminComment") && !string.IsNullOrEmpty(Request.Form["adminComment"]))
                        {
                            if (!Request.Form["adminComment"].isOneStringTextOnly()
                                // todo переработать этот участок в нормальную модель || DataManager.check(Request.Form["adminComment"])
                                )
                            {
                                errors.Add("Некорректный ввод комментария администратора!");
                            }
                            else
                            {
                                data.CommentAdmin = Request.Form["adminComment"];
                            }
                        }

                        result.Message = errors.Count > 0 ? " - " + string.Join("\r\n - ", errors) : "";

                        if (errors.Count == 0 && ModelState.IsValid)
                        {
                            data.Fields.CopyValuesFrom(model.User.Fields);
                            data.DateChangeBase = DateTime.Now;
                            data.IdUserChange   = AppCore.GetUserContextManager().GetCurrentUserContext().IdUser;

                            using (var trans = new TransactionScope())
                            {
                                if (data.IdUser == 0)
                                {
                                    db.Users.Add(data);
                                }

                                if (db.SaveChanges <User>() > 0)
                                {
                                    result.Message = "Сохранение данных прошло успешно!";
                                    result.Success = true;

                                    Module.RegisterEventForItem(data, EventType.Info, "Редактирование данных", $"Пользователь №{data.IdUser} '" + data.ToString() + "'");

                                    if (result.Success)
                                    {
                                        {
                                            var rolesMustHave = new List <int>(model.UserRoles ?? new List <int>());
                                            db.RoleUser.Where(x => x.IdUser == data.IdUser).Delete();
                                            rolesMustHave.ForEach(x => db.RoleUser.Add(new RoleUser()
                                            {
                                                IdRole       = x,
                                                IdUser       = data.IdUser,
                                                IdUserChange = AppCore.GetUserContextManager().GetCurrentUserContext().IdUser,
                                                DateChange   = DateTime.Now.Timestamp()
                                            }));

                                            if (rolesMustHave.Count > 0 && db.SaveChanges <RoleUser>() == 0)
                                            {
                                                throw new InvalidOperationException("Не удалось задать список ролей для пользователя.");
                                            }
                                        }


                                        /*
                                         * todo рассылка на мыло и по телефону
                                         * */
                                        if (oldState == UserState.RegisterWaitForModerate && data.State == UserState.Active)
                                        {
                                            this.assign("login", Request.Form["email"]);
                                            this.assign("message", "Ваша заявка была одобрена администратором, вы можете зайти на сайт, используя логин и пароль, указанные при регистрации!");

                                            AppCore.Get <EmailService>().SendMailFromSite(
                                                data.ToString(),
                                                data.email,
                                                "Успешная регистрация на сайте",
                                                this.ViewString("Register/register_mail2.cshtml"),
                                                ContentType.Html
                                                );

                                            Module.RegisterEventForItem(data, EventType.Info, "Заявка одобрена", "Пользователь №" + data.IdUser + " '" + data.ToString() + "'");
                                        }
                                        if (oldState == UserState.RegisterWaitForModerate && data.State == UserState.RegisterDecline)
                                        {
                                            var message = ".";

                                            //Если администратор указал комментарий к отклонению заявки
                                            if (!string.IsNullOrEmpty(data.CommentAdmin))
                                            {
                                                message = " по следующей причине: " + data.CommentAdmin;
                                                this.assign("comment", data.CommentAdmin);
                                            }

                                            this.assign("login", data.email);
                                            this.assign("message", "Ваша заявка была отклонена администратором" + message);

                                            AppCore.Get <EmailService>().SendMailFromSite(
                                                data.ToString(),
                                                data.email,
                                                "Регистрация на сайте отклонена",
                                                this.ViewString("Register/register_mail_decline.cshtml"),
                                                ContentType.Html
                                                );

                                            Module.RegisterEventForItem(data, EventType.Info, "Заявка отклонена", "Пользователь №" + data.IdUser + " '" + data.ToString() + "'. Заявка отклонена администратором" + message);
                                        }
                                        if (oldState != data.State && data.State == UserState.Disabled)
                                        {
                                            var message = ".";

                                            //Если администратор указал комментарий к отключению заявки
                                            if (Request.Form.HasKey("adminComment") && !string.IsNullOrEmpty(Request.Form["adminComment"]))
                                            {
                                                message = " по следующей причине: " + Request.Form["adminComment"];
                                                this.assign("comment", Request.Form["adminComment"]);
                                            }
                                            if (Request.Form.HasKey("CommentAdmin") && !string.IsNullOrEmpty(Request.Form["CommentAdmin"]))
                                            {
                                                message = " по следующей причине: " + Request.Form["CommentAdmin"];
                                                this.assign("comment", Request.Form["CommentAdmin"]);
                                            }

                                            this.assign("login", data.email);
                                            this.assign("message", "Ваш аккаунт заблокирован администратором" + message);
                                            AppCore.Get <EmailService>().SendMailFromSite(
                                                data.ToString(),
                                                data.email,
                                                "Аккаунт заблокирован",
                                                this.ViewString("Register/register_mail_ban.cshtml"),
                                                ContentType.Html
                                                );

                                            Module.RegisterEventForItem(data, EventType.Info, "Аккаунт заблокирован", "Пользователь №" + data.IdUser + " '" + data.ToString() + "'. Аккаунт заблокирован" + message);
                                        }
                                    }

                                    result.Data = data.IdUser;

                                    trans.Complete();
                                }
                                else
                                {
                                    result.Message = "Сохранение данных провалилось!";
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex) { result.FromException(ex); }

            return(this.ReturnJson(result));
        }