Пример #1
0
        public static RequestResult Create(CreateFormModel model)
        {
            RequestResult requestResult = new RequestResult();

            try
            {
                using (CFContext context = new CFContext())
                {
                    var exists = context.People.FirstOrDefault(p => p.LoginId == model.FormInput.Id);

                    if (exists == null)
                    {
                        bool exceedsLimit = false;

                        var upStreamOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(new Guid(model.OrganizationId), true);

                        PopulationLimit populationLimit = null;

                        foreach (var item in Config.PopulationLimits)
                        {
                            if (upStreamOrganizationIds.Contains(item.OrganizationId))
                            {
                                populationLimit = item;
                                break;
                            }
                        }
                        if (populationLimit != null)
                        {
                            var organization            = OrganizationDataAccessor.GetOrganization(populationLimit.OrganizationId);
                            var downStreamOrganizations = OrganizationDataAccessor.GetDownStreamOrganizations(populationLimit.OrganizationId, true);
                            var people = context.People.Where(p => downStreamOrganizations.Contains(p.OrganizationId)).ToList();
                            if (people.Count + 1 > populationLimit.NumberOfPeople)
                            {
                                exceedsLimit = true;
                                requestResult.ReturnFailedMessage(string.Format(Resources.Resource.ExceedsPopulationLimit, organization.Name, populationLimit.NumberOfPeople));
                            }
                            else
                            {
                                if (model.FormInput.IsMobilePerson && people.Count(x => x.IsMobilePerson) + 1 > populationLimit.NumberOfMobilePeople)
                                {
                                    exceedsLimit = true;
                                    requestResult.ReturnFailedMessage(string.Format(Resources.Resource.ExceedsMobilePopulationLimit, organization.Name, populationLimit.NumberOfMobilePeople));
                                }
                            }
                        }
                        if (!exceedsLimit)
                        {
                            var roles = context.Roles.Where(r => model.FormInput.RoleIdsString.Contains(r.RoleId)).ToList();
                            context.People.Add(new CF.Models.Person()
                            {
                                OrganizationId = new Guid(model.OrganizationId),
                                LoginId        = model.FormInput.Id,
                                Name           = model.FormInput.Name,
                                Password       = model.FormInput.Id,
                                Title          = model.FormInput.Title,
                                Email          = model.FormInput.EMail,
                                IsMobilePerson = model.FormInput.IsMobilePerson,
                                LastModifyTime = DateTime.Now,
                                Roles          = roles
                            });

                            context.SaveChanges();
                            requestResult.ReturnData(model.FormInput.Id, string.Format("{0} {1} {2}", Resources.Resource.Create, Resources.Resource.Person, Resources.Resource.Success));
                        }
                    }
                    else
                    {
                        requestResult.ReturnFailedMessage(string.Format("{0} {1}", Resources.Resource.PId, Resources.Resource.Exists));
                    }
                }
            }
            catch (Exception e)
            {
                var error = new Error(MethodBase.GetCurrentMethod(), e);
                Logger.Log(error);
                requestResult.ReturnError(error);
                //throw;
            }

            return(requestResult);
        }
Пример #2
0
        public static RequestResult Edit(EditFormModel editFormModel)
        {
            RequestResult requestResult = new RequestResult();

            try
            {
                using (CFContext context = new CFContext())
                {
                    var person = context.People.Include("Roles").First(x => x.LoginId == editFormModel.PId);

                    bool exceedsLimit = false;

                    if (editFormModel.FormInput.IsMobilePerson)
                    {
                        var upStreamOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(person.OrganizationId, true);

                        PopulationLimit populationLimit = null;

                        foreach (var item in Config.PopulationLimits)
                        {
                            if (upStreamOrganizationIds.Contains(item.OrganizationId))
                            {
                                populationLimit = item;

                                break;
                            }
                        }

                        if (populationLimit != null)
                        {
                            var organization = OrganizationDataAccessor.GetOrganization(populationLimit.OrganizationId);

                            var downStreamOrganizations = OrganizationDataAccessor.GetDownStreamOrganizations(populationLimit.OrganizationId, true);

                            var mobilePeople = context.People.Where(x => x.LoginId != person.LoginId && x.IsMobilePerson && downStreamOrganizations.Contains(x.OrganizationId)).ToList();

                            if (mobilePeople.Count + 1 > populationLimit.NumberOfMobilePeople)
                            {
                                exceedsLimit = true;

                                requestResult.ReturnFailedMessage(string.Format(Resources.Resource.ExceedsMobilePopulationLimit, organization.Name, populationLimit.NumberOfMobilePeople));
                            }
                        }
                    }

                    if (!exceedsLimit)
                    {
#if !DEBUG
                        using (TransactionScope trans = new TransactionScope())
                        {
#endif
                        #region Person
                        person.Name  = editFormModel.FormInput.Name;
                        person.Title = editFormModel.FormInput.Title;
                        person.Email = editFormModel.FormInput.EMail;
                        //person.UID = editFormModel.FormInput.UID;
                        person.IsMobilePerson = editFormModel.FormInput.IsMobilePerson;
                        person.LastModifyTime = DateTime.Now;

                        context.SaveChanges();
                        #endregion

                        #region PersonRoles
                        #region Delete
                        if (person != null)
                        {
                            person.Roles = new List <CF.Models.Role>();
                            context.SaveChanges();
                        }

                        #endregion

                        #region Insert
                        foreach (var roleId in editFormModel.FormInput.RoleIds)
                        {
                            var role = context.Roles.First(r => r.RoleId == roleId);
                            person.Roles.Add(role);
                        }
                        context.SaveChanges();
                        #endregion
                        #endregion
#if !DEBUG
                        trans.Complete();
                    }
#endif
                        requestResult.ReturnSuccessMessage(string.Format("{0} {1} {2}", Resources.Resource.Edit, Resources.Resource.Person, Resources.Resource.Success));
                    }
                }
            }
            catch (Exception e)
            {
                var error = new Error(MethodBase.GetCurrentMethod(), e);
                Logger.Log(error);
                requestResult.ReturnError(error);
                //throw;
            }

            return(requestResult);
        }