Exemplo n.º 1
0
        public GetRolesResponse GetRoles(GetRolesRequest request)
        {
            Logger.Current.Verbose("Request to fetch Roles of an Account");
            GetRolesResponse response = new GetRolesResponse();

            if (request != null)
            {
                IEnumerable <RoleViewModel> roleViewModel;
                Logger.Current.Informational("Requested roles for AccountId : " + request.AccountId);
                IEnumerable <Role> roles = roleRepository.GetRoles(request.AccountId);
                if (roles != null)
                {
                    roleViewModel = Mapper.Map <IEnumerable <Role>, IEnumerable <RoleViewModel> >(roles);
                    if (roleViewModel != null)
                    {
                        response.RoleViewModel  = roleViewModel;
                        response.SubscriptionId = accountRepository.GetSubscriptionIdByAccountId(request.AccountId);
                    }
                }
                else
                {
                    response.RoleViewModel = null;
                }
            }
            return(response);
        }
Exemplo n.º 2
0
        public GetRolesResponse Get(GetRolesRequest request)
        {
            request.Data.SetDefaultOrder("Name");

            var listResponse = repository
                               .AsQueryable <Models.Role>()
                               .Select(role => new RoleModel
            {
                Id             = role.Id,
                Version        = role.Version,
                CreatedBy      = role.CreatedByUser,
                CreatedOn      = role.CreatedOn,
                LastModifiedBy = role.ModifiedByUser,
                LastModifiedOn = role.ModifiedOn,

                Name         = role.Name,
                Description  = role.Description,
                IsSystematic = role.IsSystematic
            })
                               .ToDataListResponse(request);

            return(new GetRolesResponse {
                Data = listResponse
            });
        }
Exemplo n.º 3
0
        public override async Task GetRoles(GetRolesRequest request, IServerStreamWriter <RoleResponse> responseStream, ServerCallContext context)
        {
            List <RoleResponse> roles = _roleManager.GetRoles();

            foreach (var role in roles)
            {
                await responseStream.WriteAsync(role);
            }
        }
Exemplo n.º 4
0
        public async Task <Auth0.ManagementApi.Paging.IPagedList <Role> > GetRolesAsync(string search = "", int page = 0, int pageSize = 50)
        {
            var client = await GetClientAsync();

            var request = new GetRolesRequest()
            {
                NameFilter = search
            };

            return(await client.Roles.GetAllAsync(request, new PaginationInfo(page, pageSize, true)));
        }
Exemplo n.º 5
0
    /// <summary>
    /// Get User Roles Async.
    /// </summary>
    /// <param name="request">The <see cref="GetRolesRequest{TIdentity}"/>.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
    /// <returns>Void.</returns>
    public virtual async Task <IEnumerable <string> > GetRolesAsync(GetRolesRequest <TIdentity> request, CancellationToken cancellationToken = default)
    {
        if (request == null)
        {
            throw new ArgumentNullException(nameof(request));
        }

        request.Controller = BaseIdentityApi <TUser, TIdentity> .IdentityController;

        return(await this.InvokeAsync <GetRolesRequest <TIdentity>, IEnumerable <string> >(request, cancellationToken));
    }
Exemplo n.º 6
0
        public GetRolesResponse GetRolesByCriteria(GetRolesRequest request)
        {
            GetRolesResponse          response = new GetRolesResponse();
            SecurityBusinessComponent bc       = DependencyInjectionHelper.GetSecurityBusinessComponent();

            IQueryable <Role> roles = bc.GetRolesByCriteria(request.SearchType, request.Rolename);

            response.Roles = SecurityAdapter.RolesToDTOs(roles);

            return(response);
        }
Exemplo n.º 7
0
        /// <summary>
        /// Retrieves a list of all roles.
        /// </summary>
        /// <param name="request">Specifies criteria to use when querying roles.</param>
        /// <returns>An <see cref="IPagedList{Role}"/> containing the roles</returns>
        public Task <IPagedList <Role> > GetAllAsync(GetRolesRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            return(Connection.GetAsync <IPagedList <Role> >("roles", null,
                                                            new Dictionary <string, string>
            {
                { "name_filter", request.NameFilter },
            }, null, new PagedListConverter <Role>("roles")));
        }
