private void AddorUpdateManifestOffline(ManifestModel manifestPostModel, bool queue)
{
string manifestId = manifestPostModel.ManifestId;
var isNew = Realm.GetInstance(RealmDbManager.GetRealmDbConfig()).Find <ManifestModel>(manifestId);
if (isNew != null)
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
RealmDb.Write(() =>
{
manifestPostModel.IsQueue = false;
manifestPostModel.IsDraft = false;
RealmDb.Add(manifestPostModel, update: true);
});
}
else
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
RealmDb.Write(() =>
{
if (queue)
{
manifestPostModel.IsQueue = true;
}
RealmDb.Add(manifestPostModel);
});
}
}
private void RecentCommandReciever()
{
List <ManifestModel> collection;
try
{
ManifestCollection.Clear();
Loader.StartLoading();
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
collection = RealmDb.All <ManifestModel>().Where(x => x.SubmittedDate == DateTimeOffset.UtcNow.Date && x.IsDraft == false && x.IsQueue == false).ToList();
AssignColletionToManifest(collection);
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
finally
{
Loader.StopLoading();
collection = null;
}
RecentTextColor = "White";
RecentBackgroundColor = "#4E6388";
QueuedTextColor = "#4E6388";
QueuedBackgroundColor = "Transparent";
DraftTextColor = "#4E6388";
DraftBackgroundColor = "Transparent";
}
private void QueuedCommandReciever()
{
List <ManifestModel> collection;
try
{
ManifestCollection.Clear();
Loader.StartLoading();
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
collection = RealmDb.All <ManifestModel>().Where(x => x.IsDraft == false && x.IsQueue == true).ToList();
AssignColletionToManifest(collection);
}
catch (Exception ex)
{
Debug.Write(ex.Message);
}
finally
{
Loader.StopLoading();
collection = null;
}
QueuedTextColor = "White";
QueuedBackgroundColor = "#4E6388";
DraftTextColor = "#4E6388";
DraftBackgroundColor = "Transparent";
RecentTextColor = "#4E6388";
RecentBackgroundColor = "Transparent";
}
private async Task LoadMaintainTypeAsync()
{
try
{
var maintenance = await _maintainService.GetMaintainTypeAsync(AppSettings.SessionId);
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
await RealmDb.WriteAsync((realmDb) =>
{
foreach (var item in maintenance.MaintainTypeReponseModel)
{
try
{
realmDb.Add(item);
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
});
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
public async Task LoadOperators()
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
List <OperatorModel> operators = null;
var result = await ApiManager.GetOperators(Settings.SessionId);
if (result.IsSuccessStatusCode)
{
var response = await result.Content.ReadAsStringAsync();
var model = await Task.Run(() => JsonConvert.DeserializeObject <IList <string> >(response, GetJsonSetting()));
operators = new List <OperatorModel>();
foreach (var item in model)
{
operators.Add(new OperatorModel {
Operator = item
});
}
await RealmDb.WriteAsync((realmDb) =>
{
foreach (var item in operators)
{
realmDb.Add(item);
}
});
}
}
public async void InventoryCommandRecieverAsync()
{
InventoryDetailModel model = null;
try
{
Loader.StartLoading();
model = await _dashboardService.GetInventoryAsync(AppSettings.SessionId);
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
RealmDb.Write(() =>
{
foreach (var item in model.InventoryResponseModel)
{
RealmDb.Add(item);
}
});
StockInventoryCollection = model.InventoryResponseModel.Where(x => x.Status != "Empty").ToList();
EmptyInventoryCollection = model.InventoryResponseModel.Where(x => x.Status == "Empty").ToList();
StockTotals = StockInventoryCollection.Sum(x => x.Quantity);
EmptyTotals = EmptyInventoryCollection.Sum(x => x.Quantity);
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
finally
{
model = null;
Loader.StopLoading();
}
}
private async Task LoadDashboardPartnersAsync()
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
try
{
var value = await _dashboardService.GetDashboardPartnersListAsync(AppSettings.CompanyId, AppSettings.SessionId);
if (value.Response.StatusCode == System.Net.HttpStatusCode.OK.ToString())
{
var partners = value.PossessorResponseModel.Where(x => x.Location.FullName != string.Empty).ToList();
await RealmDb.WriteAsync((realmDb) =>
{
foreach (var item in partners)
{
try
{
realmDb.Add(item);
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
});
}
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
public async Task LoadBrandAsync()
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
var response = await ApiManager.GetBrandList(Settings.SessionId);
if (response.IsSuccessStatusCode)
{
var json = await response.Content.ReadAsStringAsync();
var data = JsonConvert.DeserializeObject <IList <BrandModel> >(json, GetJsonSetting());
data.Insert(0, new BrandModel {
BrandName = "Add", BrandCode = "Add", BrandId = Guid.NewGuid().ToString()
});
data.Insert(1, new BrandModel {
BrandName = "'\"'", BrandCode = "'\"'", BrandId = Guid.NewGuid().ToString()
});
//data.Move(data.FirstOrDefault(x => x.BrandName == "Empty"), 2);
try
{
await RealmDb.WriteAsync((realmDb) =>
{
foreach (var item in data)
{
realmDb.Add(item);
}
});
}
catch (Exception ex)
{
}
}
}
private void AssignInitialValue(ManifestModel manifestModel)
{
try
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
var maintenance = RealmDb.All <MaintainTypeReponseModel>().ToList();
ManifestModel = manifestModel;
MaintainTypeCollection = maintenance.Where(x => x.ActivationMethod == "ReverseOnly").OrderBy(x => x.Name).ToList();
foreach (var item in manifestModel.MaintenanceModels.MaintenanceDoneRequestModel.ActionsPerformed)
{
var result = maintenance.Find(x => x.Id == item);
if (result != null)
{
MaintainTypeCollection.Where(x => x.Id == result.Id).FirstOrDefault().IsToggled = true;
}
}
Notes = manifestModel?.MaintenanceModels?.MaintenanceDoneRequestModel?.Notes;
PartnerModel = manifestModel?.MaintenanceModels?.MaintenanceDoneRequestModel?.PartnerModel;
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
private async Task LoadPartnersAsync()
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
try
{
var value = await _moveService.GetPartnersListAsync(AppSettings.SessionId);
if (value.Response.StatusCode == System.Net.HttpStatusCode.OK.ToString())
{
var Partners = value.PartnerModel.Where(x => x.FullName != string.Empty).ToList();
RealmDb.Write(() =>
{
foreach (var item in Partners)
{
try
{
RealmDb.Add(item);
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
});
}
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
internal void AssignInitialValueAsync(List <BarcodeModel> _alerts)
{
try
{
ConstantManager.VerifiedBarcodes = _alerts;
LoadOwnderAsync();
LoadAssetSizeAsync();
LoadAssetTypeAsync();
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
foreach (var item in _alerts)
{
AssetTypeModel selectedType = null;
AssetSizeModel selectedSize = null;
OwnerModel selectedOwner = OwnerCollection.Where(x => x.FullName == item?.Kegs?.Partners?.FirstOrDefault()?.FullName).FirstOrDefault();
if (selectedOwner != null)
{
RealmDb.Write(() =>
{
selectedOwner.HasInitial = true;
});
}
if (item.Tags.Count > 2)
{
selectedType = TypeCollection.Where(x => x.AssetType == item.Tags?[2]?.Value).FirstOrDefault();
RealmDb.Write(() =>
{
selectedType.HasInitial = true;
});
}
if (item.Tags.Count > 3)
{
selectedSize = SizeCollection.Where(x => x.AssetSize == item.Tags?[3]?.Value).FirstOrDefault();
RealmDb.Write(() =>
{
selectedSize.HasInitial = true;
});
}
MaintenaceCollection.Add(
new MoveMaintenanceAlertModel
{
UOwnerCollection = OwnerCollection.ToList(),
USizeCollection = SizeCollection.ToList(),
UTypeCollection = TypeCollection.ToList(),
BarcodeId = item.Barcode,
SelectedUOwner = selectedOwner ?? selectedOwner,
SelectedUSize = selectedSize ?? selectedSize,
SelectedUType = selectedType ?? selectedType
});
}
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
public async Task LoadAssetVolumeAsync()
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
List <AssetVolumeModel> assetVolumeModel = null;
var result = await ApiManager.GetAssetVolume(Settings.SessionId, false);
if (result.IsSuccessStatusCode)
{
var response = await result.Content.ReadAsStringAsync();
var model = await Task.Run(() => JsonConvert.DeserializeObject <IList <string> >(response, GetJsonSetting()));
assetVolumeModel = new List <AssetVolumeModel>();
foreach (var item in model)
{
assetVolumeModel.Add(new AssetVolumeModel {
AssetVolume = item
});
}
await RealmDb.WriteAsync((realmDb) =>
{
foreach (var item in assetVolumeModel)
{
realmDb.Add(item);
}
});
}
}
public async Task LoadPartnerTypeAsync()
{
try
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
var value = await _moveService.GetPartnerTypeAsync(AppSettings.SessionId);
if (value.Response.StatusCode == System.Net.HttpStatusCode.OK.ToString())
{
await RealmDb.WriteAsync((realmDb) =>
{
foreach (var item in value.PartnerTypeModel)
{
try
{
realmDb.Add(item);
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
});
}
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
public async Task LoadBatchAsync()
{
try
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
var value = await _fillService.GetBatchListAsync(AppSettings.SessionId);
if (value.Response.StatusCode == System.Net.HttpStatusCode.OK.ToString())
{
var batches = value.BatchModel.Where(p => p.BrandName != string.Empty).OrderBy(x => x.BrandName).ToList();
await RealmDb.WriteAsync((realmDb) =>
{
foreach (var item in batches)
{
try
{
realmDb.Add(item);
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
});
}
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
finally
{
}
}
internal void InitialAssignValueAsync(int currentPage)
{
try
{
CurrentPage = currentPage;
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
var model = RealmDb.All <InventoryResponseModel>().ToList();
if (model.Count > 0)
{
StockInventoryCollection = model.Where(x => x.Status != "Empty").ToList();
EmptyInventoryCollection = model.Where(x => x.Status == "Empty").ToList();
StockTotals = StockInventoryCollection.Sum(x => x.Quantity);
EmptyTotals = EmptyInventoryCollection.Sum(x => x.Quantity);
}
else
{
InventoryCommandRecieverAsync();
}
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
private async Task LoadOwnerAsync()
{
try
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
var value = await _moveService.GetOwnerAsync(AppSettings.SessionId);
await RealmDb.WriteAsync((realmDb) =>
{
foreach (var item in value.OwnerModel)
{
try
{
realmDb.Add(item);
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
});
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
finally
{
}
}
private void HandleReceivedMessages()
{
MessagingCenter.Subscribe <MaintainScanMessage>(this, "MaintainScanMessage", message =>
{
Device.BeginInvokeOnMainThread(() =>
{
var value = message;
if (value != null)
{
using (var db = Realm.GetInstance(RealmDbManager.GetRealmDbConfig()).BeginWrite())
{
var oldBarcode = BarcodeCollection.Where(x => x.Barcode == value.Barcodes.Barcode).FirstOrDefault();
oldBarcode.Pallets = value.Barcodes.Pallets;
oldBarcode.Kegs = value.Barcodes.Kegs;
oldBarcode.Icon = value?.Barcodes?.Kegs?.Partners.Count > 1 ? _getIconByPlatform.GetIcon("validationquestion.png") : value?.Barcodes?.Kegs?.Partners?.Count == 0 ? _getIconByPlatform.GetIcon("validationerror.png") : _getIconByPlatform.GetIcon("validationok.png");
oldBarcode.IsScanned = true;
db.Commit();
};
}
});
});
MessagingCenter.Subscribe <CancelledMessage>(this, "CancelledMessage", message =>
{
Device.BeginInvokeOnMainThread(() =>
{
var value = "Cancelled";
if (value == "Cancelled")
{
}
});
});
}
private async Task LoginCommandRecieverAsync()
{
UserDialogs.Instance.ShowLoading("Loging");
var loginResponse = await ApiManager.GetAuthenticate(Username, Password);
if (loginResponse.IsSuccessStatusCode)
{
var response = await loginResponse.Content.ReadAsStringAsync();
var model = await Task.Run(() => JsonConvert.DeserializeObject <LoginModel>(response, GetJsonSetting())); var overDues = model.Preferences.Where(x => x.PreferenceName == "OVERDUE_DAYS").Select(x => x.PreferenceValue).FirstOrDefault();
var atRisk = model.Preferences.Where(x => x.PreferenceName == "AT_RISK_DAYS").Select(x => x.PreferenceValue).FirstOrDefault();
var appDataWebServiceUrl = model.Preferences.Where(x => x.PreferenceName == "AppDataWebServiceUrl").Select(x => x.PreferenceValue).FirstOrDefault();
if (appDataWebServiceUrl != null)
{
ConstantManager.BaseUrl = ConstantManager.BaseUrl;// appDataWebServiceUrl;
}
Settings.SessionId = model.SessionId;
Settings.CompanyId = model.CompanyId;
Settings.MasterCompanyId = model.MasterCompanyId;
Settings.UserId = model.UserId;
Settings.SessionExpires = model.SessionExpires;
Settings.Overdue_days = !string.IsNullOrEmpty(overDues) ? long.Parse(overDues) : 0;
Settings.At_risk_days = !string.IsNullOrEmpty(atRisk) ? long.Parse(atRisk) : 0;
KegRefresh = Convert.ToDouble(model.Preferences.ToList().Find(x => x.PreferenceName == "KEG_REFRESH")?.PreferenceValue);
await RunSafe(DeviceCheckIn());
var versionUpdated = VersionTracking.CurrentVersion.CompareTo(VersionTracking.PreviousVersion);
if (versionUpdated > 0 && VersionTracking.PreviousVersion != null && VersionTracking.IsFirstLaunchForCurrentVersion)
{
await NavigationService.NavigateAsync("WhatIsNewView", null, useModalNavigation : true, animated : false);
}
else
{
if (TargetIdiom.Tablet == Device.Idiom)
{
await NavigationService.NavigateAsync("MainPageTablet", null, useModalNavigation : true, animated : false);
}
else
{
await NavigationService.NavigateAsync("MainPage", null, useModalNavigation : true, animated : false);
}
}
if (!IsLogOut)
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
await RealmDb.WriteAsync((realmDb) => realmDb.Add(model));
}
}
else
{
await _dialogService.DisplayAlertAsync("Error", "Error while login please check", "Ok");
UserDialogs.Instance.HideLoading();
}
Analytics.TrackEvent("Loged In");
}
public void LoadPartnerAsync(PartnerInfoResponseModel partnerInfoModel)
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
PartnerTypeCollectioin = RealmDb.All <PartnerTypeModel>().ToList();
if (partnerInfoModel != null)
{
AssingValueAddPartner(partnerInfoModel);
}
}
public void LoadBatchAsync()
{
try
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
BatchCollection = RealmDb.All <NewBatch>().ToList();
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
private void LoadMaintenanceType()
{
try
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
MaintainTypeReponseModel = RealmDb.All <MaintainTypeReponseModel>().ToList();
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
private void LoadBrand()
{
try
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
BrandCollection = RealmDb.All <BrandModel>().ToList();
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
private void LoadAssetTypeAsync()
{
try
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
TypeCollection = RealmDb.All <AssetTypeModel>().ToList();
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
private void AssignColletionToManifest(List <ManifestModel> collection)
{
using (var db = Realm.GetInstance(RealmDbManager.GetRealmDbConfig()).BeginWrite())
{
for (int i = 0; i < collection.Count; i++)
{
ManifestModel item = collection[i];
item.SenderId = item.ManifestItemsCount > 1 ? item.ManifestItemsCount + " Items" : item.ManifestItemsCount + " Item";
ManifestCollection.Add(item);
}
db.Commit();
}
}
private void LoadOwnderAsync()
{
try
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
OwnerCollection = RealmDb.All <OwnerModel>().ToList();
SelectedOwner = OwnerCollection.OrderBy(x => x.FullName).FirstOrDefault();
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
private void LoadAssetSizeAsync()
{
try
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
var value = RealmDb.All <AssetSizeModel>().ToList();
SizeCollection = value.Select(x => x.AssetSize).ToList();
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
public void LoadMaintenanceTypeAsync()
{
try
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
var result = RealmDb.All <MaintainTypeReponseModel>().ToList();
ConstantManager.MaintainTypeCollection = result.Where(x => x.ActivationMethod == "ReverseOnly").OrderBy(x => x.Name).ToList();
MaintainTypeCollection = ConstantManager.MaintainTypeCollection;
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
private void AddorUpdatePalletsOffline(PalletRequestModel palletRequestModel)
{
string palletId = palletRequestModel.PalletId;
var isNew = Realm.GetInstance(RealmDbManager.GetRealmDbConfig()).Find <PalletRequestModel>(palletId);
if (isNew != null)
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
RealmDb.Write(() =>
{
palletRequestModel.IsQueue = false;
RealmDb.Add(palletRequestModel, update: true);
});
}
}
private void HandleReceivedMessages()
{
MessagingCenter.Subscribe<FillScanMessage>(this, "FillScanMessage", message =>
{
Device.BeginInvokeOnMainThread(() =>
{
if (message != null)
{
using (var db = Realm.GetInstance(RealmDbManager.GetRealmDbConfig()).BeginWrite())
{
try
{
var oldBarcode = BarcodeCollection.Where(x => x.Barcode == message.Barcodes.Barcode).FirstOrDefault();
oldBarcode.Pallets = message?.Barcodes?.Pallets;
oldBarcode.Kegs = message?.Barcodes?.Kegs;
oldBarcode.Icon = message?.Barcodes?.Kegs?.Partners?.Count > 1 ? _getIconByPlatform.GetIcon("validationquestion.png") : message?.Barcodes?.Kegs?.Partners?.Count == 0 ? _getIconByPlatform.GetIcon("validationerror.png") : _getIconByPlatform.GetIcon("validationok.png");
oldBarcode.IsScanned = true;
db.Commit();
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
};
}
});
});
MessagingCenter.Subscribe<AddPalletToFillScanMsg>(this, "AddPalletToFillScanMsg", message =>
{
Device.BeginInvokeOnMainThread(() =>
{
Cleanup();
});
});
MessagingCenter.Subscribe<CancelledMessage>(this, "CancelledMessage", message =>
{
Device.BeginInvokeOnMainThread(() =>
{
var value = "Cancelled";
if (value == "Cancelled")
{
}
});
});
}
private void DeletePartnerType()
{
try
{
var RealmDb = Realm.GetInstance(RealmDbManager.GetRealmDbConfig());
using (var trans = RealmDb.BeginWrite())
{
RealmDb.RemoveAll <PartnerTypeModel>();
trans.Commit();
}
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
