public async Task <IActionResult> Delete(string key) { try { /// if the Newsletter record with the same id is not found Newsletter newsletter = _DbContext.Newsletters.Find(key); if (newsletter != null) { /// now delete the Newsletter record _DbContext.Newsletters.Remove(newsletter); /// save the changes to the database await _DbContext.SaveChangesAsync().ConfigureAwait(false); } else { CoreFunc.Error(ref ErrorsList, "Your key is invalid."); return(StatusCode(412, ErrorsList)); } /// return 200 OK status return(Ok($"{newsletter.Email} is now unsubscribed")); } 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> AllTemplate() { try { List <EmailTemplate> templateList = await _DbContext.EmailTemplates .OrderByDescending(et => et.TemplateType) .ToListAsync() .ConfigureAwait(false); EmailTemplate copyDefaultTemplate = null; foreach (EmailTemplate item in templateList) { if (item.TemplateType == EmailTemplateTypes.DefaultTemplate) { copyDefaultTemplate = item; } item.PrepareDesign(WebHost.WebRootPath); item.PrepareHtml(WebHost.WebRootPath); } if (copyDefaultTemplate != null) { templateList.Remove(copyDefaultTemplate); templateList = templateList.Prepend(copyDefaultTemplate).ToList(); } return(Ok(templateList)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User));; return(StatusCode(417, ErrorsList)); } }
/// Done public async Task <IActionResult> Delete(int productId) { try { Product product = await _DbContext.Products.SingleOrDefaultAsync(d => d.Id == productId).ConfigureAwait(false); if (product is null) { CoreFunc.Error(ref ErrorsList, "Product not found"); return(NotFound(ErrorsList)); } _DbContext.Products.Remove(product); await _DbContext.SaveChangesAsync().ConfigureAwait(false); try { CoreFunc.DeleteFromWWWRoot(product.ImagePath, _WebHost.WebRootPath); CoreFunc.DeleteFromWWWRoot(product.OriginalImagePath, _WebHost.WebRootPath); CoreFunc.ClearEmptyImageFolders(_WebHost.WebRootPath); } catch (Exception ex) { _LoggingService.LogException(Request.Path, ex, User, AppLogType.FileModification); } return(Ok($"Product '{product.Name}' was deleted")); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public bool IsValid(ref List <Error> ErrorsList) { switch (this.Type) { case CouponType.FreeDelivery: this.DiscountAmount = 0; break; case CouponType.PercentageOfTotal: if (this.DiscountAmount > 100) { CoreFunc.Error(ref ErrorsList, $"Discount Amount must be less than 100"); return(false); } break; case CouponType.DiscountPrice: break; default: break; } return(true); }
public async Task <IActionResult> Search( int selectedPage, int maxNumberPerItemsPage, string searchValue = "", bool isSortAsce = true, string sortName = "Name") { try { int totalCount = await _DbContext.Categories .CountAsync(c => searchValue.Equals(CoreConst.GetAllRecords)?true : c.Name.Contains(searchValue)) .ConfigureAwait(false); List <Category> list = await _DbContext.Categories .Where(c => searchValue.Equals(CoreConst.GetAllRecords)?true : c.Name.Contains(searchValue)) .OrderByDynamic(sortName, isSortAsce) .Skip((selectedPage - 1) * maxNumberPerItemsPage) .Take(maxNumberPerItemsPage) .ToListAsync() .ConfigureAwait(false); foreach (var category in list) { category.TotalProducts = await _DbContext.Products .CountAsync(p => p.Category.Id == category.Id) .ConfigureAwait(false); } return(Ok(new MultiResult <List <Category>, int>(list, totalCount, CoreFunc.GetCustomAttributeTypedArgument(this.ControllerContext)))); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> SalesStatistics(SalesPeriod salePeriod) { try { MultiResult <List <string>, List <decimal>, List <int> > result = new MultiResult <List <string>, List <decimal>, List <int> >(); switch (salePeriod) { case SalesPeriod.Daily: result = await GetDaily(CoreFunc.GetCustomAttributeTypedArgument(this.ControllerContext)); break; case SalesPeriod.Monthly: result = await GetMonthly(CoreFunc.GetCustomAttributeTypedArgument(this.ControllerContext)); break; case SalesPeriod.Yearly: result = await GetYearly(CoreFunc.GetCustomAttributeTypedArgument(this.ControllerContext)); break; default: break; } ; return(Ok(result)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> All(int productId, int selectedPage, int maxItemsPerPage) { try { int totalCount = await _DbContext.Comments.CountAsync() .ConfigureAwait(false); List <Comment> list = await _DbContext.Comments.Include(c => c.Product).Include(c => c.User) .Where(c => c.Product.Id == productId) .OrderBy(c => c.Date) .Skip((selectedPage - 1) * maxItemsPerPage) .Take(maxItemsPerPage) .ToListAsync() .ConfigureAwait(false); return(Ok(new MultiResult <List <Comment>, int>(list, totalCount, CoreFunc.GetCustomAttributeTypedArgument(ControllerContext)))); } catch (Exception ex) { /// in the case any exceptions return the following error CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
private async Task <User> UpdatePassword(User selectedUser) { User userDetails = await _DbContext.Users.FindAsync(selectedUser.Id).ConfigureAwait(false); if (userDetails == null) { CoreFunc.Error(ref ErrorsList, "User not found!"); return(null); } string passResetToken = await _UserManager.GeneratePasswordResetTokenAsync(userDetails).ConfigureAwait(false); IdentityResult result = await _UserManager.ResetPasswordAsync( userDetails, passResetToken, selectedUser.Password).ConfigureAwait(false); if (!result.Succeeded) { foreach (var error in result.Errors) { ErrorsList.Add(new Error(error.Code, error.Description)); } return(null); } return(userDetails); }
[Authorize(AppConst.AccessPolicies.Official)] /// Ready For Test public async Task <IActionResult> Delete(int addressId) { try { Address address = await _DbContext.Addresses.SingleAsync(a => a.Id == addressId).ConfigureAwait(false); if (address is null) { CoreFunc.Error(ref ErrorsList, "Address not found"); return(NotFound(ErrorsList)); } if (address.IsDefault == true) { CoreFunc.Error(ref ErrorsList, "Unable to Delete default Address."); return(StatusCode(412, ErrorsList)); } _DbContext.Addresses.Remove(address); await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Ok($"Address was deleted")); } 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)); } }
public async Task <IActionResult> Summary() { try { int newOrderCount = await _DbContext.Orders .CountAsync(o => o.Status == OrderStatusType.InProgress).ConfigureAwait(false); int openDisputeCount = await _DbContext.Communications .CountAsync(o => o.Type == ContactType.Dispute && o.Status == true).ConfigureAwait(false); int openMessageCount = await _DbContext.Communications .CountAsync(o => o.Type == ContactType.Message && o.Status == true).ConfigureAwait(false); decimal totalPrice = await _DbContext.Orders .Where(o => o.Status == OrderStatusType.InProgress || o.Status == OrderStatusType.Confirmed || o.Status == OrderStatusType.Delivered || o.Status == OrderStatusType.PartialyRefunded) .SumAsync(o => o.TotalPrice).ConfigureAwait(false); decimal totalPartialRefund = await _DbContext.Payments .Where(p => p.Type == PaymentType.PartialyRefunded) .SumAsync(p => p.RefundAmount).ConfigureAwait(false); return(Ok(new MultiResult <int, int, int, decimal>(newOrderCount, openDisputeCount, openMessageCount, totalPrice - totalPartialRefund, CoreFunc.GetCustomAttributeTypedArgument(this.ControllerContext)))); } 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> Search( int selectedPage, int maxNumberPerItemsPage, string searchValue = "", string filterType = CoreConst.GetAllRecords, bool isSortAsce = true, string sortName = "Code") { try { int totalCount = await _DbContext.Coupons .Where(r => filterType.Equals(CoreConst.GetAllRecords)? true : r.Type.Equals((CouponType)Enum.Parse(typeof(CouponType), filterType, true))) .CountAsync(c => searchValue.Equals(CoreConst.GetAllRecords) ? true : c.Code.Contains(searchValue)) .ConfigureAwait(false); List <Coupon> list = await _DbContext.Coupons .Where(r => filterType.Equals(CoreConst.GetAllRecords)?true : r.Type.Equals((CouponType)Enum.Parse(typeof(CouponType), filterType, true))) .OrderByDynamic(sortName, isSortAsce) .Where(c => searchValue.Equals(CoreConst.GetAllRecords) ? true : c.Code.Contains(searchValue)) .Skip((selectedPage - 1) * maxNumberPerItemsPage) .Take(maxNumberPerItemsPage) .ToListAsync() .ConfigureAwait(false); return(Ok(new MultiResult <List <Coupon>, int>(list, totalCount, CoreFunc.GetCustomAttributeTypedArgument(this.ControllerContext)))); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
/// Ready For Test public async Task <IActionResult> Delete(string communicationId) { try { Communication currentDeliveryOption = await _DbContext.Communications.SingleOrDefaultAsync(d => d.Id == communicationId) .ConfigureAwait(false); if (currentDeliveryOption is null) { CoreFunc.Error(ref ErrorsList, "Communication not found"); return(NotFound(ErrorsList)); } if (currentDeliveryOption.Type == Extras.CustomTypes.ContactType.Dispute) { /// extract the errors and return bad request containing the errors CoreFunc.Error(ref ErrorsList, "Dispute can't be delete."); return(StatusCode(412, ErrorsList)); } _DbContext.Communications.Remove(currentDeliveryOption); await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Ok("Communication was deleted")); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
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)); } }
/// Ready For Test public async Task <IActionResult> Delete(int deliveyOptionId) { try { DeliveryOption currentDeliveryOption = await _DbContext.DeliveryOptions.SingleOrDefaultAsync(d => d.Id == deliveyOptionId) .ConfigureAwait(false); if (currentDeliveryOption is null) { CoreFunc.Error(ref ErrorsList, "Delivery Option not found"); return(NotFound(ErrorsList)); } if (currentDeliveryOption.IsPremitive) { /// extract the errors and return bad request containing the errors CoreFunc.Error(ref ErrorsList, "Delivery Option is primitive."); return(StatusCode(412, ErrorsList)); } _DbContext.DeliveryOptions.Remove(currentDeliveryOption); await _DbContext.SaveChangesAsync().ConfigureAwait(false); return(Ok("Delivery Option was deleted")); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> Validate(string couponCode) { try { Coupon coupon = await _DbContext.Coupons.FindAsync(couponCode); if (coupon == null) { CoreFunc.Error(ref ErrorsList, $"'{couponCode}' not found"); return(StatusCode(412, ErrorsList)); } if (coupon.MaxUseQuantity == 0 || coupon.ExpiryDate < DateTime.UtcNow) { CoreFunc.Error(ref ErrorsList, $"'{couponCode}' has expired"); return(StatusCode(412, ErrorsList)); } return(Ok(coupon)); } 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)); } }
public async Task <IActionResult> UpdateCurrentUserPassword([FromBody] UpdateCurrentUserData data) { try { _ = int.TryParse(User.Claims.FirstOrDefault(c => c.Type == "UserId").Value, out int userId); User user = _DbContext.Users.Find(userId); if (!await _UserManager.CheckPasswordAsync(user, data.CurrentPassword).ConfigureAwait(false)) { CoreFunc.Error(ref ErrorsList, "Current Password is incorrect."); return(StatusCode(412, ErrorsList)); } user.Password = data.User.Password; User result = await UpdatePassword(user).ConfigureAwait(false); if (result == null) { return(StatusCode(412, ErrorsList)); } return(Ok(result)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> GetDisputeSecret(string disputeKey) { try { Communication dispute = await _DbContext.Communications .Include(c => c.Order) .ThenInclude(o => o.User) .Include(c => c.Order) .ThenInclude(o => o.OrderItems) .Include(c => c.Messages) .SingleOrDefaultAsync(c => c.Type == ContactType.Dispute && c.Id == disputeKey) .ConfigureAwait(false); if (dispute is null) { CoreFunc.Error(ref ErrorsList, "Dispute Not Found."); return(StatusCode(412, ErrorsList)); } return(Ok(dispute)); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> ConfirmEmail([FromBody] string pathName) { try { string tokenValue = ""; for (int i = pathName.Length - 1; i >= 0; i--) { if (pathName[i] == '/') { i = -1; } else { tokenValue = pathName[i] + tokenValue; } } Token token = await _DbContext.Tokens .Include(t => t.User) .FirstOrDefaultAsync(t => t.Url.Contains(pathName) && t.Value.Equals(tokenValue)) .ConfigureAwait(false); if (token == null || token.Type != Extras.CustomTypes.TokenTypes.ConfirmEmail) { ErrorsList.Add(new Error("0", "Invalid Request/Token.")); return(StatusCode(412, ErrorsList)); } if (token.ExpiaryDateTime < DateTime.UtcNow) { ErrorsList.Add(new Error("0", "Token Expired")); return(StatusCode(412, ErrorsList)); } IdentityResult result = await _UserManager.ConfirmEmailAsync(token.User, await _UserManager.GenerateEmailConfirmationTokenAsync(token.User).ConfigureAwait(false)) .ConfigureAwait(false); _DbContext.Entry(token.User).State = EntityState.Unchanged; _DbContext.Remove(entity: token); await _DbContext.SaveChangesAsync().ConfigureAwait(false); if (result.Succeeded) { return(Ok()); } else { ErrorsList.Add(new Error("0", "Unable to process your request.")); return(StatusCode(412, ErrorsList)); } } 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)); } }
public async Task <IActionResult> RequestPasswordReset([FromBody] string email) { try { if (string.IsNullOrWhiteSpace(email)) { CoreFunc.Error(ref ErrorsList, "Email is required!"); return(StatusCode(412, ErrorsList)); } User user = await _UserManager .FindByEmailAsync(email).ConfigureAwait(false); if (user == null) { CoreFunc.Error(ref ErrorsList, "Email not registered"); return(StatusCode(412, ErrorsList)); } RegistrationMethod registrationMethod = await _DbContext.RegistrationMethods.FirstOrDefaultAsync(rm => rm.User.Id == user.Id).ConfigureAwait(false); if (registrationMethod.Type != RegistrationTypes.Application) { CoreFunc.Error(ref ErrorsList, $"Your account is linked to your {registrationMethod.Type} account."); return(StatusCode(412, ErrorsList)); } if (user.LockoutEnabled) { var currentLockoutDate = await _UserManager.GetLockoutEndDateAsync(user).ConfigureAwait(false); if (user.LockoutEnd > DateTimeOffset.UtcNow) { CoreFunc.Error(ref ErrorsList, string.Format("Account Locked for {0}" , CoreFunc.CompareWithCurrentTime(user.LockoutEnd))); return(StatusCode(412, ErrorsList)); } await _UserManager.SetLockoutEnabledAsync(user, false).ConfigureAwait(false); await _UserManager.ResetAccessFailedCountAsync(user).ConfigureAwait(false); } Request.Headers.TryGetValue("Origin", out StringValues OriginValue); if (!await _EmailService.PasswordResetAsync(user, OriginValue).ConfigureAwait(false)) { CoreFunc.Error(ref ErrorsList, "Unable to send email."); return(StatusCode(417, ErrorsList)); } return(Created("", "Created")); } 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> DownloadData([FromBody] string currentPassword) { try { User user = await _DbContext.Users .Include(u => u.Role) .Include(u => u.RegistrationMethod) .SingleOrDefaultAsync(u => u.Id == AppFunc.GetUserId(User)).ConfigureAwait(false); if (user.RegistrationMethod.Type == RegistrationTypes.Application && !await _UserManager.CheckPasswordAsync(user, currentPassword).ConfigureAwait(false)) { CoreFunc.Error(ref ErrorsList, "Current Password is incorrect."); return(StatusCode(412, ErrorsList)); } List <Order> orders = await _DbContext.Orders .Include(o => o.User) .Include(o => o.OrderItems) .Include(o => o.Dispute) .ThenInclude(c => c.Messages) .Include(o => o.Payment) .Include(o => o.Coupon) .Where(u => u.User.Id == AppFunc.GetUserId(User)).ToListAsync().ConfigureAwait(false); List <Communication> questions = await _DbContext.Communications .Include(c => c.Messages) .Where(c => c.Email.ToUpper() == user.NormalizedEmail).ToListAsync().ConfigureAwait(false); List <Comment> comments = await _DbContext.Comments .Include(c => c.User) .Where(c => c.User.Id == user.Id).ToListAsync().ConfigureAwait(false); List <Address> addresses = await _DbContext.Addresses .Include(c => c.User) .Where(c => c.User.Id == user.Id).ToListAsync().ConfigureAwait(false); dynamic userData = new { userInfo = user, orders, questions, comments, addresses }; return(Ok(JsonConvert.SerializeObject(userData, Formatting.Indented, new JsonSerializerSettings { Converters = new List <JsonConverter> { new StringEnumConverter(), new DecimalFormatConverter() }, ContractResolver = new DynamicContractResolver("Id", "Password", "AccessClaim", "OrderLength", "HasOrder" , "DeliveryOption", "Order_Id", "captchaToken", "AddressId", "UserId", "ProductId", "ImagePath", "ExternalLinkedId") }))); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> Get( int selectedPage = 1, int maxItemsPerPage = 5, string searchValue = CoreConst.GetAllRecords, string filterRole = CoreConst.GetAllRecords, bool isSortAsce = true, string sortName = "Name" ) { try { _ = int.TryParse(filterRole, out int filterRoleId); int totalCount = await _DbContext.Users .Include(u => u.Role) .Where(u => filterRole.Equals(CoreConst.GetAllRecords) || u.Role.Id == filterRoleId) .CountAsync(u => searchValue.Equals(CoreConst.GetAllRecords) || (u.FirstName.Contains(searchValue) || searchValue.Equals(CoreConst.GetAllRecords) || u.Surname.Contains(searchValue) || searchValue.Equals(CoreConst.GetAllRecords) || u.Id.ToString().Equals(searchValue) || searchValue.Equals(CoreConst.GetAllRecords) || u.Email.Contains(searchValue) || searchValue.Equals(CoreConst.GetAllRecords) || u.PhoneNumber.Contains(searchValue)) ).ConfigureAwait(false); List <User> list = await _DbContext.Users .Include(u => u.Role) .Include(u => u.RegistrationMethod) .Where(u => filterRole.Equals(CoreConst.GetAllRecords) || u.Role.Id == filterRoleId) .Where(u => searchValue.Equals(CoreConst.GetAllRecords) || u.FirstName.Contains(searchValue) || searchValue.Equals(CoreConst.GetAllRecords) || u.Surname.Contains(searchValue) || searchValue.Equals(CoreConst.GetAllRecords) || u.Id.ToString().Equals(searchValue) || searchValue.Equals(CoreConst.GetAllRecords) || u.Email.Contains(searchValue) || searchValue.Equals(CoreConst.GetAllRecords) || u.PhoneNumber.Contains(searchValue)) .OrderByDynamic(sortName, isSortAsce) .Skip((selectedPage - 1) * maxItemsPerPage) .Take(maxItemsPerPage) .Include(u => u.Orders) .ToListAsync() .ConfigureAwait(false); list.ForEach(u => { u.OrderLength = u.Orders.Count(o => o.Status == OrderStatusType.Confirmed || o.Status == OrderStatusType.InProgress || (o.Dispute != null && o.Dispute.Status)); u.HasOrder = u.Orders.Count > 0; }); return(Ok(new MultiResult <List <User>, int>(list, totalCount, CoreFunc.GetCustomAttributeTypedArgument(this.ControllerContext)))); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
[Authorize(AppConst.AccessPolicies.Public)] /// Ready For Test public async Task <IActionResult> All() { try { return(Ok(await _DbContext.DeliveryOptions.ToListAsync())); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> AllSecret() { try { return(Ok(await _DbContext.Categories.ToListAsync().ConfigureAwait(false))); } 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)); } }
[Authorize(AppConst.AccessPolicies.Official)] /// Ready For Test public async Task <IActionResult> All() { try { return(Ok(await _DbContext.Addresses. Where(t => t.User.Id == AppFunc.GetUserId(User)).ToListAsync())); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }
public async Task <IActionResult> AllPublic() { try { return(Ok(await _DbContext.Categories.Include(c => c.Products) .Where(c => c.Products.Count(p => p.Status) > 0) .ToListAsync().ConfigureAwait(false))); } catch (Exception ex) { CoreFunc.Error(ref ErrorsList, _LoggingService.LogException(Request.Path, ex, User)); return(StatusCode(417, ErrorsList)); } }