public ThemeTableEntity(string themeName)
{
RowKey = themeName;
PartitionKey = Common.Methods.ObjectNames.ConvertToObjectNameKey(themeName);
//Create the cloudtable instance and name for the entity operate against:
var cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.PlatformStorage.CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 3);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
cloudTable = cloudTableClient.GetTableReference("themes");
cloudTable.CreateIfNotExists();
}
internal static DataAccessResponseType DeleteTag(Account account, string tagName)
{
var response = new DataAccessResponseType();
//CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(account.StoragePartition).CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 4);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(account.AccountID.ToString()) + TagsTableName);
cloudTable.CreateIfNotExists();
try
{
TagTableEntity tagEntity = cloudTable.CreateQuery <TagTableEntity>().Where(t => t.PartitionKey == tagName).FirstOrDefault();
TableResult deleteResult = cloudTable.Execute(TableOperation.Delete(tagEntity));
response.isSuccess = true;
}
catch (Exception e)
{
PlatformLogManager.LogActivity(
CategoryType.Error,
ActivityType.Error_Exception,
e.Message,
"Exception while attempting to delete tag '" + tagName + "'",
account.AccountID.ToString(),
account.AccountName,
null,
null,
null,
null,
System.Reflection.MethodBase.GetCurrentMethod().ToString(),
null
);
}
return(response);
}
/// <summary>
/// Used to destroy the dunning attempts table once payment issues have been resolved
/// </summary>
/// <param name="accountID"></param>
/// <returns></returns>
internal static bool ClearDunningAttempts(string accountID, string storagePartition)
{
//CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 6);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountID) + AutomaticDunningTableName);
//Delete the entire table
cloudTable.DeleteIfExists();
return(true);
}
internal static int GetInvitedUsersCount()
{
CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.PlatformStorage.CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 3);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(PlatformInvitationsTableName);
cloudTable.CreateIfNotExists();
TableQuery <PlatformInvitationsTableEntity> query = new TableQuery <PlatformInvitationsTableEntity>();
return(cloudTable.ExecuteQuery(query).Count());
}
/// <summary>
/// Retreive all image records for an image group type (essentially the entire table)
/// </summary>
/// <param name="accountId"></param>
/// <param name="imageGroupTypeNameKey"></param>
/// <returns></returns>
internal static IEnumerable <ImageRecordTableEntity> RetrieveImageRecords(string accountId, string storagePartition, string imageFormatGroupTypeNameKey)
{
//CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 4);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + ImageRecordTableName(imageFormatGroupTypeNameKey));
//cloudTable.CreateIfNotExists();
TableQuery <ImageRecordTableEntity> query = new TableQuery <ImageRecordTableEntity>();
return(cloudTable.ExecuteQuery(query));
}
internal static int GetDunningAttemptsCount(string accountId, string storagePartition)
{
//CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 3);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + AutomaticDunningTableName);
cloudTable.CreateIfNotExists();
TableQuery <AutomaticDunningAttemptsTableEntity> query = new TableQuery <AutomaticDunningAttemptsTableEntity>();
return(cloudTable.ExecuteQuery(query).Count());
}
public BlobManager()
{
var storageAccount = CloudStorageAccount.Parse(_connectionString);
var blobClient = storageAccount.CreateCloudBlobClient();
var retryPolicy = new LinearRetry(TimeSpan.FromMilliseconds(300), 3);
blobClient.DefaultRequestOptions.RetryPolicy = retryPolicy;
_container = blobClient.GetContainerReference(_containerName);
_container.CreateIfNotExistsAsync();
BlobContainerPermissions permissions = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Container
};
_container.SetPermissionsAsync(permissions);
}
public AutomaticDunningAttemptsTableEntity(string accountId, string storagePartition, string stripeChargeId)
{
StripeChargeID = stripeChargeId;
//Create the cloudtable instance and name for the entity operate against:
//var cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 3);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
cloudTable = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + AutomaticDunningManager.AutomaticDunningTableName);
cloudTable.CreateIfNotExists();
//Ordered by Newest at top
PartitionKey = string.Format("{0:d19}+{1}", DateTime.MaxValue.Ticks - DateTime.UtcNow.Ticks, Guid.NewGuid().ToString("N"));
}
internal static bool DeleteInvitedUser(string invitationKey)
{
CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.PlatformStorage.CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 3);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(PlatformInvitationsTableName);
cloudTable.CreateIfNotExists();
var invitedAccountUser = GetInvitedUser(invitationKey);
cloudTable.Execute(TableOperation.Delete(invitedAccountUser));
return(true);
}
internal static IEnumerable <PasswordClaimTableEntity> GetPasswordClaims()
{
CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.PlatformStorage.CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 3);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(PasswordClaimTableName);
cloudTable.CreateIfNotExists();
var query = new TableQuery <PasswordClaimTableEntity>();
var passwordClaims = cloudTable.ExecuteQuery(query);
return(passwordClaims);
}
public PasswordClaimTableEntity()
{
//Generate PasswordClaimKey
PasswordClaimKey = Guid.NewGuid().ToString();
//Create the cloudtable instance and name for the entity operate against:
var cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.PlatformStorage.CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 3);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
cloudTable = cloudTableClient.GetTableReference(PasswordClaimManager.PasswordClaimTableName);
cloudTable.CreateIfNotExists();
//Ordered by Newest at top
RowKey = string.Format("{0:d19}+{1}", DateTime.MaxValue.Ticks - DateTime.UtcNow.Ticks, Guid.NewGuid().ToString("N"));
}
internal static ImageRecordTableEntity RetrieveAnyImageRecordForFormatKey(string accountId, string storagePartition, string imageFormatGroupTypeNameKey, string imageRecordKey)
{
//CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 4);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = null;
ImageRecordTableEntity imageRecordEntity = null;
//We do not use the listing table as any duplicate records that are deleted in the "Main" table will also not exist there.
cloudTable = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + ImageRecordTableName(imageFormatGroupTypeNameKey));
//var context = cloudTable.ServiceClient.GetTableServiceContext();
//context.IgnoreResourceNotFoundException = true; //<--
//cloudTableClient.DefaultRequestOptions.
try
{
imageRecordEntity = (from record in cloudTable.CreateQuery <ImageRecordTableEntity>().Where(p => p.RowKey == imageRecordKey) select record).FirstOrDefault(); //new TableQuery<ImageRecordTableEntity>().AsQueryable().Where(p => p.PartitionKey == objectId).ToList();
}
catch (Exception e)
{
if (e.InnerException.Message.Contains("404"))
{
imageRecordEntity = null; //<-- This particular exception ACTUALLY means that we checkd successfully BUT no records exist.
}
else
{
imageRecordEntity = new ImageRecordTableEntity();//<-- We new up the object so that we don't unsafely delete a format in case of connection issues with Table Storage
}
}
return(imageRecordEntity);
}
internal static PlatformInvitationsTableEntity GetInvitedUser(string invitationKey)
{
CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.PlatformStorage.CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 3);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(PlatformInvitationsTableName);
cloudTable.CreateIfNotExists();
TableQuery <PlatformInvitationsTableEntity> query = new TableQuery <PlatformInvitationsTableEntity>()
.Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, invitationKey));
PlatformInvitationsTableEntity invitedAccountUser = cloudTable.ExecuteQuery(query).FirstOrDefault();
return(invitedAccountUser);
}
internal static bool DeletePasswordClaim(string accountID, string storagePartition, string passwordClaimKey)
{
//CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 3);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountID) + PasswordClaimTableName);
cloudTable.CreateIfNotExists();
var passwordClaim = GetPasswordClaim(accountID, storagePartition, passwordClaimKey);
cloudTable.Execute(TableOperation.Delete(passwordClaim));
return(true);
}
internal static IEnumerable <PasswordClaimTableEntity> GetPasswordClaims(string accountId, string storagePartition)
{
//CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 3);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + PasswordClaimTableName);
cloudTable.CreateIfNotExists();
var query = new TableQuery <PasswordClaimTableEntity>();
var passwordClaims = cloudTable.ExecuteQuery(query);
return(passwordClaims);
}
public static CloudBlobClient GetCloudBlobClient(string url, bool isSrc, string accountKey = null)
{
CloudBlobClient blobClient = null;
if (isSrc)
{
blobClient = SrcBlobClient;
}
else
{
blobClient = TargetBlobClient;
}
if (blobClient == null)
{
var accountName = GetAccountNameFromUrl(url);
if (string.IsNullOrWhiteSpace(accountKey))
{
if (isSrc)
{
accountKey = ConfigHelper.SrcAzureAccountKey;
}
else
{
accountKey = ConfigHelper.TargetAzureAccountKey;
}
}
var storageAccount = GetCloudStorageAccount(url, accountKey, accountName);
blobClient = storageAccount.CreateCloudBlobClient();
// retry policy.
// could do with a little work.
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(ConfigHelper.RetryAttemptDelayInSeconds), ConfigHelper.MaxRetryAttempts);
blobClient.RetryPolicy = linearRetryPolicy;
}
return(blobClient);
}
internal static DataAccessResponseType UpdateImageRecordGalleryDescription(string accountId, string storagePartition, string imageGroupTypeNameKey, string objectId, string imageGroupNameKey, string imageFormatNameKey, int imageIndex, string newDescription)
{
var response = new DataAccessResponseType();
//CloudTableClient cloudTableClient = Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudTableClient();
//Create and set retry policy--------
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 4);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + Internal.ImageRecordTableStorage.ImageRecordTableName(imageGroupTypeNameKey)); //<-- accxxxxxproductimages / accxxxxxcategoryimages / accxxxxxaccountimages
//Get the entity to remove gallery index item from
var imageRecordEntity = (from record in cloudTable.CreateQuery <ImageRecordTableEntity>().Where(p => p.PartitionKey == objectId && p.ImageKey == imageGroupNameKey + "-" + imageFormatNameKey) select record).FirstOrDefault();
//through each item, convert to array, update the index & serialize back
var descriptionArray = imageRecordEntity.Description.Split('|').ToList();
descriptionArray[imageIndex] = newDescription;
imageRecordEntity.Description = String.Join("|", descriptionArray);
//Replace the record
TableOperation operation = TableOperation.Replace((imageRecordEntity as TableEntity));
try
{
//cloudTable.CreateIfNotExists();
var tableResult = cloudTable.Execute(operation);
response.isSuccess = true;
}
catch
{
response.isSuccess = false; //tableResult.;
}
return(response);
}
internal static PasswordClaimTableEntity GetPasswordClaim(string accountId, string storagePartition, string passwordClaimKey)
{
//CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 3);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + PasswordClaimTableName);
cloudTable.CreateIfNotExists();
TableQuery <PasswordClaimTableEntity> query = new TableQuery <PasswordClaimTableEntity>()
.Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, passwordClaimKey));
PasswordClaimTableEntity passwordClaim = cloudTable.ExecuteQuery(query).FirstOrDefault();
return(passwordClaim);
}
internal static bool ClearReminderEmailsLog(int amountOfDays)
{
CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.PlatformStorage.CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 3);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(ReminderEmailsCardExpirationLogTableName);
cloudTable.CreateIfNotExists();
TableQuery <CardExpirationEmailRemindersLogTableEntity> query = new TableQuery <CardExpirationEmailRemindersLogTableEntity>()
.Where(TableQuery.GenerateFilterConditionForDate("DateTimeUTC", QueryComparisons.LessThanOrEqual, DateTimeOffset.UtcNow.AddDays(amountOfDays * -1)));
var cardExirationReminderEmails = cloudTable.ExecuteQuery(query);
int count = cardExirationReminderEmails.Count();
foreach (var log in cardExirationReminderEmails)
{
cloudTable.Execute(TableOperation.Delete(log));
}
if (count > 0)
{
//Log Garbage Collection
PlatformLogManager.LogActivity(
CategoryType.GarbageCollection,
ActivityType.GarbageCollection_CreditCardExpirationRemindersLog,
"Purged " + count.ToString("#,##0") + " item(s) from the credit card expiration reminders logs",
count.ToString("#,##0") + " credit card expiration reminder(s) past " + Sahara.Core.Settings.Platform.GarbageCollection.CreditCardExpirationReminderEmailsLogDaysToPurge + " days have been purged"
);
}
return(true);
}
/// <summary>
/// Will serialize the data and add it to a queue with the same name as the class object
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
public static void AddQueueItem <T>(T data, string queueName)
{
//var queueName = typeof(T).Name;
var queue = GetQueueReference(queueName);
var dataString = JsonConvert.SerializeObject(data);
if (dataString.Length > 65535)
{
var blobContainer = GetContainer(queueName);
var filename = Guid.NewGuid().ToString() + ".json";
dataString = AddBlobText(blobContainer, filename, dataString);
}
CloudQueueMessage message = new CloudQueueMessage(dataString);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(5400), 3);
var options = new QueueRequestOptions {
RetryPolicy = linearRetryPolicy
};
queue.AddMessage(message, null, new TimeSpan(0, 1, 0), options, null);
}
public async Task LinearRetryHonorsRetryAfter()
{
TimeSpan interval = TimeSpan.FromSeconds(60);
TimeSpan retryAfter = TimeSpan.FromSeconds(10);
const int maxRetries = 10;
var linearRetry = new LinearRetry(interval, maxRetries);
RequestInformation reqInfo = new RequestInformation()
{
HttpStatusCode = (HttpStatusCode)429,
RetryAfter = retryAfter
};
BatchException batchException = new BatchException(reqInfo, "Message", null);
OperationContext context = new OperationContext();
context.RequestResults.Add(new RequestResult(new RequestInformation(), batchException));
RetryDecision retryDecision = await linearRetry.ShouldRetryAsync(batchException, context);
Assert.Equal(retryAfter, retryDecision.RetryDelay);
Assert.True(retryDecision.ShouldRetry);
}
internal StripeWebhookEventsLogTableEntity(string eventId)//, string monthYear)
{
EventID = eventId;
//MonthYear = monthYear; //<-- Format= "08-2015" (for August 2015) or "12-2014" (for December 2014) - used for 6 month cleanup by Custodian
//Create the cloudtable instance and name for the entity operate against:
var cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.PlatformStorage.CreateCloudTableClient();
RowKey = eventId;
RetryCount = 0;
DateTimeUTC = DateTime.UtcNow;
DateTimeLocal = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, Sahara.Core.Settings.Application.LocalTimeZone);
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 5);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
cloudTable = cloudTableClient.GetTableReference(StripeWebhookEventsLogManager.StripeWebhookEventsLogTableName);
cloudTable.CreateIfNotExists();
}
internal static IRetryPolicy GetRetryPolicy(string policyName, TimeSpan deltaBackoff, int maxAttempts)
{
IRetryPolicy policy;
switch (policyName)
{
case "Exponential":
policy = new ExponentialRetry(deltaBackoff, maxAttempts);
break;
case "Linear":
policy = new LinearRetry(deltaBackoff, maxAttempts);
break;
case "NoRetry":
policy = new NoRetry();
break;
default:
policy = new NoRetry();
break;
}
return(policy);
}
public void VerifyLinearRetryBackOffTime()
{
OperationContext opContext = new OperationContext();
TimeSpan retryInterval;
IRetryPolicy retryPolicy = new LinearRetry(TimeSpan.FromSeconds(10), 4);
Assert.IsTrue(retryPolicy.ShouldRetry(0, 503, new Exception(), out retryInterval, opContext));
Assert.AreEqual(TimeSpan.FromSeconds(10), retryInterval);
Assert.IsTrue(retryPolicy.ShouldRetry(1, 503, new Exception(), out retryInterval, opContext));
Assert.AreEqual(TimeSpan.FromSeconds(10), retryInterval);
Assert.IsTrue(retryPolicy.ShouldRetry(2, 503, new Exception(), out retryInterval, opContext));
Assert.AreEqual(TimeSpan.FromSeconds(10), retryInterval);
Assert.IsTrue(retryPolicy.ShouldRetry(3, 503, new Exception(), out retryInterval, opContext));
Assert.AreEqual(TimeSpan.FromSeconds(10), retryInterval);
Assert.IsFalse(retryPolicy.ShouldRetry(4, 503, new Exception(), out retryInterval, opContext));
Assert.AreEqual(TimeSpan.FromSeconds(10), retryInterval);
retryPolicy = new LinearRetry();
Assert.IsTrue(retryPolicy.ShouldRetry(0, 503, new Exception(), out retryInterval, opContext));
Assert.AreEqual(TimeSpan.FromSeconds(30), retryInterval);
Assert.IsTrue(retryPolicy.ShouldRetry(1, 503, new Exception(), out retryInterval, opContext));
Assert.AreEqual(TimeSpan.FromSeconds(30), retryInterval);
Assert.IsTrue(retryPolicy.ShouldRetry(2, 503, new Exception(), out retryInterval, opContext));
Assert.AreEqual(TimeSpan.FromSeconds(30), retryInterval);
Assert.IsFalse(retryPolicy.ShouldRetry(3, 503, new Exception(), out retryInterval, opContext));
Assert.AreEqual(TimeSpan.FromSeconds(30), retryInterval);
}
internal CardExpirationEmailRemindersLogTableEntity(string accountID, string accountName, DateTime cardExpirationDate, int timeLeftTillExpiration)
{
AccountID = accountID;
AccountName = accountName;
ReminderDays = timeLeftTillExpiration.ToString();
CardExpirationDateUTC = cardExpirationDate;
CardExpirationDateLocal = TimeZoneInfo.ConvertTimeFromUtc(cardExpirationDate, Sahara.Core.Settings.Application.LocalTimeZone);
DateTimeUTC = DateTime.UtcNow;
DateTimeLocal = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, Sahara.Core.Settings.Application.LocalTimeZone);
//Create the cloudtable instance and name for the entity operate against:
var cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.PlatformStorage.CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 5);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
cloudTable = cloudTableClient.GetTableReference(CardExpirationReminderEmailsLogManager.ReminderEmailsCardExpirationLogTableName);
cloudTable.CreateIfNotExists();
}
internal static DataAccessResponseType StoreImageRecord(string accountId, string storagePartition, string imageGroupTypeNameKey, string objectId, string imageGroupName, string imageGroupNameKey, string imageFormatName, string imageFormatNameKey, string title, string description, string url, string filename, string filepath, string containerName, string blobPath, int height, int width, bool isListing = false)
{
var response = new DataAccessResponseType();
var imageRecordEntity = new ImageRecordTableEntity
{
//PartitionKey = objectId,
//RowKey = imageGroupNameKey + "-" + imageFormatNameKey,
ObjectId = objectId, //<-- Partitionkey
ImageKey = imageGroupNameKey + "-" + imageFormatNameKey, //<-- RowKey
ImageGroup = imageGroupName,
ImageGroupKey = imageGroupNameKey,
ImageFormat = imageFormatName,
ImageFormatKey = imageFormatNameKey,
Title = title,
Description = description,
Url = url,
FileName = filename,
FilePath = filepath,
BlobPath = blobPath,
ContainerName = containerName,
Height = height,
Width = width
};
//CloudTableClient cloudTableClient = Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudTableClient();
//Create and set retry policy--------
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 4);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
TableOperation operation = TableOperation.InsertOrReplace((imageRecordEntity as TableEntity));
string tableName = Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + Internal.ImageRecordTableStorage.ImageRecordTableName(imageGroupTypeNameKey); //<-- accxxxxxproductimages / accxxxxxcategoryimages / accxxxxxaccountimages
string listingTablename = Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + Internal.ImageRecordTableStorage.ImageRecordListingTableName(imageGroupTypeNameKey); //<-- accxxxxxproductimages / accxxxxxcategoryimages / accxxxxxaccountimages
if (tableName.Length > 63 || listingTablename.Length > 63)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "Storage table names cannot be longer than 63 characters!"
});
}
try
{
CloudTable cloudTable = cloudTableClient.GetTableReference(tableName); //<-- accxxxxxproductimages / accxxxxxcategoryimages / accxxxxxaccountimages
cloudTable.CreateIfNotExists();
var tableResult = cloudTable.Execute(operation);
if (isListing)
{
//If this is a listing, we also add a copy to the listing variation of the table
CloudTable cloudTable2 = cloudTableClient.GetTableReference(listingTablename); //<-- accxxxxxproductimages / accxxxxxcategoryimages / accxxxxxaccountimages
cloudTable2.CreateIfNotExists();
var tableResult2 = cloudTable2.Execute(operation);
response.isSuccess = true; //tableResult.;
}
else
{
response.isSuccess = true;
}
}
catch
{
response.isSuccess = false; //tableResult.;
//response.ErrorMessage = "image exists";
}
return(response);
}
internal static DataAccessResponseType UpdateImageRecordDescription(string accountId, string storagePartition, string imageGroupTypeNameKey, string objectId, string imageGroupNameKey, string imageFormatNameKey, string newDescription, bool isListing)
{
var response = new DataAccessResponseType();
//CloudTableClient cloudTableClient = Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudTableClient();
//Create and set retry policy--------
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 4);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
#region Process on master image record
CloudTable cloudTable = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + Internal.ImageRecordTableStorage.ImageRecordTableName(imageGroupTypeNameKey)); //<-- accxxxxxproductimages / accxxxxxcategoryimages / accxxxxxaccountimages
//Get the entity to remove gallery index item from
var imageRecordEntity = (from record in cloudTable.CreateQuery <ImageRecordTableEntity>().Where(p => p.PartitionKey == objectId && p.ImageKey == imageGroupNameKey + "-" + imageFormatNameKey) select record).FirstOrDefault();
imageRecordEntity.Description = newDescription;
//Replace the record
TableOperation operation = TableOperation.Replace((imageRecordEntity as TableEntity));
try
{
//cloudTable.CreateIfNotExists();
var tableResult = cloudTable.Execute(operation);
response.isSuccess = true;
}
catch (Exception e)
{
var exceptionMessage = e.Message;
response.isSuccess = false; //tableResult.;
return(null);
}
#endregion
#region Process on Listing image (if applicable)
if (isListing)
{
CloudTable cloudTable2 = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + Internal.ImageRecordTableStorage.ImageRecordListingTableName(imageGroupTypeNameKey)); //<-- accxxxxxproductimages / accxxxxxcategoryimages / accxxxxxaccountimages
//Get the entity to remove gallery index item from
var imageRecordEntity2 = (from record in cloudTable2.CreateQuery <ImageRecordTableEntity>().Where(p => p.PartitionKey == objectId && p.ImageKey == imageGroupNameKey + "-" + imageFormatNameKey) select record).FirstOrDefault();
imageRecordEntity2.Description = newDescription;
//Replace the record
TableOperation operation2 = TableOperation.Replace((imageRecordEntity2 as TableEntity));
try
{
//cloudTable.CreateIfNotExists();
var tableResult2 = cloudTable2.Execute(operation2);
response.isSuccess = true;
}
catch (Exception e)
{
var exceptionMessage = e.Message;
response.isSuccess = false;
}
}
#endregion
return(response);
}
/// <summary>
/// Deletes all image records for an object in table storage
/// </summary>
/// <param name="accountId"></param>
/// <param name="imageGroupTypeNameKey"></param>
/// <param name="objectId"></param>
/// <returns></returns>
internal static DataAccessResponseType DeleteAllImageRecordsForObject(string accountId, string storagePartition, string imageFormatGroupTypeNameKey, string objectId)
{
var response = new DataAccessResponseType();
//CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudTableClient();
//Create and set retry policy
//IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 4);
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 4);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
try
{
//Delete From MAIN table
CloudTable cloudTable1 = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + ImageRecordTableName(imageFormatGroupTypeNameKey));
//cloudTable1.CreateIfNotExists();
List <TableEntity> productImageEntities1 = cloudTable1.CreateQuery <TableEntity>().Where(p => p.PartitionKey == objectId).ToList();
foreach (TableEntity productImageEntity in productImageEntities1)
{
cloudTable1.Execute(TableOperation.Delete(productImageEntity));
}
//Delete From LISTING table
CloudTable cloudTable2 = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + ImageRecordListingTableName(imageFormatGroupTypeNameKey));
//cloudTable2.CreateIfNotExists();
List <TableEntity> productImageEntities2 = cloudTable2.CreateQuery <TableEntity>().Where(p => p.PartitionKey == objectId).ToList();
foreach (TableEntity productImageEntity in productImageEntities2)
{
cloudTable2.Execute(TableOperation.Delete(productImageEntity));
}
response.isSuccess = true;
}
catch (Exception e)
{
if (!e.Message.Contains("(404) Not Found"))
{
PlatformLogManager.LogActivity(
CategoryType.Error,
ActivityType.Error_Exception,
e.Message,
"Exception while attempting to delete all image records for " + imageFormatGroupTypeNameKey + " '" + objectId + "' in table storage",
accountId,
null,
null,
null,
null,
null,
System.Reflection.MethodBase.GetCurrentMethod().ToString(),
null
);
}
}
return(response);
}
/// <summary>
/// Replicates a blob from the current storage account
/// to a target storage account
/// </summary>
/// <param name="targetConnectionString">Connection string of the target storage account</param>
/// <param name="sourceContainerName">The source container</param>
/// <param name="targetContainerName">The target container</param>
/// <param name="blobName">The blob to replicate</param>
/// <param name="log">TextWriter used for logging</param>
/// <returns>The target CloudBlobContainer, used for checking status</returns>
public async Task <CloudBlobContainer> ReplicateBlobAsync(
string targetConnectionString,
string sourceContainerName,
string targetContainerName,
string blobName,
TextWriter log)
{
var taskId = string.Empty;
//Create a connection to where the blob currently lives
CloudBlobClient sourceBlobClient = _account.CreateCloudBlobClient();
//Create remote client
var targetAccount = CloudStorageAccount.Parse(
targetConnectionString);
CloudBlobClient targetBlobClient = targetAccount.CreateCloudBlobClient();
var sourceContainer = sourceBlobClient.GetContainerReference(sourceContainerName);
var targetContainer = targetBlobClient.GetContainerReference(targetContainerName);
//Can be uncommented and used during debugging
// to avoid deploying the entire app to two regions
//bool created = await targetContainer.CreateIfNotExistsAsync();
//if (created)
//{
// var perms = await sourceContainer.GetPermissionsAsync();
// await targetContainer.SetPermissionsAsync(perms);
//}
CloudBlockBlob sourceBlob = sourceContainer.GetBlockBlobReference(blobName);
//Must use a shared access signature when copying across accounts
// else the target cannot read from source and you will get a 404
// Subtract 1 hour and add 1 hour to account for time drift between
// servers
string signature = sourceBlob.GetSharedAccessSignature(
new SharedAccessBlobPolicy
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessStartTime = System.DateTime.Now.AddHours(-1),
SharedAccessExpiryTime = System.DateTime.Now.AddHours(1)
});
var sourceUri = new Uri(sourceBlob.Uri.AbsoluteUri + signature);
CloudBlockBlob targetBlob = targetContainer.GetBlockBlobReference(blobName);
try
{
//Set a retry policy to try again in 10 seconds, 3 max attempts.
var retryPolicy = new LinearRetry(new TimeSpan(0, 0, 10), 3);
var options = new BlobRequestOptions {
RetryPolicy = retryPolicy
};
//The StartCopy method uses spare bandwidth, there is
//no SLA on how fast this will be copied.
taskId = targetBlob.StartCopy(sourceUri, options: options);
}
catch (Exception oops)
{
await log.WriteLineAsync(oops.Message);
}
return(targetContainer);
}
internal static DataAccessResponseType ReorderGalleryImages(string accountId, string storagePartition, string imageGroupTypeNameKey, string objectId, string imageGroupNameKey, string imageFormatNameKey, List <int> imageIndexOrder)
{
var response = new DataAccessResponseType();
//CloudTableClient cloudTableClient = Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudTableClient();
CloudTableClient cloudTableClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudTableClient();
//Create and set retry policy--------
IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 4);
cloudTableClient.DefaultRequestOptions.RetryPolicy = linearRetryPolicy;
CloudTable cloudTable = cloudTableClient.GetTableReference(Sahara.Core.Common.Methods.SchemaNames.AccountIdToTableStorageName(accountId) + Internal.ImageRecordTableStorage.ImageRecordTableName(imageGroupTypeNameKey)); //<-- accxxxxxproductimages / accxxxxxcategoryimages / accxxxxxaccountimages
//Get the entity to remove gallery index item from
var imageRecordEntity = (from record in cloudTable.CreateQuery <ImageRecordTableEntity>().Where(p => p.PartitionKey == objectId && p.ImageKey == imageGroupNameKey + "-" + imageFormatNameKey) select record).FirstOrDefault();
//through each item, convert to array
var _blobPathArray = imageRecordEntity.BlobPath.Split('|').ToList();
var _fileNameArray = imageRecordEntity.FileName.Split('|').ToList();
var _filePathArray = imageRecordEntity.FilePath.Split('|').ToList();
var _urlArray = imageRecordEntity.Url.Split('|').ToList();
var _titleArray = imageRecordEntity.Title.Split('|').ToList();
var _descriptionArray = imageRecordEntity.Description.Split('|').ToList();
//Ensure that new index array count matches amount of images currently in this gallery
if (_blobPathArray.Count != imageIndexOrder.Count)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "New gallery order count does not match amount of images in gallery"
});
}
//Create new versions of the arrays
var blobPathArray = new List <string>();
var fileNameArray = new List <string>();
var filePathArray = new List <string>();
var urlArray = new List <string>();
var titleArray = new List <string>();
var descriptionArray = new List <string>();
//Reorder items into the new arrays
foreach (int index in imageIndexOrder)
{
blobPathArray.Add(_blobPathArray.ElementAt(index));
fileNameArray.Add(_fileNameArray.ElementAt(index));
filePathArray.Add(_filePathArray.ElementAt(index));
urlArray.Add(_urlArray.ElementAt(index));
titleArray.Add(_titleArray.ElementAt(index));
descriptionArray.Add(_descriptionArray.ElementAt(index));
}
//Serialize back to the entity
imageRecordEntity.BlobPath = String.Join("|", blobPathArray);
imageRecordEntity.FileName = String.Join("|", fileNameArray);
imageRecordEntity.FilePath = String.Join("|", filePathArray);
imageRecordEntity.Url = String.Join("|", urlArray);
imageRecordEntity.Title = String.Join("|", titleArray);
imageRecordEntity.Description = String.Join("|", descriptionArray);
//Replace the record
TableOperation operation = TableOperation.Replace((imageRecordEntity as TableEntity));
try
{
//cloudTable.CreateIfNotExists();
var tableResult = cloudTable.Execute(operation);
response.isSuccess = true;
}
catch
{
response.isSuccess = false; //tableResult.;
}
return(response);
}
