public async Task <Tuple <bool, string[]> > UpdateRoleAsync(RoleDTO role, IEnumerable <int> claims)
        {
            ObjectMapper    mapper  = new ObjectMapper();
            ApplicationRole appRole = mapper.ConvertRoleToIdentityRole(role);

            if (claims != null)
            {
                //string[] invalidClaims = claims.Where(c => ApplicationPermissions.GetPermissionByValue(c) == null).ToArray();
                //if (invalidClaims.Any())
                //    return Tuple.Create(false, new string[] { "The following claim types are invalid: " + string.Join(", ", invalidClaims) });
            }

            var result = await _appRoleManager.UpdateAsync(appRole);

            if (!result.Succeeded)
            {
                return(Tuple.Create(false, result.Errors.ToArray()));
            }


            if (claims != null)
            {
                //var roleClaims = (await _appRoleManager.GetClaimsAsync(role)).Where(c => c.Type == CustomClaimTypes.Permission);
                //var roleClaimValues = roleClaims.Select(c => c.Value).ToArray();

                //var claimsToRemove = roleClaimValues.Except(claims).ToArray();
                //var claimsToAdd = claims.Except(roleClaimValues).Distinct().ToArray();

                //if (claimsToRemove.Any())
                //{
                //    foreach (string claim in claimsToRemove)
                //    {
                //        result = await _roleManager.RemoveClaimAsync(role, roleClaims.Where(c => c.Value == claim).FirstOrDefault());
                //        if (!result.Succeeded)
                //            return Tuple.Create(false, result.Errors.Select(e => e.Description).ToArray());
                //    }
                //}

                //if (claimsToAdd.Any())
                //{
                //    foreach (string claim in claimsToAdd)
                //    {
                //        result = await _roleManager.AddClaimAsync(role, new Claim(CustomClaimTypes.Permission, ApplicationPermissions.GetPermissionByValue(claim)));
                //        if (!result.Succeeded)
                //            return Tuple.Create(false, result.Errors.Select(e => e.Description).ToArray());
                //    }
                //}
            }

            return(Tuple.Create(true, new string[] { }));
        }
        public async Task <Tuple <bool, string[]> > CreateRoleAsync(RoleDTO role, IEnumerable <int> claims)
        {
            ObjectMapper    mapper  = new ObjectMapper();
            ApplicationRole appRole = mapper.ConvertRoleToIdentityRole(role);

            using (var dbContextTransaction = _context.Database.BeginTransaction())
            {
                try
                {
                    var result = await _appRoleManager.CreateAsync(appRole);

                    if (!result.Succeeded)
                    {
                        return(Tuple.Create(false, result.Errors.ToArray()));
                    }


                    appRole = await _appRoleManager.FindByNameAsync(appRole.Name);


                    if (claims != null)
                    {
                        List <RolePermissionMap> rolePermissionList = new List <RolePermissionMap>();

                        foreach (int claim in claims)
                        {
                            RolePermissionMap tmpDTO = new RolePermissionMap();
                            tmpDTO.PermissionId = claim;
                            tmpDTO.RoleId       = appRole.Id;

                            rolePermissionList.Add(tmpDTO);
                        }

                        _context.RolePermissionMaps.AddRange(rolePermissionList);
                        await _context.SaveChangesAsync();

                        dbContextTransaction.Commit();
                    }
                }
                catch (Exception ex)
                {
                    dbContextTransaction.Rollback();
                    throw ex;
                }
            }

            return(Tuple.Create(true, new string[] { appRole.Id }));
        }