public bool IsDetailValid(EvlRequestDto request, out string message)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            if (string.IsNullOrEmpty(request.OwnerFirstName))
            {
                message = $"{nameof(EvlRequestDto.OwnerFirstName)}IsEmpty";
                return(false);
            }

            if (string.IsNullOrEmpty(request.OwnerLastName))
            {
                message = $"{nameof(EvlRequestDto.OwnerLastName)}IsEmpty";
                return(false);
            }

            if (string.IsNullOrEmpty(request.InsurerNo))
            {
                message = $"{nameof(EvlRequestDto.InsurerNo)}IsEmpty";
                return(false);
            }

            if (string.IsNullOrEmpty(request.PlateNumber))
            {
                message = $"{nameof(EvlRequestDto.PlateNumber)}IsEmpty";
                return(false);
            }

            message = null;

            return(true);
        }
        public bool IsLostDetailValid(EvlRequestDto request, out string message)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            if (string.IsNullOrEmpty(request.LostFirstName))
            {
                message = $"{nameof(EvlRequestDto.LostFirstName)}IsEmpty";
                return(false);
            }

            if (string.IsNullOrEmpty(request.LostLastName))
            {
                message = $"{nameof(EvlRequestDto.LostLastName)}IsEmpty";
                return(false);
            }

            if (string.IsNullOrEmpty(request.LostPlateNumber))
            {
                message = $"{nameof(EvlRequestDto.LostPlateNumber)}IsEmpty";
                return(false);
            }

            if (request.LostCarId == 0)
            {
                message = $"{nameof(EvlRequestDto.LostCarId)}IsEmpty";
                return(false);
            }

            message = null;

            return(true);
        }
        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);
                    }
                }
            });
        }
Example #4
0
        public virtual async Task <EvlRequestDto> SubmitEvlRequest(CancellationToken cancellationToken)
        {
            if (!Request.Content.IsMimeMultipartContent())
            {
                throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
            }

            MultipartMemoryStreamProvider provider = new MultipartMemoryStreamProvider();

            await Request.Content.ReadAsMultipartAsync(provider, cancellationToken);

            bool          isFirstPart   = true;
            EvlRequestDto evlRequestDto = null;

            foreach (HttpContent requestPart in provider.Contents)
            {
                if (isFirstPart == true)
                {
                    evlRequestDto = JsonConvert.DeserializeObject <EvlRequestDto>(await requestPart.ReadAsStringAsync());

                    evlRequestDto.Status = EvlRequestStatus.SabteAvalie;

                    EvlRequest evlRequest = Mapper.FromDtoToEntity(evlRequestDto);
                    evlRequest.CustomerId = Guid.Parse(UserInformationProvider.GetCurrentUserId());

                    evlRequestDto = Mapper.FromEntityToDto(await EvlRequestsRepository.AddAsync(evlRequest, cancellationToken));

                    isFirstPart = false;

                    continue;
                }
                else
                {
                    byte[] data = await requestPart.ReadAsByteArrayAsync();

                    int typeId = int.Parse(Path.GetFileName(requestPart.Headers.ContentDisposition.FileName.Trim('\"')));

                    await EvlRequestFilesRepository.AddAsync(new EvlRequestFile
                    {
                        EvlRequestId = evlRequestDto.Id,
                        TypeId       = typeId,
                        File         = data
                    }, cancellationToken);
                }
            }

            if (evlRequestDto == null)
            {
                throw new BadRequestException($"{nameof(EvlRequestDto)} is null");
            }

            return(evlRequestDto);
        }
        public async Task LoginAndSubmitNewEvlRequestAndFindExpertForItTest()
        {
            using (SanaapTestEnvironment testEnv = new SanaapTestEnvironment())
            {
                TokenResponse token = await testEnv.Server.Login("1270340050", "09033610498", "SanaapResOwner", "secret");

                HttpClient httpClient = testEnv.Server.BuildHttpClient(token);

                MultipartFormDataContent content = new MultipartFormDataContent
                {
                    //new StringContent(JsonConvert.SerializeObject(new EvlRequestDto
                    //{
                    //    AccidentDate = DateTimeOffset.UtcNow,
                    //    CompanyId = 1,
                    //    AccidentReason = "Test",
                    //    InsuranceNumber = "123-456",
                    //    InsuranceTypeEnum = InsuranceType.Sales,
                    //    Latitude = 12,
                    //    Longitude = 12,
                    //    VehicleKindId = 1,
                    //    VehicleNumber = "ایران - ب 44 678"
                    //}), Encoding.UTF8, "application/json"),

                    { new StreamContent(File.OpenRead(@"C:\Users\SOFT\Desktop\Mohammad.png")), Guid.Parse("9bbd650e-3415-494d-b382-623a0840ab5a").ToString(), Guid.Parse("9bbd650e-3415-494d-b382-623a0840ab5a").ToString() }
                };

                HttpRequestMessage submitEvlRequest = new HttpRequestMessage(HttpMethod.Post, "api/evl-requests/submit-evl-request")
                {
                    Content = content
                };

                HttpResponseMessage submitEvlRequestExpertResponse = await httpClient.SendAsync(submitEvlRequest);

                submitEvlRequestExpertResponse.EnsureSuccessStatusCode();

                EvlRequestDto evlRequest = JsonConvert.DeserializeObject <EvlRequestDto>(await submitEvlRequestExpertResponse.Content.ReadAsStringAsync());

                IODataClient odataClient = testEnv.Server.BuildODataClient(odataRouteName: "Sanaap", token: token);

                EvlRequestExpertDto evlRequestExpert = await odataClient.Controller <EvlRequestExpertsController, EvlRequestExpertDto>()
                                                       .Function(nameof(EvlRequestExpertsController.FindEvlRequestExpert))
                                                       .Set(new { evlRequestId = evlRequest.Id })
                                                       .FindEntryAsync();

                evlRequestExpert = await odataClient.Controller <EvlRequestExpertsController, EvlRequestExpertDto>()
                                   .Function(nameof(EvlRequestExpertsController.FindEvlRequestExpert))
                                   .Set(new { evlRequestId = evlRequest.Id })
                                   .FindEntryAsync();
            }
        }