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;
}
}
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);
}
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 = "" }));
}
public async Task SendNewOrderNotificacion(OrderModel order)
{
var mailMessage = new MailMessage()
{
From = _fromEmail,
To = order.OrderRequestor.Email,
Subject = "[Atomic Limbs] Tu pedido de prótesis fue realizado con éxito",
Body = CompiledTemplateEngine.Render("Mails.NewOrderRequestor", order),
};
if (order.OrderRequestor.HasAlternativeEmail())
{
mailMessage.Cc = order.OrderRequestor.AlternativeEmail;
}
await AzureQueue.EnqueueAsync(mailMessage);
}
public async Task FollowUpAmbassadors([TimerTrigger("0 0 10 * * *", RunOnStartup = true)] TimerInfo myTimer, TextWriter log)
{
var ordersNoChange = await Db.OrderModels.Where(p => p.Status != OrderStatus.Delivered && p.Status != OrderStatus.NotAssigned && p.Status != OrderStatus.Rejected &&
DbFunctions.AddDays(p.StatusLastUpdated, 7) <= DateTime.UtcNow).ToListAsync();
if (ordersNoChange != null && ordersNoChange.Any())
{
MailMessage mailMessage = new MailMessage
{
From = _fromEmail,
Subject = "[Atomic Limbs] ¿Cómo va la impresión de la prótesis?"
};
foreach (var orderInList in ordersNoChange)
{
var order = await Db.OrderModels.Include(x => x.OrderAmbassador).Include(x => x.OrderRequestor).FirstOrDefaultAsync(p => p.Id == orderInList.Id);
if (order == null || (order.OrderAmbassador != null && order.OrderAmbassador.SendFollowUp == false))
{
continue;
}
var modelFollowUp = new FollowUpModel
{
AmbassadorName = order.OrderAmbassador.FullName(),
UserOrderName = order.OrderRequestor.FullName()
};
mailMessage.To = order.OrderAmbassador.Email;
mailMessage.Body = CompiledTemplateEngine.Render("Mails.FollowUpAmbassador", modelFollowUp);
await AzureQueue.EnqueueAsync(mailMessage);
order.StatusLastUpdated = DateTime.UtcNow;
order.LogMessage("Notification had sent (email follow-up) for inactivity in order");
Db.OrderModels.AddOrUpdate(order);
}
await Db.SaveChangesAsync();
}
}
/// <summary>
/// This method is required and can be public but have to have exactly the same signature
/// </summary>
protected virtual object Partial <TPModel>(string className, TPModel model)
{
return(new HtmlString(CompiledTemplateEngine.Render(className, model)));
}
public async Task SendStatusChangeNotification(OrderModel order, OrderStatus oldStatus, OrderStatus newStatus)
{
if (oldStatus == newStatus)
{
return;
}
switch (newStatus)
{
case OrderStatus.NotAssigned:
//No entra nunca
break;
case OrderStatus.PreAssigned:
//Entra por SendAmbassadorChangedNotification
break;
case OrderStatus.Pending:
var mailMessage = new MailMessage
{
From = _fromEmail,
Subject = $"[Atomic Limbs] Aceptaste el pedido (#{order.Id})",
To = order.OrderAmbassador.Email,
Body = CompiledTemplateEngine.Render("Mails.OrderAcceptedToAmbassador", order),
};
await AzureQueue.EnqueueAsync(mailMessage);
mailMessage = new MailMessage
{
From = _fromEmail,
Subject = $"[Atomic Limbs] Pedido aceptado por embajador (#{order.Id})",
To = order.OrderRequestor.Email,
Body = CompiledTemplateEngine.Render("Mails.OrderAcceptedToRequestor", order),
};
await AzureQueue.EnqueueAsync(mailMessage);
break;
case OrderStatus.Ready:
mailMessage = new MailMessage
{
From = _fromEmail,
Subject = $"[Atomic Limbs] Coordinar envío (#{order.Id})",
To = _adminEmails,
Body = CompiledTemplateEngine.Render("Mails.OrderReadyToAdmin", order),
};
await AzureQueue.EnqueueAsync(mailMessage);
mailMessage = new MailMessage
{
From = _fromEmail,
Subject = $"[Atomic Limbs] Coordinar envío (#{order.Id})",
To = order.OrderAmbassador.Email,
Body = CompiledTemplateEngine.Render("Mails.OrderReadyToAmbassador", order),
};
await AzureQueue.EnqueueAsync(mailMessage);
mailMessage = new MailMessage
{
From = _fromEmail,
Subject = $"[Atomic Limbs] Pedido listo (#{order.Id})",
To = order.OrderRequestor.Email,
Body = CompiledTemplateEngine.Render("Mails.OrderReadyToRequestor", order),
};
await AzureQueue.EnqueueAsync(mailMessage);
break;
case OrderStatus.Delivered:
//Entra por SendDeliveryInformationNotification
break;
case OrderStatus.ArrangeDelivery:
//No action
break;
}
}
public async Task <ActionResult> Create(CreateCovidOrganizationViewModel model)
{
if (!ModelState.IsValid)
{
return(Json(new
{
Error = true
}));
}
if (model.Quantity > 500)
{
return(Json(new
{
Error = true,
Msg = "La cantidad del pedido no debe superar las 500 unidades, por mas unidades, contactarse con Atomic Lab"
}));
}
var existingEmail = await Db.CovidOrganizationModels.FirstOrDefaultAsync(p => p.Email == model.Email);
if (existingEmail != null)
{
return(Json(new
{
Error = true,
Msg = "El correo electronico ya se encuentra registrado"
}));
}
var newCovidOrganization = Mapper.Map <CovidOrganizationModel>(model);
Db.CovidOrganizationModels.Add(newCovidOrganization);
await Db.SaveChangesAsync();
var id = newCovidOrganization.Id;
var currentTimeStamp = DateTime.Now.ToString("yyyyMMddHHmmssffff");
byte[] key = Encoding.UTF8.GetBytes($"{Guid.NewGuid():N}-{id}-{currentTimeStamp}");
newCovidOrganization.Token = Convert.ToBase64String(key);
Db.CovidOrganizationModels.AddOrUpdate(newCovidOrganization);
await Db.SaveChangesAsync();
var urlRedirect = Url.Action("Edit", "Covid", new { token = newCovidOrganization.Token }, Request.Url.Scheme);
var covidEmailInfo = new CovidInfoEmail
{
FullName = $"{newCovidOrganization.Name} {newCovidOrganization.Surname}",
Url = urlRedirect,
Quantity = newCovidOrganization.Quantity
};
var mailMessage = new MailMessage
{
From = _fromEmail,
To = newCovidOrganization.Email,
Subject = "[Atomic Limbs] Tu pedido de mascarillas fue realizado con éxito",
Body = CompiledTemplateEngine.Render("Mails.NewOrderCovid", covidEmailInfo),
};
await AzureQueue.EnqueueAsync(mailMessage);
return(Json(new
{
UrlRedirect = urlRedirect,
Error = false
}));
}
public async Task <ActionResult> Edit(EditCovidOrganizationViewModel model)
{
if (!ModelState.IsValid)
{
return(Json(new
{
Error = true
}));
}
var covidOrganization = await Db.CovidOrganizationModels.FirstOrDefaultAsync(p => p.Token == model.Token);
if (covidOrganization == null)
{
return(Json(new
{
Error = true,
Msg = "El pedido no existe, recargue la página."
}));
}
bool sendEmail = false;
string previousEmail = string.Empty;
if (model.Email != covidOrganization.Email)
{
var existingEmail = await Db.CovidOrganizationModels.FirstOrDefaultAsync(p => p.Email == model.Email && p.Id != model.Id);
if (existingEmail != null)
{
return(Json(new
{
Error = true,
Msg = "El correo electronico ya se encuentra registrado"
}));
}
else
{
previousEmail = model.Email;
sendEmail = true;
}
}
int quantityTmp = covidOrganization.Quantity;
covidOrganization = Mapper.Map <CovidOrganizationModel>(model);
covidOrganization.Quantity = quantityTmp;
var sum = (await Db.CovidOrgAmbassadorModels
.GroupBy(o => o.CovidOrgId).Select(x => new
{
Id = x.Key,
Sum = x.Sum(z => z.Quantity)
}).FirstOrDefaultAsync(f => f.Id == covidOrganization.Id))?.Sum;
var availableDiff = covidOrganization.Quantity - (sum ?? 0);
bool hasDiff = false;
if (model.Quantity < covidOrganization.Quantity && availableDiff < covidOrganization.Quantity)
{
hasDiff = availableDiff != 0;
covidOrganization.Quantity -= availableDiff;
}
else
{
covidOrganization.Quantity = model.Quantity;
}
Db.CovidOrganizationModels.AddOrUpdate(covidOrganization);
await Db.SaveChangesAsync();
if (sendEmail)
{
var urlRedirect = Url.Action("Edit", "Covid", new { token = covidOrganization.Token }, Request.Url.Scheme);
var covidEmailInfo = new CovidUpdateEmail
{
FullName = $"{covidOrganization.Name} {covidOrganization.Surname}",
Url = urlRedirect,
PreviousEmail = previousEmail,
NewEmail = covidOrganization.Email
};
var mailMessage = new MailMessage
{
From = _fromEmail,
To = covidOrganization.Email,
Subject = "[Atomic Limbs] Cambio de correo electrónico",
Body = CompiledTemplateEngine.Render("Mails.UpdateEmailOrderCovid", covidEmailInfo),
};
await AzureQueue.EnqueueAsync(mailMessage);
}
return(Json(new
{
Error = false,
Msg = !hasDiff ? null : $"La cantidad fue reducida a {covidOrganization.Quantity} ya que tiene máscarillas comprometidas por los embajadores"
}));
}