Exemplo n.º 8
0
        /// <summary>
        /// Retrieves a list of all roles.
        /// </summary>
        /// <param name="request">Specifies criteria to use when querying roles.</param>
        /// <returns>An <see cref="IPagedList{Role}"/> containing the roles</returns>
        public Task <IPagedList <Role> > GetAllAsync(GetRolesRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            return(Connection.GetAsync <IPagedList <Role> >(BuildUri("roles",
                                                                     new Dictionary <string, string> {
                { "name_filter", request.NameFilter }
            }),
                                                            DefaultHeaders,
                                                            rolesConverters));
        }
Exemplo n.º 9
0
        public async Task <IPagedList <Role> > GetAuth0Roles()
        {
            var token = GetToken();
            var uri   = new Uri($"https://{_configuration.Value.Domain}/api/v2");

            using (var client = new ManagementApiClient(token, uri))
            {
                var request = new GetRolesRequest
                {
                    NameFilter = ""
                };

                return(await client.Roles.GetAllAsync(request));
            }
        }
Exemplo n.º 10
0
 public GetRolesResponse Post(GetRolesRequest request)
 {
     _log.StartLog(request);
     try
     {
         var roles = _credentialStore.GetRoles(this.GetSession().UserAuthName);
         return(new GetRolesResponse {
             Roles = roles.ToList()
         });
     }
     catch (Exception e)
     {
         _log.Fatal("error", e);
         Errors.Add(e.Message + " " + e.StackTrace);
         return(new GetRolesResponse {
             Errors = Errors
         });
     }
 }
Exemplo n.º 11
0
        public async Task <RoleResponse> GetAll([FromQuery] GetRolesRequest request)
        {
            var roles = _roleManager.Roles.Where(request.Id, x => x.Id == request.Id)
                        .Where(request.Name, x => x.Name.Contains(request.Name));

            roles = roles.OrderByDynamic(request.SortBy, request.IsDesc);
            var result = await PaginatedIQueryableExtensions <Role> .CreateAsync(roles.AsNoTracking(), request.Page, request.Rows, request.ShowAll);

            var roleMappers = await result.Item.ProjectTo <RoleModel>(MappingProfile.Config).ToArrayAsync();

            return(new RoleResponse
            {
                Valid = true,
                Count = result.Count,
                PagePageIndex = result.PageIndex,
                TotalPages = result.TotalPages,
                Table = roleMappers
            });
        }
Exemplo n.º 12
0
        public GetRolesResponse Any(GetRolesRequest request)
        {
            GetRolesResponse resp = new GetRolesResponse();

            using (var con = this.TenantDbFactory.ObjectsDB.GetNewConnection())
            {
                con.Open();
                string sql = "SELECT id,role_name FROM eb_roles";
                var    dt  = this.TenantDbFactory.ObjectsDB.DoQueries(sql);

                Dictionary <string, object> returndata = new Dictionary <string, object>();
                foreach (EbDataRow dr in dt.Tables[0].Rows)
                {
                    returndata[dr[0].ToString()] = dr[1].ToString();
                }
                resp.Data = returndata;
            }
            return(resp);
        }
Exemplo n.º 13
0
        public GetRolesResponse GetRolesList(GetRolesRequest request)
        {
            Logger.Current.Verbose("Request to fetch Roles of an Account");
            GetRolesResponse   response = new GetRolesResponse();
            IEnumerable <Role> roles    = roleRepository.FindAll(request.Query, request.Limit, request.PageNumber, request.AccountId);

            if (roles == null)
            {
                response.Exception = GetRoleNotFoundException();
            }
            else
            {
                IEnumerable <RoleViewModel> leadScoreList = Mapper.Map <IEnumerable <Role>, IEnumerable <RoleViewModel> >(roles);
                response.RoleViewModel  = leadScoreList;
                response.TotalHits      = roleRepository.FindAll(request.Query, request.AccountId).Count();
                response.SubscriptionId = accountRepository.GetSubscriptionIdByAccountId(request.AccountId);
            }

            return(response);
        }
        public override Task <GetRolesResponse> GetRoles(GetRolesRequest request, ServerCallContext context)
        {
            DbUserModel dbUserModel = context.UserState["user"] as DbUserModel;

            if (dbUserModel == null)
            {
                return(Task.FromResult(new GetRolesResponse()
                {
                    Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
                }));
            }

            var response = new GetRolesResponse()
            {
                Status = ResponseFactory.createResponse(ResponseType.SUCCESS)
            };

            response.Claims.AddRange(dbUserModel.UserModel.Claims);
            return(Task.FromResult(response));
        }
