public async Task <ActiveCardModel> ActivateUserCard(int userId) { var userSeasonLeague = await GetUserActiveLeague(userId); var userCard = _uow.Query <UserCard>() .Include(c => c.UserAnswers) .Where(c => c.UserSeasonLeagueId == userSeasonLeague.Id && c.CardStateId == CardStates.ACTIVE) .SingleOrDefault(); if (userCard == null || userCard.UserAnswers.Count == 10) { if (userCard != null && userCard.UserAnswers.Count == 10) { userCard.CardStateId = CardStates.FINISHED; _uow.Update <UserCard>(userCard); _uow.Commit(); } userCard = new UserCard() { CardId = GetRandomCardId(), CardStateId = CardStates.ACTIVE, TimeStamp = GlobalSettings.CURRENT_DATETIME, UserSeasonLeagueId = userSeasonLeague.Id }; _uow.Add <UserCard>(userCard); _uow.Commit(); } return(await GetActiveCardId(userId)); }
public void Add(BookViewModel bookViewModel) { var result = mapper.Map <Book>(bookViewModel); var genre = unitOfWork.Get <int, Genre>(result.GenreId); result.Genre = genre; using (var transaction = unitOfWork.BeginTransaction()) { try { result.BookLanguages = new List <BookLanguage>(); if (bookViewModel.LanguageIds != null) { foreach (int languageId in bookViewModel.LanguageIds) { var bookLanguage = new BookLanguage() { BookId = result.Id, LanguageId = languageId }; result.BookLanguages.Add(bookLanguage); unitOfWork.Add <int, BookLanguage>(bookLanguage); } } unitOfWork.Add <int, Book>(result); unitOfWork.SaveChanges(); transaction.Commit(); } catch (Exception ex) { transaction.Rollback(); throw ex; } } }
public void Add(NewsViewModel viewModel) { viewModel = Tags(viewModel); var result = mapper.Map <News>(viewModel); var category = unitOfWork.Get <Category>(result.CategoryId.GetValueOrDefault()); result.Category = category; var author = unitOfWork.Get <User>(result.AuthorId.GetValueOrDefault()); result.Author = author; unitOfWork.Add(result); result.NewsTags = new List <NewsTag>(); if (viewModel.TagsIds != null) { foreach (int tagId in viewModel.TagsIds) { var newsTag = new NewsTag() { NewsId = result.Id, TagId = tagId }; result.NewsTags.Add(newsTag); unitOfWork.Add <NewsTag>(newsTag); } } unitOfWork.SaveChanges(); }
public Task <Result <OrderRoot> > PlaceNewOrder(Guid customerId) => _repository .Get <Contractor>(customerId) .OnSuccess(customer => SnapBuyer(customer)) .OnSuccess(buyerSnapshot => OrderRoot.Create(Guid.NewGuid(), buyerSnapshot, _systemTime.Now)) .OnSuccess(orderRoot => _unitOfWork.Add(orderRoot)) .OnSuccess(orderId => _unitOfWork.Compleate());
public async Task <CategoryResponse> Add(CategoryAddRequest request) { var categoryToAdd = request.Model.MapToModel(); categoryToAdd.FieldDefenitions?.Clear(); categoryToAdd.FieldDefenitionGroups?.Clear(); await BaseBeforeAddAsync(categoryToAdd, request.RequestOwner); await _dataSrv.AddAsync(categoryToAdd); request.Model.FieldDefenitions.ToList().MapToModel().ForEach(x => { x.CategoryId = categoryToAdd.Id; _fieldDefentionFacade.PendToAdd(x); }); request.Model.FieldDefenitionGroups.ToList().MapToModel().ForEach(x => { x.CategoryId = categoryToAdd.Id; _unitOfWork.Add(x); }); await _fieldDefentionFacade.SaveChangesAsync(); await BaseAfterAddAsync(categoryToAdd, request.RequestOwner); HandleMetaData(request.Model.MetaData, categoryToAdd); await _unitOfWork.SaveChangesAsync(); return(new CategoryResponse() { Access = ResponseAccess.Granted, Category = categoryToAdd.MapToViewModel() }); }
public async Task <long> CreateLeadDisciplineAsync(LeadDiscipline leadDiscipline, string mappingScheme) { leadDisciplineMappingSchemeRegistrator.Register(); var insertedLeadDiscipline = unitOfWork.Add(leadDiscipline, mappingScheme); await unitOfWork.SaveAsync(); return(insertedLeadDiscipline.Id); }
public async Task <long> CreateHazardRuleAsync(HazardRule hazardRule, string mappingScheme) { hazardRuleMappingSchemeRegistrator.Register(); var insertedHazardRule = unitOfWork.Add(hazardRule, mappingScheme); await unitOfWork.SaveAsync(); return(insertedHazardRule.Id); }
public async Task <long> CreateIsolationCertificateAsync(IsolationCertificate isolationCertificate, string mappingScheme) { isolationCertificateMappingSchemeRegistrator.Register(); var insertedIsolationCertificate = unitOfWork.Add(isolationCertificate, mappingScheme); await unitOfWork.SaveAsync(); return(insertedIsolationCertificate.Id); }
public async Task <long> CreateRolePermissionAsync(RolePermission rolePermission, string mappingScheme) { rolePermissionMappingSchemeRegistrator.Register(); var insertedRolePermission = unitOfWork.Add(rolePermission, mappingScheme); await unitOfWork.SaveAsync(); return(insertedRolePermission.Id); }
public async Task <long> CreateOrganizationAsync(Organization organization, string mappingScheme) { organizationMappingSchemeRegistrator.Register(); var insertedOrganization = unitOfWork.Add(organization, mappingScheme); await unitOfWork.SaveAsync(); return(insertedOrganization.Id); }
public async Task <long> CreateExternalDocumentAsync(ExternalDocument externalDocument, string mappingScheme) { externalDocumentMappingSchemeRegistrator.Register(); var insertedExternalDocument = unitOfWork.Add(externalDocument, mappingScheme); await unitOfWork.SaveAsync(); return(insertedExternalDocument.Id); }
public async Task <long> CreateAreaTypeAsync(AreaType areaType, string mappingScheme) { areaTypeMappingSchemeRegistrator.Register(); var insertedAreaType = unitOfWork.Add(areaType, mappingScheme); await unitOfWork.SaveAsync(); return(insertedAreaType.Id); }
public async Task <long> CreateHazardGroupAsync(HazardGroup hazardGroup, string mappingScheme) { hazardGroupMappingSchemeRegistrator.Register(); var insertedHazardGroup = unitOfWork.Add(hazardGroup, mappingScheme); await unitOfWork.SaveAsync(); return(insertedHazardGroup.Id); }
public async Task <long> CreateLocationAsync(Location location, string mappingScheme) { locationMappingSchemeRegistrator.Register(); var insertedLocation = unitOfWork.Add(location, mappingScheme); await unitOfWork.SaveAsync(); return(insertedLocation.Id); }
public async Task <long> CreatePositionAsync(Position position, string mappingScheme) { positionMappingSchemeRegistrator.Register(); var insertedPosition = unitOfWork.Add(position, mappingScheme); await unitOfWork.SaveAsync(); return(insertedPosition.Id); }
public async Task <long> CreateHistoryChangeAsync(HistoryChange historyChange, string mappingScheme) { historyChangeMappingSchemeRegistrator.Register(); var insertedHistoryChange = unitOfWork.Add(historyChange, mappingScheme); await unitOfWork.SaveAsync(); return(insertedHistoryChange.Id); }
public async Task <long> CreateWorkCertificateAsync(WorkCertificate workCertificate, string mappingScheme) { workCertificateMappingSchemeRegistrator.Register(); var insertedWorkCertificate = unitOfWork.Add(workCertificate, mappingScheme); await unitOfWork.SaveAsync(); return(insertedWorkCertificate.Id); }
public async Task <long> CreateUserRoleAsync(UserRole userRole, string mappingScheme) { userRoleMappingSchemeRegistrator.Register(); var insertedUserRole = unitOfWork.Add(userRole, mappingScheme); await unitOfWork.SaveAsync(); return(insertedUserRole.Id); }
public async Task <long> CreateCertificateUserAsync(CertificateUser certificateUser, string mappingScheme) { certificateUserMappingSchemeRegistrator.Register(); var insertedCertificateUser = unitOfWork.Add(certificateUser, mappingScheme); await unitOfWork.SaveAsync(); return(insertedCertificateUser.Id); }
public async Task <long> CreateIsolationPointAsync(IsolationPoint isolationPoint, string mappingScheme) { isolationPointMappingSchemeRegistrator.Register(); var insertedIsolationPoint = unitOfWork.Add(isolationPoint, mappingScheme); await unitOfWork.SaveAsync(); return(insertedIsolationPoint.Id); }
public async Task <long> CreateHazardControlAsync(HazardControl hazardControl, string mappingScheme) { hazardControlMappingSchemeRegistrator.Register(); var insertedHazardControl = unitOfWork.Add(hazardControl, mappingScheme); await unitOfWork.SaveAsync(); return(insertedHazardControl.Id); }
public async Task <long> CreateInstallationAsync(Installation installation, string mappingScheme) { installationMappingSchemeRegistrator.Register(); var insertedInstallation = unitOfWork.Add(installation, mappingScheme); await unitOfWork.SaveAsync(); return(insertedInstallation.Id); }
public override void ArrangeDataContext(IUnitOfWork context) { context.Add(new BlogPost { Id = sampleId, Code = "sample", Name = "Sample Posting" }); context.Add(new BlogPost { Id = testId, Code = "test", Name = "Test Posting" }); context.Add(new BlogPost { Id = exampleId, Code = "example", Name = "Example Posting" }); }
public async Task <MessageResult> Handle(CreateBooking message) { await semaphoreSlim.WaitAsync(); try { // TODO validations etc. var startAt = DateTime.Parse(message.StartAt); var serviceId = int.Parse(message.ServiceId); if (await unitOfWork.Exists <Booking>(b => b.StartAt == startAt && b.ServiceId == serviceId)) { throw new Domain.BookingAlreadyExists(); } var createdUtc = DateTime.UtcNow; var booking = new Booking { Email = message.Email, Name = message.Name, Surname = message.Surname, Phone = message.Phone, BookingAt = DateTime.Parse(message.BookingAt), StartAt = startAt, ServiceId = serviceId, Quantity = int.Parse(message.Quantity), Price = decimal.Parse(message.Price), Comment = message.Comment, BookingCreatedAt = createdUtc, Status = (int)Domain.BookingStatus.Created }; await unitOfWork.Add(booking); await unitOfWork.Save(); var bookingCreated = new Domain.BookingCreated { CreatedAt = createdUtc, BookingId = booking.Id, }; await unitOfWork.Add(BookingEvent.CreateFrom(bookingCreated)); await unitOfWork.Save(); return(new MessageResult(201, new { booking.Id })); } finally { semaphoreSlim.Release(); } }
public async Task <bool> ProcessPayment(ProcessPaymentModel model) { try { //Adding Payment var payment = new Payment { CreditCardNumber = model.CreditCardNumber, CardHolder = model.CardHolder, ExpirationDate = model.ExpirationDate, SecurityCode = model.SecurityCode, Amount = model.Amount }; _uow.Add(payment); await _uow.CommitAsync(); //Adding Payment Status as Initial - Pending var paymentStatus = new PaymentStatus { PaymentId = payment.Id, StatusId = (int)TransactionStatus.Pending }; _uow.Add(paymentStatus); paymentStatus = new PaymentStatus() { PaymentId = payment.Id }; var factory = new PaymentGatewayFactory(); IPaymentGateway paymentGateway = factory.GetPaymentGateway(model.Amount); if (await paymentGateway.ProcessPayment()) { paymentStatus.StatusId = (int)TransactionStatus.Processed; } else { paymentStatus.StatusId = (int)TransactionStatus.Failed; } _uow.Add(paymentStatus); await _uow.CommitAsync(); return(true); } catch (Exception ex) { throw new BadRequestException(ex.Message); } }
public async Task <Season> Create(CreateSeasonModel model) { var item = new Season { StartDate = model.StartDate, EndDate = model.EndDate, Description = model.Description, }; _uow.Add(item); await _uow.CommitAsync(); return(item); }
public void Should_save_uncommited_changes() { _aggregate.DoSomething(); _unitOfWork.Add(_aggregate); _unitOfWork.Commit(); Assert.AreEqual(1, _eventStore.Events.Count); }
public Member_Action Create(Member member, int memberAction, string description) { Member_Action member_Action = new Member_Action() { MemberID = member.MemberID, ActionType = memberAction, AddTime = DateTime.Now, Description = description, IP = HttpHelper.IP }; db.Add <Member_Action>(member_Action); db.Commit(); return(member_Action); }
public async Task <Product> Create(DtoProductPost dtoProductPost) { var product = new Product() { CategoryID = dtoProductPost.CategoryID, SupplierID = dtoProductPost.SupplierID, ProductName = dtoProductPost.ProductName, UnitPrice = dtoProductPost.UnitPrice, QuantityPerUnit = dtoProductPost.QuantityPerUnit, Discontinued = dtoProductPost.Discontinued, UnitsInStock = dtoProductPost.UnitsInStock, UnitsOnOrder = dtoProductPost.UnitsOnOrder, ReorderLevel = dtoProductPost.ReorderLevel }; unitOfWork.Add(product); unitOfWork.Commit(); var newProduct = await unitOfWork.Query <Product>().OrderBy(x => x.ProductID).LastOrDefaultAsync(); BackgroundJob.Enqueue(() => RefreshCache()); return(newProduct); }
public async Task <ValidationResult> Register(RegisterModel registerModel) { ValidationResult validationResult = new ValidationResult(); if (await userService.EmailIsUsed(registerModel.Email)) { validationResult.AddError(nameof(RegisterModel.Email), "Email is already used."); } if (registerModel.Password != registerModel.ConfirmPassword) { validationResult.AddError(nameof(RegisterModel.ConfirmPassword), "The passwords must match."); } if (validationResult.IsValid) { using IUnitOfWork unitOfWork = repository.CreateUnitOfWork(); UserEntity user = mapper.Map <RegisterModel, UserEntity>(registerModel); unitOfWork.Add(user); await unitOfWork.SaveChanges(); } return(validationResult); }
public VersionableEntity CreateNewVersion(IUnitOfWork unitOfWork) { LoadAll(unitOfWork); var type = ObjectContext.GetObjectType(GetType()); var newVersion = (VersionableEntity)unitOfWork.Add(type,Clone()); newVersion.Modified = SystemTime.Now; newVersion.Version++; this.IsNewest = false; return newVersion; }