public async Task <Subscription> ChangeAddressAsync(long id, ChangeAddressRequest changeAddressRequest)
        {
            ValidateModel(changeAddressRequest);

            var response = await PostAsJsonAsync($"/subscriptions/{id}/change_address", JsonConvert.SerializeObject(changeAddressRequest)).ConfigureAwait(false);

            return(JsonConvert.DeserializeObject <SubscriptionResponse>(
                       await response.Content.ReadAsStringAsync().ConfigureAwait(false)).Subscription);
        }
        public async Task <ChangeAddressResponse> ChangeAddressAsync(ChangeAddressRequest request)
        {
            await _client.OpenAsync();

            var response = await _client.changeAddressAsync(request.Password, request.CompanyId, request.BranchCode,
                                                            request.PostalCode, request.Address, request.ChangeAddressFormFileName, request.RentalContractFileName,
                                                            request.OfficialNewspaperFileName, request.ChangeAddressForm, request.RentalContract,
                                                            request.OfficialNewspaper);

            await _client.CloseAsync();

            return(JsonConvert.DeserializeObject <ChangeAddressResponse>(response));
        }
        public virtual async Task <IStatusResponse> ChangeAddressAsync(
            ChangeAddressRequest model, CancellationToken token = default)
        {
            model.ArgumentNullCheck(nameof(model));

            using (var scope = TransactionFactory.CreateTransaction())
            {
                var result = await service.ChangeAddressAsync(model, token)
                             .ConfigureAwaitFalse();

                scope.Complete();

                return(result);
            }
        }
Beispiel #4
0
        public async Task <IActionResult> Change(
            [FromServices] AddressCrabEditClient editClient,
            [FromServices] LegacyContext context,
            [FromServices] IStreamStore streamStore,
            [FromRoute] string lokaleIdentificator,
            [FromBody] ChangeAddressRequest request,
            CancellationToken cancellationToken)
        {
            // TODO: Turn this into proper VBR API Validation
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var persistentLocalId = int.Parse(lokaleIdentificator);

            // todo: should become position from bus.Dispatch
            var position = await streamStore.ReadHeadPosition(cancellationToken);

            var addressId = context
                            .CrabIdToPersistentLocalIds
                            .Single(item => item.PersistentLocalId == persistentLocalId);

            CrabEditClientResult crabEditResult;

            if (addressId.HouseNumberId.HasValue)
            {
                crabEditResult = await editClient.ChangeHouseNumber(addressId.HouseNumberId.Value, request, cancellationToken);
            }
            else if (addressId.SubaddressId.HasValue)
            {
                crabEditResult = await editClient.ChangeSubaddress(addressId.SubaddressId.Value, request, cancellationToken);
            }
            else
            {
                throw new InvalidOperationException();
            }

            return(AcceptedWithPosition(
                       position,
                       crabEditResult.ExecutionTime));
        }
Beispiel #5
0
        public virtual async Task <IStatusResponse> ChangeAddressAsync(
            ChangeAddressRequest model, CancellationToken token = default)
        {
            model.ArgumentNullCheck(nameof(model));

            var entity = await store.GetEntityAsync(model.Id, token);

            IStatusResponse response;

            if (entity == null)
            {
                response = NotFoundStatusResponse(model.Id);
            }
            else
            {
                model.Address.UpdateEntity(entity.Address);
                await context.SaveChangesAsync(token);

                response = new StatusResponse(entity.Id);
            }

            return(response);
        }
        public async Task <CrabEditClientResult> ChangeSubaddress(
            int subaddressId,
            ChangeAddressRequest request,
            CancellationToken cancellationToken)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            var updateResponse = await _client.Update(
                new EditSubaddress
            {
                SubaddressId       = subaddressId,
                OfficiallyAssigned = request.OfficiallyAssigned,
                Position           = MapPosition(request.Position),
                PostalCode         = request.PostalCode.AsIdentifier().Map(IdentifierMappings.PostalCode),
                Status             = request.Status.AsIdentifier().Map(IdentifierMappings.AddressStatus),
                IsCorrection       = false,
            },
                cancellationToken);

            return(CrabEditClientResult.From(updateResponse));
        }
        public async Task <ActionResult> ChangeAddress(ChangeAddressRequestDto input)
        {
            #region Check Validations

            if (input.ChangeAddressForm == null)
            {
                ModelState.AddModelError(nameof(ChangeAddressRequestDto.ChangeAddressForm),
                                         "فرم درخواست تغيير آدرس شعبه را وارد نمایید");
            }

            if (input.RentalContract == null)
            {
                ModelState.AddModelError(nameof(ChangeAddressRequestDto.RentalContract),
                                         "قرارداد اجاره نامه را وارد نمایید");
            }

            if (input.OfficialNewspaper == null)
            {
                ModelState.AddModelError(nameof(ChangeAddressRequestDto.OfficialNewspaper),
                                         "روزنامه رسمی ثبت شرکت را وارد نمایید");
            }

            if (!ModelState.IsValid)
            {
                ViewBag.Result  = false;
                ViewBag.Message = "لطفا اطلاعات ضروری را وارد نمایید";
                return(View(input));
            }

            #endregion

            #region Create Request

            var request = new ChangeAddressRequest
            {
                Password   = input.Password,
                CompanyId  = input.CompanyId,
                BranchCode = input.BranchCode,
                PostalCode = input.PostalCode,
                Address    = input.Address,
            };

            #endregion

            #region Convert Uploaded Photos To Base64 And Add To Request

            await using (var ms = new MemoryStream())
            {
                input.ChangeAddressForm.CopyTo(ms);
                var fileBytes = ms.ToArray();
                request.ChangeAddressForm         = Convert.ToBase64String(fileBytes);
                request.ChangeAddressFormFileName = input.ChangeAddressForm.FileName;
            }

            await using (var ms = new MemoryStream())
            {
                input.RentalContract.CopyTo(ms);
                var fileBytes = ms.ToArray();
                request.RentalContract         = Convert.ToBase64String(fileBytes);
                request.RentalContractFileName = input.RentalContract.FileName;
            }

            await using (var ms = new MemoryStream())
            {
                input.OfficialNewspaper.CopyTo(ms);
                var fileBytes = ms.ToArray();
                request.OfficialNewspaper         = Convert.ToBase64String(fileBytes);
                request.OfficialNewspaperFileName = input.OfficialNewspaper.FileName;
            }

            #endregion

            #region Call Webservice And Return Result

            var result = await _asnafBranchesApiClient.ChangeAddressAsync(request);

            if (result.Status == 1)
            {
                ViewBag.Result  = true;
                ViewBag.Message = $"درخواست شما با موفقیت ثبت شد، شماره پیگیری {result.RequestId}";
            }
            else
            {
                ViewBag.Result  = false;
                ViewBag.Message = result.Message;
            }

            return(View(input));

            #endregion
        }
 public async Task <IActionResult> PutAsync([FromRoute] int driverId,
                                            [FromRoute] int item, [FromBody] ChangeAddressRequest command) =>
 await SendAsync(command.ApplyIds(driverId, item));
Beispiel #9
0
        public async Task <IActionResult> PatchAddress([Required] ChangeAddressRequest model, CancellationToken token)
        {
            var result = await service.ChangeAddressAsync(model, token);

            return(GenerateResponse(result));
        }