/// <summary> /// Devuelve el recurso cuyo id es pasado por parámetro. /// </summary> /// <param name="id"></param> /// <returns></returns> public Address Get(int id) { AddressMapper addressMapper = new AddressMapper(); Address address = addressMapper.Get(id); if (address == null) { string errorDescription = "No se ha encontrado la direcció con id " + id + "."; log.AddLogCritical("Get", errorDescription, this); AddError(new ResultBE(ResultBE.Type.NULL, errorDescription)); } return(address); }
public async Task <AddressDto> UpdateAsync(int userId, AddressDto dto) { var model = await _addressRepository.GetAsync(userId, dto.Id); if (model == null) { return(null); } AddressMapper.Map(dto, model); await _addressRepository.SaveChangesAsync(userId); // Return a fresh copy of the saved object. return(await GetAsync(userId, model.Id)); }
public void GivenCreateAdressFromAddressDTO_WhenGivenAnAddressDTOToCreate_ThenCreateAddress() { var memstub = Substitute.For <IMemberServices>(); CityDTO cityDTO = new CityDTO { ZIP = 2050, CityName = "Antwerpen", CountryName = "Belgium" }; AddressDTO addressDTO = new AddressDTO { StreetName = "test", StreetNumber = "5", CityDTO = cityDTO }; var newMapper = new AddressMapper(new CityMapper(memstub)); var result = newMapper.DTOToAddress(addressDTO); Assert.IsType <Address>(result); }
protected Word GetAnyPointerArg(Word word, AddressMapper mapper) { switch (word.Type) { case WordType.Value: return(new Word(WordType.AbsoluteAddr, mapper.Remap(word.Value))); case WordType.AbsoluteAddr: case WordType.RelativeAddr: return(word); default: throw new NotImplementedException(); } }
public BranchHook(bool isLink, Word[] args, AddressMapper mapper) { if (args.Length != 2) { throw new InvalidDataException("wrong arg count for BranchCommand"); } // expected args: // source : pointer to game code // dest : pointer to game code or to Kamek code var source = GetAbsoluteArg(args[0], mapper); var dest = GetAnyPointerArg(args[1], mapper); Commands.Add(new Commands.BranchCommand(source, dest, isLink)); }
public PatchExitHook(Word[] args, AddressMapper mapper) { if (args.Length != 2) { throw new InvalidDataException("PatchExitCommand requires two arguments"); } var function = args[0]; var dest = GetAnyPointerArg(args[1], mapper); if (!args[1].IsValue || args[1].Value != 0) { Commands.Add(new Commands.PatchExitCommand(function, dest)); } }
protected Word GetAbsoluteArg(Word word, AddressMapper mapper) { if (word.Type != WordType.AbsoluteAddr) { if (word.Type == WordType.Value) { return(new Word(WordType.AbsoluteAddr, mapper.Remap(word.Value))); } else { throw new InvalidDataException(string.Format("hook {0} requested an absolute address argument, but got {1}", this, word)); } } return(word); }
public void MapToVerintAddress_ShouldMapAutomaticallyPickedAddress() { //Arrange var address = new Address { PlaceRef = "123", Postcode = "SK13EX", SelectedAddress = "address" }; //Act var result = AddressMapper.MapToVerintAddress(address, "address", "placeRef", "postcode"); //Assert Assert.True(result.Exists(_ => _.FormFieldName == "address" && _.FormFieldValue == "address")); Assert.True(result.Exists(_ => _.FormFieldName == "placeRef" && _.FormFieldValue == "123")); Assert.True(result.Exists(_ => _.FormFieldName == "postcode" && _.FormFieldValue == "SK13EX")); }
public IActionResult UpdateAddress(int affiliateId, int id, [FromBody] UpdateAddressViewModel updateAddressViewModel) { if (id != updateAddressViewModel.Id || affiliateId != updateAddressViewModel.AffiliateId) { return(BadRequest()); } if (!_addressService.Exist(id, affiliateId)) { return(NotFound()); } var addressDTO = AddressMapper.UpdateAddressVMToDTO(updateAddressViewModel); _addressService.Update(addressDTO); return(NoContent()); }
public IActionResult CreateAddress(int affiliateId, [FromBody] CreateAddressViewModel createAddressViewModel) { if (affiliateId != createAddressViewModel.AffiliateId) { return(BadRequest()); } if (!_affiiliateService.Exist(affiliateId)) { return(NotFound()); } var addressDTO = AddressMapper.CreateAddressVMToDTO(createAddressViewModel); _addressService.Create(addressDTO); return(Ok(ModelState)); }
public void ToDomain() { string streetName = "Teststraat"; string houseNumber = "88B"; string postalCode = "3000"; string country = "Belgium"; Address address = new AddressMapper().ToDomain(new AddressDto() .WithStreetName(streetName) .WithHouseNumber(houseNumber) .WithPostalCode(postalCode) .WithCountry(country)); Assert.Equal(streetName, address.StreetName); Assert.Equal(houseNumber, address.HouseNumber); Assert.Equal(postalCode, address.PostalCode); Assert.Equal(country, address.Country); }
/// <summary> /// Persiste el elemento. /// </summary> /// <param name="map"></param> /// <returns></returns> public bool Save(Address address) { if (!IsValid(address)) { return(false); } AddressMapper addressMapper = new AddressMapper(); if (!addressMapper.Save(address)) { string errorDescription = "No se ha podido guardar la dirección."; log.AddLogCritical("Save", errorDescription, this); AddError(new ResultBE(ResultBE.Type.FAIL, errorDescription)); return(false); } return(true); }
public void MapToFosteringAddress_ShouldReturnAddressWithLine1() { //Arrange var entity = new CaseBuilder() .WithIntegrationFormField("postcode", "SK1 3XE") .WithIntegrationFormField("address", "Address line 1||") .WithIntegrationFormField("placeref", "") .Build(); //Act var result = AddressMapper.MapToFosteringAddress(entity.IntegrationFormFields, "address", "placeref", "postcode"); //Assert Assert.Equal("Address line 1", result.AddressLine1); Assert.Equal(string.Empty, result.AddressLine2); Assert.Equal(string.Empty, result.Town); Assert.Equal("SK1 3XE", result.Postcode); Assert.Equal(string.Empty, result.PlaceRef); }
public void MapToVerintAddress_ShouldReturnAddress() { // Arrange var address = new Address { AddressLine1 = "Line 1", AddressLine2 = "Line 2", Postcode = "SK13XE", Town = "Town" }; // Act var result = AddressMapper.MapToVerintAddress(address, "address", "placeRef", "postcode"); // Assert Assert.True(result.Exists(_ => _.FormFieldName == "address" && _.FormFieldValue == "Line 1|Line 2|Town")); Assert.True(result.Exists(_ => _.FormFieldName == "postcode" && _.FormFieldValue == "SK13XE")); Assert.True(result.Exists(_ => _.FormFieldName == "placeRef" && _.FormFieldValue == null)); }
public void InsertPizzaOrder(PizzaOrderDAO po) { List <Pizza> Pizza = new List <Pizza>(); List <List <Topping> > toppings = new List <List <Topping> >(); List <List <Cheese> > cheeses = new List <List <Cheese> >(); foreach (var item in po.Order.Pizzas) { Pizza.Add(PizzaMapper.PizzaDAO_Pizza(item)); toppings.Add(PizzaMapper.PizzaDAO_Topping(item)); cheeses.Add(PizzaMapper.PizzaDAO_Cheeses(item)); } data.InsertPizzaOrder(CustomerMapper.CustomerDAO_Customer(po.Customer), Pizza, toppings, cheeses, EmailMapper.EmailDAO_Email(po.Customer.Email), NameMapper.NameDAO_Name(po.Customer.Name), NumberMapper.NumberDAO_Number(po.Customer.Number), AddressMapper.AddressDAO_Address(po.Customer.Address)); }
public void ToDto() { string streetName = "Teststraat"; string houseNumber = "88B"; string postalCode = "3000"; string country = "Belgium"; AddressDto addressDto = new AddressMapper().ToDto(AddressBuilder.Address() .WithStreetName(streetName) .WithHouseNumber(houseNumber) .WithPostalCode(postalCode) .WithCountry(country) .Build()); Assert.Equal(streetName, addressDto.StreetName); Assert.Equal(houseNumber, addressDto.HouseNumber); Assert.Equal(postalCode, addressDto.PostalCode); Assert.Equal(country, addressDto.Country); }
public void MapToFosteringAddress_ShouldReturnTwoAddressLines() { // Arrange var integrationFormFields = new List <CustomField> { new CustomField("postcode", "SK1 3XE"), new CustomField("address", "Address line 1|Address line 2|"), new CustomField("placeref", "") }; // Act var result = AddressMapper.MapToFosteringAddress(integrationFormFields, "address", "placeref", "postcode"); //Assert Assert.Equal("Address line 1", result.AddressLine1); Assert.Equal("Address line 2", result.AddressLine2); Assert.Equal(string.Empty, result.Town); Assert.Equal("SK1 3XE", result.Postcode); Assert.Equal(string.Empty, result.PlaceRef); }
public CustomerAddressContract Process(GetCustomerAddressRequest input) { var parameter = new GetCustomerAddress { OrganizationId = input.OrganizationId, CustomerId = input.CustomerId, IsDeleted = input.IsDeleted ?? false, Id = input.Id }; _query.BuildQuery(parameter); using (DapperUnitOfWork.Begin()) { var contact = _runner.Run(_query); var result = AddressMapper.Map(contact); return(result); } }
public void GivenCreateListOfParkingLotDTOReturnsFromParkingLotList_WhenGivenListOfParkingLosts_ThenReturnListOfParkingLotDTOToReturn() { var memstub = Substitute.For <IMemberServices>(); var stubpark = Substitute.For <IParkingLotMapper>(); var stubAddress = Substitute.For <IAddressMapper>(); AddressMapper addressmap = new AddressMapper(new CityMapper(memstub)); ParkingLotMapper parkmap = new ParkingLotMapper(new AddressMapper(new CityMapper(memstub)), new ContactPersonMapper(new AddressMapper(new CityMapper(memstub)))); var city = City.CreateCity(2050, "Antwerpen", "Belgium"); var contactPerson = ContactPerson.CreateNewContactPerson("lasr", "peelman", Address.CreateAddress("test", "5", city), "*****@*****.**", "5454548564", "5456456456"); var parkinglot = ParkingLotBuilder.CreateNewParkingLot() .WithBuildingType(BuildingType.AboveGround) .WithCapacity(5) .WithContactPerson(contactPerson) .WithDivision(new Guid()) .WithName("lasr") .WithPricePerHour(5.00M) .WithAddress(Address.CreateAddress("test", "5", city)) .Build(); var parkinglot2 = ParkingLotBuilder.CreateNewParkingLot() .WithBuildingType(BuildingType.AboveGround) .WithCapacity(5) .WithContactPerson(contactPerson) .WithDivision(new Guid()) .WithName("lasr") .WithPricePerHour(5.00M) .WithAddress(Address.CreateAddress("test", "5", city)) .Build(); List <ParkingLot> newList = new List <ParkingLot>(); newList.Add(parkinglot); newList.Add(parkinglot2); var result = parkmap.CreateListOfParkingLotDTOReturnsFromParkingLotList(newList); Assert.IsType <List <ParkingLotDTO_Return> >(result); }
public AdresMatchScorableItem Map(AddressDetailItem source) { var streetName = _latestQueries.GetAllLatestStreetNames().Single(x => x.StreetNameId == source.StreetNameId); var municipality = _latestQueries.GetAllLatestMunicipalities().Single(x => x.NisCode == streetName.NisCode); var defaultStreetName = AddressMapper.GetDefaultStreetNameName(streetName, municipality.PrimaryLanguage); var homonym = AddressMapper.GetDefaultHomonymAddition(streetName, municipality.PrimaryLanguage); return(new AdresMatchScorableItem { AddressId = source.AddressId, Identificator = new AdresIdentificator(_responseOptions.Naamruimte, source.PersistentLocalId.ToString(), source.VersionTimestamp.ToBelgianDateTimeOffset()), Detail = string.Format(_responseOptions.DetailUrl, source.PersistentLocalId.Value.ToString()), Gemeente = new AdresMatchItemGemeente { ObjectId = municipality.NisCode, Detail = string.Format(_responseOptions.GemeenteDetailUrl, municipality.NisCode), Gemeentenaam = new Gemeentenaam(new GeografischeNaam(municipality.DefaultName.Value, municipality.DefaultName.Key)) }, Straatnaam = new AdresMatchItemStraatnaam { ObjectId = streetName.PersistentLocalId, Detail = string.Format(_responseOptions.StraatnaamDetailUrl, streetName.PersistentLocalId), Straatnaam = new Straatnaam(new GeografischeNaam(defaultStreetName.Value, defaultStreetName.Key)), }, HomoniemToevoeging = homonym == null ? null : new HomoniemToevoeging(new GeografischeNaam(homonym.Value.Value, homonym.Value.Key)), Postinfo = new AdresMatchItemPostinfo { ObjectId = source.PostalCode, Detail = string.Format(_responseOptions.PostInfoDetailUrl, source.PostalCode), }, Huisnummer = source.HouseNumber, Busnummer = source.BoxNumber, VolledigAdres = AddressMapper.GetVolledigAdres(source.HouseNumber, source.BoxNumber, source.PostalCode, streetName, municipality), AdresPositie = AddressMapper.GetAddressPoint(source.Position), PositieSpecificatie = AddressMapper.ConvertFromGeometrySpecification(source.PositionSpecification), PositieGeometrieMethode = AddressMapper.ConvertFromGeometryMethod(source.PositionMethod), AdresStatus = AddressMapper.ConvertFromAddressStatus(source.Status), OfficieelToegekend = source.OfficiallyAssigned, }); }
private static string BuildDescription(AddressSyndicationQueryResult address, string naamruimte) { if (!address.ContainsEvent && !address.ContainsObject) { return("No data embedded"); } var content = new SyndicationContent(); if (address.ContainsObject) { content.Object = new AddressSyndicationContent( address.AddressId, naamruimte, address.StreetNameId, address.PersistentLocalId, address.HouseNumber, address.BoxNumber, address.PostalCode, address.PointPosition == null ? null : AddressMapper.GetAddressPoint(address.PointPosition), address.GeometryMethod == null ? (PositieGeometrieMethode?)null : AddressMapper.ConvertFromGeometryMethod(address.GeometryMethod.Value), address.GeometrySpecification == null ? (PositieSpecificatie?)null : AddressMapper.ConvertFromGeometrySpecification(address.GeometrySpecification.Value), address.Status.ConvertFromAddressStatus(), address.LastChangedOn.ToBelgianDateTimeOffset(), address.IsComplete, address.IsOfficiallyAssigned, address.Organisation, address.Reason); } if (address.ContainsEvent) { var doc = new XmlDocument(); doc.LoadXml(address.EventDataAsXml); content.Event = doc.DocumentElement; } return(content.ToXml()); }
public void Approve_Approves_Mapping() { state.SetStruct($"MappingInfo:{secondaryAddress}", new MappingInfo { Primary = primaryAddress, Status = (int)Status.Pending }); mContractState.Setup(x => x.Message).Returns(new Message(contractAddress, ownerAddress, 0)); var contract = new AddressMapper(mContractState.Object, ownerAddress); contract.Approve(secondaryAddress); Assert.Equal(secondaryAddress, state.GetAddress($"SecondaryAddress:{primaryAddress}")); Assert.Equal(new MappingInfo { Primary = primaryAddress, Status = (int)Status.Approved }, state.GetStruct <MappingInfo>($"MappingInfo:{secondaryAddress}")); mContractLogger.Verify(m => m.Log(mContractState.Object, new AddressMappedLog { Primary = primaryAddress, Secondary = secondaryAddress })); }
public void PushtoDatabase(int columns, int rows, Worksheet worksheet) { Dictionary <string, int> columnNamesWithIndex = new Dictionary <string, int>(); for (int i = 1; i <= columns; i++) { columnNamesWithIndex.Add(worksheet.Cells[i][1].Value.ToString(), i); } var addressMapper = new AddressMapper(); var addressRepository = new AddressRepository(); var personMapper = new PersonMapper(); var personRepository = new PersonRepository(); var financialStateMapper = new FinancialStateMapper(); var financialStateRepository = new FinancialStateRepository(); var agrementMapper = new AgreementMapper(); var agreementRepository = new AgreementRepository(); var peselVerifier = new PeselVerifier(); for (int i = 2; i <= rows; i++) { var addressObject = addressMapper.MapAdress(worksheet, i, columnNamesWithIndex); var addressId = addressRepository.PushAddressesToDb(addressObject); var personObject = personMapper.MapPerson(worksheet, i, columnNamesWithIndex, addressId); var validPesel = peselVerifier.VerifyPesel(personObject.NationalIdentificationNumber); // validPesel -tutaj mam wartosc true albo false dla kazdego z peseli // dla ktorego robie walidacje w osobnej metodzie var personId = personRepository.PushPeopleToDb(personObject); var financialStateObject = financialStateMapper.MapFinancialState(worksheet, i, columnNamesWithIndex); var financialStateId = financialStateRepository.PushFinancialStatesToDb(financialStateObject); var agreementObject = agrementMapper.MapAgreement(worksheet, i, columnNamesWithIndex, personId, financialStateId); agreementRepository.PushAgreementsToDb(agreementObject); } }
public static Hook Create(Linker.HookData data, AddressMapper mapper) { switch (data.type) { case 1: return(new WriteHook(false, data.args, mapper)); case 2: return(new WriteHook(true, data.args, mapper)); case 3: return(new BranchHook(false, data.args, mapper)); case 4: return(new BranchHook(true, data.args, mapper)); case 5: return(new PatchExitHook(data.args, mapper)); default: throw new NotImplementedException("unknown command type"); } }
public AdresMatchScorableItem Map(StreetNameLatestItem source) { var municipality = _latestQueries.GetAllLatestMunicipalities().Single(x => x.NisCode == source.NisCode); var name = AddressMapper.GetDefaultStreetNameName(source, municipality.PrimaryLanguage); var homonym = AddressMapper.GetDefaultHomonymAddition(source, municipality.PrimaryLanguage); return new AdresMatchScorableItem { Gemeente = new AdresMatchItemGemeente { ObjectId = source.NisCode, Detail = string.Format(_responseOptions.GemeenteDetailUrl, source.NisCode), Gemeentenaam = new Gemeentenaam(new GeografischeNaam(municipality.DefaultName.Value, municipality.DefaultName.Key)) }, Straatnaam = new AdresMatchItemStraatnaam { ObjectId = source.PersistentLocalId, Detail = string.Format(_responseOptions.StraatnaamDetailUrl, source.PersistentLocalId), Straatnaam = new Straatnaam(new GeografischeNaam(name.Value, name.Key)), }, HomoniemToevoeging = homonym == null ? null : new HomoniemToevoeging(new GeografischeNaam(homonym.Value.Value, homonym.Value.Key)) }; }
private async Task CreateDeliveryRequestAsync(string transactionId, CreateOrderCommand command, CancellationToken cancellationToken) { var address = AddressMapper.ToDeliveryApiContract(command.Address); await PerformTransactionStepAsync( transactionId, t => t.DeliveryCreationStepDetails, async ct => { try { await deliveryApiClient.CreateDeliveryRequestAsync(transactionId, address, ct).ConfigureAwait(false); return(StepResult.Successful); } catch (SwaggerException <DeliveryAPI.ApiClient.ValidationProblemDetails> ) { return(StepResult.Abort); } }, cancellationToken) .ConfigureAwait(false); }
public IEnumerable <Customer> GetEntities() { var customersDb = _testDatabaseContext.Customer.Include("Address"); var customers = new List <Customer>(); foreach (var customer in customersDb) { var mappedCustomer = CustomerMapper.Map(customer); mappedCustomer.Addresses = new List <Address>(); foreach (var address in customer.Address) { var mappedAddress = AddressMapper.Map(address); mappedCustomer.Addresses.Add(mappedAddress); } customers.Add(mappedCustomer); } return(customers); }
public async Task <ETaskStatus> UpdateGpDetails(FosteringCaseGpDetailsUpdateModel model) { var firstApplicantFormFields = new FormFieldBuilder() .AddField("nameofgp", model.FirstApplicant.NameOfGp) .AddField("nameofpractice", model.FirstApplicant.NameOfGpPractice) .AddField("gpphonenumber", model.FirstApplicant.GpPhoneNumber) .AddField(EFosteringApplicationForm.GpDetails.GetFormStatusFieldName(), ETaskStatus.Completed.GetTaskStatus()) .Build(); firstApplicantFormFields.AddRange(AddressMapper.MapToVerintAddress(model.FirstApplicant.GpAddress, "addressofpractice", "placerefofpractice", "postcodeofpractice")); var secondApplicantFormFields = new List <IntegrationFormField>(); if (model.SecondApplicant != null) { secondApplicantFormFields = new FormFieldBuilder() .AddField("nameofgp2", model.SecondApplicant.NameOfGp) .AddField("nameofpractice2", model.SecondApplicant.NameOfGpPractice) .AddField("gpphonenumber2", model.SecondApplicant.GpPhoneNumber) .Build(); secondApplicantFormFields.AddRange(AddressMapper.MapToVerintAddress(model.SecondApplicant.GpAddress, "addressofpractice2", "placerefofpractice2", "postcodeofpractice2")); } var result = await _verintServiceGateway.UpdateCaseIntegrationFormField(new IntegrationFormFieldsUpdateModel { CaseReference = model.CaseReference, IntegrationFormFields = firstApplicantFormFields.Concat(secondApplicantFormFields).ToList(), IntegrationFormName = _applicationFormName }); if (result.StatusCode != HttpStatusCode.OK) { throw new Exception("Update Gp details failure"); } return(ETaskStatus.Completed); }
public IActionResult Finalize(OrderModel order) { DBContext _context = new DBContext(); AddressModel address = order.Address; _context.Update(AddressMapper.Mapper(address)); PaymentModel payment = order.Payment; if (order.Payment.Method == Models.Enums.PaymentMethodEnum.Pix || order.Payment.Method == Models.Enums.PaymentMethodEnum.BankSlip) { payment.Status = Models.Enums.PaymentStatusEnum.Pending; } if (order.Payment.Method == Models.Enums.PaymentMethodEnum.CreditCard) { payment.Status = Models.Enums.PaymentStatusEnum.Pay; } _context.Update(PaymentMapper.Mapper(payment)); _context.SaveChanges(); return(View("Finalize", order)); }
// Get One basic table // DEFAULT CRUD public AddressMapper GetAddress(int addressId) { var content = db.Addresses.FirstOrDefault(j => j.addressId == addressId); if (content == null) { return(null); } else { AddressMapper address = new AddressMapper { AddressId = content.addressId, Name = content.name, BuildingNumber = content.buildingNumber, StreetName = content.streetName, City = content.city, Zipcode = content.zipcode, State = content.state, Country = content.country }; return(address); } }