コード例 #1
0
        public async Task <MasterDataKeyValue> Save(JObject data, bool isAuthroize = false)
        {
            dynamic masterDataDto = data;
            int?    masterDataId  = masterDataDto.Id;
            var     masterData    = new MasterDataKeyValue
            {
                Id = masterDataId ?? 0
            };
            bool isNew = masterDataDto.IsNew;

            //bool isPath;

            //try
            //{
            //    isPath = masterDataDto.IsPath;
            //}
            //catch (Exception)
            //{

            //    isPath = false;
            //}

            //bool isPathSecond;

            //try
            //{
            //    isPathSecond = masterDataDto.IsPathSecond;
            //}
            //catch (Exception)
            //{

            //    isPathSecond = false;
            //}

            int pathOrUrlProtocolId, secondPathOrUrlProtocolId;

            try
            {
                pathOrUrlProtocolId = masterDataDto.PathOrUrlProtocolId;
            }
            catch (Exception)
            {
                pathOrUrlProtocolId = (int)Protocol.LocalUrlPorotocol;
            }

            try
            {
                secondPathOrUrlProtocolId = masterDataDto.SecondPathOrUrlProtocolId;
            }
            catch (Exception)
            {
                secondPathOrUrlProtocolId = (int)Protocol.LocalUrlPorotocol;
            }

            var currentMasterData = await ContentManagementContext.MasterDataKeyValues.AsNoTracking().SingleOrDefaultAsync(md => md.Id == masterData.Id);

            if (!isNew)
            {
                if (currentMasterData == null)
                {
                    throw new KhodkarInvalidException(LanguageManager.ToAsErrorMessage(ExceptionKey.MasterDataKeyValuesNotFound));
                }

                if (currentMasterData.EditMode)
                {
                    SourceControl.CheckCodeCheckOute(masterData);
                }

                masterData            = currentMasterData;
                masterData.RowVersion = masterDataDto.RowVersion;

                ContentManagementContext.MasterDataKeyValues.Attach(masterData);
            }
            else
            {
                ContentManagementContext.MasterDataKeyValues.Add(masterData);
            }
            masterData.TypeId = masterDataDto.TypeId;

            //if (!isPath)
            //{
            //    if (masterDataUrl.IndexOf(Helper.RootUrl, StringComparison.Ordinal) != 0)
            //    {
            //        masterDataUrl = Helper.RootUrl + masterDataUrl;
            //    }

            //}
            //else
            //{

            //    if ( masterDataUrl.IndexOf("~", StringComparison.Ordinal) != 0)
            //    {
            //        if (masterDataUrl.IndexOf(Helper.RootUrl, StringComparison.Ordinal) != 0)
            //            masterDataUrl = "~" + Helper.RootUrl + masterDataUrl;
            //        else
            //            masterDataUrl = "~" + masterDataUrl;
            //    }
            //}
            string masterDataUrlOrPath = ProperPathOrUrl(Convert.ToString(masterDataDto.PathOrUrl), pathOrUrlProtocolId);

            if (masterDataUrlOrPath != Helper.RootUrl && masterData.TypeId != (int)EntityIdentity.BundleSource)
            {
                var repeatedMasterData =
                    await
                    ContentManagementContext.MasterDataKeyValues.Where(
                        md => md.PathOrUrl == masterDataUrlOrPath && md.TypeId == masterData.TypeId).CountAsync()
                ;

                if ((repeatedMasterData > 0 && isNew) || (repeatedMasterData > 1 && !isNew))
                {
                    throw new KhodkarInvalidException(LanguageManager.ToAsErrorMessage(ExceptionKey.RepeatedValue, masterDataUrlOrPath));
                }
            }
            masterData.PathOrUrl = masterDataUrlOrPath;
            try
            {
                int parentId = masterDataDto.ParentId;
                if (currentMasterData?.ParentId != parentId || isNew)
                {
                    var parentCode = await ContentManagementContext.MasterDataKeyValues.SingleOrDefaultAsync(md => md.Id == parentId);

                    if (parentCode == null)
                    {
                        throw new KhodkarInvalidException(LanguageManager.ToAsErrorMessage(ExceptionKey.ParentRecordNotFound));
                    }
                    AuthorizeManager.CheckParentNodeModifyAccessForAddingChildNode(parentCode, parentCode.Id);
                }
                masterData.ParentId = parentId;
            }
            catch (KhodkarInvalidException)
            {
                throw;
            }
            catch (Exception)
            {
                masterData.ParentId = null;
            }

            try
            {
                masterData.Key = masterDataDto.Key;
            }
            catch (Exception)
            {
                masterData.Key = null;
            }

            try
            {
                masterData.Value = masterDataDto.Value;
            }
            catch (Exception)
            {
                masterData.Value = null;
            }

            try
            {
                masterData.ForeignKey1 = masterDataDto.ForeignKey1;
            }
            catch (Exception)
            {
                masterData.ForeignKey1 = null;
            }

            try
            {
                masterData.ForeignKey2 = masterDataDto.ForeignKey2;
            }
            catch (Exception)
            {
                masterData.ForeignKey2 = null;
            }

            try
            {
                masterData.ForeignKey3 = masterDataDto.ForeignKey3;
            }
            catch (Exception)
            {
                masterData.ForeignKey3 = null;
            }

            masterData.SecondCode = masterDataDto.SecondCode;


            string secondMasterDataPathOrUrl = masterDataDto.SecondPathOrUrl;

            masterData.SecondPathOrUrl = ProperPathOrUrl(secondMasterDataPathOrUrl, secondPathOrUrlProtocolId);

            masterData.Name = masterDataDto.Name;
            masterData.Code = masterDataDto.Code;
            if (masterData.Code != null)
            {
                var repeatedMasterData =
                    await
                    ContentManagementContext.MasterDataKeyValues.Where(
                        md => md.Code == masterData.Code && md.TypeId == masterData.TypeId).CountAsync();

                if ((repeatedMasterData > 0 && isNew) || (repeatedMasterData > 1 && !isNew))
                {
                    throw new KhodkarInvalidException(LanguageManager.ToAsErrorMessage(ExceptionKey.RepeatedValue, masterData.Code));
                }
            }



            masterData.Guid        = masterDataDto.Guid;
            masterData.Description = masterDataDto.Description;
            masterData.Data        = masterDataDto.Data;
            masterData.Version     = (currentMasterData?.Version ?? 0) + 1;

            try
            {
                masterData.Order = masterDataDto.Order;
            }
            catch (Exception)
            {
                masterData.Order = 1;
            }
            masterData.IsLeaf = masterDataDto.IsLeaf;
            masterData.IsType = masterDataDto.IsType;

            if (masterData.IsType && masterData.IsLeaf)
            {
                throw new ConstraintException(LanguageManager.ToAsErrorMessage(ExceptionKey.MasterDataTypeIsLeaf));
            }

            try
            {
                masterData.TypeId = masterDataDto.TypeId;
            }
            catch (Exception)
            {
                throw new ValidationException(LanguageManager.ToAsErrorMessage(ExceptionKey.FieldMustBeNumeric, "TypeId"));
            }

            try
            {
                masterData.ParentTypeId = masterDataDto.ParentTypeId;
            }
            catch (Exception)
            {
                if (masterData.IsType)
                {
                    throw new ValidationException(LanguageManager.ToAsErrorMessage(ExceptionKey.FieldMustBeNumeric, "ParentTypeId"));
                }

                masterData.ParentTypeId = null;
            }

            masterData.Language = Config.DefaultsLanguage;
            //if(masterData.IsLeaf)
            if (masterData.TypeId == (int)EntityIdentity.Permission && !isAuthroize)
            {
                throw new UnauthorizedAccessException(LanguageManager.ToAsErrorMessage(ExceptionKey.InvalidGrant));
            }

            if (currentMasterData != null)
            {
                masterData.ViewRoleId   = currentMasterData.ViewRoleId;
                masterData.ModifyRoleId = currentMasterData.ModifyRoleId;
                masterData.AccessRoleId = currentMasterData.AccessRoleId;
            }


            AuthorizeManager.SetAndCheckModifyAndAccessRole(masterData, masterDataDto);


            masterData.Status      = masterDataDto.Status;
            masterData.EditMode    = masterDataDto.EditMode;
            masterData.EnableCache = masterDataDto.EnableCache;
            try
            {
                masterData.SlidingExpirationTimeInMinutes = masterDataDto.SlidingExpirationTimeInMinutes;
            }
            catch (Exception)
            {
                masterData.SlidingExpirationTimeInMinutes = 0;
            }
            await ContentManagementContext.SaveChangesAsync();

            if (masterData.TypeId == (int)EntityIdentity.SqlServerConnections)
            {
                WebConfigManager.AddOrUpdateConnection(masterData.Code, masterData.SecondCode,
                                                       ConnectionProvider.SqlServer);
            }
            else
            {
                UpdateMasterDatakeyVlaueSettingOfWebConfig(masterData);
            }
            return(masterData);
        }
