private async void OptionChange(string obj)
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
ObservableCollection <ItemCriteria> its = new ObservableCollection <ItemCriteria>();
switch (obj)
{
case "code":
DisplayMem = "code";
IsCode = true;
IsBarcode = false;
IsName = false;
its = await ItemRestService.GetItemAttribsByBranchIdAsync(mapper);
ItmSugges = new ItemSuggestionProvider()
{
itemCriterias = its, DisplayMember = DisplayMem
};
break;
case "barcode":
DisplayMem = "barcode";
IsBarcode = true;
IsCode = false;
IsName = false;
its = await ItemRestService.GetItemAttribsByBranchIdAsync(mapper);
ItmSugges = new ItemSuggestionProvider()
{
itemCriterias = its, DisplayMember = DisplayMem
};
break;
case "name":
DisplayMem = "name";
IsName = true;
IsBarcode = false;
IsCode = false;
its = await ItemRestService.GetItemAttribsByBranchIdAsync(mapper);
ItmSugges = new ItemSuggestionProvider()
{
itemCriterias = its, DisplayMember = DisplayMem
};
break;
default:
DisplayMem = "code";
IsCode = true;
IsBarcode = false;
IsName = false;
its = await ItemRestService.GetItemAttribsByBranchIdAsync(mapper);
ItmSugges = new ItemSuggestionProvider()
{
itemCriterias = its, DisplayMember = DisplayMem
};
break;
}
}
private async void UpdateUom()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
if (SelectedUom != null)
{
if (SelectedUom.id > 0)
{
SelectedUom.saleOtherUnitName = $"{SelectedUom.baseUnitName}, {SelectedUom.purchaseUnitName}";
UnitOfMeasurement i = await ItemRestService.UpdateUnitOfMeasurementAsync(mapper, SelectedUom);
if (i.id > 0)
{
_ = ShowMessageDialg("UnitOfMeasure Update", "UnitOfMeasure Updated Successfully", MsgDialogType.infor);
}
else
{
_ = ShowMessageDialg("UnitOfMeasure Update", "Can't Save UnitOfMeasure", MsgDialogType.error);
return;
}
}
else
{
_ = ShowMessageDialg("UnitOfMeasure Update", "Please Select UnitOfMeasure Before Update", MsgDialogType.warrning);
return;
}
}
else
{
_ = ShowMessageDialg("UnitOfMeasure Update", "Please Select UnitOfMeasure Before Update", MsgDialogType.warrning);
return;
}
}
private async void SaveMeasurement()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
if (SelectedMeasure.IsValidUnit())
{
Unit b = await ItemRestService.CreateUnitAsync(mapper, SelectedMeasure);
if (b.id > 0)
{
_ = ShowMessageDialg("New Unit Creation", "Measurement Created Successfully", MsgDialogType.infor);
RizeSyncEvent();
Initialize();
}
else
{
_ = ShowMessageDialg("New Unit Creation", "Can't Save Measurement", MsgDialogType.error);
return;
}
}
else
{
_ = ShowMessageDialg("New Unit Creation", "Invalid Unit Details or Already Exist Unit", MsgDialogType.warrning);
return;
}
}
private async void LoadUnitNames()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
ObservableCollection <Unit> ms = await ItemRestService.GetAllUnitAsync(mapper);
if (SelectedUom == null)
{
UnitNames = new ObservableCollection <string>();
foreach (var item in ms)
{
UnitNames.Add(item.unitName);
}
}
else if (string.IsNullOrEmpty(SelectedUom.unitType))
{
UnitNames = new ObservableCollection <string>();
foreach (var item in ms)
{
UnitNames.Add(item.unitName);
}
}
else
{
UnitNames = new ObservableCollection <string>();
List <Unit> msc = ms.Where(r => r.unitType.Equals(SelectedUom.unitType)).ToList();
foreach (var item in msc)
{
UnitNames.Add(item.unitName);
}
}
}
private async void SaveUom()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
if (SelectedUom.IsValidUom())
{
SelectedUom.saleOtherUnitName = $"{SelectedUom.baseUnitName}, {SelectedUom.purchaseUnitName}";
UnitOfMeasurement b = await ItemRestService.CreateUnitOfMeasurementAsync(mapper, SelectedUom);
if (b.id > 0)
{
_ = ShowMessageDialg("New UnitOfMeasure Creation", "UnitOfMeasure Created Successfully", MsgDialogType.infor);
Initialize();
}
else
{
_ = ShowMessageDialg("New UnitOfMeasure Creation", "Can't Save UnitOfMeasure", MsgDialogType.error);
return;
}
}
else
{
_ = ShowMessageDialg("New UnitOfMeasure Creation", "Invalid UnitOfMeasure Details or Already Exist UnitOfMeasure", MsgDialogType.warrning);
return;
}
}
private async void UpdateMeasurement()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
if (SelectedMeasure != null)
{
if (SelectedMeasure.id > 0)
{
Unit i = await ItemRestService.UpdateUnitAsync(mapper, SelectedMeasure);
if (i.id > 0)
{
_ = ShowMessageDialg("Unit Update", "Unit Updated Successfully", MsgDialogType.infor);
RizeSyncEvent();
}
else
{
_ = ShowMessageDialg("Unit Update", "Can't Save Unit", MsgDialogType.error);
return;
}
}
else
{
_ = ShowMessageDialg("Unit Update", "Please Select Unit Before Update", MsgDialogType.warrning);
return;
}
}
else
{
_ = ShowMessageDialg("Unit Update", "Please Select Unit Before Update", MsgDialogType.warrning);
return;
}
}
private async void SaveCustomer()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
if (!string.IsNullOrEmpty(SelectedItemGroup.subGroupName))
{
ItemSubGroup g = await ItemRestService.CreateItemSubGroupAsync(mapper, SelectedItemGroup);
if (g.id > 0)
{
dialogService.ShowMsgDialog("New Item Group Creation", "Item Group Created Successfully", MsgDialogType.infor, (r) =>
{
LoadAllItemSubGroups();
NewCustomer();
});
}
else
{
dialogService.ShowMsgDialog("New Item Group Creation", "Can't Save Item Group", MsgDialogType.error, (r) =>
{
return;
});
}
}
else
{
dialogService.ShowMsgDialog("New Item Group Creation", "Invalid Item Group Details or Already Exist Customer", MsgDialogType.warrning, (r) =>
{
return;
});
}
}
private async void LoadAllItem()
{
UnitTypes = new ObservableCollection <string>();
UnitTypes.AddRange(ConstValues.UNIT_TYPES);
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
Uoms = await ItemRestService.GetAllUnitOfMeasurementAsync(mapper);
LoadUnitNames();
}
private async void LoadAllItem()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
Branches = await BranchRestService.GetAllBranchAsync(mapper);
Banks = await BankRestService.GetAllBankAsync(mapper);
BrancheAcs = await BranchRestService.GetAllBranchAccountAsync(mapper, loggedUser.LoggedUser.branch.id);
Measures = await ItemRestService.GetAllUnitAsync(mapper);
}
private async void SavePurchaseItem()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
CurrentPurchaseItem.recordState = ConstValues.RCS_FINE;
CurrentPurchaseItem.purchaseType = GetPurchaseType();
decimal rq = (CurrentPurchaseItem.reorderLevel * SelectedUom.baseRatioToPurchase * SelectedUom.purchaseQuantifyValue);
PurchaseItem pi = PurchaseItems.Where(i => i.item.id == SelectedItem.id).FirstOrDefault();
if (pi != null)
{
SelectedStore.reorderLevel += rq;
CurrentPurchaseItem.reorderLevel = rq;
CurrentPurchaseItem = CurrentPurchaseItem.Merge(pi);
_ = await PurchaseRestService.UpdatePurchaseItemAsync(mapper, CurrentPurchaseItem);
_ = await ItemRestService.UpdateStoreInforAsync(mapper, SelectedStore);
PurchaseItem np = CurrentPurchaseItem.CloneObject();
PurchaseItems.Remove(pi);
PurchaseItems.Add(np);
SelectedStore = null;
SelectedUom = null;
SelectedItem = null;
SelectedItmCt = null;
CurrentPurchaseItem = null;
}
else
{
CurrentPurchaseItem.reorderLevel = rq;
SelectedStore.reorderLevel = rq;
CurrentPurchaseItem = await PurchaseRestService.CreatePurchaseItemAsync(mapper, CurrentPurchaseItem);
if (CurrentPurchaseItem.id > 0)
{
_ = await ItemRestService.UpdateStoreInforAsync(mapper, SelectedStore);
PurchaseItems.Add(CurrentPurchaseItem.CloneObject());
SelectedStore = null;
SelectedUom = null;
SelectedItem = null;
SelectedItmCt = null;
CurrentPurchaseItem = null;
}
else
{
_ = ShowMessageDialg("Saving Purchase Item", "Can't Savae Purchase Item, found Some problems.", MsgDialogType.error);
}
}
CurrenPurchase.CalaculatePurchase(PurchaseItems);
_ = await PurchaseRestService.UpdatePurchaseAsync(mapper, CurrenPurchase);
}
private async void UpdateCustomer()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
if (SelectedItem != null)
{
if (SelectedItem.id > 0)
{
if (SelectedItem.unitOfMeasurement.id != SelectedUom.id)
{
SelectedItem.unitOfMeasurement = SelectedUom;
}
Item i = await ItemRestService.UpdateItemAsync(mapper, SelectedItem);
if (i.id > 0)
{
StoreInfor s = await ItemRestService.UpdateStoreInforAsync(mapper, ItemStore);
if (s.id > 0)
{
_ = ShowMessageDialg("Item Update", "Item Updated Successfully", MsgDialogType.infor);
RizeSyncEvent();
Initialize();
}
else
{
_ = ShowMessageDialg("Item Update", "Can't Update Item Store", MsgDialogType.error);
return;
}
}
else
{
_ = ShowMessageDialg("Item Update", "Can't Save Item", MsgDialogType.error);
return;
}
}
else
{
_ = ShowMessageDialg("Item Update", "Please Select Item Before Update", MsgDialogType.warrning);
return;
}
}
else
{
_ = ShowMessageDialg("Item Update", "Please Select Item Before Update", MsgDialogType.warrning);
return;
}
}
private async void LoadAll()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
ItemGroups = await ItemRestService.GetAllItemGroupAsync(mapper);
ItemSubGroups = await ItemRestService.GetAllItemSubGroupAsync(mapper);
ObservableCollection <UnitOfMeasurement> ums = await ItemRestService.GetAllUnitOfMeasurementAsync(mapper);
UomSugges = new UomSuggestionProvider()
{
uomSource = ums
};
}
private async void FindStoreInfor()
{
if (SelectedItem.id <= 0)
{
return;
}
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
ItemStore = await ItemRestService.GetStoreInforByItemIdAndBranchAsync(mapper, SelectedItem.id, loggedUser.LoggedUser.branch.id);
aggregator.GetEvent <ItemGroupSelectionEvent>().Publish(SelectedItem.itemGroup);
aggregator.GetEvent <ItemSubGroupSelectionEvent>().Publish(SelectedItem.itemSubGroup);
//aggregator.GetEvent<UnitOfMeasureSelectionEvent>().Publish(SelectedItem.unitOfMeasurement);
SelectedUom = SelectedItem.unitOfMeasurement;
}
private async void SaveCustomer()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
if (SelectedItemGroup == null || SelectedItemSubGroup == null || SelectedUom == null)
{
_ = ShowMessageDialg("New Item Creation", "Can't Save Item Select Group and Sub Group", MsgDialogType.error);
return;
}
SelectedItem.barcode = SelectedItem.code;
SelectedItem.itemGroup = SelectedItemGroup;
SelectedItem.itemSubGroup = SelectedItemSubGroup;
SelectedItem.unitOfMeasurement = SelectedUom;
if (SelectedItem.IsValiedItem())
{
Item i = await ItemRestService.CreateItemAsync(mapper, SelectedItem);
if (i.id > 0)
{
ItemStore.branch = loggedUser.LoggedUser.branch;
ItemStore.item = i;
StoreInfor s = await ItemRestService.CreateStoreInforAsync(mapper, ItemStore);
if (s.id > 0)
{
_ = ShowMessageDialg("New Item Creation", "Item Created Successfully", MsgDialogType.infor);
RizeSyncEvent();
Initialize();
}
else
{
_ = ShowMessageDialg("New Item Creation", "Can't Save Item Store", MsgDialogType.error);
return;
}
}
else
{
_ = ShowMessageDialg("New Item Creation", "Can't Save Item", MsgDialogType.error);
return;
}
}
else
{
_ = ShowMessageDialg("New Item Creation", "Invalid Item Details or Already Exist Item", MsgDialogType.warrning);
return;
}
}
private async void SearchItem()
{
if (SelectedItmCt == null)
{
return;
}
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
SelectedItem = await ItemRestService.GetItemByParamAsync(mapper, ItemRestService.ITEM_CODE_FLAG, SelectedItmCt.code);
if (CurrentPurchaseItem == null)
{
CurrentPurchaseItem = CurrentPurchaseItem.CreateNew(CurrenPurchase, SelectedItem);
}
else
{
CurrentPurchaseItem.item = SelectedItem;
}
}
private async void UpdateCustomer()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
if (SelectedItemGroup != null)
{
if (SelectedItemGroup.id > 0)
{
ItemSubGroup g = await ItemRestService.UpdateItemSubGroupAsync(mapper, SelectedItemGroup);
if (g.id > 0)
{
dialogService.ShowMsgDialog("Item Group Update", "Item Group Update Successfully", MsgDialogType.infor, (r) =>
{
LoadAllItemSubGroups();
NewCustomer();
});
}
else
{
dialogService.ShowMsgDialog("Item Group Update", "Can't Update Item Group", MsgDialogType.error, (r) =>
{
return;
});
}
}
else
{
dialogService.ShowMsgDialog("Item Group Update", "Please Select Item Group Before Update", MsgDialogType.warrning, (r) =>
{
return;
});
}
}
else
{
dialogService.ShowMsgDialog("Item Group Update", "Please Select Item Group Before Update", MsgDialogType.warrning, (r) =>
{
return;
});
}
}
private async void CalculatePurchaseItem()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
SelectedStore = await ItemRestService.GetStoreInforByItemIdAndBranchAsync(mapper, SelectedItem.id, branch.id);
SelectedUom = SelectedItem.unitOfMeasurement;
decimal pq = (CurrentPurchaseItem.quantity * SelectedUom.baseRatioToPurchase * SelectedUom.purchaseQuantifyValue);
decimal fq = (CurrentPurchaseItem.freeQuantity * SelectedUom.baseRatioToPurchase * SelectedUom.purchaseQuantifyValue);
decimal pc = (CurrentPurchaseItem.cost / (SelectedUom.baseRatioToPurchase * SelectedUom.purchaseQuantifyValue));
CurrentPurchaseItem.cost = pc;
CurrentPurchaseItem.quantity = pq;
CurrentPurchaseItem.freeQuantity = fq;
CurrentPurchaseItem.realQuantity = pq + fq;
CurrentPurchaseItem.availableQuantity = pq + fq;
CurrentPurchaseItem.amount = (CurrentPurchaseItem.realQuantity * CurrentPurchaseItem.cost);
SelectedStore.cost = pc;
SelectedStore.retailPrice = CurrentPurchaseItem.retailPrice;
SelectedStore.wholesalePrice = CurrentPurchaseItem.wholesalePrice;
SelectedStore.availableQuantity += pq + fq;
}
private async void LoadAutoData()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
ObservableCollection <SupplierCriteria> sus = await SupplierRestService.GetSupplierAttribsByBranchIdAsync(mapper, loggedUser.LoggedUser.branch.id);
SupSugges = new SupplierSuggestionProvider()
{
supplierCriterias = sus
};
ObservableCollection <ItemCriteria> its = await ItemRestService.GetItemAttribsByBranchIdAsync(mapper);
ItmSugges = new ItemSuggestionProvider()
{
itemCriterias = its, DisplayMember = DisplayMem
};
ObservableCollection <BranchAccount> bacs = await BranchRestService.GetAllBranchAccountAsync(mapper, loggedUser.LoggedUser.id);
BacSugges = new BranchAccountSuggestionProvider()
{
brancgAcCriterias = bacs
};
}
private async void LoadAllItemSubGroups()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
SourceItemGroups = await ItemRestService.GetAllItemSubGroupAsync(mapper);
}
