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));
}
