public IList<PhonebookEntry> ListEntries(int startIndex, int count)
{
if (startIndex < 0 || startIndex >= this.entriesByName.Count)
{
throw new ArgumentOutOfRangeException("startIndex");
}
if (count > this.entriesByName.Count)
{
throw new ArgumentOutOfRangeException("count");
}
if (startIndex + count > this.entriesByName.Count)
{
throw new ArgumentOutOfRangeException("Invalid parameters");
}
var matchedEntries = new PhonebookEntry[count];
for (int i = startIndex; i <= startIndex + count - 1; i++)
{
PhonebookEntry entry = this.sortedEntries[i];
matchedEntries[i - startIndex] = entry;
}
return matchedEntries;
}
/// <summary>
/// Adds new Phonebook Entry or if present adds new phones to the existing Entry.
/// </summary>
/// <param name="name">Represents name to wich are asigned, added the phone numbers.</param>
/// <param name="numbers">Represents the phone numbers, in IEnumerable form.</param>
/// <returns>Returns true if </returns>
/// <remarks></remarks>
/// <exception cref=""></exception>
public bool AddPhone(string name, IEnumerable<string> numbers)
{
var existingEntry = from entry in entries
where string.Equals(entry.Name, name, StringComparison.OrdinalIgnoreCase)
select entry;
int newPhonesCount = numbers.Count();
bool actionStatus = false;
if (newPhonesCount <= 10)
{
switch (existingEntry.Count())
{
case 0:
PhonebookEntry processEntry = new PhonebookEntry(name, numbers);
entries.Add(processEntry);
actionStatus = true;
break;
case 1:
existingEntry.First().AssignPhones(numbers);
break;
default:
throw new ArgumentException("Duplicated name in the phonebook found: " + name);
break;
}
}
else
{
throw new ArgumentOutOfRangeException("numbers","New entry overpopulated phone numbers.");
}
return actionStatus;
}
public PhonebookEntryDTO(PhonebookEntry entry)
{
Id = entry.Id.ToString();
PhonebookId = entry.PhonebookId.ToString();
Name = entry.Name;
PhoneNumber = entry.PhoneNumber;
}
private async Task WriteEntryRecords(PhonebookEntry entry, int entryId)
{
var parameters = new DynamicParameters();
foreach (var entryNumber in entry.EntryNumbers)
{
parameters = new DynamicParameters();
parameters.Add("@entry_id", entryId, dbType: DbType.String);
parameters.Add("@number", entryNumber.Number, dbType: DbType.String);
parameters.Add("@number_type_id", entryNumber.NumberType, dbType: DbType.Int32);
await PhonebookDbConnection.Connection.ExecuteAsync("sp_insert_entry_number", parameters, commandType : CommandType.StoredProcedure);
}
foreach (var entryEmail in entry.EntryEmails)
{
parameters = new DynamicParameters();
parameters.Add("@entry_id", entryId, dbType: DbType.String);
parameters.Add("@email", entryEmail.Email, dbType: DbType.String);
parameters.Add("@email_type_id", entryEmail.EmailType, dbType: DbType.Int32);
await PhonebookDbConnection.Connection.ExecuteAsync("sp_insert_entry_number", parameters, commandType : CommandType.StoredProcedure);
}
foreach (var entryAddress in entry.EntryAddresses)
{
parameters = new DynamicParameters();
parameters.Add("@entry_id", entryId, dbType: DbType.String);
parameters.Add("@address_l1", entryAddress.AddressL1, dbType: DbType.String);
parameters.Add("@address_l2", entryAddress.AddressL2, dbType: DbType.String);
parameters.Add("@post_code", entryAddress.PostCode, dbType: DbType.String);
parameters.Add("@county", entryAddress.County, dbType: DbType.String);
parameters.Add("@country", entryAddress.Country, dbType: DbType.String);
parameters.Add("@email_type_id", entryAddress.AddressType, dbType: DbType.Int32);
await PhonebookDbConnection.Connection.ExecuteAsync("sp_insert_entry_address", parameters, commandType : CommandType.StoredProcedure);
}
}
public bool AddPhone(string name, IEnumerable <string> phoneNumbers)
{
string contactNameLowerInvariant = name.ToLowerInvariant();
PhonebookEntry phonebookEntry;
bool entryDoesntExist = !this.phonebookEntriesByContactName.TryGetValue(contactNameLowerInvariant, out phonebookEntry);
if (entryDoesntExist)
{
phonebookEntry = new PhonebookEntry();
phonebookEntry.ContactName = name;
phonebookEntry.PhoneNumbers = new SortedSet <string>();
this.phonebookEntriesByContactName.Add(contactNameLowerInvariant, phonebookEntry);
this.sortedPhonebookEntries.Add(phonebookEntry);
}
foreach (var phoneNumber in phoneNumbers)
{
this.multiplePhonebookEntriesByContactName.Add(phoneNumber, phonebookEntry);
}
phonebookEntry.PhoneNumbers.UnionWith(phoneNumbers);
return(entryDoesntExist);
}
public bool AddPhone(string name, IEnumerable <string> nums)
{
var oldEntries =
from e in this.entries
where e.Name.ToLowerInvariant() == name.ToLowerInvariant()
select e;
if (oldEntries.Count() == 0)
{
PhonebookEntry newEntry = new PhonebookEntry();
newEntry.Name = name;
foreach (var num in nums)
{
newEntry.PhoneNumbers.Add(num);
}
this.entries.Add(newEntry);
return(false);
}
else if (oldEntries.Count() == 1)
{
PhonebookEntry oldEntry = oldEntries.First();
foreach (var num in nums)
{
oldEntry.PhoneNumbers.Add(num);
}
return(true);
}
else
{
throw new Exception("Duplicated name in the phonebook found: " + name);
}
}
public async Task <ActionResult <Object> > Create(PhoneBookEntryDTO data)
{
var user = GetCurrentUser();
if (user != null)
{
PhonebookEntry entry = new PhonebookEntry()
{
Id = Guid.NewGuid(),
FirstName = data.FirstName,
Surname = data.Surname,
PhoneNumber = data.PhoneNumber,
Kind = (Enums.EntryKindEnum)data.Kind,
User = user
};
try
{
_context.PhonebookEntries.Add(entry);
_ = await _context.SaveChangesAsync();
return(Ok());
} catch (Exception ex)
{
throw ex;
}
}
return(BadRequest());
}
public bool AddPhone(string name, IEnumerable<string> nums)
{
var oldEntries =
from e in this.entries
where e.Name.ToLowerInvariant() == name.ToLowerInvariant()
select e;
if (oldEntries.Count() == 0)
{
PhonebookEntry newEntry = new PhonebookEntry();
newEntry.Name = name;
foreach (var num in nums)
{
newEntry.PhoneNumbers.Add(num);
}
this.entries.Add(newEntry);
return false;
}
else if (oldEntries.Count() == 1)
{
PhonebookEntry oldEntry = oldEntries.First();
foreach (var num in nums)
{
oldEntry.PhoneNumbers.Add(num);
}
return true;
}
else
{
throw new Exception("Duplicated name in the phonebook found: " + name);
}
}
public bool AddPhone(string name, IEnumerable<string> phoneNumbers)
{
string contactNameLowerInvariant = name.ToLowerInvariant();
PhonebookEntry phonebookEntry;
bool entryDoesntExist = !this.phonebookEntriesByContactName.TryGetValue(contactNameLowerInvariant, out phonebookEntry);
if (entryDoesntExist)
{
phonebookEntry = new PhonebookEntry();
phonebookEntry.ContactName = name;
phonebookEntry.PhoneNumbers = new SortedSet<string>();
this.phonebookEntriesByContactName.Add(contactNameLowerInvariant, phonebookEntry);
this.sortedPhonebookEntries.Add(phonebookEntry);
}
foreach (var phoneNumber in phoneNumbers)
{
this.multiplePhonebookEntriesByContactName.Add(phoneNumber, phonebookEntry);
}
phonebookEntry.PhoneNumbers.UnionWith(phoneNumbers);
return entryDoesntExist;
}
public PhonebookEntry Update(PhonebookEntry phonebookEntry)
{
var entity = context.PhonebookEntry.Attach(phonebookEntry);
entity.State = EntityState.Modified;
return(phonebookEntry);
}
public void UpdateDBEntry(PhonebookEntry entry, PhonebookEntryViewModel entryViewModel)
{
entry.FirstName = entryViewModel.FirstName;
entry.LastName = entryViewModel.LastName;
entry.Type = entryViewModel.Type;
this.data.PhonebookEntries.Update(entry);
this.data.SaveChanges();
}
public void ShoudAddSingleEntryWithSingleNumberAndName()
{
var entry = new PhonebookEntry("Kalina");
entry.PhoneNumbers.Add("0899 76 15 33");
Assert.AreEqual(1, entry.PhoneNumbers.Count);
Assert.AreEqual("Kalina", entry.Name);
}
public PhoneBookEntryDTO(PhonebookEntry data)
{
Id = data.Id.ToString();
UserId = data.User.Id.ToString();
Kind = (int)data.Kind;
PhoneNumber = data.PhoneNumber;
FirstName = data.FirstName;
Surname = data.Surname;
}
public ActionResult AddEmailToEntry([FromBody] PhonebookEntry phonebookEntry, string email)
{
using (var context = new SqlConnection("Server=localhost;Database=PhonebookTestDb;Trusted_Connection=True;"))
{
var sql = @"INSERT INTO Email VALUES @entryId, @email";
context.Execute(sql, new { @entryId = phonebookEntry.Id, @email = email });
}
return(Ok());
}
// Adds a phonebook entry to the internal hash table by key
private void AddEntry(string key, PhonebookEntry entry)
{
if (!this.book.ContainsKey(key))
{
this.book[key] = new List<PhonebookEntry>();
}
this.book[key].Add(entry);
}
// Adds an entry to the phonebook
public void Add(PhonebookEntry entry)
{
var names = entry.Name.Split(' ');
foreach (var name in names)
{
this.AddEntry(name, entry);
this.AddEntry(name + ' ' + entry.Town, entry);
}
}
public ActionResult AddEntry([FromBody] PhonebookEntry phonebookEntry)
{
using (var context = new SqlConnection("Server=localhost;Database=PhonebookTestDb;Trusted_Connection=True;"))
{
var sql = @"INSERT INTO [Entry] VALUES (@LastName, @FirstName, @PhoneNumber, @Email)";
context.Execute(sql, new { @LastName = phonebookEntry.LastName, @FirstName = phonebookEntry.FirstName, @PhoneNumber = phonebookEntry.PhoneNumber /*, @Email = phonebookEntry.Email*/ });
}
return(Ok());
}
public void EditEntry(PhonebookEntry editedEntry)
{
if (Book.ContainsKey(editedEntry.PhoneNumber))
{
Book[editedEntry.PhoneNumber] = editedEntry;
}
else
{
CreateEntry(editedEntry);
}
}
public async Task <IHttpActionResult> PatchPhonebookEntry(PhonebookEntry request)
{
if (ModelState.IsValid)
{
var response = await PhonebookService.EditPhonebookEntry(request);
return(Ok(response));
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> AddEntry(int id, [Bind("Name,Number,PhonebookID")] PhonebookEntry phoneBookEntry)
{
if (ModelState.IsValid)
{
_context.Add(phoneBookEntry);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(RedirectToAction(nameof(Index)));
}
public ActionResult <PhoneBookEntryDTO> Get(string id)
{
var user = GetCurrentUser();
if (user != null)
{
Guid.TryParse(id, out Guid entryId);
PhonebookEntry entry = _context.PhonebookEntries.FirstOrDefault(x => x.User.Id == user.Id && x.Id == entryId);
if (entry != null)
{
return(new PhoneBookEntryDTO(entry));
}
}
return(NotFound());
}
public PhonebookEntry[] ListEntries(int startIndex, int count)
{
if (startIndex < 0 || startIndex + count > this.entriesByName.Count)
{
throw new ArgumentOutOfRangeException("Invalid start index or count.");
}
PhonebookEntry[] matchedEntries = new PhonebookEntry[count];
for (int i = startIndex; i <= startIndex + count - 1; i++)
{
PhonebookEntry entry = this.entriesSorted[i];
matchedEntries[i - startIndex] = entry;
}
return matchedEntries;
}
public IEnumerable<PhonebookEntry> ListEntries(int first, int num)
{
if (first < 0 || first + num > this.phonebookEntriesByContactName.Count)
{
throw new ArgumentOutOfRangeException("Invalid range");
}
PhonebookEntry[] list = new PhonebookEntry[num];
for (int i = first; i <= first + num - 1; i++)
{
PhonebookEntry entry = this.sortedPhonebookEntries[i];
list[i - first] = entry;
}
return list;
}
public PhonebookEntry[] ListEntries(int first, int num)
{
if (first < 0 || first + num > this.dictEntries.Count)
{
throw new ArgumentOutOfRangeException();
}
PhonebookEntry[] list = new PhonebookEntry[num];
for (int i = first; i <= first + num - 1; i++)
{
PhonebookEntry entry = this.sortedEntries[i];
list[i - first] = entry;
}
return list;
}
public PhonebookEntry[] ListEntries(int first, int num)
{
if (first < 0 || first + num > this.dictEntries.Count)
{
throw new ArgumentOutOfRangeException();
}
PhonebookEntry[] list = new PhonebookEntry[num];
for (int i = first; i <= first + num - 1; i++)
{
PhonebookEntry entry = this.sortedEntries[i];
list[i - first] = entry;
}
return(list);
}
public IEnumerable <PhonebookEntry> ListEntries(int first, int num)
{
if (first < 0 || first + num > this.phonebookEntriesByContactName.Count)
{
throw new ArgumentOutOfRangeException("Invalid range");
}
PhonebookEntry[] list = new PhonebookEntry[num];
for (int i = first; i <= first + num - 1; i++)
{
PhonebookEntry entry = this.sortedPhonebookEntries[i];
list[i - first] = entry;
}
return(list);
}
public PhonebookEntry[] ListEntries(int start, int entriesPerPage)
{
if (start < 0 || start + entriesPerPage > this.entries.Count)
{
throw new ArgumentOutOfRangeException("Invalid start index or numbers per page.");
}
this.entries.ToList().Sort();
PhonebookEntry[] resultEntries = new PhonebookEntry[entriesPerPage];
for (int i = start; i < start + entriesPerPage; i++)
{
PhonebookEntry entry = this.entries[i];
resultEntries[i - start] = entry;
}
return resultEntries;
}
public PhonebookEntry[] ListEntries(int start, int entriesPerPage)
{
if (start < 0 || start + entriesPerPage > this.entries.Count)
{
throw new ArgumentOutOfRangeException("Invalid start index or numbers per page.");
}
this.entries.ToList().Sort();
PhonebookEntry[] resultEntries = new PhonebookEntry[entriesPerPage];
for (int i = start; i < start + entriesPerPage; i++)
{
PhonebookEntry entry = this.entries[i];
resultEntries[i - start] = entry;
}
return(resultEntries);
}
public IEnumerable <PhonebookEntry> ListEntries(int startEntryPosition, int entriesCount)
{
if (startEntryPosition < 0 || startEntryPosition + entriesCount > this.entries.Count)
{
throw new ArgumentOutOfRangeException("Invalid start index or count.");
}
this.entries.Sort();
var phonebookEntry = new PhonebookEntry[entriesCount];
for (int i = startEntryPosition; i <= startEntryPosition + entriesCount - 1; i++)
{
PhonebookEntry entry = this.entries[i];
phonebookEntry[i - startEntryPosition] = entry;
}
return(phonebookEntry);
}
public IEnumerable<PhonebookEntry> ListEntries(int startEntryPosition, int entriesCount)
{
if (startEntryPosition < 0 || startEntryPosition + entriesCount > this.entries.Count)
{
throw new ArgumentOutOfRangeException("Invalid start index or count.");
}
this.entries.Sort();
var phonebookEntry = new PhonebookEntry[entriesCount];
for (int i = startEntryPosition; i <= startEntryPosition + entriesCount - 1; i++)
{
PhonebookEntry entry = this.entries[i];
phonebookEntry[i - startEntryPosition] = entry;
}
return phonebookEntry;
}
public async Task <ActionResult> Delete(string id)
{
var user = GetCurrentUser();
if (user != null)
{
Guid.TryParse(id, out Guid entryId);
PhonebookEntry entry = _context.PhonebookEntries.FirstOrDefault(x => x.User.Id == user.Id && x.Id == entryId);
if (entry != null)
{
_context.Remove(entry);
_ = await _context.SaveChangesAsync();
return(Ok());
}
}
return(NotFound());
}
public void SetIds(PhonebookEntry phonebookEntry)
{
try
{
var id = Guid.Parse(Id);
phonebookEntry.SetId(id);
var bookId = Guid.Parse(PhonebookId);
phonebookEntry.SetPhonebookId(bookId);
}
catch (ArgumentNullException)
{
//TO DO: Log exception
throw;
}
catch (FormatException)
{
//TO DO: Log exception
throw;
}
}
public void ShoudAddSingleEntryWithMaxNumberOfPhones()
{
string[] numbersList =
{
"0899 76 15 33",
"(02) 981 22 33",
"123",
"(+1) 123 456 789",
"0883 / 456-789",
"0888 88 99 00",
"888-88-99-00",
"+359 (888) 41-80-12",
"00359 (888) 41-80-12",
"+359527734522"
};
var entry = new PhonebookEntry("Kalina", numbersList);
Assert.AreEqual(numbersList.Count(), entry.PhoneNumbers.Count);
Assert.AreEqual("Kalina", entry.Name);
}
public async Task <GenericApiResponse <object> > EditPhonebookEntry(PhonebookEntry entry)
{
GenericApiResponse <object> gResponse = new GenericApiResponse <object>();
object returnObj = null;
try
{
gResponse.Status = HttpStatusCode.OK;
gResponse.Message = "Success";
var parameters = new DynamicParameters();
parameters.Add("@entry_id", entry.Entry.Id, dbType: DbType.Int32);
parameters.Add("@first_name", entry.Entry.FirstName, dbType: DbType.String);
parameters.Add("@last_name", entry.Entry.LastName, dbType: DbType.String);
parameters.Add("@error_code", null, dbType: DbType.Int32, direction: ParameterDirection.Output);
parameters.Add("@error_msg", null, dbType: DbType.String, direction: ParameterDirection.Output, size: 200);
await PhonebookDbConnection.Connection.ExecuteAsync("sp_update_phonebook_entry", parameters, commandType : CommandType.StoredProcedure);
var errorOccured = Convert.ToBoolean(parameters.Get <dynamic>("@error_code"));
var errorMsg = (string)parameters.Get <dynamic>("@error_msg");
if (!errorOccured)
{
await WriteEntryRecords(entry, (int)entry.Entry.Id);
}
else
{
gResponse.Message = "Unable to update entry!";
}
}
catch (Exception ex)
{
gResponse.Status = HttpStatusCode.InternalServerError;
gResponse.Message = "Failure";
logger.Information(ex.Message);
}
gResponse.Payload = returnObj;
return(gResponse);
}
public bool AddPhone(string name, IEnumerable<string> phoneNumbers)
{
var nameLowercase = name.ToLowerInvariant();
PhonebookEntry entry;
bool isNewEntry = !this.entriesByName.TryGetValue(nameLowercase, out entry);
if (isNewEntry)
{
entry = new PhonebookEntry(name);
this.entriesByName.Add(nameLowercase, entry);
this.sortedEntries.Add(entry);
}
foreach (var num in phoneNumbers)
{
this.entriesByPhoneNumber.Add(num, entry);
}
entry.PhoneNumbers.UnionWith(phoneNumbers);
return isNewEntry;
}
public bool AddPhone(string name, IEnumerable<string> nums)
{
string nameToLower = name.ToLowerInvariant();
PhonebookEntry entry;
bool isNew = !this.nameEntries.TryGetValue(nameToLower, out entry);
if (isNew)
{
entry = new PhonebookEntry { Name = name, EntryPhoneNumbers = new SortedSet<string>() };
this.nameEntries.Add(nameToLower, entry);
this.sortedEntries.Add(entry);
}
foreach (var num in nums)
{
this.phoneEntries.Add(num, entry);
}
entry.EntryPhoneNumbers.UnionWith(nums);
return isNew;
}
public bool AddPhone(string name, IEnumerable <string> nums)
{
var old = from e in this.entries
where e.ContactName.ToLowerInvariant() == name.ToLowerInvariant()
select e;
bool flag;
if (old.Count() == 0)
{
PhonebookEntry obj = new PhonebookEntry();
obj.ContactName = name;
obj.PhoneNumbers = new SortedSet <string>();
foreach (var num in nums)
{
obj.PhoneNumbers.Add(num);
}
this.entries.Add(obj);
flag = true;
}
else if (old.Count() == 1)
{
PhonebookEntry obj2 = old.First();
foreach (var num in nums)
{
obj2.PhoneNumbers.Add(num);
}
flag = false;
}
else
{
Console.WriteLine("Duplicated name in the phonebook found: " + name);
return(false);
}
return(flag);
}
public bool AddPhone(string name, IEnumerable<string> phoneNumbers)
{
var matchedEntry =
from e in this.entries
where e.Name.ToLowerInvariant() == name.ToLowerInvariant()
select e;
//matchedEntry = this.entries
// .Where(entry => string.Equals(entry.Name, name, StringComparison.InvariantCultureIgnoreCase))
// .ToList();
bool isNewEntry;
if (matchedEntry.Count() == 0)
{
PhonebookEntry entry = new PhonebookEntry(name);
AddPhoneToEntry(phoneNumbers, entry);
this.entries.Add(entry);
isNewEntry = true;
}
else if (matchedEntry.Count() == 1)
{
PhonebookEntry existingEntry = matchedEntry.First();
var newPhoneNumbers = phoneNumbers
.Where(phoneNumber => !existingEntry.PhoneNumbers.Contains(phoneNumber))
.ToList();
AddPhoneToEntry(newPhoneNumbers, existingEntry);
isNewEntry = false;
}
else
{
throw new InvalidOperationException("Duplicate name.");
}
return isNewEntry;
}
public bool AddPhone(string name, IEnumerable<string> nums)
{
var old = from e in this.entries
where e.ContactName.ToLowerInvariant() == name.ToLowerInvariant()
select e;
bool flag;
if (old.Count() == 0)
{
PhonebookEntry obj = new PhonebookEntry();
obj.ContactName = name;
obj.PhoneNumbers = new SortedSet<string>();
foreach (var num in nums)
{
obj.PhoneNumbers.Add(num);
}
this.entries.Add(obj);
flag = true;
}
else if (old.Count() == 1)
{
PhonebookEntry obj2 = old.First();
foreach (var num in nums)
{
obj2.PhoneNumbers.Add(num);
}
flag = false;
}
else
{
Console.WriteLine("Duplicated name in the phonebook found: " + name);
return false;
}
return flag;
}
public void AddEntry(PhonebookEntry newEntry)
{
if (newEntry.FirstName != PhonebookEntry.NameDefaultValue)
{
this.dictByFirstName.Add(newEntry.FirstName, newEntry);
}
if (!(newEntry.MiddleName != PhonebookEntry.NameDefaultValue))
{
this.dictByMiddleName.Add(newEntry.MiddleName, newEntry);
}
if (newEntry.LastName != PhonebookEntry.NameDefaultValue)
{
this.dictByLastName.Add(newEntry.LastName, newEntry);
}
if (newEntry.NickName != PhonebookEntry.NameDefaultValue)
{
this.dictByNickname.Add(newEntry.NickName, newEntry);
}
}
public async Task <GenericApiResponse <object> > CreatePhonebookEntry(PhonebookEntry entry)
{
GenericApiResponse <object> gResponse = new GenericApiResponse <object>();
object returnObj = null;
try
{
gResponse.Status = HttpStatusCode.OK;
gResponse.Message = "Success";
var parameters = new DynamicParameters();
parameters.Add("@first_name", entry.Entry.FirstName, dbType: DbType.String);
parameters.Add("@last_name", entry.Entry.LastName, dbType: DbType.String);
parameters.Add("@ErrorCode", null, dbType: DbType.Int32, direction: ParameterDirection.Output);
parameters.Add("@ErrorMessage", null, dbType: DbType.String, direction: ParameterDirection.Output, size: 200);
var entryId = await PhonebookDbConnection.Connection.QueryFirstOrDefaultAsync <int?>("sp_create_phonebook_entry", parameters, commandType : CommandType.StoredProcedure);
if (entryId != null)
{
await WriteEntryRecords(entry, (int)entryId);
returnObj = new { Id = entryId };
}
else
{
gResponse.Message = "Unable to create entry!";
}
}
catch (Exception ex)
{
gResponse.Status = HttpStatusCode.InternalServerError;
gResponse.Message = "Failure";
logger.Information(ex.Message);
}
gResponse.Payload = returnObj;
return(gResponse);
}
public bool AddPhone(string name, IEnumerable <string> numbers)
{
string lowerName = name.ToLowerInvariant();
bool entryExists = this.dictEntries.ContainsKey(lowerName);
PhonebookEntry newEntry = new PhonebookEntry();
if (entryExists)
{
newEntry = new PhonebookEntry();
newEntry.Name = name;
this.dictEntries.Add(lowerName, newEntry);
this.sortedEntries.Add(newEntry);
}
foreach (var num in numbers)
{
this.multidictEntries.Add(num, newEntry);
}
newEntry.PhoneNumbers.UnionWith(numbers);
return(entryExists);
}
public async Task <ActionResult <Object> > Update(PhoneBookEntryDTO data)
{
var user = GetCurrentUser();
if (user != null)
{
Guid.TryParse(data.Id, out Guid entryId);
PhonebookEntry entry = _context.PhonebookEntries.FirstOrDefault(x => x.User.Id == user.Id && x.Id == entryId);
if (entry != null)
{
entry.FirstName = data.FirstName;
entry.Surname = data.Surname;
entry.PhoneNumber = data.PhoneNumber;
entry.Kind = (Enums.EntryKindEnum)data.Kind;
_ = await _context.SaveChangesAsync();
return(Ok());
}
}
return(NotFound());
}
public bool AddPhone(string name, IEnumerable<string> numbers)
{
string lowerName = name.ToLowerInvariant();
bool entryExists = this.dictEntries.ContainsKey(lowerName);
PhonebookEntry newEntry = new PhonebookEntry();
if (entryExists)
{
newEntry = new PhonebookEntry();
newEntry.Name = name;
this.dictEntries.Add(lowerName, newEntry);
this.sortedEntries.Add(newEntry);
}
foreach (var num in numbers)
{
this.multidictEntries.Add(num, newEntry);
}
newEntry.PhoneNumbers.UnionWith(numbers);
return entryExists;
}
public bool AddPhone(string name, IEnumerable<string> phoneNumbers)
{
// Create / find the phonebook entry
string nameLowercase = name.ToLowerInvariant();
PhonebookEntry entry;
bool isNewEntry = !this.entriesByName.TryGetValue(nameLowercase, out entry);
if (isNewEntry)
{
entry = new PhonebookEntry(name);
this.entriesByName.Add(nameLowercase, entry);
this.entriesSorted.Add(entry);
}
// Add the entry by phone
foreach (var phoneNumber in phoneNumbers)
{
this.entriesByPhone.Add(phoneNumber, entry);
}
// Add / merge the phone numbers
entry.Phones.UnionWith(phoneNumbers);
return isNewEntry;
}
/// <summary>Adds new phone to the phonebook.</summary>
/// <param name="name">The name of the owner to whom the list of numbers will be associated with.</param>
/// <param name="phoneNumbers">The list of numbers associated with the owner.</param>
/// <returns>The method returns true if the name is already in the phonebook and false if not.</returns>
/// <exception cref="System.NullReferenceException">Throws NullReference exception on name or numbers list being null.</exception>
/// <remarks>
/// The name might already exist. In this case the list of numbers is merged with the list in the phonebook leaving
/// only unique numbers in it. If it doesn't exist a new entry is created and all numbers are added.
/// </remarks>
public bool AddPhone(string name, IEnumerable<string> phoneNumbers)
{
string nameToLower = name.ToLowerInvariant();
PhonebookEntry entry;
bool phoneExists = this.namesDictionary.TryGetValue(nameToLower, out entry);
if (!phoneExists)
{
entry = new PhonebookEntry();
entry.Name = name;
entry.PhoneNumbers = new SortedSet<string>();
this.namesDictionary.Add(nameToLower, entry);
this.entriesSorted.Add(entry);
}
foreach (var number in phoneNumbers)
{
this.phonesDictionary.Add(number, entry);
}
entry.PhoneNumbers.UnionWith(phoneNumbers);
return phoneExists;
}
public void CreateEntry(PhonebookEntry newEntry)
{
Book.Add(newEntry.PhoneNumber, newEntry);
}
public IEnumerable <PhonebookEntry> QueryPhonebook(PhonebookStorage storage, int startIndex, int endIndex)
{
CpbsSet(storage);
return(PhonebookEntry.Parse(GetATCommandResponse(string.Format("AT+CPBR={0},{1}\r", startIndex, endIndex))));
}
/// <summary>
/// Lists entries from specified index to specified length.
/// </summary>
/// <param name="startIndex"></param>
/// <returns>Result filtered entries of PhoneEntry type.</returns>
/// <remarks></remarks>
/// <exception cref="System.ArgumentOutOfRangeException">Invalid start index or count.</exception>
public PhonebookEntry[] ListEntries(int startIndex, int entriesToReturn)
{
if (startIndex < 0 || startIndex + entriesToReturn > entries.Count)
{
throw new ArgumentOutOfRangeException("Invalid start index or count.");
}
entries.Sort();
PhonebookEntry[] resultEntries = new PhonebookEntry[entriesToReturn];
int maximalConter = startIndex + entriesToReturn - 1;
for (int i = startIndex; i <= maximalConter; i++)
{
resultEntries[i - startIndex] = entries[i];
}
return resultEntries;
}
private static void AddPhoneToEntry(IEnumerable<string> phoneNumbers, PhonebookEntry entry)
{
foreach (var phoneNumber in phoneNumbers)
{
entry.PhoneNumbers.Add(phoneNumber);
}
}
public void DeleteDBEntry(PhonebookEntry entry)
{
this.data.PhonebookEntries.Delete(entry);
this.data.SaveChanges();
}
public void CreateDBEntry(PhonebookEntry entry)
{
this.data.PhonebookEntries.Add(entry);
this.data.SaveChanges();
}
/// <summary>Lists phonebook entries from the phonebook.</summary>
/// <param name="startIndex">The index where the retrieval of numbers will start.</param>
/// <param name="count">The number of entries to be retrieved.</param>
/// <returns>Returns an array of sorted entries by name.</returns>
/// <exception cref="System.ArgumentOutOfRangeException">
/// System.ArgumentOutOfRangeException is thrown if startIndex is outside of the namesDictionary bounds
/// or if there aren't so many elements starting from the specified position.
/// </exception>
public PhonebookEntry[] ListEntries(int startIndex, int count)
{
if (startIndex < 0 || startIndex + count > this.namesDictionary.Count)
{
throw new ArgumentOutOfRangeException("Index was out of phonebook's range.");
}
PhonebookEntry[] enrtiesSelected = new PhonebookEntry[count];
for (int i = startIndex; i <= startIndex + count - 1; i++)
{
PhonebookEntry entry = this.entriesSorted[i];
enrtiesSelected[i - startIndex] = entry;
}
return enrtiesSelected;
}
public IList<PhonebookEntry> ListEntries(int startIndex, int count)
{
if (startIndex < 0 || startIndex + count > this.entries.Count)
{
throw new ArgumentOutOfRangeException("Invalid start index or count.");
}
//objListOrder.Sort((x, y) => x.OrderDate.CompareTo(y.OrderDate));
this.entries.Sort((x, y) => x.Name.CompareTo(y.Name));
var listedEntries = new PhonebookEntry[count];
for (int i = startIndex; i <= startIndex + count - 1; i++)
{
var entry = this.entries[i];
listedEntries[i - startIndex] = entry;
}
return listedEntries;
}
public static PhonebookEntry Create(Phonebook phonebook)
{
var entry = new PhonebookEntry(phonebook);
return(entry);
}
