public async Task <RunResult> LaunchAsync(Algorithm algorithm, Run run, RunSettings settings)
{
var filePath = _algorithmFileProvider.GetAlgorithmFilePath(algorithm.CodeName, algorithm.FilePath);
if (!_fileSystemWrapper.ExistsFile(filePath))
{
throw new NotFoundException("Given algorithm execution file doesn't exists");
}
using (var uow = _unitOfWorkProvider.Create())
{
// Download and Transform file arguments
await _algorithmFileProvider.DownloadFiles(settings.Arguments, run.UserId);
var stringArguments = settings.Arguments.Select(arg => arg.ToString()).ToList();
var runFolder = _temporaryFileProvider.CreateTemporaryFolder();
var tokenSource = new CancellationTokenSource(_options.Value.HardTimeoutInSeconds * 1000);
var task = _processService.RunAsync(new ProcessOptions(filePath, stringArguments, runFolder), tokenSource.Token);
var lightTimeout = !settings.Timeout.HasValue || settings.Timeout < 0
? _options.Value.LightTimeoutInSeconds
: settings.Timeout.Value;
var result = await task.WithTimeout(TimeSpan.FromSeconds(lightTimeout));
if (!result.Completed)
{
// timeout/cancellation logic
task.ContinueWith(async action =>
{
await AfterRunFinished(run.Id, action, runFolder);
}, TaskContinuationOptions.None).SupressError();
return(new RunResult()
{
RunId = run.Id,
Result = run.Result,
CreatedAt = run.CreatedAt
});
}
var savedRun = await SaveSuccessRun(runFolder, run, result.Value);
await uow.CommitAsync();
return(new RunResult()
{
FileId = savedRun.FileId,
StdOut = result.Value.StdOut,
StdErr = result.Value.StdError,
RunId = run.Id,
Result = savedRun.Result,
CreatedAt = result.Value.StartedAt,
FinishedAt = result.Value.FinishedAt
});
}
}
public ActionResult ApplyDiscountOrGiftCardCode(DiscountOrGiftCardCodeDto model)
{
try
{
using (var uow = _uowProvider.Create())
{
var store = CurrentPage.GetStore();
var order = _sessionManager.GetOrCreateCurrentOrder(store.Id)
.AsWritable(uow)
.Redeem(model.Code);
_orderService.SaveOrder(order);
uow.Complete();
}
}
catch (ValidationException ex)
{
ModelState.AddModelError("", "Failed to redeem discount code");
return(CurrentUmbracoPage());
}
return(RedirectToCurrentUmbracoPage());
}
public ActionResult AddToCart(AddToCartDto postModel)
{
try
{
using (var uow = _uowProvider.Create())
{
var store = CurrentPage.GetStore();
var order = _sessionManager.GetOrCreateCurrentOrder(store.Id)
.AsWritable(uow)
.AddProduct(postModel.ProductReference, postModel.ProductVariantReference, 1);
_orderService.SaveOrder(order);
uow.Complete();
}
}
catch (ValidationException ex)
{
ModelState.AddModelError("productReference", "Failed to add product to cart");
return(CurrentUmbracoPage());
}
TempData["addedProductReference"] = postModel.ProductReference;
return(RedirectToCurrentUmbracoPage());
}
public async Task ExecuteAsync_ComplexWherePredicate_ReturnsCorrectQueryResult()
{
QueryResult <Freelancer> actualQueryResult;
var categoryQuery = Initializer.Container.Resolve <IQuery <Freelancer> >();
var expectedQueryResult = new QueryResult <Freelancer>(new List <Freelancer> {
new Freelancer(Sex.MALE, new DateTime(1968, 12, 5), "Bardejov", "*****@*****.**", "Karol Kovach", "som super")
}, 1);
var predicate = new CompositePredicate(new List <IPredicate>
{
new SimplePredicate(nameof(Freelancer.Sex), ValueComparingOperator.Equal, Sex.MALE),
new CompositePredicate(new List <IPredicate>
{
new SimplePredicate(nameof(Freelancer.Location), ValueComparingOperator.Equal, "Brno"),
new SimplePredicate(nameof(Freelancer.Location), ValueComparingOperator.Equal, "Liberec")
}, LogicalOperator.OR)
});
using (unitOfWorkProvider.Create())
{
actualQueryResult = await categoryQuery.Where(predicate).ExecuteAsync();
}
Assert.AreEqual(actualQueryResult, expectedQueryResult);
}
public async Task <QueryResultDto <TDto, TFilterDto> > GetAllItemsAsync()
{
using (UnitOfWorkProvider.Create())
{
return(await Service.ListAllAsync());
}
}
public async Task <IActionResult> ConfirmEmail(string userId, string code)
{
if (userId == null || code == null)
{
return(ErrorView());
}
using (_unitOfWorkProvider.Create())
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(ErrorView());
}
var result = await _userManager.ConfirmEmailAsync(user, code);
if (result.Succeeded)
{
return(View(InitializeLayoutModel("Confirm Email")));
}
else
{
return(ErrorView());
}
}
}
public ActionResult UpdateOrderInformation(UpdateOrderInformationDto model)
{
try
{
using (var uow = _uowProvider.Create())
{
var store = CurrentPage.GetStore();
var order = _sessionManager.GetOrCreateCurrentOrder(store.Id)
.AsWritable(uow)
.SetProperties(new Dictionary <string, string>
{
{ Constants.Properties.Customer.EmailPropertyAlias, model.Email },
{ "marketingOptIn", model.MarketingOptIn ? "1" : "0" },
{ Constants.Properties.Customer.FirstNamePropertyAlias, model.BillingFirstName },
{ Constants.Properties.Customer.LastNamePropertyAlias, model.BillingLastName },
{ "billingAddressLine1", model.BillingAddressLine1 },
{ "billingAddressLine2", model.BillingAddressLine2 },
{ "billingCity", model.BillingCity },
{ "billingZipCode", model.BillingZipCode },
{ "billingTelephone", model.BillingTelephone },
{ "shippingSameAsBilling", model.ShippingSameAsBilling ? "1" : "0" },
{ "shippingFirstName", model.ShippingSameAsBilling ? model.BillingFirstName : model.ShippingFirstName },
{ "shippingLastName", model.ShippingSameAsBilling ? model.BillingLastName : model.ShippingLastName },
{ "shippingAddressLine1", model.ShippingSameAsBilling ? model.BillingAddressLine1 : model.ShippingAddressLine1 },
{ "shippingAddressLine2", model.ShippingSameAsBilling ? model.BillingAddressLine2 : model.ShippingAddressLine2 },
{ "shippingCity", model.ShippingSameAsBilling ? model.BillingCity : model.ShippingCity },
{ "shippingZipCode", model.ShippingSameAsBilling ? model.BillingZipCode : model.ShippingZipCode },
{ "shippingTelephone", model.ShippingSameAsBilling ? model.BillingTelephone : model.ShippingTelephone },
{ "comments", model.Comments }
})
.SetPaymentCountryRegion(model.BillingCountry, null)
.SetShippingCountryRegion(model.ShippingSameAsBilling ? model.BillingCountry : model.ShippingCountry, null);
_orderService.SaveOrder(order);
uow.Complete();
}
}
catch (ValidationException ex)
{
ModelState.AddModelError("", "Failed to update information");
return(CurrentUmbracoPage());
}
if (model.NextStep.HasValue)
{
return(RedirectToUmbracoPage(model.NextStep.Value));
}
return(RedirectToCurrentUmbracoPage());
}
public async Task GetCategoryAsync_AlreadyStoredInDBNoIncludes_ReturnsCorrectCategory()
{
Category skodaCategory;
using (unitOfWorkProvider.Create())
{
skodaCategory = await categoryRepository.GetAsync(skodaCategoryId);
}
Assert.AreEqual(skodaCategory.Id, skodaCategoryId);
}
public async Task GetCorporationAsync_AlreadyStoredInDBNoIncludes_ReturnsCorrectCorporation()
{
Corporation gotCorporation;
using (unitOfWorkProvider.Create())
{
gotCorporation = await corporationRepository.GetAsync(2);
}
Assert.AreEqual(gotCorporation.Id, 2);
}
public async Task GetFirstItemAsync_AlreadyStoredInDBNoIncludes_ReturnsCorrectUser()
{
Item firstItem;
using (unitOfWorkProvider.Create())
{
firstItem = await usersRepository.GetAsync(EFTestsInstaller.ItemUser1.Id);
}
firstItem.Should().BeEquivalentTo(EFTestsInstaller.ItemUser1);
}
public async Task GetAccountAsync()
{
Account Ivan;
using (unitOfWorkProvider.Create())
{
Ivan = await accountRepository.GetAsync(guid1);
}
Assert.AreEqual(Ivan.Username, accountIvan.Username);
}
public async Task RevokeAsync(int userId)
{
using (var uow = _unitOfWorkProvider.Create())
{
var user = await _userRepository.GetById(userId);
user.ApiKey = _apiKeyGenerator.Generate();
await uow.CommitAsync();
}
}
public async Task GetDoctorAcsync_InDB_NoIncludes_ReturnsCorrectDoctor()
{
Doctor doctorJohnDoe;
using (unitOfWorkProvider.Create())
{
doctorJohnDoe = await doctorRepository.GetAsync(doctorJohnDoeId);
}
Assert.AreEqual(doctorJohnDoe.Id, doctorJohnDoeId);
}
public async Task GetAuctionAsync_AlreadyStoredInDBNoIncludes_ReturnsCorrectAuction()
{
Auction kodiaqAuction;
using (unitOfWorkProvider.Create())
{
kodiaqAuction = await auctionRepository.GetAsync(kodiaqAuctionId);
}
Assert.AreEqual(kodiaqAuction.Id, kodiaqAuctionId);
}
public async Task GetCategoryAsync_StoredInDbNoIncludes_ReturnsCorrectCategory()
{
Category smartphoneCategory;
using (_unitOfWorkProvider.Create())
{
smartphoneCategory = await _categoryRepository.GetAsync(_smartphonesCategoryId);
}
Assert.Equal(_smartphonesCategoryId, smartphoneCategory.Id);
}
public async Task GetOfferAsync_AlreadyStoredInDBNoIncludes_ReturnsCorrectOffer()
{
JobOffer offer;
using (unitOfWorkProvider.Create())
{
offer = await repository.GetAsync(Initializer.GoogleAndroidOffer.Id);
}
Assert.NotNull(offer);
Assert.AreEqual(offer.Id, Initializer.GoogleAndroidOffer.Id);
}
public async Task GetUserAsync_AlreadyStoredInDBNoIncludes_ReturnsCorrectUser()
{
User user;
using (unitOfWorkProvider.Create())
{
user = await userRepository.GetAsync(Initializer.MadkiUser.Id);
}
Assert.NotNull(user);
Assert.AreEqual(user.Id, Initializer.MadkiUser.Id);
}
public async Task GetAnswerAsync_AlreadyStoredInDBNoIncludes_ReturnsCorrectAnswer()
{
QuestionAnswer answer;
using (unitOfWorkProvider.Create())
{
answer = await repository.GetAsync(Initializer.AnswerJavaEeRedHat.Id);
}
Assert.NotNull(answer);
Assert.AreEqual(answer.Id, Initializer.AnswerJavaEeRedHat.Id);
}
public async Task GetSkillAsync_AlreadyStoredInDBNoIncludes_ReturnsCorrectSkill()
{
SkillTag skill;
using (unitOfWorkProvider.Create())
{
skill = await repository.GetAsync(Initializer.JavaSkill.Id);
}
Assert.NotNull(skill);
Assert.AreEqual(skill.Id, Initializer.JavaSkill.Id);
}
public async Task GetQuestionAsync_AlreadyStoredInDBNoIncludes_ReturnsCorrectQuestion()
{
Question question;
using (unitOfWorkProvider.Create())
{
question = await repository.GetAsync(Initializer.JavaExperienceQuestion.Id);
}
Assert.NotNull(question);
Assert.AreEqual(question.Id, Initializer.JavaExperienceQuestion.Id);
}
public async Task GetEmployerAsync_AlreadyStoredInDBNoIncludes_ReturnsCorrectEmployer()
{
Employer employer;
using (unitOfWorkProvider.Create())
{
employer = await employerRepository.GetAsync(Initializer.RedHatEmployer.Id);
}
Assert.NotNull(employer);
Assert.AreEqual(employer.Id, Initializer.RedHatEmployer.Id);
}
public async Task GetApplicationAsync_AlreadyStoredInDBNoIncludes_ReturnsCorrectApplication()
{
JobApplication application;
using (unitOfWorkProvider.Create())
{
application = await repository.GetAsync(Initializer.ApplicationRedHatQuality.Id);
}
Assert.NotNull(application);
Assert.AreEqual(application.Id, Initializer.ApplicationRedHatQuality.Id);
}
private void ExportCustomers()
{
try
{
SynchronizeStampEntity synchronizeStamp = null;
DateTime stampTo = DateTime.Now;
using (var uow = unitOfWorkProvider.CreateReadOnly())
{
synchronizeStamp = synchronizeStampRepository.Get(SynchronizeCodes.Customer, SynchronizeDirectionType.Export);
}
DateTime stampFrom = synchronizeStamp?.DateTimeStamp ?? DateTime.MinValue;
IReadOnlyCollection <int> customerIds = null;
using (var uow = unitOfWorkProvider.CreateReadOnly())
{
customerIds = customerRepository.GetModifiedCustomersIdsWithWebAccount(stampFrom, stampTo);
}
if (Enumerable.Any(customerIds))
{
logger.LogDebug($"Starting synchronize {customerIds.Count} customers");
var parallelOptions = new ParallelOptions
{
MaxDegreeOfParallelism = 1
};
Parallel.ForEach(customerIds, parallelOptions, x => ProcessCustomerId(x, stampTo));
if (synchronizeStamp == null)
{
synchronizeStamp = SynchronizeStampFactory.Create(SynchronizeCodes.Customer, SynchronizeDirectionType.Export);
}
synchronizeStamp.DateTimeStamp = stampTo;
using (var uow = unitOfWorkProvider.Create())
{
synchronizeStampRepository.SaveOrUpdate(synchronizeStamp);
uow.Commit();
}
}
}
catch (Exception ex)
{
logger.LogError($"Synchronize customers to PrestaShop error: {ex.ToString()}");
}
}
public async Task GetCategoryAsync_AlreadyStoredInDBNoIncludes_ReturnsCorrectCategory()
{
// Arrange
Album androidCategory;
// Act
using (unitOfWorkProvider.Create())
{
androidCategory = await categoryRepository.GetAsync(androidCategoryId);
}
// Assert
Assert.AreEqual(androidCategory.Id, androidCategoryId);
}
public async Task GetProductAsync_AlreadyStoredInDBNoIncludes_ReturnsCorrectProduct()
{
// Arrange
Product samsungGalaxyJ7Product;
// Act
using (unitOfWorkProvider.Create())
{
samsungGalaxyJ7Product = await productRepository.GetAsync(samsungGalaxyJ7Id);
}
// Assert
Assert.AreEqual(samsungGalaxyJ7Product.Id, samsungGalaxyJ7Id);
}
public async Task InsertAsync(TodoItemInsertModel todoItemInsertModel)
{
var todoItemEntity = mapper.Map <TodoItemEntity>(todoItemInsertModel);
using var unitOfWork = unitOfWorkProvider.Create();
if (todoItemInsertModel.Username != null)
{
var userEntity = await userRepository.GetByUsernameAsync(todoItemInsertModel.Username);
todoItemEntity.UserId = userEntity.Id;
}
todoItemRepository.Insert(todoItemEntity);
await unitOfWork.CommitAsync();
}
private void SynchronizeOrder()
{
logger.LogDebug("Starting synchronize orders");
try
{
SynchronizeStampEntity synchronizeStamp = null;
DateTime stampTo = DateTime.Now;
using (var uow = unitOfWorkProvider.CreateReadOnly())
{
synchronizeStamp = synchronizeStampRepository.Get(SynchronizeCodes.Order, SynchronizeDirectionType.Import);
}
DateTime stampFrom = synchronizeStamp?.DateTimeStamp ?? DateTime.MinValue;
IReadOnlyCollection <long> psOrderIds = psOrderRepository.GetAllModifiedBetween(stampFrom, stampTo);
if (Enumerable.Any(psOrderIds))
{
logger.LogDebug($"Starting synchronize {psOrderIds.Count} orders");
var parallelOptions = new ParallelOptions
{
MaxDegreeOfParallelism = 1
};
Parallel.ForEach(psOrderIds, parallelOptions, x => ProcessOrderId(x, stampTo));
if (synchronizeStamp == null)
{
synchronizeStamp = SynchronizeStampFactory.Create(SynchronizeCodes.Order, SynchronizeDirectionType.Import);
}
synchronizeStamp.DateTimeStamp = stampTo;
using (var uow = unitOfWorkProvider.Create())
{
synchronizeStampRepository.SaveOrUpdate(synchronizeStamp);
uow.Commit();
}
}
}
catch (Exception ex)
{
logger.LogError($"Synchronize orders from PrestaShop error: {ex}");
}
}
private async Task <RunResultMessage> ProcessInternalAsync(CreateAlgorithmMessage request)
{
_logger.LogInformation("Processing message - Run Id: " + request.Run.Id);
using (_container.OpenScope())
{
using (var uow = _unitOfWorkProvider.Create(DbContextOptions.DisableTransactionMode))
{
uow.Context.Runs.Attach(request.Run);
var result = await _launchService.LaunchAsync(request.Algorithm, request.Run,
new RunSettings { Arguments = request.Arguments, Timeout = request.Timeout });
return(new RunResultMessage()
{
StdOut = result.StdOut,
StdErr = result.StdErr,
CreatedAt = result.CreatedAt,
FinishedAt = result.FinishedAt,
FileId = result.FileId,
Result = result.Result,
RunId = result.RunId
});
}
}
}
public async Task <CreateOfferResult> Handle(CreateOfferCommand request, CancellationToken cancellationToken)
{
//calculate price
var priceParams = ConstructPriceParams(request);
var price = await pricingService.CalculatePrice(priceParams);
var o = Offer.ForPrice(
priceParams.ProductCode,
priceParams.PolicyFrom,
priceParams.PolicyTo,
null,
price
);
//create and save offer
using (var uow = uowProvider.Create())
{
uow.Offers.Add(o);
uow.CommitChanges();
//return result
return(ConstructResult(o));
}
}
public async Task <CreatePolicyResult> Handle(CreatePolicyCommand request, CancellationToken cancellationToken)
{
using (var uow = uowProvider.Create())
{
var offer = await uow.Offers.WithNumber(request.OfferNumber);
var customer = new PolicyHolder
(
request.PolicyHolder.FirstName,
request.PolicyHolder.LastName,
request.PolicyHolder.TaxId,
Address.Of
(
request.PolicyHolderAddress.Country,
request.PolicyHolderAddress.ZipCode,
request.PolicyHolderAddress.City,
request.PolicyHolderAddress.Street
)
);
var policy = offer.Buy(customer);
uow.Policies.Add(policy);
await uow.CommitChanges();
await eventPublisher.PublishMessage(PolicyCreated(policy));
return(new CreatePolicyResult
{
PolicyNumber = policy.Number
});
}
}