/// <summary>
/// DataFilterSummaryService is a service for filtering data without mapping. It can be used
/// for mapping the data.
/// </summary>
/// <param name="dialogService">Dialog service to be used</param>
/// <param name="sqlExecutor">SqlExecutor to be used.</param>
public DataFilterSummaryService(IDialogService dialogService, ISqlExecutor sqlExecutor) : base(dialogService)
{
_incrementalList = new IncrementalList <Dto>(LoadMoreItems);
_queryStoreFactory = new QueryStoreFactory();
_sqlExecutor = sqlExecutor;
_dialogService = dialogService;
}
public void StartAndNotify()
{
_incidentCompletion = NotifyTaskCompletion.Create <IEnumerable <BookingIncidentSummaryViewObject> >(
_incidentService.GetPagedSummaryDoAsync(1, DefaultPageSize), (task, ev) =>
{
if (task is INotifyTaskCompletion <IEnumerable <BookingIncidentSummaryViewObject> > summaryCollection)
{
if (summaryCollection.IsSuccessfullyCompleted)
{
var collection = summaryCollection.Result;
if (SummaryView is IncrementalList <BookingIncidentSummaryViewObject> summary)
{
var maxItems = _incidentService.NumberItems;
PageCount = _incidentService.NumberPage;
var summaryList = new IncrementalList <BookingIncidentSummaryViewObject>(LoadMoreItems)
{
MaxItemCount = (int)maxItems
};
summaryList.LoadItems(collection);
SummaryView = summaryList;
}
}
else
{
DialogService?.ShowErrorMessage("Cannot load more pages");
}
}
});
}
public IncrementalLoadingViewModel(Context context)
{
progress = new SfLinearProgressBar(context);
popup = new SfPopupLayout(context);
string uri = "http://services.odata.org/Northwind/Northwind.svc/";
if (CheckConnection(uri).Result)
{
popup.PopupView.ContentView = progress;
popup.PopupView.HeaderTitle = "Fetching Data... ";
popup.PopupView.ShowCloseButton = false;
popup.PopupView.ShowFooter = false;
popup.PopupView.HeightRequest = 125;
popup.StaysOpen = true;
progress.Progress = 100;
progress.IsIndeterminate = true;
popup.Show();
gridSource = new IncrementalList <Order>(LoadMoreItems)
{
MaxItemsCount = 1000
};
northwindEntity = new NorthwindEntities(new Uri(uri));
}
else
{
NoNetwork = true;
IsBusy = false;
}
}
public async Task <IAssistResult <T1> > HandleAssist <T, T1>(IAssist assist) where T : class where T1 : class
{
var list = await HelperDataServices.GetPagedQueryDoAsync <T>(assist.Query, 1, 100);
var count = await HelperDataServices.GetItemsCount <T>();
var resultMapped = _mapper.Map <IEnumerable <T>, IEnumerable <T1> >(list);
IncrementalList <T1> valueList = new IncrementalList <T1>(LoadItems);
valueList.LoadItems(resultMapped);
valueList = new IncrementalList <T1>((x, index) => {
NotifyTaskCompletion.Create(HelperDataServices.GetPagedQueryDoAsync <T>(assist.Query, index, 100), (sender, arg) =>
{
if (sender is INotifyTaskCompletion <IEnumerable <T> > taskCompleted)
{
if (taskCompleted.IsSuccessfullyCompleted)
{
var resultValue = _mapper.Map <IEnumerable <T>, IEnumerable <T1> >(taskCompleted.Result);
valueList.LoadItems(resultValue);
}
}
});
})
{
MaxItemCount = count
};
T1 assistResult = valueList.FirstOrDefault();
IAssistResult <T1> result = new AssistResult <T1>(assistResult, valueList);
return(result);
}
public override void StartAndNotify()
{
_incidentCompletion = NotifyTaskCompletion.Create <IEnumerable <UsersSummary> >(
_incidentService.GetPagedSummaryDoAsync(1, DefaultPageSize), (task, ev) =>
{
if (task is INotifyTaskCompletion <IEnumerable <UsersSummary> > summaryCollection)
{
if (summaryCollection.IsSuccessfullyCompleted)
{
var collection = summaryCollection.Result;
if (SummaryView is IncrementalList <UsersSummary> summary)
{
var maxItems = _incidentService.NumberItems;
PageCount = __incidentService.NumberPage;
var summaryList = new IncrementalList <UsersSummary>(LoadMoreItems)
{
MaxItemCount = (int)maxItems
};
summaryList.LoadItems(collection);
SummaryView = summaryList;
}
}
else
{
DialogService?.ShowErrorMessage(ErrorConstants.DataLoadError + " : " + reservations.ErrorMessage);
}
}
});
}
public IncrementalLoadingViewModel()
{
LoaderBorder = new UIView();
this.LoaderLable = new UILabel();
this.LoaderIndicator = new UIActivityIndicatorView();
this.LoaderIndicator.Color = UIColor.FromRGB(255, 255, 255);
LoaderBorder.BackgroundColor = UIColor.FromRGB(70, 183, 118);
LoaderBorder.Add(LoaderLable);
LoaderBorder.Add(LoaderIndicator);
string uri = "http://services.odata.org/Northwind/Northwind.svc/";
if (CheckConnection(uri).Result)
{
gridSource = new IncrementalList <Order> (LoadMoreItems)
{
MaxItemsCount = 1000
};
northwindEntity = new NorthwindEntities(new Uri(uri));
}
else
{
NoNetwork = true;
IsBusy = false;
}
}
private void InitViewModel()
{
MailBoxHandler += OnMailBoxHandler;
MailboxName = ViewModelUri.ToString();
RegisterMailBox(MailboxName);
EventManager.RegisterObserverSubsystem(BookingModule.BookingSubSystem, this);
EventManager.RegisterMailBox(ViewModelUri.ToString(), MailBoxHandler);
_bookingLoadEventHandler += OnNotifyIncrementalList <BookingSummaryDto>;
SummaryView = new IncrementalList <BookingSummaryDto>(LoadMoreItems);
OpenCommand = new DelegateCommand <object>(OpenCurrentItem);
NavigateClient = new DelegateCommand <object>(OnNavigateClient);
_payloadInterpeterReload = new PayloadInterpeter <BookingSummaryDto>();
_payloadInterpeterReload.Init = (value, packet, insertion) =>
{
switch (packet.PayloadType)
{
case DataPayLoad.Type.UpdateView:
StartAndNotify();
break;
}
;
};
_payloadInterpeterReload.CleanUp = (key, system, name) =>
{
// up to now.
};
_payloadInterpeter = new PayloadInterpeter <IBookingData>();
InitPayLoadInterpeter(_payloadInterpeter);
RegisterToolBar();
StartAndNotify();
}
public void StartAndNotify()
{
_reservationCompletion = NotifyTaskCompletion.Create <IEnumerable <ReservationRequestSummary> >(
_reservationRequestDataService.GetPagedSummaryDoAsync(1, DefaultPageSize), (task, ev) =>
{
if (task is INotifyTaskCompletion <IEnumerable <ReservationRequestSummary> > reservations)
{
if (reservations.IsSuccessfullyCompleted)
{
var collection = reservations.Result;
if (SummaryView is IncrementalList <ReservationRequestSummary> summary)
{
var maxItems = _reservationRequestDataService.NumberItems;
PageCount = _reservationRequestDataService.NumberPage;
var summaryList = new IncrementalList <ReservationRequestSummary>(LoadMoreItems)
{
MaxItemCount = (int)maxItems
};
summaryList.LoadItems(collection);
SummaryView = summaryList;
}
}
else
{
DialogService?.ShowErrorMessage("No puedo cargar datos de peticiones : " + reservations.ErrorMessage);
}
}
});
}
private void InitViewModel()
{
MailBoxHandler += OnMailBoxHandler;
MailboxName = ViewModelUri.ToString();
RegisterMailBox(MailboxName);
base.GridIdentifier = GridIdentifiers.ReservationRequestGrid;
SubSystem = DataSubSystem.BookingSubsystem;
EventManager.RegisterObserverSubsystem(EventSubsystem.BookingSubsystemVm, this);
EventManager.RegisterObserverSubsystem("ReservationRequests", this);
OpenCommand = new DelegateCommand <object>(OpenCurrentItem);
SummaryView = new IncrementalList <ReservationRequestSummary>(LoadMoreItems);
_payloadInterpeterReload = new PayloadInterpeter <ReservationRequestSummary>();
_payloadInterpeterReload.Init = (value, packet, insertion) =>
{
switch (packet.PayloadType)
{
case DataPayLoad.Type.UpdateView:
StartAndNotify();
break;
}
;
};
_payloadInterpeterReload.CleanUp = (key, system, name) =>
{
// up to now.
};
_payloadInterpeter = new PayloadInterpeter <KarveDataServices.IReservationRequest>();
InitPayLoadInterpeter(_payloadInterpeter);
RegisterToolBar();
StartAndNotify();
}
/// <summary>
/// StartAndNotify.
/// </summary>
public void StartAndNotify()
{
_bookingSummaryCompletion = NotifyTaskCompletion.Create <IEnumerable <BookingSummaryViewObject> >(
_bookingDataService.GetPagedSummaryDoAsync(1, DefaultPageSize), (sender, ev) =>
{
if (sender is INotifyTaskCompletion <IEnumerable <BookingSummaryViewObject> > bookingSummary)
{
if (bookingSummary.IsFaulted)
{
DialogService?.ShowErrorMessage("Cannot load booking summary: " + bookingSummary.ErrorMessage);
return;
}
var booking = bookingSummary.Result;
var maxItems = _bookingDataService.NumberItems;
PageCount = _bookingDataService.NumberPage;
ItemCounts = maxItems.ToString();
var bookingList = new IncrementalList <BookingSummaryViewObject>(LoadMoreItems)
{
MaxItemCount = (int)maxItems
};
bookingList.LoadItems(booking);
SummaryView = bookingList;
}
});
}
/// <summary>
/// Load Data Transfer All. Violate SRP.
/// </summary>
/// <returns></returns>
private async Task <IEnumerable <Dto> > LoadDtoAll()
{
IEnumerable <Dto> list = null;
try
{
HelperView?.Clear();
var countItem = await _helperDataServices.GetItemsCount <Entity>();
var currentList = new IncrementalList <Dto>(LoadMoreItems)
{
MaxItemCount = countItem
};
var tmplist = await _helperDataServices.GetPagedSummaryDoAsync <Dto, Entity>(1, PageSize);
HelperView = currentList;
HelperView.LoadItems(tmplist);
list = currentList;
}
catch (Exception e)
{
throw new DataLayerException(e.Message, e);
}
if (list == null)
{
return(null);
}
return(list);
}
/// <summary>
/// This function uses a query filter, it gets resolved and return an incremental list of the data views.
/// </summary>
/// <param name="filter">clause on the where in which you can filter</param>
/// <returns>A list of objects</returns>
public override async Task <object> FilterDataAsync(string filter)
{
_currentFilter = filter;
using (var dbConnection = _sqlExecutor.OpenNewDbConnection())
{
if (dbConnection != null)
{
throw new DataAccessLayerException("");
}
// Get first the number of pages
var resultPages = await dbConnection.GetPageCount <Entity>(PageSize).ConfigureAwait(false);
PageCount = resultPages.Item2;
// Get the the defu
var resultSet = await dbConnection.GetPagedAsync <Entity>(1, PageSize, filter).ConfigureAwait(false);
var dtoResultSet = _mapper.Map <IEnumerable <Entity>, IEnumerable <Dto> >(resultSet);
_incrementalList = new IncrementalList <Dto>(LoadMoreItems)
{
MaxItemCount = resultPages.Item2
};
_incrementalList.LoadItems(dtoResultSet);
FilterEventResult?.Invoke(_incrementalList);
return(dtoResultSet);
}
}
private void LoadAllCountries()
{
/* There are at most 200 countries in the world today.
* So no incremental loading is needed. Perforance test showed up that the grid freezed
* after 1000 items.
*/
_loader = new HelperLoader <CountryDto, Country>(DataServices);
CountryDto = _loader.HelperView;
_loader.LoadAll();
var list = from country in _loader.HelperView
from province in HelperView
where province.Country == country.Code
select new ProvinciaDto()
{
Name = province.Name,
Code = province.Code,
Country = province.Country,
Capital = province.Capital,
Prefix = province.Prefix,
CountryValue = new CountryDto()
{
Code = country.Code,
CountryName = country.CountryName
}
};
HelperView = new IncrementalList <ProvinciaDto>(LoadMoreItems);
HelperView.LoadItems(list);
}
private void InitViewModel()
{
// each grid needs an unique identifier for setting the grid change in the database.
GridIdentifier = GridIdentifiers.ClientSummaryGrid;
_clientEventTask += OnNotifyIncrementalList <ClientSummaryExtended>;
_clientDataLoaded += OnClientDataLoaded;
SummaryView = new IncrementalList <ClientSummaryExtended>(LoadMoreItems);
StartAndNotify();
}
public DriversControlViewModel(IDataServices services, IRegionManager manager) : base(services)
{
_regionManager = manager;
_clientDataServices = DataServices.GetClientDataServices();
GoBackCommand = new DelegateCommand(GoBack);
GoForwardCommand = new DelegateCommand(GoForward);
_drivers = new IncrementalList <ClientSummaryExtended>(LoadMoreItems);
_notifyTaskCompletion = NotifyTaskCompletion.Create <IEnumerable <ClientSummaryExtended> >(_clientDataServices.GetPagedSummaryDoAsync(0, DefaultPageSize), PagingEvent);
}
/// <summary>
/// This allows you to have a filter.
/// </summary>
/// <param name="_sqlExecutor">SqlExeutor.</param>
public DataFilterService(ISqlExecutor sqlExecutor, IMapper mapper, IDialogService dialogService) : base(dialogService)
{
_incrementalList = new IncrementalList <Dto>(LoadMoreItems);
_queryStoreFactory = new QueryStoreFactory();
_mapper = mapper;
_sqlExecutor = sqlExecutor;
_dialogService = dialogService;
PageSize = 500;
PageCount = 0;
}
/// <summary>
/// Execute an assist given its tag.
/// </summary>
/// <param name="name">Tag to be used.</param>
/// <param name="arg">Argument to be used.</param>
/// <returns></returns>
public async Task <IncrementalList <DataTransfer> > ExecuteAssist(string name, object arg)
{
var value = _assistMapper.TryGetValue(name, out Func <object, Task <object> > transfer);
var emptyValue = new IncrementalList <DataTransfer>((uint x, int y) => { });
if (value)
{
return(await transfer.Invoke(arg) as IncrementalList <DataTransfer>);
}
return(emptyValue);
}
/// <summary>
/// Handle the notification of the driver event.
/// </summary>
/// <param name="sender">Sender of the drivers.</param>
/// <param name="e">Event coming</param>
private void OnDriverUpdate(object sender, PropertyChangedEventArgs e)
{
if (sender is INotifyTaskCompletion <IEnumerable <ClientSummaryExtended> > value)
{
if (value.IsSuccessfullyCompleted)
{
DriversList = new IncrementalList <ClientSummaryExtended>(LoadMoreDrivers);
DriversList.LoadItems(value.Task.Result);
}
}
}
/// <summary>
/// This enable incremental load of the data.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="result"></param>
protected override void SetResult <T>(IEnumerable <T> result)
{
var resultValue = result as IEnumerable <CommissionAgentSummaryViewObject>;
_commissionAgentSummaryDto = new IncrementalList <CommissionAgentSummaryViewObject>(LoadMoreItems)
{
MaxItemCount = resultValue.Count()
};
_commissionAgentSummaryDto.LoadItems(resultValue);
SummaryView = _commissionAgentSummaryDto;
}
private void InitViewModel()
{
MessageHandlerMailBox += MessageHandler;
SummaryView = new IncrementalList <VehicleSummaryViewObject>(LoadMoreItems);
StartAndNotify();
_vehicleEventTask += OnNotifyIncrementalList <VehicleSummaryViewObject>;
PagingEvent += OnPagedEvent;
EventManager.RegisterMailBox(EventSubsystem.VehichleSummaryVm, MessageHandlerMailBox);
// Register the current subsystem to the toolbar.
ActiveSubSystem();
StartAndNotify();
}
protected override void SetResult <T>(IEnumerable <T> result)
{
_clientSummaryDtos = result as IEnumerable <ClientSummaryExtended>;
var maxItems = _clientDataServices.NumberItems;
PageCount = _clientDataServices.NumberPage;
var summaryList = new IncrementalList <ClientSummaryExtended>(LoadMoreItems)
{
MaxItemCount = (int)maxItems
};
summaryList.LoadItems(_clientSummaryDtos);
SummaryView = summaryList;
}
protected override void SetResult <T>(IEnumerable <T> result)
{
// TODO: fix this correctly. This shall call the company paged configuration.
PageCount = (_companyDataServices.NumberPage == 0) ? 1: _companyDataServices.NumberPage;
var maxItems = _companyDataServices.NumberItems;
var list = new IncrementalList <CompanySummaryDto>(LoadMoreItems)
{
MaxItemCount = (int)maxItems
};
var summary = result as IEnumerable <CompanySummaryDto>;
list.LoadItems(summary);
SummaryView = list;
}
/// <summary>
/// CityCountryDto
/// </summary>
/// <param name="obj"></param>
public async void OnCityCountry(object obj)
{
IHelperDataServices helperData = DataServices.GetHelperDataServices();
IEnumerable <CountryViewObject> countries = await helperData.GetMappedAllAsyncHelper <CountryViewObject, Country>();
IncrementalList <CityViewObject> cities = HelperView;
CityCountryDto = from l in countries
from r in cities
where l.CountryCode == r.Country.CountryCode
select new CityCountryDto()
{
City = r, Country = l
};
}
private void _gridSorter_OnInitPage(IEnumerable <CompanySummaryDto> result)
{
PageCount = (_companyDataServices.NumberPage == 0) ? 1 : _companyDataServices.NumberPage;
var maxItems = _companyDataServices.NumberItems;
if (result.Count() > 0)
{
var list = new IncrementalList <CompanySummaryDto>(_gridSorter.Loader)
{
MaxItemCount = (int)maxItems
};
list.LoadItems(result);
SummaryView = list;
}
}
private void _gridSorter_OnInitPage(IEnumerable <SupplierSummaryDto> page)
{
PageCount = (_supplierDataServices.NumberPage == 0) ? 1 : _supplierDataServices.NumberPage;
var maxItems = _supplierDataServices.NumberItems;
if (page.Count() > 0)
{
var list = new IncrementalList <SupplierSummaryDto>(_gridSorter.Loader)
{
MaxItemCount = (int)maxItems
};
list.LoadItems(page);
SummaryView = list;
}
}
protected override void OnPagedEvent(object sender, PropertyChangedEventArgs e)
{
if (sender is INotifyTaskCompletion <IEnumerable <ClientSummaryExtended> > clientSummary && clientSummary.IsSuccessfullyCompleted)
{
var orders = clientSummary.Result;
if (!Drivers.Any())
{
Drivers = new IncrementalList <ClientSummaryExtended>(LoadMoreItems)
{
MaxItemCount = (int)_clientDataServices.NumberItems
};
}
Drivers.LoadItems(orders);
RaisePropertyChanged("Drivers");
}
}
/// <summary>
/// This load a data transfer object.
/// </summary>
/// <param name="query">This load a dto.</param>
/// <returns></returns>
private async Task <IEnumerable <Dto> > LoadDto(string query)
{
// we want to make in a way that we will not show more
var loaded = await _helperDataServices.GetPagedQueryDoAsync <Entity>(query, 1, PageSize).ConfigureAwait(false);
var dtoLoaded = _mapper.Map <IEnumerable <Entity>, IEnumerable <Dto> >(loaded);
var countItem = await _helperDataServices.GetItemsCount <Entity>();
var currentList = new IncrementalList <Dto>(LoadMoreItems)
{
MaxItemCount = countItem
};
currentList.LoadItems(dtoLoaded);
HelperView = currentList;
return(currentList);
}
protected override void SetResult <T>(IEnumerable <T> result)
{
switch (result)
{
case IEnumerable <BookingSummaryViewObject> booking:
var maxItems = _bookingDataService.NumberItems;
PageCount = _bookingDataService.NumberPage;
ItemCounts = maxItems.ToString();
var bookingList = new IncrementalList <BookingSummaryViewObject>(LoadMoreItems)
{
MaxItemCount = (int)maxItems
};
bookingList.LoadItems(booking);
SummaryView = bookingList;
break;
}
}
public IncrementalLoadingViewModel()
{
string uri = "http://services.odata.org/Northwind/Northwind.svc/";
if (IsConnectedToInternet())
{
gridSource = new IncrementalList <Order>(LoadMoreItems)
{
MaxItemCount = 1000
};
northwindEntity = new NorthwindEntities(new Uri(uri));
}
else
{
NoNetwork = true;
IsBusy = false;
}
}
/// <summary>
/// Unity
/// </summary>
/// <param name="unityContainer">Container </param>
public TestMainWindowViewModel(IUnityContainer unityContainer, IDataServices dataServices, ISqlExecutor executor)
{
_clientDataServices = dataServices.GetClientDataServices();
_domainFactory = AbstractDomainWrapperFactory.GetFactory(dataServices);
_unityContainer = unityContainer;
evSummaryCompleted += OnEventCompleted;
SourceView = new IncrementalList <ClientSummaryExtended>(LoadMoreItems)
{
MaxItemCount = 10000
};
//Controller = _unityContainer.Resolve<RequestController>();
ItemChangedCommand = new DelegateCommand <Dictionary <string, object> >(OnItemChangedCommand);
AssistCommand = new DelegateCommand <object>(OnAssistCommand);
GridCommand = new DelegateCommand <object>(OnGridFilterCommand);
_dataFilterService = new DataFilterSummaryService <ClientSummaryExtended>(null, executor);
_dataFilterService.FilterEventResult += _dataFilterService_FilterEventResult;
notifyTaskCompletion = NotifyTaskCompletion.Create(_clientDataServices.GetPagedSummaryDoAsync(1, 500), evSummaryCompleted);
}
public IncrementalLoadingViewModel ()
{
border = new UIView ();
this.lable = new UILabel ();
this.loaderindicator = new UIActivityIndicatorView ();
this.loaderindicator.Color = UIColor.FromRGB (255, 255, 255);
border.BackgroundColor = UIColor.FromRGB(70, 183, 118);
border.Add (lable);
border.Add (loaderindicator);
string uri = "http://services.odata.org/Northwind/Northwind.svc/";
if (CheckConnection (uri).Result) {
gridSource = new IncrementalList<Order> (LoadMoreItems) { MaxItemCount = 1000 };
northwindEntity = new NorthwindEntities (new Uri (uri));
} else {
NoNetwork = true;
IsBusy = false;
}
}
public IncrementalLoadingViewModel ( Context context)
{
progress = new MyProgressDialog (context);
string uri = "http://services.odata.org/Northwind/Northwind.svc/";
if (CheckConnection (uri).Result) {
gridSource = new IncrementalList<Order> (LoadMoreItems) { MaxItemCount = 1000 };
northwindEntity = new NorthwindEntities (new Uri (uri));
} else {
NoNetwork = true;
IsBusy = false;
}
}
