public PagingResponse <Music> GetByArtistId(string artistId, SearchSortType sortType, PagingRequest pageRequest)
{
var res = new PagingResponse <Music>();
try
{
RepositoryPagingResponse <Music> repositoryRes = (this._rep as IMusicsRepository).
GetByArtistId(artistId,
pageRequest.ResultInPage,
(pageRequest.Page - 1) * pageRequest.ResultInPage,
sortType);
res.Entities = repositoryRes.Entities;
res.CurrPage = pageRequest.Page;
res.ResultsInPage = pageRequest.ResultInPage;
res.TotalResults = repositoryRes.TotalResults;
res.Success = true;
}
catch (Exception e)
{
res.Success = false;
res.Message = "אירעה שגיאה בחיפוש היצירות";
}
return(res);
}
public PagingResponse <LeadMusicLog> GetMusicLogByAction(LogType action, DateTime start, DateTime end, PagingRequest pageReq)
{
var res = new PagingResponse <LeadMusicLog>(pageReq);
res.Success = true;
try
{
RepositoryPagingResponse <LeadMusicLog> dbRes = new RepositoryPagingResponse <LeadMusicLog>();
switch (action)
{
case LogType.Purchase:
dbRes = _purchRep.GetMusicsPurchase(start, end, (pageReq.Page - 1) * pageReq.ResultInPage, pageReq.ResultInPage);
break;
case LogType.MusicView:
dbRes = _rep.GetMusicLogByAction(LogActionType.Watch, start, end, (pageReq.Page - 1) * pageReq.ResultInPage, pageReq.ResultInPage);
break;
default:
res.Success = false;
res.Message = string.Format("Action - {0}, not supported for GetMusicLogByAction method", action.ToString());
break;
}
res.TotalResults = dbRes.TotalResults;
res.Entities = dbRes.Entities;
res.Success = true;
}
catch (Exception e)
{
res.Success = false;
res.Message = e.ToString();
}
return(res);
}
public RepositoryPagingResponse <NCRegister> Get(int max, int skip, DateTime s, DateTime e, NCUserType?nCUserType)
{
RepositoryPagingResponse <NCRegister> res =
new RepositoryPagingResponse <NCRegister>();
IQueryable <NCRegister> query = this.dbSet.Include("User");
if (s != null && e != null)
{
query = query.Where(p => p.DateTime >= s && p.DateTime <= e);
}
if (nCUserType != null)
{
query = query.Where(p => p.NCUserType == nCUserType);
}
res.TotalResults = query.Count();
query = query.OrderBy(p => p.DateTime);
res.Entities = query
.Skip(skip)
.Take(max)
.ToList() as IEnumerable <NCRegister>;
return(res);
}
public RepositoryPagingResponse <Music> GetByArtistId(string artistId, int max, int skip, SearchSortType sortType)
{
var res = new RepositoryPagingResponse <Music>();
var query = ActiveMusics.Where(m => m.ArtistID == artistId);
res.TotalResults = query.Count();
IOrderedQueryable <Music> orderQuery = null;
switch (sortType)
{
case SearchSortType.LengthDesc:
orderQuery = query.OrderByDescending(msc => msc.MusicLength);
break;
case SearchSortType.LengthAsc:
orderQuery = query.OrderBy(msc => msc.MusicLength);
break;
default:
orderQuery = query.OrderByDescending(msc => msc.CreateDate);
break;
}
res.Entities = orderQuery
.Skip(skip)
.Take(max)
.ToList();
return(res);
}
public RepositoryPagingResponse <Purchase> Get(int max, int skip, DateTime s, DateTime e, PurchaseStatus?ps, bool WithoutPhonePurchase)
{
RepositoryPagingResponse <Purchase> res =
new RepositoryPagingResponse <Purchase>();
IQueryable <Purchase> query = ConfirmedPurchase;
// Set Where
if (s != null && e != null)
{
query = query.Where(p => p.PurchaseDate >= s && p.PurchaseDate <= e);
}
if (ps != null)
{
query = query.Where(p => p.PurchaseStatus == ps.Value);
}
if (WithoutPhonePurchase)
{
query = query.Where(p => p.PurchaseStatus != PurchaseStatus.NotPaidBycustomer);
}
query = query.OrderBy(p => p.PurchaseDate);
res.TotalResults = query.Count();
res.Entities = query
.Skip(skip)
.Take(max)
.ToList() as IEnumerable <Purchase>;
return(res);
}
public virtual RepositoryPagingResponse <T> Get(int skip, int take)
{
RepositoryPagingResponse <T> res = new RepositoryPagingResponse <T>();
var query = this.dbSet;
res.TotalResults = query.Count();
res.Entities = query.Take(take).Skip(skip);
return(res);
}
public RepositoryPagingResponse <Auction> Get(int max, int skip, AuctionSort sortOrder, string UserId = null)
{
RepositoryPagingResponse <Auction> res =
new RepositoryPagingResponse <Auction>();
IQueryable <Auction> query = this.dbSet;
res.TotalResults = query.Count();
if (UserId != null)
{
query = query.Where(a => a.Customer.Id == UserId);
}
// Sort by param
switch (sortOrder)
{
case AuctionSort.OpenDate:
query = query.OrderBy(a => a.OpenDate);
break;
case AuctionSort.Status:
query = query.OrderBy(a => a.AuctionStatus);
break;
case AuctionSort.StatusDesc:
query = query.OrderByDescending(a => a.AuctionStatus);
break;
case AuctionSort.CloseDate:
query = query.OrderBy(a => a.CloseDate);
break;
case AuctionSort.CloseDateDesc:
query = query.OrderBy(a => a.CloseDate);
break;
case AuctionSort.PickWinnerDate:
query = query.OrderBy(a => a.PickWinnerDate);
break;
case AuctionSort.PickWinnerDateDesc:
query = query.OrderByDescending(a => a.PickWinnerDate);
break;
default:
query = query.OrderByDescending(a => a.OpenDate);
break;
}
res.Entities = ValidateAuctionStatus(ValidateAuctionStatus(query
.Skip(skip)
.Take(max)
.ToList() as IEnumerable <Auction>));
return(res);
}
public RepositoryPagingResponse <LeadMusicLog> GetMusicLogByAction(LogActionType action, DateTime start, DateTime end, int skip, int take)
{
RepositoryPagingResponse <LeadMusicLog> res = new RepositoryPagingResponse <LeadMusicLog>();
string queryString = null;
queryString = String.Format(queryLeadMusicFormat, (int)action, start.ToString("yyyy-MM-dd HH:mm:ss"), end.ToString("yyyy-MM-dd HH:mm:ss"));
var query = ((PaskolDbContext)_uow.context).Database.SqlQuery <LeadMusicLog>(queryString);
res.TotalResults = query.Count();
res.Entities = query.OrderByDescending(l => l.Count).Skip(skip).Take(take);
return(res);
}
public RepositoryPagingResponse <LeadMusicLog> GetMusicsPurchase(DateTime?start, DateTime?end, int skip, int resultInPage)
{
var query = GetMusicPurchaseQuery(start, end);
var res = new RepositoryPagingResponse <LeadMusicLog>();
res.TotalResults = query.Count();
res.Entities = query.
OrderBy(gr => gr.Count()).
Skip(skip).Take(resultInPage).
ToList().
Select(ConvertPurchaseGroupToLeadMusicLog);
return(res);
}
public RepositoryPagingResponse <Music> GetBySearch(string searchText, IEnumerable <Guid> tagIds,
int max, int skip, SearchSortType sortType)
{
var res = new RepositoryPagingResponse <Music>();
IQueryable <Music> query = ActiveMusics;
if (searchText.Trim() != string.Empty)
{
query = query.Where(msc => msc.HebrewName.Contains(searchText) || msc.SongText.Contains(searchText));
}
if (tagIds.Any())
{
foreach (Guid tgId in tagIds)
{
query = query.Where(msc => msc.Tags.Any(tag => tag.ID == tgId));
}
}
res.TotalResults = query.Count();
IOrderedQueryable <Music> orderQuery = null;
switch (sortType)
{
case SearchSortType.Relevant:
orderQuery = query.OrderByDescending(msc => (msc.HebrewName == searchText) ? 4 : (msc.HebrewName.Contains(searchText) ? 2 : 1));
break;
case SearchSortType.LengthDesc:
orderQuery = query.OrderByDescending(msc => msc.MusicLength);
break;
case SearchSortType.LengthAsc:
orderQuery = query.OrderBy(msc => msc.MusicLength);
break;
}
res.Entities = orderQuery
.Skip(skip)
.Take(max)
.ToList();
return(res);
}
public RepositoryPagingResponse <Confirmation> GetBySearch(IList <ConfirmType> Types, int max, int skip, ConfirmSorting sortOrder)
{
RepositoryPagingResponse <Confirmation> res =
new RepositoryPagingResponse <Confirmation>();
IQueryable <Confirmation> query = this.dbSet;
if (Types != null)
{
query = query.Where(con => Types.Any(t => t == con.ConfirmType));
}
res.TotalResults = query.Count();
// Sort by param
switch (sortOrder)
{
case ConfirmSorting.type_desc:
query = query.OrderByDescending(c => c.ConfirmType);
break;
case ConfirmSorting.date:
query = query.OrderBy(c => c.DateUpdate);
break;
case ConfirmSorting.date_desc:
query = query.OrderByDescending(c => c.DateUpdate);
break;
default:
query = query.OrderBy(c => c.ConfirmType);
break;
}
res.Entities = query
.Skip(skip)
.Take(max)
.ToList() as IEnumerable <Confirmation>;
return(res);
}
public RepositoryPagingResponse <NCPurchase> Get(int max, int skip, DateTime s, DateTime e)
{
RepositoryPagingResponse <NCPurchase> res =
new RepositoryPagingResponse <NCPurchase>();
IQueryable <NCPurchase> query = this.dbSet.Include("Purchase.Music");
if (s != null && e != null)
{
query = query.Where(p => p.DateTime >= s && p.DateTime <= e);
}
res.TotalResults = query.Count();
query = query.OrderBy(p => p.DateTime);
res.Entities = query
.Skip(skip)
.Take(max)
.ToList() as IEnumerable <NCPurchase>;
return(res);
}
public RepositoryPagingResponse <Music> GetBySearch(
string searchMusicText,
string searchArtistText,
int max,
int skip,
MusicFieldsSort sortField,
bool orderDesc)
{
var res = new RepositoryPagingResponse <Music>();
searchArtistText = searchArtistText ?? string.Empty;
searchMusicText = searchMusicText ?? string.Empty;
Expression <Func <Music, bool> > predicate = (msc => msc.HebrewName.StartsWith(searchMusicText) &&
msc.Artist.User.UserName.StartsWith(searchArtistText));
IQueryable <Music> query = this.dbSet.Include("Artist.User").Where(predicate);
res.TotalResults = query.Count();
IOrderedQueryable <Music> orDquery = OrderMusic(query, sortField, orderDesc);
res.Entities = orDquery.Skip(skip).Take(max).ToList();
return(res);
}
