public async Task <UseCaseResult <BusinessModel> > Handle(GetBusiness request, CancellationToken cancellationToken) { try { var query = _businessRepository.All(); if (!string.IsNullOrEmpty(request.Name)) { query = query.Where(b => b.Name == request.Name); } else if (!string.IsNullOrEmpty(request.AltReference)) { query = query.Where(b => b.AltReference == request.AltReference); } else if (!string.IsNullOrEmpty(request.UserId)) { query = query.Where(b => b.UserId == request.UserId); } else { return(UseCaseResult <BusinessModel> .CreateError(resultText : "No User Id")); } return(await Task.Run(() => { return UseCaseResult <BusinessModel> .Create(_mapper.Map <BusinessModel>(query.SingleOrDefault()), resultText: "GetBusiness"); })); } catch (Exception e) { return(UseCaseResult <BusinessModel> .CreateError(resultText : e.Message)); } }
public async Task <UseCaseResult <StoredFileModel> > Handle(UploadFile request, CancellationToken cancellationToken) { try { if (!string.IsNullOrEmpty(request.FileName)) { if (request.Contents.Length > 0) { return(UseCaseResult <StoredFileModel> .Create(_mapper.Map <IFileProperties, StoredFileModel>(await _fileStoreService.PostAsync(request.FileName, request.Contents, request.ContentType)))); } else { return(UseCaseResult <StoredFileModel> .CreateError(resultText : "File Contents are empty")); } } else { return(UseCaseResult <StoredFileModel> .CreateError(resultText : "No File Name Specified")); } } catch (Exception e) { return(UseCaseResult <StoredFileModel> .CreateError(resultText : e.Message)); } }
public async Task <UseCaseResult <IEnumerable <JobModel> > > Handle(GetJobs request, CancellationToken cancellationToken) { try { return(await Task.Run(() => { var query = _jobRepository.All(); if (!string.IsNullOrEmpty(request.UserId)) { query = query.Where(j => j.UserId == request.UserId); } else if (!string.IsNullOrEmpty(request.BusinessId)) { query = query.Where(b => b.Quotes.Any(q => q.QuotedByBusinessId == Guid.Parse(request.BusinessId))); } if (request.Page.HasValue && request.Size.HasValue) { query = query.Skip(request.Page.Value *request.Size.Value).Take(request.Size.Value); } else { // limit results to 500 query.Take(500); } return UseCaseResult <IEnumerable <JobModel> > .Create(_mapper.Map <IEnumerable <JobModel> >(query.ToList()), resultText: "GetBusinesses"); })); } catch (Exception e) { _logger.LogError(e, ""); return(UseCaseResult <IEnumerable <JobModel> > .CreateError(resultText : e.Message)); } }
private async Task PerformUseCase(UseCase useCase) { var repeaterBundles = useCase.RepeaterBundles?.Count > 0 ? useCase.RepeaterBundles : new List <RepeaterBundle> { new RepeaterBundle { RepeaterName = "No Repeat" } }; for (var i = 0; i < repeaterBundles.Count; i++) { var repeaterBundle = repeaterBundles[i]; _CurrentRepeaterBundle = repeaterBundle; var steps = useCase.Steps; var valueTests = useCase.ValueTests; //TODO: What is going on here? Why are we creating a variable and then retrieving it from somewhere else? Is there are reason for this? _CurrentUseCaseResult = new UseCaseResult(useCase, repeaterBundle.RepeaterName); //TODO: This is really nasty. There is no way to get test values across repeater bundles. Every time a Use Case repeats, the test values are cleared out. But the test values won't be cleared out if there are no repeats if (i > 0) { _CurrentUseCaseResult.TestValues.Clear(); } await PerformStepsAsync(steps, valueTests); //TODO: This really not good. This should be part of validating the script but is just here because it is easy. var valueTestBase = useCase.ValueTests.FirstOrDefault(vt => !_CurrentUseCaseResult.TestValueResults.Select(tvr => tvr.ValueKey).Contains(vt.ValueKey)); if (valueTestBase != null) { throw new Exception($"The value test with a value key of {valueTestBase.ValueKey} does not have a step to get the value"); } } }
public async Task <UseCaseResult <IEnumerable <BusinessModel> > > Handle(GetBusinesses request, CancellationToken cancellationToken) { try { return(await Task.Run(() => { var query = _businessRepository.All(); if (request.Services != null) { query = query.Where(b => b.BusinessServices.Any(s => request.Services.Contains(s.Name) || request.Services.Contains(s.CategoryName))); // this works } if (request.Areas != null) { query = query.Where(b => b.ServiceAreas.Any(s => request.Areas.Contains(s.Name))); } if (request.Page.HasValue && request.Size.HasValue) { query = query.Skip(request.Page.Value *request.Size.Value).Take(request.Size.Value); } else { // limit results to 500 query.Take(500); } return UseCaseResult <IEnumerable <BusinessModel> > .Create(_mapper.Map <IEnumerable <BusinessModel> >(query.ToList()), resultText: "GetBusinesses"); })); } catch (Exception e) { return(UseCaseResult <IEnumerable <BusinessModel> > .CreateError(resultText : e.Message)); } }
public async Task <UseCaseResult <IEnumerable <ReviewModel> > > Handle(GetReviews request, CancellationToken cancellationToken) { try { return(await Task.Run(() => { var query = _reviewRepository.All(); if (request.BusinessId != Guid.Empty) { query = query.Where(r => r.BusinessId == request.BusinessId); // this works } if (request.Page.HasValue && request.Size.HasValue) { query = query.Skip(request.Page.Value *request.Size.Value).Take(request.Size.Value); } else { // limit results to 500 query.Take(500); } return UseCaseResult <IEnumerable <ReviewModel> > .Create(_mapper.Map <IEnumerable <ReviewModel> >(query.ToList()), resultText: "Get Reviews"); })); } catch (Exception e) { return(new UseCaseResult <IEnumerable <ReviewModel> > { ResultCode = "Error", ResultText = e.Message, Data = null }); } }
public async Task <UseCaseResult <Guid> > Handle([NotNull] EditEvent request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var currentDiver = await currentUser.GetCurrentDiverAsync(); if (currentDiver == null) { logger.LogError("No diver record found for username [{username}]!", currentUser.Username); return(UseCaseResult <Guid> .NotFound()); } var evt = await eventRepository.FindByIdAsync(request.EventId); if (evt == null) { var newEvent = new Domain.Entities.Event( request.Title, request.Description, request.Location, request.MeetingPoint, request.StartTime, request.EndTime, currentDiver.Id); await eventRepository.InsertAsync(newEvent); return(UseCaseResult <Guid> .Success(newEvent.Id)); } var wasEdited = evt.Edit( currentDiver.Id, request.Title, request.Description, request.Location, request.MeetingPoint, request.StartTime, request.EndTime); if (!wasEdited) { return(UseCaseResult <Guid> .Fail(resultCategory : ResultCategory.AccessDenied)); } await eventRepository.UpdateAsync(evt); return(UseCaseResult <Guid> .Success(evt.Id)); }
public async Task <UseCaseResult <IEnumerable <ServiceArea> > > Handle(GetServiceAreas request, CancellationToken cancellationToken) { try { return(await Task.Run(() => { return UseCaseResult <IEnumerable <ServiceArea> > .Create(_metaInformationService.ServiceAreas, resultText: "Get Service Areas"); })); } catch (Exception e) { return(UseCaseResult <IEnumerable <ServiceArea> > .CreateError(resultText : e.Message)); } }
public async Task <UseCaseResult <string> > Handle([NotNull] AddMember request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException(nameof(request)); } logger.LogInformation("Adding member [{userName}]", request.UserName, request); if (!await currentUser.GetIsAdminAsync()) { logger.LogError("Access denied for user [{currentUser}]!", currentUser.Username); return(UseCaseResult <string> .AccessDenied()); } var user = await userManager.FindByNameAsync(request.UserName); if (user == null) { logger.LogError("Identity user [{username}] not found!", request.UserName); return(UseCaseResult <string> .NotFound()); } var diver = new Diver(user, request.FirstName, request.LastName); await AutoConfirmEmailAddress(user); await userManager.AddToRoleAsync(user, Rolenames.Tauchbold); await diverRepository.InsertAsync(diver); var warningMessage = ""; if (user.LockoutEnabled) { logger.LogWarning("User [{username}] is locked out!", request.UserName); warningMessage += "Mitglied ist noch gesperrt (LockoutEnabled). "; } if (!user.EmailConfirmed) { logger.LogWarning("User [{username}] has not confirmed email address yet!", request.UserName); warningMessage += "Mitglied hat seine Emailadresse noch nicht bestätigt!"; } logger.LogInformation("User [{username}] added as a member.", request.UserName); return(UseCaseResult <string> .Success(warningMessage.Trim())); }
public async Task <UseCaseResult <bool> > Handle(DeleteFile request, CancellationToken cancellationToken) { try { if (!string.IsNullOrEmpty(request.FileReference)) { return(UseCaseResult <bool> .Create(await _fileStoreService.DeleteAsync(request.FileReference))); } else { return(UseCaseResult <bool> .CreateError(resultText : "File Reference not provided")); } } catch (Exception e) { return(UseCaseResult <bool> .CreateError(resultText : e.Message)); } }
public async Task <UseCaseResult <BusinessModel> > Handle(UpdateBusiness request, CancellationToken cancellationToken) { try { var business = _repository.All().Where(b => b.Id == request.Id).SingleOrDefault(); if (business == null) { business = new Business(); business.UserId = request.Context.UserId; } business.Name = request.Name; //business.AltReference = request.Name.ToLower()..Replace(" ", "-"); business.AltReference = Regex.Replace(request.Name.ToLower(), @"[^A-Za-z0-9_\.~]+", "-"); business.Owner = request.Owner; business.Tagline = request.Tagline; business.Description = request.Description; business.Picture = request.Picture; business.IsTrading = request.IsTrading; business.Address = request.Address; business.ServiceAreas = request.ServiceAreas; business.BusinessServices = request.BusinessServices; business.ContactMethods = request.ContactMethods; business.StoredFiles = request.StoredFiles; if (business.Id == Guid.Empty) { await _repository.AddAsync(business); return(UseCaseResult <BusinessModel> .Create(_mapper.Map <BusinessModel>(business), resultText : "Update Business")); } else { await _repository.UpdateAsync(business); return(UseCaseResult <BusinessModel> .Create(_mapper.Map <BusinessModel>(business), resultText : "Update Business")); } } catch (Exception e) { return(UseCaseResult <BusinessModel> .CreateError(resultText : e.Message)); } }
public async Task <UseCaseResult <UserModel> > Handle(UpdateUser request, CancellationToken cancellationToken) { try { var user = await _userService.GetUserAsync(request.UserId); if (user != null) { user.Name = request.Name; user.Picture = request.Picture; user.AccountType = request.AccountType; } return(UseCaseResult <UserModel> .Create(_mapper.Map <UserModel>(await _userService.UpdateUserAsync(user)))); } catch (Exception e) { return(UseCaseResult <UserModel> .CreateError(e.Message)); } }
public async Task <UseCaseResult <AuthenticatedUserModel> > Handle(AuthenticateUser request, CancellationToken cancellationToken) { var result = await _authenticationService.AuthenticateAsync(request.Email, request.Password); if (result != null) { var user = await _userService.GetUserByEmailAsync(request.Email); // current signin info if (user != null) { var model = _mapper.Map <AuthenticatedUserModel>(user); model.AccessToken = result.AccessToken; model.IdToken = result.IdToken; model.ExpiresIn = result.ExpiresIn; model.LastSigninDate = DateTime.UtcNow; return(UseCaseResult <AuthenticatedUserModel> .Create(model)); } } return(UseCaseResult <AuthenticatedUserModel> .CreateError()); }
public async Task <UseCaseResult <JobModel> > Handle(GetJob request, CancellationToken cancellationToken) { try { return(await Task.Run(() => { var job = _jobRepository.All().Where(j => j.Id == request.Id).SingleOrDefault(); if (job != null) { return UseCaseResult <JobModel> .Create(_mapper.Map <JobModel>(job), resultText: "Get Business"); } // else throw new Exception("Record not found."); })); } catch (Exception e) { return(UseCaseResult <JobModel> .CreateError(resultText : e.Message)); } }
public async Task <UseCaseResult <DownloadFileModel> > Handle(DownloadFile request, CancellationToken cancellationToken) { try { if (!string.IsNullOrEmpty(request.FileReference)) { var props = _fileStoreService.GetProperties(request.FileReference); var model = new DownloadFileModel { ContentType = props.ContentType, Contents = await _fileStoreService.GetAsync(request.FileReference) }; return(UseCaseResult <DownloadFileModel> .Create(model)); } else { return(UseCaseResult <DownloadFileModel> .CreateError(resultText : "File Reference not found")); } } catch (Exception e) { return(UseCaseResult <DownloadFileModel> .CreateError(resultText : e.Message)); } }
private async Task <Rent> Persist(DomainResponseDto <Rent> rentProductsResponse, UseCaseResult <RentRequirementValidationResult> validationResponse) { // TODO: UnitOfWork var rentCreatedResponse = await _rents.Create(rentProductsResponse.Result); await _renterRentalHistories.Create(new RenterRentalHistory(Guid.NewGuid(), rentCreatedResponse.Response, validationResponse.Result.Renter)); foreach (var product in validationResponse.Result.Products) { product.MarkAsUnavailable(); await _products.Update(product); await _productRentalHistories.Create(new ProductRentalHistory(Guid.NewGuid(), rentCreatedResponse.Response, product, validationResponse.Result.Renter)); } return(rentCreatedResponse.Response); }
public async Task <UseCaseResult <IEnumerable <LogbookEntry> > > Handle([NotNull] SummaryListLogbookEntries request, CancellationToken cancellationToken) { var allEntries = await logbookEntryRepository.GetAllEntriesAsync(false); return(UseCaseResult <IEnumerable <LogbookEntry> > .Success(allEntries)); }