public override int GetHashCode()
{
int hash = 1;
if (StreetName.Length != 0)
{
hash ^= StreetName.GetHashCode();
}
if (BuildingNumber != 0)
{
hash ^= BuildingNumber.GetHashCode();
}
if (AddressLine.Length != 0)
{
hash ^= AddressLine.GetHashCode();
}
if (PostCode.Length != 0)
{
hash ^= PostCode.GetHashCode();
}
if (TownName.Length != 0)
{
hash ^= TownName.GetHashCode();
}
if (Country.Length != 0)
{
hash ^= Country.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public bool Equals(IAddress other)
{
return(AddressLine.Equals(other.AddressLine, StringComparison.CurrentCultureIgnoreCase) &&
City.Equals(other.City, StringComparison.CurrentCultureIgnoreCase) &&
State.Equals(other.State) &&
ZipCode.Equals(other.ZipCode, StringComparison.CurrentCultureIgnoreCase));
}
public bool IsValid()
{
return(FirstName.Validate() &&
LastName.Validate() &&
Email.Validate() &&
AddressLine.Validate() &&
City.Validate() &&
Country.Validate());
}
public override int GetHashCode()
{
int hash = 0;
if (!string.IsNullOrWhiteSpace(AddressLine))
{
hash ^= AddressLine.GetHashCode();
}
if (!string.IsNullOrWhiteSpace(AdminDistrict))
{
hash ^= AdminDistrict.GetHashCode();
}
if (!string.IsNullOrWhiteSpace(AdminDistrict2))
{
hash ^= AdminDistrict2.GetHashCode();
}
if (!string.IsNullOrWhiteSpace(CountryRegion))
{
hash ^= CountryRegion.GetHashCode();
}
if (!string.IsNullOrWhiteSpace(FormattedAddress))
{
hash ^= FormattedAddress.GetHashCode();
}
if (!string.IsNullOrWhiteSpace(Locality))
{
hash ^= Locality.GetHashCode();
}
if (!string.IsNullOrWhiteSpace(PostalCode))
{
hash ^= PostalCode.GetHashCode();
}
if (!string.IsNullOrWhiteSpace(PostalTown))
{
hash ^= PostalTown.GetHashCode();
}
if (!string.IsNullOrWhiteSpace(Landmark))
{
hash ^= Landmark.GetHashCode();
}
if (!string.IsNullOrWhiteSpace(Neighborhood))
{
hash ^= Neighborhood.GetHashCode();
}
return(hash);
}
private AddressRM CreateAddressForAssociate(Commands.V1.Associate.Address.CreateForAssociate cmd)
{
Address address = Address.Create(_addresses++, cmd.IsActive, cmd.EndDate, AddressLine.Create(cmd.Address1),
AddressLine.Create(cmd.Address2), AddressLine.Create(cmd.Address3), AddressLine.Create(cmd.Address4),
cmd.IsPrimary, AddressTypeLookup.AddressTypes[cmd.AddressType], Attention.Create(cmd.Attention),
City.Create(cmd.City), cmd.Comments, PostalCode.Create(cmd.PostalCode),
StateCodeLookup.StateCodes[cmd.GeographicState]);
if (_repository.AddressExistsForAssociate(address, cmd.AssociateId))
{
throw new InvalidOperationException($"Address already exists for Operating Context {cmd.AssociateId}");
}
_repository.AddAddressForAssociate(address, cmd.AssociateId);
return(Conversions.GetAddressRM(address));
}
public Address ToAddress()
{
string street, streetNumber;
var addressLineMatch = AddressLineRegex.Match(AddressLine ?? string.Empty);
if (addressLineMatch.Success)
{
street = AddressLine?.Remove(addressLineMatch.Index, addressLineMatch.Length);
streetNumber = addressLineMatch.Groups[1].Value;
}
else
{
street = AddressLine;
streetNumber = string.Empty;
}
return(new Address()
{
FullAddress = FormattedAddress,
Country = CountryRegion,
PostalCode = PostalCode,
PostalCodeSuffix = string.Empty,
Neighborhood = string.Empty,
Locality = Locality,
SubLocality = string.Empty,
Street = street,
StreetNumber = streetNumber,
AdministrativeArea = new Dictionary <int, string>()
{
{ 1, AdminDistrict },
{ 2, AdminDistrict2 },
{ 3, AdminDistrict3 },
{ 4, AdminDistrict4 },
{ 5, string.Empty }
}
});
}
public static Address Create(int addressId, bool isActive, DateTime endDate, AddressLine address1,
AddressLine address2, AddressLine address3, AddressLine address4, bool isPrimary, AddressTypeLookup addressType,
Attention attention, City city, string comments, PostalCode postalCode, StateCodeLookup stateCode)
{
return(new Address
{
Id = addressId,
IsActive = isActive,
EndDate = endDate,
Address1 = address1,
Address2 = address2,
Address3 = address3,
Address4 = address4,
IsPrimary = isPrimary,
AddressTypeId = addressType.AddressTypeId,
Attention = attention,
City = city,
Comments = comments,
PostalCode = postalCode,
StateCodeId = stateCode.StateCodeId
});
}
public queryUPRNRequest1(string CallerToken, string addressLine1, string addressLine2, string addressLine3, string town, string postCode)
{
if (CallerToken == null || CallerToken == string.Empty || CallerToken == "")
{
throw new System.ArgumentException("Parameter cannot be null", "CallerToken");
}
queryUPRN myQueryUPRN = new queryUPRN();
myQueryUPRN.CallerToken = CallerToken;
myQueryUPRN.queryUPRNRequest = new QueryUPRNRequest();
myQueryUPRN.queryUPRNRequest.RequestBody = new RequestBody();
AddressDetails myAddressDetails = new AddressDetails();
AddressLine myAddressLine = new AddressLine();
myAddressLine.AddressLine1 = addressLine1;
myAddressLine.AddressLine2 = addressLine2;
myAddressLine.AddressLine3 = addressLine3;
myAddressDetails.AddressLine = myAddressLine;
myAddressDetails.PostCode = postCode;
myAddressDetails.Town = town;
myAddressDetails.LACodeSpecified = false;
myQueryUPRN.queryUPRNRequest.RequestBody.Item = myAddressDetails;
this.queryUPRN = myQueryUPRN;
}
public MotorolaSRECfile_long(string filename)
{
if (filename.ToLower().EndsWith(".s19") | filename.ToLower().EndsWith(".srec"))
{
}
else
{
FileErrorMessages.Add(" Файл имеет расширение отличное от .s19(.srec)");
}
try
{
StreamReader sr = new StreamReader(filename);
bool eof = false;
int lineNumber = 0;
while (!eof)
{
lineNumber++;
SRECline line = new SRECline(sr.ReadLine(), lineNumber);
//if (ErrorMessage == "") ErrorMessage = line.ErrorMessages;
FileErrorMessages.AddRange(line.LineErrorMessages);
if (line.CriticalErrors == true)
{
CriticalError = true;
}
switch (line.recordtype)
{
case SRECline.RecordType.DataRecordS19:
case SRECline.RecordType.DataRecordSREC:
AddressLineSorted.Add((long)(line.address), line.data);
AddressLine.Add((long)(line.address), line.data);
int ij = 0;
foreach (byte bt in line.data)
{
AddressByteSorted.Add((long)(line.address + ij), line.data[ij]);
ij++;
}
break;
case SRECline.RecordType.EndOfFileS19:
case SRECline.RecordType.EndOfFileSREC:
eof = true;
break;
}
if (sr.EndOfStream)
{
eof = true;
}
}
if (AddressByteSorted.Count != 0)
{
foreach (KeyValuePair <long, byte> dabs in AddressByteSorted)
{
Addresses.Add(dabs.Key);
Bytes.Add(dabs.Value);
}
for (int i = 0; i < AddressByteSorted.Count; i++)
{
if (Addresses[i] < minAddress)
{
minAddress = Addresses[i];
}
}
for (int i = 0; i < AddressByteSorted.Count; i++)
{
if (Addresses[i] > maxAddress)
{
maxAddress = Addresses[i];
}
}
}
else
{
FileErrorMessages.Add(" Файл не имеет адресов.");
minAddress = maxAddress = long.MinValue;
}
sr.Close();
sr.Dispose();
}
catch (Exception ex)
{
ErrorMessage = ex.Message;
CriticalError = true;
}
}
public IntelHEXfile_long(string filename)
{
if (filename.ToLower().EndsWith(".hex") != true)
{
FileErrorMessages.Add(" Файл имеет расширение отличное от hex");
}
try
{
StreamReader sr = new StreamReader(filename);
bool eof = false;
int lineNumber = 0;
while (!eof)
{
lineNumber++;
HEXline line = new HEXline(sr.ReadLine(), lineNumber);
//if (ErrorMessage == "") ErrorMessage = line.ErrorMessages;
FileErrorMessages.AddRange(line.LineErrorMessages);
if (line.CriticalErrors == true)
{
CriticalError = true;
}
switch (line.recordtype)
{
case HEXline.RecordType.ExtendedLinearAddress:
ex_lin_address = (long)line.data[0];
ex_lin_address = (long)ex_lin_address << 8;
ex_lin_address = (long)(ex_lin_address + (long)line.data[1]);
ex_lin_address = (long)ex_lin_address << 16;
break;
case HEXline.RecordType.DataRecord:
//data.AddRange(line.data);
AddressLineSorted.Add((long)(line.address + ex_lin_address), line.data);
AddressLine.Add((long)(line.address + ex_lin_address), line.data);
int ij = 0;
foreach (byte bt in line.data)
{
AddressByteSorted.Add((long)(line.address + ex_lin_address + ij), line.data[ij]);
ij++;
}
break;
case HEXline.RecordType.EndOfFile:
eof = true;
break;
}
if (sr.EndOfStream)
{
eof = true;
}
}
if (AddressByteSorted.Count != 0)
{
foreach (KeyValuePair <long, byte> dabs in AddressByteSorted)
{
Addresses.Add(dabs.Key);
Bytes.Add(dabs.Value);
}
for (int i = 0; i < AddressByteSorted.Count; i++)
{
if (Addresses[i] < minAddress)
{
minAddress = Addresses[i];
}
}
for (int i = 0; i < AddressByteSorted.Count; i++)
{
if (Addresses[i] > maxAddress)
{
maxAddress = Addresses[i];
}
}
}
else
{
FileErrorMessages.Add(" Файл не имеет адресов.");
minAddress = maxAddress = long.MinValue;
}
sr.Close();
sr.Dispose();
}
catch (Exception ex)
{
ErrorMessage = ex.Message;
CriticalError = true;
}
} //constructor IntelHEXfile_long(string filename)
/// <inheritdoc />
protected override int GetHashCodeCore()
{
return(AddressLine.GetHashCode());
}
public Address(string line1, string line2, string postcode)
{
Line1 = new AddressLine(line1);
Line2 = new AddressLine(line2);
Postcode = new PostcodeField(postcode);
}
public Address()
{
Country = new Country();
AddressLine = new AddressLine();
}