Exemplo n.º 15
0
        /// <summary>
        /// Retrieves a list of all roles.
        /// </summary>
        /// <param name="request">Specifies criteria to use when querying roles.</param>
        /// <param name="pagination">Specifies pagination info to use when requesting paged results.</param>
        /// <returns>An <see cref="IPagedList{Role}"/> containing the roles requested.</returns>
        public Task <IPagedList <Role> > GetAllAsync(GetRolesRequest request, PaginationInfo pagination)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }
            if (pagination == null)
            {
                throw new ArgumentNullException(nameof(pagination));
            }

            return(Connection.GetAsync <IPagedList <Role> >("roles", null,
                                                            new Dictionary <string, string>
            {
                { "name_filter", request.NameFilter },
                { "page", pagination.PageNo.ToString() },
                { "per_page", pagination.PerPage.ToString() },
                { "include_totals", pagination.IncludeTotals.ToString().ToLower() }
            }, null, new PagedListConverter <Role>("roles")));
        }
Exemplo n.º 16
0
 private IList <RoleDTO> getRoles(RoleSearchType searchType, string name, string role)
 {
     try
     {
         GetRolesRequest request = new GetRolesRequest();
         request.SearchType = searchType;
         request.Rolename   = name;
         request.Rolename   = role;
         GetRolesResponse response = Service.GetRolesByCriteria(request);
         return(response.Roles);
     }
     catch (Exception ex)
     {
         if (ExceptionPolicy.HandleException(ex, "PL Policy"))
         {
             throw;
         }
         return(new List <RoleDTO>());
     }
 }
Exemplo n.º 17
0
        public async Task RemoveUserFromRoles(UserRole objUserRole, Auth0ConfigModel objAuth0Config)
        {
            MethodCollection methodCollection = new MethodCollection();
            string           token            = await methodCollection.GetAccessToken(objAuth0Config);

            var managementApiClient = new ManagementApiClient(token, objAuth0Config.Domain);

            GetRolesRequest getRolesRequest = new GetRolesRequest {
                NameFilter = objUserRole.RoleNames[0]
            };
            IPagedList <Role> roles = await managementApiClient.Roles.GetAllAsync(getRolesRequest);

            List <string> rolesList = new List <string>
            {
                roles[0].Id
            };
            AssignRolesRequest objAssignRoleRequest = new AssignRolesRequest {
                Roles = rolesList.ToArray()
            };
            await managementApiClient.Users.RemoveRolesAsync(objUserRole.UserId, objAssignRoleRequest);
        }
Exemplo n.º 18
0
        public GetRolesResponse Get(GetRolesRequest request)
        {
            request.Data.SetDefaultOrder("Name");

            var listResponse = repository
                .AsQueryable<Models.Role>()
                .Select(role => new RoleModel
                    {
                        Id = role.Id,
                        Version = role.Version,
                        CreatedBy = role.CreatedByUser,
                        CreatedOn = role.CreatedOn,
                        LastModifiedBy = role.ModifiedByUser,
                        LastModifiedOn = role.ModifiedOn,

                        Name = role.Name,
                        IsSystematic = role.IsSystematic
                    })
                .ToDataListResponse(request);

            return new GetRolesResponse { Data = listResponse };
        }
