public void ExecuteQuery(string sql)
{
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials("A", "B");
var c = new AmazonAthenaClient(awsCredentials);
QueryExecutionContext queryExecutionContext = new QueryExecutionContext();
queryExecutionContext.Database = ATHENA_DEFAULT_DATABASE;
// The result configuration specifies where the results of the query should go in S3 and encryption options
ResultConfiguration resultConfiguration = new ResultConfiguration();
// You can provide encryption options for the output that is written.
// .withEncryptionConfiguration(encryptionConfiguration)
resultConfiguration.OutputLocation = ATHENA_OUTPUT_BUCKET;
// Create the StartQueryExecutionRequest to send to Athena which will start the query.
StartQueryExecutionRequest startQueryExecutionRequest = new StartQueryExecutionRequest();
startQueryExecutionRequest.QueryString = sql;
startQueryExecutionRequest.QueryExecutionContext = queryExecutionContext;
startQueryExecutionRequest.ResultConfiguration = resultConfiguration;
var startQueryExecutionResponse = c.StartQueryExecutionAsync(startQueryExecutionRequest);
//Console.WriteLine($"Query ID {startQueryExecutionResponse.QueryExecutionId}");
// return startQueryExecutionResponse.QueryExecutionId();
}
public async Task <IActionResult> Post([FromBody] users _user)
{
var credentials = new Amazon.Runtime.BasicAWSCredentials(Constants.access_key, Constants.secret_key);
var S3Client = new AmazonDynamoDBClient(credentials, Constants.regionEndpoint);
var tableName = "users";
DynamoDBContext context = new DynamoDBContext(S3Client);
var tableResponse = await S3Client.ListTablesAsync();
if (tableResponse.TableNames.Contains(tableName))
{
var conditions = new List <ScanCondition>();
conditions.Add(new ScanCondition("userId", ScanOperator.Equal, _user.userId));
var allDocs = await context.ScanAsync <users>(conditions).GetRemainingAsync();
allDocs[0].userEmail = _user.userEmail;
allDocs[0].userImageUrl = _user.userImageUrl;
allDocs[0].userFirstName = _user.userFirstName;
allDocs[0].userId = _user.userId;
allDocs[0].userLastName = _user.userLastName;
allDocs[0].userName = _user.userName;
allDocs[0].userPassword = _user.userPassword;
await context.SaveAsync <users>(allDocs[0]);
}
return(Ok());
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="localizer"></param>
/// <param name="settings"></param>
/// <param name="logger"></param>
public GoSMSQueueSender(
IStringLocalizer <GoSMSQueueSender> localizer,
IOptions <Model.Settings.GoSMSQueueConfiguration> settings,
ILogger <GoSMSQueueSender> logger
)
{
if (localizer is null)
{
throw new ArgumentNullException(nameof(localizer));
}
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.settings = settings ?? throw new ArgumentNullException(nameof(settings));
if (string.IsNullOrEmpty(settings.Value.QueueURL))
{
throw new Exception(localizer["Invalid SMS endpoint"].Value);
}
var sqsConfig = new AmazonSQSConfig
{
RegionEndpoint = RegionEndpoint.GetBySystemName(settings.Value.Region)
};
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials(settings.Value.AccessKeyID, settings.Value.SecretAccessKey);
amazonSQSClient = new AmazonSQSClient(awsCredentials, sqsConfig);
}
public async Task <IActionResult> DesignAutomationCallback(string connectionId, string resultJson, [FromBody] JObject body)
{
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials(Utils.GetAppSetting("AWS_ACCESS_KEY"), Utils.GetAppSetting("AWS_SECRET_KEY"));
IAmazonS3 client = new AmazonS3Client(awsCredentials, Amazon.RegionEndpoint.USWest2);
if (!await client.DoesS3BucketExistAsync(Utils.S3BucketName))
{
return(Ok());
}
Uri downloadFromS3 = new Uri(client.GeneratePreSignedURL(Utils.S3BucketName, resultJson, DateTime.Now.AddMinutes(10), null));
string resultJsonPath = Path.Combine(_env.WebRootPath, resultJson);
var keys = await client.GetAllObjectKeysAsync(Utils.S3BucketName, null, null);
if (!keys.Contains(resultJson))
{
return(Ok()); // file is not there
}
await client.DownloadToFilePathAsync(Utils.S3BucketName, resultJson, resultJsonPath, null);
string contents = System.IO.File.ReadAllText(resultJsonPath);
System.IO.File.Delete(resultJsonPath);
//await client.DeleteObjectAsync(Utils.S3BucketName, resultJson);
await ValidationHub.ValidationFinished(_hubContext, connectionId, resultJson, JObject.Parse(contents));
return(Ok());
}
public Function()
{
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials("AKIAJI5RF4RFXM7U3ELQ", "4GH/cZnUMg9a+Tmwr6EJ5DQOplrduK3gTHYYb2D+");
_s3Client = new AmazonS3Client();
_sqs = new AmazonSQSClient(awsCredentials, RegionEndpoint.USEast2);
}
public static string PushMetrics(string ns, List <MetricDatum> metrics)
{
var request = new PutMetricDataRequest
{
Namespace = ns,
MetricData = metrics
};
//
Amazon.Runtime.AWSCredentials credentials = null;
if (Configuration.IsLinux())
{
string AccessKey = "xxx";
string SecretKey = "xxx";
credentials = new Amazon.Runtime.BasicAWSCredentials(AccessKey, SecretKey);
}
else
{
credentials = new Amazon.Runtime.StoredProfileAWSCredentials("cloudwatch");
}
//
var client = new AmazonCloudWatchClient(credentials, Amazon.RegionEndpoint.APSoutheast1);
System.Threading.Tasks.Task <PutMetricDataResponse> task = client.PutMetricDataAsync(request);
PutMetricDataResponse response = task.Result;
//
System.Net.HttpStatusCode statusCode = response.HttpStatusCode;
Console.WriteLine(DateTime.Now.ToString("HH:mm ") + statusCode.ToString());
return(statusCode.ToString());
}
static void GetPreSigUrl()
{
String fileKey = "test-txt.log";
Amazon.Runtime.BasicAWSCredentials cred = new Amazon.Runtime.BasicAWSCredentials("61140DEQBD8L2QSRATPS", "1oZedqSsM2DLjer2VvZ74ACpn998TamNbz4LEURN");
Amazon.RegionEndpoint endpoint = Amazon.RegionEndpoint.APNortheast1;
//首先创建一个s3的客户端操作对象（需要amazon提供的密钥）
AmazonS3Client s3 = new AmazonS3Client(cred, endpoint);
try
{
// 验证名称为bucketName的bucket是否存在，不存在则创建
Amazon.S3.Model.GetPreSignedUrlRequest urlRequest = new Amazon.S3.Model.GetPreSignedUrlRequest();
urlRequest.BucketName = bucketName;
urlRequest.Key = fileKey;
urlRequest.Protocol = Protocol.HTTP;
urlRequest.Verb = HttpVerb.GET;
urlRequest.Expires = DateTime.Now.AddHours(12); // ;.Now + dtSpan; //new TimeSpan(12,0,0); //12小时有效期
String strSinnedURL = s3.GetPreSignedURL(urlRequest);
Console.WriteLine(strSinnedURL);
}
catch (Amazon.S3.AmazonS3Exception e)
{
Console.WriteLine("GenerateFileSignURL AmazonS3Exception:" + e.ToString());
}
catch (Exception e)
{
Console.WriteLine("GenerateFileSignURL Exception:" + e.ToString());
}
}
public AWSClass(string region, string AccessKey, string Secret)
{
RegionEndpoint EndPoint = RegionEndpoint.GetBySystemName(region);
Amazon.Runtime.BasicAWSCredentials Credentials = new Amazon.Runtime.BasicAWSCredentials(AccessKey, Secret);
_client = new AmazonEC2Client(Credentials, EndPoint);
}
public AmazonActivities(IAmazonS3 client)
{
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials("AKIAJI5RF4RFXM7U3ELQ", "4GH/cZnUMg9a+Tmwr6EJ5DQOplrduK3gTHYYb2D+");
client = new AmazonS3Client(awsCredentials, RegionEndpoint.USEast2);
_client = client;
}
private async Task <XrefTreeArgument> BuildS3DownloadURL(string fileName)
{
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials(Credentials.GetAppSetting("AWS_ACCESS_KEY"), Credentials.GetAppSetting("AWS_SECRET_KEY"));
IAmazonS3 client = new AmazonS3Client(awsCredentials, Amazon.RegionEndpoint.USWest2);
if (!await client.DoesS3BucketExistAsync(Utils.S3BucketName))
{
throw new Exception("Bucket does not exist");
}
var keys = await client.GetAllObjectKeysAsync(Utils.S3BucketName, null, null);
if (!keys.Contains(fileName))
{
throw new Exception("Object does not exist in bucket");
}
Uri downloadFromS3 = new Uri(client.GeneratePreSignedURL(Utils.S3BucketName, fileName, DateTime.Now.AddMinutes(5), null));
return(new XrefTreeArgument()
{
Url = downloadFromS3.ToString(),
Verb = Verb.Get
});
}
private AmazonRekognitionClient CreateAwsClient()
{
var cred = new Amazon.Runtime.BasicAWSCredentials(this.AccessKeyId, this.AccessKeySecret);
var cli = new AmazonRekognitionClient(cred, Amazon.RegionEndpoint.EUWest1);
return(cli);
}
private AmazonDynamoDBClient CreateDynamoDbClient()
{
var awsAccessKey = Environment.GetEnvironmentVariable(ConfigKeys.g_env_ps_builds_aws_access_key);
var awsSecretKey = Environment.GetEnvironmentVariable(ConfigKeys.g_env_ps_builds_aws_access_secret);
var creds = new Amazon.Runtime.BasicAWSCredentials(awsAccessKey, awsSecretKey);
return(new AmazonDynamoDBClient(creds, RegionEndpoint.USWest2));
}
public UserService()
{
var awsAccessKey = Environment.GetEnvironmentVariable(ConfigKeys.g_env_ps_builds_aws_access_key);
var awsSecretKey = Environment.GetEnvironmentVariable(ConfigKeys.g_env_ps_builds_aws_access_secret);
var creds = new Amazon.Runtime.BasicAWSCredentials(awsAccessKey, awsSecretKey);
_client = new AmazonDynamoDBClient(creds, RegionEndpoint.USWest2);
}
static AmazonS3Client CreateS3Client()
{
var awsAccessKey = Environment.GetEnvironmentVariable(ConfigKeys.g_env_ps_builds_aws_access_key);
var awsSecretKey = Environment.GetEnvironmentVariable(ConfigKeys.g_env_ps_builds_aws_access_secret);
var creds = new Amazon.Runtime.BasicAWSCredentials(awsAccessKey, awsSecretKey);
var client = new AmazonS3Client(creds, Amazon.RegionEndpoint.USEast2);
return(client);
}
private AmazonS3Client GetS3Client()
{
var awsSecret = Environment.GetEnvironmentVariable("AWS_SECRET_KEY");
var awsAccessKey = Environment.GetEnvironmentVariable("AWS_ACCESS_KEY");
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials(awsAccessKey, awsSecret);
var s3Client = new AmazonS3Client(awsCredentials, RegionEndpoint.EUWest1);
return(s3Client);
}
public DisposableDatabase()
{
var creds = new Amazon.Runtime.BasicAWSCredentials("test", "test");
Client = new AmazonDynamoDBClient(creds, new AmazonDynamoDBConfig
{
ServiceURL = "http://localhost:8000"
});
Context = new DynamoDBContext(Client);
}
private void InitializeClients()
{
switch (_StorageType)
{
case StorageType.AwsS3:
_S3Region = _AwsSettings.GetAwsRegionEndpoint();
_S3Credentials = new Amazon.Runtime.BasicAWSCredentials(_AwsSettings.AccessKey, _AwsSettings.SecretKey);
if (String.IsNullOrEmpty(_AwsSettings.Endpoint))
{
_S3Config = new AmazonS3Config
{
RegionEndpoint = _S3Region,
UseHttp = !_AwsSettings.Ssl,
};
// _S3Client = new AmazonS3Client(_S3Credentials, _S3Region);
_S3Client = new AmazonS3Client(_S3Credentials, _S3Config);
}
else
{
_S3Config = new AmazonS3Config
{
RegionEndpoint = _S3Region,
ServiceURL = _AwsSettings.Endpoint,
ForcePathStyle = true,
UseHttp = !_AwsSettings.Ssl
};
_S3Client = new AmazonS3Client(_S3Credentials, _S3Config);
}
break;
case StorageType.Azure:
_AzureCredentials = new StorageCredentials(_AzureSettings.AccountName, _AzureSettings.AccessKey);
_AzureAccount = new CloudStorageAccount(_AzureCredentials, true);
_AzureBlobClient = new CloudBlobClient(new Uri(_AzureSettings.Endpoint), _AzureCredentials);
_AzureContainer = _AzureBlobClient.GetContainerReference(_AzureSettings.Container);
break;
case StorageType.Disk:
if (!Directory.Exists(_DiskSettings.Directory))
{
Directory.CreateDirectory(_DiskSettings.Directory);
}
break;
case StorageType.Kvpbase:
_Kvpbase = new KvpbaseClient(_KvpbaseSettings.UserGuid, _KvpbaseSettings.ApiKey, _KvpbaseSettings.Endpoint);
break;
default:
throw new ArgumentException("Unknown storage type: " + _StorageType.ToString());
}
}
private void UploadToS3(Stream stream, string bucketName, string filename)
{
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials(
ApplicationSettings.TryGetValueFromAppSettings("accessKey"),
ApplicationSettings.TryGetValueFromAppSettings("secretKey"));
RegionEndpoint endPoint = (RegionEndpoint)ApplicationSettings.AppSettings["regionEndpoint"];
AmazonS3Client client = new AmazonS3Client(awsCredentials, endPoint ?? RegionEndpoint.EUCentral1);
TransferUtility fileTransferUtility = new TransferUtility(client);
fileTransferUtility.Upload(stream, bucketName, filename);
}
public TextExtractionResults Extract(byte[] image)
{
var end = Amazon.RegionEndpoint.EUWest1;
Amazon.Runtime.BasicAWSCredentials awsCreds =
new Amazon.Runtime.BasicAWSCredentials(this.AmazonAccessKey, this.AmazonSecretKey);
var region = Amazon.RegionEndpoint.GetBySystemName("eu-west-1");
var cfg = new Amazon.Textract.AmazonTextractConfig();
Amazon.Textract.AmazonTextractClient client = new Amazon.Textract.AmazonTextractClient(awsCreds, end);
//Amazon.Textract.AmazonTextractClient client1 = new Amazon.Textract.AmazonTextractClient(awsCreds, cfg);
var request = new Amazon.Textract.Model.DetectDocumentTextRequest();
request.Document = new Amazon.Textract.Model.Document();
Amazon.Textract.Model.DetectDocumentTextResponse result = null;
using (var memstm = new System.IO.MemoryStream(image))
{
request.Document.Bytes = memstm;
result = client.DetectDocumentTextAsync(request).Result;
}
TextExtractionResults rs = new TextExtractionResults();
List <TextBlock> lstTextBoxes = new List <TextBlock>();
DetermineDimensions(image);
foreach (var block in result.Blocks)
{
TextBlock rsText = new TextBlock();
rsText.Text = block.Text;
if (string.IsNullOrWhiteSpace(rsText.Text))
{
continue; //The first element is always NULL, so it appears
}
if (block.BlockType == Amazon.Textract.BlockType.WORD)
{
double xTopLeft = block.Geometry.BoundingBox.Left * this.Width;
double yTopLeft = block.Geometry.BoundingBox.Top * this.Height;
double width = block.Geometry.BoundingBox.Width * this.Width;
double height = block.Geometry.BoundingBox.Height * this.Height;
rsText.X1 = xTopLeft;
rsText.Y1 = yTopLeft;
rsText.X2 = rsText.X1 + width;
rsText.Y2 = rsText.Y1 + height;
lstTextBoxes.Add(rsText);
}
else
{
//Para or line perhaps?
}
}
rs.Blocks = lstTextBoxes.ToArray();
return(rs);
}
private static void CheckBucket()
{
Amazon.Runtime.AWSCredentials credentials = new Amazon.Runtime.BasicAWSCredentials(awsAccessKey, awsSecretKey);
using (var client = new AmazonS3Client(credentials, Amazon.RegionEndpoint.EUCentral1))
{
if (!(AmazonS3Util.DoesS3BucketExist(client, bucketName)))
{
CreateBucket(client);
}
UploadFiles(client);
}
}
public async Task <bool> Upload(string key, string path)
{
var s3credentials = new Amazon.Runtime.BasicAWSCredentials(access_id, secret_key);
//var s3config = new AmazonS3Config();
//s3config.ProxyHost = "";
//s3config.ProxyPort = 8080;
var ok = false;
using (s3client = new AmazonS3Client(s3credentials, RegionEndpoint.USWest2)) {
ok = await UploadFileAsync(key, path);
}
return(ok);
}
public async Task CreateIssues(string userId, string hubId, string projectId, string versionId, string contentRootPath, string host)
{
string bucketName = "revitdesigncheck" + DesignAutomation4Revit.NickName.ToLower();
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials(Credentials.GetAppSetting("AWS_ACCESS_KEY"), Credentials.GetAppSetting("AWS_SECRET_KEY"));
IAmazonS3 client = new AmazonS3Client(awsCredentials, Amazon.RegionEndpoint.USWest2);
string resultFilename = versionId + ".txt";
// create AWS Bucket
if (!await client.DoesS3BucketExistAsync(bucketName))
{
return;
}
Uri downloadFromS3 = new Uri(client.GeneratePreSignedURL(bucketName, resultFilename, DateTime.Now.AddMinutes(10), null));
// ToDo: is there a better way?
string results = Path.Combine(contentRootPath, resultFilename);
var keys = await client.GetAllObjectKeysAsync(bucketName, null, null);
if (!keys.Contains(resultFilename))
{
return; // file is not there
}
await client.DownloadToFilePathAsync(bucketName, resultFilename, results, null);
string contents = System.IO.File.ReadAllText(results);
Credentials credentials = await Credentials.FromDatabaseAsync(userId);
VersionsApi versionApi = new VersionsApi();
versionApi.Configuration.AccessToken = credentials.TokenInternal;
dynamic versionItem = await versionApi.GetVersionItemAsync(projectId, versionId.Base64Decode());
string itemId = versionItem.data.id;
int version = Int32.Parse(versionId.Split("_")[1].Base64Decode().Split("=")[1]);
string title = string.Format("Column clash report for version {0}", version);
string description = string.Format("<a href=\"http://{0}/issues/?urn={1}&id={2}\" target=\"_blank\">Click to view issues</a>", host, versionId, contents.Base64Encode());
// create issues
BIM360Issues issues = new BIM360Issues();
string containerId = await issues.GetContainer(credentials.TokenInternal, hubId, projectId);
await issues.CreateIssue(credentials.TokenInternal, containerId, itemId, version, title, description);
// only delete if it completes
System.IO.File.Delete(resultFilename);
await client.DeleteObjectAsync(bucketName, resultFilename);
}
public async Task <userResponse> Get([FromBody] loginRequest request)
{
userResponse userResponse = new userResponse();
var credentials = new Amazon.Runtime.BasicAWSCredentials(Constants.access_key, Constants.secret_key);
var tableName = "users";
var S3Client = new AmazonDynamoDBClient(credentials, Constants.regionEndpoint);
var tableResponse = await S3Client.ListTablesAsync();
if (tableResponse.TableNames.Contains(tableName))
{
var conditions = new List <ScanCondition>();
conditions.Add(new ScanCondition("userName", ScanOperator.Equal, request.username));
conditions.Add(new ScanCondition("userPassword", ScanOperator.Equal, request.userpassword));
var allDocs = await _context.ScanAsync <users>(conditions).GetRemainingAsync();
user _user = new user();
_user.userEmail = allDocs[0].userEmail;
_user.userImageUrl = allDocs[0].userImageUrl;
_user.userFirstName = allDocs[0].userFirstName;
_user.userId = allDocs[0].userId;
_user.userLastName = allDocs[0].userLastName;
_user.userName = allDocs[0].userName;
_user.userPassword = allDocs[0].userPassword;
userResponse.user = _user;
userResponse.code = (int)System.Net.HttpStatusCode.OK;
userResponse.message = "Success";
// Create our table if it doesn't exist
DynamoDBContext context = new DynamoDBContext(S3Client);
var tableResponse1 = await S3Client.ListTablesAsync();
if (tableResponse1.TableNames.Contains(tableName))
{
var conditions1 = new List <ScanCondition>();
conditions.Add(new ScanCondition("userId", ScanOperator.Equal, allDocs[0].userId));
var allDocs1 = await context.ScanAsync <users>(conditions1).GetRemainingAsync();
users _user1 = new users();
_user1.userEmail = allDocs1[0].userEmail;
_user1.userImageUrl = request.imageUrl;
_user1.userFirstName = allDocs1[0].userFirstName;
_user1.userId = allDocs1[0].userId;
_user1.userLastName = allDocs1[0].userLastName;
_user1.userName = allDocs1[0].userName;
_user1.userPassword = allDocs1[0].userPassword;
await context.SaveAsync <users>(_user1);
}
}
return(userResponse);
}
private void UploadToS3(string filePath, string bucketName)
{
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials(
ApplicationSettings.TryGetValueFromAppSettings("accessKey"),
ApplicationSettings.TryGetValueFromAppSettings("secretKey"));
AmazonS3Client client = new AmazonS3Client(awsCredentials, RegionEndpoint.EUCentral1);
TransferUtility fileTransferUtility = new TransferUtility(client);
filePath = "/UploadedFiles/" + filePath;
using (var stream = new FileStream(filePath, FileMode.Create))
{
fileTransferUtility.Upload(stream, bucketName, filePath);
}
}
static void Main(string[] args)
{
var bucketName = Guid.NewGuid().ToString().ToLower();
var creds = new Amazon.Runtime.BasicAWSCredentials("key", "secret");
var s3Client = new AmazonS3Client(creds, new AmazonS3Config {
ServiceURL = Environment.GetEnvironmentVariable("AWS_S3_ENDPOINT"), ForcePathStyle = true
});
//s3Client.ListBucketsAsync().Wait();
s3Client.PutBucketAsync(new PutBucketRequest {
BucketName = bucketName, UseClientRegion = true
}).Wait();
Console.WriteLine("Bucket Created!");
// visit to see results http://localhost:9090
}
private async Task EnsureTemplateExists(string contentRootPath)
{
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials(Credentials.GetAppSetting("AWS_ACCESS_KEY"), Credentials.GetAppSetting("AWS_SECRET_KEY"));
IAmazonS3 client = new AmazonS3Client(awsCredentials, Amazon.RegionEndpoint.USWest2);
var keys = await client.GetAllObjectKeysAsync(Utils.S3BucketName, null, null);
if (keys.Contains(RFA_TEMPLATE))
{
return;
}
// not there yet, let's create
string rftPath = Path.Combine(contentRootPath, RFA_TEMPLATE);
await client.UploadObjectFromFilePathAsync(Utils.S3BucketName, RFA_TEMPLATE, rftPath, null);
}
public static void SendSMS(Letter letter)
{
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials(Env.ACESS_KEY, Env.PRIVATE_KEY);
AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(awsCredentials, Amazon.RegionEndpoint.USWest2);
PublishRequest pubRequest = new PublishRequest();
pubRequest.Message = letter.Message;
pubRequest.PhoneNumber = letter.Phone; //+1XXX5550100
// add optional MessageAttributes, for example:
// pubRequest.MessageAttributes.Add("AWS.SNS.SMS.SenderID", new MessageAttributeValue
// { StringValue = "SenderId", DataType = "String" });
Task <PublishResponse> pubResponse = snsClient.PublishAsync(pubRequest);
Task.WaitAll(pubResponse);
Console.WriteLine("All Fine");
}
static Task <Amazon.S3.Model.PutObjectResponse> UploadToS3(CompatibilitySummary summary)
{
var awsAccessKey = Environment.GetEnvironmentVariable("ps_aws_access_key");
var awsSecretKey = Environment.GetEnvironmentVariable("ps_aws_secret_key");
var creds = new Amazon.Runtime.BasicAWSCredentials(awsAccessKey, awsSecretKey);
var client = new AmazonS3Client(creds, Amazon.RegionEndpoint.USWest2);
var summaryBody = JsonConvert.SerializeObject(summary);
var putRequest = new Amazon.S3.Model.PutObjectRequest
{
BucketName = "playcompatibility",
Key = "compat_summary.json",
ContentBody = summaryBody
};
return(client.PutObjectAsync(putRequest));
}
private CognitoService()
{
cognitoRestApi = RestService.For <ICognitoRestApi>(new HttpClient(new HttpLoggingHandler())
{
BaseAddress = new Uri(Configurations.Cognito.CognitoUrl)
});
awsRestApi = RestService.For <IAWSRestApi>(new HttpClient(new HttpLoggingHandler())
{
BaseAddress = new Uri(Configurations.Cognito.AWSRestUrl)
});
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials(Configurations.Cognito.CognitoKey, Configurations.Cognito.CognitoSecret);
provider = new AmazonCognitoIdentityProviderClient(awsCredentials, RegionEndpoint.GetBySystemName(Configurations.Cognito.CognitoRegion));
}
/// <summary>
/// translates the text input
/// </summary>
/// <param name="sourceLang"></param>
/// <param name="targetLang"></param>
/// <param name="textToTranslate"></param>
/// <param name="categoryId"></param>
/// <param name="format"></param>
/// <returns></returns>
internal string Translate(string sourceLang, string targetLang, string textToTranslate)
{
//convert our language codes
var sourceLc = convertLangCode(sourceLang);
var targetLc = convertLangCode(targetLang);
var translatedText = string.Empty;
Amazon.Runtime.AWSCredentials awsCreds = null;
Amazon.RegionEndpoint awsRegion = null;
if (_options.SelectedAuthType == MtTranslationOptions.AWSAuthType.Profile)
{
var credentialsFile = new SharedCredentialsFile(); //TODO: always SharedCredentialsFile?
var prof = credentialsFile.TryGetProfile(_options.ProfileName, out CredentialProfile profile); //TODO: add in error-handling
awsCreds = profile.GetAWSCredentials(credentialsFile);
awsRegion = profile.Region;
}
else
{
awsCreds = new Amazon.Runtime.BasicAWSCredentials(_accessKey, _secretKey);
awsRegion = Amazon.RegionEndpoint.GetBySystemName(_options.RegionName);
}
var tclient = new AmazonTranslateClient(awsCreds, awsRegion);
var trequest = new TranslateTextRequest();
trequest.SourceLanguageCode = sourceLc;
trequest.TargetLanguageCode = targetLc;
trequest.Text = textToTranslate;
try
{
var result = tclient.TranslateText(trequest);
System.Diagnostics.Debug.WriteLine(result.TranslatedText);
translatedText = result.TranslatedText;
}
catch (Amazon.Translate.AmazonTranslateException e)
{
System.Diagnostics.Debug.WriteLine(e.Message);
throw e;
}
return(translatedText);
}
/// <summary>
/// Send the email message
/// </summary>
/// <param name="messageBody">the body text to include in the mail</param>
protected virtual void SendEmail(string messageBody)
{
// Create the email object first, then add the properties.
var subject = new Content(Subject);
Body body = new Body();
if (IsBodyHTML)
{
body.Html = new Content(messageBody);
}
else
{
body.Text = new Content(messageBody);
}
var destination = new Destination();
var msg = new Message(subject, body);
destination.ToAddresses = m_to.Split(ADDRESS_DELIMITERS).ToList();
if (!String.IsNullOrWhiteSpace(m_cc))
{
destination.CcAddresses = m_cc.Split(ADDRESS_DELIMITERS).ToList();
}
if (!String.IsNullOrWhiteSpace(m_bcc))
{
destination.BccAddresses = m_bcc.Split(ADDRESS_DELIMITERS).ToList();
}
var request = new SendEmailRequest(From, destination, msg);
var credentials = new Amazon.Runtime.BasicAWSCredentials(AccessKey, SecretKey);
var client = new AmazonSimpleEmailServiceClient(credentials, Amazon.RegionEndpoint.EUWest1);
try
{
client.SendEmailAsync(request);
}
catch (Exception ex)
{
ErrorHandler.Error("Error occurred while sending e-mail notification.", ex);
}
}
