internal static QueryFilter GetFilter(TaskFilterType filterType)
{
switch (filterType)
{
case TaskFilterType.All:
return(null);
case TaskFilterType.Active:
return(TaskView.activeFilter);
case TaskFilterType.Overdue:
{
QueryFilter queryFilter = new ComparisonFilter(ComparisonOperator.LessThan, TaskSchema.DueDate, DateTimeUtilities.GetLocalTime().Date);
return(new AndFilter(new QueryFilter[]
{
queryFilter,
TaskView.activeFilter
}));
}
case TaskFilterType.Completed:
return(TaskView.completeFilter);
default:
throw new OwaInvalidRequestException("Unknown value for TaskFilterType");
}
}
// Token: 0x06002F97 RID: 12183 RVA: 0x001140B4 File Offset: 0x001122B4
protected override QueryFilter GetViewFilter()
{
TaskFilterType filterType = TaskFilterType.All;
if (base.IsParameterSet("fltr"))
{
filterType = (TaskFilterType)base.GetParameter("fltr");
}
base.FolderQueryFilter = TaskView.GetFilter(filterType);
if (!Utilities.IsPublic(base.ContextFolder) && base.GetParameter("srchf") != null)
{
if (base.FolderQueryFilter == null)
{
base.FolderQueryFilter = TaskVirtualListViewEventHandler.taskItemFilter;
}
else
{
base.FolderQueryFilter = new AndFilter(new QueryFilter[]
{
base.FolderQueryFilter,
TaskVirtualListViewEventHandler.taskItemFilter
});
}
}
return(base.GetViewFilter());
}
public async Task <PagedList <TaskBasicModel> > GetTasksAsync(int id, TaskModelType tip,
TaskFilterType filter, PagedListParameters pagedListParameters)
{
IQueryable <TaskEntity> querable = _taskRep.Queryable;
if (tip > 0)
{
querable = querable.Where(m => m.TaskModelType == tip);
}
if (id > 0 && tip != TaskModelType.Default)
{
switch (tip)
{
//case TaskModelType.Analysis:
// querable = querable.Where(m => m.AccountId == id);
// break;
//case TaskModelType.Development:
// querable = querable.Where(m => m.OpportunityId == id);
// break;
//case TaskModelType.Issue:
// querable = querable.Where(m => m.IssueId == id);
// break;
//default:
// break;
}
}
else
{
// Ihtiyac yok su an icin
}
switch (filter)
{
//case TaskFilterType.AllTasks:
// break;
//case TaskFilterType.UserTasks:
// // querable = querable.Where(m => EF.Functions.Like("," + m.ResponsiblesStr + ",", "," + SessionManager.UserName + ",")); ?
// querable = querable.Where(m => ( "," + m.ResponsiblesStr + ",").Contains("," + SessionManager.UserName + ","));
// break;
//case TaskFilterType.Completed:
// querable = querable.Where(m => m.TaskStatus == Common.Helper.Enums.TaskStatus.Tamamlandi);
// break;
//case TaskFilterType.Waiting:
// querable = querable.Where(m => m.TaskStatus == Common.Helper.Enums.TaskStatus.Baslamadi);
// break;
//case TaskFilterType.InProggress:
// querable = querable.Where(m => m.TaskStatus == Common.Helper.Enums.TaskStatus.DevamEdiyor);
// break;
//case TaskFilterType.WaitingForAnotherTask:
// querable = querable.Where(m => m.TaskStatus == Common.Helper.Enums.TaskStatus.Bekleniyor);
// break;
//case TaskFilterType.Postphoned:
// querable = querable.Where(m => m.TaskStatus == Common.Helper.Enums.TaskStatus.Ertelendi);
// break;
}
return(await Task.FromResult(new PagedList <TaskBasicModel>(querable.Project <TaskEntity, TaskBasicModel>(), pagedListParameters)));
}
/// <summary>
/// Gets the filtered tasks by user.
/// </summary>
/// <param name="userId">The user id.</param>
/// <param name="filter">The filter.</param>
/// <returns></returns>
public List <Task> GetAllTasksByUser(int userId, TaskFilterType filter = TaskFilterType.All)
{
List <Task> tasks = new List <Task>();
try
{
tasks = TaskRepository.FindAllTasksByUser(userId, filter);
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex, PolicyNameType.ExceptionShielding);
}
return(tasks);
}
/// <summary>
/// Gets filtered tasks
/// </summary>
/// <param name="studentId">The user id.</param>
/// <param name="filter">The filter.</param>
/// <returns></returns>
public List <TaskViewModel> GetTasks(int userId, TaskFilterType displayFilter = TaskFilterType.All)
{
List <TaskViewModel> models = new List <TaskViewModel>();
try
{
List <Task> tasks = new List <Task>();
tasks = TaskManager.GetAllTasksByUser(userId, displayFilter);
models = ObjectMapper.Map <Model.Entities.Task, TaskViewModel>(tasks.OrderBy(t => t.IsCompleted).ThenByDescending(t => t.HasDeadline).ThenBy(t => t.DaysDue).ThenBy(t => t.DateCreated).ToList());
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex, PolicyNameType.ExceptionReplacing);
}
return(models);
}
public static List <int[]> GetTasks(TaskFilterType Filter, DateTime Date)
{
List <int[]> originalTasks = GetTasks(Filter);
List <int[]> newTasks = new List <int[]>();
for (int i = 0; i < originalTasks.Count; i++)
{
if (Core.Instanse.Data[originalTasks[i][0]].Tasks[originalTasks[i][1]].StartTime.Date == Date.Date)
{
newTasks.Add(originalTasks[i]);
}
}
return(newTasks);
}
/// <summary>
/// Finds tasks by user and filter.
/// </summary>
/// <param name="userId">The user id.</param>
/// <param name="filter">The filter.</param>
/// <returns></returns>
public List <Model.Entities.Task> FindAllTasksByUser(int userId, TaskFilterType filter = TaskFilterType.All)
{
List <Model.Entities.Task> taskModelList = new List <Model.Entities.Task>();
try
{
List <Task> taskEntityList;
switch (filter)
{
case TaskFilterType.All:
taskEntityList = this.Context.Set <Task>().Where(p => p.UserId == userId).ToList();
break;
case TaskFilterType.Active:
taskEntityList = this.Context.Set <Task>().Where(p => p.UserId == userId && p.IsCompleted == false).ToList();
break;
case TaskFilterType.ActiveWithDeadlines:
taskEntityList = this.Context.Set <Task>().Where(p => p.UserId == userId && p.IsCompleted == false && p.Deadline.HasValue).ToList();
break;
case TaskFilterType.Completed:
taskEntityList = this.Context.Set <Task>().Where(p => p.UserId == userId && p.IsCompleted == true).ToList();
break;
default:
taskEntityList = new List <Task>();
break;
}
// Return Tasks
taskModelList = ObjectMapper.Map <Task, Model.Entities.Task>(taskEntityList);
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex, PolicyNameType.ExceptionShielding);
}
return(taskModelList);
}
/// <summary>
/// Creates the display filter for tasks.
/// </summary>
/// <param name="action">The target action</param>
/// <param name="controller">The target controller.</param>
/// <param name="updateTargetId">The update target id.</param>
/// <param name="displayFilter">The active display filter.</param>
/// <returns></returns>
public static DisplayFilterViewModel CreateTaskDisplayFilterViewModel(string action, string controller, string updateTargetId, TaskFilterType activeFilter = TaskFilterType.Active, string view = "")
{
DisplayFilterViewModel model = new DisplayFilterViewModel()
{
TargetActionName = action,
TargetControllerName = controller,
UpdateTargetId = updateTargetId,
ActiveFilter = (int)activeFilter,
DisplayLegend = "Show",
Item1Display = EnumHelper.DiscriptionFor(TaskFilterType.All),
Item2Display = EnumHelper.DiscriptionFor(TaskFilterType.Active),
Item3Display = EnumHelper.DiscriptionFor(TaskFilterType.Completed),
Item1Css = activeFilter == TaskFilterType.All ? "active" : string.Empty,
Item2Css = activeFilter == TaskFilterType.Active ? "active" : string.Empty,
Item3Css = activeFilter == TaskFilterType.Completed ? "active" : string.Empty,
Item1Value = (int)TaskFilterType.All,
Item2Value = (int)TaskFilterType.Active,
Item3Value = (int)TaskFilterType.Completed,
ViewType = view
};
return(model);
}
public Task <PagedList <TaskBasicModel> > GetTasksAsync(int id, TaskModelType tip, TaskFilterType filter, PagedListParameters pagedListParameters)
{
return(_taskDom.GetTasksAsync(id, tip, filter, pagedListParameters));
}
/// <summary>
/// Gets the task filter view model
/// </summary>
/// <param name="action">The target action</param>
/// <param name="controller">The target controller.</param>
/// <param name="updateTargetId">The update target id.</param>
/// <param name="displayFilter">The active display filter.</param>
/// <returns></returns>
public DisplayFilterViewModel GetTaskDisplayFilter(string action, string controller, string updateTargetId, TaskFilterType displayFilter = TaskFilterType.Active, string view = "")
{
DisplayFilterViewModel model = null;
try
{
model = DisplayFilterViewModelFactory.CreateTaskDisplayFilterViewModel(action, controller, updateTargetId, displayFilter, view);
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex, PolicyNameType.ExceptionReplacing);
}
return(model);
}
public static List <int[]> GetTasks(TaskFilterType Filter)
{
List <int[]> items = new List <int[]>();
// Filter
switch (Filter)
{
case TaskFilterType.New:
{
for (int i = 0; i < Core.Instanse.Data.Count; i++)
{
for (int k = 0; k < Core.Instanse.Data[i].Tasks.Count; k++)
{
if (Core.Instanse.Data[i].Tasks[k].State == TaskStateType.New)
{
items.Add(new int[] { i, k });
}
}
}
break;
}
case TaskFilterType.Active:
{
for (int i = 0; i < Core.Instanse.Data.Count; i++)
{
for (int k = 0; k < Core.Instanse.Data[i].Tasks.Count; k++)
{
if (Core.Instanse.Data[i].Tasks[k].IsInProgress())
{
items.Add(new int[] { i, k });
}
}
}
break;
}
case TaskFilterType.Completed:
{
for (int i = 0; i < Core.Instanse.Data.Count; i++)
{
for (int k = 0; k < Core.Instanse.Data[i].Tasks.Count; k++)
{
if (Core.Instanse.Data[i].Tasks[k].IsCompleted())
{
items.Add(new int[] { i, k });
}
}
}
break;
}
default:
{
for (int i = 0; i < Core.Instanse.Data.Count; i++)
{
for (int k = 0; k < Core.Instanse.Data[i].Tasks.Count; k++)
{
items.Add(new int[] { i, k });
}
}
break;
}
}
return(items);
}
