public async Task ExecuteLoadItems()
{
TokenExpManger tokenExpManger = new TokenExpManger(App.TokenDto.Exp);
if (tokenExpManger.IsExpired())
{
await tokenExpManger.CloseSession();
}
else
{
if (StorePresenters.Count > 0)
{
StorePresenters.Clear();
}
var yourStores = StoreDataStore.GetStoresFromUser(App.LogUser.UserId);
foreach (var item in yourStores)
{
var storePresenter = new StorePresenters(item);
StorePresenters.Add(storePresenter);
}
}
}
async Task LoadOrders(string value)
{
LoadingManager.OnLoading();
Status _statusvalue = (Status)Enum.Parse(typeof(Status), value);
var orderData = await orderDataStore.GetOrdersOfUserWithSpecificStatus(App.LogUser.UserId, _statusvalue, App.TokenDto.Token);
KeyValues.Clear();
KeyValues.Add("orderAdded", orderData);
UserOrders.Clear();
foreach (var item in orderData)
{
item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());
var presenter = new OrderPresenter(item);
UserOrders.Add(presenter);
}
LoadingManager.OffLoading();
}
async Task ExecuteLoadStocksCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Stocks.Clear();
var stocks = await StoreDataStore.GetStoreStocksAsync(App.currentStore.StoreId, true);
foreach (var stock in stocks)
{
Stocks.Add(stock);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
async Task GetUserEmployeeInformation()
{
//Obtine los empleos del usuario.
var userEmployees = await EmployeeDataStore.GetUserEmployees(App.LogUser.UserId.ToString());
UserStoreEmployee = new ObservableCollection <Store>();
foreach (var item in userEmployees)
{
//Obtine el empleado
item.EmployeeStore = await StoreDataStore.GetAvailableStoreInformation(item.StoreId);
if (item.EmployeeStore != null)
{
var empWorkHours = await EmployeeWorkHour.GetEmployeeWorkHours(item.EmployeeId.ToString());
item.EmployeeWorkHours = empWorkHours.ToList();
var storePresenter = new StorePresenters(item.EmployeeStore);
StorePresenters.Add(storePresenter);
}
//UserStoreEmployee.Add(item.EmployeeStore);
}
App.LogUser.Employees = userEmployees.ToList();
}
public AdjustSerialNumbersViewModel(ObservableCollection <SerialNumber> serialNumbers)
{
SerialNumbers = new ObservableCollection <SerialNumber>();
Title = "List Serial Numbers";
foreach (SerialNumber imei in serialNumbers)
{
SerialNumbers.Add(imei);
}
MessagingCenter.Subscribe <AddSerialNumbersPage, IEnumerable <Stock> >(this, "AddMixedStocks", (async(obj, stocks) =>
{
var newstocks = stocks as IEnumerable <Stock>;
await StoreDataStore.AddStocksAsync(App.currentStore.StoreId, newstocks);
}));
MessagingCenter.Subscribe <SubtractSerialNumbersPage, IEnumerable <Stock> >(this, "SubtractMixedStocks", (async(obj, stocks) =>
{
var newstocks = stocks as IEnumerable <Stock>;
await StoreDataStore.SubtractStocksAsync(App.currentStore.StoreId, newstocks);
}));
MessagingCenter.Subscribe <PurchaseOrderSerialNumberPage, IEnumerable <Stock> >(this, "ReceiveMixedPurchaseOrder", (async(obj, stocks) =>
{
DateTime currentDateTime = DateTime.Now;
Order order = new Order {
OrderDate = currentDateTime, StoreId = App.currentStore.StoreId, UserId = App.currentUser.Id, OrderItems = new Collection <OrderItems>()
};
foreach (Stock stock in stocks)
{
order.OrderItems.Add(new OrderItems {
OrderId = order.OrderId, ProductId = stock.ProductId, Quantity = stock.Quantity
});
}
var newstocks = stocks as IEnumerable <Stock>;
await StoreDataStore.AddStocksAsync(App.currentStore.StoreId, newstocks);
await OrderDataStore.AddOrderAync(order);
}));
//MessagingCenter.Subscribe<AddSerialNumbersPage, IEnumerable<Stock>>(this, "AddSerialNumbers", async (obj, stocks) =>
//{
// var newSerialNumbers = serialNumbers as IEnumerable<SerialNumber>;
// await Serial.AddStocksAsync(App.currentStore.StoreId, newstocks);
//});
//GetSerialFieldsCommand = new Command(async () => await ExecuteGetSerialFields());
//MessagingCenter.Subscribe<AddnewSerialPage, Product>(this, "AddItem", async (obj, item) =>
//{
// var newItem = item as Product;
// Products.Add(newItem);
// await DataStore.AddProductAsync(newItem);
//});
}
public async Task GetStoreInformation(string id)
{
Guid StoreId = Guid.Parse(id);
var store = await StoreDataStore.GetAvailableStoreInformation(StoreId);
StoreImg = store.StoreImage;
StoreName = store.StoreName;
Title = store.StoreName;
StoreDescription = store.StoreDescription;
if (StoreProducts.Count > 0)
{
StoreProducts.Clear();
}
foreach (var product in store.Products)
{
var productPresenter = new ProductPresenter(product);
if (StoreProducts.Where(p => p.ProductId == productPresenter.ProductId).FirstOrDefault() == null)
{
StoreProducts.Add(productPresenter);
}
}
await GroupByProductCategory(StoreProducts);
//if (ProductCategoryPresenters.Count() > 0)
//{
// ProductCategoryPresenters.Clear();
//}
//var group = StoreProducts.GroupBy(p => p.ProductType);
//foreach (var item in group)
//{
// var _productCategory = new ProductCategoryPresenter(item.Key.ToString());
// ProductCategoryPresenters.Add(_productCategory);
//}
if (StoreWorkoutHours.Count() == 0)
{
foreach (var workhour in store.WorkHours)
{
if (workhour.Day == DateTime.Today.DayOfWeek.ToString())
{
WorkHour = workhour;
}
StoreWorkoutHours.Add(workhour);
}
}
}
public async Task GetSpecificStoreCategory(string category)
{
var data = await StoreDataStore.GetSpecificStoreCategory(category);
foreach (var store in data)
{
var storepresenter = new StorePresenters(store);
Stores.Add(storepresenter);
}
}
public void FetchStores()
{
IEnumerable <StorePresenter> storePresenters;
if (App.ApplicationManager.IsLogged() && App.ApplicationManager.CurrentUser is User user)
{
storePresenters = StoreDataStore.GetAllToExplore(user.Id.ToString());
AvailableStores = new ObservableCollection <StorePresenter>(
StorePresenterFactory.CreateStorePresenterCollection(storePresenters)
);
}
}
public AdjustStocksViewModel()
{
Title = "Add Stocks";
Stocks = new ObservableCollection <Stock>();
//LoadItemsCommand = new Command(async () => await ExecuteLoadItemsCommand());
MessagingCenter.Subscribe <AddStocksView, IEnumerable <Stock> >(this, "AddNonSerialStocks", (Action <AddStocksView, IEnumerable <Stock> >)(async(obj, stocks) =>
{
var newstocks = stocks as IEnumerable <Stock>;
await StoreDataStore.AddStocksAsync(App.currentStore.StoreId, (IEnumerable <Stock>)newstocks);
}));
}
public CountStockAndReconciliationViewModel()
{
Title = "Add Stocks";
Stocks = new ObservableCollection <Stock>();
//LoadItemsCommand = new Command(async () => await ExecuteLoadItemsCommand());
MessagingCenter.Subscribe <CountStockAndReconciliationPage, IEnumerable <Stock> >(this, "PostNonSerialStocksCount", (async(obj, stocks) =>
{
var newstocks = stocks as IEnumerable <Stock>;
await StoreDataStore.ReconcileInventoryAsync(App.currentStore.StoreId, newstocks);
}));
}
public ShipStocksViewModel()
{
Title = "Transfer Stocks";
Stocks = new ObservableCollection <Stock>();
MessagingCenter.Subscribe <ShipStocksViewModel, IEnumerable <Stock> >(this, "ShipNonSerialStocks", (Action <ShipStocksViewModel, IEnumerable <Stock> >)(async(obj, stocks) =>
{
var shippedStocks = stocks as IEnumerable <Stock>;
await StoreDataStore.SubtractStocksAsync(App.currentStore.StoreId, (IEnumerable <Stock>)shippedStocks);
foreach (Stock stock in shippedStocks)
{
stock.StoreId = ReceivingStoreId;
}
await StoreDataStore.AddStocksAsync(ReceivingStoreId, (IEnumerable <Stock>)shippedStocks);
}));
}
public CountStockAndReconciliationSerialNumbersViewModel(ObservableCollection <SerialNumber> serialNumbers)
{
SerialNumbers = new ObservableCollection <SerialNumber>();
Title = "Add serial numbers to the count";
foreach (SerialNumber imei in serialNumbers)
{
SerialNumbers.Add(imei);
}
MessagingCenter.Subscribe <CountStockAndReconciliationSerialNumbersPage, IEnumerable <Stock> >(this, "PostMixedStocksCount", (async(obj, stocks) =>
{
var newstocks = stocks as IEnumerable <Stock>;
await StoreDataStore.ReconcileInventoryAsync(App.currentStore.StoreId, newstocks);
}));
}
public async Task SetOrders()
{
var userOrderData = orderDataStore.GetUserOrders(App.LogUser.UserId);
UserOrders.Clear();
foreach (var item in userOrderData)
{
item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());
var presenter = new OrderPresenter(item);
UserOrders.Add(presenter);
}
}
public StocksViewModel()
{
Title = "Current Store Stocks";
Stocks = new ObservableCollection <Stock>();
LoadStocksCommand = new Command(async() => await ExecuteLoadStocksCommand());
MessagingCenter.Subscribe <IEnumerable <Stock> >(this, "AddStocks", (Action <IEnumerable <Stock> >)(async(stocks) =>
{
int storeId = stocks.First().StoreId;
foreach (Stock stock in stocks)
{
var newStock = stock as Stock;
Stocks.Add(stock);
}
await StoreDataStore.AddStocksAsync(storeId, stocks);
}));
}
public async Task ExecuteLoadElementsCommand()
{
Products = await DataStore.GetProductsAsync();
decimal totalCostAccumulator = 0;
decimal totalRetailValueAccumulator = 0;
decimal phoneStocksCostAccumulator = 0;
decimal accessoryStocksCostAccumulator = 0;
int phoneStockCounter = 0;
int AccessoryStockCounter = 0;
Stocks = await StoreDataStore.GetStoreStocksAsync(App.currentStore.StoreId, true);
foreach (Stock stock in Stocks)
{
Product product = Products.FirstOrDefault(x => x.Id == stock.ProductId);
totalCostAccumulator += (product.Cost * stock.Quantity);
totalRetailValueAccumulator += (product.Cost * stock.Quantity);
if (product.ProductType.ToLower() == "phone")
{
phoneStockCounter += stock.Quantity;
phoneStocksCostAccumulator += (product.Cost * stock.Quantity);
}
else
{
AccessoryStockCounter += stock.Quantity;
accessoryStocksCostAccumulator += (product.Cost * stock.Quantity);
}
}
StoreTotalStockCost = Stocks.Count().ToString();
StorePhoneStocksCount = phoneStockCounter.ToString();
StoreAccessoryStocksCount = AccessoryStockCounter.ToString();
StoreStocksTotalRetailValue = totalRetailValueAccumulator.ToString();
StoreTotalPhoneStocksCost = phoneStocksCostAccumulator.ToString();
StoreTotalAccessoryStocksCost = accessoryStocksCostAccumulator.ToString();
}
public PurchaseOrderViewModel()
{
Title = "Purchase Order";
Order = new Order {
OrderDate = DateTime.Now, StoreId = App.currentStore.StoreId, UserId = App.currentUser.Id, OrderItems = new Collection <OrderItems>()
};
Stocks = new ObservableCollection <Stock>();
MessagingCenter.Subscribe <PurchaseOrderPage, IEnumerable <Stock> >(this, "ReceivePurchaseOrder", (Action <PurchaseOrderPage, IEnumerable <Stock> >)(async(obj, stocks) =>
{
foreach (Stock stock in stocks)
{
Order.OrderItems.Add(new OrderItems {
OrderId = Order.OrderId, ProductId = stock.ProductId, Quantity = stock.Quantity
});
}
var newstocks = stocks as IEnumerable <Stock>;
await StoreDataStore.AddStocksAsync(App.currentStore.StoreId, (IEnumerable <Stock>)newstocks);
await OrderDataStore.AddOrderAync(Order);
}));
}
public ShipSerialNumbersViewModel(ObservableCollection <SerialNumber> serialNumbers)
{
SerialNumbers = new ObservableCollection <SerialNumber>();
Title = "Ship Serial Numbers";
foreach (SerialNumber imei in serialNumbers)
{
SerialNumbers.Add(imei);
}
MessagingCenter.Subscribe <ShipSerialNumbersPage, IEnumerable <Stock> >(this, "ShipMixedStocks", (async(obj, stocks) =>
{
var shippedStocks = stocks as IEnumerable <Stock>;
await StoreDataStore.SubtractStocksAsync(App.currentStore.StoreId, shippedStocks);
foreach (Stock stock in shippedStocks)
{
stock.StoreId = ReceivingStoreId;
}
await StoreDataStore.AddStocksAsync(ReceivingStoreId, shippedStocks);
}));
}
public async Task LoadItems()
{
LoadingManager.OnLoading();
TokenExpManger tokenExpManger = new TokenExpManger(App.TokenDto.Exp);
if (tokenExpManger.IsExpired())
{
await tokenExpManger.CloseSession();
LoadingManager.OffLoading();
}
else
{
var storeData = await StoreDataStore.GetAvailableStore();
if (!KeyValues.ContainsKey("storeAdded"))
{
KeyValues.Add("storeAdded", storeData);
}
if (Stores.Count > 0)
{
Stores.Clear();
}
foreach (var store in storeData)
{
var storepresenter = new StorePresenters(store);
Stores.Add(storepresenter);
}
LoadingManager.OffLoading();
}
}
async void GetStoreInformation(string value)
{
Store = await StoreDataStore.GetItemAsync(value);
}
async Task LoadStore(string storeId)
{
var result = await StoreDataStore.GetItemAsync(storeId);
Store = result;
}
async Task LoadUserOrderWithStatus(string value)
{
LoadingManager.OnLoading();
Status _statusvalue = (Status)Enum.Parse(typeof(Status), value);
var orderData = await orderDataStore.GetOrdersOfUserWithSpecificStatus(App.LogUser.UserId, _statusvalue, App.TokenDto.Token);
if (!KeyValues.ContainsKey("orderAdded"))
{
KeyValues.Add("orderAdded", orderData);
}
switch (_statusvalue)
{
case Status.Completed:
{
List <Order> tempData = new List <Order>();
var data = await orderDataStore.GetOrdersOfUserWithSpecificStatusDifferent(KeyValues["orderAdded"], _statusvalue, App.LogUser.UserId);
if (data != null)
{
foreach (var item in KeyValues["orderAdded"])
{
if (!tempData.Any(o => o.OrderId == item.OrderId))
{
tempData.Add(item);
}
}
foreach (var item in data)
{
if (!tempData.Any(s => s.StoreId == item.StoreId))
{
tempData.Add(item);
}
}
KeyValues.Clear();
KeyValues.Add("orderAdded", tempData);
foreach (var item in KeyValues["orderAdded"])
{
if (!UserOrders.Any(s => s.OrderId == item.OrderId))
{
//Task.Run(async() =>
//{
// item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());
//}).Wait();
item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());
var presenter = new OrderPresenter(item);
UserOrders.Add(presenter);
}
}
}
break;
}
case Status.NotSubmited:
{
List <Order> tempData = new List <Order>();
var data = await orderDataStore.GetOrdersOfUserWithSpecificStatusDifferent(KeyValues["orderAdded"], _statusvalue, App.LogUser.UserId);
if (data != null)
{
foreach (var item in KeyValues["orderAdded"])
{
if (!tempData.Any(o => o.OrderId == item.OrderId))
{
tempData.Add(item);
}
}
foreach (var item in data)
{
if (!tempData.Any(s => s.StoreId == item.StoreId))
{
tempData.Add(item);
}
}
KeyValues.Clear();
KeyValues.Add("orderAdded", tempData);
foreach (var item in KeyValues["orderAdded"])
{
if (!UserOrders.Any(s => s.OrderId == item.OrderId))
{
item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());
var presenter = new OrderPresenter(item);
UserOrders.Add(presenter);
}
}
}
break;
//UserOrders.Clear();
//foreach (var item in orderData)
//{
// item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());
// var presenter = new OrderPresenter(item);
// UserOrders.Add(presenter);
//}
}
case Status.Submited:
{
List <Order> tempData = new List <Order>();
var data = await orderDataStore.GetOrdersOfUserWithSpecificStatusDifferent(KeyValues["orderAdded"], _statusvalue, App.LogUser.UserId);
if (data != null)
{
foreach (var item in KeyValues["orderAdded"])
{
if (!tempData.Any(o => o.OrderId == item.OrderId))
{
tempData.Add(item);
}
}
foreach (var item in data)
{
if (!tempData.Any(s => s.StoreId == item.StoreId))
{
tempData.Add(item);
}
}
KeyValues.Clear();
KeyValues.Add("orderAdded", tempData);
foreach (var item in KeyValues["orderAdded"])
{
if (!UserOrders.Any(s => s.OrderId == item.OrderId))
{
item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());
var presenter = new OrderPresenter(item);
UserOrders.Add(presenter);
}
}
}
//UserOrders.Clear();
//foreach (var item in orderData)
//{
// item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());
// var presenter = new OrderPresenter(item);
// UserOrders.Add(presenter);
//}
break;
}
default:
break;
}
LoadingManager.OffLoading();
}
public RegisterStoreViewModel()
{
ValidatorInitializer();
StoreImage = ImageSource.FromFile("imgPlaceholder.jpg");
StoreTypes = new List <string>(Enum.GetNames(typeof(StoreType)).ToList());
#region WorkHourPresenter Initialize
WorkHourPresenters = new ObservableCollection <WorkHourPresenter>();
WorkHourPresenters.Add(new WorkHourPresenter(DayOfWeek.Monday.ToString()));
WorkHourPresenters.Add(new WorkHourPresenter(DayOfWeek.Tuesday.ToString()));
WorkHourPresenters.Add(new WorkHourPresenter(DayOfWeek.Wednesday.ToString()));
WorkHourPresenters.Add(new WorkHourPresenter(DayOfWeek.Thursday.ToString()));
WorkHourPresenters.Add(new WorkHourPresenter(DayOfWeek.Friday.ToString()));
WorkHourPresenters.Add(new WorkHourPresenter(DayOfWeek.Saturday.ToString()));
WorkHourPresenters.Add(new WorkHourPresenter(DayOfWeek.Sunday.ToString()));
#endregion
PickPhotoCommand = new Command(async() =>
{
//Stream stream = await DependencyService.Get<IPickPhotoService>().GetImageStreamAsync();
//if (stream != null)
//{
// ImgArray = ConvertToByteArray(stream);
// StoreImage = ImageSource.FromStream(() => stream);
//}
try
{
await CrossMedia.Current.Initialize();
files.Clear();
if (!CrossMedia.Current.IsPickPhotoSupported)
{
await Shell.Current.DisplayAlert("Photos Not Supported", ":( Permission not granted to photos.", "OK");
return;
}
var mediOptions = new PickMediaOptions()
{
PhotoSize = PhotoSize.Full,
};
var selectedImgFile = await CrossMedia.Current.PickPhotoAsync(mediOptions);
if (selectedImgFile == null)
{
return;
}
ImgArray = ConvertToByteArray(selectedImgFile.GetStream());
StoreImage = ImageSource.FromStream(() => selectedImgFile.GetStream());
}
catch (Exception e)
{
Console.WriteLine(e);
}
});
CompleteRegisterCommand = new Command(async() =>
{
TokenExpManger tokenExpManger = new TokenExpManger(App.TokenDto.Exp);
if (tokenExpManger.IsExpired())
{
await tokenExpManger.CloseSession();
}
else
{
List <string> valuesToCheck = new List <string>();
valuesToCheck.Add(StoreName);
valuesToCheck.Add(LicenseCode);
valuesToCheck.Add(StripeSecretKey);
valuesToCheck.Add(StripePublicKey);
StoreNameValidator = ValidatorRules.EmptyOrNullValueRule(StoreName);
StoreDescriptionValidator = ValidatorRules.EmptyOrNullValueRule(StoreDescription);
LicenseCodeValidator = ValidatorRules.EmptyOrNullValueRule(LicenseCode);
SkStripeValidator = ValidatorRules.EmptyOrNullValueRule(StripeSecretKey);
PKeyStripeValidator = ValidatorRules.EmptyOrNullValueRule(StripePublicKey);
if (!StoreNameValidator.HasError && !StoreDescriptionValidator.HasError && !LicenseCodeValidator.HasError && !SkStripeValidator.HasError && !PKeyStripeValidator.HasError && GlobalValidator.CheckNullOrEmptyImage(StoreImage))
{
bool isSKKeyCorrect = StripeSecretKey.StartsWith("sk");
bool isPBkeyCorrect = StripePublicKey.StartsWith("pk");
if (isSKKeyCorrect || isSKKeyCorrect)
{
Guid licenseCodeGuid = Guid.Parse(LicenseCode);
var licenseResult = storeLicenseDataStore.StoreLicenseExists(licenseCodeGuid);
if (licenseResult)
{
var licenseIsInUsed = await storeLicenseDataStore.IsLicenseInUsed(LicenseCode);
if (!licenseIsInUsed)
{
StoreType value;
Enum.TryParse(StoreTypeSelected, out value);
var newStoreRegister = new Store()
{
StoreId = Guid.NewGuid(),
StoreName = StoreName,
UserId = App.LogUser.UserId,
StoreImage = ImgArray,
StoreType = value,
StoreRegisterLicenseId = licenseCodeGuid,
StoreDescription = StoreDescription,
SKKey = StripeSecretKey,
PBKey = StripePublicKey,
};
List <WorkHour> workHours = new List <WorkHour>();
foreach (var item in WorkHourPresenters)
{
var workHour = new WorkHour()
{
CloseTime = Convert.ToDateTime(item.Close.ToString()),
Day = item.Day,
OpenTime = Convert.ToDateTime(item.Open.ToString()),
WorkHourId = Guid.NewGuid(),
StoreId = newStoreRegister.StoreId
};
workHours.Add(workHour);
}
newStoreRegister.WorkHours = workHours;
var storeaddedResult = await StoreDataStore.AddItemAsync(newStoreRegister);
if (storeaddedResult)
{
var licenceUpdateResult = await storeLicenseDataStore.UpdateLicenceInCode(licenseCodeGuid);
if (licenceUpdateResult)
{
await Shell.Current.DisplayAlert("Notification", "Store Added...!", "OK");
}
}
}
else
{
await Shell.Current.DisplayAlert("Notification", "This License is in used.", "OK");
}
}
else
{
await Shell.Current.DisplayAlert("Notification", "License Code Incorrect", "OK");
}
}
else
{
await Shell.Current.DisplayAlert("Notification", "Srtipe Secret Key or Public Key are set in incorrect entry check again.", "OK");
}
}
else
{
await Shell.Current.DisplayAlert("Notification", "Some fields are empty", "OK");
}
}
});
}
async Task GetStore(string id)
{
var store = await StoreDataStore.GetItemAsync(StoreId);
StoreName = store.StoreName;
}
public async Task LoadDifferentItems()
{
LoadingManager.OnLoading();
TokenExpManger tokenExpManger = new TokenExpManger(App.TokenDto.Exp);
if (tokenExpManger.IsExpired())
{
await tokenExpManger.CloseSession();
LoadingManager.OffLoading();
}
else
{
if (!KeyValues.ContainsKey("storeAdded"))
{
await LoadItems();
}
else
{
var storeData = await StoreDataStore.GetDifferentStore(KeyValues["storeAdded"]);
if (storeData != null)
{
var tempData = new List <Store>();
foreach (var item in KeyValues["storeAdded"])
{
if (!tempData.Any(s => s.StoreId == item.StoreId))
{
tempData.Add(item);
}
}
foreach (var item in storeData)
{
if (!tempData.Any(s => s.StoreId == item.StoreId))
{
tempData.Add(item);
}
}
KeyValues.Clear();
KeyValues.Add("storeAdded", tempData);
foreach (var item in KeyValues["storeAdded"])
{
if (!Stores.Any(s => s.StoreId == item.StoreId))
{
var storepresenter = new StorePresenters(item);
Stores.Add(storepresenter);
}
}
}
}
LoadingManager.OffLoading();
}
}
async Task <Store> GetStore(string storeId)
{
var store = await StoreDataStore.GetItemAsync(storeId);
return(store);
}
