public async Task <IActionResult> Put([FromBody] Address modifiedAddress) { try { if (modifiedAddress != null) { modifiedAddress.User = await _DbContext.Users.AsTracking().Include(u => u.Role) .Include(u => u.RegistrationMethod).SingleOrDefaultAsync(u => u.Id == AppFunc.GetUserId(User)); } ModelState.Clear(); if (!TryValidateModel(modifiedAddress)) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } _DbContext.Addresses.Update(modifiedAddress); await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Ok(modifiedAddress)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> Post([FromBody] Newsletter newsletter) { try { if (_DbContext.Newsletters.Find(newsletter.Email) != null) { return(Created("Success", "Thank you for your subscription.")); } TryValidateModel(newsletter); if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } await _DbContext.Newsletters.AddAsync(newsletter).ConfigureAwait(false); await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Created("Success", "Thank you for your subscription.")); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
/// Ready For Test public async Task <IActionResult> Post([FromBody] Coupon newCoupon) { try { if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } if (!newCoupon.IsValid(ref ErrorsList)) { return(UnprocessableEntity(ErrorsList)); } if (await _DbContext.Coupons.AnyAsync(c => c.Code == newCoupon.Code) .ConfigureAwait(false)) { CoreFunc.Error(ref ErrorsList, "Coupon Code already exists."); return(StatusCode(412, ErrorsList)); } await _DbContext.Coupons.AddAsync(newCoupon).ConfigureAwait(false); await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Created("Success", newCoupon)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
private async Task <IActionResult> PrivateCreateUser(User newUser) { try { newUser.PasswordHash = newUser.Password; if (newUser.RegistrationMethod.Type != RegistrationTypes.Application) { newUser.PasswordHash = CoreFunc.StringGenerator(40, 10, 10, 10, 10); newUser.EmailConfirmed = true; } ModelState.Clear(); if (!TryValidateModel(newUser)) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } if (await _DbContext.Users.AnyAsync(u => u.NormalizedEmail == newUser.Email.ToUpper()).ConfigureAwait(false)) { CoreFunc.Error(ref ErrorsList, "This email is already registered."); return(StatusCode(412, ErrorsList)); } newUser.Id = 0; IdentityResult newUserResult = await _UserManager.CreateAsync(newUser, newUser.PasswordHash) .ConfigureAwait(false); if (!newUserResult.Succeeded) { foreach (var error in newUserResult.Errors) { CoreFunc.Error(ref ErrorsList, error.Description, error.Code); } return(StatusCode(417, ErrorsList)); } IdentityResult addedClaimResult = await _UserManager.AddClaimAsync( newUser, new Claim(AppConst.AccessClaims.Type, newUser.Role.AccessClaim) ).ConfigureAwait(false); if (!addedClaimResult.Succeeded) { _DbContext.Users.Remove(newUser); await _DbContext.SaveChangesAsync().ConfigureAwait(false); CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, null, User)); return(StatusCode(417, ErrorsList)); } await _UserManager.SetLockoutEnabledAsync(newUser, false); IsUserCreated = true; return(Created("Success", newUser)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
[Authorize(AppConst.AccessPolicies.Secret)] /// Done public async Task <IActionResult> Put([FromBody] DeliveryOption modifiedDeliveryOption) { try { /// get the current category DeliveryOption currentDeliveryOption = await _DbContext.DeliveryOptions .SingleOrDefaultAsync(c => c.Id == modifiedDeliveryOption.Id) .ConfigureAwait(false); // if the current category does not exists if (currentDeliveryOption == null) { CoreFunc.Error(ref ErrorsList, "Category Not Found"); return(NotFound(ErrorsList)); } if (await _DbContext.DeliveryOptions .AnyAsync(d => d.Name.Equals(modifiedDeliveryOption.Name) && d.Id != modifiedDeliveryOption.Id).ConfigureAwait(false)) { /// extract the errors and return bad request containing the errors CoreFunc.Error(ref ErrorsList, "Delivery Option Name already exists."); return(StatusCode(412, ErrorsList)); } currentDeliveryOption.Name = modifiedDeliveryOption.Name; if (!(currentDeliveryOption.IsPremitive && currentDeliveryOption.MinimumOrderTotal == 0)) { currentDeliveryOption.MinimumOrderTotal = modifiedDeliveryOption.MinimumOrderTotal; } if (!(currentDeliveryOption.IsPremitive && currentDeliveryOption.Price == 0)) { currentDeliveryOption.Price = modifiedDeliveryOption.Price; } TryValidateModel(currentDeliveryOption); if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } _DbContext.DeliveryOptions.Update(currentDeliveryOption); await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Ok(currentDeliveryOption)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> CreateUser([FromBody] User newUser) { try { if (string.IsNullOrWhiteSpace(newUser.Password)) { newUser.Password = CoreFunc.StringGenerator(10, 3, 3, 2, 2); } if (newUser.Role.Id == 0) { newUser.Role = null; } TryValidateModel(newUser); ModelState.Remove("Role.Name"); ModelState.Remove("Role.AccessClaim"); ModelState.Remove("PasswordHash"); if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } newUser.Role = await _DbContext.Roles.AsTracking() .FirstOrDefaultAsync(r => r.Id == newUser.Role.Id).ConfigureAwait(false); IActionResult result = await PrivateCreateUser(newUser).ConfigureAwait(false); if (IsUserCreated) { Request.Headers.TryGetValue("Origin", out StringValues OriginValue); await _EmailService .WelcomeNewEmployeeAsync(newUser, OriginValue) .ConfigureAwait(false); } newUser.Password = string.Empty; return(result); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); if (IsUserCreated) { _DbContext.Remove(newUser); await _DbContext.SaveChangesAsync().ConfigureAwait(false); } return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> PostQuestion([FromBody] Communication newContact) { try { if (!ReCaptchaPassed(newContact.captchaToken)) { CoreFunc.Error(ref ErrorsList, "Captcha validation failed"); return(StatusCode(412, ErrorsList)); } if (string.IsNullOrWhiteSpace(newContact.Messages.FirstOrDefault().Body)) { CoreFunc.Error(ref ErrorsList, "Message is required."); return(StatusCode(412, ErrorsList)); } if (AppFunc.GetUserId(User) != 0) { var user = await _DbContext.Users.SingleOrDefaultAsync(u => u.Id == AppFunc.GetUserId(User)); newContact.Email = user.Email; newContact.FullName = $"{user.FirstName} {user.Surname}"; } newContact.Status = true; newContact.Type = ContactType.Message; newContact.Messages[0].IsCustomer = true; ModelState.Clear(); TryValidateModel(newContact); if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } await _DbContext.Communications.AddAsync(newContact).ConfigureAwait(false); await _DbContext.SaveChangesAsync().ConfigureAwait(false); // await _EmailService.EmailConfirmationAsync(orderData).ConfigureAwait(false); return(Created("", $"Thank you for contacting us. We will contact you as soon as possible. ")); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> Put([FromBody] Comment modifiedComment) { try { ModelState.Clear(); TryValidateModel(modifiedComment); foreach (var key in ModelState.Keys) { if (key.StartsWith("User") || key.StartsWith("Product")) { ModelState.Remove(key); } } if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } Comment comment = await _DbContext.Comments .Include(c => c.User) .SingleOrDefaultAsync(c => c.Id == modifiedComment.Id && c.User.Id == AppFunc.GetUserId(User)).ConfigureAwait(false); if (comment == null) { CoreFunc.Error(ref ErrorsList, "Comment not exist."); return(StatusCode(412, ErrorsList)); } comment.Description = modifiedComment.Description; comment.Rate = modifiedComment.Rate; await comment.CencoredDescription(); _DbContext.Comments.Update(comment); await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Ok(comment)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
[Authorize(AppConst.AccessPolicies.Secret)] /// Done public async Task <IActionResult> PutTemplate([FromBody] EmailTemplate emailTemplate) { try { /// if model validation failed if (!TryValidateModel(emailTemplate)) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); /// return Unprocessable Entity with all the errors return(UnprocessableEntity(ErrorsList)); } EmailTemplate foundTemplate = await _DbContext.EmailTemplates .FirstOrDefaultAsync((et) => et.Id == emailTemplate.Id) .ConfigureAwait(false); if (foundTemplate == null) { ErrorsList.Add(new Error("", "Template cannot be found.")); /// return Unprocessable Entity with all the errors return(UnprocessableEntity(ErrorsList)); } foundTemplate.PrepareHtml(WebHost.WebRootPath); emailTemplate.RemoveHtmlComment(); if (foundTemplate.HTML != emailTemplate.HTML) { emailTemplate.SaveFilesToWWWRoot(WebHost.WebRootPath); } else { emailTemplate.FolderName = foundTemplate.FolderName; } _DbContext.EmailTemplates.Update(emailTemplate); await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Ok(emailTemplate)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
[Authorize(AppConst.AccessPolicies.Secret)] /// Ready For Test public async Task <IActionResult> Put([FromBody] Coupon modifiedCoupon) { try { if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } if (!await _DbContext.Coupons.AnyAsync(d => d.Code == modifiedCoupon.Code).ConfigureAwait(false)) { CoreFunc.Error(ref ErrorsList, "Coupon Not exists."); return(StatusCode(412, ErrorsList)); } if (await _DbContext.Coupons.AnyAsync(d => d.Code == modifiedCoupon.Code && d.Type != modifiedCoupon.Type).ConfigureAwait(false)) { CoreFunc.Error(ref ErrorsList, "Coupon Type Can't be Change."); return(StatusCode(412, ErrorsList)); } Coupon originalCoupon = await _DbContext.Coupons.FindAsync(modifiedCoupon.Code).ConfigureAwait(false); originalCoupon.MaxUseQuantity = modifiedCoupon.MaxUseQuantity; originalCoupon.ExpiryDate = modifiedCoupon.ExpiryDate; originalCoupon.DiscountAmount = originalCoupon.DiscountAmount; originalCoupon.MinimumOrderPrice = originalCoupon.MinimumOrderPrice; _DbContext.Coupons.Update(originalCoupon); await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Ok(originalCoupon)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> Post([FromBody] DeliveryOption newDeliveryOption) { try { /// check the database to see if a Category with the same name exists if (await _DbContext.DeliveryOptions .AnyAsync(d => d.Name.Equals(newDeliveryOption.Name)).ConfigureAwait(false)) { /// extract the errors and return bad request containing the errors CoreFunc.Error(ref ErrorsList, "Delivery Option Name already exists."); return(StatusCode(412, ErrorsList)); } TryValidateModel(newDeliveryOption); if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } newDeliveryOption.IsPremitive = false; /// else Category object is made without any errors /// Add the new Category to the EF context await _DbContext.DeliveryOptions.AddAsync(newDeliveryOption).ConfigureAwait(false); /// save the changes to the database await _DbContext.SaveChangesAsync().ConfigureAwait(false); /// return 201 created status with the new object /// and success message return(Created("", newDeliveryOption)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
[Authorize(AppConst.AccessPolicies.Official)] /// Ready For Test public async Task <IActionResult> Post([FromBody] Address newAddress) { try { //if (newAddress is null) // return checkObjectIsNull(newAddress); if (newAddress != null) { newAddress.User = await _DbContext.Users.AsTracking().Include(u => u.Role) .Include(u => u.RegistrationMethod) .SingleOrDefaultAsync(u => u.Id == AppFunc.GetUserId(User)); } ModelState.Clear(); if (!TryValidateModel(newAddress)) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } if (!await _DbContext.Addresses.AnyAsync(a => a.User.Id == AppFunc.GetUserId(User))) { newAddress.IsDefault = true; } await _DbContext.Addresses.AddAsync(newAddress).ConfigureAwait(false); await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Created("Success", newAddress)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
[Authorize(AppConst.AccessPolicies.Secret)] /// Done public async Task <IActionResult> PostTemplate([FromBody] EmailTemplate emailTemplate) { try { if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } /// save files emailTemplate.SaveFilesToWWWRoot(WebHost.WebRootPath); _DbContext.EmailTemplates.Add(emailTemplate); await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Created("", emailTemplate)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
[Authorize(AppConst.AccessPolicies.Secret)] /// Done public async Task <IActionResult> Put([FromBody] Category modifiedCategory) { try { bool containsNewImages = true; TryValidateModel(modifiedCategory); /// if new image is not provided do not check for new images if (string.IsNullOrWhiteSpace(modifiedCategory.ImageBase64) && string.IsNullOrWhiteSpace(modifiedCategory.OriginalImageBase64)) { containsNewImages = false; ModelState.Remove("ImageBase64"); ModelState.Remove("OriginalImageBase64"); } if (ModelState.ContainsKey("ImageBase64")) { ModelState.Remove("OriginalImageBase64"); } /// if model validation failed if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); /// return Unprocessable Entity with all the errors return(UnprocessableEntity(ErrorsList)); } /// check the database to see if a Category with the same name exists if (await _DbContext.Categories .AnyAsync(c => c.Name == modifiedCategory.Name && c.Id != modifiedCategory.Id) .ConfigureAwait(false)) { /// extract the errors and return bad request containing the errors CoreFunc.Error(ref ErrorsList, "Category with the given name already exists."); return(StatusCode(412, ErrorsList)); } /// get the current category Category currentCatogory = await _DbContext.Categories .SingleOrDefaultAsync(c => c.Id == modifiedCategory.Id) .ConfigureAwait(false); // if the current category does not exists if (currentCatogory == null) { CoreFunc.Error(ref ErrorsList, "Category Not Found"); return(NotFound(ErrorsList)); } string oldImagePath = modifiedCategory.ImagePath.Clone().ToString(); string oldOriginalImagePath = modifiedCategory.OriginalImagePath.Clone().ToString(); /// if new image is provided save the new image if (containsNewImages) { try { string folderName = CoreFunc.StringGenerator(10, 3, 3, 4); modifiedCategory.ImagePath = CoreFunc.SaveImageToWWWRoot(CoreFunc.StringGenerator(10, 3, 3, 4), _WebHost.WebRootPath, modifiedCategory.ImageBase64, $"Images\\Categories\\{folderName}"); modifiedCategory.OriginalImagePath = CoreFunc.SaveImageToWWWRoot(CoreFunc.StringGenerator(10, 3, 3, 4), _WebHost.WebRootPath, modifiedCategory.OriginalImageBase64, $"Images\\Categories\\{folderName}"); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, "Image cannot be saved."); _LoggingService.LogException(Request.Path, ex, User, AppLogType.FileModification); return(StatusCode(412, ErrorsList)); } } try { /// else Category object is made without any errors _DbContext.Categories.Update(modifiedCategory); await _DbContext.SaveChangesAsync().ConfigureAwait(false); } catch (Exception ex) { if (containsNewImages) { CoreFunc.DeleteFromWWWRoot(modifiedCategory.ImagePath, _WebHost.WebRootPath); CoreFunc.DeleteFromWWWRoot(modifiedCategory.OriginalImagePath, _WebHost.WebRootPath); CoreFunc.ClearEmptyImageFolders(_WebHost.WebRootPath); } _LoggingService.LogException(Request.Path, ex, User, AppLogType.FileModification); } if (containsNewImages) { CoreFunc.DeleteFromWWWRoot(oldImagePath, _WebHost.WebRootPath); CoreFunc.DeleteFromWWWRoot(oldOriginalImagePath, _WebHost.WebRootPath); CoreFunc.ClearEmptyImageFolders(_WebHost.WebRootPath); } return(Ok(modifiedCategory)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
/// Done public async Task <IActionResult> Post([FromBody] Product newProduct) { try { if (newProduct.Category.Id == 0) { newProduct.Category = null; } TryValidateModel(newProduct); ModelState.Remove("Category.Name"); ModelState.Remove("Category.ImageBase64"); ModelState.Remove("NutritionalInfo.Product"); ModelState.Remove("Category.OriginalImageBase64"); if (ModelState.ContainsKey("ImageBase64")) { ModelState.Remove("OriginalImageBase64"); } if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } /// check the database to see if a Product with the same name exists if (await _DbContext.Products.AnyAsync(d => d.Name == newProduct.Name && d.Category.Id == newProduct.Category.Id).ConfigureAwait(false)) { CoreFunc.Error(ref ErrorsList, "Product already exists."); return(StatusCode(412, ErrorsList)); } try { string folderName = CoreFunc.StringGenerator(10, 3, 3, 4); newProduct.ImagePath = CoreFunc.SaveImageToWWWRoot(CoreFunc.StringGenerator(10, 3, 3, 4), _WebHost.WebRootPath, newProduct.ImageBase64, $"Images\\Products\\{folderName}"); newProduct.OriginalImagePath = CoreFunc.SaveImageToWWWRoot(CoreFunc.StringGenerator(10, 3, 3, 4), _WebHost.WebRootPath, newProduct.OriginalImageBase64, $"Images\\Products\\{folderName}"); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, "Image cannot be saved."); _LoggingService.LogException(Request.Path, ex, User, AppLogType.FileModification); return(StatusCode(412, ErrorsList)); } try { await _DbContext.Products.AddAsync(newProduct).ConfigureAwait(false); _DbContext.Entry(newProduct.Category).State = EntityState.Unchanged; await _DbContext.SaveChangesAsync().ConfigureAwait(false); } catch (Exception) { CoreFunc.DeleteFromWWWRoot(newProduct.ImagePath, _WebHost.WebRootPath); CoreFunc.DeleteFromWWWRoot(newProduct.OriginalImagePath, _WebHost.WebRootPath); CoreFunc.ClearEmptyImageFolders(_WebHost.WebRootPath); throw; } return(Created("", newProduct)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> UpdateUser([FromBody] User modifiedUser) { try { User user = await _DbContext.Users .AsTracking() .Include(u => u.Role) .Include(u => u.RegistrationMethod) .FirstOrDefaultAsync(u => u.Id == modifiedUser.Id) .ConfigureAwait(false); if (user == null) { CoreFunc.Error(ref ErrorsList, "User Not Found."); return(StatusCode(412, ErrorsList)); } modifiedUser.Role = await _DbContext.Roles.AsTracking() .SingleOrDefaultAsync(r => r.Id == modifiedUser.Role.Id) .ConfigureAwait(false); ModelState.Clear(); TryValidateModel(modifiedUser); ModelState.Remove("PasswordHash"); if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } user.FirstName = modifiedUser.FirstName; user.Surname = modifiedUser.Surname; if (user.RegistrationMethod.Type == RegistrationTypes.Application && user.Email != modifiedUser.Email) { if (await _DbContext.Users.AnyAsync(d => d.NormalizedEmail == modifiedUser.Email.ToUpper()).ConfigureAwait(false)) { CoreFunc.Error(ref ErrorsList, "This email is already registered."); return(StatusCode(412, ErrorsList)); } await _DbContext.Communications.Where(c => c.Email == user.Email) .ForEachAsync(c => c.Email = modifiedUser.Email).ConfigureAwait(false); await _DbContext.Newsletters.Where(c => c.Email == user.Email) .ForEachAsync(c => c.Email = modifiedUser.Email).ConfigureAwait(false); user.Email = modifiedUser.Email; user.NormalizedEmail = modifiedUser.Email.ToUpper(); } user.PhoneNumber = modifiedUser.PhoneNumber; string oldAccessClaim = ""; if (!user.Role.Equals(modifiedUser.Role)) { oldAccessClaim = user.Role.AccessClaim; user.Role = modifiedUser.Role; } _DbContext.Users.Update(user); await _DbContext.SaveChangesAsync().ConfigureAwait(false); if (!string.IsNullOrEmpty(oldAccessClaim)) { IdentityResult removedClaimResult = await _UserManager.RemoveClaimAsync(user, new Claim(AppConst.AccessClaims.Type, oldAccessClaim) ).ConfigureAwait(false); if (removedClaimResult.Succeeded) { IdentityResult addedClaimResult = await _UserManager.AddClaimAsync(user, new Claim(AppConst.AccessClaims.Type, user.Role.AccessClaim) ).ConfigureAwait(false); } } return(Ok(user)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> UpdateCurrentUser([FromBody] UpdateCurrentUserData currentUserData) { try { _ = int.TryParse(User.Claims.FirstOrDefault(c => c.Type == "UserId").Value, out int userId); User user = await _DbContext.Users .Include(u => u.RegistrationMethod) .FirstOrDefaultAsync(u => u.Id == userId) .ConfigureAwait(false); if (user == null || currentUserData.User.Id != user.Id) { CoreFunc.Error(ref ErrorsList, "Information access is denied."); return(UnprocessableEntity(ErrorsList)); } ModelState.Clear(); TryValidateModel(currentUserData.User); ModelState.Remove("PasswordHash"); if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } if (user.RegistrationMethod.Type == RegistrationTypes.Application && !await _UserManager.CheckPasswordAsync(user, currentUserData.CurrentPassword).ConfigureAwait(false)) { CoreFunc.Error(ref ErrorsList, "Current Password is incorrect."); return(StatusCode(412, ErrorsList)); } user.FirstName = currentUserData.User.FirstName; user.Surname = currentUserData.User.Surname; if (user.RegistrationMethod.Type == RegistrationTypes.Application && user.Email != currentUserData.User.Email) { if (await _DbContext.Users.AnyAsync(d => d.NormalizedEmail == currentUserData.User.Email.ToUpper()).ConfigureAwait(false)) { CoreFunc.Error(ref ErrorsList, "This email is already registered."); return(StatusCode(412, ErrorsList)); } await _DbContext.Communications.Where(c => c.Email == user.Email) .ForEachAsync(c => c.Email = currentUserData.User.Email).ConfigureAwait(false); await _DbContext.Newsletters.Where(c => c.Email == user.Email) .ForEachAsync(c => c.Email = currentUserData.User.Email).ConfigureAwait(false); user.Email = currentUserData.User.Email; user.NormalizedEmail = currentUserData.User.Email.ToUpper(); } user.PhoneNumber = currentUserData.User.PhoneNumber; _DbContext.Users.Update(user); await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Ok(user)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> Post([FromBody] Comment newComment) { try { User user = await _DbContext.Users .Include(u => u.Orders) .ThenInclude(o => o.OrderItems) .SingleOrDefaultAsync(u => u.Id == AppFunc.GetUserId(User)) .ConfigureAwait(false); if (user.Orders.Any(o => o.Status == OrderStatusType.Delivered && o.OrderItems.Any(oi => oi.ProductId == newComment.Product.Id))) { Comment selectComment = await _DbContext.Comments .Include(c => c.User) .SingleOrDefaultAsync(c => c.Product.Id == newComment.Product.Id && c.User.Id == AppFunc.GetUserId(User)); if (selectComment != null) { _LoggingService.Log(Request.Path, AppLogType.OrderException, new { message = $"Try to add duplicate comment.", newContact = newComment }, User); CoreFunc.Error(ref ErrorsList, "You Can't add review for this product.Try again or Contact Admin."); return(StatusCode(412, ErrorsList)); } } else { _LoggingService.Log(Request.Path, AppLogType.OrderException, new { message = $"Try to add comment without order.", newContact = newComment }, User); CoreFunc.Error(ref ErrorsList, "You Can't add review for this product.Try again or Contact Admin."); return(StatusCode(412, ErrorsList)); } newComment.User = user; newComment.User.Orders = null; ModelState.Clear(); TryValidateModel(newComment); foreach (var key in ModelState.Keys) { if (key.StartsWith("User") || key.StartsWith("Product")) { ModelState.Remove(key); } } if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } await _DbContext.Comments.AddAsync(newComment).ConfigureAwait(false); _DbContext.Entry(newComment.User).State = EntityState.Unchanged; _DbContext.Entry(newComment.Product).State = EntityState.Unchanged; await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Created("", newComment)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> Post([FromBody] Category newCategory) { try { TryValidateModel(newCategory); if (ModelState.ContainsKey("ImageBase64")) { ModelState.Remove("OriginalImageBase64"); } if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } /// check the database to see if a Category with the same name exists if (await _DbContext.Categories .AnyAsync(d => d.Name.Equals(newCategory.Name)).ConfigureAwait(false)) { /// extract the errors and return bad request containing the errors CoreFunc.Error(ref ErrorsList, "Category already exists."); return(StatusCode(412, ErrorsList)); } try { string folderName = CoreFunc.StringGenerator(10, 3, 3, 4); newCategory.ImagePath = CoreFunc.SaveImageToWWWRoot(CoreFunc.StringGenerator(10, 3, 3, 4), _WebHost.WebRootPath, newCategory.ImageBase64, $"Images\\Categories\\{folderName}"); newCategory.OriginalImagePath = CoreFunc.SaveImageToWWWRoot(CoreFunc.StringGenerator(10, 3, 3, 4), _WebHost.WebRootPath, newCategory.OriginalImageBase64, $"Images\\Categories\\{folderName}"); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, "Image cannot be saved."); _LoggingService.LogException(Request.Path, ex, User, AppLogType.FileModification); return(StatusCode(412, ErrorsList)); } try { /// else Category object is made without any errors /// Add the new Category to the EF context await _DbContext.Categories.AddAsync(newCategory).ConfigureAwait(false); /// save the changes to the database await _DbContext.SaveChangesAsync().ConfigureAwait(false); } catch (Exception ex) { CoreFunc.DeleteFromWWWRoot(newCategory.ImagePath, _WebHost.WebRootPath); CoreFunc.DeleteFromWWWRoot(newCategory.OriginalImagePath, _WebHost.WebRootPath); CoreFunc.ClearEmptyImageFolders(_WebHost.WebRootPath); CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User, AppLogType.FileModification)); } /// return 201 created status with the new object /// and success message return(Created("", newCategory)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> PostDispute([FromBody] Communication newDispute) { try { if (string.IsNullOrWhiteSpace(newDispute.Messages.FirstOrDefault().Body)) { CoreFunc.Error(ref ErrorsList, "Message is required."); return(StatusCode(412, ErrorsList)); } if (!string.IsNullOrEmpty(newDispute.Order_Id) && (await _DbContext.Orders.SingleOrDefaultAsync(o => o.Id == newDispute.Order_Id) == null)) { CoreFunc.Error(ref ErrorsList, "Cannot find your order."); return(UnprocessableEntity(ErrorsList)); } User user = await _DbContext.Users.SingleOrDefaultAsync(u => u.Id == AppFunc.GetUserId(User)); newDispute.Email = user.Email; newDispute.FullName = $"{user.FirstName} {user.Surname}"; newDispute.Status = true; newDispute.Order = await _DbContext.Orders .Include(o => o.Payment) .Include(o => o.User) .SingleOrDefaultAsync(o => o.Id == newDispute.Order_Id); newDispute.Type = ContactType.Dispute; newDispute.Messages[0].IsCustomer = true; TryValidateModel(newDispute); foreach (var key in ModelState.Keys) { if (key.StartsWith("User") || key.StartsWith("Order") || key.StartsWith("OrderItem")) { ModelState.Remove(key); } } if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } await _DbContext.Communications.AddAsync(newDispute).ConfigureAwait(false); _DbContext.Entry(newDispute.Order).State = EntityState.Unchanged; _DbContext.Entry(newDispute.Order.User).State = EntityState.Unchanged; _DbContext.Entry(newDispute.Order.Payment).State = EntityState.Unchanged; await _DbContext.SaveChangesAsync().ConfigureAwait(false); await _EmailService.OrderDisputeAsync(newDispute.Order, newDispute).ConfigureAwait(false); return(Created("", newDispute)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
private async Task <IActionResult> Update(string communicationId, bool isCustomer, Message message, bool status = false) { try { var originalCommunication = await _DbContext.Communications .Include(c => c.Messages) .SingleOrDefaultAsync(c => c.Id == communicationId); if (originalCommunication is null) { CoreFunc.Error(ref ErrorsList, "Communication Not exists."); return(StatusCode(412, ErrorsList)); } if (!isCustomer) { originalCommunication.Status = status; } if (string.IsNullOrWhiteSpace(message.Body) && originalCommunication.Status) { /// extract the errors and return bad request containing the errors CoreFunc.Error(ref ErrorsList, "Message is required."); return(StatusCode(412, ErrorsList)); } if (!originalCommunication.Status) { message.Body = $"{originalCommunication.CommunicationType} was closed"; } message.IsCustomer = isCustomer; originalCommunication.Messages.Add(message); ModelState.Clear(); TryValidateModel(originalCommunication); foreach (var key in ModelState.Keys) { if (key.StartsWith("User") || key.StartsWith("Order") || key.StartsWith("OrderItem")) { ModelState.Remove(key); } } if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } _DbContext.Communications.Update(originalCommunication); await _DbContext.SaveChangesAsync().ConfigureAwait(false); if (message.IsCustomer) { await _EmailService.MessageToAdminAsync(message, originalCommunication).ConfigureAwait(false); } else if (originalCommunication.Status) { await _EmailService.MessageToUser(message, originalCommunication).ConfigureAwait(false); } return(Ok(originalCommunication)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
[Authorize(AppConst.AccessPolicies.Secret)] /// Done public async Task <IActionResult> Put([FromBody] Product modifiedProduct) { try { bool containsNewImages = true; if (modifiedProduct.Category.Id == 0) { modifiedProduct.Category = null; } ModelState.Remove("Category.Name"); ModelState.Remove("Category.ImageBase64"); ModelState.Remove("Category.OriginalImageBase64"); ModelState.Remove("NutritionalInfo.Product"); /// if new image is not provided do not check for new images if (string.IsNullOrWhiteSpace(modifiedProduct.ImageBase64) && string.IsNullOrWhiteSpace(modifiedProduct.OriginalImageBase64)) { containsNewImages = false; ModelState.Remove("ImageBase64"); ModelState.Remove("OriginalImageBase64"); } if (ModelState.ContainsKey("ImageBase64")) { ModelState.Remove("OriginalImageBase64"); } if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } /// check the database to see if a Product with the same name exists if (await _DbContext.Products.AnyAsync(d => d.Id != modifiedProduct.Id && d.Name == modifiedProduct.Name && d.Category.Id == modifiedProduct.Category.Id).ConfigureAwait(false)) { CoreFunc.Error(ref ErrorsList, "Duplicated product name in selected category."); return(StatusCode(412, ErrorsList)); } string oldImagePath = modifiedProduct.ImagePath.Clone().ToString(); string oldOriginalImagePath = modifiedProduct.OriginalImagePath.Clone().ToString(); /// if new image is provided save the new image if (containsNewImages) { try { string folderName = CoreFunc.StringGenerator(10, 3, 3, 4); modifiedProduct.ImagePath = CoreFunc.SaveImageToWWWRoot(CoreFunc.StringGenerator(10, 3, 3, 4), _WebHost.WebRootPath, modifiedProduct.ImageBase64, $"Images\\Products\\{folderName}"); modifiedProduct.OriginalImagePath = CoreFunc.SaveImageToWWWRoot(CoreFunc.StringGenerator(10, 3, 3, 4), _WebHost.WebRootPath, modifiedProduct.OriginalImageBase64, $"Images\\Products\\{folderName}"); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, "Image cannot be saved."); _LoggingService.LogException(Request.Path, ex, User, AppLogType.FileModification); return(StatusCode(412, ErrorsList)); } } try { _DbContext.Products.Update(modifiedProduct); await _DbContext.SaveChangesAsync().ConfigureAwait(false); } catch (Exception) { if (containsNewImages) { CoreFunc.DeleteFromWWWRoot(modifiedProduct.ImagePath, _WebHost.WebRootPath); CoreFunc.DeleteFromWWWRoot(modifiedProduct.OriginalImagePath, _WebHost.WebRootPath); CoreFunc.ClearEmptyImageFolders(_WebHost.WebRootPath); } throw; } if (containsNewImages) { CoreFunc.DeleteFromWWWRoot(oldImagePath, _WebHost.WebRootPath); CoreFunc.DeleteFromWWWRoot(oldOriginalImagePath, _WebHost.WebRootPath); CoreFunc.ClearEmptyImageFolders(_WebHost.WebRootPath); } return(Ok(modifiedProduct)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> ExternalLogin(ExternalLoginDetails externalLoginInfo) { try { IEnumerable <string> policies = AppFunc.GetCurrentRequestPolicies(Request, out AppTypes apptype); if (apptype == AppTypes.Invalid) { CoreFunc.Error(ref ErrorsList, "Unauthorised Application Access. 🤔"); return(Unauthorized(ErrorsList)); } if (!TryValidateModel(externalLoginInfo)) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(UnprocessableEntity(ErrorsList)); } User externalLoginUser = new User(); switch (externalLoginInfo.Type) { case RegistrationTypes.Google: externalLoginUser = await GetGoogleUserInfo(externalLoginInfo).ConfigureAwait(false); break; case RegistrationTypes.Facebook: externalLoginUser = await GetFacebookUserInfo(externalLoginInfo).ConfigureAwait(false); break; } // Check if the user is already registered User registeredUser = await _DbContext.Users .Include(u => u.Role) .Include(u => u.RegistrationMethod) .SingleOrDefaultAsync(u => u.RegistrationMethod.Type == externalLoginInfo.Type && u.RegistrationMethod.ExternalLinkedId == externalLoginUser.RegistrationMethod.ExternalLinkedId) .ConfigureAwait(false); // if the user is already registered if (registeredUser != null) { if (!await IsUserPolicyAccepted(registeredUser, policies).ConfigureAwait(false)) { CoreFunc.Error(ref ErrorsList, "You do not have permission to login here."); return(Unauthorized(ErrorsList)); } // sign the user in without any password await _SignInManager.SignInAsync(registeredUser, externalLoginInfo.RememberMe).ConfigureAwait(false); return(Ok(registeredUser)); } if (apptype == AppTypes.Admin) { CoreFunc.Error(ref ErrorsList, "You do not have permission to login here. Please contact administrator."); return(Unauthorized(ErrorsList)); } /// check if the user is registered using other methods User user = await _UserManager .FindByEmailAsync(externalLoginUser?.Email).ConfigureAwait(false); if (user != null) { RegistrationMethod registrationMethod = await _DbContext.RegistrationMethods .FirstOrDefaultAsync(r => r.User.Id == user.Id).ConfigureAwait(false); if (registrationMethod.Type != RegistrationTypes.Application) { /// in the case any exceptions return the following error CoreFunc.Error(ref ErrorsList, $"Please use {registrationMethod.Type} account to login."); } else { /// in the case any exceptions return the following error CoreFunc.Error(ref ErrorsList, $"Please use Email and Password to login"); } return(StatusCode(403, ErrorsList)); } externalLoginUser.Role = await _DbContext.Roles.FirstOrDefaultAsync(r => r.Name == "Customer").ConfigureAwait(false); // else if the user is not registered but information is received from external login externalLoginUser.Id = -1; return(StatusCode(206, externalLoginUser)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
private async Task <Order> CheckOrderDetail(Order orderData) { Address currentAddress = await _DbContext.Addresses.Include(a => a.User) .SingleOrDefaultAsync(a => a.Id == orderData.AddressId && a.User.Id == AppFunc.GetUserId(User)); if (currentAddress != null) { orderData.UpdateAddress(currentAddress); } orderData.DeliveryOption = await _DbContext.DeliveryOptions.AsTracking() .SingleOrDefaultAsync(a => a.Id == orderData.DeliveryOption.Id) .ConfigureAwait(false); ModelState.Clear(); TryValidateModel(orderData); foreach (var key in ModelState.Keys) { if ( (key.StartsWith("Payment") || key.StartsWith("Coupon") || key.StartsWith("OrderItems") || key.StartsWith("User")) || (AppFunc.GetUserId(User) == 0 && currentAddress == null && (key.StartsWith("Name") || key.StartsWith("City") || key.StartsWith("Postcode") || key.StartsWith("FirstLine"))) ) { ModelState.Remove(key); } } if (!ModelState.IsValid) { CoreFunc.ExtractErrors(ModelState, ref ErrorsList); return(null); } List <Product> productList = await _DbContext.Products.AsTracking() .Include(p => p.Category) .Where(p => orderData.OrderItems.Select(t => t.ProductId).ToList().Contains(p.Id)) .ToListAsync() .ConfigureAwait(false); Product originalProduct; List <OrderItem> CheckedOrderItems = new List <OrderItem>(); orderData.TotalItemPrice = 0; foreach (var orderItem in orderData.OrderItems) { originalProduct = productList.SingleOrDefault(t => t.Id == orderItem.ProductId); if (originalProduct == null || !originalProduct.Status) { _LoggingService.Log(Request.Path, AppLogType.OrderException, new { message = $"Product ({orderItem.Name}) Unavailable.", order = orderData }, User); CoreFunc.Error(ref ErrorsList, $"Product ({orderItem.Name}) Unavailable."); return(null); } if (orderItem.Price != originalProduct.Price) { _LoggingService.Log(Request.Path, AppLogType.OrderException, new { message = "Product Price mismatch.", order = orderData }, User); CoreFunc.Error(ref ErrorsList, "Product Price mismatch"); return(null); } if (orderItem.Quantity > originalProduct.StockQuantity) { CoreFunc.Error(ref ErrorsList, $"Product '{orderItem.Name}' is out of stock"); return(null); } if (orderItem.Quantity == 0) { _LoggingService.Log(Request.Path, AppLogType.OrderException, new { message = "Product quantity can't be zero.", order = orderData }, User); CoreFunc.Error(ref ErrorsList, $"Product quantity can't be zero."); return(null); } orderData.TotalItemPrice += (orderItem.Quantity * originalProduct.Price ?? 0); originalProduct.StockQuantity -= orderItem.Quantity; CheckedOrderItems.Add(new OrderItem(originalProduct, orderItem.Quantity)); } if (orderData.DeliveryOption.Price == 0 && orderData.DeliveryOption.MinimumOrderTotal > orderData.TotalItemPrice && orderData.DeliveryOption.IsPremitive) { CoreFunc.Error(ref ErrorsList, $"You do not meet the free delivery requirement of £{orderData.DeliveryOption.MinimumOrderTotal}"); return(null); } //Check coupon if (orderData.Coupon != null && !string.IsNullOrEmpty(orderData.Coupon.Code)) { Coupon currentCoupon = await _DbContext.Coupons.AsTracking() .SingleOrDefaultAsync(c => c.Code == orderData.Coupon.Code) .ConfigureAwait(false); if (currentCoupon == null || currentCoupon.MaxUseQuantity < 1 || currentCoupon.ExpiryDate < DateTime.UtcNow || orderData.TotalItemPrice < currentCoupon.MinimumOrderPrice) { _LoggingService.Log(Request.Path, AppLogType.OrderException, new { message = "Coupon Invalid", order = orderData }, User); CoreFunc.Error(ref ErrorsList, $"'{orderData.Coupon.Code}' is invalid"); return(null); } else { orderData.Coupon = currentCoupon; } } orderData.CalculateTotalPrice(); return(orderData); }