public async static Task <AddPermissionResponse> Add(GetAddesssApi api, AddPermissionRequest request, string path, AdminKey adminKey) { if (api == null) { throw new ArgumentNullException(nameof(api)); } if (request == null) { throw new ArgumentNullException(nameof(request)); } api.SetAuthorizationKey(adminKey); var response = await api.Post(path, request); var body = await response.Content.ReadAsStringAsync(); if (response.IsSuccessStatusCode) { var message = MessageResponse.GetMessageResponse(body); return(new AddPermissionResponse.Success((int)response.StatusCode, response.ReasonPhrase, body, message.Message)); } return(new AddPermissionResponse.Failed((int)response.StatusCode, response.ReasonPhrase, body)); }
/** * Convert AddPermissionRequest to name value pairs */ private static IDictionary <string, string> ConvertAddPermission(AddPermissionRequest request) { IDictionary <string, string> parameters = new Dictionary <string, string>(); parameters["Action"] = "AddPermission"; if (request.IsSetTopicArn()) { parameters["TopicArn"] = request.TopicArn; } if (request.IsSetLabel()) { parameters["Label"] = request.Label; } List <string> addPermissionRequestAWSAccountIdsList = request.AWSAccountIds; int addPermissionRequestAWSAccountIdsListIndex = 1; foreach (string addPermissionRequestAWSAccountIds in addPermissionRequestAWSAccountIdsList) { parameters[String.Concat("AWSAccountIds", ".member.", addPermissionRequestAWSAccountIdsListIndex)] = addPermissionRequestAWSAccountIds; addPermissionRequestAWSAccountIdsListIndex++; } List <string> addPermissionRequestActionNamesList = request.ActionNames; int addPermissionRequestActionNamesListIndex = 1; foreach (string addPermissionRequestActionNames in addPermissionRequestActionNamesList) { parameters[String.Concat("ActionNames", ".member.", addPermissionRequestActionNamesListIndex)] = addPermissionRequestActionNames; addPermissionRequestActionNamesListIndex++; } return(parameters); }
public async Task <AddPermissionResponse> Add(AddPermissionRequest request, AdminKey adminKey = null, HttpClient httpClient = null) { using (var api = new GetAddesssApi(adminKey ?? AdminKey, HttpClient ?? httpClient)) { return(await api.Permission.Add(request)); } }
public async Task <IActionResult> Add([FromBody] AddPermissionRequest request, CancellationToken cancellationToken = default) { await _mediator.Send(request, cancellationToken); //TODO: fix url and set NoContent return(Ok()); }
/** * Convert AddPermissionRequest to name value pairs */ private static IDictionary <string, string> ConvertAddPermission(AddPermissionRequest request) { IDictionary <string, string> parameters = new Dictionary <string, string>(); parameters["Action"] = "AddPermission"; if (request.IsSetQueueUrl()) { parameters["QueueUrl"] = request.QueueUrl; } if (request.IsSetLabel()) { parameters["Label"] = request.Label; } List <string> addPermissionRequestAWSAccountIdList = request.AWSAccountId; int addPermissionRequestAWSAccountIdListIndex = 1; foreach (string addPermissionRequestAWSAccountId in addPermissionRequestAWSAccountIdList) { parameters[String.Concat("AWSAccountId", ".", addPermissionRequestAWSAccountIdListIndex)] = addPermissionRequestAWSAccountId; addPermissionRequestAWSAccountIdListIndex++; } List <string> addPermissionRequestActionNameList = request.ActionName; int addPermissionRequestActionNameListIndex = 1; foreach (string addPermissionRequestActionName in addPermissionRequestActionNameList) { parameters[String.Concat("ActionName", ".", addPermissionRequestActionNameListIndex)] = addPermissionRequestActionName; addPermissionRequestActionNameListIndex++; } return(parameters); }
/// <summary> /// Initiates the asynchronous execution of the AddPermission operation. /// <seealso cref="Amazon.SimpleNotificationService.IAmazonSimpleNotificationService"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the AddPermission 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> public Task <AddPermissionResponse> AddPermissionAsync(AddPermissionRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new AddPermissionRequestMarshaller(); var unmarshaller = AddPermissionResponseUnmarshaller.Instance; return(Invoke <IRequest, AddPermissionRequest, AddPermissionResponse>(request, marshaller, unmarshaller, signer, cancellationToken)); }
internal AddPermissionResponse AddPermission(AddPermissionRequest request) { var marshaller = new AddPermissionRequestMarshaller(); var unmarshaller = AddPermissionResponseUnmarshaller.Instance; return(Invoke <AddPermissionRequest, AddPermissionResponse>(request, marshaller, unmarshaller)); }
/** * Convert AddPermissionRequest to name value pairs */ private IDictionary <String, String> ConvertAddPermission(AddPermissionRequest request) { IDictionary <String, String> parameters = new Dictionary <String, String>(); parameters.Add("Action", "AddPermission"); if (request.IsSetQueueUrl()) { parameters.Add("QueueUrl", request.QueueUrl); } if (request.IsSetLabel()) { parameters.Add("Label", request.Label); } List <String> addPermissionRequestAWSAccountIdList = request.AWSAccountId; int addPermissionRequestAWSAccountIdListIndex = 1; foreach (String addPermissionRequestAWSAccountId in addPermissionRequestAWSAccountIdList) { parameters.Add("AWSAccountId" + "." + addPermissionRequestAWSAccountIdListIndex, addPermissionRequestAWSAccountId); addPermissionRequestAWSAccountIdListIndex++; } List <String> addPermissionRequestActionNameList = request.ActionName; int addPermissionRequestActionNameListIndex = 1; foreach (String addPermissionRequestActionName in addPermissionRequestActionNameList) { parameters.Add("ActionName" + "." + addPermissionRequestActionNameListIndex, addPermissionRequestActionName); addPermissionRequestActionNameListIndex++; } return(parameters); }
private static IDictionary <string, string> ConvertAddPermission(AddPermissionRequest request) { IDictionary <string, string> dictionary = new Dictionary <string, string>(); dictionary["Action"] = "AddPermission"; if (request.IsSetQueueUrl()) { dictionary["QueueUrl"] = request.QueueUrl; } if (request.IsSetLabel()) { dictionary["Label"] = request.Label; } List <string> aWSAccountId = request.AWSAccountId; int num = 1; foreach (string str in aWSAccountId) { dictionary["AWSAccountId" + "." + num] = str; num++; } List <string> actionName = request.ActionName; int num2 = 1; foreach (string str2 in actionName) { dictionary["ActionName" + "." + num2] = str2; num2++; } return(dictionary); }
private static IDictionary <string, string> ConvertAddPermission(AddPermissionRequest request) { IDictionary <string, string> dictionary = new Dictionary <string, string>(); dictionary["Action"] = "AddPermission"; if (request.IsSetTopicArn()) { dictionary["TopicArn"] = request.TopicArn; } if (request.IsSetLabel()) { dictionary["Label"] = request.Label; } List <string> aWSAccountIds = request.AWSAccountIds; int num = 1; foreach (string str in aWSAccountIds) { dictionary["AWSAccountIds" + ".member." + num] = str; num++; } List <string> actionNames = request.ActionNames; int num2 = 1; foreach (string str2 in actionNames) { dictionary["ActionNames" + ".member." + num2] = str2; num2++; } return(dictionary); }
public async Task <String> SetPermission(AmazonLambdaClient lambda, String rulearn, String rulename) { //var RemovePermissionRequest = new RemovePermissionRequest //{ // FunctionName = "Ec2StartStop", // StatementId = rulename //}; try { var AddPermissionRequest = new AddPermissionRequest { Action = "lambda:InvokeFunction", FunctionName = "Ec2StartStop", Principal = "events.amazonaws.com", SourceArn = rulearn, StatementId = rulename }; var AddPermissionResponse = await lambda.AddPermissionAsync(AddPermissionRequest); return("sucessfully created permission"); } catch (Exception e) { return("permission already exists"); } }
private void addQueuePermission(String queueUrl) { AddPermissionRequest permissionRequest = new AddPermissionRequest() .WithActionName("SendMessage") .WithAWSAccountId(properties.MessageGearsAWSAccountId) .WithLabel("MessageGears Send Permission") .WithQueueUrl(queueUrl); sqs.AddPermission(permissionRequest); }
public void PolicyAndPermissionTest() { string functionName; string iamRoleName = null; bool iamRoleCreated = false; try { string iamRoleArn; string functionArn; CreateLambdaFunction(out functionName, out functionArn, out iamRoleName, out iamRoleArn); var publishResponse = Client.PublishVersion(new PublishVersionRequest { FunctionName = functionName }); var version = publishResponse.Version; var apr = new AddPermissionRequest { FunctionName = functionName, SourceAccount = "999999999999", SourceArn = "arn:aws:s3:::cloudtrail-999999999999", StatementId = "id1", Principal = "s3.amazonaws.com", Action = "lambda:InvokeFunction", Qualifier = version }; var addResponse = Client.AddPermission(apr); var statement = addResponse.Statement; var expectedFunctionName = functionArn + ":" + version; // verify that the qualifier (in query string) got sent to the server correctly // by checking that the function with the qualifier (version) is specified in the // statement we get back from the service Assert.IsTrue(statement.IndexOf(expectedFunctionName, StringComparison.Ordinal) >= 0); var policy = Client.GetPolicy(new Amazon.Lambda.Model.GetPolicyRequest { FunctionName = functionName, Qualifier = version }).Policy; // verify that the function is part of the policy Assert.IsTrue(policy.IndexOf(expectedFunctionName, StringComparison.Ordinal) >= 0); } finally { if (iamRoleCreated) { iamClient.DeleteRole(new DeleteRoleRequest { RoleName = iamRoleName }); } } }
internal AddPermissionResponse AddPermission(AddPermissionRequest request) { var task = AddPermissionAsync(request); try { return(task.Result); } catch (AggregateException e) { ExceptionDispatchInfo.Capture(e.InnerException).Throw(); return(null); } }
/// <summary> /// Adds permission to the Topic for Aws Accounts to performe the actions named. /// </summary> /// <param name="actionNames"></param> /// <param name="awsAccountIds"></param> /// <param name="label"></param> /// <param name="topicArn"></param> public void AddPermission(IEnumerable <string> actionNames, IEnumerable <string> awsAccountIds, string label, string topicArn) { var request = new AddPermissionRequest { ActionNames = new List <string>(actionNames), AWSAccountIds = new List <string>(awsAccountIds), Label = label, TopicArn = topicArn }; // NB: As of version 1.0.8.1 of AWS SDK there appears to be a problem with action names and aws account Id's // validations and these fail whilst apparently having valid values. Client.AddPermission(request); }
public IActionResult Add([FromBody] AddPermissionRequest addPermission) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } Result result = _permissionService.Add(addPermission); if (result.Failure) { ModelState.AddErrors(result.Errors); return(BadRequest(ModelState)); } return(Ok(new EmptyResult())); }
public IHttpActionResult AddPermission(AddPermissionRequest request) { request.ValidateNotNull(); PermissionDomain permissionDomain = new PermissionDomain() { Code = request.Code, IsActive = request.IsActive, ModuleId = request.ModuleId }; return(Ok(new AddPermissionResponse() { Data = _permissionManipulation.AddPermission(permissionDomain), Success = Common.Enumerations.ResponseStatus.Succeeded })); }
public ActionResult Create(PermissionDetailView permissionDetailView) { #region Access Check bool hasPermission = GetEmployee().IsGuaranteed("Permission_Insert"); if (!hasPermission) { ModelState.AddModelError("", "AccessDenied"); return(View(permissionDetailView)); } #endregion if (ModelState.IsValid) { try { AddPermissionRequest request = new AddPermissionRequest(); request.CreateEmployeeID = GetEmployee().ID; request.Group = permissionDetailView.PermissionView.Group; request.Key = permissionDetailView.PermissionView.Key; request.Title = permissionDetailView.PermissionView.Title; GeneralResponse response = this._permissionService.AddPermission(request); if (response.success) { return(RedirectToAction("Index")); } else { foreach (string error in response.ErrorMessages) { ModelState.AddModelError("", error); } return(View(permissionDetailView)); } } catch (Exception ex) { ModelState.AddModelError("", ex.Message); return(View(permissionDetailView)); } } return(View(permissionDetailView)); }
/// <summary> /// Initiates the asynchronous execution of the AddPermission operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the AddPermission operation on AmazonLambdaClient.</param> /// <param name="callback">An Action delegate that is invoked when the operation completes.</param> /// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> public void AddPermissionAsync(AddPermissionRequest request, AmazonServiceCallback <AddPermissionRequest, AddPermissionResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new AddPermissionRequestMarshaller(); var unmarshaller = AddPermissionResponseUnmarshaller.Instance; Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if (callback != null) { callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult <AddPermissionRequest, AddPermissionResponse> responseObject = new AmazonServiceResult <AddPermissionRequest, AddPermissionResponse>((AddPermissionRequest)req, (AddPermissionResponse)res, ex, ao.State); callback(responseObject); } } ; BeginInvoke <AddPermissionRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
public async Task AddPolicy(string account) { try { var request = new AddPermissionRequest() { Action = "lambda:InvokeFunction", FunctionName = $"arn:aws:lambda:us-east-2:125237747044:function:SafeArrival-SIS-infra-green", Principal = "s3.amazonaws.com", SourceArn = $"arn:aws:s3:::safe-arrival-{region}-{environment}-sisbucket", StatementId = "SIS_Lambda_Trigger_Permission", SourceAccount = account }; var response = await client.AddPermissionAsync(request); } catch (Amazon.Lambda.Model.ResourceConflictException) { //Policy created, skip. ; } }
public static void SQSAddPermission() { #region SQSAddPermission var client = new AmazonSQSClient(); var request = new AddPermissionRequest { Actions = new List <string>() { "GetQueueAttributes", "GetQueueUrl" }, AWSAccountIds = new List <string>() { "80398EXAMPLE" }, Label = "JohnDoeCanAccessQueues", QueueUrl = "https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyTestQueue" }; client.AddPermission(request); #endregion }
public static void SNSAddPermission() { #region SNSAddPermission var snsClient = new AmazonSimpleNotificationServiceClient(); var request = new AddPermissionRequest { TopicArn = "arn:aws:sns:us-east-1:80398EXAMPLE:CodingTestResults", ActionName = new List <string>() { "Subscribe" }, AWSAccountId = new List <string>() { "80398EXAMPLE" }, Label = "SubscribePolicy" }; snsClient.AddPermission(request); #endregion }
internal static Task <AddPermissionResponse> AddExecuteApiPermissionAsync ( this AmazonLambdaClient client, ASPNetServerLessPublishAWSLambdaConfigSection lambdaConfig, string restApiId, string awsRegion, string accountId ) { var permissionRequest = new AddPermissionRequest() { Action = lambdaConfig.PermissionAction, FunctionName = lambdaConfig.FunctionName, Principal = lambdaConfig.PermissionPrincipal, StatementId = lambdaConfig.PermissionStatementId, SourceArn = $"arn:aws:execute-api:{awsRegion}:{accountId}:{restApiId}/*/*/*" }; return(client.AddPermissionAsync(permissionRequest)); }
public GeneralResponse AddPermission(AddPermissionRequest request) { GeneralResponse response = new GeneralResponse(); try { Permission permission = new Permission(); permission.ID = Guid.NewGuid(); permission.CreateDate = PersianDateTime.Now; permission.CreateEmployee = _employeeRepository.FindBy(request.CreateEmployeeID); permission.Group = request.Group; permission.Key = request.Key; permission.Title = request.Title; permission.RowVersion = 1; _permissionRepository.Add(permission); _uow.Commit(); // Validation if (permission.GetBrokenRules().Count() > 0) { foreach (BusinessRule businessRule in permission.GetBrokenRules()) { response.ErrorMessages.Add(businessRule.Rule); } return(response); } } catch (Exception ex) { response.ErrorMessages.Add(ex.Message); } return(response); }
public Result Add(AddPermissionRequest addPermission) { ValidationResult validationResult = _addPermissionValidator.Validate(addPermission); if (!validationResult.IsValid) { _logger.LogWarning($"Invalid {nameof(AddPermissionRequest)} model"); return(Result.Fail(validationResult.Errors)); } BaseSpecification <PermissionEntity> baseSpecification = new BaseSpecification <PermissionEntity>(); baseSpecification.AddFilter(x => x.Name.ToUpper() == addPermission.Name.ToUpper()); bool permissionAlreadyExist = _permissionRepository.Exist(baseSpecification); if (permissionAlreadyExist) { _logger.LogError($"Permission with that name already exist"); return(Result.Fail("permission_already_exists", "Permission already exists")); } PermissionEntity permission = new PermissionEntity( name: addPermission.Name, description: addPermission.Description); bool addResult = _permissionRepository.Add(permission); if (!addResult) { _logger.LogError($"Failed to add Permission. PermissionName {permission.Name}"); return(Result.Fail("failed_to_add_permission", "Failed to add permission")); } return(Result.Ok()); }
public Task AddPermission(AddPermissionRequest request) => _service.AddPermission(request);
public Task <AddPermissionResponse> AddPermissionAsync( AddPermissionRequest request, CancellationToken cancellationToken = new CancellationToken()) { return(Task.FromResult(new AddPermissionResponse())); }
public Task <AddPermissionResponse> AddPermissionAsync(AddPermissionRequest request, CancellationToken token = default(CancellationToken)) { throw new NotImplementedException(); }
public AddPermissionResponse AddPermission(AddPermissionRequest request) { throw new NotImplementedException(); }
public void AddPermissionAsync(AddPermissionRequest request, AmazonServiceCallback <AddPermissionRequest, AddPermissionResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }