public IQueryable <Picking> GetAll([ScopedService] QueryDbContext context, CancellationToken token)
{
SetLogTransaction();
return(context.Pickings
.Where(c => c.ProducerId == CurrentUser.Id));
}
public IQueryable <DeliveryMode> Get([ID] Guid id, [ScopedService] QueryDbContext context)
{
SetLogTransaction(id);
return(context.DeliveryModes
.Where(c => c.ProducerId == CurrentUser.Id && c.Id == id));
}
public async Task <StoresSearchDto> SearchAsync(
[GraphQLType(typeof(SearchTermsInputType))][GraphQLName("input")]
SearchTermsDto terms,
[ScopedService] QueryDbContext context,
CancellationToken token)
{
SetLogTransaction(terms);
var query = context.Stores.Where(c => c.OpenForNewBusiness);
if (!string.IsNullOrWhiteSpace(terms.Text))
{
query = query.Where(p => p.Name.Contains(terms.Text));
}
if (terms.Tags != null && terms.Tags.Any())
{
query = query.Where(p => p.Tags.Any(t => terms.Tags.Contains(t.Tag.Name)));
}
var producer = await context.Producers.SingleAsync(e => e.Id == CurrentUser.Id, token);
Point currentPosition = null;
if (producer.Address?.Latitude != null && producer.Address?.Longitude != null)
{
currentPosition =
LocationProvider.CreatePoint(producer.Address.Latitude.Value, producer.Address.Longitude.Value);
query = query.Where(p => p.Address.Location.Distance(currentPosition) < _searchOptions.StoresDistance);
}
var count = await query.CountAsync(token);
if (!string.IsNullOrWhiteSpace(terms.Sort))
{
if (terms.Sort.Contains("store_geolocation") && currentPosition != null)
{
query = query.OrderBy(p => p.Address.Location.Distance(currentPosition));
}
else
{
query = query.OrderBy(p => p.Name);
}
}
else
{
query = query.OrderBy(p => p.Name);
}
query = query.Skip(((terms.Page ?? 1) - 1) * terms.Take ?? 20);
query = query.Take(terms.Take ?? 20);
var results = await query.ToListAsync(token);
return(new StoresSearchDto
{
Count = count,
Stores = results
});
}
public IQueryable <DeliveryMode> GetAll([ScopedService] QueryDbContext context)
{
SetLogTransaction();
return(context.DeliveryModes
.Where(c => c.ProducerId == CurrentUser.Id));
}
public IQueryable <DeliveryBatch> GetAll([ScopedService] QueryDbContext context)
{
SetLogTransaction();
return(context.DeliveryBatches
.Where(c => c.AssignedToId == CurrentUser.Id && c.Status != DeliveryBatchStatus.Cancelled));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env,
RelationalContext relationalContext,
QueryDbContext queryDbContext,
IMediator mediator)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.UseSession();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
relationalContext.Database.Migrate();
queryDbContext.Database.Migrate();
mediator.Send(new InitCommand()).Wait();
}
public IQueryable <DeliveryBatch> Get([ID] Guid id, [ScopedService] QueryDbContext context)
{
SetLogTransaction(id);
return(context.DeliveryBatches
.Where(c => c.AssignedToId == CurrentUser.Id && c.Id == id));
}
public IQueryable <Product> Get([ID] Guid id, [ScopedService] QueryDbContext context,
CancellationToken token)
{
SetLogTransaction(id);
return(context.Products
.Where(c => c.Id == id));
}
public async Task <IQueryable <Batch> > GetProductsBatches([ID(nameof(Product))] IEnumerable <Guid> ids,
[ScopedService] QueryDbContext context, CancellationToken token)
{
SetLogTransaction();
var batchIds = new List <Guid>();
if (CurrentUser.IsInRole(_roleOptions.Producer.Value))
{
batchIds = await context.Set <PreparedProduct>()
.Where(cp => ids.Contains(cp.ProductId))
.SelectMany(cp => cp.Batches.Select(b => b.BatchId))
.ToListAsync(token);
}
else
{
batchIds = await context.PurchaseOrders
.Where(po => po.ClientId == CurrentUser.Id)
.SelectMany(cp => cp.Picking.PreparedProducts.Where(po => ids.Contains(po.ProductId)).Where(po => po.PurchaseOrderId == cp.Id).SelectMany(po => po.Batches.Select(b => b.BatchId)))
.ToListAsync(token);
}
batchIds = batchIds.Distinct().ToList();
return(context.Batches
.Where(c => batchIds.Contains(c.Id)));
}
public async Task <IQueryable <Batch> > GetAll([ScopedService] QueryDbContext context, CancellationToken token,
bool validOnly = false)
{
SetLogTransaction();
if (CurrentUser.IsInRole(_roleOptions.Producer.Value))
{
if (validOnly)
{
return(context.Batches
.Where(c => c.ProducerId == CurrentUser.Id && ((c.DLC.HasValue && c.DLC > DateTime.UtcNow) ||
(c.DDM.HasValue && c.DDM > DateTime.UtcNow))));
}
return(context.Batches
.Where(c => c.ProducerId == CurrentUser.Id));
}
var batchIds = await context.PurchaseOrders
.Where(c => c.ClientId == CurrentUser.Id)
.SelectMany(c =>
c.Picking.PreparedProducts.Where(pp => pp.PurchaseOrderId == c.Id)
.SelectMany(pp => pp.Batches.Select(b => b.BatchId))
).ToListAsync(token);
if (validOnly)
{
return(context.Batches
.Where(c => batchIds.Contains(c.Id) && ((c.DLC.HasValue && c.DLC > DateTime.UtcNow) ||
(c.DDM.HasValue && c.DDM > DateTime.UtcNow))));
}
return(context.Batches
.Where(c => batchIds.Contains(c.Id)));
}
public IQueryable <Recall> GetRecall([ID] Guid id,
[ScopedService] QueryDbContext context)
{
SetLogTransaction(id);
return(context.Recalls
.Where(c => c.Id == id));
}
public IQueryable <Picking> GetPicking([ID] Guid id,
[ScopedService] QueryDbContext context)
{
SetLogTransaction(id);
return(context.Pickings
.Where(c => c.Id == id));
}
public IQueryable <Delivery> GetDelivery([ID] Guid id,
[ScopedService] QueryDbContext context)
{
SetLogTransaction(id);
return(context.Set <Delivery>()
.Where(c => c.Id == id));
}
public IQueryable <Order> Get(string identifier, [ScopedService] QueryDbContext context)
{
SetLogTransaction(identifier);
return(context.PreAuthorizations
.Where(p => p.Identifier == identifier)
.Select(p => p.Order));
}
public IQueryable <Observation> GetObservation([ID] Guid id,
[ScopedService] QueryDbContext context)
{
SetLogTransaction(id);
return(context.Observations
.Where(c => c.Id == id));
}
public async Task <User> GetUser(Withholding withholding, [ScopedService] QueryDbContext context,
UsersByIdBatchDataLoader usersDataLoader, CancellationToken token)
{
var userId = await context.Wallets
.Where(w => w.Id == withholding.CreditedWalletId)
.Select(w => w.UserId)
.SingleAsync(token);
return(await usersDataLoader.LoadAsync(userId, token));
}
public async Task <ConsumerLegal> GetLegals(Consumer consumer,
[ScopedService] QueryDbContext context,
ConsumerLegalsByIdBatchDataLoader consumerLegalsDataLoader, CancellationToken token)
{
var legalId = await context.Legals.OfType <ConsumerLegal>()
.Where(p => p.UserId == consumer.Id)
.Select(p => p.Id)
.SingleOrDefaultAsync(token);
return(await consumerLegalsDataLoader.LoadAsync(legalId, token));
}
public IQueryable <Order> GetAll([ScopedService] QueryDbContext context)
{
SetLogTransaction();
if (CurrentUser.IsAuthenticated())
{
return(context.Orders
.Where(o => o.UserId == CurrentUser.Id));
}
return(new List <Order>().AsQueryable());
}
public IQueryable <Order> Get([ScopedService] QueryDbContext context)
{
SetLogTransaction();
if (CurrentUser.IsAuthenticated())
{
return(context.Orders
.Where(c => c.UserId == CurrentUser.Id && c.Status == OrderStatus.Created)
.OrderByDescending(c => c.CreatedOn));
}
return(new List <Order>().AsQueryable());
}
public IQueryable <Order> Get([ID] Guid id, [ScopedService] QueryDbContext context)
{
SetLogTransaction(id);
if (CurrentUser.IsAuthenticated())
{
return(context.Orders
.Where(c => c.Id == id && c.UserId == CurrentUser.Id));
}
return(context.Orders
.Where(c => c.Id == id && c.Status == OrderStatus.Created && !c.UserId.HasValue));
}
public IQueryable <PurchaseOrder> GetAll([ScopedService] QueryDbContext context)
{
SetLogTransaction();
if (CurrentUser.IsInRole(_roleOptions.Producer.Value))
{
return(context.PurchaseOrders
.Where(c => c.ProducerId == CurrentUser.Id));
}
return(context.PurchaseOrders
.Where(c => c.ClientId == CurrentUser.Id));
}
public IQueryable <Recall> GetAll([ScopedService] QueryDbContext context, CancellationToken token)
{
SetLogTransaction();
if (CurrentUser.IsInRole(_roleOptions.Producer.Value))
{
return(context.Recalls
.Where(c => c.ProducerId == CurrentUser.Id));
}
return(context.Recalls.Where(r => r.Clients.Any(c => c.ClientId == CurrentUser.Id) && r.Status != RecallStatus.Waiting));
}
public static bool AllMigrationsApplied(this QueryDbContext context)
{
var applied = context.GetService <IHistoryRepository>()
.GetAppliedMigrations()
.Select(m => m.MigrationId);
var total = context.GetService <IMigrationsAssembly>()
.Migrations
.Select(m => m.Key);
return(!total.Except(applied).Any());
}
public static void InsertFakeData(QueryDbContext context, int count)
{
for (int i = 0; i < count; i++)
{
context.Todos.Add(
new Infra.Data.SqlServer.Queries.Todo.Entities.Todo()
{
Text = "test" + i, Title = "test" + i, ValidTo = DateTime.Now.AddDays(i + 1)
});
}
context.SaveChanges();
}
public IQueryable <Consumer> GetConsumerProfile([ScopedService] QueryDbContext context)
{
SetLogTransaction(CurrentUser.Id);
if (!CurrentUser.IsAuthenticated())
{
return(null);
}
return(context.Consumers
.Where(c => c.Id == CurrentUser.Id));
}
public IQueryable <Delivery> GetAll([ScopedService] QueryDbContext context, CancellationToken token)
{
SetLogTransaction();
if (CurrentUser.IsInRole(_roleOptions.Producer.Value))
{
return(context.Set <Delivery>()
.Where(c => c.ProducerId == CurrentUser.Id));
}
return(context.Set <Delivery>()
.Where(c => c.ClientId == CurrentUser.Id));
}
public async Task <bool> Get(IEnumerable <JobKind> kinds, [ScopedService] QueryDbContext context, CancellationToken token)
{
if (kinds == null)
{
kinds = new List <JobKind>();
}
SetLogTransaction(kinds);
return(await context.Jobs
.AnyAsync(r => kinds.Contains(r.Kind) && !r.Archived &&
r.Kind == JobKind.ImportProducts &&
(r.Status == ProcessStatus.Paused || r.Status == ProcessStatus.Processing || r.Status == ProcessStatus.Waiting) &&
r.UserId == CurrentUser.Id, token));
}
public async Task <User> GetUser(Donation donation, [ScopedService] QueryDbContext context,
UsersByIdBatchDataLoader usersDataLoader, CancellationToken token)
{
var userId = await context.Wallets
.Where(u => u.Id == donation.CreditedWalletId)
.Select(u => u.UserId)
.SingleOrDefaultAsync(token);
if (userId == Guid.Empty)
{
return(null);
}
return(await usersDataLoader.LoadAsync(userId, token));
}
public async Task <IEnumerable <Producer> > SuggestProducersAsync(
[GraphQLType(typeof(SearchTermsInputType))][GraphQLName("input")]
SearchTermsDto terms,
[ScopedService] QueryDbContext context, CancellationToken token)
{
SetLogTransaction(terms);
var query = context.Producers.Where(c => c.ProductsCount > 0);
if (!string.IsNullOrWhiteSpace(terms.Text))
{
query = query.Where(c => c.Name.Contains(terms.Text));
}
return(await query.ToListAsync(token));
}
public async Task Migrate_DoesNotThrowException()
{
var exception = await Record.ExceptionAsync(async() =>
{
var connString = Environment.GetEnvironmentVariable("ConnectionStrings__DirectoryConnection") ??
throw new Exception();
var options = new DbContextOptionsBuilder <QueryDbContext>()
.UseNpgsql(connString, m => m.MigrationsAssembly(typeof(Initial).Assembly.GetName().Name))
.EnableSensitiveDataLogging()
.Options;
await using var context = new QueryDbContext(options);
await context.Database.MigrateAsync();
});
Assert.Null(exception);
}