コード例 #2
0
        public async Task <MasterDataKeyValue> Save(JObject data)
        {
            dynamic serviceDto = data;
            int?    serviceId  = serviceDto.Id;
            var     service    = new MasterDataKeyValue
            {
                Id     = serviceId ?? 0,
                TypeId = (int)EntityIdentity.Service
            };
            bool isNew = serviceDto.IsNew;


            bool   checkIn = serviceDto.CheckIn;
            string comment = serviceDto.Comment;

            var currentService = await _contentManagementContext
                                 .MasterDataKeyValues.AsNoTracking().SingleOrDefaultAsync(sv => sv.Id == service.Id && sv.TypeId == (int)EntityIdentity.Service);

            if (!isNew)
            {
                if (currentService == null)
                {
                    throw new KhodkarInvalidException(LanguageManager.ToAsErrorMessage(ExceptionKey.ServiceNotFound));
                }

                if (currentService.EditMode)
                {
                    _sourceControl.CheckCodeCheckOute(currentService);
                }

                service            = currentService;
                service.RowVersion = serviceDto.RowVersion;

                _contentManagementContext.MasterDataKeyValues.Attach(service);
            }
            else
            {
                _contentManagementContext.MasterDataKeyValues.Add(service);
            }



            string serviceCode = serviceDto.Code;

            if (serviceCode.IndexOf(_codeTemplate.ServicePrefix, StringComparison.Ordinal) != 0)
            {
                serviceCode = _codeTemplate.ServicePrefix + "." + serviceCode;
            }

            string serviceUrl = serviceDto.Url;

            if (serviceUrl.IndexOf(Helper.RootUrl, StringComparison.Ordinal) != 0)
            {
                serviceUrl = Helper.RootUrl + serviceUrl;
            }
            if (serviceUrl.LastIndexOf(Helper.RootUrl, StringComparison.Ordinal) == serviceUrl.Length - 1 && serviceUrl != "/")
            {
                serviceUrl = serviceUrl.Remove(serviceUrl.LastIndexOf(Helper.RootUrl, StringComparison.Ordinal));
            }
            var repeatedService = await _contentManagementContext
                                  .MasterDataKeyValues.Where(sr => sr.PathOrUrl == serviceUrl && sr.TypeId == (int)EntityIdentity.Service).CountAsync()
            ;

            if ((repeatedService > 0 && isNew) || (repeatedService > 1 && !isNew))
            {
                throw new KhodkarInvalidException(LanguageManager.ToAsErrorMessage(ExceptionKey.RepeatedValue, serviceUrl));
            }


            int?parentId = serviceDto.ParentId;

            if (currentService?.ParentId != parentId || isNew)
            {
                var parentCode = await _contentManagementContext
                                 .MasterDataKeyValues.SingleOrDefaultAsync(sr => sr.Id == parentId && sr.TypeId == (int)EntityIdentity.Service);

                if (parentCode == null)
                {
                    throw new KhodkarInvalidException(LanguageManager.ToAsErrorMessage(ExceptionKey.ParentRecordNotFound));
                }
                AuthorizeManager.CheckParentNodeModifyAccessForAddingChildNode(parentCode, parentCode.Id);
            }

            service.ParentId = parentId;

            service.Name = serviceDto.Name;
            service.Code = serviceCode;

            repeatedService = await _contentManagementContext
                              .MasterDataKeyValues.Where(sr => sr.Code == service.Code && sr.TypeId == (int)EntityIdentity.Service)
                              .CountAsync();

            if ((repeatedService > 0 && isNew) || (repeatedService > 1 && !isNew))
            {
                throw new KhodkarInvalidException(LanguageManager.ToAsErrorMessage(ExceptionKey.RepeatedValue, service.Code));
            }


            service.Guid        = serviceDto.Guid;
            service.Description = serviceDto.Description;
            service.Version     = (currentService?.Version ?? 0) + 1;
            service.PathOrUrl   = serviceUrl;
            try
            {
                service.Order = serviceDto.Order;
            }
            catch (Exception)
            {
                service.Order = 1;
            }

            //LOG SERVICE EVENT?1:TRUE,2:FALSE
            try
            {
                service.Key = serviceDto.Key;
            }
            catch (Exception)
            {
                service.Key = 0;
            }

            service.IsLeaf   = serviceDto.IsLeaf;
            service.Language = Config.DefaultsLanguage;

            //if(service.IsLeaf)
            if (currentService != null)
            {
                service.ViewRoleId   = currentService.ViewRoleId;
                service.ModifyRoleId = currentService.ModifyRoleId;
                service.AccessRoleId = currentService.AccessRoleId;
            }
            AuthorizeManager.SetAndCheckModifyAndAccessRole(service, serviceDto);

            service.Status      = serviceDto.Status;
            service.EditMode    = serviceDto.EditMode;
            service.EnableCache = serviceDto.EnableCache;
            try
            {
                service.SlidingExpirationTimeInMinutes = serviceDto.SlidingExpirationTimeInMinutes;
            }
            catch (Exception)
            {
                service.SlidingExpirationTimeInMinutes = 0;
            }
            await _contentManagementContext.SaveChangesAsync();

            string jsCode = serviceDto.JsCode;

            if (!string.IsNullOrEmpty(jsCode))
            {
                await _sourceControl.AddChange(Config.ServicesSourceCodePath, service.Guid + ".js", jsCode, service.Version,
                                               comment);

                if (checkIn)
                {
                    await WriteFileAsync(Config.ServicesSourceCodePath, service.Guid, ".js", jsCode);
                }
            }


            CacheManager.ClearAllItemContainKey(service.PathOrUrl);
            UpdateServiceSettingOfWebConfig(service);
            return(service);
        }
