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