/// <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);
}
}