コード例 #3
0
        public async Task <ApplicationRole> SaveRole(JObject role)
        {
            dynamic         roleDto = role;
            ApplicationRole applicationRole;
            bool            isNew = roleDto.IsNew;

            if (!isNew)
            {
                applicationRole = new ApplicationRole()
                {
                    Id = roleDto.Id
                };
                applicationRole = await _roleManager.FindByIdAsync(applicationRole.Id);

                if (applicationRole == null)
                {
                    throw new KhodkarInvalidException(LanguageManager.ToAsErrorMessage(ExceptionKey.RoleNotFound));
                }
            }
            else
            {
                applicationRole = new ApplicationRole();
            }

            applicationRole.Name        = roleDto.Name;
            applicationRole.IsLeaf      = roleDto.IsLeaf;
            applicationRole.Description = roleDto.Description;
            try
            {
                applicationRole.Order = roleDto.Order;
            }
            catch (Exception)
            {
                applicationRole.Order = 0;
            }

            applicationRole.Status = roleDto.Status;

            try
            {
                int parentId = roleDto.ParentId;
                if (applicationRole.ParentId != parentId)
                {
                    var parentCode = await _roleManager.FindByIdAsync(parentId);

                    if (parentCode == null)
                    {
                        throw new KhodkarInvalidException(
                                  LanguageManager.ToAsErrorMessage(ExceptionKey.ParentRecordNotFound));
                    }
                    AuthorizeManager.CheckParentNodeModifyAccessForAddingChildNode(parentCode, parentCode.Id);
                }
                applicationRole.ParentId = parentId;
            }
            catch (KhodkarInvalidException)
            {
                throw;
            }
            catch (Exception)
            {
                applicationRole.ParentId = null;
            }

            AuthorizeManager.SetAndCheckModifyAndAccessRole(applicationRole, roleDto);

            var roleresult = isNew
                ? await _roleManager.CreateAsync(applicationRole)
                : await _roleManager.UpdateAsync(applicationRole);

            if (!roleresult.Succeeded)
            {
                throw new KhodkarInvalidException(roleresult.Errors.First());
            }
            return(applicationRole);
        }
