public async Task <CurrencyModel> GetCurrency(int currencyId)
{
using (var context = DataContextFactory.CreateContext())
{
return(await context.Currency.Select(MapCurrency).FirstOrDefaultNoLockAsync(c => c.Id == currencyId));
}
}
public ProductBaseModel GetProductBaseModel(int productBaseId)
{
if (productBaseId == 0)
{
return(new ProductBaseModel());
}
using (var context = _contextFactory.CreateContext())
{
var model = context.ProductBases
.AsNoTracking()
.Where(p => p.ProductBaseId == productBaseId)
.Include(pb => pb.Products).ThenInclude(p => p.Prices)
.Include(pb => pb.Products).ThenInclude(p => p.ProductSource)
.Include(pb => pb.Products).ThenInclude(p => p.ProductDestination)
.Include(pb => pb.ProductVariationsLink).ThenInclude(pvl => pvl.ProductVariation)
.Select(p => MappingFactory.MapTo <ProductBaseModel>(p))
.FirstOrDefault();
var priceList = context.PriceLists
.AsNoTracking()
.Where(pl => pl.Prices.Any(p => p.Product.ProductBaseId == productBaseId))
.Select(pl => MappingFactory.MapTo <PriceListModel>(pl));
model.PriceLists = new ObservableCollection <PriceListModel>(priceList);
return(model);
}
}
public async Task <TradePairModel> GetTradePair(int tradePairId)
{
using (var context = DataContextFactory.CreateContext())
{
return(await context.TradePair
.Where(t => t.Currency1.IsEnabled && t.Currency2.IsEnabled)
.Include(t => t.Currency1)
.Include(t => t.Currency2)
.Select(MapTradePair)
.FirstOrDefaultNoLockAsync(t => t.Id == tradePairId));
}
}
public IList <LocationInventoryListModel> GetLocationInventoryListModels(LocationInventoryListOptionModel options)
{
using (var context = _contextFactory.CreateContext())
{
return(context.Inventory
.AsNoTracking()
.FilterBy(options)
.OrderBy(i => i.Product.ProductCode)
.ProjectBetween <Inventory, LocationInventoryListModel>()
.ToList());
}
}
public async void InitializeAsync()
{
using (var context = _contextFactory.CreateContext())
{
BusinessLines = await GetBusinessLinesAsync(context);
ProductSourceTypes = await GetProductSourceTypesAsync(context);
ProductDestinationTypes = await GetProductDestinationTypesAsync(context);
ProductStatuses = await GetProductStatusesAsync(context);
ProductMaterials = await GetProductMaterialsAsync(context);
ProductTypes = await GetProductTypesAsync(context);
ProductGroups = await GetProductGroupsAsync(context);
ProductBrands = await GetProductBrandsAsync(context);
ProductCollections = await GetProductCollectionsAsync(context);
ProductDesigns = await GetProductDesignsAsync(context);
ProductSourceCompanies = await GetProductSourceCompanies(context);
ProductDestCompanies = await GetProductDestCompanies(context);
PriceLists = await GetPriceListsAsync(context);
}
}
public SalesOrderModel GetSalesOrderModel(int salesOrderId)
{
using (var context = _contextFactory.CreateContext())
{
return(context.SalesOrders
.AsNoTracking()
.Where(s => s.SalesOrderId == salesOrderId)
.ProjectBetween <SalesOrder, SalesOrderModel>()
.FirstOrDefault());
}
}
public DeliveryNoteModel GetDeliveryNoteModel(int deliveryHeaderId)
{
using (var context = _contextFactory.CreateContext())
{
return(context.DeliveryHeaders
.AsNoTracking()
.Where(d => d.DeliveryHeaderId == deliveryHeaderId)
.ProjectBetween <DeliveryHeader, DeliveryNoteModel>()
.FirstOrDefault());
}
}
public async void InitializeAsync()
{
using (var context = _contextFactory.CreateContext())
{
LocationTypes = await GetLocationTypesAsync(context);
Locations = await GetLocationsAsync(context);
DocumentStates = GetDocumentStates();
}
}
public IList <CompanyListModel> GetCompanyListModels(string query)
{
using (var context = _contextFactory.CreateContext())
{
return(context.Companies
.AsNoTracking()
.FilterBy(query)
.OrderBy(c => c.Name)
.ProjectBetween <Company, CompanyListModel>()
.ToList());
}
}
public IList <ProductListModel> GetProductListModels(ProductListOptionsModel options)
{
using (var context = _contextFactory.CreateContext())
{
return(context.ProductBases
.AsNoTracking()
.FilterBy(options)
.OrderBy(p => p.ProductBaseCode)
.ProjectBetween <ProductBase, ProductListModel>()
.ToList());
}
}
public IList <DeliveryNoteListModel> GetDeliveryNoteListModels(DeliveryNoteListOptionsModel options)
{
using (var context = _contextFactory.CreateContext())
{
return(context.DeliveryHeaders
.AsNoTracking()
.FilterBy(options)
.OrderByDescending(d => d.DocDate)
.ProjectBetween <DeliveryHeader, DeliveryNoteListModel>()
.ToList());
}
}
public IList <SalesOrderListModel> GetSalesOrderListModels(SalesOrderListOptionsModel options)
{
using (var context = _contextFactory.CreateContext())
{
return(context.SalesOrders
.AsNoTracking()
.FilterBy(options)
.OrderByDescending(s => s.OrderNo)
.ProjectBetween <SalesOrder, SalesOrderListModel>()
.ToList());
}
}
public IList <LocationListModel> GetLocationListModels(int locationTypeId)
{
using (var context = _contextFactory.CreateContext())
{
return(context.Locations
.AsNoTracking()
.Where(l => l.LocationTypeId == locationTypeId)
.OrderBy(l => l.LocationName)
.Select(l => new LocationListModel
{
LocationId = l.LocationId,
LocationName = l.LocationName,
TotalReservedQuantity = l.Inventory.Sum(i => i.ReservedQuantity),
TotalStockQuantity = l.Inventory.Sum(i => i.StockQuantity)
})
.ToList());
}
}
public async void InitializeAsync()
{
using (var context = _contextFactory.CreateContext())
{
Countries = await GetCountriesAsync(context);
DocumentStates = GetDocumentStates();
Customers = await GetCustomersAsync(context);
Locations = await GetLocationsAsync(context);
PriceLists = await GetPriceListsAsync(context);
DeliveryTerms = await GetDeliveryTermsAsync(context);
PaymentTerms = await GetPaymentTermsAsync(context);
}
}
public async void InitializeAsync()
{
using (var context = _contextFactory.CreateContext())
{
Countries = await GetCountriesAsync(context);
Currencies = await GetCurrenciesAsync(context);
PriceLists = await GetPriceListsAsync(context);
Locations = await GetLocationsAsync(context);
DeliveryTerms = await GetDeliveryTermsAsync(context);
PaymentTerms = await GetPaymentTermsAsync(context);
CompanyTypes = await GetCompanyTypesAsync(context);
}
}
public static async Task <bool> UpdateGameStatus(int gameId, GameStatus status)
{
try
{
Log.Message(LogLevel.Info, $"[UpdateGameStatus] - Updating game status, GameId: {gameId}, Status: {status}");
using (var context = DataContextFactory.CreateContext())
{
var game = await context.Games.FirstOrDefaultAsync(x => x.Id == gameId);
if (game == null)
{
return(false);
}
if (status == GameStatus.Finished && game.Type == GameType.TeamBattle)
{
var result = 1;
var teams = await context.Team
.Where(x => x.GameId == game.Id)
.OrderByDescending(x => x.Pixels.Count)
.ThenBy(x => x.Name)
.ToListAsync();
foreach (var team in teams)
{
team.Result = result;
result++;
}
}
game.Status = status;
await context.SaveChangesAsync();
Log.Message(LogLevel.Info, "[UpdateGameStatus] - Updating game status award complete.");
return(true);
}
}
catch (Exception ex)
{
Log.Message(LogLevel.Error, $"[UpdateGameStatus] - Exception updating game status, Error: {ex.Message}");
}
return(false);
}
private async Task ProcessEmails()
{
Log.Message(LogLevel.Info, "[ProcessEmails] - ProcessEmails started...");
using (var context = _dataContextFactory.CreateContext())
{
var templates = await context.EmailTemplate
.Where(x => x.IsEnabled)
.ToListAsync();
var emails = await context.EmailOutbox
.Where(x => x.Status == EmailStatus.Pending)
.ToListAsync();
if (emails.IsNullOrEmpty())
{
Log.Message(LogLevel.Info, "[ProcessEmails] - No pending emails found.");
return;
}
Log.Message(LogLevel.Info, "[ProcessEmails] - {0} pending emails found.", emails.Count);
foreach (var email in emails)
{
Log.Message(LogLevel.Info, "[ProcessEmails] - Processing email, Id: {0}.", email.Id);
var template = templates.FirstOrDefault(x => x.Type == email.Type && x.Culture.Equals(email.UserCulture, StringComparison.OrdinalIgnoreCase))
?? templates.FirstOrDefault(x => x.Type == email.Type && x.Culture.Equals("en-US", StringComparison.OrdinalIgnoreCase));
if (template == null)
{
email.Status = EmailStatus.Failed;
email.Error = "Template missing.";
}
else
{
email.Status = await SendEmail(template, email);
}
email.Updated = DateTime.UtcNow;
await context.SaveChangesAsync();
Log.Message(LogLevel.Info, "[ProcessEmails] - Processed email, Id: {0}, Status: {1}", email.Id, email.Status);
}
Log.Message(LogLevel.Info, "[ProcessEmails] - ProcessEmails complete.");
}
}
public CompanyModel GetCompanyModel(int companyId)
{
if (companyId == 0)
{
return(GetNewCompanyModel());
}
using (var context = _contextFactory.CreateContext())
{
return(context.Companies
.AsNoTracking()
.Include(c => c.Addresses)
.Include(c => c.Contacts)
.Include(c => c.CompanyTypesLink).ThenInclude(l => l.CompanyType)
.Where(c => c.CompanyId == companyId)
//.ProjectBetween<Company, CompanyModel>()
.Select(c => MappingFactory.MapTo <CompanyModel>(c))
.FirstOrDefault());
}
}
protected TDataContext CreateContext <TDataContext>(Func <IDbConnection, TDataContext> createContext)
where TDataContext : DataContext
{
return(_dataContextFactory.CreateContext(createContext));
}