public IHttpActionResult AddContact([FromBody] RequestContact contactRequest)
{
try
{
string result = ValidateContact(contactRequest);
if (!string.IsNullOrEmpty(result))
{
ModelState.AddModelError("request", result);
return(BadRequest(ModelState));
}
var contact = new Contact();
contact.FirstName = contactRequest.FirstName;
contact.LastName = contactRequest.LastName;
contact.Email = contactRequest.Email;
contact.PhoneNumber = contactRequest.PhoneNumber;
contact.Status = true;
this.contactsRepository.AddContact(contact);
}
catch (Exception ex)
{
_log.Error("Error occured in AddContact method:", ex);
ModelState.AddModelError("request", "Some error has occured.");
return(BadRequest(ModelState));
}
return(Ok());
}
// [Route("api/contacts/filter")]
public async Task <HttpResponseMessage> PostFilterOrderBy([FromBody] RequestContact model)
{
var data = await manager.FilterOrderByRequestAsync(model);
if (ReferenceEquals(data, null))
{
return(Create400());
}
return(Create200(data));
}
public async Task <IHttpActionResult> PostQueryContacts([FromBody] RequestContact request, int?start = null, int?rows = null, int?date = null,
int?name = null, int?company = null, int?country = null, int?position = null)
{
KeyValuePair <int, List <ViewContactSimple> > data = await appManager.GetQueryContactsAsync(request, start, rows, date, name, company, country, position);
if (data.Value == null)
{
return(NotFound());
}
return(Ok(data));
}
public bool UpdateStatus(int id)
{
RequestContact contact = new RequestContact();
contact.ID = id;
contact = ctr.GetObject <RequestContact>(contact);
if (contact != null)
{
contact.Status = true;
ctr.Update <RequestContact>(contact);
return(true);
}
return(false);
}
public override int GetHashCode()
{
int hashCode = 786331036;
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(Text);
hashCode = hashCode * -1521134295 + RequestContact.GetHashCode();
hashCode = hashCode * -1521134295 + RequestLocation.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <KeyboardButtonPollType?> .Default.GetHashCode(RequestPoll);
hashCode = hashCode * -1521134295 + EqualityComparer <WebAppInfo?> .Default.GetHashCode(WebApp);
return(hashCode);
}
public async Task <IHttpActionResult> PostCreateContact([FromBody] RequestContact contact)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Contact contactToAdd = new Contact();
Contact addedcontact = await appManager.AddOrUpdateContactAsync(contactToAdd, contact, true);
if (addedcontact != null)
{
return(Created($"Contacts?guid = {addedcontact.GuID}", new ViewContact(addedcontact)));
}
return(BadRequest("Contact with such an email address is already exist"));
}
public string ValidateContact(RequestContact contact)
{
if (string.IsNullOrEmpty(contact.FirstName))
{
return("First name cannot be empty.");
}
if (string.IsNullOrEmpty(contact.LastName))
{
return("Last name cannot be empty.");
}
if (string.IsNullOrEmpty(contact.Email))
{
return("Email cannot be empty.");
}
if (string.IsNullOrEmpty(contact.PhoneNumber))
{
return("PhoneNumber cannot be empty.");
}
return(string.Empty);
}
public int UpdateRequestTypeBasedContacts(Admin adminObj)
{
try
{
adminServ = new AdminService();
int isSuccess = adminServ.AddUserData(adminObj);
RequestContact requestContactObj = new RequestContact();
requestContactObj.RequestContact_ID = adminObj.Id;
requestContactObj.UserID = adminObj.UserId;
isSuccess = adminServ.UpdateContactBasedonRequestType(requestContactObj);
return(isSuccess);
}
catch (Exception ex)
{
NameValueCollection additionalInfo = new NameValueCollection();
additionalInfo.Add("PageName", "Admin");
ExceptionManager.Publish(ex, additionalInfo);
return(420);
}
}
public async Task <IHttpActionResult> PutUpdateContact([FromBody] RequestContact contact)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Contact contactToUpdate = await appManager.GetContactByGuIdAsync(contact.GuID);
if (contactToUpdate == null)
{
return(NotFound());
}
Contact updatedcontact = await appManager.AddOrUpdateContactAsync(contactToUpdate, contact, false);
if (updatedcontact != null)
{
return(Ok(new ViewContact(updatedcontact)));
}
return(BadRequest("Contact with such an email address is already exist"));
}
public IHttpActionResult EditContact(int contactId, [FromBody] RequestContact contactRequest)
{
try
{
var contact = this.contactsRepository.GetContactById(contactId);
if (contact == null)
{
ModelState.AddModelError("request", "Contact with the provided Id is not present.");
return(BadRequest(ModelState));
}
if (!string.IsNullOrEmpty(contactRequest.LastName))
{
contact.LastName = contactRequest.LastName;
}
if (!string.IsNullOrEmpty(contactRequest.PhoneNumber))
{
contact.PhoneNumber = contactRequest.PhoneNumber;
}
if (!string.IsNullOrEmpty(contactRequest.FirstName))
{
contact.FirstName = contactRequest.FirstName;
}
if (!string.IsNullOrEmpty(contactRequest.Email))
{
contact.Email = contactRequest.Email;
}
this.contactsRepository.UpdateContact(contact);
}
catch (Exception ex)
{
_log.Error("Error occured in EditContact method:", ex);
ModelState.AddModelError("request", "Some error has occured.");
return(BadRequest(ModelState));
}
return(Ok("Contact updated successfully."));
}
static RequestContact FromCsv(string csvLine)
{
string[] values = csvLine.Split(',');
RequestContact contactValues = new RequestContact();
for (int i = 0; i < 5; i++)
{
if (values[i] == null || values[i].Length < 1)
{
return(null);
}
}
if (!EmailValidator(values[4]))
{
return(null);
}
contactValues.FullName = values[0];
contactValues.CompanyName = values[1];
contactValues.Position = values[2];
contactValues.Country = values[3];
contactValues.Email = values[4];
return(contactValues);
}
public async Task <List <ViewContactLess> > FilterSortAsync(RequestContact model, FilterBy filter)
{
var data = new List <Contact>();
var sortby = model.SortBy;
var filterby = model.FilterBy;
#region SWITCH
switch (filter)
{
case FilterBy.Name:
data = await
_database.Contacts
.Where(p => p.FullName == filterby.FullName)
.ToListAsync();
break;
case FilterBy.Company:
data = await
_database.Contacts
.Where(p => p.CompanyName == filterby.CompanyName)
.ToListAsync();
break;
case FilterBy.NameCompany:
data =
await
_database.Contacts.Where(
p => p.FullName == filterby.FullName && p.CompanyName == filterby.CompanyName)
.ToListAsync();
break;
case FilterBy.Position:
data = await _database.Contacts.Where(p => p.Position == filterby.Position).ToListAsync();
break;
case FilterBy.NamePosition:
data =
await
_database.Contacts.Where(
p => p.FullName == filterby.FullName && p.Position == filterby.Position).ToListAsync();
break;
case FilterBy.NameCompanyPosition:
data =
await
_database.Contacts.Where(
p =>
p.FullName == filterby.FullName && p.CompanyName == filterby.CompanyName &&
p.Position == filterby.Position).ToListAsync();
break;
case FilterBy.Country:
data = await _database.Contacts.Where(p => p.Country == filterby.Country).ToListAsync();
break;
case FilterBy.NameCountry:
data =
await
_database.Contacts.Where(
p => p.FullName == filterby.FullName && p.Country == filterby.Country).ToListAsync();
break;
case FilterBy.NameCompanyCountry:
data =
await
_database.Contacts.Where(
p =>
p.FullName == filterby.FullName && p.CompanyName == filterby.CompanyName &&
p.Country == filterby.Country).ToListAsync();
break;
case FilterBy.NameCompanyPositionCountry:
data =
await
_database.Contacts.Where(
p =>
p.FullName == filterby.FullName && p.CompanyName == filterby.CompanyName &&
p.Position == filterby.Position && p.Country == filterby.Country).ToListAsync();
break;
case FilterBy.NamePositionCountry:
data =
await
_database.Contacts.Where(
p =>
p.FullName == filterby.FullName && p.Position == filterby.Position &&
p.Country == filterby.Country).ToListAsync();
break;
case FilterBy.CountryPosition:
data =
await
_database.Contacts.Where(
p => p.Country == filterby.Country && p.Position == filterby.Position).ToListAsync();
break;
}
#endregion
#region PAGING
string first = "Start", second = "Count";
if (sortby.ContainsKey(first) && sortby.ContainsKey(second))
{
int start;
bool st = int.TryParse(sortby[first], out start);
int count;
bool end = int.TryParse(sortby[second], out count);
if (st && end)
{
data = Paging(data, start, count);
}
}
#endregion
#region ORDERBY
if (sortby.ContainsKey("OrderBy"))
{
string orderby = sortby["OrderBy"];
if (orderby == "Ascending" || orderby == "0" || orderby == "Asc")
{
data = Sort(data, OrderBy.Ascending);
}
if (orderby == "Descending" || orderby == "1" || orderby == "Desc")
{
data = Sort(data, OrderBy.Descending);
}
}
#endregion
var list = new List <ViewContactLess>();
AutoMapper.Mapper.Map(data, list);
return(list);
}
public async Task <List <ViewContactLess> > FilterOrderByRequestAsync(RequestContact request)
{
if (ReferenceEquals(request, null))
{
return(null);
}
ViewContactLess filter = request.FilterBy;
List <ViewContactLess> result = new List <ViewContactLess>();
try
{
if (filter.FullName != null)
{
result = await FilterSortAsync(request, FilterBy.Name);
}
if (filter.CompanyName != null)
{
result = await FilterSortAsync(request, FilterBy.Company);
if (filter.FullName != null)
{
result = await FilterSortAsync(request, FilterBy.NameCompany);
}
}
if (filter.Position != null)
{
result = await FilterSortAsync(request, FilterBy.Position);
if (filter.FullName != null)
{
result = await FilterSortAsync(request, FilterBy.NamePosition);
}
if (filter.CompanyName != null)
{
result = await FilterSortAsync(request, FilterBy.CompanyPosition);
}
if (filter.FullName != null && filter.CompanyName != null)
{
result = await FilterSortAsync(request, FilterBy.NameCompanyPosition);
}
}
if (filter.Country != null)
{
result = await FilterSortAsync(request, FilterBy.Country);
if (filter.FullName != null)
{
result = await FilterSortAsync(request, FilterBy.NameCountry);
}
if (filter.Position != null)
{
result = await FilterSortAsync(request, FilterBy.CountryPosition);
}
if (filter.FullName != null && filter.Position != null)
{
result = await FilterSortAsync(request, FilterBy.NamePositionCountry);
}
}
return(result);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <Contact> AddOrUpdateContactAsync(Contact contactToAddOrUpdate, RequestContact requestContact, bool flag)
{
if (requestContact == null)
{
return(null); // in case of uploading file.
}
using (DbContextTransaction transaction = db.Database.BeginTransaction())
{
contactToAddOrUpdate.FullName = requestContact.FullName;
contactToAddOrUpdate.Country = requestContact.Country;
contactToAddOrUpdate.CompanyName = requestContact.CompanyName;
contactToAddOrUpdate.Email = requestContact.Email;
contactToAddOrUpdate.Position = requestContact.Position;
if (requestContact.EmailLists != null)
{
contactToAddOrUpdate.EmailLists.Clear();
foreach (var emaillistId in requestContact.EmailLists)
{
EmailList emlist = await db.EmailLists.FirstOrDefaultAsync(x => x.EmailListID == emaillistId);
if (emlist != null)
{
contactToAddOrUpdate.EmailLists.Add(emlist);
}
}
}
if (flag)
{
if ((await db.Contacts.CountAsync(e => e.Email == contactToAddOrUpdate.Email) > 0))
{
return(null);
}
contactToAddOrUpdate.GuID = Guid.NewGuid();
contactToAddOrUpdate.DateInserted = DateTime.Now;
db.Contacts.Add(contactToAddOrUpdate);
}
else
{
if ((await db.Contacts.CountAsync(e => e.Email == contactToAddOrUpdate.Email && e.GuID != contactToAddOrUpdate.GuID) > 0))
{
return(null);
}
contactToAddOrUpdate.Modified = DateTime.Now;
db.Contacts.AddOrUpdate(contactToAddOrUpdate);
}
try
{
await db.SaveChangesAsync();
transaction.Commit();
return(contactToAddOrUpdate);
}
catch
{
transaction.Rollback();
throw;
}
}
}
public async Task <KeyValuePair <int, List <ViewContactSimple> > > GetQueryContactsAsync(RequestContact request, int?start, int?rows, int?
dt, int?fn, int?cmp, int?cnt, int?pos)
{
db.Configuration.LazyLoadingEnabled = false;
IQueryable <Contact> data = db.Contacts;
// TODO: Add OrderBy().ThenBy()..... multiple ordring
if (request != null)
{
if (request.FullName != null)
{
data = data.Where(x => x.FullName == request.FullName);
}
if (request.CompanyName != null)
{
data = data.Where(x => x.CompanyName == request.CompanyName);
}
if (request.Country != null)
{
data = data.Where(x => x.Country == request.Country);
}
if (request.Position != null)
{
data = data.Where(x => x.Position == request.Position);
}
if (request.Email != null)
{
data = data.Where(x => x.Email == request.Email);
}
}
if (fn.HasValue || cmp.HasValue || cnt.HasValue || pos.HasValue || dt.HasValue)
{
if (fn.HasValue)
{
data = fn != 0 ? data.OrderBy(x => x.FullName) : data.OrderByDescending(x => x.FullName);
}
if (cmp.HasValue)
{
data = cmp != 0 ? data.OrderBy(x => x.CompanyName) : data.OrderByDescending(x => x.CompanyName);
}
if (cnt.HasValue)
{
data = cnt != 0 ? data.OrderBy(x => x.Country) : data.OrderByDescending(x => x.Country);
}
if (pos.HasValue)
{
data = pos != 0 ? data.OrderBy(x => x.Position) : data.OrderByDescending(x => x.Position);
}
if (dt.HasValue)
{
data = dt != 0 ? data.OrderBy(x => x.DateInserted) : data.OrderByDescending(x => x.DateInserted);
}
}
else
{
data = data.OrderBy(x => x.DateInserted);
}
int pagecount = 1;
if (start.HasValue && rows.HasValue)
{
pagecount = await data.CountAsync() >= rows.Value ? (await data.CountAsync() % rows.Value == 0) ?
(await data.CountAsync() / rows.Value) : (await data.CountAsync() / rows.Value + 1) : 1;
}
if (start.HasValue && rows.HasValue)
{
data = data.Skip(start.Value).Take(rows.Value);
}
var contacts = new List <ViewContactSimple>();
await data.ForEachAsync(p => contacts.Add(new ViewContactSimple(p)));
return(new KeyValuePair <int, List <ViewContactSimple> >(pagecount, contacts));
}
static List <RequestContact> ReadExcelFile(string filename)
{
List <RequestContact> contacts = new List <RequestContact>();
string[] strProperties = new string[5];
RequestContact contact;
int j = 0;
using (SpreadsheetDocument myDoc = SpreadsheetDocument.Open(filename, false))
{
WorkbookPart workbookPart = myDoc.WorkbookPart;
IEnumerable <Sheet> Sheets = myDoc.WorkbookPart.Workbook.GetFirstChild <Sheets>().Elements <Sheet>();
string relationshipId = Sheets?.First().Id.Value;
WorksheetPart worksheetPart = (WorksheetPart)myDoc.WorkbookPart.GetPartById(relationshipId);
SheetData sheetData = worksheetPart.Worksheet.GetFirstChild <SheetData>();
int i = 1;
string value;
foreach (Row r in sheetData.Elements <Row>())
{
if (i != 1)
{
foreach (Cell c in r.Elements <Cell>())
{
if (c == null)
{
continue;
}
value = c.InnerText;
if (c.DataType != null)
{
var stringTable = workbookPart.GetPartsOfType <SharedStringTablePart>().FirstOrDefault();
if (stringTable != null)
{
value = stringTable.SharedStringTable.ElementAt(int.Parse(value)).InnerText;
}
}
strProperties[j] = value;
j = j + 1;
}
}
j = 0;
i++;
if (strProperties.Any(p => p == null || p.Length < 1))
{
contacts.Add(null); continue;
}
if (!EmailValidator(strProperties[4]))
{
contacts.Add(null); continue;
}
contact = new RequestContact();
contact.FullName = strProperties[0];
contact.CompanyName = strProperties[1];
contact.Position = strProperties[2];
contact.Country = strProperties[3];
contact.Email = strProperties[4];
contacts.Add(contact);
}
return(contacts);
}
}
