public AssociatedBoardsViewModel(IBoardsService boardsService)
{
Title = "Associated Boards";
_boardsService = boardsService;
AssociatedBoards = new ObservableCollectionFast <BoardTest>();
}
public WoksViewModel()
{
main = new ObservableCollectionFast <AppItem>();
sauce = new ObservableCollectionFast <AppItem>();
meat = new ObservableCollectionFast <AppItem>();
toppings = new ObservableCollectionFast <AppItem>();
wok = new MyProduct();
tabs = new string[2] {
"СОБРАТЬ ВОК", "МОИ ВОКИ"
};
CreateWok = new Command((product) =>
{
DataBase.WriteItem <MyProduct>("Woks", (MyProduct)product as MyProduct);
});
LoadSubcatsCommand = new Command(async() =>
{
fullPrice = 0;
mainPrice = 0;
saucePrice = 0;
meatPrice = 0;
toppingPrice = 0;
var main = await DataBase.GetByQueryEnumerableAsync <AppItem>("Items", Query.Where("category", x => x.AsArray.Contains(mainCateg)));
this.main.Clear();
this.main.AddRange(main);
var sauce = await DataBase.GetByQueryEnumerableAsync <AppItem>("Items", Query.Where("category", y => y.AsArray.Contains(229)));
this.sauce.Clear();
this.sauce.AddRange(sauce);
var meat = await DataBase.GetByQueryEnumerableAsync <AppItem>("Items", Query.Where("category", z => z.AsArray.Contains(meatCateg)));
this.meat.Clear();
this.meat.AddRange(meat);
var toppings = await DataBase.GetByQueryEnumerableAsync <AppItem>("Items", Query.Where("category", w => w.AsArray.Contains(toppingsCateg)));
this.toppings.AddRange(toppings);
});
}
public CartPageViewModel()
{
CartItems = new ObservableCollectionFast <CartItem>();
//FillCart();
//PropertyChanged += PropertyHasChanged;
}
public AddRemoveBoardsViewModel(IBoardsService boardsService)
{
Title = "Add/Remove Board";
_boardsService = boardsService;
Boards = new ObservableCollectionFast <BoardDetailsSelect>();
TestedBoards = new List <BoardTest>();
}
public AllBoardsViewModel(IBoardsService boardsService)
{
Title = "Boards on Cloud";
_boardsService = boardsService;
Boards = new ObservableCollectionFast <BoardSelect>();
TestedBoards = new List <BoardTest>();
}
public CircuitsViewModel(IBoardsService boardsService)
{
Title = "Circuits";
_boardsService = boardsService;
TestedCircuits = new List <CircuitTest>();
Circuits = new ObservableCollectionFast <CircuitSelect>();
}
public CertificatesViewModel(ICertificatesService certificatesService, IBuildingService buildingService)
{
Title = "Certificates";
_certificatesService = certificatesService;
_buildingService = buildingService;
Certificates = new ObservableCollectionFast <Certificate>();
}
public BuildingsViewModel(IBuildingsService buildingsService, IBuildingService buildingService)
{
Title = "Buildings";
_buildingsService = buildingsService;
_buildingService = buildingService;
Buildings = new ObservableCollectionFast <BuildingRow>();
}
public AllCertificatesViewModel(ICertificatesService certificatesService, IBuildingService buildingService)
{
Title = "Certificates on cloud";
_certificatesService = certificatesService;
_buildingService = buildingService;
Certificates = new ObservableCollectionFast <CertificateRowSelect>();
DownloadedCertificates = new List <Certificate>();
}
public EditPointViewModel(IBoardsService boardsService)
{
Title = "Edit Point";
_boardsService = boardsService;
Boards = new ObservableCollectionFast <BoardTest>();
Circuits = new ObservableCollectionFast <CircuitTest>();
ShowArrows = true;
}
public EstatesViewModel(IEstatesService estatesService, ILookupsService lookupsService, IEstatesLookupsService estatesLookupsService)
{
Title = "Estates";
_estatesService = estatesService;
_lookupsService = lookupsService;
_estatesLookupsService = estatesLookupsService;
Estates = new ObservableCollectionFast <EstateRow>();
}
public static async Task SaveCartDataToFile(ObservableCollectionFast <CartItem> CartItems, string CartListFile)
{
var json = JsonConvert.SerializeObject(CartItems, Formatting.Indented);
try
{
var StoredFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), CartListFile);
using (var writer = File.CreateText(StoredFile))
{
await writer.WriteLineAsync(json);
}
}
catch (Exception ex)
{
Debug.WriteLine("\tERROR {0}", ex.Message);
}
}
private async Task LoadPosts()
{
var allFollowers = await _userFollowersService.Get <List <Model.UserFollowers> >(new UserFollowersSearchRequest()
{
FollowedByUserId = current.UserId
});
var allFollowedArtists = await _userFollowsArtistService.Get <List <Model.UserFollowsArtist> >(new UserFollowsArtistSearchRequest()
{
UserId = current.UserId
});
var allPosts = await _postService.Get <List <Model.Post> >(null);
var localPosts = new ObservableCollectionFast <Post>();
localPosts.AddRange(allPosts.Where(a => a.IsGlobal.HasValue && a.IsGlobal == true).ToList());
localPosts.AddRange(allPosts.Where(a => a.ArtistRelatedId != null &&
a.ArtistRelatedId == allFollowedArtists.Where(b => b.ArtistId == a.ArtistRelatedId).Select(c => c.ArtistId).FirstOrDefault()).ToList());
localPosts.AddRange(allPosts.Where(a => a.UserRelatedId != null &&
a.UserRelatedId == allFollowers.Where(b => b.UserId == a.UserRelatedId &&
b.FollowedByUserId == APIService.loggedProfile.UserId).Select(c => c.UserId).FirstOrDefault()).ToList());
localPosts.AddRange(allPosts.Where(a => a.UserRelatedId != null &&
a.UserRelatedId == APIService.loggedProfile.UserId).ToList());
var dist = localPosts.Distinct().OrderByDescending(a => a.PostDateTime);
foreach (var item in dist)
{
loadedPosts.Add(new PostHelperVM()
{
AdminName = item.AdminName,
OPPhoto = item.Opphoto,
PostDateTime = item.PostDateTime,
PostId = item.PostId,
PostPhoto = item.PostPhoto,
PostText = item.PostText,
PostTitle = item.PostTitle
});
}
}
public static async Task <ObservableCollectionFast <CartItem> > ReadCartDataFromFile(string CartListFile)
{
ObservableCollectionFast <CartItem> results = new ObservableCollectionFast <CartItem>();
try
{
var StoredFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), CartListFile);
if (StoredFile == null || !File.Exists(StoredFile))
{
return(results);
}
string FileData = string.Empty;
using (var reader = new StreamReader(StoredFile, true))
{
string line;
while ((line = reader.ReadLine()) != null)
{
FileData += line;
}
}
var settings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Ignore
};
results = JsonConvert.DeserializeObject <ObservableCollectionFast <CartItem> >(FileData, settings);
return(results);
}
catch (Exception ex)
{
Debug.WriteLine("\tERROR {0}", ex.Message);
return(results);
}
}
public FavoriteViewModel()
{
favorites = new ObservableCollectionFast <AppItem>();
wasLoaded = false;
LoadFavorites = new Command(async() =>
{
await Task.Run(async() =>
{
var fav = await DataBase.GetAllStreamAsync <AppItem>("Favorite");
Device.BeginInvokeOnMainThread(() =>
{
favorites.Clear();
favorites.AddRange(fav);
});
});
});
RemoveFavorite = new Command((item) =>
{
favorites.Remove(item as AppItem);
DataBase.RemoveItem <AppItem>("Favorite", LiteDB.Query.Where("uid", x => x.AsString == (item as AppItem).uid));
(item as AppItem).Favorite = false;
DataBase.UpdateItem <AppItem>("Items", null, (item as AppItem));
});
AddToCart = new Command((item) =>
{
var Item = (AppItem)item as AppItem;
Task.Run(() =>
{
AddToCartMethod(Item);
}).ContinueWith((obj) =>
{
TokioCity.Views.CategoriesTabs.RenewCount();
});
});
}
public ProductCatalogViewModel()
{
ProductCatalogs = new List <ProductCatalog>();
CartItems = new ObservableCollectionFast <CartItem>();
//create http client
_client = CreateHTTPClient();
//test server connection
var serverOnline = false;
Task.Run(async() => { serverOnline = await TestServerConnection(_client); }).Wait();
//retrieve data for product catalog
if (serverOnline)
{
Task.Run(async() => { ProductList = await GetProductAsync(_client); }).Wait();
Task.Run(async() => { await SaveProductDataToFile(ProductList, ProductListFile); }).Wait();
}
else
{
Task.Run(async() => { ProductList = await ReadProductDataFromFile(ProductListFile); }).Wait();
}
foreach (Product product in ProductList)
{
ProductCatalogs.Add(
new ProductCatalog {
Product = product, Qty = 1, PriceWithCurrency = Currency + " " + product.Regular_price
});
}
//FillCatalog();
//Retrieve cart data
Task.Run(async() => { CartItems = await ReadCartDataFromFile(CartListFile); }).Wait();
}
public BurgersViewModel()
{
wasLoaded = false;
burgers = new ObservableCollectionFast <AppItem>();
var info = Xamarin.Essentials.DeviceDisplay.MainDisplayInfo;
widthGrid = (int)(info.Width / info.Density);
toppings = new ObservableCollectionFast <AppItem>();
height = App.screenHeight / 2;
AddToFavorite = new Command((item) =>
{
var check = DataBase.GetProduct <AppItem>("Favorite", (item as AppItem).uid);
if (check == null)
{
DataBase.WriteItem <AppItem>("Favorite", (AppItem)item as AppItem);
(item as AppItem).Favorite = true;
DataBase.UpdateItem <AppItem>("Items", null, (item as AppItem));
}
else
{
DataBase.RemoveItem <AppItem>("Favorite", Query.Where("uid", x => x.AsString == check.uid));
(item as AppItem).Favorite = false;
DataBase.UpdateItem <AppItem>("Items", null, (item as AppItem));
}
});
LoadBurgers = new Command(async() =>
{
if (wasLoaded)
{
return;
}
else
{
await Task.Run(async() =>
{
var burgers = await DataBase.GetByQueryEnumerableAsync <AppItem>("Items", Query.Where("category", x => x.AsArray.Contains(222)));
Device.BeginInvokeOnMainThread(() =>
{
this.burgers.Clear();
this.burgers.AddRange(burgers);
});
LoadToppings.Execute(null);
});
wasLoaded = true;
}
});
AddToCart = new Command((item) =>
{
var Item = (AppItem)item as AppItem;
Task.Run(() =>
{
AddToCartMethod(Item);
}).ContinueWith((obj) =>
{
TokioCity.Views.CategoriesTabs.RenewCount();
});
});
LoadToppings = new Command(() =>
{
var toppings = DataBase.GetByQueryEnumerable <AppItem>("Items", Query.Where("category", x => x.AsArray.Contains(1564)));
this.toppings.Clear();
while (toppings.MoveNext())
{
this.toppings.Add(toppings.Current);
}
toppings.Dispose();
});
}
public BaseCategoryViewModel(int[] category, bool showSubcats = true)
{
wasLoaded = false;
subcatsShow = showSubcats;
width = App.screenWidth / 4;
var info = Xamarin.Essentials.DeviceDisplay.MainDisplayInfo;
widthGrid = (int)(info.Width / info.Density);
height = (App.screenHeight / 2);
products = new ObservableCollectionFast <AppItem>();
subcats = new ObservableCollectionFast <SubcategorySimplified>();
Products = new ObservableCollectionFast <AppItem>();
Toppings = new ObservableCollection <AppItem>();
selectedCategory = new SubcategorySimplified();
SelectedCategory = new SubcategorySimplified();
ClearProducts = new Command(() =>
{
products.Clear();
Products.Clear();
});
LoadProducts = new Command(async() =>
{
if (wasLoaded)
{
this.SelectedCategory = this.subcats[0];
return;
}
else
{
if (subcatsShow)
{
try
{
ReloadCategories.Execute(category[0]);
}
catch (IndexOutOfRangeException e) { }
}
this.category = await DataBase.GetItemAsync <CategorySimplified>("Categories", Query.EQ("cat_id", category[0]));
foreach (var subcat in category)
{
await Task.Run(async() =>
{
var query = Query.Where("category", x => x.AsArray.Contains(subcat));
var database = await DataBase.GetByQueryEnumerableAsync <AppItem>("Items", query);
Device.BeginInvokeOnMainThread(() =>
{
products.AddRange(database);
});
});
}
wasLoaded = true;
}
});
AddFavorite = new Command((item) =>
{
var check = DataBase.GetProduct <AppItem>("Favorite", (item as AppItem).uid);
if (check == null)
{
DataBase.WriteItem <AppItem>("Favorite", (AppItem)item as AppItem);
(item as AppItem).Favorite = true;
DataBase.UpdateItem <AppItem>("Items", null, (item as AppItem));
}
else
{
DataBase.RemoveItem <AppItem>("Favorite", Query.Where("uid", x => x.AsString == check.uid));
(item as AppItem).Favorite = false;
DataBase.UpdateItem <AppItem>("Items", null, (item as AppItem));
}
});
ReloadCategories = new Command(async(categ) =>
{
try
{
await Task.Run(async() =>
{
var subcats = await DataBase.GetItemAsync <CategorySimplified>("Categories", LiteDB.Query.EQ("cat_id", (int)categ));
if (subcats != null)
{
Device.BeginInvokeOnMainThread(() =>
{
this.subcats.AddRange(subcats.subcats);
this.SelectedCategory = this.subcats[0];
});
}
});
}
catch (ArgumentOutOfRangeException e) { }
});
AddToCart = new Command((item) =>
{
var Item = (AppItem)item as AppItem;
Task.Run(() =>
{
AddToCartMethod(Item);
}).ContinueWith((obj) =>
{
TokioCity.Views.CategoriesTabs.RenewCount();
});
});
LoadProductSubcatd = new Command((categ) =>
{
Products.Clear();
var items = DataBase.GetByQuery <AppItem>("Items", Query.Where("category", x => x.AsArray.Contains((int)categ)));
Products.AddRange(items);
});
}
private async Task GetCircuitsForCurrentBoard()
{
try
{
_inCode = true;
if (Boards != null && Boards.Any() && CurrentBoardPosition == -1)
{
CurrentBoardPosition = 0;
}
if (Boards != null)
{
SelectedBoard = Boards[CurrentBoardPosition];
}
var result = await _boardsService.GetTestedCircuits(CertificateId, SelectedBoard.BoardId);
if (!result.Success)
{
Dialogs.Toast(result.Message);
return;
}
var circuitTest = result.ResultObject as List <CircuitTest>;
if (circuitTest == null)
{
return;
}
CurrentCircuitPosition = 0;
Circuits.Clear();
var circuits = new List <CircuitTest>();
if (SelectedBoard.BoardPhase == "3" || SelectedBoard.BoardPhase == "TP&N")
{
var numberToSkip = 0;
var numbers = circuitTest.Select(x => x.CircuitReference).Distinct();
var threePhaseCircutes = new List <int>();
foreach (var number in numbers)
{
if (circuitTest.Any(x => x.CircuitReference == number && x.CircuitIs3Phase == "Y"))
{
threePhaseCircutes.Add(number);
}
}
if (!threePhaseCircutes.Any())
{
circuits.AddRange(circuitTest);
}
else
{
foreach (var circuit in circuitTest)
{
if (circuit.CircuitReference == numberToSkip)
{
continue;
}
if (threePhaseCircutes.Contains(circuit.CircuitReference))
{
if (circuit.CircuitIs3Phase == "Y")
{
circuit.NotBelongsToThreePhase = false;
circuit.ThreePhase = circuit.CircuitReference + SelectedBoard.BoardCircuitPhaseNaming;
circuits.Add(circuit);
numberToSkip = circuit.CircuitReference;
}
continue;
}
circuit.NotBelongsToThreePhase = true;
circuits.Add(circuit);
}
}
}
else
{
circuits.AddRange(circuitTest);
}
Circuits = new ObservableCollectionFast <CircuitTest>(circuits.OrderBy(x => x.ThreePhaseRepresentation));
//Circuits.AddRange(new List<CircuitTest>(circuitTest.OrderBy(x => x.CircuitIdentity)));
GetPointsForCurrentCircuit();
_inCode = false;
}
catch (ServiceAuthenticationException e)
{
var result = await TryToLogin();
if (!result)
{
await NavigationService.NavigateToAsync <LoginViewModel>();
}
else
{
await GetCircuitsForCurrentBoard();
}
}
catch (Exception e)
{
//await ShowErrorAlert(e.Message);
}
}
