public void ShouldReturnSucessWhenEditAddress()
{
var address = GetAddress();
string updatedDescription = "Edited Address";
string updatedZipCode = "12237-900";
AddressType?updatedType = AddressType.Billing;
string updatedStreet = $"Rodovia Presidente Dutra km 156";
string updatedNeighborhood = "Palmeiras de São José";
int updatedNumber = 310;
string updatedCity = "São José dos Campos";
string updatedState = "SP";
address.Edit(
updatedDescription,
updatedZipCode,
updatedType,
updatedStreet,
updatedNeighborhood,
updatedNumber,
updatedCity,
updatedState);
Assert.AreEqual(address.Description, updatedDescription);
Assert.AreEqual(address.ZipCode, updatedZipCode);
Assert.AreEqual(address.Type, updatedType);
Assert.AreEqual(address.Street, updatedStreet);
Assert.AreEqual(address.Neighborhood, updatedNeighborhood);
Assert.AreEqual(address.Number, updatedNumber);
Assert.AreEqual(address.City, updatedCity);
Assert.AreEqual(address.State, updatedState);
Assert.IsTrue(address.Valid);
}
public AddressCandidate(AddressType type, long address, int port)
{
this.type = new AddressType?(type);
this.address = new long?(address);
this.port = new int?(port);
this.extension = null;
}
public int CompareTo(AddressType?other)
{
if (other == null || other.GetType() != typeof(AddressType))
{
return(1);
}
return(string.Compare(Field, other.Field, StringComparison.Ordinal));
}
/// <summary>
/// Gets the addresses for <see cref="ApplicationUser"/> asynchronously.
/// </summary>
/// <param name="userId">The user identifier.</param>
/// <param name="addressType">Type of the address.</param>
/// <returns>List of <see cref="Address"/> for specified <see cref="ApplicationUser"/>.</returns>
public Task <IEnumerable <Address> > GetAddressesForUserAsync(Guid userId, AddressType?addressType)
{
if (addressType.HasValue)
{
return(_addressRepository.GetAsync(p => p.UserAddresses.Any(s => s.UserId == userId && s.AddressType == addressType.Value)));
}
return(_addressRepository.GetAsync(p => p.UserAddresses.Any(s => s.UserId == userId)));
}
/// <summary>
/// Метод пытается получить тип адреса из его строкого представления
/// </summary>
/// <param name="addressTypeString"></param>
/// <param name="addressTypeEnum"></param>
/// <returns></returns>
private bool TryGetAddressType(string addressTypeString, ref AddressType?addressTypeEnum)
{
if (!Enum.TryParse(typeof(AddressType), addressTypeString, out object addressType))
{
return(false);
}
addressTypeEnum = (AddressType)addressType;
return(true);
}
internal ShippingAddress(string streetAddress1, string streetAddress2, string streetAddress3, string city, string stateOrProvince, string country, string postalCode, string zipExtendedCode, string companyName, AddressType?addressType)
{
StreetAddress1 = streetAddress1;
StreetAddress2 = streetAddress2;
StreetAddress3 = streetAddress3;
City = city;
StateOrProvince = stateOrProvince;
Country = country;
PostalCode = postalCode;
ZipExtendedCode = zipExtendedCode;
CompanyName = companyName;
AddressType = addressType;
}
/// <summary>
/// Initializes a new instance of the ShippingAddress class.
/// </summary>
/// <param name="streetAddress1">Street Address line 1.</param>
/// <param name="country">Name of the Country.</param>
/// <param name="postalCode">Postal code.</param>
/// <param name="streetAddress2">Street Address line 2.</param>
/// <param name="streetAddress3">Street Address line 3.</param>
/// <param name="city">Name of the City.</param>
/// <param name="stateOrProvince">Name of the State or
/// Province.</param>
/// <param name="zipExtendedCode">Extended Zip Code.</param>
/// <param name="companyName">Name of the company.</param>
/// <param name="addressType">Type of address. Possible values include:
/// 'None', 'Residential', 'Commercial'</param>
public ShippingAddress(string streetAddress1, string country, string postalCode, string streetAddress2 = default(string), string streetAddress3 = default(string), string city = default(string), string stateOrProvince = default(string), string zipExtendedCode = default(string), string companyName = default(string), AddressType?addressType = default(AddressType?))
{
StreetAddress1 = streetAddress1;
StreetAddress2 = streetAddress2;
StreetAddress3 = streetAddress3;
City = city;
StateOrProvince = stateOrProvince;
Country = country;
PostalCode = postalCode;
ZipExtendedCode = zipExtendedCode;
CompanyName = companyName;
AddressType = addressType;
CustomInit();
}
public static IList <TAddress> GetAddresses <TAddress>(this IParty party, AddressType?type = null)
where TAddress : class, IAddress
{
var session = EntityHelper.GetSession(party);
var links = session.EntitySet <IAddressPartyLink>();
var query = links.Where(lnk => lnk.Party == party);
if (type != null)
{
query = query.Where(lnk => lnk.Type == type.Value);
}
var list = query.Select(lnk => lnk.Address).ToList();
return(list.Select(a => (TAddress)a).ToList());
}
internal Response(ReturnCode result,
string[] postalAddress,
string[] geographicAddress,
string[] vanityAddress,
string postcode,
int?addressId,
AddressType?addressType,
MatchLevel?matchLevel,
Request input,
Model.Link[] links)
{
if (links == null)
{
throw new ArgumentNullException("links");
}
Result = result;
PostalAddress = postalAddress;
GeographicAddress = geographicAddress;
VanityAddress = vanityAddress;
Postcode = postcode;
AddressId = addressId;
AddressType = addressType;
MatchLevel = matchLevel;
Input = input;
var newLinks = new List <Model.Link>();
foreach (Model.Link link in links)
{
Model.Link newLink;
switch (link.Rel)
{
case "self":
newLink = new Model.VerifyAddress.Link(link.Rel, link.Href);
break;
default:
newLink = link;
break;
}
newLinks.Add(newLink);
}
Links = newLinks.ToArray();
}
public static Address GetAddress(
string description = AddressTestsConstants.ValidDescription,
string zipCode = AddressTestsConstants.ValidZipCode,
AddressType?type = AddressTestsConstants.ValidType,
string street = AddressTestsConstants.ValidStreet,
string neighborhood = AddressTestsConstants.ValidNeighborhood,
int number = AddressTestsConstants.ValidNumber,
string city = AddressTestsConstants.ValidCity,
string state = AddressTestsConstants.ValidState)
=> new Address(
description: description,
zipCode: zipCode,
type: type,
street: street,
neighborhood: neighborhood,
number: number,
city: city,
state: state,
customerId: Guid.NewGuid());
public async Task <IActionResult> AddressBook(AddressType?showAddressType)
{
var customer = await HttpContext.GetMemberAsync();
var filter = new AddressFilter {
CustomerId = customer.Id
};
var addresses = await _addressService.ListAsync(filter);
var model = new AddressListModel
{
Filter = filter,
AddressType = showAddressType
};
await _appService.PrepareModelAsync(model, addresses.ToPageable());
return(PartialView("AddressBook", model));
}
public async Task <IActionResult> AddAddress(AddressEditModel model, AddressType?addressType)
{
var customer = await HttpContext.GetMemberAsync();
if (HttpMethods.IsGet(Request.Method))
{
ModelState.Clear();
if (addressType != null)
{
model.AddressTypes.Add(addressType.Value);
}
// Set predefined values when adding a new address.
model.FirstName = customer.FirstName;
model.LastName = customer.LastName;
model.Email = customer.Email;
model.PhoneNumber = customer.PhoneNumber;
model.Organization = customer.StoreName;
await _appService.PrepareModelAsync(model, null);
}
else if (HttpMethods.IsPost(Request.Method))
{
if (ModelState.IsValid)
{
var addresses = await _addressService.ListAsync(new AddressFilter { CustomerId = customer.Id });
var address = new Address();
await _appService.PrepareAddressAsync(address, model);
address.CustomerId = customer.Id;
await _addressService.CreateAsync(address);
await _addressService.ResolveAddressTypesAsync(address, addresses);
TempData.AddAlert(AlertMode.Notify, AlertType.Success, "Address was added.");
}
}
return(PartialView("AddressEdit", model));
}
/**
* Address validation method.
*
* @static
* @param {String/Hash} addr - Account address.
* @param {Number} type - NormalType / ContractType
*
* @return {Boolean} Is address has correct format.
*
* @example
* if ( Account.isValidAddress("n1QZMXSZtW7BUerroSms4axNfyBGyFGkrh5") ) {
* // some code
* };
*/
public static bool IsValidAddress(string address, AddressType?type = null)
{
byte[] addBytes;
try {
addBytes = Base58.Decode(address);
if (addBytes.Length != ADDRESS_LENGTH)
{
return(false);
}
if (Convert.ToUInt32(addBytes[0]) != ADDRESS_PREFIX)
{
return(false);
}
uint typeUint;
if (type.HasValue)
{
typeUint = Convert.ToUInt32(type.Value);
if (typeUint != Convert.ToUInt32(addBytes[1]))
{
return(false);
}
}
else
{
typeUint = Convert.ToUInt32(addBytes[1]);
}
if (typeUint != (uint)AddressType.ContractType && typeUint != (uint)AddressType.NormalType)
{
return(false);
}
var content = addBytes.Slice(0, 22);
var checksum = addBytes.Slice(addBytes.Length - 4);
return(ByteUtil.Compare(Sha3Util.Get256Hash(content).Slice(0, 4), checksum));
}
catch (Exception ex)
{
return(false);
}
}
internal Option(string displayName, int?addressId, AddressType?addressType, string postcode, OptionType optionType, Model.Link[] links)
{
if (string.IsNullOrWhiteSpace(displayName))
{
throw new ArgumentNullException("displayName");
}
if (links == null)
{
throw new ArgumentNullException("links");
}
DisplayName = displayName;
AddressId = addressId;
AddressType = addressType;
Postcode = postcode;
OptionType = optionType;
var newLinks = new List <Model.Link>();
foreach (Model.Link link in links)
{
Model.Link newLink;
switch (link.Rel)
{
case "next":
newLink = new Link(link.Rel, link.Href);
break;
default:
newLink = link;
break;
}
newLinks.Add(newLink);
}
Links = newLinks.ToArray();
}
private void GetRamLabelAddressAndType(int address, out int absoluteAddress, out AddressType?addressType)
{
if (address < 0x2000)
{
absoluteAddress = address;
addressType = AddressType.InternalRam;
}
else if (address >= _workRamStart && address <= _workRamEnd)
{
absoluteAddress = address - _workRamStart;
addressType = AddressType.WorkRam;
}
else if (address >= _saveRamStart && address <= _saveRamEnd)
{
absoluteAddress = address - _saveRamStart;
addressType = AddressType.SaveRam;
}
else
{
absoluteAddress = -1;
addressType = null;
}
}
public Address(
string description,
string zipCode,
AddressType?type,
string street,
string neighborhood,
int number,
string city,
string state,
Guid customerId)
{
this.Description = description;
this.ZipCode = zipCode;
this.Type = type;
this.Street = street;
this.Neighborhood = neighborhood;
this.Number = number;
this.City = city;
this.State = state;
this.CustomerId = customerId;
DoValidations();
}
public Address Edit(
string description,
string zipCode,
AddressType?type,
string street,
string neighborhood,
int number,
string city,
string state)
{
this.Description = description;
this.ZipCode = zipCode;
this.Type = type;
this.Street = street;
this.Neighborhood = neighborhood;
this.Number = number;
this.City = city;
this.State = state;
DoValidations();
return(this);
}
internal Response(ReturnCode result,
string postcode,
int?addressId,
AddressType?addressType,
MatchLevel matchLevel,
string[] postalAddress,
AddressElement[] postalAddressElements,
string[] geographicAddress,
AddressElement[] geographicAddressElements,
string[] vanityAddress,
AddressElement[] vanityAddressElements,
ReformattedAddressResult?reformattedAddressResult,
string[] reformattedAddress,
int totalOptions,
Option[] options,
Request input,
Model.Link[] links
)
{
if (links == null)
{
throw new ArgumentNullException("links");
}
Result = result;
Postcode = postcode;
AddressId = addressId;
AddressType = addressType;
MatchLevel = matchLevel;
PostalAddress = postalAddress;
PostalAddressElements = postalAddressElements;
GeographicAddress = geographicAddress;
GeographicAddressElements = geographicAddressElements;
VanityAddress = vanityAddress;
VanityAddressElements = vanityAddressElements;
ReformattedAddressResult = reformattedAddressResult;
ReformattedAddress = reformattedAddress;
TotalOptions = totalOptions;
Options = options;
Input = input;
var newLinks = new List <Model.Link>();
foreach (Model.Link link in links)
{
Model.Link newLink;
switch (link.Rel)
{
case "self":
newLink = new Model.PostcodeLookup.Link(link.Rel, link.Href);
break;
default:
newLink = link;
break;
}
newLinks.Add(newLink);
}
Links = newLinks.ToArray();
}
/// <summary>
/// Метод проверяет тип адреса, и, в случае успеха, возвращает клиента, к которому относится адрес и сам тип адреса, преобразуя его из типа "string" в тип "AddressType"
/// </summary>
/// <param name="addressViewModel"></param>
/// <param name="account"></param>
/// <param name="addressType"></param>
private bool TryCheckType(AccountAddressViewModel addressViewModel, out Account account, out AddressType?addressType)
{
account = null;
addressType = null;
if (string.IsNullOrEmpty(addressViewModel.AccountId) || !Guid.TryParse(addressViewModel.AccountId, out Guid accountId))
{
errors.Add("AccountNotFound", resManager.GetString("AccountNotFound"));
return(false);
}
account = context.Accounts.Include(addr => addr.AccountAddresses).FirstOrDefault(i => i.Id == accountId);
if (account == null)
{
errors.Add("AccountNotFound", resManager.GetString("AccountNotFound"));
return(false);
}
if (!TryGetAddressType(addressViewModel.AddressType, ref addressType))
{
errors.Add("AddressTypeWrong", resManager.GetString("AddressTypeWrong"));
return(false);
}
return(true);
}
public static IList <IAddress> GetAddresses(this IParty party, AddressType?type = null)
{
return(GetAddresses <IAddress>(party, type));
}
static void TestPlainCase()
{
var streets = new[] { "First", "Second", "Third" };
var codes = new[] { "001001", "002002", "003003", "004004" };
var extraNumbers = new int?[] { null, 1, 2, 3, 5, 8, 13, 21, 34 };
var addressTypes = new AddressType?[] { null, AddressType.Type1, AddressType.Type2 };
var dates = new DateTime?[] { null, DateTime.Now };
var guids = new Guid?[] { null, Guid.Empty };
var decimals = new decimal?[] { null, decimal.Zero };
var context = new BulkContext("DefaultConnection");
context.Database.ExecuteSqlCommand("TRUNCATE addresses cascade");
var data = Enumerable.Range(0, 100000)
.Select((x, i) => new Address()
{
StreetName = streets[i % streets.Length],
HouseNumber = i + 1,
PostalCode = codes[i % codes.Length],
ExtraHouseNumber = extraNumbers[i % extraNumbers.Length],
Type = addressTypes[i % addressTypes.Length],
Date = dates[i % dates.Length],
Guid = guids[i % guids.Length],
Dec = decimals[i % decimals.Length]
}).ToList();
var uploader = new NpgsqlBulkUploader(context);
context.Database.ExecuteSqlCommand("DELETE FROM addresses");
var sw = Stopwatch.StartNew();
HardcodedInsert(data, context);
sw.Stop();
Console.WriteLine($"Hardcoded solution inserted {data.Count} records for {sw.Elapsed }");
context.Database.ExecuteSqlCommand("DELETE FROM addresses");
sw = Stopwatch.StartNew();
uploader.Insert(data, InsertConflictAction.UpdateProperty <Address>(x => x.AddressId, x => x.Dec));
uploader.Insert(data, InsertConflictAction.DoNothing());
sw.Stop();
Console.WriteLine($"Dynamic solution inserted {data.Count} records for {sw.Elapsed }");
data.ForEach(x => x.HouseNumber += 1);
sw = Stopwatch.StartNew();
uploader.Update(data);
sw.Stop();
Console.WriteLine($"Dynamic solution updated {data.Count} records for {sw.Elapsed }");
TestViaInterfaceCase(data, context);
context.Database.ExecuteSqlCommand("TRUNCATE addresses CASCADE");
sw = Stopwatch.StartNew();
uploader.Import(data);
sw.Stop();
Console.WriteLine($"Dynamic solution imported {data.Count} records for {sw.Elapsed }");
// With transaction
context.Database.ExecuteSqlCommand("TRUNCATE addresses CASCADE");
using (var transaction = new TransactionScope())
{
uploader.Insert(data);
}
Trace.Assert(context.Addresses.Count() == 0);
sw = Stopwatch.StartNew();
uploader.Update(data);
sw.Stop();
Console.WriteLine($"Dynamic solution updated {data.Count} records for {sw.Elapsed } (after transaction scope)");
TestAsync(context, uploader, data).Wait();
}
internal static string ToSerializedValue(this AddressType?value)
{
return(value == null ? null : ((AddressType)value).ToSerializedValue());
}