public ActionResult Index(SendViewModel model)
{
if (ModelState.IsValid)
{
if (model.SendBy == 0)
{
HostingEnvironment.QueueBackgroundWorkItem(ct => MessageSender.SendAsync(model));
}
else if (model.SendBy == 1)
{
BackgroundJob.Enqueue(() => MessageSender.SendWithEvent(model));
}
else
{
//TODO send queue message to use WebJobs
var storageAccount = CloudStorageAccount.Parse(
ConfigurationManager.ConnectionStrings["AzureWebJobsStorage"].ConnectionString);
var queueClient = storageAccount.CreateCloudQueueClient();
var queue = queueClient.GetQueueReference("pending-mail");
// Create the queue if it doesn't already exist
queue.CreateIfNotExists();
var message = new CloudQueueMessage(JsonConvert.SerializeObject(model));
queue.AddMessage(message);
}
return(RedirectToAction("Pending"));
}
return(View(model));
}
private async Task EnvoieAsync(int id)
{
int tentativeEnvoie = 0;
bool reussite = false;
string idUser = User.FindFirstValue(ClaimTypes.NameIdentifier);
while (!reussite)
{
if (estValide())
{
SendViewModel.SetStatus(context, id, "Réussis");
reussite = true;
}
else
{
tentativeEnvoie++;
SendViewModel.SetStatus(context, id, "En cours, Tentative " + tentativeEnvoie);
}
if (tentativeEnvoie == 3)
{
SendViewModel.SetStatus(context, id, "Échec et Remboursé");
CustomUser utilisateur;
using (ApplicationDbContext database = new ApplicationDbContext(context))
{
utilisateur = database.Users.First(u => u.Id == idUser);
utilisateur.Solde += 1;
database.SaveChanges();
}
reussite = true;
}
Task.Delay(tempsAttente());
}
}
public async Task <IActionResult> SendAsync(SendViewModel model)
{
if (model.OpportunityIds == null || model.OpportunityIds.Count == 0)
{
TempData["Messages"] = "No opportunities selected, no newsletters delivered.";
return(RedirectToAction(nameof(Index)));
}
var opportunities = await MemoryCacheImpl.GetOpportunitiesAcceptingApplications(_memory, _context);
var html = GenerateSendGridHtmlFromOpportunities(
opportunities
.Where(x => model.OpportunityIds.Contains(x.Id))
.ToList());
var response = await _sendgridClient.SendNewsletterAsync(html);
var res = await response.Body.ReadAsStringAsync();
if (response.StatusCode.Equals(HttpStatusCode.Accepted) ||
response.StatusCode.Equals(HttpStatusCode.OK))
{
TempData["Messages"] = "Newsletter successfully sent";
}
return(RedirectToAction(nameof(Index)));
}
public ActionResult Send()
{
SendViewModel viewModel = new SendViewModel();
SetupSendViewModel(viewModel);
return(View(viewModel));
}
public SendMessageView()
{
InitializeComponent();
BindingContext = new SendViewModel(this)
{
Navigation = this.Navigation
};
}
public SendPage()
{
ISenderBluetoothService service = DependencyService.Get <ISenderBluetoothService>();
SendViewModel viewModel = new SendViewModel(service);
this.BindingContext = viewModel;
InitializeComponent();
}
public SendPage(BottomTabbedPage tabbedContext)
{
InitializeComponent();
BindingContext =
SendViewModel =
new SendViewModel(this, tabbedContext);
}
public void Initialize(Asset asset, UserAsset userAsset, Rate rate)
{
Asset = asset;
UserAsset = userAsset;
Rate = rate;
SendViewModel.Initialize(asset, userAsset);
ReceiveViewModel.Initialize(this);
TransferViewModel.Initialize(asset, userAsset);
}
public IActionResult Index()
{
var model = new List <SendViewModel>();
foreach (SendViewModel item in SendViewModel.getTelecopies(context, User.FindFirstValue(ClaimTypes.NameIdentifier)))
{
model.Add(item);
}
return(View("Index", model));
}
public static void SendWithEvent(SendViewModel model)
{
try
{
var smtpClient = new SmtpClient("smtp.sendgrid.net");
smtpClient.Credentials = GetCredential();
smtpClient.SendCompleted += smtpClient_SendCompleted;
smtpClient.SendAsync(GetMailMessage(model), null);
}
catch (Exception ex)
{
Trace.TraceError(ex.Message);
}
}
public ActionResult Send(SendViewModel sendReq)
{
var target = dbManager.Users.First(u => u.UserName == sendReq.UserName);
CheckManager checkManager = new CheckManager(target.UserName);
string targPath = Infrastructure.GetUsersDirectory(target.UserName);
string srcPath = Infrastructure.GetUsersDirectory(User.Identity.Name);
System.IO.File.Copy(srcPath, targPath);
Infrastructure.Logger.Info("{0} copied succ to {1}", srcPath, targPath);
return(View("SendSuccess"));
}
public IActionResult OnPostAddTask(string nom, string adresse, string NuméroTelecopieur)
{
BlobController blob = new BlobController();
string fileName = "";
if (HttpContext.Request.Form.Files != null)
{
var files = HttpContext.Request.Form.Files;
foreach (var file in files)
{
if (file.Length > 0)
{
fileName = file.FileName;
blob.Post(file);
}
}
}
string idUser = User.FindFirstValue(ClaimTypes.NameIdentifier);
int id = SendViewModel.insert(context, nom, adresse, NuméroTelecopieur, fileName, "En cours", idUser);
string view;
CustomUser utilisateur;
using (ApplicationDbContext database = new ApplicationDbContext(context))
{
utilisateur = database.Users.First(u => u.Id == idUser);
if (utilisateur.Solde != 0)
{
utilisateur.Solde -= 1;
database.SaveChanges();
Queue.QueueBackgroundWorkItem(async token =>
{
await EnvoieAsync(id);
});
var model = new List <SendViewModel>();
foreach (SendViewModel item in SendViewModel.getTelecopies(context, User.FindFirstValue(ClaimTypes.NameIdentifier)))
{
model.Add(item);
}
return(View("Index", model));
}
else
{
return(View("soldeInsufisant"));
}
}
}
public ActionResult Send(SendViewModel viewModel)
{
if (ModelState.IsValid)
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
SetupSendViewModel(viewModel);
UserBankAccount fromAccount = ctx.UserBankAccounts.FirstOrDefault(a => a.AccountId == viewModel.SenderAccountId && a.UserId == currentUser.UserId);
UserBankAccount toAccount = ctx.UserBankAccounts.AsNoTracking().FirstOrDefault(u => u.User.Email == viewModel.ReciverName && u.Currency == fromAccount.Currency);
if (viewModel.Amount > fromAccount.Amount)
{
ModelState.AddModelError("", "Insuficient funds");
}
else if (toAccount == null)
{
ModelState.AddModelError("", "Reciver don`t have an account in this currency or doesn`t exist");
}
else
{
fromAccount.Amount -= viewModel.Amount;
toAccount.Amount += viewModel.Amount;
ctx.SaveChanges();
UserTransaction userTransaction = new UserTransaction
{
Amount = viewModel.Amount,
FromAccountId = fromAccount.AccountId,
ToAccountId = toAccount.AccountId,
CurrencyRate = 0,
TransactionDate = DateTime.Now
};
ctx.UserTransactions.Add(userTransaction);
ctx.SaveChanges();
ViewBag.successMessage = "Transaction successful";
return(View(viewModel));
}
}
}
return(View(viewModel));
}
private static MailMessage GetMailMessage(SendViewModel model)
{
var myMessage = new MailMessage();
myMessage.From = string.IsNullOrEmpty(model.FromName)
? new MailAddress(model.FromEmail)
: new MailAddress(model.FromEmail, model.FromName);
myMessage.To.Add(model.ToEmail);
myMessage.Subject = model.Subject;
//Add the HTML and Text bodies
myMessage.IsBodyHtml = false;
myMessage.Body = model.Body;
return(myMessage);
}
public static async Task SendAsync(SendViewModel model)
{
try
{
var smtpClient = new SmtpClient("smtp.sendgrid.net");
smtpClient.Credentials = GetCredential();;
await smtpClient.SendMailAsync(GetMailMessage(model));
if (NotifyCompleted != null)
{
await NotifyCompleted();
}
}
catch (Exception ex)
{
Trace.TraceError(ex.Message);
}
}
private void SetupSendViewModel(SendViewModel viewModel)
{
using (CryptowalletDbContext ctx = new CryptowalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
List <BankAccountViewModel> accounts = ctx.UserBankAccounts.Where(a => a.UserId == currentUser.UserId).Select(u => new BankAccountViewModel
{
AccountID = u.AccountId,
Amount = u.Amount,
Currency = u.Currency
}).ToList();
viewModel.SenderAccounts.AddRange(accounts.Select(a => new SelectListItem
{
Value = a.AccountID.ToString(),
Text = a.Currency
}));
}
}
private void SetupSendViewModel(SendViewModel viewModel)
{
using (CryptoWalletDBContext ctx = new CryptoWalletDBContext())
{
List <UserBankAccount> accounts = ctx.Users.FirstOrDefault(u => u.Email == User.Identity.Name).UserBankAccounts.ToList();
List <BankAccountViewModel> accountsViewModel = accounts.Select(a => new BankAccountViewModel
{
AccountId = a.AccountId,
Amount = a.Amount,
Currency = a.Currency
}).ToList();
viewModel.Currencies.AddRange(accountsViewModel.Select(a => new SelectListItem
{
Value = a.Currency.ToString(),
Text = a.AccountId.ToString() + "( " + a.Currency + " )"
}));
}
}
public SendView()
{
InitializeComponent();
DataContext = new SendViewModel();
}
// This function will get triggered/executed when a new message is written
// on an Azure Queue called queue.
public async static Task ProcessMailQueueMessage([QueueTrigger("pending-mail")] SendViewModel model, TextWriter log)
{
await MessageSender.SendAsync(model);
await log.WriteLineAsync(string.Format("from: {0} , to: {1}", model.FromEmail, model.ToEmail));
}
public SendPage(SendViewModel sendViewModel)
{
InitializeComponent();
BindingContext = sendViewModel;
}
public ActionResult Send(SendViewModel viewModel)
{
if (ModelState.IsValid)
{
using (CryptoWalletDBContext ctx = new CryptoWalletDBContext())
{
User fromUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
User toUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == viewModel.ToUserEmail);
if (toUser != null)
{
if (fromUser.UserId == toUser.UserId)
{
ModelState.AddModelError("", "You can not send yourself!");
SetupSendViewModel(viewModel);
return(View(viewModel));
}
UserBankAccount toAccount = ctx.UsersBankAccounts.FirstOrDefault(u => u.Currency == viewModel.Currency && u.UserId == toUser.UserId);
UserBankAccount fromAccount = ctx.UsersBankAccounts.FirstOrDefault(u => u.Currency == viewModel.Currency && u.UserId == fromUser.UserId);
if (toAccount == null)
{
ModelState.AddModelError("", "The receiver does not have an account!");
SetupSendViewModel(viewModel);
return(View(viewModel));
}
if (fromAccount.Amount > viewModel.Amount)
{
fromAccount.Amount -= viewModel.Amount;
toAccount.Amount += viewModel.Amount;
UserTransaction transaction = new UserTransaction
{
Amount = viewModel.Amount,
ToAccountId = toAccount.AccountId,
FromAccountId = fromAccount.AccountId,
TransactionDate = DateTime.Now,
TransactionRate = 1,
ToAccount = toAccount,
FromAccount = fromAccount
};
ctx.UsersTransactions.Add(transaction);
ctx.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Insufficient funds!");
SetupSendViewModel(viewModel);
return(View(viewModel));
}
}
else
{
ModelState.AddModelError("", "Invalid friend's email!");
SetupSendViewModel(viewModel);
return(View(viewModel));
}
}
}
SetupSendViewModel(viewModel);
return(View(viewModel));
}
public SendPage(SendViewModel viewModel)
{
viewModel.Navigation = Navigation;
BindingContext = viewModel;
Title = "Send";
Icon = "send.png";
MessagingCenter.Subscribe <SendViewModel, bool>(this, "EmailSent", (arg1, sent) => {
Device.BeginInvokeOnMainThread(() => {
if (sent)
{
DisplayAlert("Success", "Email sent succesfully", "Ok");
}
else
{
DisplayAlert("Failed", "Email failed to send", "Ok");
}
});
}, viewModel);
var toEntry = new BorderlessEntry {
Placeholder = string.Empty,
Keyboard = Keyboard.Default,
BackgroundColor = Color.Transparent,
HorizontalOptions = LayoutOptions.FillAndExpand,
HeightRequest = 30
};
toEntry.SetBinding <SendViewModel> (BorderlessEntry.TextProperty, m => m.To, BindingMode.TwoWay);
var subjectEntry = new BorderlessEntry {
Placeholder = string.Empty,
Keyboard = Keyboard.Default,
BackgroundColor = Color.Transparent,
HorizontalOptions = LayoutOptions.FillAndExpand,
HeightRequest = 30
};
subjectEntry.SetBinding <SendViewModel> (BorderlessEntry.TextProperty, m => m.Subject, BindingMode.TwoWay);
var bodyEditor = new Editor {
Keyboard = Keyboard.Default,
HeightRequest = 200
};
bodyEditor.SetBinding <SendViewModel> (Editor.TextProperty, m => m.Body, BindingMode.TwoWay);
var button = new Button()
{
Text = "Send",
BackgroundColor = Helpers.Color.Blue.ToFormsColor(),
TextColor = Color.White
};
button.SetBinding <SendViewModel> (Button.CommandProperty, m => m.SendEmailCommand);
Content = new StackLayout {
Children =
{
new TableView {
Intent = TableIntent.Form,
Root = new TableRoot(string.Empty)
{
new TableSection("New Message")
{
new ViewCell {
View = new StackLayout{
Children =
{
new Label {
Text = "To: ",
FontSize = 15,
HeightRequest = 30
},
toEntry
},
Orientation = StackOrientation.Horizontal,
Padding = new Thickness(10)
}
},
new ViewCell {
View = new StackLayout{
Children =
{
new Label {
Text = "Subject: ",
FontSize = 15,
HeightRequest = 30
},
subjectEntry
},
Orientation = StackOrientation.Horizontal,
Padding = new Thickness(10)
}
},
new ViewCell {
View = new StackLayout{
Children =
{
bodyEditor
},
HeightRequest = 200,
Padding = new Thickness(10)
},
Height = 220
}
}
},
HasUnevenRows = true,
},
new StackLayout {
Children =
{
button
},
Padding = new Thickness(10)
}
}
};
}
public ActionResult Send(SendViewModel viewModel)
{
if (ModelState.IsValid)
{
using (CryptoWalletDbContext ctx = new CryptoWalletDbContext())
{
User currentUser = ctx.Users.AsNoTracking().FirstOrDefault(u => u.Email == User.Identity.Name);
User receiverEmail = ctx.Users.AsNoTracking().FirstOrDefault(x => x.Email == viewModel.ReceiverName);
if (receiverEmail == null)
{
ModelState.AddModelError("", "The email is invalid.");
SetupSendViewModel(viewModel);
return(View(viewModel));
}
UserBankAccount fromAccount = ctx.UserBankAccounts.FirstOrDefault(a => a.AccountId.ToString() == viewModel.SenderAccountId);
UserBankAccount toAccount = ctx.UserBankAccounts.FirstOrDefault(a => a.Currency == fromAccount.Currency && a.UserId == receiverEmail.UserId);
if (fromAccount == null)
{
ModelState.AddModelError("", "The currency of the sender does not match.");
SetupSendViewModel(viewModel);
return(View(viewModel));
}
if (toAccount == null)
{
ModelState.AddModelError("", "The currency of the receiver does not match.");
SetupSendViewModel(viewModel);
return(View(viewModel));
}
if (fromAccount.Amount < viewModel.Amount)
{
ModelState.AddModelError("", "Insufficient funds.");
SetupSendViewModel(viewModel);
return(View(viewModel));
}
fromAccount.Amount -= viewModel.Amount;
toAccount.Amount += viewModel.Amount;
UserTransaction transaction = new UserTransaction
{
Amount = viewModel.Amount,
FromAccountId = fromAccount.AccountId,
ToAccountId = toAccount.AccountId,
TransactionDate = DateTime.Now,
CurrencyRate = 1,
FromAccount = fromAccount,
ToAccount = toAccount
};
ctx.UserTransactions.Add(transaction);
ctx.SaveChanges();
return(RedirectToAction("Index"));
}
}
return(View(viewModel));
}
public ActionResult Send(SendViewModel sendView, string packagePath)
{
if (!string.IsNullOrEmpty(sendView.PackagePath))
{
ModelState["EncryptedPackage"].Errors.Clear();
if (ModelState.IsValid)
{
// Setup sessions options
SessionOptions currentSFTPSession = SFTPManager.CreateSFTPSession(sendView.SFTPServer, sendView.SFTPUsername, sendView.SFTPPassword);
string sftpUpName = packagePath;
try
{
string transferResult = SFTPManager.UploadFile(currentSFTPSession, sftpUpName);
ViewBag.Message = transferResult;
}
catch (Exception e)
{
ViewBag.Message = e.Message;
}
return(View("~/Views/Shared/Info.cshtml"));
}
else
{
return(View(sendView));
}
}
else
{
// File got uploaded from the user
ModelState["PackagePath"].Errors.Clear();
if (ModelState.IsValid)
{
string dir = Server.MapPath("~/App_Data/Send/");
string tempPackagePath = Path.Combine(dir, sendView.EncryptedPackage.FileName);
// Save xml report to the disk
sendView.EncryptedPackage.SaveAs(tempPackagePath);
// Setup sessions options
SessionOptions currentSFTPSession = SFTPManager.CreateSFTPSession(sendView.SFTPServer, sendView.SFTPUsername, sendView.SFTPPassword);
string sftpUpName = tempPackagePath;
try
{
string transferResult = SFTPManager.UploadFile(currentSFTPSession, sftpUpName);
ViewBag.Message = transferResult;
}
catch (Exception e)
{
ViewBag.Message = e.Message;
}
return(View("~/Views/Shared/Info.cshtml"));
}
else
{
return(View(sendView));
}
}
}