コード例 #4
0
        //public async Task<IList<LinkObjective>> GetAllLinkAsync(IEnumerable<string> accessRoles = null, IEnumerable<string> denyRoles = null)
        //{
        //    //var ts = _securityContext.ApplicationTrees
        //    // .Include(x => x.Offspring.Select(y => y.Offspring))
        //    // .SingleOrDefault(x => x.Id == 72);
        //    //ts = ts;
        //    var lang = Setting.Language;
        //    var baseTree = await _contentManagementContext.Links.Where(ln => ln.Language == lang).AsNoTracking().ToListAsync();
        //    var newTree = new List<LinkObjective>();
        //    foreach (var node in baseTree)
        //    {
        //        if (node.IsLeaf)
        //        {
        //            if (accessRoles == null && denyRoles == null)
        //                BuildTree<LinkObjective, LinkObjective>(node, newTree, baseTree);
        //            else if (accessRoles != null && denyRoles != null)
        //            {
        //                if (accessRoles.Any(r => r == node.ViewRoleId.ToString()) && !denyRoles.Any(r => r == node.ViewRoleId.ToString()))
        //                {
        //                    BuildTree<LinkObjective, LinkObjective>(node, newTree, baseTree);
        //                }
        //            }
        //            else if (denyRoles == null)
        //            {
        //                if (accessRoles.Any(r => r == node.ViewRoleId.ToString()))
        //                {
        //                    BuildTree<LinkObjective, LinkObjective>(node, newTree, baseTree);
        //                }
        //            }
        //            else if (accessRoles == null)
        //            {
        //                if (!denyRoles.Any(r => r == node.ViewRoleId.ToString()))
        //                {
        //                    BuildTree<LinkObjective, LinkObjective>(node, newTree, baseTree);
        //                }
        //            }

        //        }


        //        if (node.ParentId == null)
        //        {
        //            if (node.IsLeaf)
        //            {

        //                if (accessRoles == null && denyRoles == null)
        //                {
        //                    if (!newTree.Exists(t => t.Id == node.Id))
        //                        newTree.Add(node);
        //                }
        //                else if (accessRoles != null && denyRoles != null)
        //                {
        //                    if (accessRoles.Any(r => r == node.ViewRoleId.ToString()) && !denyRoles.Any(r => r == node.ViewRoleId.ToString()))
        //                    {
        //                        if (!newTree.Exists(t => t.Id == node.Id))
        //                            newTree.Add(node);
        //                    }
        //                }
        //                else if (denyRoles == null)
        //                {
        //                    if (accessRoles.Any(r => r == node.ViewRoleId.ToString()))
        //                    {
        //                        if (!newTree.Exists(t => t.Id == node.Id))
        //                            newTree.Add(node);
        //                    }
        //                }
        //                else if (accessRoles == null)
        //                {
        //                    if (!denyRoles.Any(r => r == node.ViewRoleId.ToString()))
        //                    {
        //                        if (!newTree.Exists(t => t.Id == node.Id))
        //                            newTree.Add(node);
        //                    }
        //                }
        //            }
        //            else
        //            {
        //                if (!newTree.Exists(t => t.Id == node.Id))
        //                    newTree.Add(node);
        //            }
        //        }
        //    }
        //    return RemoveEmptyParentNode<LinkObjective, LinkObjective>(newTree);
        //}

        #region [SaveLink..]
        public async Task <Link> Save(JObject data)
        {
            dynamic linkDto = data;

            string oldUrl = "";

            int?linkId = linkDto.Id;


            var link = new Link()
            {
                Id = linkId == null ? 0 : linkDto.Id
            };
            var currentLink = await _contentManagementContext.Links.AsNoTracking().SingleOrDefaultAsync(ln => ln.Id == link.Id);

            try
            {
                if (currentLink == null)
                {
                    throw new KhodkarInvalidException(LanguageManager.ToAsErrorMessage(ExceptionKey.LinkNotFound));
                }
                oldUrl          = currentLink.Url;
                link            = currentLink;
                link.RowVersion = linkDto.RowVersion;
                _contentManagementContext.Links.Attach(link);
            }
            catch (Exception)
            {
                link = new Link();
                _contentManagementContext.Links.Add(link);
            }


            string linkUrl = linkDto.Url;

            if (linkUrl.IndexOf(Helper.RootUrl, StringComparison.Ordinal) != 0)
            {
                linkUrl = Helper.RootUrl + linkUrl;
            }
            if (linkUrl.LastIndexOf(Helper.RootUrl, StringComparison.Ordinal) == linkUrl.Length - 1)
            {
                linkUrl = linkUrl.Substring(0, linkUrl.Length - 1);
            }
            try
            {
                int parentId = linkDto.ParentId;
                if (currentLink?.ParentId != parentId)
                {
                    var parentCode = await _contentManagementContext.Links.SingleOrDefaultAsync(md => md.Id == parentId);

                    if (parentCode == null)
                    {
                        throw new KhodkarInvalidException(
                                  LanguageManager.ToAsErrorMessage(ExceptionKey.ParentRecordNotFound));
                    }
                    AuthorizeManager.CheckParentNodeModifyAccessForAddingChildNode(parentCode, parentCode.Id);
                }
                link.ParentId = parentId;
            }
            catch (KhodkarInvalidException)
            {
                throw;
            }
            catch (Exception)
            {
                link.ParentId = null;
            }
            link.Text               = linkDto.Text;
            link.TransactionCode    = linkDto.TransactionCode;
            link.Html               = linkDto.Html;
            link.Action             = linkDto.Action;
            link.Url                = linkUrl;
            link.ShowToSearchEngine = linkDto.ShowToSearchEngine;

            var repeatedLink = await _contentManagementContext.Links.Where(sr => sr.Url == link.Url).CountAsync();

            if ((repeatedLink > 0 && oldUrl == "") || (repeatedLink > 1 && oldUrl == ""))
            {
                throw new KhodkarInvalidException(LanguageManager.ToAsErrorMessage(ExceptionKey.RepeatedValue, link.Url));
            }


            try
            {
                link.Order = linkDto.Order;
            }
            catch (Exception)
            {
                link.Order = 1;
            }
            link.IsLeaf   = linkDto.IsLeaf;
            link.Language = linkDto.Language;

            //if(service.IsLeaf)

            if (currentLink != null)
            {
                link.ViewRoleId   = currentLink.ViewRoleId;
                link.ModifyRoleId = currentLink.ModifyRoleId;
                link.AccessRoleId = currentLink.AccessRoleId;
            }

            AuthorizeManager.SetAndCheckModifyAndAccessRole(link, linkDto);

            link.Status   = linkDto.Status;
            link.IsMobile = linkDto.IsMobile;
            link.TypeId   = linkDto.TypeId;

            await _contentManagementContext.SaveChangesAsync();

            if (oldUrl != "")
            {
                _contentManagementContext.WebPages.Where(wp => wp.Url == oldUrl).Update(wp => new WebPage()
                {
                    Url = linkUrl
                });
            }
            return(link);
        }
