public ActionResult Index(ContactFilterDto filterBox)
{
var contactListDto = new List <ContactListDto>();
var contactClients = _hermesDataContext.Contacts.Select(x => x.KntId).Distinct().ToList();
var clients = _optimaDbContext.Kontrahenci.Where(x => contactClients.Contains(x.Knt_KntId)).ToList();
foreach (var item in _hermesDataContext.Contacts.ToList())
{
var user = _hermesDataContext.Users.Find(item.ApplicationUserId);
var client = clients.SingleOrDefault(y => y.Knt_KntId == item.KntId);
contactListDto.Add(new ContactListDto
{
Id = item.Id,
ClientName = client != null ? client.Knt_Nazwa1 : string.Empty,
ApplicationUser = item.ApplicationUser,
ApplicationUserId = item.ApplicationUserId,
CreateDate = item.CreateDate,
EndDate = item.EndDate,
SelectedContactType = item.SelectedContactType,
KntId = item.KntId,
Note = item.Note,
WorkerName = user.FirstName + " " + user.LastName,
});
}
var dataFormatter = new ContactDataFormat(filterBox);
SetHeaders("Kontakty", "Lista wszystkich kontaktów", "Index", "Contact");
SetViewParams(dataFormatter.SortParam, dataFormatter.Page, dataFormatter.PageSize);
var listData = dataFormatter.GetFormattedData(contactListDto)
.ToPagedList(dataFormatter.Page, dataFormatter.PageSize);
return(PartialView("_PagedListPartial", listData));
}
public List <ContactExcelDto> GetExcelData(ContactFilterDto input)
{
return(contactRepository.GetAll()
.Where(p => p.ContactType == ContactType.GetInTouch)
.WhereIf(input.FullName.IsNotNullOrEmpty(), p => p.FullName.Contains(input.FullName))
.WhereIf(input.Email.IsNotNullOrEmpty(), p => p.Email.Contains(input.Email))
.WhereIf(input.Phone.IsNotNullOrEmpty(), p => p.Phone == input.Phone)
.Where(p => p.IsDeleted == false)
.ToList()
.Select(p => p.MapTo <ContactExcelDto>())
.ToList());
}
public ActionResult <PagedListDto <ContactDto> > Search([FromQuery] ContactFilterDto filterDto)
{
// map filters
var filter = _mapper.Map <ContactFilter>(filterDto);
var paging = _mapper.Map <PagingFilter>(filterDto);
// query repository
var pagedList = _repository.Search(filter, paging);
// map to dto and return
var pagedListDto = _mapper.Map <PagedListDto <ContactDto> >(pagedList);
return(pagedListDto);
}
public async Task <IActionResult> Get([FromQuery] ContactFilterDto filter)
{
try
{
var pageSize = filter.PageSize ?? 10;
var skip = 0;
if (filter.Page.HasValue && filter.Page.Value > 1)
{
skip = (filter.Page.Value - 1) * pageSize;
}
var predicate = BuildFilter(filter);
var filterExpression = predicate.Expand();
var entities = await _dbContext.Contacts
.Where(filterExpression)
.OrderBy(fld => fld.LastName)
.Skip(skip)
.Take(pageSize)
.ToListAsync();
var models = entities.Select(ent => new ContactDto
{
BusinessEntityID = ent.BusinessEntityID,
Street = ent.Street,
LastName = ent.LastName,
City = ent.City,
CountryRegion = ent.CountryRegion,
EMailAddress = ent.EMailAddress,
FirstName = ent.FirstName,
MiddleName = ent.MiddleName,
ModifiedDate = ent.ModifiedDate,
PostalCode = ent.PostalCode,
StateProvince = ent.StateProvince,
TelephoneNumber = ent.TelephoneNumber
});
return(Ok(models));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public virtual async Task <PagedResultDto <ContactDto> > GetAll(ContactFilterDto input)
{
var query = contactRepository.GetAll()
.Where(p => p.ContactType == ContactType.GetInTouch)
.WhereIf(input.FullName.IsNotNullOrEmpty(), p => p.FullName.Contains(input.FullName))
.WhereIf(input.Email.IsNotNullOrEmpty(), p => p.Email.Contains(input.Email))
.WhereIf(input.Phone.IsNotNullOrEmpty(), p => p.Phone == input.Phone);
var totalCount = await query.CountAsync();
query = ApplySorting(query, input);
query = ApplyPaging(query, input);
var entities = await query.ToListAsync();
return(new PagedResultDto <ContactDto>(
totalCount,
entities.Select(p => p.MapTo <ContactDto>())
.ToList()
));
}
public static Expression <Func <ContactInfoEntity, bool> > BuildFilter(ContactFilterDto filter)
{
var predicate = PredicateBuilder.New <ContactInfoEntity>()
.And(x => x.BusinessEntityID > 0);
if (!string.IsNullOrWhiteSpace(filter.Address))
{
var addressFilter = PredicateBuilder.New <ContactInfoEntity>()
.Or(x => x.Street.Contains(filter.Address))
.Or(x => x.City.Contains(filter.Address))
.Or(x => x.CountryRegion.Contains(filter.Address))
.Or(x => x.PostalCode.Contains(filter.Address));
predicate = predicate.And(addressFilter);
}
if (!string.IsNullOrWhiteSpace(filter.City))
{
predicate = predicate.And(flt => flt.City.Contains(filter.Address));
}
if (!string.IsNullOrWhiteSpace(filter.Name))
{
var nameFilter = PredicateBuilder.New <ContactInfoEntity>()
.Or(x => x.FirstName.Contains(filter.Name))
.Or(x => x.LastName.Contains(filter.Name))
.Or(x => x.MiddleName.Contains(filter.Name));
predicate = predicate.And(nameFilter);
}
if (filter.DateFrom.HasValue)
{
var date = filter.DateFrom.Value.LocalDateTime;
predicate = predicate.And(ent => ent.ModifiedDate >= date);
}
if (filter.DateTo.HasValue)
{
var date = filter.DateTo.Value.LocalDateTime.AddDays(1);
predicate = predicate.And(ent => ent.ModifiedDate < date);
}
return(predicate);
}
protected virtual IQueryable <Contact> ApplyPaging(IQueryable <Contact> query, ContactFilterDto input)
{
var pagedInput = input as IPagedResultRequest;
if (pagedInput != null)
{
return(query.PageBy(pagedInput));
}
var limitedInput = input as ILimitedResultRequest;
if (limitedInput != null)
{
return(query.Take(limitedInput.MaxResultCount));
}
return(query);
}
protected virtual IQueryable <Contact> ApplySorting(IQueryable <Contact> query, ContactFilterDto input)
{
var sortInput = input as ISortedResultRequest;
if (sortInput != null)
{
if (sortInput.Sorting.IsNotNullOrEmpty())
{
return(query.OrderBy(sortInput.Sorting));
}
}
if (input is ILimitedResultRequest)
{
return(query.OrderByDescending(e => e.Id));
}
return(query);
}
public async Task <IActionResult> Query(int skip = 0, int take = 10, [FromQuery] ContactFilterDto contactFilter = null)
{
var queryable = _contactService.Queryable();
if (contactFilter?.Domain != null)
{
queryable = queryable.Where(x => x.UrlTracking.Domain.Contains(contactFilter.Domain));
}
if (contactFilter?.FromTime != DateTime.MinValue && contactFilter?.ToTime != DateTime.MinValue)
{
queryable = queryable.Where(x => x.CreatedDate.Date >= contactFilter.FromTime.Date && x.CreatedDate.Date <= contactFilter.ToTime.Date);
}
if (contactFilter != null && !string.IsNullOrEmpty(contactFilter.UtmCampaign))
{
queryable = queryable.Where(x => x.UrlTracking.UtmCampaign.Contains(contactFilter.UtmCampaign));
}
if (contactFilter != null && !string.IsNullOrEmpty(contactFilter.UtmAdset))
{
queryable = queryable.Where(x => x.UrlTracking.UtmAdset.Contains(contactFilter.UtmAdset));
}
if (contactFilter != null && !string.IsNullOrEmpty(contactFilter.UtmAds))
{
queryable = queryable.Where(x => x.UrlTracking.UtmAds.Contains(contactFilter.UtmAds));
}
if (contactFilter != null && !string.IsNullOrEmpty(contactFilter.UtmAgent))
{
queryable = queryable.Where(x => x.UrlTracking.UtmAgent.Contains(contactFilter.UtmAgent));
}
if (contactFilter != null && !string.IsNullOrEmpty(contactFilter.UtmMedium))
{
queryable = queryable.Where(x => x.UrlTracking.UtmMedium.Contains(contactFilter.UtmMedium));
}
if (contactFilter != null && !string.IsNullOrEmpty(contactFilter.UtmSource))
{
queryable = queryable.Where(x => x.UrlTracking.UtmSource.Contains(contactFilter.UtmSource));
}
if (contactFilter != null && !string.IsNullOrEmpty(contactFilter.UtmTeam))
{
queryable = queryable.Where(x => x.UrlTracking.UtmTeam.Contains(contactFilter.UtmTeam));
}
var list = new QueryResult <Contact>
{
Items = await queryable
.Include(x => x.UrlTracking)
.OrderByDescending(x => x.CreatedDate)
.Skip(skip).Take(take)
.Select(x => new Contact()
{
Id = x.Id,
Data = x.Data,
AdsLinkId = x.AdsLinkId,
UrlTracking = x.UrlTracking,
CreatedDate = x.CreatedDate,
UpdatedDate = x.UpdatedDate
}).ToListAsync(),
Count = await queryable.CountAsync()
};
return(Ok(list));
}
