public static void Log(this Exception exception, HttpContext context, string customMessage, ExceptionAction action = ExceptionAction.Enqueue)
{
var url = "Not available";
var urlreferer = "Not available";
if (context != null)
{
url = context.Request.Url.ToString();
}
if (context != null && context.Request.UrlReferrer != null)
{
urlreferer = context.Request.UrlReferrer.ToString();
}
var message = new AppException
{
CustomMessage = string.IsNullOrWhiteSpace(customMessage) ? "ABServicios.Error" : customMessage,
Exception = exception,
Url = url,
UrlReferrer = urlreferer,
};
try
{
if (ExceptionAction.Enqueue.Equals(action) || ExceptionAction.SendMailAndEnqueue.Equals(action))
{
AzureQueue.Enqueue(message);
}
}
catch (Exception ex)
{
//estamos en la B, error del error
}
try
{
if (ExceptionAction.SendMail.Equals(action) || ExceptionAction.SendMailAndEnqueue.Equals(action))
{
var mailSender = new GeneralMailSender("*****@*****.**", "Y@361]96KB{CPiw");
var mailMessage = new System.Net.Mail.MailMessage("*****@*****.**", "*****@*****.**", message.CustomMessage, message.Exception + "\n\n" + message.LogMessage + "\n\n" + message.Message + "\n\n" + message.StackTrace + "\n\n" + message.Url + "\n\n" + message.UrlReferrer + "\n\n" + message.InnerExceptionMessage);
// si el mensaje es null significa que el maker controló algunas situaciones y no hay nada para enviar y el mensaje se puede remover de la queue
mailSender.Send(mailMessage);
}
}
catch (Exception ex)
{
//estamos en la B, error del error
}
try
{
Telemetry.TrackException(exception);
}
catch (Exception ex)
{
//estamos en la B, error del error
}
}
public override void Run()
{
try
{
CloudStorageAccount account = CloudConfiguration.GetStorageAccount(AzureConnectionStrings.DataConnection);
// Receipt Queue
var receiptQueue = new AzureQueue <NewReceiptMessage>(account, AzureStorageNames.NewReceiptMessage);
var poisonReceiptQueue = new AzureQueue <NewReceiptMessage>(account, AzureStorageNames.PoisonNewReceiptMessage);
var receiptQueueCommand = new ReceiptThumbnailQueueCommand();
QueueCommandHandler.For(receiptQueue).Every(TimeSpan.FromSeconds(5)).WithPosionMessageQueue(poisonReceiptQueue).Do(receiptQueueCommand);
// ExpenseExportQueueCommand
var exportQueue = new AzureQueue <ApprovedExpenseMessage>(account, AzureStorageNames.ApprovedExpenseMessage);
var poisonExportQueue = new AzureQueue <ApprovedExpenseMessage>(account, AzureStorageNames.PoisonApprovedExpenseMessage);
var exportQueueCommand = new ExpenseExportQueueCommand();
QueueCommandHandler.For(exportQueue).Every(TimeSpan.FromSeconds(5)).WithPosionMessageQueue(poisonExportQueue).Do(exportQueueCommand);
// Expense Export
CommandHandler.Every(TimeSpan.FromSeconds(60)).Do(new ExpenseExportCommand());
while (true)
{
Thread.Sleep(TimeSpan.FromSeconds(5));
}
}
catch (Exception e)
{
Log.Write(EventKind.Error, e.Message);
throw;
}
}
// POST api/<controller>
public HttpStatusCodeResult Post(DenunciaPreciosModel form)
{
try
{
Guid trackingId = Guid.NewGuid();
AzureQueue.Enqueue(new DenunciaPrecios
{
AppId = form.AppId,
AppVersion = form.AppVersion,
Date = form.Date,
InstallationId = form.InstallationId,
Lat = form.Lat,
Lon = form.Lon,
Address = form.Address,
Comment = form.Comment,
MarketId = form.MarketId,
MarketName = form.MarketName,
ProductId = form.ProductId,
RegionId = form.RegionId,
Type = form.Type,
TrackingId = trackingId,
});
return(new HttpStatusCodeResult(200, trackingId.ToString()));
}
catch (Exception)
{
return(new HttpStatusCodeResult(500));
}
}
public void UpdateMessageThrowIfMessageRefIsNull()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var queue = new AzureQueue <MessageForTests>(account, "messagefortests", TimeSpan.FromSeconds(1));
queue.UpdateMessage(new MessageForTests());
}
public async Task GetAndUpdateMessage()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var queue = new AzureQueue <MessageForTests>(account, "messagefortests", TimeSpan.FromSeconds(1));
var message = new MessageForTests {
Content = "content"
};
await queue.ClearAsync();
await queue.AddMessageAsync(message);
var retrievedMessage = await queue.GetMessageAsync();
Assert.AreEqual("content", retrievedMessage.Content);
retrievedMessage.Content = "newContent";
await queue.UpdateMessageAsync(retrievedMessage);
await Task.Delay(1000);
retrievedMessage = await queue.GetMessageAsync();
Assert.AreEqual("newContent", retrievedMessage.Content);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
string azureStorage = Configuration["PDFTEXTREADER_FRONTEND_STORAGE"];
string configFullAccess = Configuration["PDFTEXTREADER_FRONTEND_FULLACCESS"];
bool hasFullAccess = (configFullAccess != null) && Boolean.Parse(configFullAccess);
string azureQueueConfig = Configuration["PDFTEXTREADER_FRONTEND_QUEUE"];
services.Configure <CopyFilesConfig>(Configuration.GetSection("CopyFiles"));
services.Configure <ImagesController.Config>(Configuration.GetSection("Images"));
IVirtualFS2 virtualFS = (String.IsNullOrEmpty(azureStorage)) ?
(IVirtualFS2) new WebVirtualFS() : new AzureFS(azureStorage);
services.AddSingleton <IVirtualFS2>(virtualFS);
if (azureQueueConfig != null)
{
services.AddSingleton(AzureQueue.OpenAsync(azureQueueConfig).Result);
services.AddSingleton <JobManager>();
services.AddSingleton <JobProcess>();
services.AddSingleton <CopyFiles>();
services.AddSingleton <IHostedService, JobManagerHostedService>();
}
services.AddSingleton <DownloadFolder>();
services.AddTransient <PrettyTextFile>();
services.AddSingleton <DeleteFiles>();
services.AddSingleton(new AccessManager(virtualFS, hasFullAccess));
services.AddMvc();
}
private GameActionStatisticsQueue CreateQueue()
{
CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
this.gameActionStatisticsQueue = new AzureQueue<GameActionStatisticsMessage>(account, ConfigurationConstants.GameActionStatisticsQueue + "test" + this.suffix);
return new GameActionStatisticsQueue(this.gameActionStatisticsQueue);
}
public void ProcessMessagesGroup(IQueueMessageRemover <TrenEnEstacion> messagesRemover, IEnumerable <QueueMessage <TrenEnEstacion> > messages)
{
var queueMessages = messages.ToList();
var focusingMessagge = queueMessages.FirstOrDefault();
if (focusingMessagge == null)
{
return;
}
var cleanList = queueMessages.Where(x => x.DequeueCount <= 1).Select(x => x.Data).Distinct(new TrenEnEstacionCompare()).ToList();
foreach (var queueMessage in cleanList)
{
AzureQueue.Enqueue(new TrenEnEstacionClean
{
Estacion = queueMessage.Estacion,
Key = queueMessage.Key,
SentidoDescription = queueMessage.SentidoDescription,
Time = queueMessage.Time,
Vuelta = queueMessage.Vuelta,
});
}
messagesRemover.RemoveProcessedMessages(queueMessages);
}
public static T PopMessage <T>(this AzureQueue <T> azureQueue) where T : AzureQueueMessage
{
var message = azureQueue.GetMessage();
azureQueue.DeleteMessage(message);
return(message);
}
public async Task SendAmbassadorChangedNotification(OrderModel order, AmbassadorModel oldAmbassador, AmbassadorModel newAmbassador)
{
var mailMessage = new MailMessage
{
From = _fromEmail,
Subject = $"[Atomic Limbs] Nuevo pedido (#{order.Id})",
To = newAmbassador.Email,
Body = CompiledTemplateEngine.Render("Mails.OrderNewAmbassador", order),
};
await AzureQueue.EnqueueAsync(mailMessage);
if (oldAmbassador != null && oldAmbassador != newAmbassador) //tenia otro embajador
{
order.OrderAmbassador = oldAmbassador;
mailMessage = new MailMessage
{
From = _fromEmail,
Subject = $"[Atomic Limbs] Cambio de embajador (pedido #{order.Id})",
To = oldAmbassador.Email,
Body = CompiledTemplateEngine.Render("Mails.OrderNewAmbassadorToOldAmbassador", order),
};
await AzureQueue.EnqueueAsync(mailMessage);
order.OrderAmbassador = newAmbassador;
}
}
private static async Task <int> ProcessItensAsync(IEnumerable <IAzureBlob> itens, string fileExtension)
{
var itens_added = 0;
var queue = new AzureQueue(_config.Get("QUEUE_STORAGE_ACCOUNT"), _config.Get("QUEUE_NAME"));
foreach (var item in itens)
{
if (item is IAzureBlobFolder)
{
var folder = (IAzureBlobFolder)item;
Console.WriteLine($"Folder: {folder.Path}");
itens_added += await ProcessItensAsync(folder.EnumItems(), fileExtension);
}
else if (item is IAzureBlobFile)
{
IAzureBlobFile itemFile = item as IAzureBlobFile;
if (string.Equals(itemFile.Extension, fileExtension, StringComparison.CurrentCultureIgnoreCase))
{
await queue.AddMessageAsync(itemFile.Uri);
Console.WriteLine($"Arquivo: {itemFile.Path}");
itens_added++;
}
}
}
return(itens_added);
}
public override void Run()
{
Log.Verbose("OfferManagementWorker is running");
try
{
Log.Verbose("Instantiating the job queue");
string queueConnectionString = CloudConfigurationManager.GetSetting(EarnStorageConnectionString);
string queueName = CloudConfigurationManager.GetSetting(EarnJobsQueueName);
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(queueConnectionString);
azureQueue = new AzureQueue(storageAccount, queueName);
JobManager.Start();
int maxThreads = 5;
if (!int.TryParse(CloudConfigurationManager.GetSetting(MaxThreads), out maxThreads))
{
Log.Warn($"MaxThreads has an invalid value {CloudConfigurationManager.GetSetting(MaxThreads)} in the config. Default value of 5 will be used");
}
Log.Info($"MaxThreads is set to {maxThreads}");
Parallel.For(0, 5, (i) => { this.RunAsync(this.cancellationTokenSource.Token).Wait(); });
}
catch (Exception exception)
{
Log.Error(exception, "Error in running earn jobs role");
}
finally
{
this.runCompleteEvent.Set();
}
}
private async Task <int> ProcessItensAsync(IEnumerable <IAzureBlob> itens, string fileExtension)
{
var itens_added = 0;
var queue = await AzureQueue.CreateAsync(_queueStorageAccount, _queueName);
foreach (var item in itens)
{
if (item is IAzureBlobFolder)
{
var folder = (IAzureBlobFolder)item;
Console.WriteLine($"Folder: {folder.Path}");
itens_added += await ProcessItensAsync(folder.EnumItems(), fileExtension);
}
else if (item is IAzureBlobFile)
{
IAzureBlobFile itemFile = item as IAzureBlobFile;
if (string.Equals(itemFile.Extension, fileExtension, StringComparison.CurrentCultureIgnoreCase))
{
await queue.AddMessageAsync(itemFile.Uri);
Console.WriteLine($"Arquivo: {itemFile.Path}");
itens_added++;
}
}
}
return(itens_added);
}
public static async Task SaveSubscriptionAsync([QueueTrigger("%" + NameResolver.SaveSubscriptionQueueNameKey + "%")] CloudQueueMessage cloudQueueMessage)
{
var job = (IQueueJob <SaveSubscriptionMessage>)Resolver(typeof(IQueueJob <SaveSubscriptionMessage>));
QueueMessage <SaveSubscriptionMessage> queueMessage = AzureQueue <SaveSubscriptionMessage> .Deserialize(cloudQueueMessage);
await job.ExecuteAsync(queueMessage.Content);
}
public async Task Test_AzureImpl_Enqueue_Dequeue()
{
// Init
var queueMock = new CloudQueueClientWrapperMock();
var keyVaultMock = new DatabaseMock("url");
var encryptionManager = new KeyVaultCryptoActions(
new CertificateInfo("emc", string.Empty),
new CertificateInfo("emc", string.Empty),
new CertificateInfo("emc", string.Empty),
new CertificateInfo("emc", string.Empty),
keyVaultMock,
keyVaultMock);
await encryptionManager.InitializeAsync();
var queueName = "queueName";
var azureQueue = new AzureQueue(queueName, queueMock, encryptionManager, true);
await azureQueue.InitializeAsync();
// Enqueue Message
var msg = "new message";
await azureQueue.EnqueueAsync(Communication.Utils.ToByteArray(msg));
var task = azureQueue.DequeueAsync(decrypted =>
{
// Verify that the decrypted message equals to the original
Assert.Equal(msg, Communication.Utils.FromByteArray <string>(decrypted));
}, (message) => { Console.WriteLine("Verification failure, doing nothing"); },
TimeSpan.FromMilliseconds(1));
Thread.Sleep(10000);
azureQueue.CancelListeningOnQueue();
await task;
}
public override void Run()
{
try
{
CloudStorageAccount account = CloudConfiguration.GetStorageAccount(AzureConnectionStrings.DataConnection);
// Receipt Queue
var receiptQueue = new AzureQueue<NewReceiptMessage>(account, AzureStorageNames.NewReceiptMessage);
var poisonReceiptQueue = new AzureQueue<NewReceiptMessage>(account, AzureStorageNames.PoisonNewReceiptMessage);
var receiptQueueCommand = new ReceiptThumbnailQueueCommand();
QueueCommandHandler.For(receiptQueue).Every(TimeSpan.FromSeconds(5)).WithPosionMessageQueue(poisonReceiptQueue).Do(receiptQueueCommand);
// ExpenseExportQueueCommand
var exportQueue = new AzureQueue<ApprovedExpenseMessage>(account, AzureStorageNames.ApprovedExpenseMessage);
var poisonExportQueue = new AzureQueue<ApprovedExpenseMessage>(account, AzureStorageNames.PoisonApprovedExpenseMessage);
var exportQueueCommand = new ExpenseExportQueueCommand();
QueueCommandHandler.For(exportQueue).Every(TimeSpan.FromSeconds(5)).WithPosionMessageQueue(poisonExportQueue).Do(exportQueueCommand);
// Expense Export
CommandHandler.Every(TimeSpan.FromSeconds(60)).Do(new ExpenseExportCommand());
while (true)
{
Thread.Sleep(TimeSpan.FromSeconds(5));
}
}
catch (Exception e)
{
Log.Write(EventKind.Error, e.Message);
throw;
}
}
public async Task Test_Enqueue_Message_Happy_flow()
{
// Init
var queueMock = new CloudQueueClientWrapperMock();
var keyVaultMock = new DatabaseMock("url");
var encryptionManager = new KeyVaultCryptoActions(
new CertificateInfo("emc", string.Empty),
new CertificateInfo("emc", string.Empty),
new CertificateInfo("emc", string.Empty),
new CertificateInfo("emc", string.Empty),
keyVaultMock,
keyVaultMock);
await encryptionManager.InitializeAsync();
var queueName = "queueName";
var azureQueue = new AzureQueue(queueName, queueMock, encryptionManager, true);
await azureQueue.InitializeAsync();
// Enqueue message
var msg = "new message";
await azureQueue.EnqueueAsync(Communication.Utils.ToByteArray(msg));
var queueRefernce = queueMock.GetQueueReference(queueName);
var result = await queueRefernce.GetMessageAsync(TimeSpan.FromSeconds(10),
new QueueRequestOptions(), new OperationContext());
var encryptedMessage = Communication.Utils.FromByteArray <Message>(result.AsBytes);
// String is encrypted, check it value
Assert.Equal(256, encryptedMessage.Data.Length);
}
public async Task SendProofOfDeliveryNotification(OrderModel order)
{
var mailMessage = new MailMessage
{
From = _fromEmail,
Subject = $"[Atomic Limbs] Nueva prueba de entrega (pedido #{order.Id})",
To = order.OrderRequestor.Email,
Body = CompiledTemplateEngine.Render("Mails.OrderProofOfDeliveryInfoToRequestor", order),
};
if (order.OrderRequestor.HasAlternativeEmail())
{
mailMessage.Cc = order.OrderRequestor.AlternativeEmail;
}
await AzureQueue.EnqueueAsync(mailMessage);
mailMessage = new MailMessage
{
From = _fromEmail,
Subject = $"[Atomic Limbs] Nueva prueba de entrega (pedido #{order.Id})",
To = order.OrderAmbassador.Email,
Body = CompiledTemplateEngine.Render("Mails.OrderProofOfDeliveryInfoToAmbassador", order),
};
if (order.OrderAmbassador.HasAlternativeEmail())
{
mailMessage.Cc = order.OrderAmbassador.AlternativeEmail;
}
await AzureQueue.EnqueueAsync(mailMessage);
}
public async Task SendDeliveryInformationNotification(OrderModel order)
{
var ambassadorMailMessage = new MailMessage
{
From = _fromEmail,
Subject = $"[Atomic Limbs] Información de envío (pedido #{order.Id})",
To = order.OrderAmbassador.Email,
Body = CompiledTemplateEngine.Render("Mails.OrderDeliveryInformation", order),
};
if (order.OrderAmbassador.HasAlternativeEmail())
{
ambassadorMailMessage.Cc = order.OrderAmbassador.AlternativeEmail;
}
await AzureQueue.EnqueueAsync(ambassadorMailMessage);
var userMailMessage = new MailMessage
{
From = _fromEmail,
Subject = $"[Atomic Limbs] Información de envío (pedido #{order.Id})",
To = order.OrderRequestor.Email,
Body = CompiledTemplateEngine.Render("Mails.OrderDeliveryInformation", order),
};
if (order.OrderRequestor.HasAlternativeEmail())
{
userMailMessage.Cc = order.OrderRequestor.AlternativeEmail;
}
await AzureQueue.EnqueueAsync(userMailMessage);
}
protected override void OnActionExecuting(ActionExecutingContext ctx)
{
var request = ctx.HttpContext.Request;
_stopwatch.Start();
_requestName = request.Url?.PathAndQuery ?? "";
try
{
_telemetry.Context.Operation.Id = Guid.NewGuid().ToString();
_telemetry.Context.Operation.Name = _requestName;
_telemetry.TrackEvent("Access");
AzureQueue.Enqueue(new ApiAccessLog
{
DateTime = DateTime.UtcNow,
FullUrl = request.Url?.ToString() ?? "",
Host = request.UrlReferrer?.ToString() ?? "",
PathAndQuery = request.Url?.PathAndQuery ?? "",
//Request = JsonConvert.SerializeObject(request),
});
}
catch (Exception ex)
{
_telemetry.TrackException(ex);
}
//ctx.HttpContext.Trace.Write("Log: OnActionExecuting",
// "Calling " +
// ctx.ActionDescriptor.ActionName);
base.OnActionExecuting(ctx);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
services.AddSingleton <IQueue, AzureQueue>((serviceProvider) =>
{
const string queueName = "somequeue";
KV = new KeyVault(Configuration["AzureKeyVaultUri"],
Configuration["applicationId"], Configuration["applicationSecret"]);
var encryptionKeyName = Configuration["EncryptionKeyName"];
var decryptionKeyName = Configuration["DecryptionKeyName"];
var signKeyName = Configuration["SignKeyName"];
var verifyKeyName = Configuration["VerifyKeyName"];
var encryptionCertPassword = Configuration["EncryptionCertPassword"];
var decryptionCertPassword = Configuration["DecryptionCertPassword"];
var signCertPassword = Configuration["SignCertPassword"];
var verifyCertPassword = Configuration["VerifyCertPassword"];
var secretsMgmnt = new KeyVaultCryptoActions(
new CertificateInfo(encryptionKeyName, encryptionCertPassword),
new CertificateInfo(decryptionKeyName, decryptionCertPassword),
new CertificateInfo(signKeyName, signCertPassword),
new CertificateInfo(verifyKeyName, verifyCertPassword),
KV,
KV);
secretsMgmnt.InitializeAsync().Wait();
//var securedComm = new RabbitMQBusImpl(config["rabbitMqUri"], secretsMgmnt, true, "securedCommExchange");
var queueClient = new CloudQueueClientWrapper(Configuration["AzureStorageConnectionString"]);
securedComm = new AzureQueue(queueName, queueClient, secretsMgmnt, true);
securedComm.Initialize().Wait();
return(securedComm);
});
}
public static void Initialize(TestContext context)
{
account = CloudStorageAccount.Parse("UseDevelopmentStorage=true");
var newSurveyAnswerQueue = new AzureQueue <MessageForTests>(account);
newSurveyAnswerQueue.EnsureExistsAsync().Wait();
}
public async Task UsingAzureQueue()
{
//Using the environment variable 'AzureWebJobsStorage' for storage authentication
AzureQueue queue = new AzureQueue("samplequeue");
//Using literal connection string for authentication
//AzureQueue queue = new AzureQueue("samplequeue", "my_connection_string", null);
//Creating "samplequeue". Loading it if already exists.
queue.CreateOrLoadStructure();
//Set this true to deactivate inner logs.
queue.LoggingDisabled = false;
//Inserting 3 random messages
for (int i = 1; i <= 3; i++)
{
await queue.SendAsync("Message " + i);
}
//Processing and deleting from the queue ALL messages. Sometimes Azure services may struggle with delays.
List <string> messages = await queue.GetMessages();
foreach (var m in messages)
{
Console.WriteLine(m);
}
//Inserting an encoded message
await queue.SendAsBase64Async("Hello World!");
//Processing and deleting the encoded message
Console.WriteLine(await queue.GetMessage());
}
public static async Task ProcessDocumentAsync([QueueTrigger("%" + NameResolver.ProcessDocumentQueueNameKey + "%")] CloudQueueMessage cloudQueueMessage)
{
var job = (IQueueJob <ProcessDocumentMessage>)Resolver(typeof(IQueueJob <ProcessDocumentMessage>));
QueueMessage <ProcessDocumentMessage> queueMessage = AzureQueue <ProcessDocumentMessage> .Deserialize(cloudQueueMessage);
await job.ExecuteAsync(queueMessage.Content);
}
public static void Initialize(TestContext context)
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var newSurveyAnswerQueue = new AzureQueue <MessageForTests>(account);
newSurveyAnswerQueue.EnsureExist();
}
public void SaveExpense(Expense expense)
{
var context = new ExpenseDataContext(this.account);
ExpenseEntity expenseRow = expense.ToTableEntity();
foreach (var expenseItem in expense.Details)
{
var expenseItemRow = expenseItem.ToTableEntity(expenseRow.PartitionKey, expense.Id);
context.AddObject(AzureStorageNames.ExpenseTable, expenseItemRow);
}
context.AddObject(AzureStorageNames.ExpenseTable, expenseRow);
context.SaveChanges(SaveChangesOptions.Batch);
foreach (var expenseItem in expense.Details)
{
// save receipt image if any
if (expenseItem.Receipt != null && expenseItem.Receipt.Length > 0)
{
this.receiptStorage.AddReceipt(expenseItem.Id, expenseItem.Receipt, string.Empty);
var queue = new AzureQueue <NewReceiptMessage>(this.account, AzureStorageNames.NewReceiptMessage);
queue.AddMessage(new NewReceiptMessage
{
ExpenseItemId = expenseItem.Id,
ExpenseId = expense.Id,
Username = expense.UserName
});
}
}
}
private GameActionStatisticsQueue CreateQueue()
{
CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
this.gameActionStatisticsQueue = new AzureQueue <GameActionStatisticsMessage>(account, ConfigurationConstants.GameActionStatisticsQueue + "test" + this.suffix);
return(new GameActionStatisticsQueue(this.gameActionStatisticsQueue));
}
public static void Demo()
{
var azq = new AzureQueue <ExampleMessage>();
var generator = new ProxyGenerator();
var proxy = (IQueue <ExampleMessage>)generator.CreateInterfaceProxyWithTarget(typeof(IQueue <ExampleMessage>), azq, new ExceptionLoggingInterceptor(null));
proxy.Send(new ExampleMessage());
}
public async Task DeleteMessageThrowIfMessageRefIsNull()
{
var queue = new AzureQueue <MessageForTests>(account);
var message = new MessageForTests {
Content = "content"
};
await queue.DeleteMessageAsync(message);
}
public async Task <ActionResult> WrongInfo(WrongInfoModel model)
{
string subject = string.Empty;
WrongInfoEmail modelEmail = new WrongInfoEmail
{
Comments = model.Comments,
Fullname = model.Fullname_Requestor,
Url = HttpContext.Request.UrlReferrer.ToString(),
Url_Image = HttpContext.Request.Url.GetLeftPart(UriPartial.Authority) + Url.Content("~/Content/img/ej_mano_email.jpg")
};
MailMessage mailMessage = new MailMessage
{
From = _fromEmail,
To = model.Email_Requestor
};
if (model.IsWrongImages)
{
if (!string.IsNullOrEmpty(model.Comments))
{
subject = "[Acción requerida] Lamentablemente necesitamos más datos y otra foto para hacerte la prótesis";
modelEmail.Url_UserEdit = Url.Action("Edit", "Users", new { area = "" }, Request.Url.Scheme);
mailMessage.Body = CompiledTemplateEngine.Render("Mails.IncorrectPhotoAmbassadorExtraComment", modelEmail);
}
else
{
subject = "[Acción requerida] Lamentablemente necesitamos otra foto para hacerte la prótesis";
mailMessage.Body = CompiledTemplateEngine.Render("Mails.IncorrectPhotoAmbassador", modelEmail);
}
}
if (!string.IsNullOrEmpty(model.Comments) && !model.IsWrongImages)
{
subject = "[Acción requerida] Lamentablemente necesitamos más datos para hacerte la prótesis";
mailMessage.Body = CompiledTemplateEngine.Render("Mails.IncorrectInfoComment", modelEmail);
}
mailMessage.Subject = subject;
await AzureQueue.EnqueueAsync(mailMessage);
if (model.Order_Id != null)
{
OrderModel order = await Db.OrderModels.FindAsync(model.Order_Id);
if (order != null)
{
order.LogMessage(User, "Request more info because of wrong info", order.ToString());
await Db.SaveChangesAsync();
}
}
return(RedirectToAction("Details", "Orders", new { id = model.Order_Id, area = "" }));
}
private EventService CreateEventService()
{
CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
this.notificationsQueue = new AzureQueue <GameActionNotificationMessage>(account, ConfigurationConstants.GameActionNotificationsQueue + "test" + this.suffix);
this.statisticsQueue = new AzureQueue <GameActionStatisticsMessage>(account, ConfigurationConstants.GameActionStatisticsQueue + "test" + this.suffix);
return(new EventService(new GameActionNotificationQueue(this.notificationsQueue), new GameActionStatisticsQueue(this.statisticsQueue), new StringUserProvider("test")));
}
public void DeleteMessageThrowIfMessageRefIsNull()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var queue = new AzureQueue <MessageForTests>(account);
var message = new MessageForTests {
Content = "content"
};
queue.DeleteMessage(message);
}
public void AddAndGetMessage()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var queue = new AzureQueue<MessageForTests>(account);
var message = new MessageForTests { Content = "content" };
queue.Clear();
queue.AddMessage(message);
var actualMessage = queue.GetMessage();
Assert.AreEqual(message.Content, actualMessage.Content);
}
public void AddAndGetMessages()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var newSurveyAnswerQueue = new AzureQueue<MessageForTests>(account);
int maxMessagesToReturn = 2;
newSurveyAnswerQueue.AddMessage(new MessageForTests());
newSurveyAnswerQueue.AddMessage(new MessageForTests());
var actualMessages = newSurveyAnswerQueue.GetMessages(maxMessagesToReturn);
Assert.AreEqual(2, actualMessages.Count());
}
public void PutAndPeek()
{
var queue = new AzureQueue<TestClass>("UseDevelopmentStorage=true", "TestQueue");
queue.Clear();
var putClass = new TestClass {DateTime = DateTime.UtcNow, Description = "Test Description", Id = 15};
queue.PutMessage(putClass);
var msg = queue.GetMessage();
Assert.AreEqual(putClass.Id, msg.Id);
Assert.AreEqual(putClass.Description, msg.Description);
}
public ActionResult Register(RegisterModel model)
{
AzureQueue<UserRegistrationMessage> queue = new AzureQueue<UserRegistrationMessage>(account);
queue.AddMessage(new UserRegistrationMessage
{
DateOfBirth = model.DateOfBirth,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
RegistratoinId = model.RegistrationId,
});
return new EmptyResult();
}
public void AsyncPeek()
{
_asyncQueue = new AzureQueue<TestClass>("UseDevelopmentStorage=true", "TestQueue");
_asyncQueue.Clear();
var thread = new Thread(TestAsync);
thread.Start();
_asyncQueue.PutMessage(_putClass);
while (!_asyncRead)
{
Thread.Sleep(100);
}
}
public ActionResult Create(CustomerFormModel formModel)
{
if (ModelState.IsValid)
{
AzureQueue<NewCustomerCommand> queue = new
AzureQueue<NewCustomerCommand>(account);
queue.AddMessage(new NewCustomerCommand
{
FirstName = formModel.FirstName,
LastName = formModel.LastName,
Address = formModel.Address,
Phone = formModel.Phone,
Email = formModel.Email
});
return RedirectToAction("Index");
}
return View(formModel);
}
public override bool OnStart()
{
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
CloudStorageAccount.SetConfigurationSettingPublisher(
(name, publisher) =>
{
var connectionString = RoleEnvironment.GetConfigurationSettingValue(name);
publisher(connectionString);
}
);
var account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
AzureQueue<UserRegistrationMessage> queue = new AzureQueue<UserRegistrationMessage>(account);
queue.EnsureExist();
AzureBlobContainer<RegistrationTokenEntity> registrationBlob = new AzureBlobContainer<RegistrationTokenEntity>(account, true);
registrationBlob.EnsureExist();
// We could do the 'worker role' portion here aslo
//Task.Factory.StartNew(() =>
//{
// while (true)
// {
// try
// {
// var message = queue.GetMessage();
// if (message != null)
// {
// var entity = new RegistrationTokenEntity();
// entity.RegistrationToken = (new Random()).Next().ToString();
// registrationBlob.Save(message.ContainerId, entity);
// queue.DeleteMessage(message);
// }
// }
// catch { }
// Thread.Sleep(5000);
// }
//});
return base.OnStart();
}
public void Add_Queue_Message_Get_Message()
{
IAzureQueue<TestAzureQueueMessage> testMessageQueue = new AzureQueue<TestAzureQueueMessage>(CloudStorageAccount.DevelopmentStorageAccount, "test");
testMessageQueue.Clear();
var testMessage = new TestAzureQueueMessage
{
Name = "One",
Value = 1
};
testMessageQueue.AddMessage(testMessage);
var popTestMessage = testMessageQueue.GetMessage();
popTestMessage.Delete();
Assert.AreEqual(testMessage.Name, popTestMessage.Name);
Assert.AreEqual(testMessage.Value, popTestMessage.Value);
}
public override void Run()
{
CloudStorageAccount.SetConfigurationSettingPublisher(
(name, publisher) =>
{
var connectionString = RoleEnvironment.GetConfigurationSettingValue(name);
publisher(connectionString);
}
);
var account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
AzureQueue<NewCustomerCommand> queue = new AzureQueue<NewCustomerCommand>(account);
queue.EnsureExist();
while (true)
{
try
{
var message = queue.GetMessage();
if (message != null)
{
AzureTable<Customer> table = new AzureTable<Customer>(account);
var guiid= Guid.NewGuid().ToString();
table.AddEntity( new Customer
{
Id = Guid.NewGuid().ToString(),
PartitionKey = guiid,
RowKey = message.FirstName,
FirstName = message.FirstName,
LastName=message.LastName,
Address=message.Address,
Phone=message.Phone,
Email=message.Email
});
queue.DeleteMessage(message);
}
}
catch { }
Thread.Sleep(5000);
}
}
public void Add_Queue_Messages_Get_Messages_More_Than_Storage_Batch_Limit()
{
IAzureQueue<TestAzureQueueMessage> testMessageQueue = new AzureQueue<TestAzureQueueMessage>(CloudStorageAccount.DevelopmentStorageAccount, "test3");
testMessageQueue.Clear();
var testMessage = new TestAzureQueueMessage
{
Name = "One",
Value = 1
};
for (var i = 0; i < 120; i++)
{
testMessageQueue.AddMessage(testMessage);
}
var popTestMessages = testMessageQueue.GetMessages(120);
Assert.AreEqual(120, popTestMessages.Count);
}
public ActionResult Register(RegisterModel model)
{
AzureQueue<UserRegistrationMessage> queue = new AzureQueue<UserRegistrationMessage>(account);
AzureBlobContainer<RegistrationTokenEntity> registrationBlob = new AzureBlobContainer<RegistrationTokenEntity>(account, true);
var containerId = Guid.NewGuid().ToString();
registrationBlob.Save(containerId, new RegistrationTokenEntity
{
RegistrationToken = null,
});
var blobContainer = registrationBlob.GetSharedAccessSignature(containerId, DateTime.Now.AddHours(1));
queue.AddMessage(new UserRegistrationMessage
{
DateOfBirth = model.DateOfBirth,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
ContainerId = containerId,
});
return Json(new { container = blobContainer });
}
public override void Run()
{
// This is a sample worker implementation. Replace with your logic.
Trace.WriteLine("WorkerRole1 entry point called", "Information");
CloudStorageAccount.SetConfigurationSettingPublisher(
(name, publisher) =>
{
var connectionString = RoleEnvironment.GetConfigurationSettingValue(name);
publisher(connectionString);
}
);
var account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
AzureQueue<UserRegistrationMessage> queue = new AzureQueue<UserRegistrationMessage>(account);
queue.EnsureExist();
AzureBlobContainer<RegistrationTokenEntity> registrationBlob = new AzureBlobContainer<RegistrationTokenEntity>(account, "registrationtoken", true);
registrationBlob.EnsureExist(true);
while (true)
{
try
{
var message = queue.GetMessage();
if (message != null)
{
var entity = new RegistrationTokenEntity();
entity.RegistrationToken = (new Random()).Next().ToString();
registrationBlob.Save(message.RegistratoinId, entity);
queue.DeleteMessage(message);
}
}
catch { }
Thread.Sleep(5000);
}
}
public void GameRepositoryConstructor()
{
IAzureBlobContainer<Game> gameContainer = new AzureBlobContainer<Game>(this.cloudStorageAccount);
IAzureQueue<SkirmishGameQueueMessage> skirmishGameMessageQueue = new AzureQueue<SkirmishGameQueueMessage>(this.cloudStorageAccount, skirmishGameMessageQueueName);
IAzureQueue<LeaveGameMessage> leaveGameMessageQueue = new AzureQueue<LeaveGameMessage>(this.cloudStorageAccount, leaveGameMessageQueueName);
ExceptionAssert.ShouldThrow<ArgumentNullException>(() => new GameRepository(null, null, null, null, null, null));
ExceptionAssert.ShouldThrow<ArgumentNullException>(() => new GameRepository(gameContainer, null, null, null, null, null));
ExceptionAssert.ShouldThrow<ArgumentNullException>(() => new GameRepository(null, null, skirmishGameMessageQueue, null, null, null));
ExceptionAssert.ShouldThrow<ArgumentNullException>(() => new GameRepository(null, null, null, leaveGameMessageQueue, null, null));
ExceptionAssert.ShouldThrow<ArgumentNullException>(() => new GameRepository(null, null, skirmishGameMessageQueue, leaveGameMessageQueue, null, null));
ExceptionAssert.ShouldThrow<ArgumentNullException>(() => new GameRepository(gameContainer, null, null, leaveGameMessageQueue, null, null));
ExceptionAssert.ShouldThrow<ArgumentNullException>(() => new GameRepository(gameContainer, null, skirmishGameMessageQueue, null, null, null));
}
public ContactQueue()
{
var factory = new AzureStorageFactory();
_queue = (AzureQueue<ContactQueueMessage>)factory.GetQueue<ContactQueueMessage>(AzureConstants.ContactQueueName);
}
private EventService CreateEventService()
{
CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
this.notificationsQueue = new AzureQueue<GameActionNotificationMessage>(account, ConfigurationConstants.GameActionNotificationsQueue + "test" + this.suffix);
this.statisticsQueue = new AzureQueue<GameActionStatisticsMessage>(account, ConfigurationConstants.GameActionStatisticsQueue + "test" + this.suffix);
return new EventService(new GameActionNotificationQueue(this.notificationsQueue), new GameActionStatisticsQueue(this.statisticsQueue), new StringUserProvider("test"));
}
public void InitializeGameRepository()
{
this.cloudStorageAccount = CloudStorageAccount.DevelopmentStorageAccount;
this.skirmishGameMessageQueue = new AzureQueue<SkirmishGameQueueMessage>(this.cloudStorageAccount, skirmishGameMessageQueueName);
this.leaveGameMessageQueue = new AzureQueue<LeaveGameMessage>(this.cloudStorageAccount, leaveGameMessageQueueName);
this.gameContainer = new AzureBlobContainer<Game>(this.cloudStorageAccount, gameContainerName, true);
this.gameQueueContainer = new AzureBlobContainer<GameQueue>(this.cloudStorageAccount, gameQueueContainerName, true);
this.userContainer = new AzureBlobContainer<UserProfile>(this.cloudStorageAccount, userContainerName, true);
this.inviteQueue = new AzureQueue<InviteMessage>(this.cloudStorageAccount, inviteQueueName);
this.gameRepository = new GameRepository(this.gameContainer, this.gameQueueContainer, this.skirmishGameMessageQueue, this.leaveGameMessageQueue, this.userContainer, this.inviteQueue);
this.gameRepository.Initialize();
this.skirmishGameMessageQueue.Clear();
this.leaveGameMessageQueue.Clear();
}
static void Main(string[] args)
{
AzureQueue pvpQueue = new AzureQueue();
int action = 0;
bool io = false;
for (int count = 0; count < 20; count++)
{
Console.WriteLine(
"Choose action:\n1 - Create queue\n2 - Add message\n3 - Peek at the next message\n4 - Change message");
Console.WriteLine(
"5 - De-queue message\n6 - Read and delete all(20) messages\n7 - Get the queue length\n8 - View all(20) messages");
Console.WriteLine("9 - Delete queue\n10 - Count Queue Length manually");
string actioninput = Console.ReadLine();
if (!int.TryParse(actioninput, out action))
{
Console.WriteLine("{0} - is not a number", actioninput);
break;
}
switch (action)
{
case 0:
Console.WriteLine("count={0}", count);
Console.ReadLine();
return;
case 1:
Console.WriteLine("Queues have been already created");
break;
case 2:
Console.WriteLine("Please select queue: 1 - input queue, 0 - output queue");
actioninput = Console.ReadLine();
if (!int.TryParse(actioninput, out action))
{
Console.WriteLine("{0} - is not a number", actioninput);
break;
}
if (action < 0 || action > 1)
{
Console.WriteLine("{0} - is not a valid number", actioninput);
break;
}
if (action == 1)
io = true;
else
io = false;
Console.WriteLine("Write down the message:");
actioninput = Console.ReadLine();
pvpQueue.AddMsgQ(actioninput, io);
break;
case 3:
Console.WriteLine("Please select queue: 1 - input queue, 0 - output queue");
actioninput = Console.ReadLine();
if (!int.TryParse(actioninput, out action))
{
Console.WriteLine("{0} - is not a number", actioninput);
break;
}
if (action < 0 || action > 1)
{
Console.WriteLine("{0} - is not a valid number", actioninput);
break;
}
if (action == 1)
io = true;
else
io = false;
pvpQueue.PeekMsg(io);
break;
case 4:
Console.WriteLine("Please select queue: 1 - input queue, 0 - output queue");
actioninput = Console.ReadLine();
if (!int.TryParse(actioninput, out action))
{
Console.WriteLine("{0} - is not a number", actioninput);
break;
}
if (action < 0 || action > 1)
{
Console.WriteLine("{0} - is not a valid number", actioninput);
break;
}
if (action == 1)
io = true;
else
io = false;
Console.WriteLine("Write down new message:");
actioninput = Console.ReadLine();
pvpQueue.UpdMsg(actioninput, io);
break;
case 5:
Console.WriteLine("Please select queue: 1 - input queue, 0 - output queue");
actioninput = Console.ReadLine();
if (!int.TryParse(actioninput, out action))
{
Console.WriteLine("{0} - is not a number", actioninput);
break;
}
if (action < 0 || action > 1)
{
Console.WriteLine("{0} - is not a valid number", actioninput);
break;
}
if (action == 1)
io = true;
else
io = false;
pvpQueue.deQueueMsg(io);
break;
case 6:
Console.WriteLine("Please select queue: 1 - input queue, 0 - output queue");
actioninput = Console.ReadLine();
if (!int.TryParse(actioninput, out action))
{
Console.WriteLine("{0} - is not a number", actioninput);
break;
}
if (action < 0 || action > 1)
{
Console.WriteLine("{0} - is not a valid number", actioninput);
break;
}
if (action == 1)
io = true;
else
io = false;
Console.WriteLine("Write down quantity of messages:");
actioninput = Console.ReadLine();
if (!int.TryParse(actioninput, out action))
{
Console.WriteLine("{0} - is not a number", actioninput);
break;
}
pvpQueue.ReadMsg(action, io);
break;
case 7:
Console.WriteLine("Please select queue: 1 - input queue, 0 - output queue");
actioninput = Console.ReadLine();
if (!int.TryParse(actioninput, out action))
{
Console.WriteLine("{0} - is not a number", actioninput);
break;
}
if (action < 0 || action > 1)
{
Console.WriteLine("{0} - is not a valid number", actioninput);
break;
}
if (action == 1)
io = true;
else
io = false;
action = pvpQueue.getQueueLength(io);
Console.WriteLine(action);
break;
case 8:
Console.WriteLine("Please select queue: 1 - input queue, 0 - output queue");
actioninput = Console.ReadLine();
if (!int.TryParse(actioninput, out action))
{
Console.WriteLine("{0} - is not a number", actioninput);
break;
}
if (action < 0 || action > 1)
{
Console.WriteLine("{0} - is not a valid number", actioninput);
break;
}
if (action == 1)
io = true;
else
io = false;
Console.WriteLine("Write down quantity of messages:");
actioninput = Console.ReadLine();
if (!int.TryParse(actioninput, out action))
{
Console.WriteLine("{0} - is not a number", actioninput);
break;
}
pvpQueue.ViewMsg(action, io);
break;
case 9:
Console.WriteLine("Please select queue: 1 - input queue, 0 - output queue");
actioninput = Console.ReadLine();
if (!int.TryParse(actioninput, out action))
{
Console.WriteLine("{0} - is not a number", actioninput);
break;
}
if (action < 0 || action > 1)
{
Console.WriteLine("{0} - is not a valid number", actioninput);
break;
}
if (action == 1)
io = true;
else
io = false;
pvpQueue.deleteQueue(io);
break;
case 10:
Console.WriteLine("Please select queue: 1 - input queue, 0 - output queue");
actioninput = Console.ReadLine();
if (!int.TryParse(actioninput, out action))
{
Console.WriteLine("{0} - is not a number", actioninput);
break;
}
if (action < 0 || action > 1)
{
Console.WriteLine("{0} - is not a valid number", actioninput);
break;
}
if (action == 1)
io = true;
else
io = false;
Console.WriteLine("Queue count (manually) = {0}", pvpQueue.countQueueLength(io));
break;
/*case 10:
{
string blobName = "vmpay";
try
{
Blobs.PointImagesBlob.DownloadMiniature(blobName);
}
catch
{
Console.WriteLine("Plakat jeszcze nie został wygenerowany.");
//throw new UnauthorizedAccessException("Plakat jeszcze nie został wygenerowany.");
}
break;
}
case 11:
{
try
{
string blobName = "vmpay";
Console.WriteLine("Opening file.");
var fileStream = System.IO.File.OpenRead(@"d:\vmpay.pdf");
Console.WriteLine("Creating blob.");
CloudBlockBlob blob = Blobs.TripPostersBlob.Insert(fileStream, blobName);
Console.WriteLine("Inserting successfull.");
}
catch
{
Console.WriteLine("Insertion failed.");
}
break;
}*/
default:
Console.WriteLine("count={0}", count);
Console.ReadLine();
return;
}
}
Console.ReadLine();
}
public void SaveExpense(Expense expense)
{
var context = new ExpenseDataContext(this.account);
ExpenseEntity expenseRow = expense.ToTableEntity();
foreach (var expenseItem in expense.Details)
{
var expenseItemRow = expenseItem.ToTableEntity(expenseRow.PartitionKey, expense.Id);
context.AddObject(AzureStorageNames.ExpenseTable, expenseItemRow);
}
context.AddObject(AzureStorageNames.ExpenseTable, expenseRow);
context.SaveChanges(SaveChangesOptions.Batch);
foreach (var expenseItem in expense.Details)
{
// save receipt image if any
if (expenseItem.Receipt != null && expenseItem.Receipt.Length > 0)
{
this.receiptStorage.AddReceipt(expenseItem.Id, expenseItem.Receipt, string.Empty);
var queue = new AzureQueue<NewReceiptMessage>(this.account, AzureStorageNames.NewReceiptMessage);
queue.AddMessage(new NewReceiptMessage
{
ExpenseItemId = expenseItem.Id,
ExpenseId = expense.Id,
Username = expense.UserName
});
}
}
}
public void UpdateApproved(Expense expense)
{
var context = new ExpenseDataContext(this.account);
IExpenseEntity expenseRow = GetExpenseRowById(context, expense.UserName, expense.Id);
expenseRow.Approved = expense.Approved;
var queue = new AzureQueue<ApprovedExpenseMessage>(this.account, AzureStorageNames.ApprovedExpenseMessage);
queue.AddMessage(new ApprovedExpenseMessage { ExpenseId = expense.Id, ApproveDate = DateTime.UtcNow, Username = expense.UserName });
context.UpdateObject(expenseRow);
context.SaveChanges();
}
public void GetAndUpdateMessage()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var queue = new AzureQueue<MessageForTests>(account, "messagefortests", TimeSpan.FromSeconds(1));
var message = new MessageForTests { Content = "content" };
queue.Clear();
queue.AddMessage(message);
var retrievedMessage = queue.GetMessage();
Assert.AreEqual("content", retrievedMessage.Content);
retrievedMessage.Content = "newContent";
queue.UpdateMessage(retrievedMessage);
// wait 1 second
Thread.Sleep(1000);
retrievedMessage = queue.GetMessage();
Assert.AreEqual("newContent", retrievedMessage.Content);
}
public void DeleteMessageThrowIfMessageRefIsNull()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var queue = new AzureQueue<MessageForTests>(account);
var message = new MessageForTests { Content = "content" };
queue.DeleteMessage(message);
}
public void UpdateMessageThrowIfTryToUpdateOtherMessageType()
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var queue = new AzureQueue<MessageForTests>(account, "messagefortests", TimeSpan.FromSeconds(1));
queue.UpdateMessage(new OtherMessage());
}
public static void Initialize(TestContext context)
{
var account = CloudConfiguration.GetStorageAccount("DataConnectionString");
var newSurveyAnswerQueue = new AzureQueue<MessageForTests>(account);
newSurveyAnswerQueue.EnsureExist();
}
