/// <summary>
/// Creates a server model compatible with the database. This does not calculate any cached data, such as groups and series.
/// </summary>
/// <returns></returns>
public SVR_GroupFilter ToServerModel(SVR_GroupFilter existing = null)
{
var groupFilter = new SVR_GroupFilter
{
FilterType = Directory ? (int)(GroupFilterType.UserDefined | GroupFilterType.Directory) : (int)GroupFilterType.UserDefined,
ApplyToSeries = ApplyAtSeriesLevel ? 1 : 0,
GroupFilterName = Name,
InvisibleInClients = HideInAPI ? 1 : 0,
ParentGroupFilterID = ParentID == 0 ? (int?)null : ParentID,
// Conditions
BaseCondition = (int)(Conditions.InvertLogic
? GroupFilterBaseCondition.Exclude
: GroupFilterBaseCondition.Include),
Conditions = Conditions.Conditions.Select(c =>
{
GroupFilterCondition condition = new GroupFilterCondition();
return(condition);
}).ToList(),
// Sorting
SortCriteriaList = Sorting.Select(s =>
{
GroupFilterSortingCriteria criteria = new GroupFilterSortingCriteria
{
SortType = s.Type,
SortDirection = s.Descending ? GroupFilterSortDirection.Desc : GroupFilterSortDirection.Asc
};
return(criteria);
}).ToList()
};
// Return new group filter.
if (existing == null)
{
return(groupFilter);
}
// Merge into existing group filter.
existing.ApplyToSeries = groupFilter.ApplyToSeries;
existing.ParentGroupFilterID = groupFilter.ParentGroupFilterID;
existing.FilterType = groupFilter.FilterType;
existing.InvisibleInClients = groupFilter.InvisibleInClients;
if (groupFilter.GroupFilterName != null)
{
existing.GroupFilterName = groupFilter.GroupFilterName;
}
if (groupFilter.Conditions != null)
{
existing.BaseCondition = groupFilter.BaseCondition;
existing.Conditions = groupFilter.Conditions;
}
if (groupFilter.SortCriteriaList != null)
{
existing.SortCriteriaList = groupFilter.SortCriteriaList;
}
return(existing);
}
/// <summary>
/// Creates a server model compatible with the database. This does not calculate any cached data, such as groups and series.
/// </summary>
/// <returns></returns>
public SVR_GroupFilter ToServerModel(SVR_GroupFilter existing = null)
{
SVR_GroupFilter gf = new SVR_GroupFilter
{
FilterType = (int)Type,
ApplyToSeries = ApplyAtSeriesLevel ? 1 : 0,
GroupFilterName = Name,
InvisibleInClients = HideInAPI ? 1 : 0,
ParentGroupFilterID = ParentID == 0 ? (int?)null : ParentID,
// Conditions
BaseCondition = (int)(Conditions.InvertLogic
? GroupFilterBaseCondition.Exclude
: GroupFilterBaseCondition.Include),
Conditions = Conditions.Conditions.Select(c =>
{
GroupFilterCondition condition = new GroupFilterCondition();
return(condition);
}).ToList(),
// Sorting
SortCriteriaList = Sorting.Select(s =>
{
GroupFilterSortingCriteria criteria = new GroupFilterSortingCriteria
{
SortType = s.Type,
SortDirection = s.Descending ? GroupFilterSortDirection.Desc : GroupFilterSortDirection.Asc
};
return(criteria);
}).ToList()
};
// Merge into existing
if (existing == null)
{
return(gf);
}
if (gf.GroupFilterName != null)
{
existing.GroupFilterName = gf.GroupFilterName;
}
if (gf.Conditions != null)
{
existing.BaseCondition = gf.BaseCondition;
existing.Conditions = gf.Conditions;
}
if (gf.SortCriteriaList != null)
{
existing.SortCriteriaList = gf.SortCriteriaList;
}
existing.ApplyToSeries = gf.ApplyToSeries;
existing.ParentGroupFilterID = gf.ParentGroupFilterID;
existing.FilterType = gf.FilterType;
existing.InvisibleInClients = gf.InvisibleInClients;
return(existing);
}
public static IQueryable <T> SortGroups <T>(CL_GroupFilter gf, IQueryable <T> list) where T : VM_AnimeGroup_User
{
BaseConfig.MyAnimeLog.Write("Criteria Orig: " + gf.SortingCriteria);
List <GroupFilterSortingCriteria> criterias = GroupFilterSortingCriteria.Create(gf.GroupFilterID, gf.SortingCriteria);
foreach (GroupFilterSortingCriteria f in criterias)
{
BaseConfig.MyAnimeLog.Write("Criteria: " + f.SortType.ToString() + " " + f.SortDirection);
list = GeneratePredicate(list, f.SortType, f.SortDirection);
}
return(list);
}
private static IOrderedEnumerable <SVR_AnimeGroup> Order(IEnumerable <SVR_AnimeGroup> groups,
GroupFilterSortingCriteria gfsc, bool isFirst)
{
bool desc = gfsc.SortDirection == GroupFilterSortDirection.Desc;
switch (gfsc.SortType)
{
case GroupFilterSorting.Year:
return(!desc
? Order(groups, a => a.Contract.Stat_AirDate_Min, false, isFirst)
: Order(groups, a => a.Contract.Stat_AirDate_Max, true, isFirst));
case GroupFilterSorting.AniDBRating:
return(Order(groups, a => a.Contract.Stat_AniDBRating, desc, isFirst));
case GroupFilterSorting.EpisodeAddedDate:
return(Order(groups, a => a.EpisodeAddedDate, desc, isFirst));
case GroupFilterSorting.EpisodeAirDate:
return(Order(groups, a => a.LatestEpisodeAirDate, desc, isFirst));
case GroupFilterSorting.EpisodeWatchedDate:
return(Order(groups, a => a.Contract.WatchedDate, desc, isFirst));
case GroupFilterSorting.MissingEpisodeCount:
return(Order(groups, a => a.MissingEpisodeCount, desc, isFirst));
case GroupFilterSorting.SeriesAddedDate:
return(Order(groups, a => a.Contract.Stat_SeriesCreatedDate, desc, isFirst));
case GroupFilterSorting.SeriesCount:
return(Order(groups, a => a.Contract.Stat_SeriesCount, desc, isFirst));
case GroupFilterSorting.SortName:
return(Order(groups, a => a.SortName, desc, isFirst));
case GroupFilterSorting.UnwatchedEpisodeCount:
return(Order(groups, a => a.Contract.UnwatchedEpisodeCount, desc, isFirst));
case GroupFilterSorting.UserRating:
return(Order(groups, a => a.Contract.Stat_UserVoteOverall, desc, isFirst));
case GroupFilterSorting.GroupName:
case GroupFilterSorting.GroupFilterName:
return(Order(groups, a => a.GroupName, desc, isFirst));
default:
return(Order(groups, a => a.GroupName, desc, isFirst));
}
}
private static IOrderedEnumerable <SVR_AnimeSeries> Order(IEnumerable <SVR_AnimeSeries> groups,
GroupFilterSortingCriteria gfsc, bool isFirst)
{
bool desc = gfsc.SortDirection == GroupFilterSortDirection.Desc;
switch (gfsc.SortType)
{
case GroupFilterSorting.Year:
return(Order(groups, a => a.Contract.AniDBAnime.AniDBAnime.AirDate, desc, isFirst));
case GroupFilterSorting.AniDBRating:
return(Order(groups, a => a.Contract.AniDBAnime.AniDBAnime.Rating, desc, isFirst));
case GroupFilterSorting.EpisodeAddedDate:
return(Order(groups, a => a.EpisodeAddedDate, desc, isFirst));
case GroupFilterSorting.EpisodeAirDate:
return(Order(groups, a => a.LatestEpisodeAirDate, desc, isFirst));
case GroupFilterSorting.EpisodeWatchedDate:
return(Order(groups, a => a.Contract.WatchedDate, desc, isFirst));
case GroupFilterSorting.MissingEpisodeCount:
return(Order(groups, a => a.MissingEpisodeCount, desc, isFirst));
case GroupFilterSorting.SeriesAddedDate:
return(Order(groups, a => a.Contract.DateTimeCreated, desc, isFirst));
case GroupFilterSorting.SeriesCount:
return(Order(groups, a => 1, desc, isFirst));
case GroupFilterSorting.SortName:
return(Order(groups, a => a.GetSeriesName(), desc, isFirst));
case GroupFilterSorting.UnwatchedEpisodeCount:
return(Order(groups, a => a.Contract.UnwatchedEpisodeCount, desc, isFirst));
case GroupFilterSorting.UserRating:
return(Order(groups, a => a.Contract.AniDBAnime.UserVote.VoteValue, desc, isFirst));
case GroupFilterSorting.GroupName:
case GroupFilterSorting.GroupFilterName:
return(Order(groups, a => a.GetSeriesName(), desc, isFirst));
default:
return(Order(groups, a => a.GetSeriesName(), desc, isFirst));
}
}
public void Init(GroupFilterVM gf, GroupFilterSortingCriteria gfsc)
{
groupFilter = gf;
groupFilterSortingCriteria = gfsc;
try
{
cboSortType.Items.Clear();
foreach (string stype in GroupFilterHelper.GetAllSortTypes())
{
if (gf != null)
{
bool alreadyExists = false;
foreach (GroupFilterSortingCriteria gfsc_old in gf.SortCriteriaList)
{
if (GroupFilterHelper.GetTextForEnum_Sorting(gfsc_old.SortType) == stype)
{
alreadyExists = true;
break;
}
}
if (!alreadyExists)
{
cboSortType.Items.Add(stype);
}
}
}
if (cboSortType.Items.Count > 0)
{
cboSortType.SelectedIndex = 0;
}
cboDirection.Items.Clear();
cboDirection.Items.Add(GroupFilterHelper.GetTextForEnum_SortDirection(GroupFilterSortDirection.Asc));
cboDirection.Items.Add(GroupFilterHelper.GetTextForEnum_SortDirection(GroupFilterSortDirection.Desc));
cboDirection.SelectedIndex = 0;
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
public SortingCriteria(GroupFilterSortingCriteria criteria)
{
Type = criteria.SortType;
Descending = criteria.SortDirection == GroupFilterSortDirection.Desc;
}
public void Populate(JMMServerBinary.Contract_GroupFilter contract)
{
this.GroupFilterID = contract.GroupFilterID;
this.FilterName = contract.GroupFilterName;
this.ApplyToSeries = contract.ApplyToSeries;
this.BaseCondition = contract.BaseCondition;
this.isLocked = contract.Locked.HasValue && contract.Locked == 1;
this.FilterType = contract.FilterType;
this.PredefinedCriteria = "";
this.InvisibleInClients = contract.InvisibleInClients;
this.GroupFilterParentId = contract.ParentGroupFilterID;
this.Groups = contract.Groups.ToDictionary(a => a.Key, a => new HashSet <int>(a.Value));
this.Series = contract.Series.ToDictionary(a => a.Key, a => new HashSet <int>(a.Value));
this.Childs = new HashSet <int>(contract.Childs);
this.AllowDeletion = true;
this.AllowEditing = true;
if (this.isLocked)
{
this.AllowDeletion = false;
this.AllowEditing = false;
}
if (this.FilterType == (int)GroupFilterType.ContinueWatching)
{
this.AllowDeletion = false;
}
this.IsSystemGroupFilter = false;
this.IsNotSystemGroupFilter = true;
//this.FilterConditions = new ObservableCollection<GroupFilterConditionVM>();
this.FilterConditions.Clear();
if (contract.FilterConditions != null)
{
foreach (JMMServerBinary.Contract_GroupFilterCondition gfc_con in contract.FilterConditions)
{
FilterConditions.Add(new GroupFilterConditionVM(gfc_con));
}
}
//SortCriteriaList = new ObservableCollection<GroupFilterSortingCriteria>();
SortCriteriaList.Clear();
string sortCriteriaRaw = contract.SortingCriteria;
if (!string.IsNullOrEmpty(sortCriteriaRaw))
{
string[] scrit = sortCriteriaRaw.Split('|');
foreach (string sortpair in scrit)
{
string[] spair = sortpair.Split(';');
if (spair.Length != 2)
{
continue;
}
int stype = 0;
int sdir = 0;
int.TryParse(spair[0], out stype);
int.TryParse(spair[1], out sdir);
if (stype > 0 && sdir > 0)
{
GroupFilterSortingCriteria gfsc = new GroupFilterSortingCriteria();
gfsc.GroupFilterID = this.GroupFilterID;
gfsc.SortType = (GroupFilterSorting)stype;
gfsc.SortDirection = (GroupFilterSortDirection)sdir;
SortCriteriaList.Add(gfsc);
}
}
}
//Update GroupCount
//SortCriteriaList = new ObservableCollection<GroupFilterSortingCriteria>(SortCriteriaList.OrderBy(p => p.GroupFilterSortingString));
//FilterConditions = new ObservableCollection<GroupFilterConditionVM>(FilterConditions.OrderBy(p => p.ConditionTypeString));
}
