public CreatePermissionResponse CreatePermission(CreatePermissionRequest request)
{
IPermissionService permissionService = IoC.Container.Resolve <IPermissionService>();
CreatePermissionResponse per = permissionService.Create(request);
return(per);
}
private CreatePermissionResponse CreateNewPermission()
{
CreatePermissionRequest request = new CreatePermissionRequest("update permission name" + Guid.NewGuid(), "update permission key" + Guid.NewGuid(), "desc");
IResponseData <CreatePermissionResponse> response = this.Connector.Post <CreatePermissionRequest, CreatePermissionResponse>(string.Format(this.BaseUrl, string.Empty), request);
return(response.Data);
}
private CreatePermissionResponse CreatePermissionItem(string name, string key, string desc)
{
CreatePermissionRequest request = new CreatePermissionRequest(name, key, desc);
IPermissionService service = IoC.Container.Resolve <IPermissionService>();
return(service.Create(request));
}
public IActionResult Post(CreatePermissionRequest request)
{
var command = new CreatePermissionCommand(request.Label, request.Description, request.CreatedBy, request.Features);
Result result = _dispatcher.Dispatch(command);
return(FromResult(result));
}
internal virtual CreatePermissionResponse CreatePermission(CreatePermissionRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreatePermissionRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreatePermissionResponseUnmarshaller.Instance;
return(Invoke <CreatePermissionResponse>(request, options));
}
/// <summary>
/// Initiates the asynchronous execution of the CreatePermission operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreatePermission operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/acm-pca-2017-08-22/CreatePermission">REST API Reference for CreatePermission Operation</seealso>
public virtual Task <CreatePermissionResponse> CreatePermissionAsync(CreatePermissionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreatePermissionRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreatePermissionResponseUnmarshaller.Instance;
return(InvokeAsync <CreatePermissionResponse>(request, options, cancellationToken));
}
public void Security_Permission_CreatePermission_ShouldThroException_WithInValidRequest()
{
CreatePermissionRequest request = new CreatePermissionRequest(string.Empty, string.Empty, "desc");
IResponseData <CreatePermissionResponse> response = this.Connector.Post <CreatePermissionRequest, CreatePermissionResponse>(this.BaseUrl, request);
Assert.IsTrue(response.Errors.Count > 0);
Assert.IsTrue(response.Errors.Any(item => item.Key == "security.addPermission.validation.nameIsRequire"));
Assert.IsTrue(response.Errors.Any(item => item.Key == "security.addPermission.validation.keyIsRequire"));
}
public void Security_Permission_CreatePermission_ShouldBeSuccess_WithValidRequest()
{
CreatePermissionRequest request = new CreatePermissionRequest("Name " + Guid.NewGuid(), "Key " + Guid.NewGuid(), "desc");
IResponseData <CreatePermissionResponse> response = this.Connector.Post <CreatePermissionRequest, CreatePermissionResponse>(this.BaseUrl, request);
/* Assert.IsTrue(response.Status == HttpStatusCode.OK); */
Assert.IsTrue(response.Errors.Count == 0);
Assert.IsTrue(response.Data != null);
Assert.IsTrue(response.Data.Id != null && response.Data.Id != Guid.Empty);
}
public void Common_Validator_ValidateUniqueAttribute_ShouldThrowException_WithDuplicatedName()
{
CreatePermissionRequest request = new CreatePermissionRequest("abc", "dsfsdfs", "sdfdfs");
IPermissionService service = IoC.Container.Resolve <IPermissionService>();
service.Create(request);
CustomAttributeObject obj = new CustomAttributeObject("abc");
IValidationException ex = ValidationHelper.Validate(obj);
Assert.IsTrue(ex.HasExceptionKey(ValidateUniqueAttribute.NameExceptionKey));
}
public void Security_Permission_CreatePermission_ShouldThroException_WithDuplicatedNameAndKey()
{
CreatePermissionRequest request = new CreatePermissionRequest("Name " + Guid.NewGuid(), "Key " + Guid.NewGuid(), "desc");
this.Connector.Post <CreatePermissionRequest, CreatePermissionResponse>(this.BaseUrl, request);
IResponseData <CreatePermissionResponse> response = this.Connector.Post <CreatePermissionRequest, CreatePermissionResponse>(this.BaseUrl, request);
Assert.IsTrue(response.Errors.Count > 0);
Assert.IsTrue(response.Errors.Any(item => item.Key == "security.addPermission.validation.nameAlreadyExist"));
Assert.IsTrue(response.Errors.Any(item => item.Key == "security.addPermission.validation.keyAlreadyExist"));
}
public CreatePermissionResponse Create(CreatePermissionRequest permission)
{
this.ValidateCreatePermissionRequest(permission);
using (App.Common.Data.IUnitOfWork uow = new App.Common.Data.UnitOfWork(RepositoryType.MSSQL))
{
IPermissionRepository perRepository = IoC.Container.Resolve <IPermissionRepository>(uow);
Permission per = new Permission(permission.Name, permission.Key, permission.Description);
perRepository.Add(per);
uow.Commit();
return(ObjectHelper.Convert <CreatePermissionResponse>(per));
}
}
public override async Task <GuidRequired> CreatePermission(CreatePermissionRequest request, ServerCallContext context)
{
var command = new CreatePermissionCommand
{
Code = request.Code,
Name = request.Name,
Description = request.Description,
IsEnabled = request.IsEnabled,
};
var result = await _authorizationApp.CreatePermissionAsync(command);
return(result);
}
public async Task <PermissionResponse> CreatePermissionAsync(CreatePermissionRequest permission)
{
var newPermission = _mapper.Map <Permission>(permission);
var created = await _permissionRepo.CreatePermissionAsync(newPermission);
if (!created)
{
return(null);
}
return(await GetPermissionByIdAsync(newPermission.Id));
}
public async Task <IActionResult> CreatePermissionAsync([FromBody] CreatePermissionInput input)
{
var request = new CreatePermissionRequest
{
Code = input.Code,
Name = input.Name,
Description = input.Description,
IsEnabled = input.IsEnabled,
};
var response = (Guid)await _authorizationClient.CreatePermissionAsync(request);
return(CreatedAtAction(nameof(GetPermissionAsync), new { Id = response }, default));
}
public JsonResult Create(PermissionDetailView vm)
{
CreatePermissionRequest request = new CreatePermissionRequest();
request.PermissionName = vm.PermissionName;
request.PermissionDescription = vm.PermissionDescription;
request.ControllerName = vm.ControllerName;
request.ActionName = vm.ActionName;
request.IsAnonymous = vm.IsAnonymous;
request.IsDefaultAllow = vm.IsDefaultAllow;
CreatePermissionResponse response = _permissionService.CreatePermission(request);
return(Json(response));
}
public async Task <IActionResult> PostPermission([FromBody] CreatePermissionRequest createPermission)
{
var created = await _permissionService.CreatePermissionAsync(createPermission);
if (created == null)
{
return(BadRequest());
}
var baseUri = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}";
var location = baseUri + "/api/permissions/" + created.Id.ToString();
return(Created(location, created));
}
public void EncodeToBytes()
{
var request = new CreatePermissionRequest(
new IPEndPoint(IPAddress.Parse("54.65.63.212"), 37005)
)
{
TransactionId = new byte[]
{
0xf8, 0x57, 0xe3, 0x50, 0x4c, 0x8f, 0xd3, 0x9d, 0xb8, 0xca,
0x69, 0x83,
},
};
var ctx = new TestStunContext()
{
Username = "******",
Password = "******",
Realm = "twilio.com",
Nonce = new byte[]
{
0x64, 0x32, 0x34, 0x35, 0x39, 0x35, 0x35, 0x39, 0x61, 0x33,
0x38, 0x37, 0x34, 0x63, 0x39, 0x61,
},
};
Assert.Equal(
new byte[]
{
0x00, 0x08, 0x00, 0x94, 0x21, 0x12, 0xa4, 0x42, 0xf8, 0x57,
0xe3, 0x50, 0x4c, 0x8f, 0xd3, 0x9d, 0xb8, 0xca, 0x69, 0x83,
0x00, 0x12, 0x00, 0x08, 0x00, 0x01, 0xb1, 0x9f, 0x17, 0x53,
0x9b, 0x96, 0x00, 0x06, 0x00, 0x40, 0x61, 0x65, 0x30, 0x36,
0x33, 0x33, 0x63, 0x64, 0x35, 0x38, 0x62, 0x61, 0x30, 0x39,
0x37, 0x61, 0x31, 0x31, 0x36, 0x37, 0x63, 0x36, 0x64, 0x32,
0x63, 0x63, 0x34, 0x65, 0x32, 0x33, 0x36, 0x64, 0x62, 0x35,
0x32, 0x32, 0x35, 0x36, 0x61, 0x34, 0x30, 0x64, 0x35, 0x36,
0x35, 0x66, 0x31, 0x31, 0x65, 0x64, 0x66, 0x37, 0x36, 0x63,
0x30, 0x32, 0x64, 0x31, 0x33, 0x64, 0x62, 0x39, 0x33, 0x63,
0x00, 0x15, 0x00, 0x10, 0x64, 0x32, 0x34, 0x35, 0x39, 0x35,
0x35, 0x39, 0x61, 0x33, 0x38, 0x37, 0x34, 0x63, 0x39, 0x61,
0x00, 0x14, 0x00, 0x0a, 0x74, 0x77, 0x69, 0x6c, 0x69, 0x6f,
0x2e, 0x63, 0x6f, 0x6d, 0x00, 0x00, 0x00, 0x08, 0x00, 0x14,
0xe9, 0x4a, 0x95, 0x2a, 0x53, 0xb0, 0xdc, 0x8c, 0x3a, 0x42,
0xd7, 0xfd, 0x21, 0xeb, 0x0c, 0xd4, 0x2f, 0x6c, 0x8d, 0x40,
0x80, 0x28, 0x00, 0x04, 0x31, 0x5b, 0x2f, 0x0e,
},
request.Encode(ctx));
}
public async Task <IActionResult> CreatePermission(CreatePermissionRequest request)
{
if (ModelState.IsValid)
{
var response = await _adminService.CreatePermission(request);
if (response.IsSuccessful)
{
AddNotifications(response);
return(RedirectToAction(nameof(AdminController.PermissionManagement)));
}
AddFormErrors(response);
}
var viewModel = new CreatePermissionViewModel(request);
return(View(viewModel));
}
public async Task CreatePermissionAsync(IPEndPoint peerAddress)
{
NetworkStream stream = _control.GetStream();
var request = new CreatePermissionRequest(peerAddress);
await SendMessageAsync(stream, request);
StunMessage response =
await _responses[request.TransactionId].Task;
if (response is CreatePermissionErrorResponse)
{
throw new TurnClientException(
"CreatePermission failed.",
response);
}
}
public async Task <CreatePermissionResponse> CreatePermission(CreatePermissionRequest request)
{
var sessionUser = await _sessionManager.GetUser();
var response = new CreatePermissionResponse();
var permissions = await _cache.Permissions();
var permission = permissions.FirstOrDefault(c => c.Key == request.Key);
if (permission != null)
{
response.Notifications.AddError($"A permission already exists with the key {request.Key}");
return(response);
}
int id;
using (var uow = _uowFactory.GetUnitOfWork())
{
id = await uow.UserRepo.CreatePermission(new Repositories.DatabaseRepos.UserRepo.Models.CreatePermissionRequest()
{
Key = request.Key,
Description = request.Description,
Group_Name = request.GroupName,
Name = request.Name,
Created_By = sessionUser.Id
});
uow.Commit();
}
_cache.Remove(CacheConstants.Permissions);
await _sessionManager.WriteSessionLogEvent(new Models.ManagerModels.Session.CreateSessionLogEventRequest()
{
EventKey = SessionEventKeys.PermissionCreated,
Info = new Dictionary <string, string>()
{
{ "Key", request.Key }
}
});
response.Notifications.Add($"Permission '{request.Key}' has been created", NotificationTypeEnum.Success);
return(response);
}
public async Task CreatePermissionAsync(
IPEndPoint peerAddress,
CancellationToken cancellationToken = default(CancellationToken))
{
NetworkStream stream = _control.GetStream();
var request = new CreatePermissionRequest(peerAddress);
await SendMessageAsync(stream, request, cancellationToken);
StunMessage response = await ReceiveMessage(request.TransactionId);
if (response is CreatePermissionErrorResponse)
{
throw new TurnClientException(
"CreatePermission failed.",
response);
}
}
private void ValidateCreatePermissionRequest(CreatePermissionRequest permission)
{
IValidationException validationException = ValidationHelper.Validate(permission);
IPermissionRepository perRepo = IoC.Container.Resolve <IPermissionRepository>();
if (perRepo.GetByName(permission.Name) != null)
{
validationException.Add(new App.Common.Validation.ValidationError("security.addOrUpdatePermission.validation.nameAlreadyExist"));
}
if (perRepo.GetByKey(permission.Key) != null)
{
validationException.Add(new App.Common.Validation.ValidationError("security.addOrUpdatePermission.validation.keyAlreadyExist"));
}
validationException.ThrowIfError();
}
public async Task <int> CreatePermission(CreatePermissionRequest request)
{
var sqlStoredProc = "sp_permission_create";
var response = await DapperAdapter.GetFromStoredProcAsync <int>
(
storedProcedureName : sqlStoredProc,
parameters : request,
dbconnectionString : DefaultConnectionString,
sqltimeout : DefaultTimeOut,
dbconnection : _connection,
dbtransaction : _transaction);
if (response == null || response.FirstOrDefault() == 0)
{
throw new Exception("No items have been created");
}
return(response.FirstOrDefault());
}
public CreatePermissionResponse CreatePermission(CreatePermissionRequest request)
{
CreatePermissionResponse response = new CreatePermissionResponse();
Permission permission = new Permission();
permission.PermissionName = request.PermissionName;
permission.PermissionDescription = request.PermissionDescription;
permission.ControllerName = request.ControllerName;
permission.ActionName = request.ActionName;
permission.IsAnonymous = request.IsAnonymous;
permission.IsDefaultAllow = request.IsDefaultAllow;
permission.Roles = request.Roles.ConvertToRoles();
permission.Users = request.Users.ConvertToUsers();
if (permission.GetBrokenRules().Count() > 0)
{
response.Errors = permission.GetBrokenRules().ToList();
}
else
{
try {
_permissionRepository.Add(permission);
_uow.Commit();
response.Errors = new List <BusinessRule>();
} catch (Exception ex)
{
List <BusinessRule> errors = new List <BusinessRule>();
do
{
errors.Add(new BusinessRule("DAL", "DAL_ERROR: " + ex.Message));
ex = ex.InnerException;
} while (ex != null);
response.Errors = errors;
}
}
return(response);
}
public CreatePermissionModel(IPermissionsService permissionsService)
{
_permissionsService = permissionsService;
FormData = new CreatePermissionRequest();
}
