public async Task <IActionResult> Create(int?id, [Bind("Id,ProductId,PackageTypeId,StoreId,StorePrice,StoreCost,CreatedOn,CreatedBy,UpdatedOn,UpdatedBy")] ProductStoreSpecific productStoreSpecific)
{
productStoreSpecific.Id = 0;
if (ModelState.IsValid)
{
if (User != null)
{
var userFullName = User.Claims.FirstOrDefault(x => x.Type == $"name").Value;
productStoreSpecific.CreatedBy = userFullName;
}
productStoreSpecific.CreatedOn = DateTime.Now;
productStoreSpecific.ProductId = id;
_dbWriteService.Add(productStoreSpecific);
await _dbWriteService.SaveChangesAsync();
var request = await _dbReadService.GetSingleRecordAsync <Request>(s => s.Id.Equals(RequestDto.RequestId));
RequestEmail requestEmail = new RequestEmail(_configuration, _dbReadService);
requestEmail.SendNewRequestToHeadQuarters(request);
return(RedirectToAction("Index", "ProductStoreSpecificProducts", new { id = productStoreSpecific.ProductId }));
}
ViewData["ProductId"] = new SelectList(_context.Product, "Id", "ProductName", productStoreSpecific.ProductId);
return(View(productStoreSpecific));
}
public async Task <IActionResult> CreateRequest([Bind("Id,RequestDescription,RequestTypeId,StatusTypeId,UserId,SupplierId,StoreId,CreatedOn,CreatedBy,UpdatedOn,UpdatedBy")] Request request)
{
if (ModelState.IsValid)
{
if (User != null)
{
string claimTypeEmailAddress = $"http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name";
var userFullName = User.Claims.FirstOrDefault(x => x.Type == $"name").Value;
request.UserId = User.Claims.FirstOrDefault(x => x.Type == claimTypeEmailAddress).Value;
request.CreatedBy = userFullName;
}
request.CreatedOn = DateTime.Now;
var status = await _dbReadService.GetSingleRecordAsync <StatusType>(s => s.StatusTypeName.Equals("New Request"));
request.StatusTypeId = status.Id;
_dbWriteService.Add(request);
await _dbWriteService.SaveChangesAsync();
}
RequestDto.RequestId = request.Id;
return(RedirectToAction("CreateProduct", "Products", new { id = request.Id }));
}
public async Task <IActionResult> Create(int id, bool multiple, [Bind("Id,Quantity,Unit,AlternateProductName,AlternateProductUpccode,SupplierData,SupplierId,AlternateProductPrice,AlternateProductCost,AlternateSuggestedPrice,ProductId,CreatedOn,CreatedBy,UpdatedOn,UpdatedBy")] ProductPackageType productPackageType)
{
productPackageType.Id = 0;
if (ModelState.IsValid)
{
if (User != null)
{
var userFullName = User.Claims.FirstOrDefault(x => x.Type == $"emails").Value;
productPackageType.CreatedBy = userFullName;
}
productPackageType.SupplierId = RequestDto.SupplierId;
productPackageType.CreatedOn = DateTime.Now;
productPackageType.ProductId = id;
_dbWriteService.Add(productPackageType);
await _dbWriteService.SaveChangesAsync();
}
ViewData["ProductId"] = new SelectList(_context.Product, "Id", "ProductName", productPackageType.ProductId);
ViewData["SupplierId"] = new SelectList(_context.Supplier, "Id", "SupplierName", productPackageType.SupplierId);
if (multiple == true)
{
TempData["notifyUserSuccess"] = "Alternate Package Saved.";
return(RedirectToAction("Create", "ProductPackageTypes", new { id = productPackageType.ProductId }));
}
return(RedirectToAction("Index", "ProductPackageTypes", new { id = productPackageType.ProductId }));
}
public async Task <IActionResult> CreateRequest([Bind("Id,RequestDescription,RequestTypeId,StatusTypeId,UserId,SupplierId,StoreId,CreatedOn,CreatedBy,UpdatedOn,UpdatedBy")] Request request)
{
if (ModelState.IsValid)
{
if (User != null)
{
var userFullName = User.Claims.FirstOrDefault(x => x.Type == $"emails").Value;
request.CreatedBy = userFullName;
}
request.CreatedOn = DateTime.Now;
request.UserId = UserDto.UserId;
var status = await _dbReadService.GetSingleRecordAsync <StatusType>(s => s.StatusTypeName.Equals("New Request"));
request.StatusTypeId = status.Id;
request.SupplierId = RequestDto.SupplierId;
_dbWriteService.Add(request);
await _dbWriteService.SaveChangesAsync();
}
ViewData["RequestTypeId"] = new SelectList(_context.RequestType, "Id", "RequestTypeName", request.RequestTypeId);
ViewData["StatusTypeId"] = new SelectList(_context.StatusType, "Id", "StatusTypeName", request.StatusTypeId).SelectedValue;
RequestDto.RequestId = request.Id;
return(RedirectToAction("CreateProduct", "Products", new { id = request.Id }));
}
public async Task <IActionResult> Create([Bind("Id,ContainerSizeTypeName")] ContainerSizeType containerSizeType)
{
if (ModelState.IsValid)
{
_dbWriteService.Add(containerSizeType);
await _dbWriteService.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(containerSizeType));
}
public async Task <bool> DeleteAsync <TSource>(Expression <Func <TSource, bool> > expression) where TSource : class
{
try
{
var entity = await _dbRead.SingleAsync(expression);
_dbWrite.Delete(entity);
return(await _dbWrite.SaveChangesAsync());
}
catch
{
return(false);
}
}
public async Task <IActionResult> OnPostAddAsync(string userId)
{
try
{
_dbWriteService.Add(new UserCourse {
CourseId = CourseId, UserId = userId
});
var succeeded = await _dbWriteService.SaveChangesAsync();
}
catch
{
}
await FillViewData(userId);
return(Page());
}
public async Task <IActionResult> Create([Bind("Id,NoteId,NoteListItem1,CreatedOn,CreatedBy")] NoteListItem noteListItem)
{
if (ModelState.IsValid)
{
noteListItem.CreatedBy = User.Identity.Name;
noteListItem.CreatedOn = DateTime.Now;
_dbWrite.Add(noteListItem);
await _dbWrite.SaveChangesAsync();
noteId = 0;
return(RedirectToAction("Index", "NoteListItems", new { Id = noteListItem.NoteId }));
}
ViewData["NoteId"] = new SelectList(_context.Note, "Id", "Id", noteListItem.NoteId);
return(View(noteListItem));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,UserId,FamilyId,Email,Profile,FirstName,LastName,Picture,PictureContentType,Blurb,CreatedOn,CreatedBy,UpdatedOn,UpdatedBy")] UserProfile userProfile, IFormFile file)
{
if (id != userProfile.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
if (file != null)
{
// MediaHelper does the work, just send the file over.
userProfile.Picture = MediaHelper.ResizeImageFromFile(file);
// byte array was returned with 0 length meaning the file is too large, try again!
if (userProfile.Picture.Length == 0)
{
TempData["notifyUserWarning"] = Constants.ImageMediaExceedsSizeLimit;
return(RedirectToAction("Edit", "UserProfiles"));
}
userProfile.PictureContentType = file.ContentType;
}
else
{
userProfile.Picture = UserData.ProfileImage;
}
_dbWrite.Update(userProfile);
await _dbWrite.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserProfileExists(userProfile.Id))
{
return(NotFound());
}
else
{
throw;
}
}
if (userProfile.LastName != null || userProfile.FirstName != null || userProfile.Email != null)
{
UserData.UserProfileComplete = true;
}
else
{
TempData["notifyUserWarning"] = "Your profile is not complete!";
}
return(RedirectToAction("Details", "UserProfiles", new { Id = id }));
}
ViewData["FamilyId"] = new SelectList(_context.Family, "Id", "Id", userProfile.FamilyId);
return(View(userProfile));
}
public async Task <IActionResult> CreateNote(int?id, [Bind("Id,NoteText,SendEmailRequestor,SendEmailSupplier,RequestId,CreatedOn,CreatedBy,UpdatedOn,UpdatedBy")] Note note)
{
note.Id = 0;
if (ModelState.IsValid)
{
if (User != null)
{
var userFullName = User.Claims.FirstOrDefault(x => x.Type == $"name").Value;
note.CreatedBy = userFullName;
}
note.CreatedOn = DateTime.Now;
note.RequestId = id;
_dbWriteService.Add(note);
await _dbWriteService.SaveChangesAsync();
var request = await _dbReadService.GetSingleRecordAsync <Request>(r => r.Id.Equals(id));
if (note.SendEmailSupplier == true)
{
RequestEmail emailSupplier = new RequestEmail(_configuration, _dbReadService);
emailSupplier.SendNewNoteEmailToSuppliers(request, note);
}
if (note.SendEmailRequestor == true)
{
RequestEmail emailOriginator = new RequestEmail(_configuration, _dbReadService);
var user = await _dbReadService.GetSingleRecordAsync <Entity.Models.User>(u => u.EmailAddress.Equals(request.UserId));
if (user != null)
{
if (user.SupplierId != null && user.SupplierId > 0)
{
emailOriginator.SendNewNoteEmailToOriginatingUser(request, note, user.SupplierId);
}
else
{
emailOriginator.SendNewNoteEmailToOriginatingUser(request, note);
}
}
}
}
return(RedirectToAction("Index", "Notes", new { id = note.RequestId }));
}
public async Task <IActionResult> CreateProduct(int id, [Bind("Id,ProductName,ProductDescription,Upccode,ProductLocation,ProductCost,ProductPrice,SuggestedPrice,PackageSize,PackageType,ContainerSizeTypeId,ContainerTypeId,OrderWeek,CategoryId,CreatedOn,CreatedBy,UpdatedOn,UpdatedBy,UnitsPerCase,SupplierData")] Product product)
{
var requestId = id;
product.Id = 0;
if (ModelState.IsValid)
{
if (User != null)
{
var userFullName = User.Claims.FirstOrDefault(x => x.Type == $"emails").Value;
product.CreatedBy = userFullName;
}
product.CreatedOn = DateTime.Now;
_dbWriteService.Add(product);
await _dbWriteService.SaveChangesAsync();
_dbReadService.IncludeEntityNavigation <Request>();
var request = await _dbReadService.GetSingleRecordAsync <Request>(s => s.Id.Equals(requestId));
request.ProductId = product.Id;
_dbWriteService.Update(request);
await _dbWriteService.SaveChangesAsync();
if (request.StoreId != null)
{
RequestEmail requestEmail = new RequestEmail(_configuration, _dbReadService);
requestEmail.SendRequestToStoreManager(request);
}
RequestLogHelper logHelper = new RequestLogHelper();
logHelper.LogRequestChange(request, _context, RequestLogConstants.RequestAddByVendor);
}
ViewData["CategoryId"] = new SelectList(_context.Category, "Id", "CategoryName", product.CategoryId);
ViewData["OrderWeeks"] = new SelectList(new Dictionary <int, int>()
{
{ 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 }, { 5, 5 }, { 6, 6 }, { 7, 7 }, { 8, 8 }, { 9, 9 }
}, "Key", "Value", product.OrderWeek);
return(RedirectToAction("Details", "Requests", new { id = requestId }));
}
public async Task <int> CreateAsync <TSource, TDestination>(TSource item)
where TSource : class
where TDestination : class
{
try
{
var entity = _mapper.Map <TDestination>(item);
_dbWrite.Add(entity);
var success = await _dbWrite.SaveChangesAsync();
if (success)
{
return((int)entity.GetType().GetProperty("Id").GetValue(entity));
}
return(-1);
}
catch { }
return(-1);
}
public async Task <IActionResult> Create([Bind("Id,FamilyLastName,Title,Picture,PictureContentType,Description,InvitationCode,FamilyAdminUserProfileId,CreatedOn,CreatedBy")] Family family, IFormFile file, string emailInvite)
{
if (!_signInManager.IsSignedIn(User))
{
return(RedirectToPage("/Account/Login", new { Area = "Identity" }));
}
if (!string.IsNullOrEmpty(emailInvite))
{
EmailHelper.SendSubscriberMessage(emailInvite, Constants.EmailInvitationCode);
}
// MediaHelper does the work, just send the file over.
family.Picture = MediaHelper.ResizeImageFromFile(file);
// byte array was returned with 0 length meaning the file is too large, try again!
if (family.Picture.Length == 0)
{
TempData["notifyUserWarning"] = Constants.ImageMediaExceedsSizeLimit;
return(RedirectToAction("Create", "Families"));
}
family.PictureContentType = file.ContentType;
family.CreatedBy = User.Identity.Name;
family.CreatedOn = DateTime.Now;
family.FamilyAdminUserProfileId = UserData.UserProfileId;
if (ModelState.IsValid)
{
_dbWrite.Add <Family>(family);
await _dbWrite.SaveChangesAsync();
}
var user = _dbRead.GetSingleRecordAsync <UserProfile>(u => u.Id.Equals(UserData.UserProfileId)).Result;
user.FamilyId = family.Id;
await _dbWrite.SaveChangesAsync();
UserData.FamilyId = family.Id;
UserData.FamilyProfileComplete = true;
return(RedirectToAction("Details", "Families", new { id = user.FamilyId }));
}
public async Task <IActionResult> Create([Bind("Id,SupplierName,SupplierEmail,CreatedOn,CreatedBy,UpdatedOn,UpdatedBy")] Supplier supplier)
{
if (ModelState.IsValid)
{
if (User != null)
{
var userFullName = User.Claims.FirstOrDefault(x => x.Type == $"name").Value;
supplier.CreatedBy = userFullName;
}
supplier.CreatedOn = DateTime.Now;
_dbWriteService.Add(supplier);
await _dbWriteService.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(supplier));
}
public async Task <IActionResult> Create([Bind("Id,SupplierId,FirstName,LastName,EmailAddress,AuthId,CreatedOn,CreatedBy,UpdatedOn,UpdatedBy")] User user)
{
var userFullName = User.Claims.FirstOrDefault(x => x.Type == $"name").Value;
if (ModelState.IsValid)
{
if (User != null)
{
user.CreatedBy = userFullName;
}
user.CreatedOn = DateTime.Now;
var graphClient = new GraphClient(Configuration, true);
var password = string.Empty;
var graphResult = graphClient.CreateUser(user, out password);
if (graphResult)
{
_dbWriteService.Add(user);
var saveResult = await _dbWriteService.SaveChangesAsync();
if (saveResult)
{
var userEmail = new PM.Business.Email.User(Configuration);
userEmail.SendWelcomeEmail(user, password);
return(RedirectToAction(nameof(Index)));
}
// Failed to save to the database, delete the user from the directory.
graphClient.DeleteUser(user.AuthId);
}
}
ViewData["SupplierId"] = new SelectList(_context.Supplier, "Id", "SupplierName", user.SupplierId);
return(View(user));
}
public async Task <IActionResult> Create([Bind("Id,Title,Text,Advanced,DueDate,UserProfileId,ShareToFam,CreatedOn,CreatedBy")] Note note)
{
if (ModelState.IsValid)
{
note.UserProfileId = UserData.UserProfileId;
note.CreatedOn = DateTime.Now;
note.CreatedBy = UserData.UserId;
_dbWrite.Add(note);
await _dbWrite.SaveChangesAsync();
if (note.Advanced == true)
{
return(RedirectToAction("Create", "NoteListItems", new { noteid = note.Id }));
}
return(RedirectToAction(nameof(Index)));
}
ViewData["UserProfileId"] = new SelectList(_context.UserProfile, "Id", "UserId", note.UserProfileId);
return(View(note));
}
public async Task <Boolean> DeleteAsync(int id)
{
try
{
//TODO: TWO Queries to delete entity????
//_dbWriteService.Delete(new Entity{Id = })
var entity = await _dbReadService.SingleAsync <Course>(d => d.Equals(id));
_dbWriteService.Delete(entity);
return(await _dbWriteService.SaveChangesAsync());
}
catch (Exception)
{
return(false);
}
}
