public static HttpResponseMessage PostProductInstance(int barcode)
{
//string ProductInstanceEndPoint = "https://ifridgeapi.azurewebsites.net/api/ProductInsta";
string ProductInstanceEndPoint = "https://ifridgeapi.azurewebsites.net/api/ProductInstances";
ProductInstance newInstance = new ProductInstance()
{
Barcode = barcode,
DateAdded = DateTime.Now,
OwnerId = 0
};
using (HttpClient client = new HttpClient())
{
string ProductInstanceString = JsonConvert.SerializeObject(newInstance);
Console.WriteLine(ProductInstanceString);
StringContent content = new StringContent(ProductInstanceString, Encoding.UTF8, "application/json");
HttpResponseMessage response = client.PostAsync(ProductInstanceEndPoint, content).Result;
Console.WriteLine(response);
return(response);
}
}
public void Update(ProductInstance p)
{
var a = p.Product as Products;
p.Name = Name;
p.TypeId = Genre;
}
public ToolConsumerProfile(IEnumerable <string> capabilityOffered, string guid,
string ltiVersion, ProductInstance productInstance) :
this(new[] { LtiConstants.ToolConsumerProfileContext }, capabilityOffered, guid,
ltiVersion, productInstance)
{
}
//list tests
public static IList <Test> GetTestsSystemLevel(Machine TargetName, MachinePool testPool, Project project)
{
IList <Test> Test_List = new List <Test> {
};
try
{
OSPlatform platform = testPool.GetMachines().First().OSPlatform;
ProductInstance pi = project.CreateProductInstance(project.Name, testPool, platform);
TargetData data = pi.FindTargetFromSystem(TargetName);
if (data == null)
{
Log("Error! No target data found in system " + TargetName.Name);
Console.ReadLine();
return(Test_List);
}
pi.CreateTarget(data);
IList <Test> tests = project.GetTests();
if (tests.Count == 0)
{
Log("Warning! Test list count is 0");
Console.ReadLine();
return(Test_List);
}
Test_List = tests;
}
catch (Exception e)
{
Console.WriteLine("Exception :- {0}", e.ToString());
}
return(Test_List);
}
public ProductCostRow(ProductInstance rank, double unitCost)
{
this.Rank = rank.Name;
this.Quantity = rank.Quantity;
this.UnitCost = unitCost;
this.TotalCost = unitCost * this.Quantity;
}
public ProductDal(ProductInstance p)
{
Id = p.UniqueId;
Name = p.Name;
Genre = p.TypeId;
CustomerId = "";
}
public async Task <IActionResult> PutProductInstance(int id, ProductInstance productInstance)
{
if (id != productInstance.ProductInstanceId)
{
return(BadRequest());
}
_context.Entry(productInstance).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductInstanceExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void MainTest()
{
using (var session = Domain.OpenSession()) {
using (TransactionScope t = session.OpenTransaction()) {
new ProductModel();
session.SaveChanges();
var model = session.Query.All <ProductModel>().FirstOrDefault();
//works
session.Query.All <ProductInstance>()
.Where(pi => pi.Product.ProductModel == model)
.Where(ProductInstance.IsAvialableForSale())
.Count();
//Works
model.Products
.SelectMany(p => p.InstanceSet.Where(pi => !pi.IsChecked && !pi.IsWaybilled))
.Count();
//don't works
model.Products
.SelectMany(p => p.InstanceSet.Where(ProductInstance.IsAvialableForSale()))
.Count();
}
}
}
// Update is called once per frame
void Update()
{
if (PM.loaded && !inited)
{
inited = true;
color.ClearOptions();
size.ClearOptions();
if (Data.currentScanID == "101")
{
currProduct = PM.instances [0];
color.AddOptions(shirtColors);
size.AddOptions(shirtSizes);
}
else if (Data.currentScanID == "102")
{
currProduct = PM.instances [6];
color.AddOptions(jeansColors);
size.AddOptions(jeansSizes);
}
else if (Data.currentScanID == "103")
{
currProduct = PM.instances [12];
color.AddOptions(jacketColors);
size.AddOptions(jacketSizes);
}
setCurrentProduct();
}
}
public async Task <ActionResult <ProductInstance> > PostProductInstance(ProductInstance productInstance)
{
_context.ProductInstance.Add(productInstance);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetProductInstance", new { id = productInstance.ProductInstanceId }, productInstance));
}
/// <summary>
/// Transform entities to business objects
/// </summary>
private ProductInstance[] TransformArticles(IUnitOfWork uow, ICollection <ProductInstanceEntity> entities)
{
var results = new ProductInstance[entities.Count];
// Fetch all products we need to load product instances
var productMap = new Dictionary <long, IProductType>();
var requiredProducts = entities.Select(e => e.ProductId).Distinct();
foreach (var productId in requiredProducts)
{
productMap[productId] = LoadType(uow, productId);
}
// Create product instance using the type and fill properties
var index = 0;
foreach (var entity in entities)
{
var product = productMap[entity.ProductId];
var instance = product.CreateInstance();
instance.Id = entity.Id;
TransformInstance(uow, entity, instance);
results[index++] = instance;
}
return(results);
}
/// <inheritdoc />
public override void LoadInstance(IGenericColumns source, ProductInstance target)
{
var watch = (WatchInstance)target;
watch.TimeSet = source.Integer1 == 1;
watch.DeliveryDate = DateTime.FromBinary(source.Integer2);
}
/// <inheritdoc />
public override void SaveInstance(ProductInstance source, IGenericColumns target)
{
var watch = (WatchInstance)source;
target.Integer1 = watch.TimeSet ? 1 : 0;
target.Integer2 = watch.DeliveryDate.ToBinary();
}
public void RemoveProductInstanceTest()
{
var a = ProductInstance.Random();
var c = ProductInstances.Instance.Count;
Obj.RemoveProductInstance(a);
Assert.AreEqual(c, ProductInstances.Instance.Count);
}
public void AddProductInstanceTest()
{
var a = ProductInstance.Random(); // productinstance
var c = ProductInstances.Instance.Count; // counter
Obj.AddProductInstance(a);
Assert.AreEqual(c + 1, ProductInstances.Instance.Count);
Assert.AreEqual(a, ProductInstances.Instance.Find(x => x.UniqueId == a.UniqueId));
}
public void UpdateTest()
{
var obj = new ProductEditModel(product);
TestProperty(() => obj.Genre, x => obj.Genre = x, product.TypeId);
ProductInstance newInstance = ProductInstance.Random();
obj.Update(newInstance);
TestProperty(() => obj.Genre, x => obj.Genre = x, newInstance.TypeId);
}
public ToolConsumerProfile(IEnumerable <string> context, IEnumerable <string> capabilityOffered, string guid,
string ltiVersion, ProductInstance productInstance)
{
// These are the required fields in a ToolConsumerProfile
Context = context;
Type = "ToolConsumerProfile";
CapabilityOffered = capabilityOffered;
Guid = guid;
LtiVersion = ltiVersion;
ProductInstance = productInstance;
}
public void FindTest()
{
var s = GetRandom.String();
Assert.IsNull(Products.Find(s));
var t = ProductInstance.Random();
t.UniqueId = s;
Products.Instance.Add(t);
Products.Instance.AddRange(Products.Random());
Assert.AreEqual(t, Products.Find(s));
}
public static void DeleteProductInstance(ProductInstance instance)
{
ProductDal dbProductDal = db.Products.Find(instance.UniqueId);
if (dbProductDal == null)
{
Console.WriteLine("Couldn't find entity to delete!");
}
else
{
db.Products.Remove(entity: dbProductDal);
db.SaveChanges();
}
}
public static List <ProductInstance> GetCustomerLendedBooks(string customerId)
{
var list = new List <ProductInstance>();
foreach (var u in db.Products.SqlQuery("SELECT * FROM dbo.Books WHERE CustomerId = @id", new SqlParameter("@id", customerId)))
{
var au = new ProductInstance();
au.UniqueId = u.Id;
au.Name = u.Name;
au.TypeId = u.Genre;
list.Add(au);
}
return(list);
}
public static List <ProductInstance> Load()
{
var list = new List <ProductInstance>();
foreach (var u in db.Products)
{
var au = new ProductInstance();
au.UniqueId = u.Id;
au.Name = u.Name;
au.TypeId = u.Genre;
list.Add(au);
}
return(list);
}
public ActionResult AddBook([Bind(Include = "Id,Name,Genre")] ProductEditModel e)
{
if (!ModelState.IsValid)
{
return(View("AddBook", e));
}
var book = new ProductInstance {
Product = new Products()
};
book.UniqueId = GetRandom.String();
e.Update(book);
BusinessProduct.SaveProductInstance(book);
return(RedirectToAction("Index"));
}
public static void UpdateProductInstance(ProductInstance instance)
{
ProductDal dbProductDal = db.Products.Find(instance.UniqueId);
if (dbProductDal == null)
{
Console.WriteLine("Couldn't find entity to update!");
}
else
{
dbProductDal.Name = instance.Name;
dbProductDal.Genre = instance.TypeId;
db.Products.AddOrUpdate(dbProductDal);
db.SaveChanges();
}
}
public bool putProduct(ProductInstance product)
{
if (holding)
{
foreach (Transition t in blueprint.transitions)
{
if (t.src == product.id)
{
StartCoroutine(holding.transformProduct(t.src, t.time));
return(true);
}
}
return(false);
}
holding = product;
return(true);
}
public static Transfer Sell(this Organization Shop, Product Product, decimal Quantity, DateTime?SellDate = null)
{
Organization customer = GetCustomer();
ProductInstance many = Db.SQL <ProductInstance>("SELECT p FROM Simplified.Ring3.ProductInstance p WHERE p.Product = ? AND p.Owner = ? AND p.IsAggregate = ? AND p.Quantity > ?", Product, Shop, false, 0).First;
if (many == null || many.Quantity < Quantity)
{
throw new ArgumentOutOfRangeException("Quantity", "No ProductInstances to sell " + Quantity);
}
var toSell = new ProductInstance()
{
Quantity = Quantity, Product = Product, Owner = Shop
};
if (many.Quantity > toSell.Quantity)
{
var notSold = new ProductInstance()
{
Quantity = many.Quantity - toSell.Quantity, Product = Product, Owner = Shop
};
new Subset()
{
WhatIs = notSold, ToWhat = many
};
}
new Subset()
{
WhatIs = toSell, ToWhat = many
};
many.IsAggregate = true;
DateTime date = SellDate ?? DateTime.Now;
Transfer t = new Transfer()
{
When = date, ProductInstance = toSell, From = Shop, To = customer
};
toSell.Owner = customer;
return(t);
}
private static IProductInstance ProductInstanceFromRow(Row row)
{
if (row == null)
{
return(null);
}
var tt = row.GetValue <string>("documenttype");
var type = Type.GetType(tt);
var document = row.GetValue <string>("document");
var theObject = JsonConvert.DeserializeObject(document, type);
var documentRecord = new ProductInstance <object>(row.GetValue <Guid>("id"), theObject)
{
DocumentMetaData = new DocumentMetaData(type.FullName, row.GetValue <string>("documentversion")),
BubbleId = row.GetValue <Guid>("bubbleid"),
Label = row.GetValue <string>("label"),
ProductTemplateId = row.GetValue <Guid>("producttemplateid"),
};
return(documentRecord);
}
public static ProductInstance ToEntity(this ProductInstanceEditDto e)
{
if (e == null)
{
return(null);
}
var res = new ProductInstance();
res.Id = e.Id;
res.Description = e.Description;
res.Name = e.Name;
res.IdProduct = e.IdProduct;
res.Months = e.Months;
res.Price = e.Price;
res.Weeks = e.Weeks;
res.Years = e.Years;
res.Days = e.Days;
return(res);
}
public int ProductInstanceCreateOrUpdate(ProductInstance productInstance)
{
using (var connection = this.getConnection())
{
DynamicParameters ParamsForProc = new DynamicParameters();
ParamsForProc.Add("@FKRoom", productInstance.FKRoom);
ParamsForProc.Add("@Rating", productInstance.Rating);
ParamsForProc.Add("@Price", productInstance.Price);
if (productInstance.Id != 0)
{
ParamsForProc.Add("@Id", productInstance.Id);
connection.Execute("ProductInstance_Update", ParamsForProc, commandType: CommandType.StoredProcedure);
return(productInstance.Id);
}
// These param should not be updated. If any of these are updated, then its inherantly a different Product Instance.
ParamsForProc.Add("@FKParentInstance", productInstance.FKParentInstance);
ParamsForProc.Add("@FKProject", productInstance.FKProject);
ParamsForProc.Add("@ProductTypeGUID", productInstance.ProductTypeGUID);
ParamsForProc.Add("@newid", DbType.Int32, direction: ParameterDirection.ReturnValue);
connection.Execute("ProductInstance_Create", ParamsForProc, commandType: CommandType.StoredProcedure);
return(ParamsForProc.Get <int>("@newid"));
}
}
//list tests
public static IList <Test> GetTestsDeviceLevel(Machine TargetName, MachinePool testPool, Project project)
{
IList <Test> Test_List = new List <Test> {
};
try
{
OSPlatform platform = testPool.GetMachines().First().OSPlatform;
ProductInstance pi = project.CreateProductInstance(project.Name, testPool, platform);
//Device Level
ReadOnlyCollection <TargetData> devices = testPool.GetMachines().First().GetTestTargets();
TargetData device_tpm = null;
//Find TPM device
foreach (TargetData device in devices)
{
if (device.Name.Contains("Trusted Platform Module 2.0"))
{
Console.WriteLine(device.Name);
device_tpm = device;
}
}
pi.CreateTarget(device_tpm);
IList <Test> tests_tpm = project.GetTests();
if (tests_tpm.Count == 0)
{
Log("Warning! Device Level Test list count is 0");
Console.ReadLine();
return(tests_tpm);
}
Test_List = tests_tpm;
}
catch (Exception e)
{
Console.WriteLine("Exception :- {0}", e.ToString());
}
return(Test_List);
}
/// <summary>
/// Base implementation to save an instance hierarchy.
/// </summary>
/// <param name="uow">An open unit of work</param>
/// <param name="productInstance">The instance to save</param>
/// <returns>The instance entity.</returns>
private ProductInstanceEntity SaveInstance(IUnitOfWork uow, ProductInstance productInstance)
{
// Check if this type is persisted
var strategy = InstanceStrategies[productInstance.GetType().Name];
if (strategy.SkipInstances)
{
return(null);
}
// Save to entity
var archived = uow.GetEntity <ProductInstanceEntity>(productInstance);
archived.ProductId = productInstance.Type.Id;
strategy.SaveInstance(productInstance, archived);
// Save its parts if the have a dedicated archive
var partsContainer = ReflectionTool.GetReferences <ProductInstance>(productInstance);
foreach (var partGroup in partsContainer)
{
foreach (var part in partGroup)
{
var partEntity = SaveInstance(uow, part);
if (partEntity == null) // Parts are null when they are skipped
{
continue;
}
partEntity.Parent = archived;
partEntity.PartLinkId = part.PartLink.Id;
}
}
return(archived);
}
static async Task MainAsync(string[] args)
{
try
{
var productTemplate = new ProductTemplate<GenericProductV1>(Guid.NewGuid(),
new GenericProductV1()
{
Services =
{
{"OxygenId", Guid.NewGuid().ToString()},
{"StoratePlatformId", Guid.NewGuid().ToString()}
}
}
)
{
DocumentMetaData = new DocumentMetaData(typeof(GenericProductV1).FullName,"1.0")
};
string output = productTemplate.DocumentJson;
List<Guid> productGuids = new List<Guid>();
productGuids.Add(productTemplate.Id);
// Product Templates
var ptRes = await CassandraDAO.CreateProductTemplateAsync(productTemplate);
// make a double to test insert by type.
productTemplate.DocumentMetaData.Version = "1.1";
productTemplate.Id = Guid.NewGuid();
productGuids.Add(productTemplate.Id);
ptRes = await CassandraDAO.CreateProductTemplateAsync(productTemplate);
Console.WriteLine("-----------------------------------------------");
foreach (var id in productGuids)
{
var ptRead = await CassandraDAO.FindProductTemplateByIdAsync(id);
Console.WriteLine("");
Console.WriteLine("ProductTemplate");
Console.WriteLine(ptRead.Json);
Console.WriteLine(ptRead.MetaDataJson);
Console.WriteLine(ptRead.DocumentJson);
}
var ptRecords = await CassandraDAO.FindProductTemplateByTypeAsync(productTemplate.MetaData.Type);
Console.WriteLine("-----------------------------------------------");
foreach (var ptRecord in ptRecords)
{
Console.WriteLine("");
Console.WriteLine("ProductTemplate");
Console.WriteLine(ptRecord.Json);
Console.WriteLine(ptRecord.MetaDataJson);
Console.WriteLine(ptRecord.DocumentJson);
}
Console.WriteLine("-----------------------------------------------");
productGuids.Clear();
// Bubble
var bid = Guid.NewGuid();
var bubbleRecord = new BubbleRecord()
{
Id = bid,
BubbleChainId = Guid.Empty,
DeviceId = Guid.Empty,
DeviceIdText = null,
Name = "Nameof:" + bid
};
var bidRes = await CassandraDAO.CreateBubbleRecordAsync(bubbleRecord);
var bidRead = await CassandraDAO.FindBubbleRecordByIdAsync(bubbleRecord.Id);
Console.WriteLine("");
Console.WriteLine("Bubbles");
Console.WriteLine(bidRead.Json);
var label = "Label:" + Guid.NewGuid();
// Product Instance
var doc = new GenericProductV1()
{
Services =
{
{"OxygenId", Guid.NewGuid().ToString()},
{"StoratePlatformId", Guid.NewGuid().ToString()}
}
};
var productInstance = new ProductInstance<GenericProductV1>(
Guid.NewGuid(), doc, productTemplate.DocumentMetaData, productTemplate.Id, label, bubbleRecord.Id);
productGuids.Add(productInstance.Id);
var piRes = await CassandraDAO.CreateProductInstanceAsync(productInstance);
productInstance.Id = Guid.NewGuid();
productInstance.BubbleId = Guid.NewGuid();
productGuids.Add(productInstance.Id);
piRes = await CassandraDAO.CreateProductInstanceAsync(productInstance);
Console.WriteLine("-----------------------------------------------");
foreach (var id in productGuids)
{
var piRead = await CassandraDAO.FindProductInstanceByIdAsync(id);
Console.WriteLine("");
Console.WriteLine("ProductInstance");
Console.WriteLine(piRead.Json);
Console.WriteLine(piRead.MetaDataJson);
Console.WriteLine(piRead.DocumentJson);
}
Console.WriteLine("-----------------------------------------------");
var piRecords = await CassandraDAO.FindProductInstanceByLabelAsync(productInstance.Label);
foreach (var record in piRecords)
{
Console.WriteLine("");
Console.WriteLine("ProductInstance");
Console.WriteLine(record.Json);
Console.WriteLine(record.MetaDataJson);
Console.WriteLine(record.DocumentJson);
}
Console.WriteLine("-----------------------------------------------");
}
catch (Exception e)
{
}
}
