public OperationStatus JoinCommunity(PermissionItem permissionItem) { // Make sure input is not null this.CheckNotNull(() => new { permissionItem }); var operationStatus = new OperationStatus(); try { var permissionRequest = new PermissionRequest(); Mapper.Map(permissionItem, permissionRequest); permissionRequest.RequestedDate = DateTime.UtcNow; _permissionRequestRepository.Add(permissionRequest); _permissionRequestRepository.SaveChanges(); operationStatus.Succeeded = true; } catch (Exception) { // TODO: Add exception handling logic here. operationStatus.Succeeded = false; operationStatus.CustomErrorMessage = true; operationStatus.ErrorMessage = Resources.UnknownErrorMessage; } return(operationStatus); }
public override void OnPermissionRequest(PermissionRequest p_per_) { s_act_.RunOnUiThread(() => { p_per_.Grant(p_per_.GetResources()); }); }
/// <summary> /// Sets the permissions. /// </summary> /// <param name="request">The request.</param> /// <returns></returns> public PermissionResponse SetPermissions(PermissionRequest request) { var response = new PermissionResponse(); var permissionEntity = request.Permission; if (request.Action != PersistType.Delete) { if (!permissionEntity.Validate()) { foreach (var error in permissionEntity.ValidationErrors) { response.Message += error + Environment.NewLine; } response.Acknowledge = AcknowledgeType.Failure; return(response); } } try { if (request.Action == PersistType.Insert) { permissionEntity.PermissionId = PermissionDao.InsertPermission(permissionEntity); if (permissionEntity.PermissionId == 0) { response.Acknowledge = AcknowledgeType.Failure; return(response); } } else if (request.Action == PersistType.Update) { response.Message = PermissionDao.UpdatePermission(permissionEntity); if (response.Message != null) { response.Acknowledge = AcknowledgeType.Failure; return(response); } } else { var permissionForDelete = PermissionDao.GetPermission(request.PermissionId); response.Message = PermissionDao.DeletePermission(permissionForDelete); if (response.Message != null) { response.Acknowledge = AcknowledgeType.Failure; response.RowsAffected = 0; return(response); } response.RowsAffected = 1; } } catch (Exception ex) { response.Acknowledge = AcknowledgeType.Failure; response.Message = ex.Message; return(response); } response.PermissionId = permissionEntity != null ? permissionEntity.PermissionId : 0; return(response); }
public IActionResult RegisterPermissionapplying([FromBody] PermissionRequest permissionRequest) { if (permissionRequest == null) { return(Ok(new APIResponse() { status = APIStatus.FAIL.ToString(), response = "Requst can not be empty." })); } try { PermissionRequest result = PermissionRequestHelper.RegisterPermissionApplDetails(permissionRequest); if (result != null) { return(Ok(new APIResponse() { status = APIStatus.PASS.ToString(), response = result })); } return(Ok(new APIResponse() { status = APIStatus.FAIL.ToString(), response = "Registration failed." })); } catch (Exception ex) { return(Ok(new APIResponse() { status = APIStatus.FAIL.ToString(), response = ex.Message })); } }
/// <inheritdoc/> public async Task <PermissionResponse> Create(PermissionRequest request, string token) { HttpClient client = this.httpClientService.CreateDefaultHttpClient(); client.DefaultRequestHeaders.Accept.Clear(); client.BearerTokenAuthorization(token); string requestUrl = this.serverConfigurationDelegate.ServerConfiguration.PermissionEndpoint; client.BaseAddress = new Uri(requestUrl); string jsonOutput = JsonSerializer.Serialize <PermissionRequest>(request); using (HttpContent content = new StringContent(jsonOutput)) { HttpResponseMessage response = await client.PostAsync(new Uri(requestUrl), content).ConfigureAwait(false); if (!response.IsSuccessStatusCode) { this.logger.LogError($"createPermissionTicket(PermissionRequest ) returned with StatusCode := {response.StatusCode}."); } string result = await response.Content.ReadAsStringAsync().ConfigureAwait(false); PermissionResponse?permissionResponse = JsonSerializer.Deserialize <PermissionResponse>(result); return(permissionResponse !); } }
public override void OnPermissionRequest(PermissionRequest request) { mContext.RunOnUiThread(() => { request.Grant(request.GetResources()); }); }
public async Task <Dictionary <String, Object> > ProcessAsync(PermissionRequest permissionRequest) { _logger.LogDebug("Creating permission response"); Client client = await _clientStore.GetFromClientIdAsync(permissionRequest.ClientId); if (client == null) { _logger.LogWarning("No client found with the clientId given: {clienId}", permissionRequest.ClientId); return(new Dictionary <String, Object> { { "ErrorMessage", "client is not valid. See the log." } }); } PolicyResult policyResult = await _policyService.EvaluateAsync(client.Policy, permissionRequest.User); _logger.LogDebug($"PolicyResult: { Newtonsoft.Json.JsonConvert.SerializeObject(policyResult)}"); Dictionary <String, Object> result = new Dictionary <String, Object> { { nameof(client.ClientId), client.ClientId }, { nameof(policyResult.PolicyHash), policyResult.PolicyHash }, { nameof(policyResult.LastPolicyChangeDate), policyResult.LastPolicyChangeDate }, { nameof(policyResult.Roles), policyResult.Roles }, { nameof(policyResult.Permissions), policyResult.Permissions } }; return(result); }
private async Task <IEndpointResult> ProcessPolicyRequestAsync(HttpContext context) { _logger.LogDebug("Start permission request"); if (!context.User.Identity.IsAuthenticated) { _logger.LogWarning("User is not authorized."); return(new StatusCodeResult(HttpStatusCode.Unauthorized)); } PermissionRequest request = await _requestParser.ParseAsync(context); if (request.IsError) { return(Error(request.Error, request.ErrorDescription)); } Dictionary <String, Object> response = await _responseGenerator.ProcessAsync(request); String baseUrl = context.GetPolicyServerBaseUrl().EnsureTrailingSlash(); String issuerUri = context.GetPolicyServerIssuerUri(); response.Add("Issuer", issuerUri); response.Add("ExpireIn", 3600); _logger.LogDebug("End permission request"); return(new PermissionResult(response)); }
public void IsAuthorizedCalledTwiceWithAnErrorBetweenEachCall() { var request = new PermissionRequest { User = "******", Action = "lecture", Entity = "collaborateur" }; Assert.True(Fixture.SampleProvider.IsAuthorized(request)); request = new PermissionRequest { User = "******", Action = "lecture", Entity = "collaborateur", Target = "\"" }; Assert.Throws <InvalidOperationException>(() => { Fixture.SampleProvider.IsAuthorized(request); }); request = new PermissionRequest { User = "******", Action = "lecture", Entity = "collaborateur" }; Assert.True(Fixture.SampleProvider.IsAuthorized(request)); }
public async Task When_Adding_Permission_Then_TicketId_Is_Returned() { var handler = new JwtSecurityTokenHandler(); var idtoken = handler.CreateEncodedJwt( "test", "test", new ClaimsIdentity(new[] { new Claim("sub", "tester") }), null, null, null, null); const string resourceSetId = "resource_set_id"; var addPermissionParameter = new PermissionRequest { ResourceSetId = resourceSetId, Scopes = new[] { "scope" }, IdToken = idtoken }; var resources = new[] { new ResourceSet { Id = resourceSetId, Scopes = new[] { "scope" } } }; InitializeFakeObjects(resources); _ticketStoreStub.Setup(r => r.Add(It.IsAny <Ticket>(), It.IsAny <CancellationToken>())).ReturnsAsync(true); var ticket = (await _requestPermissionHandler .Execute("tester", CancellationToken.None, addPermissionParameter) .ConfigureAwait(false) as Option <Ticket> .Result) !.Item; Assert.NotEmpty(ticket.Requester); }
public override void OnPermissionRequest(PermissionRequest request) { string[] PermissionsAndroid = { Android.Manifest.Permission.CaptureAudioOutput, Android.Manifest.Permission.Vibrate, Android.Manifest.Permission.ModifyAudioSettings, Android.Manifest.Permission.RecordAudio, Android.Manifest.Permission.WriteExternalStorage, Android.Manifest.Permission.AccessNetworkState, Android.Manifest.Permission.MediaContentControl, Android.Manifest.Permission.Camera, PermissionRequest.ResourceVideoCapture, PermissionRequest.ResourceAudioCapture }; mContext.RunOnUiThread(() => { request.Grant(PermissionsAndroid); }); //var statusCamera = await CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Camera); //var statusMicrophone = await CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Microphone); //return statusCamera == PermissionStatus.Granted && statusMicrophone == PermissionStatus.Granted; /* * mContext.RunOnUiThread(() => { * request.Grant(request.GetResources()); * * }); */ }
public async Task <Result <string> > UpdatePermissionsAsync(PermissionRequest request) { try { var role = await _roleManager.FindByIdAsync(request.RoleId); if (role.Name == RoleConstants.AdministratorRole) { return(await Result <string> .FailAsync(_localizer["Not allowed to modify Permissions for this Role."])); } var claims = await _roleManager.GetClaimsAsync(role); foreach (var claim in claims) { await _roleManager.RemoveClaimAsync(role, claim); } var selectedClaims = request.RoleClaims.Where(a => a.Selected).ToList(); foreach (var claim in selectedClaims) { await _roleManager.AddPermissionClaim(role, claim.Value); } return(await Result <string> .SuccessAsync(_localizer["Permission Updated."])); } catch (Exception ex) { return(await Result <string> .FailAsync(ex.Message)); } }
protected override string GetProcessSuccessfulMessage(PermissionRequest request, Room chatRoom) { var msg = new MessageBuilder(); msg.AppendPing(chatRoom.GetUser(request.RequestingUserId)); msg.AppendText($"has been added to the {request.RequestedPermissionGroup} group."); return(msg.ToString()); }
public void IsAuthorisedReturnsTrueIfRuleExistsInProlog() { var request = new PermissionRequest { User = "******" }; Assert.True(Fixture.Provider.IsAuthorized(request)); }
public PermissionStatus OnRequestPermission(PermissionRequest request) { if (request.Type == PermissionType.NOTIFICATIONS) { return(PermissionStatus.GRANTED); } return(PermissionStatus.DENIED); }
public bool EditPermission(PermissionRequest request) { try { return(_permissionLogic.EditPermission(request.Id, request.Key, request.PermissionTypeId)); } catch (Exception e) { throw new FaultException(e.Message); } }
public PermissionDto AddPermission(PermissionRequest request) { try { return(_permissionLogic.AddPermission(request).Map()); } catch (Exception e) { throw new FaultException("Sikertelen"); } }
public void IsAuthorisedReturnsTrueIfRuleExistsInPrologFile() { var request = new PermissionRequest { User = "******", Action = "lecture", Entity = "collaborateur" }; Assert.True(Fixture.SampleProvider.IsAuthorized(request)); }
public async Task UpdateAsync(PermissionRequest permissionRequest) { var permissions = await _context.Permissions.Where(x => x.Id == permissionRequest.Id).Include(x => x.PermissionTypes).Include(x => x.Employees).FirstOrDefaultAsync(); permissions.RequestDate = permissionRequest.RequestDate; permissions.Employees.Name = permissionRequest.Employee.Name; permissions.Employees.LastName = permissionRequest.Employee.LastName; permissions.PermissionTypes.Description = permissionRequest.PermissionType.Description; _context.Permissions.Update(permissions); await _context.SaveChangesAsync(); }
public void GetTargetPermissionsReturnsThePermissionsForTheUserAndEntity() { var request = new PermissionRequest { User = "******", Entity = "stuff" }; var permission = Fixture.Provider.GetTargetPermissions(request); Assert.Equal("stuff", permission.Entity); Assert.Null(permission.Target); Assert.Equal(AccessType.Values.Read | AccessType.Values.Update, permission.AccessTypes); }
public async Task <Guid> Insert(PermissionRequest permissionRequest) { var data = await _context.Employees.AddAsync(new Employee { Name = permissionRequest.Employee.Name, LastName = permissionRequest.Employee.LastName }); var dataResponse = await _context.PermissionTypes.AddAsync(new PermissionType { Description = permissionRequest.PermissionType.Description }); var re = await _context.Permissions.AddAsync(new Permission { RequestDate = permissionRequest.RequestDate, EmployeeId = data.Entity.Id, PermissionTypeId = dataResponse.Entity.Id }); await _context.SaveChangesAsync(); return(re.Entity.Id); }
public void GetAuthorizedTargetReturnsAllTargetsMatchingTheRequest() { var request = new PermissionRequest { User = "******", Action = "lecture", Entity = "stuff" }; var targets = Fixture.Provider.GetAuthorizedTargets(request)?.Distinct().ToList(); Assert.NotNull(targets); Assert.Equal(2, targets.Count); Assert.Contains("publicStuff", targets); Assert.Contains("restrictedStuff", targets); }
public async Task <ActionResult> Update( [FromRoute(Name = "id")][Required] int id, [FromBody] PermissionRequest permission) { if (permission == null) { throw new ArgumentNullException(nameof(permission)); } await _service.UpdateAsync(id, permission); return(Ok()); }
public async Task <IActionResult> Save(PermissionRequest permissionRequest) { try { await this.permissionService.SavePermissionAsync(permissionRequest, this.authHelper.UserId); return(this.Ok()); } catch (Exception ex) { return(this.BadRequest(ex.Message)); } }
public bool GetSpecificPermissionValue(PermissionRequest permissionRequest) { bool hasPermission = false; try { int currentUser; ThingReader <CalculatedPermission> calculatedPermissionReader; currentUser = System.Convert.ToInt32(OperationContext.Current.IncomingMessageProperties["edge-user-id"]); List <CalculatedPermission> calculatedPermissionList = new List <CalculatedPermission>(); using (DataManager.Current.OpenConnection()) { SqlCommand sqlCommand = DataManager.CreateCommand("User_CalculatePermissions(@UserID:Int)", CommandType.StoredProcedure); sqlCommand.Parameters["@UserID"].Value = currentUser; calculatedPermissionReader = new ThingReader <CalculatedPermission>(sqlCommand.ExecuteReader(), null); while (calculatedPermissionReader.Read()) { calculatedPermissionList.Add(calculatedPermissionReader.Current); } calculatedPermissionReader.Dispose(); } if (calculatedPermissionList != null && calculatedPermissionList.Count > 0) { if (string.IsNullOrEmpty(permissionRequest.Path)) { if (calculatedPermissionList.Count > 0) { CalculatedPermission calculatedPermissions = calculatedPermissionList.Find(calculatedPermission => calculatedPermission.AccountID == permissionRequest.AccountID); if (calculatedPermissions != null) { hasPermission = true; } } } else { CalculatedPermission calculatedPermissions = calculatedPermissionList.Find(calculatedPermission => calculatedPermission.AccountID == permissionRequest.AccountID && calculatedPermission.Path.Trim().ToUpper() == permissionRequest.Path.Trim().ToUpper()); if (calculatedPermissions != null) { hasPermission = true; } } } } catch (Exception ex) { ErrorMessageInterceptor.ThrowError(HttpStatusCode.InternalServerError, ex.Message); } return(hasPermission); }
public async Task <bool> AssignPermissionsAsync(string id, PermissionRequest permissions, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); await _client.SetAuthHeaderAsync(cancellationToken); var content = new StringContent(JsonSerializer.Serialize(permissions), Encoding.UTF8, "application/json"); var response = await _client.HttpClient.PostAsync($"api/v2/users/{id}/permissions", content, cancellationToken); await _client.HandleErrorAsync(response, cancellationToken); return(response.IsSuccessStatusCode); }
/// <summary> Updates the given pObjRecord. </summary> /// <remarks> Ranaya, 08/05/2017. </remarks> /// <param name="pObjRecord"> The Object record to add. </param> /// <returns> An int. </returns> public int Update(PermissionRequest pObjRecord) { int lIntResult = 0; lIntResult = mObjPermissionRequestDAO.Update(pObjRecord); if (lIntResult == 0 && mObjPermissionsDAO.ExistsSaleOrder(pObjRecord.RequestId)) { lIntResult = mObjPermissionsDAO.UpdateSaleOrder(pObjRecord.RequestId); } return(lIntResult); }
public bool GetSpecificPermissionValue(PermissionRequest permissionRequest) //TODO: CHANGE TO GET { bool hasPermission = false; int currentUser; ThingReader <CalculatedPermission> calculatedPermissionReader; currentUser = System.Convert.ToInt32(CurrentContext.Request.Headers["edge-user-id"]); List <CalculatedPermission> calculatedPermissionList = new List <CalculatedPermission>(); using (SqlConnection conn = new SqlConnection(AppSettings.GetConnectionString("Easynet.Edge.Core.Data.DataManager.Connection", "String"))) { SqlCommand sqlCommand = DataManager.CreateCommand("User_CalculatePermissions(@UserID:Int)", CommandType.StoredProcedure); sqlCommand.Connection = conn; conn.Open(); sqlCommand.Parameters["@UserID"].Value = currentUser; calculatedPermissionReader = new ThingReader <CalculatedPermission>(sqlCommand.ExecuteReader(), null); while (calculatedPermissionReader.Read()) { calculatedPermissionList.Add(calculatedPermissionReader.Current); } calculatedPermissionReader.Dispose(); } if (calculatedPermissionList != null && calculatedPermissionList.Count > 0) { if (string.IsNullOrEmpty(permissionRequest.Path)) { if (calculatedPermissionList.Count > 0) { CalculatedPermission calculatedPermissions = calculatedPermissionList.Find(calculatedPermission => calculatedPermission.AccountID == permissionRequest.AccountID); if (calculatedPermissions != null) { hasPermission = true; } } } else { CalculatedPermission calculatedPermissions = calculatedPermissionList.Find(calculatedPermission => calculatedPermission.AccountID == permissionRequest.AccountID && calculatedPermission.Path.Trim().ToUpper() == permissionRequest.Path.Trim().ToUpper()); if (calculatedPermissions != null) { hasPermission = true; } } } return(hasPermission); }
/// <summary> /// Gets the permissions. /// </summary> /// <param name="request">The request.</param> /// <returns></returns> public PermissionResponse GetPermissions(PermissionRequest request) { var response = new PermissionResponse(); if (request.LoadOptions.Contains("Permissions")) { response.Permissions = request.LoadOptions.Contains("Active") ? PermissionDao.GetPermissions(request.IsActive) : PermissionDao.GetPermissions(); } if (request.LoadOptions.Contains("Permission")) { response.Permission = PermissionDao.GetPermission(request.PermissionId); } return(response); }
public async Task <ActionResult <int> > Create([FromBody] PermissionRequest permission) { if (permission == null) { throw new ArgumentNullException(nameof(permission)); } var id = await _service.CreateAsync(permission); if (permission == null) { return(NotFound()); } return(Ok(id)); }