Example #1
0
        protected async override void OnStepCommand()
        {
            if (ValidateForm())
            {
                if (_collectedInputsArgs != null)
                {
                    ResetCancellationTokenSource(ref _signUpCancellationTokenSource);
                    CancellationTokenSource cancellationTokenSource = _signUpCancellationTokenSource;

                    Guid busyKey = Guid.NewGuid();
                    SetBusy(busyKey, true);

                    try {
                        AuthenticationResult signUpResult = await _identityService.SignUpAsync(_collectedInputsArgs, cancellationTokenSource.Token);

                        if (signUpResult != null)
                        {
                            if (signUpResult.IsSucceed)
                            {
                                await NavigationService.InitializeAsync();
                            }
                            else
                            {
                                ServerError = signUpResult.Errors.LastOrDefault().Item2;
                            }
                        }
                        else
                        {
                            Debugger.Break();
                            await NavigationService.GoBackAsync();
                        }
                    }
                    catch (Exception ex) {
                        try {
                            HttpRequestExceptionResult httpRequestExceptionResult = JsonConvert.DeserializeObject <HttpRequestExceptionResult>(ex.Message);
                            if (httpRequestExceptionResult != null)
                            {
                                ServerError = httpRequestExceptionResult.Message;
                            }
                        }
                        catch (Exception) {
                            ServerError = ResourceLoader[nameof(AppStrings.TryLate)].Value;
                        }

                        Debug.WriteLine($"ERROR:{ex.Message}");
                        Debugger.Break();
                    }
                    SetBusy(busyKey, false);
                }
            }
        }
Example #2
0
        private async void AnalysePhotoAsync()
        {
            Guid busyKey = Guid.NewGuid();

            SetBusy(busyKey, true);
            PickedImage targetImage = null;

            ResetCancellationTokenSource(ref _analysePhotoCancellationTokenSource);
            CancellationTokenSource cancellationTokenSource = _analysePhotoCancellationTokenSource;

            try {
                using (var file = await _pickMediaService.TakePhotoAsync()) {
                    if (file != null)
                    {
                        List <string> results = await _visionService.AnalyzeImageForText(file);

                        if (results != null && results.Any())
                        {
                            List <string> parsedResult = results.ParseVisionResult();

                            targetImage = await _pickMediaService.BuildPickedImageAsync(file);

                            if (targetImage != null)
                            {
                                FormDataContent formDataContent = new FormDataContent {
                                    Content      = parsedResult,
                                    MediaContent = targetImage
                                };

                                List <DriveAuto> driveAutoDetails =
                                    await _driveAutoService.SearchDriveAutoByCognitiveAsync(formDataContent, cancellationTokenSource.Token);

                                if (driveAutoDetails != null)
                                {
                                    DriveAutoDetails = driveAutoDetails.ToObservableCollection();
                                    HasResult        = true;
                                }
                                else
                                {
                                    HasResult    = false;
                                    ErrorMessage = string.Empty;
                                }
                            }
                        }
                        else
                        {
                            HasResult    = false;
                            ErrorMessage = ResourceLoader.GetString(nameof(AppStrings.TryMore)).Value;
                        }
                        file.Dispose();
                    }
                }
            }
            catch (Exception ex) {
                Debug.WriteLine($"ERROR: -{ex.Message}");
                Debugger.Break();
                try {
                    HttpRequestExceptionResult httpRequestExceptionResult = JsonConvert.DeserializeObject <HttpRequestExceptionResult>(ex.Message);
                    HasResult    = false;
                    ErrorMessage = httpRequestExceptionResult.Message;
                }
                catch (Exception exc) {
                    Debug.WriteLine($"ERROR: -{exc.Message}");
                    Debugger.Break();
                    BackCommand.Execute(null);
                }
            }
            SetBusy(busyKey, false);

            if (targetImage == null)
            {
                BackCommand.Execute(null);
            }
        }