コード例 #5
0
        public async Task <ApplicationGroup> SaveGroup(JObject group)
        {
            dynamic          groupDto = group;
            ApplicationGroup applicationGroup;
            bool             isNew             = groupDto.IsNew;
            JArray           sremovedListArray = groupDto.RemovedList;
            var    removedList    = sremovedListArray.ToObject <List <int> >();
            JArray addedListArray = groupDto.AddedList;
            var    addedList      = addedListArray.ToObject <List <int> >();

            if (!isNew)
            {
                applicationGroup = new ApplicationGroup()
                {
                    Id = groupDto.Id
                };
                applicationGroup = await _securityContext.Groups.FindAsync(applicationGroup.Id);

                if (applicationGroup == null)
                {
                    throw new KhodkarInvalidException(LanguageManager.ToAsErrorMessage(ExceptionKey.GroupNotFound));
                }
            }
            else
            {
                applicationGroup = new ApplicationGroup();
                _securityContext.Groups.Add(applicationGroup);
            }



            applicationGroup.Name        = groupDto.Name;
            applicationGroup.IsLeaf      = groupDto.IsLeaf;
            applicationGroup.Description = groupDto.Description;
            try
            {
                applicationGroup.Order = groupDto.Order;
            }
            catch (Exception)
            {
                applicationGroup.Order = 0;
            }

            applicationGroup.Status = groupDto.Status;

            try
            {
                int parentId = groupDto.ParentId;
                if (applicationGroup.ParentId != parentId)
                {
                    var parentCode = await _securityContext.Groups.FindAsync(parentId);

                    if (parentCode == null)
                    {
                        throw new KhodkarInvalidException(
                                  LanguageManager.ToAsErrorMessage(ExceptionKey.ParentRecordNotFound));
                    }
                    AuthorizeManager.CheckParentNodeModifyAccessForAddingChildNode(parentCode, parentCode.Id);
                }
                applicationGroup.ParentId = parentId;
            }
            catch (KhodkarInvalidException)
            {
                throw;
            }
            catch (Exception)
            {
                applicationGroup.ParentId = null;
            }

            AuthorizeManager.SetAndCheckModifyAndAccessRole(applicationGroup, groupDto);

            foreach (var item in addedList)
            {
                var role = new ApplicationGroupRole()
                {
                    GroupId = applicationGroup.Id,
                    RoleId  = item
                };
                _securityContext.ApplicationGroupRoles.Add(role);
            }

            if (removedList.Count > 0)
            {
                _securityContext.ApplicationGroupRoles.Where(
                    eg => removedList.Contains(eg.RoleId) && eg.GroupId == applicationGroup.Id).Delete();
            }

            await _securityContext.SaveChangesAsync();


            CacheManager.Remove(CacheManager.GetGroupKey(CacheKey.Aspect.ToString(), applicationGroup.Id));

            return(applicationGroup);
        }