public PrintJobService(IDbContextFactory <OrderDbContext> provider)
{
this.Provider = provider;
using (var orderDbContext = Provider.CreateDbContext())
{
PrinterName = orderDbContext.PrintParameter.FirstOrDefault().PrinterName;
}
}
public IQueryable <Deployment> GetDeployments(
[Service] IDbContextFactory <SuperComposeContext> ctx,
[GlobalState("ClaimsPrincipal")] ClaimsPrincipal user)
{
var tenant = user.Tenant();
return(ctx.CreateDbContext().Deployments.Where(x => x.TenantId == tenant));
}
public async Task <List <ContactInfo> > GetContactInfoFromStudent(int Id)
{
var context = dbContextFactory.CreateDbContext();
var user = await context.Persons.Include(x => x.ContactInfos).Where(x => x.Id == Id).FirstOrDefaultAsync();
return(user.ContactInfos.ToList());
}
public PostModel GetById(Guid postId)
{
using (var dbContext = dbContextFactory.CreateDbContext())
{
var entity = dbContext.Posts
.Include(x => x.Author)
.Include(x => x.Contributions).ThenInclude(x => x.Author)
.FirstOrDefault(t => t.Id == postId);
if (entity == null)
{
return(null);
}
return(Mapper.Mapper.MapPostEntityToPostModel(entity));
}
}
public void WorkIt()
{
using var ctx = contextFactory.CreateDbContext();
foreach (var item in ctx.Customers.Take(10))
{
Console.WriteLine($"Name: {item.Name}");
}
}
protected ApplicationDbContext GetDbContext()
{
using IServiceScope scope = ServiceProvider.CreateScope();
IDbContextFactory <ApplicationDbContext> factory = scope.ServiceProvider.GetService <IDbContextFactory <ApplicationDbContext> >();
ApplicationDbContext dbContext = factory?.CreateDbContext();
return(dbContext);
}
public Task <T> DoAsync <T>(Func <DbContext, T> func)
{
using (var db = _dbContextFactory.CreateDbContext <TEntity>())
{
var ret = func.Invoke(db);
return(Task.FromResult(ret));
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
using var context = _contextFactory.CreateDbContext();
Movie = await context.Movie.FirstOrDefaultAsync(m => m.Id == id);
if (Movie == null)
{
return(NotFound());
}
return(Page());
}
protected override async Task <IReadOnlyDictionary <Guid, Product> > LoadBatchAsync(IReadOnlyList <Guid> keys, CancellationToken cancellationToken)
{
await using ApplicationDbContext dbContext = _dbContextFactory.CreateDbContext();
return(await dbContext.Products
.Where(s => keys.Contains(s.Id))
.ToDictionaryAsync(t => t.Id, cancellationToken));
}
protected override async Task <IReadOnlyDictionary <int, Ad> > LoadBatchAsync(IReadOnlyList <int> keys, CancellationToken cancellationToken)
{
await using AdDbContext dbContext = _dbContextFactory.CreateDbContext();
return(await dbContext.Ads
.Where(s => keys.Contains(s.Id))
.ToDictionaryAsync(t => t.Id, cancellationToken));
}
public IngredientRepositoryTests()
{
_dbContextFactory = new DbContextInMemoryFactory(nameof(IngredientRepositoryTests));
using CookBookDbContext dbx = _dbContextFactory.CreateDbContext();
dbx.Database.EnsureCreated();
_ingredientRepositorySUT = new IngredientRepository(_dbContextFactory);
}
protected override async Task <IReadOnlyDictionary <Guid, Payout> > LoadBatchAsync(
IReadOnlyList <Guid> keys,
CancellationToken token)
{
return(await _contextFactory.CreateDbContext().Payouts
.Where(u => keys.Contains(u.Id))
.ToDictionaryAsync(c => c.Id, token));
}
public async Task <string> Handle(DeleteCharacterCommand request, CancellationToken cancellationToken)
{
await using var context = _contextFactory.CreateDbContext();
var character = await context.Characters
.FirstOrDefaultAsync(c => c.Id == request.CharacterId, cancellationToken);
if (character != null)
{
var allianceLeaderInAlliance = await context.Alliances.FirstOrDefaultAsync(a => a.LeaderId == character.Id, cancellationToken);
if (allianceLeaderInAlliance != null)
{
var clans = await context.Clans.Where(c => c.AllianceId == allianceLeaderInAlliance.Id)
.ToListAsync(cancellationToken);
if (clans.Count > 0)
{
clans.ForEach(fc => fc.AllianceId = null);
context.Clans.UpdateRange(clans);
}
context.Alliances.Remove(allianceLeaderInAlliance);
}
var clanLeaderInClan = await context.Clans.FirstOrDefaultAsync(c => c.LeaderId == character.Id, cancellationToken);
if (clanLeaderInClan != null)
{
var clanCharacters = await context.Characters.Where(c => c.ClanId == clanLeaderInClan.Id)
.ToListAsync(cancellationToken);
if (clanCharacters.Count > 0)
{
clanCharacters.ForEach(fcc => fcc.ClanId = null);
context.Characters.UpdateRange(clanCharacters);
}
context.Clans.Remove(clanLeaderInClan);
}
var clanMemberInClan = await context.Clans.FirstOrDefaultAsync(c => c.Id == character.ClanId, cancellationToken);
if (clanMemberInClan != null)
{
clanMemberInClan.CurrentCountCharacters--;
context.Clans.Update(clanMemberInClan);
}
context.Characters.Remove(character);
await context.SaveChangesAsync(cancellationToken);
return("OK");
}
else
{
throw new AppException("The character not found.");
}
}
public TeamDetailModel Create(TeamDetailModel team)
{
using (var dbContext = _fitterDbContext.CreateDbContext())
{
var entity = _mapper.MapTeamToEntity(team);
dbContext.Teams.Add(entity);
dbContext.SaveChanges();
return(_mapper.MapTeamDetailModelFromEntity(entity));
}
}
public async Task <int> Count()
{
using (var context = _contextFactory.CreateDbContext())
{
return(await context.Bookings.CountAsync());
}
}
// GET: Movies
public async Task <IActionResult> Index(string movieGenre, string searchString)
{
using var context = _contextFactory.CreateDbContext();
// Use LINQ to get list of genres.
IQueryable <string> genreQuery = from m in context.Movie
orderby m.Genre
select m.Genre;
var movies = from m in context.Movie
select m;
if (!string.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => !string.IsNullOrEmpty(s.Title) && s.Title.Contains(searchString));
}
if (!string.IsNullOrEmpty(movieGenre))
{
movies = movies.Where(x => x.Genre == movieGenre);
}
var genres = new SelectList(await genreQuery.Distinct().ToListAsync());
var moviesList = await movies.ToListAsync();
var movieGenreVM = new MovieGenreViewModel
{
Genres = genres,
Movies = moviesList
};
return(View(movieGenreVM));
}
/// <summary>
/// Saves specified delivery details.
/// </summary>
/// <param name="manufacturer">Object of the manufacturer</param>
/// <param name="materialItems">List of the Material Items</param>
/// <returns>Manufacturer</returns>
public Manufacturer SaveDelivery(Manufacturer manufacturer, List <MaterialItems> materialItems)
{
using (_loggerFactory.CreateMethodLogger(MethodBase.GetCurrentMethod(), _logger))
{
using (var context = _dbContextFactory.CreateDbContext())
{
if (manufacturer != null)
{
var delivery = new Delivery()
{
DeliveryDate = DateTime.Now
};
context.SaveDeliveryDetails(delivery);
if (delivery != null)
{
var itemDetails = materialItems?.GroupBy(x => x.ItemId)
.Select(item =>
{
var returnQTY = item.First();
returnQTY.Quantity = item.Sum(xt => xt.Quantity);
return(returnQTY);
}).ToList();
itemDetails?.ForEach(item =>
{
var deliveryDetails = new DeliveryDetails()
{
DeliveryId = delivery.DeliveryId,
DeliveryDate = DateTime.Now,
ItemId = item.ItemId,
Quantity = item.Quantity
};
context.SaveDeliveryDetails(deliveryDetails);
});
}
context.SaveChanges();
}
return(manufacturer);
}
}
}
public bool AddCustomer(CustomerDetailModel customerDetailModel)
{
using var connection = _cloudCashDbContextFactory.CreateDbContext();
connection.Customers.Add(Mapper.MapDetailModelToEntity(customerDetailModel));
return(connection.SaveChanges() is 1);
}
//private ILog Log;
public PrintJobService(IDbContextFactory <DBContext> provider)
{
this.Provider = provider;
using (var orderDbContext = Provider.CreateDbContext())
{
PrinterName = orderDbContext.PrintParameter.FirstOrDefault().PrinterName;
}
//Log = LogManager.GetLogger("PrintJobService");
}
protected override async Task <IReadOnlyDictionary <int, OrderItem> > LoadBatchAsync(IReadOnlyList <int> keys, CancellationToken cancellationToken)
{
await using var dbContext = _dbContextFactory.CreateDbContext();
var orderItemDictionary = await dbContext.OrderItems
.Where(oi => keys.Contains(oi.Id))
.ToDictionaryAsync(oi => oi.Id, cancellationToken);
return(orderItemDictionary);
}
public void ConnectTo(DbToolDatabase connectionData)
{
if (IsConnected)
{
throw new UserException(ExceptionType.AlreadyConnected);
}
_database = connectionData;
_dbContext = _dbConnectionFactory.CreateDbContext(connectionData);
}
protected override async Task <IReadOnlyDictionary <int, Product> > LoadBatchAsync(IReadOnlyList <int> keys, CancellationToken cancellationToken)
{
await using var dbContext = _dbContextFactory.CreateDbContext();
var productDictionary = await dbContext.Products
.Where(p => keys.Contains(p.Id))
.ToDictionaryAsync(p => p.Id, cancellationToken);
return(productDictionary);
}
protected override async Task <IReadOnlyDictionary <Guid, GradedDish> > LoadBatchAsync(IReadOnlyList <Guid> keys, CancellationToken cancellationToken)
{
await using DatabaseContext dbContext = _dbContextFactory.CreateDbContext();
return(await dbContext.GradedDishes
.AsQueryable()
.Where(d => keys.Contains(d.Id))
.ToDictionaryAsync(d => d.Id, cancellationToken));
}
public async Task <KeyChain> CreateNewChain(Item keyItem)
{
if (keyItem.Id == 0)
{
throw new InvalidOperationException("KeyItem invalid.");
}
using var dbContext = _dbContextFactory.CreateDbContext();
var chain = new KeyChain()
{
Item = keyItem
};
await dbContext.SaveChangesAsync();
return(chain);
}
public async Task <Either <BaseError, Unit> > Handle(
UpdatePlayoutDaysToBuild request,
CancellationToken cancellationToken)
{
await using TvContext dbContext = _dbContextFactory.CreateDbContext();
Validation <BaseError, Unit> validation = await Validate(request);
return(await validation.Apply <Unit, Unit>(_ => ApplyUpdate(dbContext, request.DaysToBuild)));
}
public async Task <string> GetCanonicalDomain(string host)
{
if (string.IsNullOrEmpty(host))
{
throw new ArgumentNullException(nameof(host), "The host parameter must be specified for GetCanonicalDomain.");
}
using (var db = _dbContextFactory.CreateDbContext())
{
SIPDomain sipDomain = db.SIPDomains.Where(x => x.Domain.ToLower() == host.ToLower()).SingleOrDefault();
if (sipDomain == null)
{
sipDomain = await db.SIPDomains.Where(x => x.AliasList.ToLower().Contains(host.ToLower())).FirstOrDefaultAsync();
}
return(sipDomain?.Domain);
}
}
protected override async Task <IReadOnlyDictionary <int, User> > LoadBatchAsync(IReadOnlyList <int> keys, CancellationToken cancellationToken)
{
await using var dbContext = _dbContextFactory.CreateDbContext();
var userDictionary = await dbContext.Users
.Where(u => keys.Contains(u.Id))
.ToDictionaryAsync(u => u.Id, cancellationToken);
return(userDictionary);
}
public async Task <string> Handle(CreateCharacterCommand request, CancellationToken cancellationToken)
{
await using var context = _contextFactory.CreateDbContext();
var character = await context
.Characters
.AnyAsync(c => c.Name == request.Name, cancellationToken);
if (character)
{
throw new AppException("This name is unavailable");
}
var initializeDataCharacter = await context
.InitializeDataCharacters
.FirstOrDefaultAsync(c => c.RaceId == request.RaceId && c.ClassId == request.ClassId, cancellationToken);
if (initializeDataCharacter != null)
{
var newCharacter = new Character
{
UserId = request.UserId,
GameServerId = request.ServerId,
Name = request.Name,
Gender = request.Gender,
Level = 1,
Experience = 0,
RaceId = initializeDataCharacter.RaceId,
ClassId = initializeDataCharacter.ClassId,
Health = initializeDataCharacter.Health,
Mana = initializeDataCharacter.Mana,
PosX = initializeDataCharacter.PosX,
PosY = initializeDataCharacter.PosY,
PosZ = initializeDataCharacter.PosZ,
RotationYaw = initializeDataCharacter.RotationYaw,
EquipChest = initializeDataCharacter.EquipChest,
EquipFeet = initializeDataCharacter.EquipFeet,
EquipHands = initializeDataCharacter.EquipHands,
EquipHead = initializeDataCharacter.EquipHead,
EquipLegs = initializeDataCharacter.EquipLegs,
Hotbar0 = initializeDataCharacter.Hotbar0,
Hotbar1 = initializeDataCharacter.Hotbar1,
Hotbar2 = initializeDataCharacter.Hotbar2,
Hotbar3 = initializeDataCharacter.Hotbar3
};
await context.Characters.AddAsync(newCharacter, cancellationToken);
await context.SaveChangesAsync(cancellationToken);
return("OK");
}
else
{
throw new AppException("The character could not be initialized.");
}
}
protected override async Task <IReadOnlyDictionary <int, T> > LoadBatchAsync(
IReadOnlyList <int> keys,
CancellationToken cancellationToken)
{
await using var ctx = dbContextFactory.CreateDbContext();
return(await dbsetCreator(ctx).AsAsyncEnumerable()
.Where(s => keys.Contains(s.Id))
.ToDictionaryAsync(t => t.Id, cancellationToken));
}
/// <summary>
/// Инициализирует новый экземпляр класса <see cref="UnitOfWorkEf" />
/// </summary>
/// <param name="contextFactory">Фабрика контекста доступа к БД</param>
/// <param name="isolationLevel">Уровень изоляции данных</param>
public UnitOfWorkEf(
IDbContextFactory contextFactory,
IsolationLevel isolationLevel = IsolationLevel.ReadCommitted)
{
this._context = contextFactory.CreateDbContext<EntitiesContext>();
// Если БД не была создана вызовет ошибку
this._transaction = this._context.Database.BeginTransaction(isolationLevel);
}
protected U GetDbContext()
{
if (_dbContext != null)
{
return(_dbContext);
}
return(_dbFactory.CreateDbContext());
}
