public ActionResult RegisterRequest(RegisterRequestViewModel model)
{
if (ModelState.IsValid)
{
FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF();
// TODO:deny multiple requests from the same ip address
// TODO: make temporary encrypted url that holds => timeCreated,email,role,address,division
char separator = (char)31; // ASCII char 31 is the separator character
string urlParamStr = DateTime.UtcNow.Ticks.ToString() + separator
+ model.Email + separator
+ model.address.ToString() + separator
+ model.division.ToString();
string urlParamStrB64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(urlParamStr));
// posts notification
db_manager.Notifications.Add(new Notification()
{
notifyType = AppSettings.Notify.newUser,
notifyText = model.Email,
Email = model.Email,
Address = db_manager.Addresses.FirstOrDefault(m => m.Id == model.address),
Division = db_manager.Divisions.FirstOrDefault(m => m.Id == model.division),
timeStamp = DateTime.UtcNow
});
db_manager.SaveChanges();
Mail.send(model.Email, "Request Recieved", "Dear user your request has been recieved and an administrator will be looking at your request soon, so please be patient.");
return(Redirect(Url.Action("RegisterRequestCompletion")));
}
return(RegisterRequest());
}
public ActionResult Completed()
{
if (HttpContext.Request.UrlReferrer != null) // comes from another site
{
return(new HttpNotFoundResult());
}
List <Transaction> boughtItems;
SessionSaver.Load.transactions(Session, out boughtItems);
using (FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF())
{
string email = User.Identity.Name;
Models.User usr = db_manager.Users.FirstOrDefault(m => m.Email == email);
for (int i = 0; i < boughtItems.Count; i++)
{
boughtItems[i].purchaserId = usr.Id;
boughtItems[i].purchaseDate = DateTime.Now;
db_manager.Transactions.Add(boughtItems[i]);
}
db_manager.SaveChanges();
}
Session[AppSettings.SessionVariables.TRANSACTION] = null; // reset the cart
return(View(new VM.CompletedViewModel()
{
boughtItems = boughtItems
}));
}
public ActionResult Index(long?Id)
{
using (FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF())
{
if (Session[AppSettings.SessionVariables.CATEGORY] != null)
{ // if session var exists remove product from session var
List <Category> products = (List <Category>)Session[AppSettings.SessionVariables.CATEGORY];
products.Remove(products.FirstOrDefault(m => m.Id == Id));
Session[AppSettings.SessionVariables.CATEGORY] = products;
}
Category category = db_manager.Categories.Single(m => m.Id == Id);
db_manager.Categories.Remove(category);
db_manager.SaveChanges();
}
return(View());
}
/// <summary>
///
/// </summary>
/// <param name="Session"></param>
/// <param name="product">.Id must be valid</param>
public static void product(TempDataDictionary TempData, Product product)
{
// Update Database
Product db_product;
using (FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF())
{
db_product = db_manager.Products.Include(AppSettings.Includes.Category).FirstOrDefault(m => m.Id == product.Id);
if (db_product != null)
{
db_product.name = product.name;
db_product.price = product.price;
db_product.categoryId = product.categoryId;
db_manager.Entry(db_product);
db_manager.SaveChanges();
}
}
if (db_product != null)
{
db_product.Category = product.Category;
// Update session
List <Product> products;
Load.products(TempData, out products);
Product tmpProd = products.FirstOrDefault(m => m.Id == product.Id);
if (tmpProd != null)
{
int indexTmpProd = products.IndexOf(tmpProd);
products[indexTmpProd] = db_product;
}
// Update session combobox
List <SelectListItem> productsCombobox;
Load.productsCombobox(TempData, out productsCombobox);
SelectListItem tmpSLI = productsCombobox.FirstOrDefault(m => m.Value == db_product.Id.ToString());
if (tmpSLI != null)
{
int indexTmpSLI = productsCombobox.IndexOf(tmpSLI);
productsCombobox[indexTmpSLI] = new SelectListItem()
{
Text = db_product.name, Value = db_product.Id.ToString()
};
}
}
}
/// <summary>
///
/// </summary>
/// <param name="Session"></param>
/// <param name="category">.Id must be valid</param>
public static void category(TempDataDictionary TempData, Category category)
{
Category db_category;
// Update Database
using (FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF())
{
db_category = db_manager.Categories.FirstOrDefault(m => m.Id == category.Id);
if (db_category != null)
{
db_category.name = category.name;
db_manager.Entry(db_category);
db_manager.SaveChanges();
}
}
// Update session
List <Category> categories;
Load.categories(TempData, out categories);
Category tmpCategory = categories.FirstOrDefault(m => m.Id == db_category.Id);
if (tmpCategory != null)
{
int indexTmpProd = categories.IndexOf(tmpCategory);
categories[indexTmpProd] = db_category;
}
// Update session combobox
List <SelectListItem> productsCombobox;
Load.categoriesCombobox(TempData, out productsCombobox);
SelectListItem tmpSLI = productsCombobox.FirstOrDefault(m => m.Value == db_category.Id.ToString());
if (tmpSLI != null)
{
int indexTmpSLI = productsCombobox.IndexOf(tmpSLI);
productsCombobox[indexTmpSLI] = new SelectListItem()
{
Text = db_category.name, Value = db_category.Id.ToString()
};
}
}
public static void transaction(HttpSessionStateBase Session, Transaction transaction)
{
// Update Database
using (FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF())
{
db_manager.Entry(transaction);
db_manager.SaveChanges();
}
// Update session
List <Transaction> transactions;
Load.transactions(Session, out transactions, false);
Transaction tmpTransaction = transactions.FirstOrDefault(m => m.Id == transaction.Id);
if (tmpTransaction != null)
{
int indexTmpProd = transactions.IndexOf(tmpTransaction);
transactions[indexTmpProd] = transaction;
}
// no combobox needed
}
public async Task <ActionResult> Setup(SetupViewModel model)
{
if (ModelState.IsValid)
{
// dispose of quickly
using (FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF())
{
if (db_manager.Users.Count() != 0)
{
return(new HttpNotFoundResult());
}
}
if (TempData.ContainsKey("Setup") && Session["SetupUser"] == null)
{
return(new HttpNotFoundResult());
}
Address address;
Division division;
using (FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF())
{
address = db_manager.Addresses.Add(model.Address);
division = db_manager.Divisions.Add(model.Division);
foreach (var item in AppSettings.Roles.ComboBox)
{
db_manager.Roles.Add(new Role()
{
Name = item.Value
});
}
try
{
db_manager.SaveChanges();
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
Trace.TraceInformation("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);
}
}
}
}
AccountUser user = new AccountUser
{
UserName = model.Email,
Email = model.Email,
Address = address.Id,
Division = division.Id,
TimeZoneOffset = DateTime.UtcNow,// TODO: change to hours of offset
CreationDate = DateTime.UtcNow
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// create or add role
UserManager.AddToRole(UserManager.FindByEmail(model.Email).Id, AppSettings.Roles.CONGRESS);
await SignInAsync(user, false);
return(RedirectToAction("Index", "Manage")); // redirect to manage home
}
AddErrors(result);
return(View(model));
}
return(Setup());
}
public ActionResult Notify(NotifyViewModel model, string submitButton, string id, long?Role)
{
if (User.IsInRole(AppSettings.Roles.APPROVEDUSER) || User.IsInRole(AppSettings.Roles.AUDITORS))
{
return(new HttpNotFoundResult());
}
if (model.Role == null)
{
return(View(model)); // redisplay the view if error
}
long role = (long)model.Role;
if (Role != null)
{
role = (long)Role;
}
model.notifyList = (List <Notification>)Session["notifyListDB"];
model.Role = (long)Session["roleResult"];
model.Roles = (List <SelectListItem>)Session["RolesList"];
long result;
if (!long.TryParse(id, out result))
{
return(View(model));
}
FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF();
// get notification
Notification oldNotify = db_manager.Notifications.FirstOrDefault(m => m.Id == result);
switch (submitButton)
{
case "Resend Notification":
//send email to new user
Mail.send(
oldNotify.Email,
"Access Approved",
"here is the link to sign up this link will only be available for so long - "
+ "https://"
+ HttpContext.Request.Url.Authority
+ Url.Action("Register", "Account")
+ "?rqst="
+ UrlEncryption.Encrypt(
DateTime.UtcNow,
oldNotify.Email,
oldNotify.AddressId,
oldNotify.DivisionId,
role));
ViewBagHelper.setMessage(ViewBag, ViewBagHelper.MessageType.SuccessMsgBox, "New user request resent to \"" + oldNotify.Email + "\"");
return(NotifyView());
case "Accept":
if (oldNotify.notifyType.Equals(AppSettings.Notify.newUser))
{
//send email to new user
Mail.send(
oldNotify.Email,
"Access Approved",
"here is the link to sign up this link will only be available for so long - "
+ "https://"
+ HttpContext.Request.Url.Authority
+ Url.Action("Register", "Account")
+ "?rqst="
+ UrlEncryption.Encrypt(
DateTime.UtcNow,
oldNotify.Email,
oldNotify.AddressId,
oldNotify.DivisionId,
role));
oldNotify.notifyType = AppSettings.Notify.pendingUser;
oldNotify.Role = db_manager.Roles.FirstOrDefault(m => m.Id == role).Name;
db_manager.Entry(oldNotify);
db_manager.SaveChanges();
db_manager.Dispose();
}
return(NotifyView());
case "Deny":
// send denial email to user
Mail.send(oldNotify.Email, "Denied Access", "Appologies user you have been denied access by administration to the application.");
model.notifyList.Remove(model.notifyList.First(m => m.Id == result)); // remove from current model
db_manager.Notifications.Remove(oldNotify);
break;
default:
break;
}
db_manager.SaveChanges();
db_manager.Dispose();
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
AccountUser user = new AccountUser
{
UserName = model.Email,
Email = model.Email,
Address = (long)Session["AddressResult"],
Division = (long)Session["DivisionResult"],
TimeZoneOffset = DateTime.UtcNow,// TODO: change to hours of offset
CreationDate = DateTime.UtcNow
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// create or add role
if (!RoleManager.RoleExists(model.Role))
{
var roleResult = await RoleManager.CreateAsync(new AccountRole()
{
Name = model.Role
});
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "Error in creating account please contact administrator");
return(View(model));
}
}
UserManager.AddToRole(UserManager.FindByEmail(model.Email).Id, model.Role);
await SignInAsync(user, false);
// check if notification is in table (if so remove)
using (FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF())
{
Notification notify = db_manager.Notifications.FirstOrDefault(m => m.Email == user.Email);
if (notify != null)
{
db_manager.Notifications.Remove(notify);
db_manager.SaveChanges();
}
}
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
/// <summary>
/// Displays the transactions view as well as acts as post back to add items
/// </summary>
/// <param name="model"></param>
/// <param name="productId"></param>
/// <returns></returns>
public ActionResult RequestTransaction(VM.RequestTransactionViewModel model, string Id)
{
if (Id != null)
{
long id;
if (long.TryParse(Id, out id))
{
Session[AppSettings.SessionVariables.TRANSACTION] = null;
using (FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF())
{
Notification notify = db_manager.Notifications.FirstOrDefault(m => m.notifyText == Id);
db_manager.Notifications.Remove(notify);
var transS = db_manager.TransactionRequests;
db_manager.TransactionRequests.RemoveRange(transS);
List <TransactionRequest> transR = transS.ToList();
transR = transR.FindAll(m => m.cartId == id).ToList();
foreach (var item in transR)
{
var itemProd = db_manager.Products.FirstOrDefault(m => m.Id == item.productId);
SessionSaver.Add.transaction(Session, new Transaction()
{
productId = item.productId,
quantity = item.quantity,
unitPrice = item.unitPrice,
purchaseDate = DateTime.UtcNow,
requestedForUserId = null,
Product = itemProd,
isDeleted = false
});
}
db_manager.SaveChanges();
}
}
}
else if (model.productId != null && model.quantity != null)
{
if (model.quantity <= 0)
{
ViewBagHelper.setMessage(ViewBag, ViewBagHelper.MessageType.WarningMsgBox, "Cannot create a product with a quantity of " + model.quantity);
}
else
{
List <Transaction> trans;
SessionSaver.Load.transactions(Session, out trans);
Transaction transactionValidate = trans.FirstOrDefault(m => m.productId == model.productId);
if (transactionValidate != null)
{
transactionValidate.quantity += (int)model.quantity;
}
else
{
// get unit price from database
Product db_product;
decimal db_unitPrice;
using (FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF())
{
db_unitPrice = db_manager.Products.FirstOrDefault(m => m.Id == model.productId).price;
db_product = db_manager.Products.Include(AppSettings.Includes.Category).FirstOrDefault(m => m.Id == model.productId);
}
// create transaction (still need to add cartId on checkout)
Transaction transaction = new Transaction()
{
purchaseDate = DateTime.UtcNow,
requestedForUserId = null,
quantity = (int)model.quantity,
unitPrice = db_unitPrice,
productId = (long)model.productId,
Product = db_product,
isDeleted = false // on creating transaction it starts as not deleted
};
SessionSaver.Add.transaction(Session, transaction); // add to session
}
}
}
else
{
model = new VM.RequestTransactionViewModel();
}
List <Product> ProductTable;
using (FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF())
{
ProductTable = db_manager.Products.Include(AppSettings.Includes.Category).ToList();
}
model.ProductTable = ProductTable;
List <Transaction> transactions;
SessionSaver.Load.transactions(Session, out transactions);
model.SelectedProductTable = transactions;
return(View(model));
}
public ActionResult RequestTransaction(string submit)
{
switch (submit)
{
case "Checkout":
if (!(User.IsInRole(AppSettings.Roles.PURCHASINGAGENT) || User.IsInRole(AppSettings.Roles.CONGRESS)))
{
return(new HttpNotFoundResult());
}
long cartId = getCartId();
List <Transaction> trans;
SessionSaver.Load.transactions(Session, out trans);
paypal.ItemList paypalItems = new paypal.ItemList();
paypalItems.items = new List <PayPal.Api.Item>();
decimal sum = 0;
for (int i = 0; i < trans.Count; i++)
{
trans[i].cartId = cartId;
trans[i].unitPrice = trans[i].Product.price;
sum += (trans[i].unitPrice * trans[i].quantity);
paypalItems.items.Add(new PayPal.Api.Item()
{
name = trans[i].Product.name,
currency = "USD",
price = trans[i].unitPrice.ToString("0.00"),
tax = "0",
sku = trans[i].productId.ToString(),
quantity = trans[i].quantity.ToString()
});
}
paypal.Transaction transaction = new PayPal.Api.Transaction()
{
description = "User added description",
invoice_number = cartId.ToString(),
amount = new paypal.Amount()
{
currency = "USD",
total = sum.ToString("0.00"),
details = new paypal.Details()
{
tax = "0",
shipping = "0",
subtotal = sum.ToString("0.00")
}
},
item_list = paypalItems
};
paypal.APIContext apiContext = PayPalHelper.GetAPIContext();
try
{
string payerId = Request.Params["PayerID"];
if (string.IsNullOrEmpty(payerId))
{
string baseURI = Request.Url.Scheme + "://" + Request.Url.Authority;
var guid = Convert.ToString((new Random()).Next(100000));
var createdPayment = PayPalHelper.CreatePayment(apiContext, baseURI + Url.Action("RequestTransaction", "Transaction") + "?guid=" + guid, baseURI + Url.Action("Completed", "Transaction"), transaction);
var links = createdPayment.links.GetEnumerator();
string paypalRedirectUrl = null;
while (links.MoveNext())
{
paypal.Links lnk = links.Current;
if (lnk.rel.ToLower().Trim().Equals("approval_url"))
{
paypalRedirectUrl = lnk.href;
}
}
Session.Add(guid, createdPayment.id);
return(Redirect(paypalRedirectUrl));
}
else
{
var guid = Request.Params["guid"];
var s = Session[guid];
var executedPayment = PayPalHelper.ExecutePayment(apiContext, null, payerId, Session[guid] as string);
if (executedPayment.state.ToLower() != "approved")
{
return(View("PaypalFatal"));
}
}
}
catch (Exception ex)
{
Logger.Log("Error" + ex.Message);
return(View("PaypalFatal"));
}
return(View("Completed"));
case "Request Checkout":
using (FM_Datastore_Entities_EF db_manager = new FM_Datastore_Entities_EF())
{
string email = User.Identity.Name;
User usr = db_manager.Users.FirstOrDefault(m => m.Email == email);
if (usr != null)
{
long userId = usr.Id;
long cartIdRequest = getCartIdTransactionRequests();
List <Transaction> transactLst;
SessionSaver.Load.transactions(Session, out transactLst);
foreach (var item in transactLst)
{
db_manager.TransactionRequests.Add(new TransactionRequest()
{
cartId = cartIdRequest,
productId = item.productId,
quantity = item.quantity,
unitPrice = item.unitPrice,
requestedForUserId = userId
});
}
Session[AppSettings.SessionVariables.TRANSACTION] = null;
db_manager.Notifications.Add(new Notification()
{
Email = usr.Email,
DivisionId = usr.Division,
AddressId = usr.Address,
Address = usr.Address1,
Division = usr.Division1,
timeStamp = DateTime.Now,
notifyType = AppSettings.Notify.pendingTransactionRequest,
notifyText = cartIdRequest.ToString()
});
db_manager.SaveChanges();
}
}
return(Redirect(Url.Action("RequestCompletion")));
default:
break;
}
return(new HttpNotFoundResult());
}
