static void Main(string[] args)
{
var path = args.FirstOrDefault(x => !string.IsNullOrWhiteSpace(x));
System.Console.WriteLine($"Processing file {path}");
if (File.Exists(path))
{
using (var context = new AppDataContext(path))
{
var contactDomain = new ContactDomain();
var addressDomain = new AddressDomain();
IEnumerable <KeyValuePair <int, string> > contacts = contactDomain.GetSortedListByNamesAndFrequency(context);
IEnumerable <string> addresses = addressDomain.SortByStreetAndFrequency(context);
System.Console.WriteLine($"{contacts.Count()} Names extracted");
System.Console.WriteLine($"{addresses.Count()} Addresses extracted");
System.Console.WriteLine($"Exporting to {Path.GetDirectoryName(path)}");
contactDomain.ExportToFile(contacts, Path.Combine(Path.GetFullPath(path), "contacts.txt"));
addressDomain.ExportToFile(addresses, Path.Combine(Path.GetFullPath(path), "addresses.txt"));
System.Console.WriteLine($"Exporting done, press any key");
System.Console.ReadKey();
}
}
}
internal ThreadManager(Debugger debugger)
{
this.debugger = debugger;
thread_hash = Hashtable.Synchronized (new Hashtable ());
engine_hash = Hashtable.Synchronized (new Hashtable ());
processes = ArrayList.Synchronized (new ArrayList ());
pending_events = Hashtable.Synchronized (new Hashtable ());
last_pending_sigstop = DateTime.Now;
pending_sigstops = new Dictionary<int,DateTime> ();
address_domain = AddressDomain.Global;
wait_event = new ST.AutoResetEvent (false);
engine_event = new ST.ManualResetEvent (true);
ready_event = new ST.ManualResetEvent (false);
event_queue = new DebuggerEventQueue ("event_queue");
event_queue.DebugFlags = DebugFlags.Wait;
mono_debugger_server_global_init ();
wait_thread = new ST.Thread (new ST.ThreadStart (start_wait_thread));
wait_thread.IsBackground = true;
wait_thread.Start ();
inferior_thread = new ST.Thread (new ST.ThreadStart (start_inferior));
inferior_thread.IsBackground = true;
inferior_thread.Start ();
ready_event.WaitOne ();
}
public void ValidationFailsIfAddressIsNotProvided()
{
AddressDomain address = new AddressDomain()
{
Uprn = 123,
Postcode = "AB1"
};
var errors = ValidationHelper.ValidateModel(address);
Assert.AreEqual(1, errors.Count);
}
public void CanMapDbAddressToAddressDomain()
{
dbAddress address = DatabaseGatewayHelper.CreateAddressDatabaseEntity();
AddressDomain expectedAddressDomain = new AddressDomain()
{
Address = address.AddressLines,
Postcode = address.PostCode,
Uprn = address.Uprn
};
EntityFactory.DbAddressToAddressDomain(address).Should().BeEquivalentTo(expectedAddressDomain);
}
public void AddressDomainIncludesRequiredProperties()
{
var address = new AddressDomain
{
Address = "Address11",
Uprn = 123,
Postcode = "AB1 2BC"
};
address.Address.Should().Be("Address11");
address.Uprn.Should().Be(123);
address.Postcode.Should().Be("AB1 2BC");
}
public static Address AddResidentAddress(AddressDomain addressRequest, long personId, string createdBy)
{
return(new Address
{
AddressLines = addressRequest.Address,
PersonId = personId,
PostCode = addressRequest.Postcode,
Uprn = addressRequest.Uprn,
DataIsFromDmPersonsBackup = "N",
IsDisplayAddress = "Y",
CreatedBy = createdBy
});
}
public HttpResponseMessage AddressByIdGet([FromUri] AddressRequest model)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
AddressDomain address = _AddressService.GetAddressById(model);
var response = new ItemResponse <AddressDomain> {
Item = address
};
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
public void TestSortByAddresses()
{
var domain = new AddressDomain();
var context = new Mock <IAppDataContext>();
context.SetupGet(x => x.Addresses)
.Returns(() =>
{
return(new Repository <Address>(new List <Address>()
{
new Address()
{
Number = 102, Street = "Long Lane"
},
new Address()
{
Number = 65, Street = "Ambling Way"
},
new Address()
{
Number = 82, Street = "Stewart St"
},
new Address()
{
Number = 12, Street = "Howard St"
},
new Address()
{
Number = 78, Street = "Short Lane"
},
new Address()
{
Number = 49, Street = "Sutherland St"
},
}));
});
IEnumerable <string> result = domain.SortByStreetAndFrequency(context.Object);
Assert.IsNotNull(result);
CollectionAssert.AllItemsAreUnique(result.ToList());
Assert.IsTrue(result.Any(), "Returned No Resultes");
Assert.IsTrue(result.Count() == 6, "Result count mismatch");
Assert.IsTrue(result.First() == "65 Ambling Way", "First element mismatch");
Assert.IsTrue(result.Last() == "49 Sutherland St", "Last element mismatch");
}
protected Inferior(ThreadManager thread_manager, Process process,
ProcessStart start, BreakpointManager bpm,
DebuggerErrorHandler error_handler,
AddressDomain address_domain)
{
this.thread_manager = thread_manager;
this.process = process;
this.start = start;
this.native = start.IsNative;
this.error_handler = error_handler;
this.breakpoint_manager = bpm;
this.address_domain = address_domain;
server_handle = mono_debugger_server_create_inferior (breakpoint_manager.Manager);
if (server_handle == IntPtr.Zero)
throw new InternalError ("mono_debugger_server_initialize() failed.");
}
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public List <AddressDomain> GetByCompanyIdAndAddressType(AddressRequest model)
{
List <AddressDomain> addressList = null;
try
{
DataProvider.ExecuteCmd(GetConnection, "dbo.Address_Select_ByCompanyAndType"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@companyId", model.CompanyId);
paramCollection.AddWithValue("@addressType", model.AddressType);
}
, map : delegate(IDataReader reader, short set)
{
var singleAddress = new AddressDomain();
int startingIndex = 0; //startingOrdinal
singleAddress.AddressId = reader.GetSafeInt32(startingIndex++);
singleAddress.CompanyId = reader.GetSafeInt32(startingIndex++);
singleAddress.Date = reader.GetSafeDateTime(startingIndex++);
singleAddress.Address1 = reader.GetSafeString(startingIndex++);
singleAddress.City = reader.GetSafeString(startingIndex++);
singleAddress.State = reader.GetSafeString(startingIndex++);
singleAddress.ZipCode = reader.GetSafeString(startingIndex++);
singleAddress.Latitude = reader.GetSafeDecimal(startingIndex++);
singleAddress.Longitude = reader.GetSafeDecimal(startingIndex++);
singleAddress.Slug = reader.GetSafeString(startingIndex++);
singleAddress.AddressType = reader.GetSafeInt32(startingIndex++);
if (addressList == null)
{
addressList = new List <AddressDomain>();
}
addressList.Add(singleAddress);
});
}
catch (Exception ex)
{
throw ex;
}
return(addressList);
}
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public AddressDomain GetAddressById(AddressRequest model)
{
AddressDomain address = null;
try
{
DataProvider.ExecuteCmd(GetConnection, "dbo.Address_GetById"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@Id", model.AddressId);
}, map : delegate(IDataReader reader, short set)
{
address = new AddressDomain();
int startingIndex = 0; //startingOrdinal
address.AddressId = reader.GetSafeInt32(startingIndex++);
address.CompanyId = reader.GetSafeInt32(startingIndex++);
address.Date = reader.GetSafeDateTime(startingIndex++);
address.Address1 = reader.GetSafeString(startingIndex++);
address.City = reader.GetSafeString(startingIndex++);
address.State = reader.GetSafeString(startingIndex++);
address.ZipCode = reader.GetSafeString(startingIndex++);
address.Latitude = reader.GetSafeDecimal(startingIndex++);
address.Longitude = reader.GetSafeDecimal(startingIndex++);
address.Slug = reader.GetSafeString(startingIndex++);
address.AddressType = reader.GetSafeInt32(startingIndex++);
});
}
catch (Exception ex)
{
throw ex;
}
return(address);
}
public static TargetMemoryInfo GetTargetMemoryInfo(AddressDomain domain)
{
int target_int_size, target_long_size, target_addr_size, is_bigendian;
check_error (mono_debugger_server_get_target_info
(out target_int_size, out target_long_size,
out target_addr_size, out is_bigendian));
return new TargetMemoryInfo (target_int_size, target_long_size,
target_addr_size, is_bigendian != 0, domain);
}
public void CanMapPersonDetailsToGetPersonResponse()
{
Person person = DatabaseGatewayHelper.CreatePersonDatabaseEntity();
person.Id = 123;
Address address = DatabaseGatewayHelper.CreateAddressDatabaseEntity(person.Id);
//set to display address
address.IsDisplayAddress = "Y";
PhoneNumber phoneNumber1 = DatabaseGatewayHelper.CreatePhoneNumberEntity(person.Id);
PhoneNumber phoneNumber2 = DatabaseGatewayHelper.CreatePhoneNumberEntity(person.Id);
PersonOtherName otherName1 = DatabaseGatewayHelper.CreatePersonOtherNameDatabaseEntity(person.Id);
PersonOtherName otherName2 = DatabaseGatewayHelper.CreatePersonOtherNameDatabaseEntity(person.Id);
person.Addresses = new List <Address>
{
address
};
person.PhoneNumbers = new List <PhoneNumber>
{
phoneNumber1,
phoneNumber2
};
person.OtherNames = new List <PersonOtherName>
{
otherName1,
otherName2
};
AddressDomain addressDomain = new AddressDomain()
{
Address = address.AddressLines,
Postcode = address.PostCode,
Uprn = address.Uprn
};
OtherName personOtherName1 = new OtherName()
{
FirstName = otherName1.FirstName,
LastName = otherName1.LastName
};
OtherName personOtherName2 = new OtherName()
{
FirstName = otherName2.FirstName,
LastName = otherName2.LastName
};
PhoneNumberDomain phoneNumberDomain1 = new PhoneNumberDomain()
{
Number = phoneNumber1.Number,
Type = phoneNumber1.Type
};
PhoneNumberDomain phoneNumberDomain2 = new PhoneNumberDomain()
{
Number = phoneNumber2.Number,
Type = phoneNumber2.Type
};
var expectedResponse = new GetPersonResponse()
{
EmailAddress = person.EmailAddress,
DateOfBirth = person.DateOfBirth.Value,
DateOfDeath = person.DateOfDeath.Value,
Address = addressDomain,
SexualOrientation = person.SexualOrientation,
ContextFlag = person.AgeContext,
CreatedBy = person.CreatedBy,
Ethnicity = person.Ethnicity,
FirstLanguage = person.FirstLanguage,
FirstName = person.FirstName,
Gender = person.Gender,
LastName = person.LastName,
NhsNumber = person.NhsNumber.Value,
Id = person.Id,
PreferredMethodOfContact = person.PreferredMethodOfContact,
Religion = person.Religion,
Restricted = person.Restricted,
Title = person.Title,
OtherNames = new List <OtherName>()
{
personOtherName1, personOtherName2
},
PhoneNumbers = new List <PhoneNumberDomain>()
{
phoneNumberDomain1, phoneNumberDomain2
}
};
var result = ResponseFactory.ToResponse(person);
result.Should().BeEquivalentTo(expectedResponse);
}