Exemplo n.º 19
0
        public async Task <IReadOnlyDictionary <ulong, Domain.Role> > GetRolesAsync(string gameId, string token)
        {
            try
            {
                var request = new GetRolesRequest
                {
                    GameId = gameId
                };

                var response = await _client.GetRolesAsync(request, CreateHeader(token));

                return(response.Roles.ToDictionary(x => x.Key, x => (Domain.Role)x.Value));
            }
            catch (RpcException ex)
            {
                throw JinrouExceptionMapper.Transform(ex);
            }
            catch
            {
                throw;
            }
        }
Exemplo n.º 20
0
        public override async Task <RolePageModel> GetRoles(GetRolesRequest getRolesRequest, ServerCallContext context)
        {
            var getRoles = _mapper.Map <GetRolesRequest, GetRoles>(getRolesRequest);

            return(_mapper.Map <PageModel <RoleModel>, RolePageModel>(await _mediator.Send(getRoles)));
        }
Exemplo n.º 21
0
 public GetRolesResponse GetRoles(GetRolesRequest request)
 {
     return(WrapResponse <GetRolesResponse, GetRolesResponseBody>(new ServiceExecutionDelegator <GetRolesResponseBody, GetRolesRequestBody>().ResolveRequest(request.Request,
                                                                                                                                                             ApiTargetPlatform.Kinacu, ApiServiceName.GetRoles)));
 }
Exemplo n.º 22
0
 /// <remarks/>
 public void GetRolesAsync(GetRolesRequest GetRolesRequest, object userState)
 {
     if ((this.GetRolesOperationCompleted == null)) {
         this.GetRolesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetRolesOperationCompleted);
     }
     this.InvokeAsync("GetRoles", new object[] {
                 GetRolesRequest}, this.GetRolesOperationCompleted, userState);
 }
Exemplo n.º 23
0
 /// <remarks/>
 public void GetRolesAsync(GetRolesRequest GetRolesRequest)
 {
     this.GetRolesAsync(GetRolesRequest, null);
 }
Exemplo n.º 24
0
 public GetRolesResponse Get(GetRolesRequest request)
 {
     throw new CmsException(UsersApiConstants.UsersApiHasNoImplementationMessage);
 }
Exemplo n.º 25
0
 public GetRolesResponse Get(GetRolesRequest request)
 {
     throw new CmsException(UsersApiConstants.UsersApiHasNoImplementationMessage);
 }
 public static IAsyncEnumerable <Role> GetAllAsync(this RolesClient client, GetRolesRequest request, IReporter reporter = null)
 {
     return(GetAllAsyncInternal(page => client.GetAllAsync(request, page), "roles", reporter));
 }
Exemplo n.º 27
0
 public async Task <List <Role> > Handle(GetRolesRequest request, CancellationToken cancellationToken)
 {
     return(await _roleRepository.GetRoles());
 }
Exemplo n.º 28
0
        public GetRolesResponse Post(GetRolesRequest request)
        {
            _log.StartLog(request);
            try
            {

                var roles = _authProvider.GetRoles(this.GetSession().UserAuthName);
                return new GetRolesResponse {Roles = roles.ToList()};
            }
            catch (Exception e)
            {
                _log.Fatal("error", e);
                Errors.Add(e.Message + " " + e.StackTrace);
                return new GetRolesResponse {Errors = Errors};
            }
        }
Exemplo n.º 29
0
 /// <summary>
 /// Get Roles
 /// </summary>
 /// <param name="request">Request</param>
 /// <returns>Response</returns>
 public GetRolesResponse GetRoles(GetRolesRequest request)
 {
     return(Channel.GetRoles(request));
 }
Exemplo n.º 30
0
 /// <summary>
 /// Get Roles
 /// </summary>
 /// <returns>Response</returns>
 public GetRolesResponse GetRoles(GetRolesRequest request)
 {
     return(new GetRolesResponse {
         Roles = _operations.GetRoles(request.roleToSearch)
     });
 }
Exemplo n.º 31
0
 /// <remarks/>
 public System.IAsyncResult BeginGetRoles(GetRolesRequest GetRolesRequest, System.AsyncCallback callback, object asyncState)
 {
     return this.BeginInvoke("GetRoles", new object[] {
                 GetRolesRequest}, callback, asyncState);
 }