public async static Task UpdateProductProcessTaskAsync([QueueTrigger("product")] ProductMessage message)
{
var builder = new ConfigurationBuilder();
builder.Add(new JsonConfigurationSource("config.json"));
var config = builder.Build();
var connectionString = config["Data:DefaultConnection:ConnectionString"];
using (var context = new PartsUnlimitedContext(connectionString))
{
var dbProductList = await context.Products.ToListAsync();
foreach (var queueProduct in message.ProductList)
{
var dbProduct = dbProductList.SingleOrDefault(x => x.SkuNumber == queueProduct.SkuNumber);
if (dbProduct != null)
{
dbProduct.Inventory = queueProduct.Inventory;
dbProduct.LeadTime = queueProduct.LeadTime;
}
}
await context.SaveChangesAsync(CancellationToken.None);
}
}
public void SearchTest01()
{
using (PexDisposableContext disposables = PexDisposableContext.Create())
{
PartsUnlimitedContext partsUnlimitedContext;
StringContainsProductSearch stringContainsProductSearch;
Task <IEnumerable <Product> > task;
partsUnlimitedContext = new PartsUnlimitedContext();
partsUnlimitedContext.Products = (IDbSet <Product>)null;
partsUnlimitedContext.Orders = (IDbSet <Order>)null;
partsUnlimitedContext.Categories = (IDbSet <Category>)null;
partsUnlimitedContext.CartItems = (IDbSet <CartItem>)null;
partsUnlimitedContext.OrderDetails = (IDbSet <OrderDetail>)null;
partsUnlimitedContext.RainChecks = (IDbSet <Raincheck>)null;
partsUnlimitedContext.Stores = (IDbSet <Store>)null;
((IdentityDbContext <ApplicationUser, IdentityRole, string,
IdentityUserLogin, IdentityUserRole, IdentityUserClaim>)partsUnlimitedContext)
.Users = (IDbSet <ApplicationUser>)null;
((IdentityDbContext <ApplicationUser, IdentityRole, string,
IdentityUserLogin, IdentityUserRole, IdentityUserClaim>)partsUnlimitedContext)
.Roles = (IDbSet <IdentityRole>)null;
((IdentityDbContext <ApplicationUser, IdentityRole, string,
IdentityUserLogin, IdentityUserRole, IdentityUserClaim>)partsUnlimitedContext)
.RequireUniqueEmail = false;
disposables.Add((IDisposable)partsUnlimitedContext);
stringContainsProductSearch = new StringContainsProductSearch
((IPartsUnlimitedContext)partsUnlimitedContext);
task = this.SearchTest(stringContainsProductSearch, "");
disposables.Add((IDisposable)task);
disposables.Dispose();
}
}
private void InitializeDb()
{
using (var db = new PartsUnlimitedContext())
{
db.Database.Initialize(false);
}
}
public static void CreateOrderProcessTask([Queue("orders")] CloudQueue orderQueue)
{
Console.WriteLine("Starting Create Order Process Task");
try
{
var builder = new ConfigurationBuilder();
builder.Add(new JsonConfigurationSource("config.json"));
var config = builder.Build();
var connectionString = config["Data:DefaultConnection:ConnectionString"];
using (var context = new PartsUnlimitedContext(connectionString))
{
var orders = context.Orders.Where(x => !x.Processed).ToList();
Console.WriteLine("Found {0} orders to process", orders.Count);
foreach (var order in orders)
{
var productIds = context.OrderDetails.Where(x => x.OrderId == order.OrderId).Select(x => x.ProductId).ToList();
var items = context.Products
.Where(x => productIds.Contains(x.ProductId))
.ToList();
var orderItems = items.Select(
x => new LegacyOrderItem
{
SkuNumber = x.SkuNumber,
Price = x.Price
}).ToList();
var queueOrder = new LegacyOrder
{
Address = order.Address,
Country = order.Country,
City = order.City,
Phone = order.Phone,
CustomerName = order.Name,
OrderDate = order.OrderDate,
PostalCode = order.PostalCode,
State = order.State,
TotalCost = order.Total,
Discount = order.Total,
Items = orderItems
};
var settings = new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var message = JsonConvert.SerializeObject(queueOrder, settings);
orderQueue.AddMessage(new CloudQueueMessage(message));
order.Processed = true;
}
context.SaveChanges();
Console.WriteLine("Orders successfully processed.");
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public static void CreateOrderProcessTask([Queue("orders")] CloudQueue orderQueue)
{
Console.WriteLine("Starting Create Order Process Task");
try
{
var builder = new ConfigurationBuilder();
//builder.Add(new JsonConfigurationSource("config.json"));
builder.AddJsonFile("config.json");
var config = builder.Build();
var connectionString = config["Data:DefaultConnection:ConnectionString"];
using (var context = new PartsUnlimitedContext(connectionString))
{
var orders = context.Orders.Where(x => !x.Processed).ToList();
Console.WriteLine("Found {0} orders to process", orders.Count);
foreach (var order in orders)
{
var productIds = context.OrderDetails.Where(x => x.OrderId == order.OrderId).Select(x => x.ProductId).ToList();
var items = context.Products
.Where(x => productIds.Contains(x.ProductId))
.ToList();
var orderItems = items.Select(
x => new LegacyOrderItem
{
SkuNumber = x.SkuNumber,
Price = x.Price
}).ToList();
var queueOrder = new LegacyOrder
{
Address = order.Address,
Country = order.Country,
City = order.City,
Phone = order.Phone,
CustomerName = order.Name,
OrderDate = order.OrderDate,
PostalCode = order.PostalCode,
State = order.State,
TotalCost = order.Total,
Discount = order.Total,
Items = orderItems
};
var settings = new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() };
var message = JsonConvert.SerializeObject(queueOrder, settings);
orderQueue.AddMessage(new CloudQueueMessage(message));
order.Processed = true;
}
context.SaveChanges();
Console.WriteLine("Orders successfully processed.");
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "categories")] HttpRequestMessage req, TraceWriter log)
{
GlobalConfiguration.SetConfiguration(req);
log.Info("Retrieving Product Categories");
var db = new PartsUnlimitedContext();
var categories = await db.Categories.ToListAsync();
return(req.CreateResponse(HttpStatusCode.OK, categories));
}
public void Can_create_db()
{
// when
using (var db = new PartsUnlimitedContext())
{
db.Database.Initialize(true);
}
// then
Assert.That(Database.Exists("PartsUnlimitedContext"), Is.True);
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "categories/{id:int}")] HttpRequestMessage req, int?id, TraceWriter log)
{
GlobalConfiguration.SetConfiguration(req);
log.Info($"Get Product Category {id}");
if (!id.HasValue)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, "Please pass a valid category ID"));
}
var db = new PartsUnlimitedContext();
var genreModel = await db.Categories.Include("Products").SingleAsync(g => g.CategoryId == id.Value);
return(req.CreateResponse(HttpStatusCode.OK, genreModel));
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "product/{id:int}")] HttpRequestMessage req, int?id, TraceWriter log)
{
GlobalConfiguration.SetConfiguration(req);
log.Info($"GetProductDetails {id}");
if (!id.HasValue)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, "Please pass a valid product id"));
}
var db = new PartsUnlimitedContext();
var product = await db.Products.SingleAsync(a => a.ProductId == id.Value);
return(req.CreateResponse(HttpStatusCode.OK, product));
}
public async static Task UpdateProductProcessTaskAsync([QueueTrigger("product")] ProductMessage message)
{
using (var context = new PartsUnlimitedContext())
{
var dbProductList = await context.Products.ToListAsync();
foreach (var queueProduct in message.ProductList)
{
var dbProduct = dbProductList.SingleOrDefault(x => x.SkuNumber == queueProduct.SkuNumber);
if (dbProduct != null)
{
dbProduct.Inventory = queueProduct.Inventory;
dbProduct.LeadTime = queueProduct.LeadTime;
}
}
await context.SaveChangesAsync(CancellationToken.None);
}
}
public async static Task UpdateProductProcessTaskAsync([QueueTrigger("product")] ProductMessage message)
{
using (var context = new PartsUnlimitedContext())
{
var dbProductList = await context.Products.ToListAsync();
foreach (var queueProduct in message.ProductList)
{
var dbProduct = dbProductList.SingleOrDefault(x => x.SkuNumber == queueProduct.SkuNumber);
if (dbProduct != null)
{
dbProduct.Inventory = queueProduct.Inventory;
dbProduct.LeadTime = queueProduct.LeadTime;
}
}
await context.SaveChangesAsync(CancellationToken.None);
}
}
public async static Task UpdateProductProcessTaskAsync([QueueTrigger("product")] ProductMessage message)
{
var config = new Configuration().AddJsonFile("config.json");
var connectionString = config.Get("Data:DefaultConnection:ConnectionString");
using (var context = new PartsUnlimitedContext(connectionString))
{
var dbProductList = await context.Products.ToListAsync();
foreach (var queueProduct in message.ProductList)
{
var dbProduct = dbProductList.SingleOrDefault(x => x.SkuNumber == queueProduct.SkuNumber);
if (dbProduct != null)
{
dbProduct.Inventory = queueProduct.Inventory;
dbProduct.LeadTime = queueProduct.LeadTime;
}
}
await context.SaveChangesAsync(CancellationToken.None);
}
}
public static void Main(string[] args)
{
var host = BuildWebHost(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
PartsUnlimitedContext context = services.GetRequiredService <PartsUnlimitedContext>();
context.Database.EnsureCreated();
//Populates the PartsUnlimited sample data
SampleData.InitializePartsUnlimitedDatabaseAsync(services).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
host.Run();
}
public HomeController(PartsUnlimitedContext context, IMemoryCache memoryCache)
{
_db = context;
_cache = memoryCache;
}
public CustomerController(PartsUnlimitedContext context)
{
_context = context;
}
public AnnouncementComponent(PartsUnlimitedContext context, IMemoryCache memoryCache)
{
_db = context;
_cache = memoryCache;
}
public ProductsController(PartsUnlimitedContext db)
{
_db = db;
}
public StoreManagerController(PartsUnlimitedContext context, IMemoryCache memoryCache)
{
_db = context;
_cache = memoryCache;
}
public RainChecksController(PartsUnlimitedContext db)
{
_db = db;
}
public CheckoutController(PartsUnlimitedContext context, UserManager <ApplicationUser> userManager, IConfiguration configuration)
{
_userManager = userManager;
_db = context;
Configuration = configuration;
}
public StringContainsProductSearch(PartsUnlimitedContext context)
{
_context = context;
}
public RaincheckQuery(PartsUnlimitedContext context)
{
_context = context;
}
public RecommendationsController(PartsUnlimitedContext context, IRecommendationEngine recommendationEngine, IWebsiteOptions websiteOptions)
{
_db = context;
_recommendation = recommendationEngine;
_option = websiteOptions;
}
public ProductsController(PartsUnlimitedContext context)
{
_context = context;
}
public ChallengeSeedsController(PartsUnlimitedContext context)
{
db = context;
}
public CategoryMenuComponent(PartsUnlimitedContext context, IMemoryCache memoryCache)
{
_db = context;
_cache = memoryCache;
}
public OrdersQuery(PartsUnlimitedContext context)
{
_db = context;
}
public CartSummaryComponent(PartsUnlimitedContext context)
{
_db = context;
}
public ShoppingCartController(PartsUnlimitedContext context, ITelemetryProvider telemetryProvider, IAntiforgery antiforgery)
{
_db = context;
_telemetry = telemetryProvider;
_antiforgery = antiforgery;
}
