public static IUnitOfWork Start()
{
_innerUnitOfWorkFactory = ServiceLocator.Current.GetInstance<IUnitOfWorkFactory>();
_innerUnitOfWork = _innerUnitOfWorkFactory.Create();
return Current;
}
public static IUnitOfWork Start()
{
if (_innerUnitOfWork != null)
throw new InvalidOperationException("You cannot start more than one unit of work at the same time.");
_unitOfWorkFactory = Context.Current.UnitOfWorkFactory;
_innerUnitOfWork = _unitOfWorkFactory.Create();
return _innerUnitOfWork;
}
/// <summary>
/// Overloaded Constructor.
/// Creates a new instance of the <see cref="UnitOfWorkScopeTransaction"/> that takes in a
/// <see cref="IUnitOfWorkFactory"/> instance that is responsible for creating instances of <see cref="IUnitOfWork"/> and
/// a <see cref="IDbConnection"/> that is used by the instance to connect to the data store.
/// </summary>
/// <param name="unitOfWorkFactory">The <see cref="IUnitOfWorkFactory"/> implementation that is responsible
/// for creating instances of <see cref="IUnitOfWork"/> instances.</param>
/// <param name="isolationLevel">One of the values of <see cref="IsolationLevel"/> that specifies the transaction
/// isolation level of the <see cref="UnitOfWorkScopeTransaction"/> instance.</param>
public UnitOfWorkScopeTransaction(IUnitOfWorkFactory unitOfWorkFactory, IsolationLevel isolationLevel)
{
Guard.Against<ArgumentNullException>(unitOfWorkFactory == null,
"A valid non-null instance that implements the IUnitOfWorkFactory is required.");
_transactionID = new Guid();
_transactionRolledback = false;
_disposed = false;
_unitOfWork = unitOfWorkFactory.Create();
_runningTransaction = _unitOfWork.BeginTransaction(isolationLevel);
_isolationLevel = isolationLevel;
_attachedScopes = new Stack<UnitOfWorkScope>();
}
public void SetupContext()
{
_factory = _mocks.DynamicMock<IUnitOfWorkFactory>();
_unitOfWork = _mocks.DynamicMock<IUnitOfWork>();
_session = _mocks.DynamicMock<ISession>();
InstrumentUnitOfWork();
_mocks.BackToRecordAll();
SetupResult.For(_factory.Create()).Return(_unitOfWork);
SetupResult.For(_factory.CurrentSession).Return(_session);
_mocks.ReplayAll();
}
public void SetupContext() {
_factory = _mocks.DynamicMock<IUnitOfWorkFactory>();
_unitOfWork = _mocks.DynamicMock<IUnitOfWork>();
_session = _mocks.DynamicMock<ISession>();
var fieldInfo = typeof(UnitOfWork).GetField("_unitOfWorkFactory",
BindingFlags.Static | BindingFlags.SetField | BindingFlags.NonPublic);
fieldInfo.SetValue(null, _factory);
_mocks.BackToRecordAll();
SetupResult.For(_factory.Create()).Return(_unitOfWork);
SetupResult.For(_factory.CurrentSession).Return(_session);
_mocks.ReplayAll();
}
public async Task SeedLibraryAsync(CancellationToken token)
{
if (!_ctx.Authors.Any() || !_ctx.Books.Any())
{
using (var unitOfWork = _unitOfWorkFactory.Create())
{
var ivanko = _entityFactory.CreateAuthor(
"Ivan",
"Ivchenko",
new LifePeriod(new DateTime(1988, 1, 11)));
var slavko = _entityFactory.CreateAuthor(
"Myroslava",
"Tarcha",
new LifePeriod(new DateTime(1993, 5, 5)));
var astrid = _entityFactory.CreateAuthor(
"Astrid",
"Lindgren",
new LifePeriod(new DateTime(1907, 11, 14), new DateTime(2002, 1, 14)));
for (var i = 1; i < 10; i++)
{
var book = _entityFactory.CreateBook(
"Karlsson-on-the-Roof " + i,
new DateTime(2016, 09, 08),
"Karlsson-on-the-Roof is a character who figures in a series of children's books by the Swedish author Astrid Lindgren");
book.AddAuthor(astrid);
}
for (var i = 1; i < 10; i++)
{
var book = _entityFactory.CreateBook(
"Adventures of Vivchyk and Tarchavka" + i,
new DateTime(2016, 09, 08),
"Adventures of Vivchyk and Tarchavka " + i);
book.AddAuthor(ivanko);
book.AddAuthor(slavko);
}
for (var i = 1; i < 10; i++)
{
var book = _entityFactory.CreateBook(
"Adventures of Vivchyk" + i,
new DateTime(2016, 09, 08),
"Adventures of Vivchyk before he has met Tarchavka " + i);
book.AddAuthor(ivanko);
}
for (var i = 1; i < 10; i++)
{
var book = _entityFactory.CreateBook(
"Adventures of Tarchavka" + i,
new DateTime(2016, 09, 08),
"Adventures of Tarchavka before she has met Vivchyk " + i);
book.AddAuthor(slavko);
}
await unitOfWork.Authors.CreateAsync(ivanko, token);
await unitOfWork.Authors.CreateAsync(slavko, token);
await unitOfWork.Authors.CreateAsync(astrid, token);
}
}
}
public AccountController(ICryptoProvider cryptoProvider, IUnitOfWorkFactory unitOfWorkFactory)
{
_cryptoProvider = cryptoProvider;
_unitOfWork = unitOfWorkFactory.Create();
}
public IHttpActionResult AddRequest([FromBody] RequestModel model)
{
#region [Vendor]
// check nearest venodr
var vendor = _vendorRepository.First(new Specification <Vendor>(s => s.Latitude == model.Latitude && s.Longitude == model.Longitude));
#endregion
#region Add Request
Request request = new Request
{
CustomerId = model.CustomerId,
CreatedOn = DateTime.UtcNow,
CreatedById = model.CustomerId,
VendorId = vendor.Id,
Latitude = model.Latitude,
Longitude = model.Longitude
};
request.Items = new List <Item>();
foreach (var reqitem in model.Items)
{
Item item = new Item
{
Data = reqitem.Data,
ServiceTypeId = reqitem.ServiceTypeId
};
request.Items.Add(item);
}
using (var uow = _unitOfWorkFactory.Create())
{
_requestRepository.Add(request);
}
using (var uow = _unitOfWorkFactory.Create())
{
RequestHistory requestHistory = new RequestHistory()
{
CreatedOn = DateTime.Now,
CreatedById = model.CustomerId,
RequestId = request.Id,
CustomerId = model.CustomerId,
RequestStatus = RequestStatus.pending
};
_requestHistoryRepo.Add(requestHistory);
}
#endregion
#region [Notifaction]
List <NotificationObject> listNotifications = new List <NotificationObject>();
if (!String.IsNullOrEmpty(vendor.Token))
{
listNotifications.Add(new NotificationObject
{
to = vendor.Token,
title = "CopyLi",
body = "New request created",
data = new NotificationData
{
title = "CopyLi",
body = "New request created",
code = "VEN_NEW_REQ"
}
});
}
// ExpoPushHelper.SendPushNotification(listNotifications);
#endregion
return(Ok());
}
public DiscordGuildDeleteConsumer(IUnitOfWorkFactory factory, IBusControl bus)
{
_work = factory.Create();
_bus = bus;
}
public CategoryService(IUnitOfWorkFactory factory)
{
_unitOfWork = factory.Create();
_repository = _unitOfWork.Repository<Category>();
}
public GuildsController(IUnitOfWorkFactory factory, DiscordShardedClient client)
{
_work = factory.Create();
_client = client;
}
public async Task <ApiResult> Handle(CreateCompany request, CancellationToken cancellationToken)
{
var userUid = request.UserUid ?? throw new ArgumentNullException(nameof(request.UserUid));
var company = request.Item ?? throw new ArgumentNullException(nameof(request.Item));
var now = _dateTimeProvider.GetUtcNow();
var companyUid = Guid.NewGuid();
var documentUid = Guid.NewGuid();
var documentTypeRepository = _classifierRepositoryFactory.GetNamedOrDefaultService(Docs.ClassifierTypeCode.DocumentType);
var documentType = await documentTypeRepository.Get(Docs.ClassifierTypeCode.DocumentType, DocumentTypes.CompanyRegistrationRequest, cancellationToken);
// todo: validate fields
var metadata = await _fieldMetadataRepository.Search(new MetadataSearchRequest
{
EntityTypeCode = DocumentType.EntityTypeCode,
EntityUid = documentType.Uid.Value,
// todo: check flags
// IsSystem = false,
IsActive = true,
SkipPaging = true
}, cancellationToken);
var manageFieldDataRequest = new ManageFieldDataRequest
{
EntityTypeCode = Document.TypeCode,
EntityUid = documentUid,
Metadata = metadata.Rows,
Item = company
};
// todo: move to Validator (?)
var result = await _fieldDataRepository.Validate(manageFieldDataRequest, cancellationToken);
if (result.Success == false)
{
return(result);
}
using (var scope = _unitOfWorkFactory.Create())
{
using (var db = _dbContextFactory.Create())
{
// todo: валидация и ограничения
// company + todo: creation date
await db.GetTable <DbCompany>()
.Value(x => x.Uid, companyUid)
.Value(x => x.ConfigCode, company.ConfigCode ?? CompanyConfigCode.Company)
.Value(x => x.StatusCode, CompanyStatusCode.Draft)
.Value(x => x.Name, company.Name)
.InsertAsync(cancellationToken);
// user in company
await db.GetTable <DbCompanyUser>()
.Value(x => x.CompanyUid, companyUid)
.Value(x => x.UserUid, userUid)
.InsertAsync(cancellationToken);
}
// insert fields
// todo: exclude db fields and sections
await _fieldDataRepository.Insert(manageFieldDataRequest, cancellationToken);
// todo: user roles
// company registration request + todo: creation date
var document = new Document
{
Uid = documentUid,
DocumentTypeUid = documentType.Uid.Value,
CompanyUid = companyUid,
StatusCode = DocumentStatusCode.Published,
Direction = DocumentDirection.Outgoing,
DocumentDate = now,
// Name = $"Company {company.Name} registration request"
};
await _documentRepository.Create(document, cancellationToken);
// todo: audit log for company and for document
await _auditLogService.Save(new AuditEvent
{
EntityTypeCode = Company.EntityTypeCode,
EntityUid = companyUid,
CompanyUid = companyUid,
UserUid = userUid,
CreatedAtUtc = now,
MessageCode = ExpressionHelper.GetFullName <CreateCompany.Resources>(x => x.CompanyCreated)
}, cancellationToken);
// todo: auto-approve request, notifications
_jobManager.Enqueue <ISender>(x => x.Send(new RunAutomations
{
EntityTypeCode = DocumentType.EntityTypeCode,
EntityTypeUid = documentType.Uid.Value,
EntityUid = documentUid
}, cancellationToken));
scope.Commit();
return(new ApiResult {
Uid = companyUid
});
}
}
public DiscordGuildAvailableConsumer(IUnitOfWorkFactory factory, DiscordShardedClient client, IBusControl bus)
{
_work = factory.Create();
_client = client;
_bus = bus;
}
public BlockController(ISystemController systemController,
IUnitOfWorkFactory unitOfWorkFactory)
{
_unitOfWork = unitOfWorkFactory.Create();
_systemController = systemController;
}
private static void TestFactoryCreate(IUnitOfWorkFactory uowFactory)
{
Assert.NotNull(uowFactory.Create());
Assert.NotNull(uowFactory.CreateInstance <UnitOfWork>());
}
public async Task Process(INetworkMessage message, GameNetworkContext context)
{
if (await context.FaultyState(GameState.Online))
{
return;
}
if (message is ShopPurchaseRequest shopRequest)
{
int goldCost = 0, apCost = 0, charmCost = 0, newCharacters = 0;
var result = ValidatePurchase(context, shopRequest, ref goldCost, ref apCost, ref charmCost, ref newCharacters);
if (result == ShopPurchaseResponse.ShopPurchaseResult.Success)
{
if (!context.HasGold(goldCost))
{
result = ShopPurchaseResponse.ShopPurchaseResult.NeedMoreGold;
}
else if (!context.HasAp(apCost))
{
result = ShopPurchaseResponse.ShopPurchaseResult.NeedMoreAp;
}
else if (!context.HasCharm(charmCost))
{
result = ShopPurchaseResponse.ShopPurchaseResult.NotEnoughCharmPoints;
}
if (newCharacters > 0)
{
await using (var uow = _unitOfWorkFactory.Create())
{
var currentCount = await uow.Characters.Where(p => p.AccountId == context.Character.AccountId).CountAsync();
if (newCharacters + currentCount > MaxCharacters)
{
result = ShopPurchaseResponse.ShopPurchaseResult.CharacterLimit;
}
}
}
}
var newItems = new List <Item>();
if (result == ShopPurchaseResponse.ShopPurchaseResult.Success)
{
if (!await context.AddCurrency(-goldCost, -apCost, -charmCost))
{
result = ShopPurchaseResponse.ShopPurchaseResult.CashInfoFailed;
}
else
{
await using (var uow = _unitOfWorkFactory.Create())
{
foreach (var purchaseItem in shopRequest.Items)
{
if (_shopItemDataStore.TryGetValue(purchaseItem.Index, out ShopItem shopItem))
{
if (shopItem.GoldBack > 0)
{
await context.AddGold(shopItem.GoldBack);
}
if (shopItem.Item1 != 0) // set
{
int characterId = context.Character.Id;
if (!shopItem.Hero.IsStrict(HeroType.All))
{
var character = await _characterBuilder.Create(context.Character.AccountId, shopItem.Hero);
characterId = character.Id;
}
foreach (var index in shopItem.Items)
{
var item = new Item()
{
CharacterId = characterId,
CategoryType = ShopCategoryType.Parts,
Index = index,
UseType = shopItem.UseType,
Quantity = 1,
};
uow.Items.Add(item);
if (characterId == context.Character.Id)
{
newItems.Add(item);
}
}
}
else
{
var item = context.Items.FirstOrDefault(p => p.Index == shopItem.Item0);
if (item == null)
{
item = new Item()
{
CharacterId = context.Character.Id,
CategoryType = shopItem.CategoryType,
Index = shopItem.Item0,
UseType = shopItem.UseType
};
uow.Items.Add(item);
context.Items.Add(item);
}
else
{
uow.Attach(item);
}
if (purchaseItem.Option == 0)
{
item.Quantity += shopItem.Use0 == 0 ? 1 : shopItem.Use0;
}
else if (purchaseItem.Option == 1)
{
item.Quantity += shopItem.Use1;
}
else if (purchaseItem.Option == 2)
{
item.Quantity += shopItem.Use2;
}
if (shopItem.UseType == ItemUseType.Time)
{
item.ExpirationDate = DateTime.UtcNow.AddDays(item.Quantity);
}
}
}
}
await uow.CommitAsync();
}
}
}
await context.SendAsync(new ShopPurchaseResponse()
{
Result = result,
Items = newItems
});
if (result == ShopPurchaseResponse.ShopPurchaseResult.Success)
{
await context.SendAsync(new SynchronizeCurrencyResponse()
{
Ap = context.Ap,
Gold = context.Gold
});
}
}
}
public PersonService(IUnitOfWorkFactory uowFactory, IAuthenticationService authService)
{
_uow = uowFactory.Create();
_authService = authService;
}
public AddImageToPostHandler(IUnitOfWorkFactory unitOfWorkFactory, ICloudinaryService cloudinary)
{
_cloudinary = cloudinary;
_unitOfWork = unitOfWorkFactory.Create();
}
public WebPageConnectionsController(IUnitOfWorkFactory unitOfWorkFactory)
{
_unitOfWork = unitOfWorkFactory.Create();
}
public async Task <Character> Create(Func <Character, Task <Character> > builder)
{
await using (var uow = _unitOfWorkFactory.Create())
return(await Create(uow, builder));
}
public async Task EditCustomerProfile(string email, CustomerDto customerDto)
{
var user = await _userManager.FindByEmailAsync(email);
using (IUnitOfWork unitOfWork = _unitOfWorkFactory.Create())
{
IRepository <Customer> repository = unitOfWork.Repository <Customer>();
var customer = repository.Get(user.Id);
_iMapper.Map <CustomerDto, Customer>(customerDto, customer);
await unitOfWork.SaveAsync();
}
}
public DepartmentController(IUnitOfWorkFactory unitOfWorkFactory)
{
m_unitOfWork = unitOfWorkFactory.Create();
}
public IHttpActionResult CreateVendor(CreateVendorModel model)
{
var enSaltKey = _encryptionService.CreateSaltKey(4);
var enPassword = _encryptionService.CreatePasswordHash(model.Password, enSaltKey);
if (model == null)
{
return(NotFound());
}
Vendor vendor = new Vendor()
{
Email = model.Email,
Mobile = model.Mobile,
Name = model.Name,
Membership = new Membership()
{
PasswordSalt = enSaltKey,
Password = enPassword,
UserName = model.Email,
CreatedOn = DateTime.Now,
Role = _roleRepository.First(new Specification <Role>(r => r.Name == "Vendor"))
}
};
using (var uow = _unitOfWorkFactory.Create())
{
_vendorRepository.Add(vendor);
}
return(Ok(vendor));
}
public SubTaskService(IUnitOfWorkFactory factory)
{
_unitOfWork = factory.Create();
_taskRepository = _unitOfWork.Repository<Task>();
_repository = _unitOfWork.Repository<SubTask>();
}
protected IUnitOfWork NewUnitOfWork(UnitOfWorkMode mode = UnitOfWorkMode.ReadOnly)
{
return(_unitOfWorkFactory.Create(mode));
}
public void SetUpContext()
{
ResetUnitOfWork();
_factory = _mocks.DynamicMock<IUnitOfWorkFactory>();
_unitOfWork = _mocks.DynamicMock<IUnitOfWork>();
_session = _mocks.DynamicMock<ISession>();
//var fieldInfo = typeof(UnitOfWork).GetField("_innerUnitOfWork",
// BindingFlags.Static | BindingFlags.SetField | BindingFlags.NonPublic);
//fieldInfo.SetValue(null, null);
InstrumentUnitOfWork();
_mocks.BackToRecordAll();
SetupResult.For(_factory.Create(dbKey)).Return(_unitOfWork);
SetupResult.For(_factory.GetCurrentSession(dbKey)).Return(_session);
SetupResult.For(_unitOfWork.DatabaseKey).Return(dbKey);
_mocks.ReplayAll();
}
public GetDreamHandler(IUnitOfWorkFactory unitOfWorkFactory)
{
_unitOfWork = unitOfWorkFactory.Create();
}
public async Task <tbl_ipos_appraiseditem> FindById(int id)
{
try
{
using (var uow = _unitOfWorkFactory.Create())
{
return(await uow.AppraisedItemRepository.FindAsync(id));
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private static INHibernateUnitOfWork CreateUnitOfWork()
{
var unitOfWork = unitOfWorkFactory.Create();
return((INHibernateUnitOfWork)unitOfWork);
}
public async Task Initialize()
{
await using (var uow = _unitOfWorkFactory.Create())
_gameServer = await uow.GameServers.Where(p => p.Name == _options.GameServer.Name).FirstAsync();
}
public void Test_Factory_ReturnInstance_WithoutError()
{
Action createInstance = () => _unitOfWorkFactory.Create(_connectionFactory);
createInstance.Should().NotThrow();
}
