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 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 SaveBranch()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
if (SelectedBank == null)
{
_ = ShowMessageDialg("New Branch Account Creation", "Can't Save Branch Account, Bank not selected", MsgDialogType.error);
}
if (SelectedBranchAcc.IsValidBranchAccount())
{
SelectedBranchAcc.bank = SelectedBank;
SelectedBranchAcc.branch = loggedUser.LoggedUser.branch;
BranchAccount b = await BranchRestService.CreateBranchAccountAsync(mapper, SelectedBranchAcc);
if (b.id > 0)
{
_ = ShowMessageDialg("New Branch Account Creation", "Branch Account Created Successfully", MsgDialogType.infor);
RizeSyncEvent();
Initialize();
}
else
{
_ = ShowMessageDialg("New Branch Account Creation", "Can't Save Branch Account", MsgDialogType.error);
return;
}
}
else
{
_ = ShowMessageDialg("New Branch Account Creation", "Invalid Branch Account Details or Already Exist Branch Account", 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 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 SaveBranch()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
if (SelectedBank.IsValidBank())
{
Bank b = await BankRestService.CreateBankAsync(mapper, SelectedBank);
if (b.id > 0)
{
_ = ShowMessageDialg("New Bank Creation", "Bank Created Successfully", MsgDialogType.infor);
RizeSyncEvent();
Initialize();
}
else
{
_ = ShowMessageDialg("New Bank Creation", "Can't Save Branch", MsgDialogType.error);
return;
}
}
else
{
_ = ShowMessageDialg("New Bank Creation", "Invalid Bank Details or Already Exist Branch", MsgDialogType.warrning);
return;
}
}
private async void SaveCustomer()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
if (!string.IsNullOrEmpty(SelectedCustomer.name) && SelectedCustomer.id == 0)
{
SelectedCustomer.branch = loggedUser.LoggedUser.branch;
CustomerCreditAccount ac = await CustomerCreditRestService
.CreateCustomerCreditAccountAsync(mapper, new CustomerCreditAccount()
{
id = 0, totalCredit = 0.00m
});
if (ac.id <= 0)
{
dialogService.ShowMsgDialog("New Customer Creation", "Can't Save Customer", MsgDialogType.error, (r) =>
{
return;
});
}
SelectedCustomer.customerCreditAccount = ac;
Customer c = await CustomerRestService.CreateCustomerAsync(mapper, SelectedCustomer);
if (c.id > 0)
{
c.code = $"C{c.id}";
c = await CustomerRestService.UpdateCustomerAsync(mapper, c);
if (c.id > 0 && !string.IsNullOrEmpty(c.code))
{
dialogService.ShowMsgDialog("New Customer Creation", "Customer Created Successfully", MsgDialogType.infor, (r) =>
{
LoadCustomersAsync();
NewCustomer();
});
}
else
{
dialogService.ShowMsgDialog("New Customer Creation", "Can't Update Customer", MsgDialogType.error, (r) =>
{
return;
});
}
}
else
{
dialogService.ShowMsgDialog("New Customer Creation", "Can't Save Customer", MsgDialogType.error, (r) =>
{
return;
});
}
}
else
{
dialogService.ShowMsgDialog("New Customer Creation", "Invalid Customer Details or Already Exist Customer", MsgDialogType.warrning, (r) =>
{
return;
});
}
}
private async void UpdateBranch()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
if (SelectedBranch != null)
{
if (SelectedBranch.id > 0)
{
Branch i = await BranchRestService.UpdateBranchAsync(mapper, SelectedBranch);
if (i.id > 0)
{
_ = ShowMessageDialg("Branch Update", "Branch Updated Successfully", MsgDialogType.infor);
RizeSyncEvent();
}
else
{
_ = ShowMessageDialg("Branch Update", "Can't Save Branch", MsgDialogType.error);
return;
}
}
else
{
_ = ShowMessageDialg("Branch Update", "Please Select Branch Before Update", MsgDialogType.warrning);
return;
}
}
else
{
_ = ShowMessageDialg("Branch Update", "Please Select Branch 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 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 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 SearchOldPurChase()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
Purchase p = await PurchaseRestService.GetAllPurchaseByInvoiceNoAndRecordStAsync(mapper, branch.id, CurrenPurchase.invoiceNo, ConstValues.RCS_NEW);
if (p != null)
{
string msg = "Found Exist Purchase Invoice, Do you want to Continue it?";
if (ShowMessageDialg("Find Exist Purchase", msg, MsgDialogButtonType.YesNo, MsgDialogType.Confirmation))
{
CurrenPurchase = p;
IsNew = false;
SelectedSupCt = CurrenPurchase.supplier.ToSupplierCriterita();
SelectedSupplier = CurrenPurchase.supplier;
PurchaseItems = await PurchaseRestService.GetAllPurchaseItemByParamAsync(mapper, branch.id, PurchaseRestService.PI_PID_FLAG, p.id);
aggregator.GetEvent <UIElementFocusEvent>().Publish("pdt");
}
else
{
CurrenPurchase.invoiceNo = string.Empty;
aggregator.GetEvent <UIElementFocusEvent>().Publish("inv");
}
}
else
{
aggregator.GetEvent <UIElementFocusEvent>().Publish("sup");
}
}
private async void LoadBranchNames()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
branches = await BranchRestService.GetAllBranchAsync(mapper);
BranchNames = branches.Select(b => b.name).ToList();
}
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 SearchSupplier()
{
if (SelectedSupCt == null)
{
return;
}
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
SelectedSupplier = await SupplierRestService.GetSupplierByIdAndBranchIdAsync(mapper, SelectedSupCt.id, branch.id);
}
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 UpdateCustomer()
{
IRestDataMapper mapper = containerExtension.Resolve <IRestDataMapper>();
if (SelectedCustomer != null)
{
if (SelectedCustomer.id > 0)
{
Customer c = await CustomerRestService.UpdateCustomerAsync(mapper, SelectedCustomer);
if (c != null)
{
if (c.id > 0)
{
dialogService.ShowMsgDialog("Customer Details Update", "Customer Update Successfully", MsgDialogType.infor, (r) =>
{
LoadCustomersAsync();
NewCustomer();
});
}
else
{
dialogService.ShowMsgDialog("Customer Details Update", "Can't Update Customer", MsgDialogType.error, (r) =>
{
return;
});
}
}
else
{
dialogService.ShowMsgDialog("Customer Details Update", "Can't Update Customer", MsgDialogType.error, (r) =>
{
return;
});
}
}
else
{
dialogService.ShowMsgDialog("Customer Details Update", "Please Select Customer Before Update", MsgDialogType.warrning, (r) =>
{
return;
});
}
}
else
{
dialogService.ShowMsgDialog("Customer Details Update", "Please Select Customer Before Update", MsgDialogType.warrning, (r) =>
{
return;
});
}
}
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);
}
public static async Task <ItemGroup> GetItemGroupByNameAsync(IRestDataMapper mapper, string groupName)
{
ItemGroup reds = new ItemGroup();
if (mapper == null)
{
return(reds);
}
string url = $"item/api/v1/itemgroups/{groupName}";
reds = await mapper.GetDataAsync <ItemGroup>(url);
return(reds);
}
public static async Task <int> DeleteCashBookAsync(IRestDataMapper mapper, long cbId)
{
int reds = 0;
if (mapper == null)
{
return(reds);
}
string url = $"cashbook/api/v1/cashbooks/{cbId}";
reds = await mapper.DeleteDataAsync <int>(url);
return(reds);
}
public static async Task <Bank> UpdateBankAsync(IRestDataMapper mapper, Bank data)
{
Bank reds = new Bank();
if (mapper == null)
{
return(reds);
}
string url = $"bank/api/v1/banks/{data.id}";
reds = await mapper.PutDataAsync(url, data);
return(reds);
}
/* public static async Task<CashBook> GetCashBookByIdAndBranchIdAsync(IRestDataMapper mapper, long cusId, int branchId)
* {
* CashBook reds = new CashBook();
* if (mapper == null)
* return reds;
* string url = $"cashbook/api/v1/cashbooks/{cusId}/{branchId}";
* reds = await mapper.GetDataAsync<CashBook>(url);
* return reds;
* }
*
* public static async Task<CashBook> GetCashBookByParamAndBranchIdAsync(IRestDataMapper mapper, string flag, string codeOrName, int branchId)
* {
* CashBook reds = new CashBook();
* if (mapper == null)
* return reds;
* string url = $"cashbook/api/v1/cashbooks/{flag}/{codeOrName}/{branchId}";
* reds = await mapper.GetDataAsync<CashBook>(url);
* return reds;
* }
*/
#endregion
#region Cheque Transaction Rest Services
public static async Task <ChequeBook> CreateChequeBookAsync(IRestDataMapper mapper, ChequeBook data)
{
ChequeBook reds = new ChequeBook();
if (mapper == null)
{
return(reds);
}
string url = "chequebook/api/v1/chequebooks";
reds = await mapper.PostDataAsync(url, data);
return(reds);
}
public static async Task <CashBook> UpdateCashBookAsync(IRestDataMapper mapper, CashBook data)
{
CashBook reds = new CashBook();
if (mapper == null)
{
return(reds);
}
string url = $"cashbook/api/v1/cashbooks/{data.id}";
reds = await mapper.PutDataAsync(url, data);
return(reds);
}
public static async Task <int> DeleteSupplierAsync(IRestDataMapper mapper, long SupplierId)
{
int reds = 0;
if (mapper == null)
{
return(reds);
}
string url = $"supplier/api/v1/suppliers/{SupplierId}";
reds = await mapper.DeleteDataAsync <int>(url);
return(reds);
}
public static async Task <Supplier> UpdateSupplierAsync(IRestDataMapper mapper, Supplier data)
{
Supplier reds = new Supplier();
if (mapper == null)
{
return(reds);
}
string url = $"supplier/api/v1/suppliers/{data.id}";
reds = await mapper.PutDataAsync(url, data);
return(reds);
}
public static async Task <Supplier> GetSupplierByParamAndBranchIdAsync(IRestDataMapper mapper, string flag, string codeOrName, int branchId)
{
Supplier reds = new Supplier();
if (mapper == null)
{
return(reds);
}
string url = $"supplier/api/v1/suppliers/{flag}/{codeOrName}/{branchId}";
reds = await mapper.GetDataAsync <Supplier>(url);
return(reds);
}
public static async Task <Supplier> GetSupplierByIdAndBranchIdAsync(IRestDataMapper mapper, long supId, int branchId)
{
Supplier reds = new Supplier();
if (mapper == null)
{
return(reds);
}
string url = $"supplier/api/v1/suppliers/{supId}/{branchId}";
reds = await mapper.GetDataAsync <Supplier>(url);
return(reds);
}
public static async Task <int> DeleteItemGroupAsync(IRestDataMapper mapper, int itemGroupId)
{
int reds = 0;
if (mapper == null)
{
return(reds);
}
string url = $"item/api/v1/itemgroups/{itemGroupId}";
reds = await mapper.DeleteDataAsync <int>(url);
return(reds);
}
public static async Task <ObservableCollection <Bank> > GetAllBankAsync(IRestDataMapper mapper)
{
ObservableCollection <Bank> data = new ObservableCollection <Bank>();
if (mapper == null)
{
return(data);
}
string url = "bank/api/v1/banks";
data = await mapper.GetDataAsync <ObservableCollection <Bank> >(url);
return(data);
}
public static async Task <UnitOfMeasurement> UpdateUnitOfMeasurementAsync(IRestDataMapper mapper, UnitOfMeasurement data)
{
UnitOfMeasurement reds = new UnitOfMeasurement();
if (mapper == null)
{
return(reds);
}
string url = $"item/api/v1/uoms/{data.id}";
reds = await mapper.PutDataAsync(url, data);
return(reds);
}
