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));
}
