public async Task AddShouldAddANewAddress()
        {
            var sut     = Factory.CreateClient();
            var address = new AddAddressModel
            {
                City    = AddressFixture.City,
                Country = AddressFixture.Country,
                Number  = AddressFixture.Number,
                State   = AddressFixture.State,
                ZipCode = AddressFixture.ZipCode,
                Street  = AddressFixture.Street
            };

            var serializedJson = JsonSerializer.Serialize(address);
            var contentJson    = new StringContent(serializedJson, Encoding.UTF8, "application/json");

            var result = await sut.PostAsync("Address/Add", contentJson);

            result.EnsureSuccessStatusCode();

            using var scope         = ServiceProvider.CreateScope();
            await using var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();

            Assert.NotEmpty(context.Addresses);
            Assert.Equal(1, context.Addresses.Count());
        }
Example #2
0
        public IActionResult UpdateSingleAddress([FromBody] AddAddressModel model, [FromRoute] int id)
        {
            var result = GetUserMasterDetails();

            if (result == null)
            {
                return(StatusCode(500));
            }

            if (model.MarkAsDefault != null && model.MarkAsDefault == true)
            {
                Repo.UnMarkUserAddressNotDefault(result.UserId);
            }

            var addressDetails = Mapper.Map <UserAddress>(model);

            Repo.UpdateParticularAddress(id, addressDetails);
            var saveResult = Repo.SaveData();

            if (saveResult == 1 || saveResult == 2 || saveResult == 0)
            {
                return(Ok());
            }

            return(StatusCode(500));
        }
Example #3
0
        public IActionResult AddAddress([FromBody] AddAddressModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var result = GetUserMasterDetails();

            if (result == null)
            {
                return(StatusCode(500));
            }

            var addressDetails = Mapper.Map <UserAddress>(model);

            addressDetails.UserId = result.UserId;

            Repo.AddDataToDataSet(addressDetails);
            if (model.MarkAsDefault != null && model.MarkAsDefault == true)
            {
                Repo.UnMarkUserAddressNotDefault(result.UserId);
            }

            var saveResult = Repo.SaveData();

            if (saveResult == 3)
            {
                return(StatusCode(500));
            }

            return(Created("api/users/address", model));
        }
        public async Task <ActionResult> Add(AddAddressModel model)
        {
            var address = model.GetAddress();
            var result  = await _addressService.SaveAsync(address);

            if (result is not SuccessResult <Guid> successResult)
            {
                return(FailResult(result));
            }
            if (await _unitOfWork.SaveChangesAsync())
            {
                return(CreatedAtAction(nameof(Get), new { uuid = successResult.Result }, null));
            }
            return(ErrorResult());
        }
Example #5
0
        public ServiceResult Add(AddAddressModel model)
        {
            var result = new ServiceResult();

            if (!ModelState.IsValid)
            {
                result.Code = ReasonCode.MISSING_REQUIRED_FIELDS;
                foreach (string error in ModelState.Values.SelectMany(v => v.Errors.Select(b => b.ErrorMessage)))
                {
                    result.Message += error + Environment.NewLine;
                }

                return(result);
            }

            var cpt = new CryptoAddressComponent();

            cpt.AddAddress(this.GetMerchantAccountId(), model.CryptoId, model.Address, model.Tag, model.Remark);



            return(result);
        }