public bool Reader(OperationType type, ref AddressBooks addressBooks)
{
LogDetails logDetails = new LogDetails();
IDataSourceOperation dataSourceOperation;
if (type == OperationType.Mock)
{
dataSourceOperation = new MockDataSourceOperation();
}
else
{
dataSourceOperation = new JsonOperation();
}
try
{
addressBooks = DictToListMapping.ListToDictionary(Reader(dataSourceOperation));
}
catch (Exception e)
{
logDetails.LogDebug("IO Error in Reading operation");
logDetails.LogError(e.Message);
return(false);
}
return(true);
}
public IHttpActionResult PutAddressBooks(int id, AddressBooks addressBooks)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != addressBooks.Id)
{
return(BadRequest());
}
addressBooks.User = db.Users.Find(User.Identity.GetUserId());
db.Entry(addressBooks).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!AddressBooksExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public static void ReadFromSqlServer(ref AddressBooks addressBooks)
{
DictToListMapping dictToList = new DictToListMapping();
using (SqlConnection connection = new SqlConnection(path))
{
SqlCommand command = new SqlCommand("select * from AddressBook", connection);
connection.Open();
SqlDataReader dataReader = command.ExecuteReader();
while (dataReader.Read())
{
dictToList.AddressBookName.Add(dataReader["AddressBookName"].ToString());
dictToList.ContactName.Add(dataReader["ContactName"].ToString());
dictToList.FirstName.Add(dataReader["FirstName"].ToString());
dictToList.LastName.Add(dataReader["LastName"].ToString());
dictToList.City.Add(dataReader["City"].ToString());
dictToList.State.Add(dataReader["State"].ToString());
dictToList.ZipCode.Add(dataReader["Zip"].ToString());
dictToList.PhoneNumber.Add(dataReader["Phone"].ToString());
dictToList.Email.Add(dataReader["Email"].ToString());
dictToList.DateAdded.Add((DateTime)dataReader["DateAdded"]);
}
}
addressBooks = DictToListMapping.ListToDictionary(dictToList);
}
public static AddressBooks CreateAddressBooks(string name)
{
AddressBooks addressBooks = new AddressBooks();
addressBooks.Name = name;
return(addressBooks);
}
/// <summary>
/// Read from CSV file to store in address books
/// </summary>
/// <param name="addressBooks"></param>
public static void ReadFromCsv(ref AddressBooks addressBooks)
{
DictToListMapping dictToListMapping = new DictToListMapping();
var lines = File.ReadAllLines(path);
var csv = from line in lines
select(line.Split('\n')).ToArray();
DictToListMapping dictToList = new DictToListMapping();
int index = 0;
foreach (var words in csv)
{
if (index == 0)
{
index++;
continue;
}
var values = words[0].Split(',');
dictToList.AddressBookName.Add(values[0]);
dictToList.ContactName.Add(values[1]);
dictToList.FirstName.Add(values[2]);
dictToList.LastName.Add(values[3]);
dictToList.City.Add(values[4]);
dictToList.State.Add(values[5]);
dictToList.ZipCode.Add(values[6]);
dictToList.PhoneNumber.Add(values[7]);
dictToList.Email.Add(values[8]);
}
addressBooks = DictToListMapping.ListToDictionary(dictToList);
}
/// <summary>
/// Write addressbooks to JSON file
/// </summary>
/// <param name="addressBooks"></param>
public static void WriteToJson(AddressBooks addressBooks)
{
DictToListMapping dictToList = new DictToListMapping(DictToListMapping.DictionaryToList(addressBooks));
string jsonData = JsonConvert.SerializeObject(dictToList);
File.WriteAllText(path, jsonData);
}
public void SortAddress()
{
AddressDict = new Dictionary <string, string>();
AddressBooks?.ForEach(delegate(AddressBook addressBook)
{
ExtractStreetName(addressBook.Address.ToLower());
});
SortAddressDict();
}
public void ReadFromSqlServer_ShouldReturnAllFiles_AsAddressBookObject()
{
//Arrange
AddressBooks addressBooks = new AddressBooks();
//Act
SqlServerOperation.ReadFromSqlServer(ref addressBooks);
//Assert
Assert.AreEqual(2, addressBooks._multiAddressBooks["General"].AddressBook.Count);
}
/// <summary>
/// Read from JSON file to store in address books
/// </summary>
/// <param name="addressBooks"></param>
public static void ReadFromJson(ref AddressBooks addressBooks)
{
DictToListMapping dictToList = new DictToListMapping();
string jsonData = File.ReadAllText(path);
dictToList = JsonConvert.DeserializeObject <DictToListMapping>(jsonData);
addressBooks = DictToListMapping.ListToDictionary(dictToList);
}
public void Search()
{
AddressBooks.Clear();
IQueryable <AddressBook> query = unitOfWork.addressBookRepository.GetObjectsQueryable(a => a.Name.Contains(SearchName));
foreach (var item in query)
{
AddressBooks.Add(item);
}
}
private string GetAllWords()
{
string words = string.Empty;
AddressBooks?.ForEach(delegate(AddressBook addressBook)
{
words += addressBook.FullName + " ";
});
return(words);
}
/// <summary>
/// Switch Cases to add / choose/ other operations involving all address books
/// </summary>
/// <param name="addressBooksCollection">ref to all address books</param>
/// <param name="userChoice">User input to choose operation among available options</param>
private static void AddressBookChoiceSwitch(ref AddressBooks addressBooksCollection, string userChoice, ref bool contContactPanel)
{
switch (userChoice)
{
case "1":
Console.WriteLine("Add Name of the new Address Book");
addressBooksCollection.Name = Console.ReadLine();
contContactPanel = true;
break;
case "2":
contContactPanel = true;
break;
case "3":
Console.WriteLine("Available books : ");
foreach (var item in addressBooksCollection._multiAddressBooks)
{
Console.Write(item.Key + " , ");
}
Console.WriteLine("\nEnter Name of the Address Book you want to switch");
addressBooksCollection.Name = Console.ReadLine();
contContactPanel = true;
break;
case "4":
Console.WriteLine("Enter\n" +
"1 : Search by State\n" +
"2 : Search by City");
switch (Console.ReadLine())
{
case "1":
Console.Write("Enter state name : ");
string state = Console.ReadLine();
addressBooksCollection.SearchAllAddressBooksByState(state);
break;
case "2":
Console.Write("Enter city name : ");
string city = Console.ReadLine();
addressBooksCollection.SearchAllAddressBooksByCity(city);
break;
default:
Console.WriteLine("Wrong Choice\n");
break;
}
break;
default:
Console.WriteLine("Wrong Option Entered !!");
Console.WriteLine("Continuing with " + addressBooksCollection.Name + " address book");
break;
}
}
public void DataAdapterReader_WhenGivenJsonTypeShouldReturn_AdressBookListWithValuesInJsonFile()
{
//Arrange
AddressBooks addressBooks = new AddressBooks();
AddressBookDataAdapter adapter = new AddressBookDataAdapter();
//Act
adapter.Reader(AddressBookDataAdapter.OperationType.JSON, ref addressBooks);
//Assert
Assert.AreEqual("Jyoti Ranjan", addressBooks._multiAddressBooks["General"].AddressBook["Jyoti RanjanMishra"].FirstName);
Assert.AreEqual("Mishra", addressBooks._multiAddressBooks["General"].AddressBook["Jyoti RanjanMishra"].LastName);
}
public void DataAdapterReader_WhenGivenMockTypeShouldReturn_AdressBookWithMockValues()
{
//Arrange
AddressBooks addressBooks = new AddressBooks();
AddressBookDataAdapter adapter = new AddressBookDataAdapter();
//Act
adapter.Reader(AddressBookDataAdapter.OperationType.Mock, ref addressBooks);
//Assert
Assert.AreEqual("TestFirstName", addressBooks._multiAddressBooks["TestAddressBook"].AddressBook["TestContactName"].FirstName);
Assert.AreEqual("TestLastName", addressBooks._multiAddressBooks["TestAddressBook"].AddressBook["TestContactName"].LastName);
}
/// <summary>
/// Switch Cases for address books operation
/// </summary>
/// <param name="addressBooksCollection">addressbooks instance to perform operations</param>
/// <param name="choice">User input to choose operation among available options</param>
/// <returns></returns>
private static void AddressBookOperationSwitch(ref AddressBooks addressBooksCollection, string choice)
{
LogDetails logDetails = new LogDetails();
switch (choice)
{
case "1":
addressBooksCollection.AddNewContactInAddressBook();
break;
case "2":
addressBooksCollection.EditDetailsInAddressBook();
break;
case "3":
addressBooksCollection.DeleteOneContactDetail();
break;
case "4":
Console.Write("Enter State Name to search : ");
string stateToSearch = Console.ReadLine();
addressBooksCollection.SearchCurrentAddressBookByState(stateToSearch);
break;
case "5":
Console.WriteLine("Enter\n" +
"1 : Sort by name\n" +
"2 : Sort by city\n" +
"3 : Sort by state\n" +
"4 : Sort by Zip");
int userChoiceToSort;
try
{
userChoiceToSort = Int32.Parse(Console.ReadLine());
}
catch (Exception e)
{
logDetails.LogDebug("Error in sorting section");
logDetails.LogError(e.Message);
Console.WriteLine("Wrong Choice\nSorting by Name(default)");
userChoiceToSort = 1;
}
string[] property = new string[5] {
"", "FirstName", "City", "State", "Zip"
};
addressBooksCollection.SortPersonsByProperty(property[userChoiceToSort]);
break;
default:
break;
}
}
public IHttpActionResult PostAddressBooks(AddressBooks addressBooks)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
addressBooks.User = db.Users.Find(User.Identity.GetUserId());
db.AddressBooks.Add(addressBooks);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = addressBooks.Id }, addressBooks));
}
public IHttpActionResult DeleteAddressBooks(int id)
{
AddressBooks addressBooks = db.AddressBooks.Find(id);
if (addressBooks == null)
{
return(NotFound());
}
db.AddressBooks.Remove(addressBooks);
db.SaveChanges();
return(Ok(addressBooks));
}
public static void WriteToSqlServer(AddressBooks addressBooks)
{
DeleteAllRows();
DictToListMapping dictToList = new DictToListMapping(DictToListMapping.DictionaryToList(addressBooks));
DataSet dataSet = new DataSet();
DataTable dataTable = new DataTable("AddressBook");
dataTable.Columns.Add("AddressBookName", typeof(string));
dataTable.Columns.Add("ContactName", typeof(string));
dataTable.Columns.Add("FirstName", typeof(string));
dataTable.Columns.Add("LastName", typeof(string));
dataTable.Columns.Add("City", typeof(string));
dataTable.Columns.Add("State", typeof(string));
dataTable.Columns.Add("Zip", typeof(string));
dataTable.Columns.Add("Phone", typeof(string));
dataTable.Columns.Add("Email", typeof(string));
dataTable.Columns.Add("DateAdded", typeof(DateTime));
dataSet.Tables.Add(dataTable);
dataSet.Tables[0].TableName = "AddressBook";
for (int i = 0; i < dictToList.AddressBookName.Count; i++)
{
DataRow row = dataSet.Tables[0].NewRow();
row[0] = dictToList.AddressBookName[i];
row[1] = dictToList.ContactName[i];
row[2] = dictToList.FirstName[i];
row[3] = dictToList.LastName[i];
row[4] = dictToList.City[i];
row[5] = dictToList.State[i];
row[6] = dictToList.ZipCode[i];
row[7] = dictToList.PhoneNumber[i];
row[8] = dictToList.Email[i];
row[9] = dictToList.DateAdded[i];
dataSet.Tables["AddressBook"].Rows.Add(row);
}
using (SqlConnection connection = new SqlConnection(path))
{
connection.Open();
SqlDataAdapter dataAdapter = new SqlDataAdapter("select * from AddressBook", connection);
SqlCommandBuilder builder = new SqlCommandBuilder(dataAdapter);
int rowsUpdated = dataAdapter.Update(dataSet, "AddressBook");
Console.WriteLine("Rows Affected " + rowsUpdated);
}
}
/// <summary>
/// Read contact details from XML/ CSV / JSON file
/// and store in AddressBooks class instance
/// </summary>
/// <param name="addressBooksCollection">reference to addressbooks instance to store contact details</param>
private static void FileReadingOperation(ref AddressBooks addressBooksCollection)
{
LogDetails logDetails = new LogDetails();
try
{
//IoOperations.DeserializeAddressBooks(ref addressBooksCollection);
//CsvOperations.ReadFromCsv(ref addressBooksCollection);
//JsonOperation.ReadFromJson(ref addressBooksCollection);
SqlServerOperation.ReadFromSqlServer(ref addressBooksCollection);
}
catch (Exception e)
{
logDetails.LogDebug("IO Error in Reading operation");
logDetails.LogError(e.Message);
}
}
//----------------------------------- [ Private Methods ]----------------------------------------//
/// <summary>
/// Write contact details of all address books in XML, CSV & JSON file
/// </summary>
/// <param name="addressBooksCollection"></param>
private static void FileWritingOperation(AddressBooks addressBooksCollection)
{
LogDetails logDetails = new LogDetails();
try
{
//IoOperations.SerializeAddressBooks(addressBooksCollection);
//CsvOperations.WriteToCsv(addressBooksCollection);
JsonOperation.WriteToJson(addressBooksCollection);
//SqlServerOperation.WriteToSqlServer(addressBooksCollection);
}
catch (Exception e)
{
Console.WriteLine("In catch block : " + e.Message);
logDetails.LogDebug("IO Error in Writing operation");
logDetails.LogError(e.Message);
}
}
static bool getSnmp(string host, string OID, bool adump)
{
bool result = false;
SimpleSnmp snmpVerb = new SimpleSnmp(host, 161, "public", 500, 0);
if (!snmpVerb.Valid)
{
return(result);
}
Oid varbind = new Oid(OID);
Dictionary <Oid, AsnType> snmpDataS = snmpVerb.Get(SnmpVersion.Ver1, new string[] { varbind.ToString() });
if (snmpDataS != null)
{
if (adump == true)
{
AddressBooks data = new AddressBooks();
string temp = snmpDataS[varbind].ToString();
AddressBooks.AddressList.Add(temp);
}
else
{
string temp = snmpDataS[varbind].ToString();
// Get MANUFACTURER
int startIndex = temp.IndexOf("MFG:");
int endIndex = temp.IndexOf(";", startIndex);
string mfg = temp.Substring(startIndex + 4, endIndex - (startIndex + 4));
// Get MODEL
startIndex = temp.IndexOf("MDL:");
endIndex = temp.IndexOf(";", startIndex);
string printerMDL = temp.Substring(startIndex + 4, endIndex - (startIndex + 4));
Printers data = new Printers();
Printers.PrinterList.Add(host + " " + mfg + " " + printerMDL);
}
}
return(result);
}
/// <summary>
/// Write addressbooks to CSV file
/// </summary>
/// <param name="addressBooks"></param>
public static void WriteToCsv(AddressBooks addressBooks)
{
DictToListMapping dictToList = new DictToListMapping(DictToListMapping.DictionaryToList(addressBooks));
List <string[]> records = new List <string[]>();
string[] person;
for (int i = 0; i < dictToList.AddressBookName.Count; i++)
{
person = new string[9];
person[0] = dictToList.AddressBookName[i];
person[1] = dictToList.ContactName[i];
person[2] = dictToList.FirstName[i];
person[3] = dictToList.LastName[i];
person[4] = dictToList.City[i];
person[5] = dictToList.State[i];
person[6] = dictToList.ZipCode[i];
person[7] = dictToList.PhoneNumber[i];
person[8] = dictToList.Email[i];
records.Add(person);
}
Type type = dictToList.GetType();
PropertyInfo[] propertyInfo = type.GetProperties();
using (var writer = new StreamWriter(path))
{
writer.WriteLine(string.Join(",", propertyInfo.Select(p => p.Name)));
for (int i = 0; i < records.Count; i++)
{
writer.WriteLine(string.Join(",", records[i]));
}
}
}
static void Main(string[] args)
{
bool AddressDump = false;
bool showhelp = false;
var opts = new OptionSet()
{
{ "AddressDump=", " --AddressDump+", v => AddressDump = v != null },
{ "h|?|help", "Show available options", v => showhelp = v != null },
};
try
{
opts.Parse(args);
}
catch (OptionException e)
{
Console.WriteLine(e.Message);
}
if (showhelp)
{
Console.WriteLine("RTFM");
opts.WriteOptionDescriptions(Console.Out);
Console.WriteLine("[*] Example: SharpPrinter.exe --AddressDump+");
return;
}
try
{
if (AddressDump == true)
{
Task task = Task.Run(() => ScanPrinters());
task.Wait();
Thread.Sleep(2000);
AddressBooks data = new AddressBooks();
foreach (string a in AddressBooks.AddressList)
{
if (a != null)
{
Console.WriteLine(a);
}
else
{
AddressBooks.AddressList.ForEach(i => Console.WriteLine("{0}\t", i));
Console.WriteLine("");
}
}
}
else
{
Task task = Task.Run(() => ScanPrinters());
task.Wait();
Thread.Sleep(2000);
Printers data = new Printers();
foreach (string p in Printers.PrinterList)
{
if (p != null)
{
Match passback = Regex.Match(p, @"\b(Aficio MP|Sharp MX|ColorQube 9303)\b");
if (passback.Success)
{
Console.WriteLine("Found printer with potential LDAP passback: '{0}'.", p);
Console.WriteLine("");
}
Match export = Regex.Match(p, @"\b(iR-ADV|Minolta|KYOCERA Document Solutions Printing System|KYOCERA MITA Printing System)\b");
if (export.Success)
{
Console.WriteLine("Found printer with potential for passwords in address book: '{0}'.", p);
Console.WriteLine("");
}
Match leakage = Regex.Match(p, @"\b(M3035|KONICA MINOLTA magicolor 4690MF|KONICA MINOLTA magicolor 1690MF)\b");
if (leakage.Success)
{
Console.WriteLine("Found printer with potential for password leakage: '{0}'.", p);
Console.WriteLine("");
}
}
else
{
Printers.PrinterList.ForEach(i => Console.WriteLine("{0}\t", i));
Console.WriteLine("");
}
}
}
Console.WriteLine("Done!");
Console.WriteLine("For more information on these attacks, check out the following information:");
Console.WriteLine("https://www.defcon.org/images/defcon-19/dc-19-presentations/Heiland/DEFCON-19-Heiland-Printer-To-Pwnd.pdf");
Console.WriteLine("");
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
/// <summary>
/// Start AddressBook Program to perform various operations
/// </summary>
public static void Start()
{
AddressBooks addressBooksCollection = new AddressBooks();
//FileReadingOperation(ref addressBooksCollection);
//Task readingTask = new Task(() =>
//{
// FileReadingOperation(ref addressBooksCollection);
//});
//readingTask.Start();
//readingTask.Wait();
AddressBookDataAdapter adapter = new AddressBookDataAdapter();
adapter.Reader(AddressBookDataAdapter.OperationType.JSON, ref addressBooksCollection);
addressBooksCollection.Name = "General";
bool contAddressBook = true;;
bool contContactPanel = true;;
do
{
Console.WriteLine("Enter\n" +
"1 : To Add a new Address Book\n" +
"2 : To use current address books ( " + addressBooksCollection.Name + " )\n" +
"3 : Switch Address Book\n" +
"4 : Search across all address books\n" +
"0 : Exit");
string userChoice = Console.ReadLine();
if (userChoice != "0")
{
contContactPanel = false;
AddressBookChoiceSwitch(ref addressBooksCollection, userChoice, ref contContactPanel);
}
else
{
contAddressBook = false;
contContactPanel = false;
}
while (contContactPanel)
{
Console.WriteLine("Enter\n" +
"1 : Add Contact Details to " + addressBooksCollection.Name + " Address Book\n" +
"2 : Edit a Contact Detail\n" +
"3 : Delete a Contact Detail\n" +
"4 : Search across a state\n" +
"5 : Sort persons\n" +
"0 : Exit");
string choice = Console.ReadLine();
if (choice != "0")
{
AddressBookOperationSwitch(ref addressBooksCollection, choice);
}
else
{
contContactPanel = false;
}
}
} while (contAddressBook);
//FileWritingOperation(addressBooksCollection);
Task writingTask = new Task(() =>
{
FileWritingOperation(addressBooksCollection);
});
writingTask.Start();
writingTask.Wait();
Console.WriteLine("Saved changes to database");
}
public ContactsManager(ICore core, ISynchronizeInvoke syncInvoke)
{
Core = core;
_contactsWrapper = new ObservableDictionaryValuesMapperConverter <Contact, IContact>(_contacts);
_tagsWrapper = new ObservableDictionaryValuesMapperConverter <TagLocal, IContactTagLocal>(_tags);
var dbPath = string.Format("{0}{1}contactpoint{1}{2}", Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), Path.DirectorySeparatorChar, "address_book.s3db");
#if CONTACTS_DEBUG
if (File.Exists(dbPath))
{
File.Delete(dbPath);
}
#endif
if (!File.Exists(dbPath))
{
CreateDatabase(dbPath);
}
else
{
if (!InitializeConnection(dbPath))
{
Logger.LogWarn("Error loading ContactsManager - continue without Contacts API");
return;
}
}
var contacts = new Dictionary <long, Contact>();
using (new EnsuredResourceCriticalOperation(_sqlConnection))
{
DatabaseSchema.Upgrade(_sqlConnection);
#region Load address books
Logger.LogNotice("Loading Address Books");
using (var command = _sqlConnection.CreateCommand())
{
command.CommandText = @"select id, name, lastupdate, key from addressbooks";
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
_addressBooks.Add(
new AddressBookLocal(
this,
reader.GetInt32(0),
Guid.Parse(reader.GetString(3)),
reader.GetString(1)
)
{
LastUpdate =
reader.IsDBNull(2)
? DateTime.Now - TimeSpan.FromDays(365)
: reader.GetDateTime(2)
});
}
}
}
#endregion
#region Load tags
Logger.LogNotice("Loading Tags");
using (var command = _sqlConnection.CreateCommand())
{
command.CommandText =
@"select id, name, key, color, version_tag, addressbook_id from tags where is_deleted = 0";
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var addressBookId = reader.GetInt64(5);
var addressBook = AddressBooks.FirstOrDefault(x => x.Id == addressBookId);
if (addressBook == null)
{
continue;
}
var tag = new TagLocal(reader.GetInt64(0), addressBook, this)
{
Name = reader.GetString(1),
Key = reader.GetStringSafe(2),
Color = reader.GetStringSafe(3),
VersionKey = reader.GetStringSafe(4),
IsDeleted = false
};
tag.ResetIsChanged();
_tags.Add(tag.Id, tag);
}
}
}
#endregion
#region Load contacts
Logger.LogNotice("Loading Contacts");
using (var command = _sqlConnection.CreateCommand())
{
command.CommandText = @"select id, first_name, last_name, middle_name, company from contacts";
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var id = reader.GetInt32(0);
var contact = new Contact(this, id)
{
FirstName = reader.GetStringSafe(1),
LastName = reader.GetStringSafe(2),
MiddleName = reader.GetStringSafe(3),
Company = reader.GetStringSafe(4)
};
contacts.Add(id, contact);
}
}
}
#endregion
#region Load contact infos links for contacts
Logger.LogNotice("Loading Contact Links");
var contactInfoIdsContacts = new Dictionary <long, Contact>();
using (var command = _sqlConnection.CreateCommand())
{
command.CommandText = @"select contact_info_id, contact_id from contacts_links";
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var contactInfoId = reader.GetInt64(0);
if (contactInfoIdsContacts.ContainsKey(contactInfoId))
{
continue;
}
var contactId = reader.GetInt64(1);
if (!contacts.ContainsKey(contactId))
{
continue;
}
contactInfoIdsContacts.Add(contactInfoId, contacts[contactId]);
}
}
}
#endregion
#region Load contact infos
Logger.LogNotice("Loading Contact details");
var contactInfos = new Dictionary <long, ContactInfoLocal>();
using (var command = _sqlConnection.CreateCommand())
{
command.CommandText =
@"select id, first_name, last_name, middle_name, company, job_title, addressbook_id, key, note, version_tag from contact_infos where is_deleted = 0";
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var id = reader.GetInt64(0);
var addressBookId = reader.GetInt64(6);
var addressBook = _addressBooks.FirstOrDefault(x => x.Id == addressBookId);
if (addressBook == null)
{
continue;
}
if (!contactInfoIdsContacts.ContainsKey(id))
{
continue;
}
var contactInfo = new ContactInfoLocal(id, addressBook, this)
{
FirstName = reader.GetStringSafe(1),
LastName = reader.GetStringSafe(2),
MiddleName = reader.GetStringSafe(3),
Company = reader.GetStringSafe(4),
JobTitle = reader.GetStringSafe(5),
Key = reader.GetString(7),
Note = reader.GetStringSafe(8),
VersionKey = reader.GetStringSafe(9),
Contact = contactInfoIdsContacts[id],
IsDeleted = false
};
contactInfos.Add(id, contactInfo);
contactInfo.ResetIsChanged();
contactInfoIdsContacts[id].ContactInfos.Add(contactInfo);
}
}
}
#endregion
#region Load phone numbers
Logger.LogNotice("Loading Phone Numbers");
using (var command = _sqlConnection.CreateCommand())
{
command.CommandText =
@"select id, number, comment, key, version_tag, contact_info_id from contact_info_phones";
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var contactInfoId = reader.GetInt64(5);
if (!contactInfos.ContainsKey(contactInfoId))
{
continue;
}
var number = new ContactPhoneLocal(reader.GetInt64(0),
contactInfos[contactInfoId].AddressBook)
{
Number = reader.GetString(1),
Comment = reader.GetStringSafe(2),
Key = reader.GetStringSafe(3),
VersionKey = reader.GetStringSafe(4)
};
number.ResetIsChanged();
contactInfos[contactInfoId].PhoneNumbers.Add(number);
contactInfos[contactInfoId].ResetIsChanged();
}
}
}
#endregion
#region Load emails
Logger.LogNotice("Loading Emails");
using (var command = _sqlConnection.CreateCommand())
{
command.CommandText =
@"select id, email, comment, key, version_tag, contact_info_id from contact_info_emails";
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var contactInfoId = reader.GetInt64(5);
if (!contactInfos.ContainsKey(contactInfoId))
{
continue;
}
var email = new ContactEmailLocal(reader.GetInt64(0),
contactInfos[contactInfoId].AddressBook)
{
Email = reader.GetString(1),
Comment = reader.GetStringSafe(2),
Key = reader.GetStringSafe(3),
VersionKey = reader.GetStringSafe(4)
};
email.ResetIsChanged();
contactInfos[contactInfoId].Emails.Add(email);
contactInfos[contactInfoId].ResetIsChanged();
}
}
}
#endregion
#region Fill tags links on contacts infos
Logger.LogNotice("Loading Tag links");
using (var command = _sqlConnection.CreateCommand())
{
command.CommandText = @"select tag_id, contact_info_id from tags_links";
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var tagId = reader.GetInt32(0);
var contactInfoId = reader.GetInt32(1);
if (!_tags.ContainsKey(tagId))
{
continue;
}
if (!contactInfos.ContainsKey(contactInfoId))
{
continue;
}
contactInfos[contactInfoId].Tags.Add(_tags[tagId]);
contactInfos[contactInfoId].ResetIsChanged();
if (!_contactsTags.ContainsKey(tagId))
{
_contactsTags.Add(tagId, new List <IContact>());
}
_contactsTags[tagId].Add(contactInfoIdsContacts[contactInfoId]);
}
}
}
#endregion
}
// Fill contacts into main collection
foreach (var item in contacts)
{
_contacts.Add(item.Key, item.Value);
}
Logger.LogNotice("Starting update watcher");
_updateWatcher = new UpdateWatcher(this, syncInvoke);
}
