public async Task <IActionResult> Shipping(Customer model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (model.CustomerId == 0)
{
_contextModel.Add(model);
await _contextModel.SaveChangesAsync();
}
else
{
_contextModel.Update(model);
await _contextModel.SaveChangesAsync();
}
Customer customer = _contextModel.Customers.SingleOrDefault <Customer>(m => m.UserId == model.UserId);
if (customer == null)
{
throw new ApplicationException($"Unable to load customer.");
}
_logger.LogInformation("Shipping information changed successfully.");
StatusMessage = "Your shipping has been changed.";
ViewBag.StatusMessage = StatusMessage;
return(View(customer));
}
public async Task <IActionResult> Create([Bind("CustomerId,FirstName,LastName,Address,City,State,Country,UserId")] Customer customer)
{
if (ModelState.IsValid)
{
_context.Add(customer);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(customer));
}
public async Task <IActionResult> Create([Bind("CategoryId,Description")] Category category)
{
if (ModelState.IsValid)
{
_context.Add(category);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(category));
}
public async Task <IActionResult> Create([Bind("OrderId,OrderDate,ShippingAddress,City,State,Country,OrderStatus")] Order order)
{
if (ModelState.IsValid)
{
_context.Add(order);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(order));
}
public async Task <IActionResult> Create([Bind("ProductId,Name,Discription,Price,CategoryId,Active")] Product product)
{
if (ModelState.IsValid)
{
_context.Add(product);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(product));
}
// PUT: odata/PUR070(5)
public async Task <IHttpActionResult> Put([FromODataUri] string key, Delta <PUR070> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
PUR070 pUR070 = await db.PUR070.FindAsync(key);
if (pUR070 == null)
{
return(NotFound());
}
patch.Put(pUR070);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PUR070Exists(key))
{
return(NotFound());
}
else
{
throw;
}
}
return(Updated(pUR070));
}
private async Task ApplyOrdering(ModelDbContext context, long serviceId, CancellationToken cancellationToken)
{
// TODO: This has O(n) complexity in terms of service versions per service.
// It would be nice to port semantic version handling to be executable inside the database
var allVersions = await context.ServiceVersions.Where(s => s.ServiceId == serviceId)
.ToListAsync(cancellationToken).ConfigureAwait(false);
var orderedVersions = allVersions.OrderBy(s => SemanticVersion.Parse(s.Version)).Select((v, index) =>
{
v.VersionOrder = index;
return(v);
}).ToList();
await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
var changePasswordResult = await _userManager.ChangePasswordAsync(user, Input.OldPassword, Input.NewPassword);
if (!changePasswordResult.Succeeded)
{
foreach (var error in changePasswordResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(Page());
}
else
{
using (var db = new ModelDbContext())
{
var setNewPasswordInOriginalDb = db.Users.Where(x => x.Email == user.Email)
.SingleOrDefault();
setNewPasswordInOriginalDb.Password = Input.NewPassword;
//db.Update(setNewPasswordInOriginalDb);
db.Attach(setNewPasswordInOriginalDb);
db.Entry(setNewPasswordInOriginalDb).Property("Password").IsModified = true;
var responseSave = await db.SaveChangesAsync();
}
}
await _signInManager.RefreshSignInAsync(user);
_logger.LogInformation("User changed their password successfully.");
StatusMessage = "Your password has been changed.";
return(RedirectToPage());
}
