public void TestTop()
{
var box = Factory.CreateBox("Box", 10, 10, 10, 0, 10, 10, 10, 100);
var itemA = Factory.CreateItem("Item A", 5, 10, 10, 10, true);
var itemB = Factory.CreateItem("Item B", 5, 10, 10, 20, true);
var packedItemA = new PackedItem(itemA, 0, 0, 0, 5, 10, 10);
var packedItemB = new PackedItem(itemB, 0, 0, 0, 5, 10, 10);
var packedItemListA = new PackedItemList();
packedItemListA.Insert(packedItemA);
var packedBoxA = new PackedBox(box, packedItemListA);
var packedItemListB = new PackedItemList();
packedItemListB.Insert(packedItemB);
var packedBoxB = new PackedBox(box, packedItemListB);
var pBoxArray = new PackedBox[] { packedBoxA, packedBoxB };
var packedBoxList = new PackedBoxList();
packedBoxList.Insert(packedBoxA);
packedBoxList.Insert(packedBoxB);
Assert.Equal(packedBoxA, packedBoxList.Top());
}
public void TestGetters()
{
var box = Factory.CreateBox("Box", 370, 375, 60, 140, 364, 374, 40, 3000);
var oItem = new OrientatedItem(
Factory.CreateItem("Item", 230, 330, 6, 320, true),
230,
330,
6
);
var packedItemList = new PackedItemList();
packedItemList.Insert(PackedItem.FromOrientatedItem(oItem, 0, 0, 0));
var pBox = new PackedBox(box, packedItemList);
Assert.Equal(box.Reference, pBox.Box.Reference);
Assert.Equal(460, pBox.TotalWeight);
Assert.Equal(134, pBox.RemainingWidth);
Assert.Equal(44, pBox.RemainingLength);
Assert.Equal(34, pBox.RemainingDepth);
Assert.Equal(2540, pBox.RemainingWeight);
Assert.Equal(5445440, pBox.InnerVolume);
}
public void CreateAdjustEntry(StoredBox sBox, int itemPK, double adjustedQuantity, bool isRestored, bool isMinus, AdjustingSession adjustingSession)
{
try
{
Entry entry;
Accessory accessory;
if (isRestored)
{
RestoredItem restoredItem = db.RestoredItems.Find(itemPK);
accessory = db.Accessories.Find(restoredItem.AccessoryPK);
}
else
{
PassedItem passedItem = db.PassedItems.Find(itemPK);
ClassifiedItem classifiedItem = db.ClassifiedItems.Find(passedItem.ClassifiedItemPK);
PackedItem packedItem = db.PackedItems.Find(classifiedItem.PackedItemPK);
OrderedItem orderedItem = db.OrderedItems.Find(packedItem.OrderedItemPK);
accessory = db.Accessories.Find(orderedItem.AccessoryPK);
}
if (isMinus)
{
entry = new Entry(sBox, "AdjustingMinus", adjustingSession.AdjustingSessionPK, isRestored, adjustedQuantity, itemPK, accessory);
}
else
{
entry = new Entry(sBox, "AdjustingPlus", adjustingSession.AdjustingSessionPK, isRestored, adjustedQuantity, itemPK, accessory);
}
db.Entries.Add(entry);
db.SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
public List <PackedLayer> Stabilise(IEnumerable <PackedLayer> packedLayers)
{
// first re-order according to footprint
var stabilizedLayers = new List <PackedLayer>();
packedLayers.OrderBy(l => l);
var currentZ = 0;
foreach (var oldZLayer in packedLayers)
{
var oldZStart = oldZLayer.GetStartDepth();
var newZLayer = new PackedLayer();
foreach (var oldZItem in oldZLayer.Items)
{
var newZ = oldZItem.Z - oldZStart + currentZ;
var newZItem = new PackedItem()
{
Item = oldZItem.Item,
Width = oldZItem.Width,
Length = oldZItem.Length,
Depth = oldZItem.Depth,
X = oldZItem.X,
Y = oldZItem.Y,
Z = newZ,
};
newZLayer.Items.Add(newZItem);
}
stabilizedLayers.Add(newZLayer);
currentZ += newZLayer.GetDepth();
}
return(stabilizedLayers);
}
public void CreateDiscardEntry(StoredBox sBox, int itemPK, double discardedQuantity, bool isRestored, DiscardingSession discardingSession)
{
try
{
Entry entry;
Accessory accessory;
if (isRestored)
{
RestoredItem restoredItem = db.RestoredItems.Find(itemPK);
accessory = db.Accessories.Find(restoredItem.AccessoryPK);
}
else
{
PassedItem passedItem = db.PassedItems.Find(itemPK);
ClassifiedItem classifiedItem = db.ClassifiedItems.Find(passedItem.ClassifiedItemPK);
PackedItem packedItem = db.PackedItems.Find(classifiedItem.PackedItemPK);
OrderedItem orderedItem = db.OrderedItems.Find(packedItem.OrderedItemPK);
accessory = db.Accessories.Find(orderedItem.AccessoryPK);
}
entry = new Entry(sBox, "Discarding", discardingSession.DiscardingSessionPK, isRestored, discardedQuantity, itemPK, accessory);
db.Entries.Add(entry);
db.SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
public bool IsUpdatedPackedItem(PackedItem packedItem)
{
PackedItem dbPackedItem = GetPackedItem(packedItem.PackedItemPK);
if (packedItem.PackedQuantity == 0)
{
db.PackedItems.Remove(dbPackedItem);
}
else
{
dbPackedItem.PackedQuantity = packedItem.PackedQuantity;
dbPackedItem.Comment = packedItem.Comment;
db.Entry(dbPackedItem).State = EntityState.Modified;
}
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException e)
{
throw e;
}
return(true);
}
public void TestInsertAndCount()
{
var box = Factory.CreateBox("Box", 10, 10, 10, 0, 10, 10, 10, 100);
var itemA = Factory.CreateItem("Item A", 5, 10, 10, 10, true);
var itemB = Factory.CreateItem("Item B", 5, 10, 10, 20, true);
var packedItemA = new PackedItem(itemA, 0, 0, 0, 5, 10, 10);
var packedItemB = new PackedItem(itemB, 0, 0, 0, 5, 10, 10);
var packedItemListA = new PackedItemList();
packedItemListA.Insert(packedItemA);
var packedBoxA = new PackedBox(box, packedItemListA);
var packedItemListB = new PackedItemList();
packedItemListB.Insert(packedItemB);
var packedBoxB = new PackedBox(box, packedItemListB);
var packedBoxList = new PackedBoxList();
packedBoxList.Insert(packedBoxA);
packedBoxList.Insert(packedBoxB);
Assert.Equal(2, packedBoxList.Count);
}
public void updateAllIdentifiedItemsToVirtualBox(int failedItemPK)
{
try
{
FailedItem failedItem = db.FailedItems.Find(failedItemPK);
ClassifiedItem classifiedItem = db.ClassifiedItems.Find(failedItem.ClassifiedItemPK);
PackedItem packedItem = db.PackedItems.Find(classifiedItem.PackedItemPK);
List <IdentifiedItem> identifiedItems = (from iI in db.IdentifiedItems
where iI.PackedItemPK == packedItem.PackedItemPK
select iI).ToList();
UnstoredBox virtualBox = (from uB in db.UnstoredBoxes
where uB.BoxPK == (from b in db.Boxes
where b.BoxID == "InvisibleBox"
select b).FirstOrDefault().BoxPK
select uB).FirstOrDefault();
foreach (var item in identifiedItems)
{
item.UnstoredBoxPK = virtualBox.UnstoredBoxPK;
db.Entry(item).State = EntityState.Modified;
}
db.SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
public Client_PackedItem(Accessory accessory, PackedItem packedItem)
{
this.PackedItemPK = packedItem.PackedItemPK;
this.PackedQuantity = packedItem.PackedQuantity;
this.AccessoryID = accessory.AccessoryID;
this.AccessoryDescription = accessory.AccessoryDescription;
this.Comment = packedItem.Comment;
}
public static string[] ExpandPackedItem(PackedItem item)
{
string[] result = new string[item.Count];
for (int i = 0; i < item.Count; i++)
{
result[i] = item.Value;
}
return result;
}
public void DeletePackedItem(int PackedItemPK)
{
PackedItem packedItem = db.PackedItems.Find(PackedItemPK);
if (packedItem == null)
{
throw new Exception("ITEM PACK KHÔNG TỒN TẠI");
}
db.PackedItems.Remove(packedItem);
db.SaveChanges();
}
public Client_PackedItemClassified(Accessory accessory, Pack pack, PackedItem packedItem, bool isEditable, ClassifiedItem classifiedItem)
{
PackedItemPK = packedItem.PackedItemPK;
AccessoryID = accessory.AccessoryID;
AccessoryDescription = accessory.AccessoryDescription;
Art = accessory.Art;
Color = accessory.Color;
Item = accessory.Item;
PackID = pack.PackID;
IsOpened = pack.IsOpened;
QualityState = classifiedItem.QualityState;
IsEditable = isEditable;
}
public bool IsPackedItemClassified(IdentifiedItem identifiedItem)
{
try
{
PackedItem packedItem = (from pI in db.PackedItems
where pI.PackedItemPK == identifiedItem.PackedItemPK
select pI).FirstOrDefault();
return(packedItem.IsClassified);
}
catch (Exception e)
{
throw e;
}
}
public void TestVolumeCalculation()
{
var pItem = new PackedItem(
Factory.CreateItem("Item", 1, 1, 0, 0, true),
0,
0,
0,
3,
5,
7
);
Assert.Equal(105, pItem.Volume);
}
public void CreateEntriesUpdatePassedItem(Box box, StoredBox storedBox, StoringSession storingSession)
{
try
{
IdentifyItemDAO identifyItemDAO = new IdentifyItemDAO();
BoxDAO boxDAO = new BoxDAO();
UnstoredBox unstoredBox = boxDAO.GetUnstoredBoxbyBoxPK(box.BoxPK);
List <IdentifiedItem> identifiedItems = (from iI in db.IdentifiedItems
where iI.UnstoredBoxPK == unstoredBox.UnstoredBoxPK
select iI).ToList();
foreach (var identifiedItem in identifiedItems)
{
PackedItem packedItem = db.PackedItems.Find(identifiedItem.PackedItemPK);
// lấy accessory
OrderedItem orderedItem = db.OrderedItems.Find(packedItem.OrderedItemPK);
Accessory accessory = db.Accessories.Find(orderedItem.AccessoryPK);
//
ClassifiedItem classifiedItem = (from cI in db.ClassifiedItems
where cI.PackedItemPK == packedItem.PackedItemPK
select cI).FirstOrDefault();
if (classifiedItem != null)
{
PassedItem passedItem = (from pI in db.PassedItems
where pI.ClassifiedItemPK == classifiedItem.ClassifiedItemPK
select pI).FirstOrDefault();
if (passedItem != null)
{
UpdatePassedItem(passedItem.PassedItemPK);
// tạo entry
Entry entry = new Entry(storedBox, "Storing", storingSession.StoringSessionPK, false,
identifyItemDAO.ActualQuantity(identifiedItem.IdentifiedItemPK), passedItem.PassedItemPK, accessory);
db.Entries.Add(entry);
}
else
{
throw new Exception("ITEM KHÔNG HỢP LỆ");
}
}
else
{
throw new Exception("ITEM KHÔNG HỢP LỆ");
}
}
db.SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
public Client_PackedItemAngular(Accessory accessory, PackedItem packedItem, double actualQuantity, double sumIdentifiedQuantity)
{
PackedItemPK = packedItem.PackedItemPK;
PackedQuantity = packedItem.PackedQuantity;
SumIdentifiedQuantity = sumIdentifiedQuantity;
ActualQuantity = actualQuantity;
ContractNumber = packedItem.ContractNumber;
AccessoryPK = accessory.AccessoryPK;
AccessoryID = accessory.AccessoryID;
AccessoryDescription = accessory.AccessoryDescription;
Art = accessory.Art;
Color = accessory.Color;
Item = accessory.Item;
Comment = packedItem.Comment;
}
private static List<PackedItem> Pick(List<PackedItem> list, int count)
{
int addedCount = 0;
var added = new List<PackedItem>();
for (int i = 0; i < list.Count; i++)
{
PackedItem item = list[i];
if (item.Count + addedCount > count)
continue;
added.Add(item);
addedCount += item.Count;
if (addedCount == count)
break;
}
return added;
}
public bool ChangeContract(int packedItemPK, string contractNumber)
{
PackedItem packedItem = db.PackedItems.Find(packedItemPK);
packedItem.ContractNumber = contractNumber;
try
{
db.Entry(packedItem).State = EntityState.Modified;
db.SaveChanges();
}
catch (DbUpdateConcurrencyException e)
{
throw e;
}
return(true);
}
public Client_PackedItemClassified2(Accessory accessory, Pack pack, PackedItem packedItem, double sample, double defectLimit, double sumIdentifiedQuantity, double sumCountedQuantity, double sumCheckedQuantity, double sumUnqualifiedQuantity)
{
PackedItemPK = packedItem.PackedItemPK;
AccessoryID = accessory.AccessoryID;
AccessoryDescription = accessory.AccessoryDescription;
Art = accessory.Art;
Color = accessory.Color;
Item = accessory.Item;
PackID = pack.PackID;
PackedQuantity = packedItem.PackedQuantity;
Sample = sample;
DefectLimit = defectLimit;
SumIdentifiedQuantity = sumIdentifiedQuantity;
SumCountedQuantity = sumCountedQuantity;
SumCheckedQuantity = sumCheckedQuantity;
SumUnqualifiedQuantity = sumUnqualifiedQuantity;
}
public void TestVolumeUtilisation()
{
var box = Factory.CreateBox("Box", 10, 10, 10, 0, 10, 10, 10, 10);
var item = Factory.CreateItem("Item", 5, 10, 10, 10, true);
var packedItem = new PackedItem(item, 0, 0, 0, 5, 10, 10);
var packedItemList = new PackedItemList();
packedItemList.Insert(packedItem);
var packedBox = new PackedBox(box, packedItemList);
var packedBoxList = new PackedBoxList();
packedBoxList.Insert(packedBox);
Assert.Equal(50f, packedBoxList.GetVolumeUtilisation());
}
private void TryAndStackItemsIntoSpace(PackedLayer layer,
PackedItem prevItem,
ItemList nextItems,
int maxWidth,
int maxLength,
int maxDepth,
int x,
int y,
int z,
int rowLength
)
{
while (items.Count() > 0 && CheckNonDimensionalConstraints(items.Top()))
{
var stackedItem = GetOrientationForItem(
items.Top(),
prevItem,
nextItems,
items.Count == 1,
maxWidth,
maxLength,
maxDepth,
rowLength,
x,
y,
z
);
if (stackedItem != null)
{
remainingWeight -= items.Top().Weight;
layer.Insert(PackedItem.FromOrientatedItem(stackedItem, x, y, z));
items.Extract();
maxDepth -= stackedItem.Depth;
z += stackedItem.Depth;
}
else
{
break;
}
}
}
public void CreateIssueEntry(Client_InputPrepareRequestAPI input, IssuingSession issuingSession)
{
try
{
Entry entry;
Accessory accessory;
foreach (var item_position_quantity in input.Item_position_quantities)
{
// lấy hàng cần xuất
if (item_position_quantity.IsRestored)
{
RestoredItem restoredItem = db.RestoredItems.Find(item_position_quantity.ItemPK);
accessory = db.Accessories.Find(restoredItem.AccessoryPK);
}
else
{
PassedItem passedItem = db.PassedItems.Find(item_position_quantity.ItemPK);
ClassifiedItem classifiedItem = db.ClassifiedItems.Find(passedItem.ClassifiedItemPK);
PackedItem packedItem = db.PackedItems.Find(classifiedItem.PackedItemPK);
OrderedItem orderedItem = db.OrderedItems.Find(packedItem.OrderedItemPK);
accessory = db.Accessories.Find(orderedItem.AccessoryPK);
}
// tạo entry xuất trong n - thùng chưa hàng
foreach (var item in item_position_quantity.BoxAndQuantity)
{
StoredBox sBox = db.StoredBoxes.Find(item.StoredBoxPK);
if (sBox == null)
{
throw new Exception("Data StoreBoxes Lỗi!");
}
entry = new Entry(sBox, "Issuing", issuingSession.IssuingSessionPK, item_position_quantity.IsRestored,
item.Quantity, item_position_quantity.ItemPK, accessory);
db.Entries.Add(entry);
}
}
db.SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
public void TestVolumeUtilisation()
{
var box = Factory.CreateBox("Box", 10, 10, 20, 10, 10, 10, 20, 10);
var oItem = new OrientatedItem(
Factory.CreateItem("Item", 4, 10, 10, 10, true),
4,
10,
10
);
var packedItemList = new PackedItemList();
packedItemList.Insert(PackedItem.FromOrientatedItem(oItem, 0, 0, 0));
var pBox = new PackedBox(box, packedItemList);
Assert.Equal(400, pBox.UsedVolume);
Assert.Equal(1600, pBox.UnusedVolume);
Assert.Equal(20, pBox.VolumeUtilizationPercent);
}
private OrientatedItem GetOrientationForItem(Item itemToPack,
PackedItem prevItem,
ItemList nextItems,
bool isLastItem,
int maxWidth,
int maxLength,
int maxDepth,
int rowLength,
int x,
int y,
int z
)
{
var prevOrientatedItem = prevItem?.ToOrientatedItem();
// TODO: ConstrainedPlacementItem check implementation
// don't calculate it if not going to be used
var prevPackedItemList = new PackedItemList();
var oifDecision = orientatedItemFactory.GetBestOrientation(
itemToPack,
prevOrientatedItem,
nextItems,
isLastItem,
maxWidth,
maxLength,
maxDepth,
rowLength,
x,
y,
z,
prevPackedItemList
);
return(oifDecision);
}
public void CreateInAndOutEntry(List <Client_ItemPK_TransferQuantity_IsRestored> list, StoredBox sBoxFrom, StoredBox sBoxTo, TransferringSession transferringSession)
{
try
{
foreach (var item in list)
{
Accessory accessory;
if (item.IsRestored)
{
RestoredItem restoredItem = db.RestoredItems.Find(item.ItemPK);
accessory = db.Accessories.Find(restoredItem.AccessoryPK);
}
else
{
PassedItem passedItem = db.PassedItems.Find(item.ItemPK);
ClassifiedItem classifiedItem = db.ClassifiedItems.Find(passedItem.ClassifiedItemPK);
PackedItem packedItem = db.PackedItems.Find(classifiedItem.PackedItemPK);
OrderedItem orderedItem = db.OrderedItems.Find(packedItem.OrderedItemPK);
accessory = db.Accessories.Find(orderedItem.AccessoryPK);
}
// Tạo out entry
Entry entry = new Entry(sBoxFrom, "Out", transferringSession.TransferingSessionPK,
item.IsRestored, item.TransferQuantity, item.ItemPK, accessory);
db.Entries.Add(entry);
// Tạo in entry
entry = new Entry(sBoxTo, "In", transferringSession.TransferingSessionPK,
item.IsRestored, item.TransferQuantity, item.ItemPK, accessory);
db.Entries.Add(entry);
}
db.SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
public List <Client_Session_Activity_Angular> GetSessions(int sessionNum)
{
List <Client_Session_Activity_Angular> result = new List <Client_Session_Activity_Angular>();
switch (sessionNum)
{
case 1:
List <IdentifyingSession> identifyingSessions = (from ss in db.IdentifyingSessions
select ss).ToList();
foreach (var ss in identifyingSessions)
{
SystemUser systemUser = db.SystemUsers.Find(ss.UserID);
// query pack
IdentifiedItem identifiedItem = (from iI in db.IdentifiedItems
where iI.IdentifyingSessionPK == ss.IdentifyingSessionPK
select iI).FirstOrDefault();
PackedItem packedItem = db.PackedItems.Find(identifiedItem.PackedItemPK);
Pack pack = db.Packs.Find(packedItem.PackPK);
string content = "Ghi nhận " + "cụm phụ liệu thuộc Phiếu nhập mã số " + pack.PackID;
result.Add(new Client_Session_Activity_Angular(ss.ExecutedDate, systemUser.Name + " (" + ss.UserID + ")", content));
}
break;
case 2:
List <CountingSession> countingSessions = (from ss in db.CountingSessions
select ss).ToList();
foreach (var ss in countingSessions)
{
SystemUser systemUser = db.SystemUsers.Find(ss.UserID);
// query pack
IdentifiedItem identifiedItem = db.IdentifiedItems.Find(ss.IdentifiedItemPK);
PackedItem packedItem = db.PackedItems.Find(identifiedItem.PackedItemPK);
Pack pack = db.Packs.Find(packedItem.PackPK);
string content = "Kiểm số lượng " + "cụm phụ liệu thuộc Phiếu nhập mã số " + pack.PackID;
result.Add(new Client_Session_Activity_Angular(ss.ExecutedDate, systemUser.Name + " (" + ss.UserID + ")", content));
}
break;
case 3:
List <CheckingSession> checkingSessions = (from ss in db.CheckingSessions
select ss).ToList();
foreach (var ss in checkingSessions)
{
SystemUser systemUser = db.SystemUsers.Find(ss.UserID);
IdentifiedItem identifiedItem = db.IdentifiedItems.Find(ss.IdentifiedItemPK);
PackedItem packedItem = db.PackedItems.Find(identifiedItem.PackedItemPK);
Pack pack = db.Packs.Find(packedItem.PackPK);
string content = "Kiểm chất lượng " + "cụm phụ liệu thuộc Phiếu nhập mã số " + pack.PackID;
result.Add(new Client_Session_Activity_Angular(ss.ExecutedDate, systemUser.Name + " (" + ss.UserID + ")", content));
}
break;
case 4:
List <ClassifyingSession> classifyingSessions = (from ss in db.ClassifyingSessions
select ss).ToList();
foreach (var ss in classifyingSessions)
{
SystemUser systemUser = db.SystemUsers.Find(ss.UserID);
ClassifiedItem classifiedItem = db.ClassifiedItems.Find(ss.ClassifiedItemPK);
PackedItem packedItem = db.PackedItems.Find(classifiedItem.PackedItemPK);
Pack pack = db.Packs.Find(packedItem.PackPK);
string content = "Đánh giá " + "phụ liệu thuộc Phiếu nhập mã số " + pack.PackID;
result.Add(new Client_Session_Activity_Angular(ss.ExecutedDate, systemUser.Name + " (" + ss.UserID + ")", content));
}
break;
case 5:
List <ArrangingSession> arrangingSessions = (from ss in db.ArrangingSessions
select ss).ToList();
foreach (var ss in arrangingSessions)
{
SystemUser systemUser = db.SystemUsers.Find(ss.UserID);
UnstoredBox uBox1 = db.UnstoredBoxes.Find(ss.StartBoxPK);
Box box1 = db.Boxes.Find(uBox1.BoxPK);
UnstoredBox uBox2 = db.UnstoredBoxes.Find(ss.DestinationBoxPK);
Box box2 = db.Boxes.Find(uBox2.BoxPK);
string content = "Sắp xếp " + "cụm phụ liệu từ thùng mã số " + box1.BoxID.Substring(0, box1.BoxID.Length - 3) + "sang thùng mã số " + box2.BoxID.Substring(0, box2.BoxID.Length - 3);
result.Add(new Client_Session_Activity_Angular(ss.ExecutedDate, systemUser.Name + " (" + ss.UserID + ")", content));
}
break;
case 6:
List <ReturningSession> returningSessions = (from ss in db.ReturningSessions
select ss).ToList();
foreach (var ss in returningSessions)
{
SystemUser systemUser = db.SystemUsers.Find(ss.UserID);
FailedItem failedItem = db.FailedItems.Find(ss.FailedItemPK);
ClassifiedItem classifiedItem = db.ClassifiedItems.Find(failedItem.ClassifiedItemPK);
PackedItem packedItem = db.PackedItems.Find(classifiedItem.PackedItemPK);
Pack pack = db.Packs.Find(packedItem.PackPK);
string content = "Trả hàng lỗi " + "thuộc Phiếu nhập mã số " + pack.PackID;
result.Add(new Client_Session_Activity_Angular(ss.ExecutedDate, systemUser.Name + " (" + ss.UserID + ")", content));
}
break;
case 7:
List <StoringSession> storingSessions = (from ss in db.StoringSessions
select ss).ToList();
foreach (var ss in storingSessions)
{
SystemUser systemUser = db.SystemUsers.Find(ss.UserID);
Box box = db.Boxes.Find(ss.BoxPK);
string content = "Lưu kho " + "thùng mã số " + box.BoxID.Substring(0, box.BoxID.Length - 3);
result.Add(new Client_Session_Activity_Angular(ss.ExecutedDate, systemUser.Name + " (" + ss.UserID + ")", content));
}
break;
case 8:
List <MovingSession> movingSessions = (from ss in db.MovingSessions
select ss).ToList();
foreach (var ss in movingSessions)
{
SystemUser systemUser = db.SystemUsers.Find(ss.UserID);
StoredBox sBox = db.StoredBoxes.Find(ss.StoredBoxPK);
Box box = db.Boxes.Find(sBox.BoxPK);
Shelf shelf1 = db.Shelves.Find(ss.StartShelfPK);
Shelf shelf2 = db.Shelves.Find(ss.DestinationShelfPK);
string content = "Di chuyển thùng " + "mã số " + box.BoxID.Substring(0, box.BoxID.Length - 3)
+ "từ kệ " + shelf1.ShelfID + "sang kệ " + shelf2.ShelfID;
result.Add(new Client_Session_Activity_Angular(ss.ExecutedDate, systemUser.Name + " (" + ss.UserID + ")", content));
}
break;
case 9:
List <TransferringSession> tranferringSessions = (from ss in db.TransferringSessions
select ss).ToList();
foreach (var ss in tranferringSessions)
{
SystemUser systemUser = db.SystemUsers.Find(ss.UserID);
StoredBox sBox1 = db.StoredBoxes.Find(ss.StartBoxPK);
Box box1 = db.Boxes.Find(sBox1.BoxPK);
StoredBox sBox2 = db.StoredBoxes.Find(ss.StartBoxPK);
Box box2 = db.Boxes.Find(sBox2.BoxPK);
string content = "Chuyển phụ liệu " + "tồn kho từ thùng mã số " + box1.BoxID.Substring(0, box1.BoxID.Length - 3)
+ "sang thùng mã số " + box2.BoxID.Substring(0, box2.BoxID.Length - 3);
result.Add(new Client_Session_Activity_Angular(ss.ExecutedDate, systemUser.Name + " (" + ss.UserID + ")", content));
}
break;
case 10:
List <IssuingSession> issuingSessions = (from ss in db.IssuingSessions
select ss).ToList();
foreach (var ss in issuingSessions)
{
SystemUser systemUser = db.SystemUsers.Find(ss.UserID);
Request request = db.Requests.Find(ss.RequestPK);
string content = "Xuất kho " + "phụ liệu cho Yêu cầu nhận mã số " + request.RequestID;
result.Add(new Client_Session_Activity_Angular(ss.ExecutedDate, systemUser.Name + " (" + ss.UserID + ")", content));
}
break;
case 11:
List <ReceivingSession> restoringSessions = (from ss in db.ReceivingSessions
select ss).ToList();
foreach (var ss in restoringSessions)
{
SystemUser systemUser = db.SystemUsers.Find(ss.UserID);
Restoration restoration = db.Restorations.Find(ss.RestorationPK);
string content = "Nhận tồn " + "phụ liệu thuộc Phiếu trả mã số " + restoration.RestorationID;
result.Add(new Client_Session_Activity_Angular(ss.ExecutedDate, systemUser.Name + " (" + ss.UserID + ")", content));
}
break;
default:
break;
}
return(result);
}
public List <Client_Box_Shelf_Row> StoredBox_ItemPK_IsRestoredOfEntries(Accessory accessory)
{
List <Client_Box_Shelf_Row> result = new List <Client_Box_Shelf_Row>();
StoringDAO storingDAO = new StoringDAO();
try
{
// cực phẩm IQ
double inStoredQuantity = InStoredQuantity(accessory.AccessoryPK);
if (inStoredQuantity == 0)
{
throw new Exception("HÀNG TRONG KHO ĐÃ HẾT!");
}
List <Entry> entries = (from e in db.Entries
where e.AccessoryPK == accessory.AccessoryPK
select e).ToList();
Dictionary <StoredBox_ItemPK_IsRestored, InBoxQuantity_AvailableQuantity> tempDictionary = new Dictionary <StoredBox_ItemPK_IsRestored, InBoxQuantity_AvailableQuantity>();
foreach (var entry in entries)
{
double inBoxQuantity = 0;
StoredBox storedBox = db.StoredBoxes.Find(entry.StoredBoxPK);
if (entry.KindRoleName == "AdjustingMinus" || entry.KindRoleName == "AdjustingPlus")
{
AdjustingSession adjustingSession = db.AdjustingSessions.Find(entry.SessionPK);
Verification verification = db.Verifications.Where(unit => unit.SessionPK == adjustingSession.AdjustingSessionPK &&
unit.IsDiscard == false).FirstOrDefault();
if (verification != null && verification.IsApproved)
{
inBoxQuantity = storingDAO.EntryQuantity(entry);
}
}
else if (entry.KindRoleName == "Discarding")
{
DiscardingSession discardingSession = db.DiscardingSessions.Find(entry.SessionPK);
Verification verification = db.Verifications.Where(unit => unit.SessionPK == discardingSession.DiscardingSessionPK &&
unit.IsDiscard == true).FirstOrDefault();
if (verification != null && verification.IsApproved)
{
inBoxQuantity = storingDAO.EntryQuantity(entry);
}
}
else
{
inBoxQuantity = storingDAO.EntryQuantity(entry);
}
Box box = db.Boxes.Find(storedBox.BoxPK);
PassedItem passedItem;
RestoredItem restoredItem;
StoredBox_ItemPK_IsRestored key;
if (entry.IsRestored)
{
restoredItem = db.RestoredItems.Find(entry.ItemPK);
key = new StoredBox_ItemPK_IsRestored(storedBox.StoredBoxPK, restoredItem.RestoredItemPK, entry.IsRestored);
}
else
{
passedItem = db.PassedItems.Find(entry.ItemPK);
key = new StoredBox_ItemPK_IsRestored(storedBox.StoredBoxPK, passedItem.PassedItemPK, entry.IsRestored);
}
if (box.IsActive)
{
InBoxQuantity_AvailableQuantity tmp = new InBoxQuantity_AvailableQuantity(inBoxQuantity, storingDAO.EntryQuantity(entry));
if (!tempDictionary.ContainsKey(key))
{
tempDictionary.Add(key, tmp);
}
else
{
tempDictionary[key].InBoxQuantity += tmp.InBoxQuantity;
tempDictionary[key].AvailableQuantity += tmp.AvailableQuantity;
}
}
}
foreach (var item in tempDictionary)
{
if (item.Value.AvailableQuantity > 0)
{
StoredBox storedBox = db.StoredBoxes.Find(item.Key.StoredBoxPK);
Box box = db.Boxes.Find(storedBox.BoxPK);
Shelf shelf = db.Shelves.Find(storedBox.ShelfPK);
Row row = db.Rows.Find(shelf.RowPK);
if (item.Key.IsRestored)
{
RestoredItem restoredItem = db.RestoredItems.Find(item.Key.ItemPK);
Restoration restoration = db.Restorations.Find(restoredItem.RestorationPK);
result.Add(new Client_Box_Shelf_Row(box.BoxID, storedBox.StoredBoxPK, shelf.ShelfID, row.RowID, item.Key.ItemPK, item.Key.IsRestored, item.Value.InBoxQuantity, restoration.RestorationID, item.Value.AvailableQuantity));
}
else
{
PassedItem passedItem = db.PassedItems.Find(item.Key.ItemPK);
ClassifiedItem classifiedItem = db.ClassifiedItems.Find(passedItem.ClassifiedItemPK);
PackedItem packedItem = db.PackedItems.Find(classifiedItem.PackedItemPK);
Pack pack = db.Packs.Find(packedItem.PackPK);
result.Add(new Client_Box_Shelf_Row(box.BoxID, storedBox.StoredBoxPK, shelf.ShelfID, row.RowID, item.Key.ItemPK, item.Key.IsRestored, item.Value.InBoxQuantity, pack.PackID, item.Value.AvailableQuantity));
}
}
}
}
catch (Exception e)
{
throw e;
}
return(result);
}
public Client_CheckingSessionDetail(Accessory accessory, Pack pack, CheckingSession checkingSession, Box box, PackedItem packedItem, double sample)
{
CheckingSessionPK = checkingSession.CheckingSessionPK;
ExecutedDate = checkingSession.ExecutedDate;
CheckedQuantity = checkingSession.CheckedQuantity;
UnqualifiedQuantity = checkingSession.UnqualifiedQuantity;
Comment = checkingSession.Comment;
AccessoryID = accessory.AccessoryID;
AccessoryDescription = accessory.AccessoryDescription;
Art = accessory.Art;
Color = accessory.Color;
Item = accessory.Item;
PackID = pack.PackID;
BoxID = box.BoxID;
IsClassified = packedItem.IsClassified;
Sample = sample;
}
public IHttpActionResult GetItemByRowID(string rowID)
{
BoxDAO boxDAO = new BoxDAO();
StoringDAO storingDAO = new StoringDAO();
try
{
Client_InBoxItems_Shelf <List <string> > result;
List <string> shelfIDs = new List <string>();
List <Shelf> shelves;
Row row = (from r in db.Rows
where r.RowID == rowID
select r).FirstOrDefault();
if (row != null || rowID == "TẠM THỜI")
{
if (rowID == "TẠM THỜI")
{
shelves = (from sh in db.Shelves
where sh.RowPK == null && sh.ShelfID != "InvisibleShelf"
select sh).ToList();
}
else
{
shelves = (from sh in db.Shelves
where sh.RowPK == row.RowPK && sh.ShelfID != "InvisibleShelf"
select sh).ToList();
}
Dictionary <KeyValuePair <int, bool>, Client_InBoxItem> client_InBoxItems = new Dictionary <KeyValuePair <int, bool>, Client_InBoxItem>();
foreach (var shelf in shelves)
{
List <StoredBox> sBoxes = (from sB in db.StoredBoxes
where sB.ShelfPK == shelf.ShelfPK
select sB).ToList();
shelfIDs.Add(shelf.ShelfID);
foreach (var sBox in sBoxes)
{
// Get list inBoxItem
List <Entry> entries = (from e in db.Entries
where e.StoredBoxPK == sBox.StoredBoxPK
select e).ToList();
// Hiện thực cặp value ko được trùng 2 key là itemPK và isRestored
HashSet <KeyValuePair <int, bool> > listItem = new HashSet <KeyValuePair <int, bool> >();
foreach (var entry in entries)
{
listItem.Add(new KeyValuePair <int, bool>(entry.ItemPK, entry.IsRestored));
}
foreach (var item in listItem)
{
List <Entry> tempEntries = new List <Entry>();
foreach (var entry in entries)
{
if (entry.ItemPK == item.Key && entry.IsRestored == item.Value)
{
tempEntries.Add(entry);
}
}
if (tempEntries.Count > 0 && storingDAO.EntriesQuantity(tempEntries) > 0)
{
Entry entry = tempEntries[0];
PassedItem passedItem;
RestoredItem restoredItem;
if (item.Value)
{
restoredItem = db.RestoredItems.Find(item.Key);
Restoration restoration = db.Restorations.Find(restoredItem.RestorationPK);
Accessory accessory = db.Accessories.Find(restoredItem.AccessoryPK);
if (!client_InBoxItems.ContainsKey(item))
{
client_InBoxItems.Add(item, new Client_InBoxItem(accessory, restoration.RestorationID,
storingDAO.EntriesQuantity(tempEntries), restoredItem.RestoredItemPK, item.Value));
}
else
{
client_InBoxItems[item].InBoxQuantity += storingDAO.EntriesQuantity(tempEntries);
}
}
else
{
passedItem = db.PassedItems.Find(item.Key);
ClassifiedItem classifiedItem = db.ClassifiedItems.Find(passedItem.ClassifiedItemPK);
PackedItem packedItem = db.PackedItems.Find(classifiedItem.PackedItemPK);
// lấy pack ID
Pack pack = db.Packs.Find(packedItem.PackPK);
// lấy phụ liệu tương ứng
OrderedItem orderedItem = db.OrderedItems.Find(packedItem.OrderedItemPK);
Accessory accessory = db.Accessories.Find(orderedItem.AccessoryPK);
if (!client_InBoxItems.ContainsKey(item))
{
client_InBoxItems.Add(item, new Client_InBoxItem(accessory, pack.PackID,
storingDAO.EntriesQuantity(tempEntries), passedItem.PassedItemPK, item.Value));
}
else
{
client_InBoxItems[item].InBoxQuantity += storingDAO.EntriesQuantity(tempEntries);
}
}
}
}
}
}
result = new Client_InBoxItems_Shelf <List <string> >(shelfIDs, client_InBoxItems.Values.ToList());
return(Content(HttpStatusCode.OK, result));
}
else
{
return(Content(HttpStatusCode.Conflict, "ĐỐI TƯỢNG KHÔNG TỒN TẠI"));
}
}
catch (Exception e)
{
return(Content(HttpStatusCode.Conflict, new Content_InnerException(e).InnerMessage()));
}
}
public IHttpActionResult GetItemByBoxID(string boxID)
{
BoxDAO boxDAO = new BoxDAO();
StoringDAO storingDAO = new StoringDAO();
try
{
Box box = boxDAO.GetBoxByBoxID(boxID);
if (box != null)
{
StoredBox sBox = boxDAO.GetStoredBoxbyBoxPK(box.BoxPK);
UnstoredBox uBox = boxDAO.GetUnstoredBoxbyBoxPK(box.BoxPK);
// Nếu box chưa identify
if (uBox.IsIdentified)
{
// nếu box chưa được store
if (!(boxDAO.IsStored(box.BoxPK)))
{
List <Client_IdentifiedItemRead> client_IdentifiedItems = new List <Client_IdentifiedItemRead>();
List <IdentifiedItem> identifiedItems;
identifiedItems = (from iI in db.IdentifiedItems.OrderByDescending(unit => unit.PackedItemPK)
where iI.UnstoredBoxPK == uBox.UnstoredBoxPK
select iI).ToList();
foreach (var identifiedItem in identifiedItems)
{
PackedItem packedItem = db.PackedItems.Find(identifiedItem.PackedItemPK);
// lấy pack ID
Pack pack = db.Packs.Find(packedItem.PackPK);
// lấy phụ liệu tương ứng
OrderedItem orderedItem = db.OrderedItems.Find(packedItem.OrderedItemPK);
Accessory accessory = db.Accessories.Find(orderedItem.AccessoryPK);
// lấy qualityState
ClassifiedItem classifiedItem = (from cI in db.ClassifiedItems
where cI.PackedItemPK == packedItem.PackedItemPK
select cI).FirstOrDefault();
int?qualityState = null;
if (classifiedItem != null)
{
qualityState = classifiedItem.QualityState;
}
client_IdentifiedItems.Add(new Client_IdentifiedItemRead(identifiedItem, accessory, pack.PackID, qualityState));
}
return(Content(HttpStatusCode.OK, client_IdentifiedItems));
}
else
{
Client_InBoxItems_Shelf <Client_Shelf> result;
Client_Shelf client_Shelf;
List <Client_InBoxItem> client_InBoxItems = new List <Client_InBoxItem>();
Shelf shelf = db.Shelves.Find(sBox.ShelfPK);
Row row = db.Rows.Find(shelf.RowPK);
client_Shelf = new Client_Shelf(shelf.ShelfID, row.RowID);
// Get list inBoxItem
List <Entry> entries = (from e in db.Entries
where e.StoredBoxPK == sBox.StoredBoxPK
select e).ToList();
HashSet <KeyValuePair <int, bool> > listItemPK = new HashSet <KeyValuePair <int, bool> >();
foreach (var entry in entries)
{
listItemPK.Add(new KeyValuePair <int, bool>(entry.ItemPK, entry.IsRestored));
}
foreach (var itemPK in listItemPK)
{
List <Entry> tempEntries = new List <Entry>();
foreach (var entry in entries)
{
if (entry.ItemPK == itemPK.Key && entry.IsRestored == itemPK.Value)
{
tempEntries.Add(entry);
}
}
if (tempEntries.Count > 0 && storingDAO.EntriesQuantity(tempEntries) > 0)
{
Entry entry = tempEntries[0];
PassedItem passedItem;
RestoredItem restoredItem;
if (entry.IsRestored)
{
restoredItem = db.RestoredItems.Find(entry.ItemPK);
Restoration restoration = db.Restorations.Find(restoredItem.RestorationPK);
Accessory accessory = db.Accessories.Find(restoredItem.AccessoryPK);
client_InBoxItems.Add(new Client_InBoxItem(accessory, restoration.RestorationID, storingDAO.EntriesQuantity(tempEntries), restoredItem.RestoredItemPK, true));
}
else
{
passedItem = db.PassedItems.Find(entry.ItemPK);
ClassifiedItem classifiedItem = db.ClassifiedItems.Find(passedItem.ClassifiedItemPK);
PackedItem packedItem = db.PackedItems.Find(classifiedItem.PackedItemPK);
// lấy pack ID
Pack pack = (from p in db.Packs
where p.PackPK == packedItem.PackPK
select p).FirstOrDefault();
// lấy phụ liệu tương ứng
OrderedItem orderedItem = (from oI in db.OrderedItems
where oI.OrderedItemPK == packedItem.OrderedItemPK
select oI).FirstOrDefault();
Accessory accessory = (from a in db.Accessories
where a.AccessoryPK == orderedItem.AccessoryPK
select a).FirstOrDefault();
client_InBoxItems.Add(new Client_InBoxItem(accessory, pack.PackID, storingDAO.EntriesQuantity(tempEntries), passedItem.PassedItemPK, false));
}
}
}
result = new Client_InBoxItems_Shelf <Client_Shelf>(client_Shelf, client_InBoxItems);
return(Content(HttpStatusCode.OK, result));
}
}
else
{
return(Content(HttpStatusCode.Conflict, "THÙNG NÀY CHƯA ĐƯỢC GHI NHẬN"));
}
}
else
{
return(Content(HttpStatusCode.Conflict, "ĐỐI TƯỢNG KHÔNG TỒN TẠI"));
}
}
catch (Exception e)
{
return(Content(HttpStatusCode.Conflict, new Content_InnerException(e).InnerMessage()));
}
}
