public void ShouldBeAbleToAccessNewlyAddedItem(int times)
{
var set = new AddressSet <int> {
0, 1, 2, 3
};
// we loop several turns on the full set
for (var j = 0; j < times; j++)
{
for (var i = 0; i < set.Count; i++)
{
var real = set.ToList()[i];
real.Should().Be(i);
}
}
// we add a new item into the set
set.Add(4);
// we loop again and everything is in set
for (var j = 0; j < times; j++)
{
// first we got the newly added out
set.Contains(4).Should().BeTrue();
for (var i = 0; i < set.Count; i++)
{
var real = set.ToList()[i];
real.Should().Be(i);
}
}
}
public void ShouldBeAbleToRemoveItem(int times)
{
var set = new AddressSet <int> {
0, 1, 2, 3
};
for (var j = 0; j < times; j++)
{
for (var i = 0; i < set.Count; i++)
{
var real = set.ToList()[i];
real.Should().Be(i);
}
}
set.Remove(3);
for (var j = 0; j < times; j++)
{
set.Contains(3).Should().BeFalse();
for (var i = 0; i < set.Count; i++)
{
var real = set.ToList()[i];
real.Should().Be(i);
}
}
}
/// <summary>
/// Create an address set
/// </summary>
public AddressSet CreateAddressSet(AD address, List <IResultDetail> dtls)
{
AddressSet retVal = new AddressSet();
AddressSet.AddressSetUse internalNameUse = ConvertAddressUse(address.Use, dtls);
if (address == null || address.IsNull)
{
return(null);
}
retVal.Use = internalNameUse;
// Create the parts
foreach (ADXP namePart in address.Part)
{
var pt = new AddressPart()
{
AddressValue = namePart.Value,
PartType = (AddressPart.AddressPartType)Enum.Parse(typeof(AddressPart.AddressPartType), namePart.Type.ToString())
};
if (pt.PartType == AddressPart.AddressPartType.AddressLine) // R1 doesn't use AL but SAL and the formatter
{
pt.PartType = AddressPart.AddressPartType.StreetAddressLine;
}
retVal.Parts.Add(pt);
}
if (address.UseablePeriod != null && !address.UseablePeriod.IsNull)
{
dtls.Add(new NotImplementedElementResultDetail("useablePeriod", "urn:hl7-org:v3"));
}
return(retVal);
}
public async Task <IActionResult> ToExcel([FromBody] Excel excel)
{
IEnumerable <ClientSetEntity> clients = _context.ClientSetEntity;
IEnumerable <AddressSet> addresses = _context.AddressSet;
List <ClientSetEntity> clientsRes = new List <ClientSetEntity>();
ClientSetEntity clnt = new ClientSetEntity();
AddressSet adr = new AddressSet();
for (int i = 0; i < excel.Ids.Count(); i++)
{
clnt = clients.FirstOrDefault(u => u.Id == excel.Ids[i]);
adr = addresses.FirstOrDefault(u => u.Id == clnt.LegalAddressId);
adr.ClientSetEntity = null;
clnt.LegalAddress = adr;
clientsRes.Add(clnt);
}
var fileDownloadName = "Юрид лица.xlsx";
using (var package = createExcelPackage(clientsRes))
{
package.SaveAs(new FileInfo(Path.Combine(@"C:\Users\user\Downloads", fileDownloadName)));
}
return(Ok());
}
public OnlineStat()
{
InitializeComponent();
initIndicator.Visibility = Visibility.Hidden;
var mySqlConfig = new IpPortConfig
{
Ip = Settings.Default.mysql_ip,
Port = Settings.Default.mysql_port
};
var worldConfig = new IpPortConfig
{
Ip = Settings.Default.world_ip,
Port = Settings.Default.world_port
};
var addressSet = new AddressSet
{
LoadStatOnline = string.Format(Settings.Default.api_url + "?_key={0}&_url=online", Settings.Default.skey_api),
};
_addressSet = addressSet;
_mySqlConfig = mySqlConfig;
_worldConfig = worldConfig;
_launcher = new LauncherLogic(addressSet, mySqlConfig, worldConfig);
_launcher.StatOnline += Launcher_OnStatOnline;
_webClientFactory = new WebClientFactory();
_web = _webClientFactory.Create();
}
/// <summary>
/// Create an address from the specified address set
/// </summary>
public AD CreateAD(AddressSet addressSet, List <IResultDetail> dtls)
{
if (addressSet == null)
{
return new AD()
{
NullFlavor = MARC.Everest.DataTypes.NullFlavor.NoInformation
}
}
;
AD retVal = new AD();
retVal.Use = new SET <CS <PostalAddressUse> >();
foreach (var kv in ComponentUtil.m_addressUseMap)
{
if ((kv.Value & addressSet.Use) != 0)
{
retVal.Use.Add(kv.Key);
}
}
if (retVal.Use.IsEmpty)
{
retVal.Use = null;
}
foreach (var pt in addressSet.Parts)
{
retVal.Part.Add(new ADXP(pt.AddressValue, (AddressPartType)Enum.Parse(typeof(AddressPartType), pt.PartType.ToString())));
}
return(retVal);
}
public async Task <IActionResult> ToExcel([FromBody] Excel excel)
{
IEnumerable <ObjectSetFlat> flats = _context.ObjectSetFlat;
IEnumerable <AddressSet> addresses = _context.AddressSet;
IEnumerable <ObjectSet> objects = _context.ObjectSet;
List <ObjectSetFlat> flatsRes = new List <ObjectSetFlat>();
ObjectSetFlat flt = new ObjectSetFlat();
ObjectSet obj = new ObjectSet();
AddressSet adr = new AddressSet();
for (int i = 0; i < excel.Ids.Count(); i++)
{
flt = flats.FirstOrDefault(u => u.Id == excel.Ids[i]);
adr = addresses.FirstOrDefault(u => u.Id == flt.AddressId);
adr.ObjectSetFlat = null;
flt.Address = adr;
obj = objects.FirstOrDefault(u => u.Id == flt.Id);
obj.ObjectSetFlat = null;
flt.IdNavigation = obj;
flatsRes.Add(flt);
}
var fileDownloadName = "Квартиры.xlsx";
using (var package = createExcelPackage(flatsRes))
{
package.SaveAs(new FileInfo(Path.Combine(@"C:\Users\user\Downloads", fileDownloadName)));
}
return(Ok());
}
public async Task <IActionResult> PutAddressSet([FromRoute] int id, [FromBody] AddressSet addressSet)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != addressSet.Id)
{
return(BadRequest());
}
_context.Entry(addressSet).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AddressSetExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private string getAddress(AddressSet adr)
{
string res = "";
res = adr.Street + ", " + adr.House;
return(res);
}
public ActionResult DeleteConfirmed(int id)
{
AddressSet addressSet = db.AddressSet.Find(id);
db.AddressSet.Remove(addressSet);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void ShouldAddNew()
{
// ReSharper disable once UseObjectOrCollectionInitializer
var set = new AddressSet <int>();
set.Add(1);
set.Count.Should().Be(1);
set.ToList().Should().ContainInOrder(1);
}
public void ShouldRemove()
{
var set = new AddressSet <int> {
0, 1, 2, 3
};
set.Remove(0);
set.Remove(2);
set.ToList().Should().ContainInOrder(1, 3);
}
public void ShouldNotMoveIfNotExists()
{
var set = new AddressSet <int> {
0, 1
};
set.Remove(3);
set.Count.Should().Be(2);
set.ToList().Should().ContainInOrder(0, 1);
}
public ActionResult Edit([Bind(Include = "Id,Country,Region,City")] AddressSet addressSet)
{
if (ModelState.IsValid)
{
db.Entry(addressSet).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(addressSet));
}
/// <summary>
/// Convert address set
/// </summary>
internal List <Address> ConvertAddressSet(AddressSet addr)
{
List <Address> retVal = new List <Address>();
foreach (var use in Enum.GetValues(typeof(AddressSet.AddressSetUse)))
{
if (((int)use == 0 && addr.Use == 0) ^ ((int)use != 0 && addr.Use.HasFlag((AddressSet.AddressSetUse)use)))
{
Address adEntry = new Address();
// An address can have multiple uses
if ((AddressSet.AddressSetUse)use != AddressSet.AddressSetUse.Search)
{
adEntry.Use = new PrimitiveCode <string>(HackishCodeMapping.ReverseLookup(HackishCodeMapping.ADDRESS_USE, (AddressSet.AddressSetUse)use));
if (adEntry.Use == null || adEntry.Use.Value == null)
{
adEntry.Use = new PrimitiveCode <string>();
adEntry.Use.Extension.Add(ExtensionUtil.CreateADUseExtension((AddressSet.AddressSetUse)use));
}
}
foreach (var pt in addr.Parts)
{
switch (pt.PartType)
{
case AddressPart.AddressPartType.AddressLine:
case AddressPart.AddressPartType.StreetAddressLine:
adEntry.Line.Add(pt.AddressValue);
break;
case AddressPart.AddressPartType.City:
adEntry.City = pt.AddressValue;
break;
case AddressPart.AddressPartType.Country:
adEntry.Country = pt.AddressValue;
break;
case AddressPart.AddressPartType.PostalCode:
adEntry.Zip = pt.AddressValue;
break;
case AddressPart.AddressPartType.State:
adEntry.State = pt.AddressValue;
break;
default: // Can't find a place to put it and don't want to lose data ... so stuff it into an extension
adEntry.Extension.Add(ExtensionUtil.CreateADExtension(pt));
break;
}
}
retVal.Add(adEntry);
}
}
return(retVal);
}
public ActionResult Create([Bind(Include = "Id,Country,Region,City")] AddressSet addressSet)
{
if (ModelState.IsValid)
{
db.AddressSet.Add(addressSet);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(addressSet));
}
public void ShouldProvideSnapshotWhenEmpty()
{
// Given
var set = new AddressSet <int>();
// When
var snaphost = set.Snaphost;
// Then
snaphost.Should().BeEmpty();
}
public async Task <IActionResult> PostAddressSet([FromBody] AddressSet addressSet)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.AddressSet.Add(addressSet);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAddressSet", new { id = addressSet.Id }, addressSet));
}
public PlanningCenterClient(PlanningCenterOptions options, PlanningCenterToken token)
{
System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12 | System.Net.SecurityProtocolType.Tls11;
People = new PeopleSet(options, token);
MaritalStatuses = new MaritalStatusSet(options, token);
Households = new HouseholdSet(options, token);
Emails = new EmailSet(options, token);
FieldDefinitions = new FieldDefinitionSet(options, token);
PhoneNumbers = new PhoneNumberSet(options, token);
Addresses = new AddressSet(options, token);
Campuses = new CampusSet(options, token);
Giving = new GivingRealm(options, token);
MembershipStatuses = new MembershipStatusSet(options, token);
}
public void ShouldNotAddIfAlreadyExists()
{
// ReSharper disable once UseObjectOrCollectionInitializer
var set = new AddressSet <int> {
0, 1, 2, 3
};
set.Add(0);
set.Add(1);
set.Add(2);
set.Add(3);
set.Count.Should().Be(4);
set.Should().ContainInOrder(0, 1, 2, 3);
}
// GET: AddressSets/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AddressSet addressSet = db.AddressSet.Find(id);
if (addressSet == null)
{
return(HttpNotFound());
}
return(View(addressSet));
}
public void ShouldProvideSnapshot()
{
// Given
var set = new AddressSet <int> {
0, 1, 2
};
// When
var snaphost = set.Snaphost;
// Then
snaphost.Should().HaveCount(3);
snaphost.Should().ContainInOrder(0, 1, 2);
}
public void ShouldClear()
{
// Given
var set = new AddressSet <int> {
0, 1, 2, 3
};
set.Should().NotBeEmpty();
// When
set.Clear();
// Then
set.Should().BeEmpty();
}
/// <summary>
/// Match address
/// </summary>
internal static float MatchAddress(AddressSet a, AddressSet b)
{
if (a == null || b == null && a != b)
{
return(0.0f);
}
int nMatched = 0;
foreach (var part in a.Parts)
{
nMatched += b.Parts.Count(o => o.PartType == part.PartType && o.AddressValue == part.AddressValue);
}
return((float)nMatched / a.Parts.Count);
}
public IEnumerable <ClientSetIndividual> GetClientSetIndividual()
{
IEnumerable <AddressSet> addresses = _context.AddressSet;
IEnumerable <ClientSetIndividual> individuals = _context.ClientSetIndividual;
AddressSet adr = new AddressSet();
ClientSetIndividual ind = new ClientSetIndividual();
for (int i = 0; i < individuals.Count(); i++)
{
adr = addresses.FirstOrDefault(u => u.Id == individuals.ElementAt(i).AddressOfResidenceId);
adr.ClientSetIndividual = null;
individuals.ElementAt(i).AddressOfResidence = adr;
}
return(individuals);
}
public IEnumerable <ClientSetEntity> GetClientSetEntity()
{
IEnumerable <AddressSet> addresses = _context.AddressSet;
IEnumerable <ClientSetEntity> entities = _context.ClientSetEntity;
AddressSet adr = new AddressSet();
ClientSetEntity ent = new ClientSetEntity();
for (int i = 0; i < entities.Count(); i++)
{
adr = addresses.FirstOrDefault(u => u.Id == entities.ElementAt(i).LegalAddressId);
adr.ClientSetEntity = null;
entities.ElementAt(i).LegalAddress = adr;
}
return(entities);
}
public void ShouldProvideSnapshotAfterUpdate()
{
// Given
var set = new AddressSet <int> {
0, 1, 2
};
// When
set.Remove(1);
set.Add(42);
var snaphost = set.Snaphost;
// Then
snaphost.Should().HaveCount(3);
snaphost.Should().ContainInOrder(0, 2, 42);
}
/// <summary>
/// Get an address set from the database
/// </summary>
public static AddressSet GetAddress(IDbConnection conn, IDbTransaction tx, decimal?addrSetId, bool loadFast)
{
IDbCommand cmd = CreateCommandStoredProc(conn, tx);
try
{
cmd.CommandText = "get_addr_set";
if (!loadFast)
{
cmd.CommandText += "_efft";
}
cmd.Parameters.Add(CreateParameterIn(cmd, "addr_set_id_in", DbType.Decimal, addrSetId));
// Execute a reader
IDataReader reader = cmd.ExecuteReader();
AddressSet retVal = new AddressSet()
{
Use = AddressSet.AddressSetUse.PhysicalVisit, Key = addrSetId.Value
};
// Populate set
while (reader.Read())
{
AddressPart part = new AddressPart();
part.AddressValue = Convert.ToString(reader["addr_cmp_value"]);
part.PartType = (AddressPart.AddressPartType)Convert.ToInt32(reader["addr_cmp_cls"]);
retVal.Parts.Add(part);
// Effective time
if (!loadFast && retVal.EffectiveTime == default(DateTime) && reader["efft_utc"] != DBNull.Value)
{
retVal.EffectiveTime = Convert.ToDateTime(reader["efft_utc"]);
if (reader["obslt_utc"] != DBNull.Value)
{
retVal.EffectiveTime = Convert.ToDateTime(reader["obslt_utc"]);
}
}
}
return(retVal);
}
finally
{
cmd.Dispose();
}
}
public async Task <IActionResult> ToExcel([FromBody] Excel excel)
{
IEnumerable <AddressSet> addresses = _context.AddressSet;
List <AddressSet> addressRes = new List <AddressSet>();
AddressSet usr = new AddressSet();
for (int i = 0; i < excel.Ids.Count(); i++)
{
usr = addresses.FirstOrDefault(u => u.Id == excel.Ids[i]);
addressRes.Add(usr);
}
var fileDownloadName = "Адреса.xlsx";
using (var package = createExcelPackage(addressRes))
{
package.SaveAs(new FileInfo(Path.Combine(@"C:\Users\user\Downloads", fileDownloadName)));
}
return(Ok());
}
public IEnumerable <ObjectSetFlat> GetObjectSetFlat()
{
IEnumerable <ObjectSetFlat> flats = _context.ObjectSetFlat;
IEnumerable <ObjectSet> objects = _context.ObjectSet;
IEnumerable <AddressSet> adresses = _context.AddressSet;
ObjectSetFlat flt = new ObjectSetFlat();
AddressSet adr = new AddressSet();
ObjectSet obj = new ObjectSet();
for (int i = 0; i < flats.Count(); i++)
{
adr = adresses.FirstOrDefault(u => u.Id == flats.ElementAt(i).AddressId);
adr.ObjectSetFlat = null;
flats.ElementAt(i).Address = adr;
obj = objects.FirstOrDefault(u => u.Id == flats.ElementAt(i).Id);
obj.ObjectSetFlat = null;
flats.ElementAt(i).IdNavigation = obj;
}
return(flats);
}
private String MatchAddress(out double matchingResult, AddressSet addressSet, ref String addressMasked )
{
matchingResult = 0;
double addressElementWeight = addressSet.Count > 0 ? 100.0 / addressSet.Count : 0;
String result = transactionAddressLine;
if (addressElementWeight > 0)
{
Regex rx;
foreach (var word in addressSet.wordComponents)
{
rx = new Regex(@"(^|[\s])" + word + @"([\s]|$)", RegexOptions.IgnoreCase);
if (rx.Matches(transactionAddressLine).Count > 0)
{
result = result.RemoveWords(word).RemoveMultipleWhiteSpaces();
matchingResult += addressElementWeight;
addressMasked = MaskString(word, '%', addressMasked);
}
}
}
if (!addressSet.postalCodeComponent.IsNullOrWhiteSpace())
{
if (result.Contains(addressSet.postalCodeComponent))
{
result = result.Replace(addressSet.postalCodeComponent, " ").RemoveMultipleWhiteSpaces();
addressMasked = MaskString(addressSet.postalCodeComponent.Replace(" ","@"), '%', addressMasked);
matchingResult += addressElementWeight;
}
else if (result.Contains(addressSet.postalCodeComponent.Replace(" ","")))
{
result = result.Replace(addressSet.postalCodeComponent.Replace(" ", "")," ").RemoveMultipleWhiteSpaces();
addressMasked = MaskString(addressSet.postalCodeComponent.Replace(" ", ""), '%', addressMasked);
matchingResult += addressElementWeight;
}
}
int housePosition = 0, apartmentPosition = 0;
bool houseMatched = false, apartmentMatched = false;
if (!addressSet.houseNumberComponent.IsNullOrWhiteSpace())
{
int tempPosition;
if (result.ContainsAsWord(addressSet.houseNumberComponent, out tempPosition))
{
//result = result.ReplaceFirstOccurence(addressSet.houseNumberComponent, " ").RemoveMultipleWhiteSpaces();
result = result.Remove(tempPosition, addressSet.houseNumberComponent.Length).RemoveMultipleWhiteSpaces().Trim();
addressMasked = MaskString(addressSet.houseNumberComponent, '%', addressMasked, out housePosition);
matchingResult += addressElementWeight;
houseMatched = true;
}
}
if (!addressSet.apartmentNumberComponent.IsNullOrWhiteSpace())
{
int tempPosition;
if (result.ContainsAsWord(addressSet.apartmentNumberComponent, out tempPosition))
{
//result = result.Replace(addressSet.apartmentNumberComponent, " ").RemoveMultipleWhiteSpaces();
result = result.Remove(tempPosition, addressSet.apartmentNumberComponent.Length).RemoveMultipleWhiteSpaces().Trim();
addressMasked = MaskString(addressSet.apartmentNumberComponent, '%', addressMasked, out apartmentPosition);
matchingResult += addressElementWeight;
apartmentMatched = true;
}
}
if (houseMatched && apartmentMatched && housePosition > apartmentPosition)
{
matchingResult -= 2 * addressElementWeight;
}
return result;
}
private void ArrangeAddressSet(AddressSet addressSet, String street, String postCode, String houseNumber, String apartmentNumber, String city)
{
GetWordsFromField(addressSet.wordComponents, city.PrepareString(WORDSTOREMOVE));
GetWordsFromField(addressSet.wordComponents, street.PrepareString(WORDSTOREMOVE));
if (!postCode.IsNullOrWhiteSpace())
{
String tempCode = postCode.GetOnlyDigits();
if (tempCode.Length == 5)
{
addressSet.postalCodeComponent = tempCode.Substring(0, 2) + " " + tempCode.Substring(2, 3);
}
}
if (!String.IsNullOrEmpty(houseNumber))
{
addressSet.houseNumberComponent = houseNumber.PrepareString();
}
if (!String.IsNullOrEmpty(apartmentNumber))
{
addressSet.apartmentNumberComponent = apartmentNumber.PrepareString();
}
}
//other methods
public MatchingResult Match()
{
nameSet = new List<String>();
registrationAddressSet = new AddressSet();
mailAddressSet = new AddressSet();
MatchingResult result = new MatchingResult();
maskedAddressLine = transactionAddressLine.Mask();
transactionAddressLine = transactionAddressLine.PrepareString(WORDSTOREMOVE);
ChangeNullStringToEmpty(leaderEntry);
//Przygotowanie zbioru imion
GetWordsFromField(nameSet,leaderEntry.firstName.PrepareString(WORDSTOREMOVE));
GetWordsFromField(nameSet, leaderEntry.lastName.PrepareString(WORDSTOREMOVE));
ArrangeAddressSet(registrationAddressSet, leaderEntry.street, leaderEntry.postCode, leaderEntry.houseNumber, leaderEntry.apartmentNumber, leaderEntry.city);
ArrangeAddressSet(mailAddressSet, leaderEntry.streetMail, leaderEntry.postCodeMail, leaderEntry.houseNumberMail, leaderEntry.apartmentNumberMail, leaderEntry.cityMail);
MatchName(result);
double registrationAddressMatchingResult;
String registrationAddressMasked = maskedAddressLine;
String registrationAddressLeftovers = MatchAddress(out registrationAddressMatchingResult, registrationAddressSet, ref registrationAddressMasked);
double mailAddressMatchingResult;
String mailAddressMasked = maskedAddressLine;
String mailAddressLeftOvers = MatchAddress(out mailAddressMatchingResult, mailAddressSet, ref mailAddressMasked);
if (registrationAddressMatchingResult > mailAddressMatchingResult)
{
result.addressMatchingResult = registrationAddressMatchingResult;
addressMatchingKind = AddressMatchingKind.REGISTRATION;
transactionAddressLine = registrationAddressLeftovers;
maskedAddressLine = registrationAddressMasked;
}
else
{
result.addressMatchingResult = mailAddressMatchingResult;
addressMatchingKind = AddressMatchingKind.MAIL;
transactionAddressLine = mailAddressLeftOvers;
maskedAddressLine = mailAddressMasked;
}
moreThanTwoWordsLeft = transactionAddressLine.Split(' ').Where(x => x.Length > 1).Count() >= 2;
int maximumNameIndex = maskedAddressLine.LastIndexOf('#');
int minimumAddressIndex = maskedAddressLine.IndexOf('%');
String between = string.Empty;
if (maximumNameIndex > minimumAddressIndex)
{
//Tu bym obniżył współczynnik matchingu bo coś jest nie tak i wysłałbym cały adres
result.namePart = String.Empty;
result.addressPart = String.Empty;
}
else
{
between = originalAddressLine.Mid(maximumNameIndex + 1, minimumAddressIndex - maximumNameIndex - 1); //originalAddressLine.Substring(maximumNameIndex+1, minimumAddressIndex - maximumNameIndex -1);
}
if (!Regex.IsMatch(between, @"[a-zA-Z/d]+")) //w środku nie ma żadnych znaków alfanumerycznych
{
result.namePart = originalAddressLine.Left(maximumNameIndex + 1);
result.addressPart = originalAddressLine.Right(originalAddressLine.Length - minimumAddressIndex);
}
else // w środku są znaki alfanumeryczne
{
if (!Regex.IsMatch(between, @"[a-zA-Z]+")) //w środku są same cyfry - na pewno nie jest to część imienia i nazwiska
{
result.namePart = originalAddressLine.Left(maximumNameIndex + 1);
result.addressPart = between + originalAddressLine.Right(originalAddressLine.Length - minimumAddressIndex);
}
else if (!Regex.IsMatch(between, @"[/d]+")) //w środku są same litery
{
//sprawdzam czy zaczyna się to od myślnika - zwykle jest to drugi człon imienia i nazwiska
if(Regex.IsMatch(between,@"([A-Za-z0-9]+\.)+[A-Za-z0-9]+"))
{
Regex rx = new Regex(@"([A-Za-z0-9]+\.)+[A-Za-z0-9]+");
MatchCollection mx = rx.Matches(between);
result.namePart = originalAddressLine.Left(maximumNameIndex + 1) + between.Left(mx[mx.Count - 1].Index + mx[mx.Count - 1].Length);
result.addressPart = between.Right(between.Length - mx[mx.Count - 1].Index - mx[mx.Count - 1].Length) + originalAddressLine.Right(originalAddressLine.Length - minimumAddressIndex);
}
//sprawdzam czy zaczyna się to od myślnika - zwykle jest to drugi człon imienia i nazwiska
else if (between.Replace(" ", "").StartsWith("-"))
{
String[] split = between.Split(new char[] { ' ' },StringSplitOptions.RemoveEmptyEntries);
if(split.Count() > 0)
{
result.namePart = originalAddressLine.Left(maximumNameIndex + 1) + split[0];
result.addressPart = String.Join(" ", split.Skip(1).Take(split.Count() - 1).ToArray())+ " " + originalAddressLine.Right(originalAddressLine.Length - minimumAddressIndex);
}
else
{
result.namePart = originalAddressLine.Left(maximumNameIndex + 1) + between;
result.addressPart = originalAddressLine.Right(originalAddressLine.Length - minimumAddressIndex);
}
}
//sprawdzam czy zaczyna się to od przecinka - zwykle kończy on człon imienia i nazwiska i rozpoczyna adres
else if (between.Replace(" ", "").StartsWith(","))
{
result.namePart = originalAddressLine.Left(maximumNameIndex + 1);
result.addressPart = between + originalAddressLine.Right(originalAddressLine.Length - minimumAddressIndex);
}
else
{
//jak zawiera skrót, to wszystko po lewej do name, od skrótu począwszy do addres
bool abbrFound = false;
String[] skroty = new String[] { "OS", "AL", "PL", "UL","ULICA","OSIEDLE","ALEJA","PLAC" };
foreach (String skrot in skroty)
{
String exact = String.Empty;
if (between.ContainsWord(skrot, ref exact))
{
String temp = between.ReplaceWords("|", skrot);
result.namePart = originalAddressLine.Left(maximumNameIndex + 1) + " " + temp.Left(temp.IndexOf("|"));
result.addressPart = exact + temp.Right(temp.Length - temp.IndexOf("|") - 1) + " " + originalAddressLine.Right(originalAddressLine.Length - minimumAddressIndex);
abbrFound = true;
break;
}
}
if (!abbrFound)//w środku same litery, nie zaczyna się od myślnika ani od przecinka - do adresu
{
//STARA OBSŁUGA : DO ADRESU
//result.namePart = originalAddressLine.Left(maximumNameIndex + 1);
//result.addressPart = between + originalAddressLine.Right(originalAddressLine.Length - minimumAddressIndex);
//NOWA OBSŁUGA : DO NAZWISKA
result.namePart = originalAddressLine.Left(maximumNameIndex + 1) + between;
result.addressPart = originalAddressLine.Right(originalAddressLine.Length - minimumAddressIndex);
}
}
}
else
{
// mamy litery i cyfry
// od cyfry począwszy w prawo do adresu
// przed cyframi do imienia
int firstOccurrenceOfDigit = between.IndexOfAny(new char [] {'0','1','2','3','4','5','6','7','8','9'});
result.namePart = originalAddressLine.Left(maximumNameIndex + 1) + between.Left(firstOccurrenceOfDigit);
result.addressPart = between.Right(between.Length - firstOccurrenceOfDigit) + originalAddressLine.Right(originalAddressLine.Length - minimumAddressIndex);
}
}
//TU PRZEROBIC, ABY ZGADZALO SIE Z TYM CO PL WYSYLAL DZIS DO BANKU
if (result.nameMatchingResult == 100 && result.addressMatchingResult == 100)
{
result.verificationStatus = MatchingResult.VerificationStatus.POSITIVE;
//entry.status = 2;
}
else if (result.nameMatchingResult == 100 || (result.nameMatchingResult > 49 && result.addressMatchingResult > 49))
{
result.verificationStatus = MatchingResult.VerificationStatus.TOFURTHERVERIFICATION;
//entry.status = 1;
}
else
{
result.verificationStatus = MatchingResult.VerificationStatus.NEGATIVE;
//entry.status = 3;
}
if (result.verificationStatus == MatchingResult.VerificationStatus.POSITIVE && moreThanTwoWordsLeft)
{
result.verificationStatus = MatchingResult.VerificationStatus.TOFURTHERVERIFICATION;
}
//ostatnia weryfikacja - do tej pory zapewnione jest, że wszystkie człony imienia i nazwiska znajdujące się w polach
//fistName i lastName znajdują się w linii adresowej
//teraz sprawdzam czy wszystkie czlony namePart znajdują się w polach firstName i lastName
if (result.verificationStatus == MatchingResult.VerificationStatus.POSITIVE)
{
Regex rx = new Regex("[A-Za-ząęćóźżśńłĄĘÓŹŻŚŃŁ]+", RegexOptions.CultureInvariant);
foreach (Match mt in rx.Matches(result.namePart))
{
if (!nameSet.Contains(mt.Value.PrepareString()))
{
result.verificationStatus = MatchingResult.VerificationStatus.TOFURTHERVERIFICATION;
break;
}
}
}
//Ostateczne wyczyszczenie - usunięcie wielokrotnych spacji i przycięcie
result.namePart = result.namePart.RemoveMultipleWhiteSpaces().Trim();
result.addressPart = result.addressPart.RemoveMultipleWhiteSpaces().Trim();
return result;
}
