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