public EvaluationRequestListViewModel(IEvlRequestService evlRequestService, IUserDialogs userDialogs, IPageDialogService dialogService, IEventAggregator eventAggregator)
        {
            _evlRequestService = evlRequestService;
            _userDialogs       = userDialogs;
            _dialogService     = dialogService;
            _eventAggregator   = eventAggregator;

            ShowRequestProgress = new BitDelegateCommand <EvlRequestListItemSource>(async(request) =>
            {
                await NavigationService.NavigateAsync(nameof(EvlRequestProgressView), new NavigationParameters
                {
                    { nameof(EvlRequestListItemSource), request }
                });
            });

            OpenInquiryBox = new BitDelegateCommand(async() =>
            {
                eventAggregator.GetEvent <OpenInquiryPopupEvent>().Publish(new OpenInquiryPopupEvent());
            });

            Inquiry = new BitDelegateCommand(async() =>
            {
                inquiryCancellationTokenSource?.Cancel();
                inquiryCancellationTokenSource = new CancellationTokenSource();
                using (_userDialogs.Loading(ConstantStrings.Loading, cancelText: ConstantStrings.Loading_Cancel, onCancel: inquiryCancellationTokenSource.Cancel))
                {
                    if (string.IsNullOrEmpty(DocumentNumber) || !Requests.Any(r => r.Code == int.Parse(DocumentNumber)))
                    {
                        await dialogService.DisplayAlertAsync(ConstantStrings.Error, ConstantStrings.DocumentNumberIsInvalid, ConstantStrings.Ok);
                        DocumentNumber = null;
                        return;
                    }

                    EvlRequestDto requestDto = await evlRequestService.SearchByCode(int.Parse(DocumentNumber));

                    if (requestDto == null)
                    {
                        await dialogService.DisplayAlertAsync(ConstantStrings.Error, ConstantStrings.RequestDosentExist, ConstantStrings.Ok);
                        DocumentNumber = null;
                        return;
                    }
                    else
                    {
                        DocumentNumber = null;

                        eventAggregator.GetEvent <OpenInquiryPopupEvent>().Publish(new OpenInquiryPopupEvent());

                        INavigationParameters parameter = new NavigationParameters();
                        parameter.Add(nameof(EvlRequestListItemSource), new EvlRequestListItemSource
                        {
                            Code            = requestDto.Code,
                            RequestId       = requestDto.Id,
                            RequestTypeName = EnumHelper <EvlRequestType> .GetDisplayValue(requestDto.EvlRequestType)
                        });

                        await NavigationService.NavigateAsync(nameof(EvlRequestProgressView), parameter);
                    }
                }
            });
        }
Beispiel #2
0
        public EvlRequestWaitViewModel(
            IODataClient odataClient,
            IEvlRequestService evlRequestService,
            IDeviceService deviceService,
            IODataClient oDataClient,
            HttpClient httpClient,
            IDateTimeUtils dateTimeUtils,
            IInitialDataService initialDataService,
            IPageDialogService pageDialogService)
        {
            _odataClient        = odataClient;
            _evlRequestService  = evlRequestService;
            _pageDialogService  = pageDialogService;
            _initialDataService = initialDataService;
            _httpClient         = httpClient;
            _dateTimeUtils      = dateTimeUtils;

            GoToMain = new BitDelegateCommand(async() =>
            {
                await NavigationService.NavigateAsync($"/{nameof(NavigationPage)}/{nameof(MainMenuView)}");
            });

            Call = new BitDelegateCommand(async() =>
            {
                deviceService.OpenUri(new Uri("tel://" + ExpertMobileNo + ""));
            });

            //RatingValueChanged = new BitDelegateCommand<int>(async (value) =>
            //{
            //    await _pageDialogService.DisplayAlertAsync("", "RatingValueChanged : " + value.ToString(), ErrorMessages.Ok);
            //});
        }
        public EvlRequestProgressViewModel(IEvlRequestService evlRequestService, IUserDialogs userDialogs, IDateHelper dateHelper)
        {
            _evlRequestService = evlRequestService;
            _userDialogs       = userDialogs;
            _dateHelper        = dateHelper;

            ClosePopup = new BitDelegateCommand(async() =>
            {
                await NavigationService.GoBackAsync();
            });
        }
Beispiel #4
0
        public EvaluationRequestExpertRankViewModel(IEvlRequestService requestService)
        {
            SubmitRank = new BitDelegateCommand(async() =>
            {
                if (Request.RankValue != 0 || !string.IsNullOrEmpty(Request.RankDescription))
                {
                    await requestService.UpdateRank(Request);
                }

                await NavigationService.NavigateAsync($"/{nameof(NavigationPage)}/{nameof(MainMenuView)}");
            });
        }
        public EvaluationRequestWaitViewModel(IEvlRequestService evlRequestService, IPageDialogService dialogService)
        {
            _evlRequestService = evlRequestService;
            _dialogService     = dialogService;

            Cancel = new BitDelegateCommand(async() =>
            {
                if (await dialogService.DisplayAlertAsync(string.Empty, ConstantStrings.AreYouSureToCancel, ConstantStrings.Yes, ConstantStrings.No))
                {
                    await NavigationService.NavigateAsync($"/{nameof(NavigationPage)}/{nameof(MainMenuView)}");
                }
            });
        }
Beispiel #6
0
        public EvaluationRequestExpertViewModel(IEvlRequestService evlRequestService, IPageDialogService dialogService, ILicenseHelper licenseHelper)
        {
            _evlRequestService = evlRequestService;
            _licenseHelper     = licenseHelper;

            Call = new BitDelegateCommand(async() =>
            {
                Device.OpenUri(new Uri($"tel:{Expert.Expert.Mobile}"));
            });

            Cancel = new BitDelegateCommand(async() =>
            {
                if (await dialogService.DisplayAlertAsync(string.Empty, ConstantStrings.AreYouSureToCancel, ConstantStrings.Yes, ConstantStrings.No))
                {
                    await NavigationService.NavigateAsync($"/{nameof(NavigationPage)}/{nameof(MainMenuView)}");
                    return;
                }
            });
        }