private async Task <Service> MappingService(PostServiceViewModel vm, string currentUserContext) { Service sv = new Service(); sv.CategoryId = vm.CategoryId; sv.DateCreated = DateTime.Now; sv.PriceOfService = vm.PriceOfService; sv.Description = vm.Description; sv.ServiceName = vm.ServiceName; sv.codeConfirm = RandomCodeSupport.RandomString(6); sv.Status = (await _getPermissionActionQuery.ExecuteAsync(currentUserContext, ConstantFunctions.SERVICE, ActionSetting.CanCreate) || await _checkUserIsAdminQuery.ExecuteAsync(currentUserContext)) ? Status.WaitingApprove : Status.Pending; sv.ServiceImages = vm.listImages.Select(x => new ServiceImage { Path = x.Path != null ? x.Path : "", DateCreated = DateTime.Now, isAvatar = x.IsAvatar }).ToList(); sv.TagServices = vm.tagofServices.Where(x => x.isDelete == false && x.isAdd == false).Select(x => new Model.Entities.ServiceModel.TagService { TagId = Guid.Parse(x.TagId), }).ToList(); return(sv); }
private async Task <PostServiceViewModel> MapViewModel( Service serv, AppUser user, Provider provider) { var query = await _serviceRepository.FindAllAsync(); var providerService = await _providerServiceRepository.FindAllAsync(); var userService = await _userServiceRepository.FindAllAsync(); var providers = await _providerRepository.FindAllAsync(); var getTag = await _tagRepository.FindAllAsync(); var getUserTag = await _tagServiceRepository.FindAllAsync(x => x.ServiceId == serv.Id); var getListTag = (from tag in getTag.ToList() join serviceTag in getUserTag.ToList() on tag.Id equals serviceTag.TagId select new { tag.TagName }).ToList(); var getImage = await _imageRepository.FindAllAsync(x => x.ServiceId == serv.Id); PostServiceViewModel postServiceView = new PostServiceViewModel(); postServiceView.Id = serv.Id.ToString(); postServiceView.listImages = getImage.Select(x => new PostServiceImageViewModel { Path = x.Path, ImageId = x.Id }).ToList(); postServiceView.PriceOfService = serv.PriceOfService; postServiceView.CategoryName = _getByIDCategoryServiceQuery.ExecuteAsync(serv.CategoryId).Result.CategoryName; postServiceView.ServiceName = serv.ServiceName; postServiceView.Status = serv.Status; postServiceView.tagofServices = getListTag.Select(x => new TagofServiceViewModel { TagName = x.TagName }).ToList(); postServiceView.Description = serv.Description; postServiceView.ProviderId = _getProviderInformationQuery.ExecuteAsync(serv.Id, query, providers, providerService).idProvider == "" ? _getUserInformationQuery.ExecuteAsync(serv.Id, query, userService) : _getProviderInformationQuery.ExecuteAsync(serv.Id, query, providers, providerService).idProvider; postServiceView.CategoryId = serv.CategoryId; postServiceView.Author = _getProviderInformationQuery.ExecuteAsync(serv.Id, query, providers, providerService).NameProvider == "" ? _getUserInformationQuery.ExecuteAsync(serv.Id, query, userService) : _getProviderInformationQuery.ExecuteAsync(serv.Id, query, providers, providerService).NameProvider; return(postServiceView); }
public async Task <PostServiceViewModel> ExecuteAsync(PostServiceViewModel model) { try { await _elasticSearchRepository.DeleteAsync(model); return(model); } catch (Exception ex) { await Logging <DeleteService> .ErrorAsync(ex, ActionCommand.COMMAND_DELETE, "System", "Has error"); return(null); } }
private async Task <Service> MappingService(PostServiceViewModel vm, Service sv, string currentUserContext) { sv.CategoryId = vm.CategoryId; sv.DateModified = DateTime.Now; sv.PriceOfService = vm.PriceOfService; sv.Description = vm.Description; sv.ServiceName = vm.ServiceName; sv.Status = (await _getPermissionActionQuery.ExecuteAsync(currentUserContext, ConstantFunctions.SERVICE, ActionSetting.CanCreate) || await _checkUserIsAdminQuery.ExecuteAsync(currentUserContext)) ? Status.WaitingApprove : Status.Pending; sv.TagServices = vm.tagofServices.Where(t => t.isDelete == false && t.isAdd == false).Select(x => new Model.Entities.ServiceModel.TagService { TagId = Guid.Parse(x.TagId), }).ToList(); return(sv); }
public async Task <PostServiceViewModel> ExecuteAsync(PostServiceViewModel postService) { try { await _elasticSearchRepository.SaveSingleAsync(postService); return(postService); } catch (Exception ex) { await Logging <AddNewService> .ErrorAsync(ex, ActionCommand.COMMAND_ADD, "System", "Has error"); throw; } }
public async Task <IActionResult> updatePostService([FromBody] PostServiceViewModel vm) { var model = await _updatePostServiceCommand.ExecuteAsync(vm); return(new OkObjectResult(model)); }
public async Task <IActionResult> RegisterServiceFromUser([FromBody] PostServiceViewModel vm) { var model = await _registerServiceFromUserCommand.ExecuteAsync(vm); return(new OkObjectResult(model)); }
public async Task <IActionResult> RejectPostService([FromBody] PostServiceViewModel vm) { var model = await _rejectPostServiceCommand.ExecuteAsync(vm.Id, vm.Reason); return(new OkObjectResult(model)); }
public async Task <CommandResult <PostServiceViewModel> > ExecuteAsync(PostServiceViewModel vm) { var userId = _httpContextAccessor.HttpContext.User.Identity.Name; var userName = _userManager.FindByIdAsync(userId).Result.UserName; try { //var checkUserIsAdmin = await _checkUserIsAdminQuery.ExecuteAsync(userId); if (await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.SERVICE, ActionSetting.CanCreate) || await _checkUserIsAdminQuery.ExecuteAsync(userId)) { //Add new tag when isAdd equal true List <Tag> newTag = new List <Tag>(); foreach (var item in vm.tagofServices) { if (item.isAdd == true) { newTag.Add(new Tag { TagName = item.TagName }); } } await _tagServiceRepository.Add(newTag); //Mapping between ViewModel and Model of Service var mappingService = await MappingService(vm, userId); await _postServiceRepository.Add(mappingService); //Mapping between ViewModel and Model of UserService var mappingUserService = MappingUserService(mappingService.Id, !string.IsNullOrEmpty(vm.UserId) ? Guid.Parse(vm.UserId) : Guid.Parse(userId)); await _userServiceRepository.Add(mappingUserService); //Add new Tag with Id in TagService foreach (var item in newTag) { Model.Entities.ServiceModel.TagService mappingTag = new Model.Entities.ServiceModel.TagService(); mappingTag.TagId = item.Id; mappingService.TagServices.Add(mappingTag); } await _tagServiceRepository.SaveAsync(); //Write Log await Logging <RegisterServiceFromUserCommand> . InformationAsync(ActionCommand.COMMAND_ADD, userName, JsonConvert.SerializeObject(vm)); var findUserInformation = await _userManager.FindByIdAsync(vm.UserId); //Send mail for user if admin if ((await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.SERVICE, ActionSetting.CanCreate) || await _checkUserIsAdminQuery.ExecuteAsync(userId))) { //Set content for email //Generate code //Create Generate code var generateCode = _configuration.GetSection("Host").GetSection("LinkConfirmService").Value + mappingService.codeConfirm + '_' + mappingService.Id; var getEmailContent = await _getAllEmailServiceQuery.ExecuteAsync(); var getFirstEmail = getEmailContent.Where(x => x.Name == EmailName.Approve_Service).FirstOrDefault(); getFirstEmail.Message = getFirstEmail.Message. Replace(EmailKey.UserNameKey, findUserInformation.Email). Replace(EmailKey.ConfirmLink, generateCode);; ContentEmail(_config.Value.SendGridKey, getFirstEmail.Subject, getFirstEmail.Message, _userManager.FindByIdAsync(!string.IsNullOrEmpty(vm.UserId) ? vm.UserId : userId).Result.Email).Wait(); } //End send mail for user return(new CommandResult <PostServiceViewModel> { isValid = true, myModel = new PostServiceViewModel { Id = mappingService.Id.ToString(), DateCreated = mappingService.DateCreated, IsProvider = false, Author = findUserInformation.UserName + "(" + findUserInformation.Email + ")", UserId = vm.UserId, AvtService = mappingService.ServiceImages.Where(x => x.isAvatar == true).FirstOrDefault().Path, listImages = mappingService.ServiceImages.Select(x => new PostServiceImageViewModel { ImageId = x.Id, IsAvatar = x.isAvatar, Path = x.Path }).ToList(), CategoryId = vm.CategoryId, CategoryName = vm.CategoryName, Description = vm.Description, PriceOfService = vm.PriceOfService, ServiceName = vm.ServiceName, Status = mappingService.Status, tagofServices = mappingService.TagServices.Select(x => new TagofServiceViewModel { TagId = x.TagId.ToString(), TagName = _tagServiceRepository.FindSingleAsync(t => t.Id == x.TagId).Result.TagName }).ToList(), } }); } else { await Logging <RegisterServiceFromUserCommand> . WarningAsync(ActionCommand.COMMAND_ADD, userName, ErrorMessageConstant.ERROR_ADD_PERMISSION); return(new CommandResult <PostServiceViewModel> { isValid = false, errorMessage = ErrorMessageConstant.ERROR_ADD_PERMISSION }); } } catch (System.Exception ex) { await Logging <RegisterServiceFromUserCommand> . ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName, "Had error"); return(new CommandResult <PostServiceViewModel> { isValid = true, myModel = vm, errorMessage = ex.InnerException.ToString() }); } }
public async Task <CommandResult <PostServiceViewModel> > ExecuteAsync(PostServiceViewModel vm) { var userId = _httpContext.HttpContext.User.Identity.Name; var userName = _userManager.FindByIdAsync(userId).Result.UserName; try { var getPermissionForService = await IsOwnService(Guid.Parse(vm.Id)); if (getPermissionForService.isValid || await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.SERVICE, ActionSetting.CanUpdate)) { var currentService = getPermissionForService.myModel; var service = await _serviceRepository.FindByIdAsync(Guid.Parse(vm.Id)); if (service == null) { return(new CommandResult <PostServiceViewModel> { isValid = false, errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID }); } List <Tag> newTag = new List <Tag>(); var tagDelete = await RemoveTag(Guid.Parse(vm.Id), vm.tagofServices); foreach (var item in vm.tagofServices) { if (item.isAdd == true) { newTag.Add(new Tag { TagName = item.TagName }); } } //Update Image List <ServiceImage> lstService = new List <ServiceImage>(); foreach (var item in vm.listImages) { if (item.ImageId == 0) { ServiceImage serviceImage = new ServiceImage() { DateCreated = DateTime.Now, Path = item.Path, isAvatar = item.IsAvatar, ServiceId = Guid.Parse(vm.Id) }; lstService.Add(serviceImage); } else { var imageId = await _serviceImageRepository.FindByIdAsync(item.ImageId); if (imageId != null) { imageId.isAvatar = item.IsAvatar; imageId.DateModified = DateTime.Now; _serviceImageRepository.Update(imageId); } } } var deletImage = await RemoveImage(Guid.Parse(vm.Id), vm.listImages); _serviceImageRepository.RemoveMultiple(deletImage); await _tagServiceRepository.Add(newTag); _tagServiceRepository.RemoveMultiple(tagDelete); var mappingService = await MappingService(vm, service, userId); mappingService.TagServices = null; foreach (var tag in newTag) { Model.Entities.ServiceModel.TagService mappingTag = new Model.Entities.ServiceModel.TagService(); mappingTag.TagId = tag.Id; mappingTag.ServiceId = Guid.Parse(vm.Id); await _serviceOfTagRepository.Add(mappingTag); } _serviceRepository.Update(mappingService); await _serviceRepository.SaveAsync(); //Cotentemail var findEmailUser = await GetEmailUserAsync(mappingService); if (findEmailUser != ErrorMessageConstant.ERROR_CANNOT_FIND_ID) { //Set content for email //Get All email var getAllEmail = await _getAllEmailServiceQuery.ExecuteAsync(); var getFirstEmail = getAllEmail.Where(x => x.Name == EmailName.Approve_Service).FirstOrDefault(); var generateCode = _configuration.GetSection("Host").GetSection("LinkConfirmService").Value + mappingService.codeConfirm + '_' + mappingService.Id; getFirstEmail.Message = getFirstEmail.Message. Replace(EmailKey.ServiceNameKey, mappingService.ServiceName). Replace(EmailKey.UserNameKey, findEmailUser). Replace(EmailKey.ConfirmLink, generateCode); ContentEmail(_configEmail.Value.SendGridKey, getFirstEmail.Subject, getFirstEmail.Message, findEmailUser).Wait(); } else { await Logging <UpdatePostServiceCommand> . WarningAsync(ActionCommand.COMMAND_APPROVE, userName, "Cannot find email user"); return(new CommandResult <PostServiceViewModel> { isValid = false, errorMessage = "Cannot find email user" }); } await Logging <UpdatePostServiceCommand> . InformationAsync(ActionCommand.COMMAND_UPDATE, userName, JsonConvert.SerializeObject(vm)); return(new CommandResult <PostServiceViewModel> { isValid = true, }); } await Logging <UpdatePostServiceCommand> . WarningAsync(ActionCommand.COMMAND_UPDATE, userName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION); return(new CommandResult <PostServiceViewModel> { isValid = false, errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION }); } catch (System.Exception ex) { await Logging <UpdatePostServiceCommand> . ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName, "Has error"); return(new CommandResult <PostServiceViewModel> { isValid = false, errorMessage = ex.InnerException.ToString() }); } }