/// <summary>
/// Updates the all goals cached query results when a goal is updated
/// </summary>
void AllGoalsOnGoalUpdated(object sender, GoalUpdatedEventArgs e)
{
QueryCacheItem cachedQuery = _appInfo.GlobalQueryCache.GetCacheItem(Constants.AllGoalsCacheItem);
if (cachedQuery != null)
{
// updated the query results if needed
List <Data.Goal> allGoals = (List <Data.Goal>)cachedQuery.Value;
Data.Goal oldGoal = allGoals.FirstOrDefault(g => g.GoalID == e.UpdatedGoal.GoalId);
Data.Goal newGoal = e.UpdatedDbGoal;
if (oldGoal != null && newGoal != null)
{
allGoals.Remove(oldGoal);
allGoals.Add(newGoal);
}
else if (newGoal != null)
{
allGoals.Add(newGoal);
}
allGoals = SortList(allGoals);
_appInfo.GlobalQueryCache.UpdateCacheItem(Constants.AllGoalsCacheItem, allGoals);
}
}
/// <summary>
/// Updates the all projects cached query results when a project is updated
/// </summary>
void AllProjectsOnProjectUpdated(object sender, ProjectUpdatedEventArgs e)
{
QueryCacheItem cachedQuery = _appInfo.GlobalQueryCache.GetCacheItem(Constants.AllProjectsCacheItem);
if (cachedQuery != null)
{
// updated the query results if needed
List <Data.Project> allProjects = (List <Data.Project>)cachedQuery.Value;
Data.Project oldProject = allProjects.FirstOrDefault(p => p.ProjectID == e.UpdatedProject.ProjectId);
Data.Project newProject = e.UpdatedDbProject;
if (oldProject != null && newProject != null)
{
allProjects.Remove(oldProject);
allProjects.Add(newProject);
}
else if (newProject != null)
{
allProjects.Add(newProject);
}
allProjects = SortList(allProjects);
_appInfo.GlobalQueryCache.UpdateCacheItem(Constants.AllProjectsCacheItem, allProjects);
}
}
/// <summary>
/// Updates the all tasks cached query results when a task is updated
/// </summary>
void AllTasksOnTaskUpdated(object sender, TaskUpdatedEventArgs e)
{
QueryCacheItem cachedQuery = _appInfo.GlobalQueryCache.GetCacheItem(Constants.AllTasksCacheItem);
if (cachedQuery != null)
{
// updated the query results if needed
List <Data.Task> allTasks = (List <Data.Task>)cachedQuery.Value;
Data.Task oldTask = allTasks.FirstOrDefault(t => t.TaskID == e.UpdatedTask.TaskId);
Data.Task newTask = e.UpdatedDbTask;
if (oldTask != null && newTask != null)
{
allTasks.Remove(oldTask);
allTasks.Add(newTask);
}
else if (newTask != null)
{
allTasks.Add(newTask);
}
allTasks = SortList(allTasks);
_appInfo.GlobalQueryCache.UpdateCacheItem(Constants.AllTasksCacheItem, allTasks);
}
}
public void RemoveCacheItem(string name)
{
QueryCacheItem requestedItem = CacheItems.FirstOrDefault(i => i.Name == name);
if (requestedItem != null)
{
CacheItems.Remove(requestedItem);
}
}
/// <summary>
/// Returns a shallow-copied list of all tasks in the repository.
/// </summary>
public List <Task> GetTasks(string filterTerm = "", SortableProperty sortColumn = null, int?pageNumber = null)
{
if (sortColumn == null)
{
sortColumn = new SortableProperty()
{
Description = "Title", Name = "Title"
}
}
;
QueryCacheItem allTasksCacheItem = _appInfo.GlobalQueryCache.GetCacheItem(Constants.AllTasksCacheItem);
List <Data.Task> allTasksList;
// retrieve the query from cache if available
// this will avoid retrieving all records when only a page is needed
if (allTasksCacheItem == null)
{
// get the unordered, unfiltered list for caching
IQueryable <Data.Task> allTasks = GetAllTasksQuery(filterTerm);
allTasksList = GetOrderedList(allTasks, sortColumn);
_appInfo.GlobalQueryCache.AddCacheItem(Constants.AllTasksCacheItem, allTasksList);
}
else
{
allTasksList = (List <Data.Task>)allTasksCacheItem.Value;
}
// now do the ordering and filtering
if (!string.IsNullOrEmpty(filterTerm))
{
allTasksList = (from t in allTasksList
where t.Title.ToLower().Contains(filterTerm.ToLower())
select t).ToList();
}
if (sortColumn != null)
{
allTasksList = SortList(allTasksList, sortColumn);
}
if (pageNumber.HasValue)
{
allTasksList = allTasksList.Skip(Constants.RecordsPerPage * (pageNumber.Value - 1))
.Take(Constants.RecordsPerPage).ToList();
}
List <Task> tasks = new List <Task>();
foreach (Data.Task dbTask in allTasksList)
{
tasks.Add(Task.CreateTask(dbTask));
}
return(tasks);
}
public void UpdateCacheItem(string name, object value)
{
QueryCacheItem selectedItem = GetCacheItem(name);
if (selectedItem != null)
{
selectedItem.Value = value;
}
else
{
throw new ArgumentOutOfRangeException(Properties.Resources.CacheItem_Exception_Name, Properties.Resources.CacheItem_Exception_NotFound);
}
}
/// <summary>
/// Returns a shallow-copied list of all goals in the repository.
/// </summary>
public List <Goal> GetGoals(string filterTerm = "", SortableProperty sortColumn = null, int?pageNumber = null)
{
QueryCacheItem allGoalsCacheItem = _appInfo.GlobalQueryCache.GetCacheItem(Constants.AllGoalsCacheItem);
List <Data.Goal> dbGoalsList;
// retrieve the query from cache if available
// this will avoid retrieving all records when only a page is needed
if (allGoalsCacheItem == null)
{
// get the unordered, unfiltered list for caching
IQueryable <Data.Goal> allGoals = GetAllGoalsQuery();
dbGoalsList = GetOrderedList(allGoals);
_appInfo.GlobalQueryCache.AddCacheItem(Constants.AllGoalsCacheItem, dbGoalsList);
}
else
{
dbGoalsList = (List <Data.Goal>)allGoalsCacheItem.Value;
}
// now do the ordering and filtering
if (!string.IsNullOrEmpty(filterTerm))
{
dbGoalsList = (from g in dbGoalsList
where g.Title.ToLower().Contains(filterTerm.ToLower())
select g).ToList();
}
if (sortColumn != null)
{
dbGoalsList = SortList(dbGoalsList, sortColumn);
}
// do the paging
if (pageNumber.HasValue)
{
dbGoalsList = dbGoalsList.Skip(Constants.RecordsPerPage * (pageNumber.Value - 1))
.Take(Constants.RecordsPerPage).ToList();
}
// create system goal objects from db goal objects
List <Goal> goals = new List <Goal>();
foreach (Data.Goal dbGoal in dbGoalsList)
{
goals.Add(Goal.CreateGoal(dbGoal));
}
return(goals);
}
/// <summary>
/// Updates the all goals cached query results when a goal is deleted
/// </summary>
void AllGoalsOnGoalDeleted(object sender, GoalDeletedEventArgs e)
{
QueryCacheItem cachedQuery = _appInfo.GlobalQueryCache.GetCacheItem(Constants.AllGoalsCacheItem);
if (cachedQuery != null)
{
List <Data.Goal> allGoals = (List <Data.Goal>)cachedQuery.Value;
Data.Goal deletedGoal = allGoals.FirstOrDefault(g => g.GoalID == e.DeletedGoal.GoalId);
if (deletedGoal != null)
{
allGoals.Remove(deletedGoal);
_appInfo.GlobalQueryCache.UpdateCacheItem(Constants.AllGoalsCacheItem, allGoals);
}
}
}
/// <summary>
/// Updates the all projects cached query results when a project is deleted
/// </summary>
void AllProjectsOnProjectDeleted(object sender, ProjectDeletedEventArgs e)
{
QueryCacheItem cachedQuery = _appInfo.GlobalQueryCache.GetCacheItem(Constants.AllProjectsCacheItem);
if (cachedQuery != null)
{
List <Data.Project> allProjects = (List <Data.Project>)cachedQuery.Value;
Data.Project deletedProject = allProjects.FirstOrDefault(p => p.ProjectID == e.DeletedProject.ProjectId);
if (deletedProject != null)
{
allProjects.Remove(deletedProject);
_appInfo.GlobalQueryCache.UpdateCacheItem(Constants.AllProjectsCacheItem, allProjects);
}
}
}
/// <summary>
/// Updates the active tasks cached query results when a task is deleted
/// </summary>
void ActiveTasksOnTaskDeleted(object sender, TaskDeletedEventArgs e)
{
QueryCacheItem cachedQuery = _appInfo.GlobalQueryCache.GetCacheItem(Constants.ActiveTasksCacheItem);
if (cachedQuery != null)
{
List <Data.Task> activeTasks = (List <Data.Task>)cachedQuery.Value;
Data.Task deletedTask = activeTasks.FirstOrDefault(t => t.TaskID == e.DeletedTask.TaskId);
if (deletedTask != null)
{
activeTasks.Remove(deletedTask);
_appInfo.GlobalQueryCache.UpdateCacheItem(Constants.ActiveTasksCacheItem, activeTasks);
}
}
}
/// <summary>
/// Returns a shallow-copied list of all projects in the repository.
/// </summary>
public List <Project> GetProjects(string filterTerm = "", SortableProperty sortColumn = null, int?pageNumber = null)
{
QueryCacheItem allProjectsCacheItem = _appInfo.GlobalQueryCache.GetCacheItem(Constants.AllProjectsCacheItem);
List <Data.Project> allProjectsList;
// retrieve the query from cache if available
// this will avoid retrieving all records when only a page is needed
if (allProjectsCacheItem == null)
{
// get the unordered, unfiltered list for caching
IQueryable <Data.Project> allProjects = GetAllProjectsQuery();
allProjectsList = GetOrderedList(allProjects);
_appInfo.GlobalQueryCache.AddCacheItem(Constants.AllProjectsCacheItem, allProjectsList);
}
else
{
allProjectsList = (List <Data.Project>)allProjectsCacheItem.Value;
}
// now do the ordering and filtering
if (!string.IsNullOrEmpty(filterTerm))
{
allProjectsList = (from p in allProjectsList
where p.Title.ToLower().Contains(filterTerm.ToLower())
select p).ToList();
}
if (sortColumn != null)
{
allProjectsList = SortList(allProjectsList, sortColumn);
}
if (pageNumber.HasValue)
{
allProjectsList = allProjectsList.Skip(Constants.RecordsPerPage * (pageNumber.Value - 1))
.Take(Constants.RecordsPerPage).ToList();
}
List <Project> projects = new List <Project>();
foreach (Data.Project dbProject in allProjectsList)
{
projects.Add(Project.CreateProject(dbProject));
}
return(projects);
}
/// <summary>
/// Updates the all goals cached query results when a goal is added
/// </summary>
void AllGoalsOnGoalAdded(object sender, GoalAddedEventArgs e)
{
QueryCacheItem cachedQuery = _appInfo.GlobalQueryCache.GetCacheItem(Constants.AllGoalsCacheItem);
if (cachedQuery != null)
{
// add the added item to the cached query results
List <Data.Goal> allGoals = (List <Data.Goal>)cachedQuery.Value;
Data.Goal addedGoal = _appInfo.GcContext.Goals.FirstOrDefault(g => g.GoalID == e.NewGoal.GoalId);
if (addedGoal != null)
{
allGoals.Add(addedGoal);
allGoals = SortList(allGoals);
_appInfo.GlobalQueryCache.UpdateCacheItem(Constants.AllGoalsCacheItem, allGoals);
}
}
}
/// <summary>
/// Updates the all tasks cached query results when a task is added
/// </summary>
void AllTasksOnTaskAdded(object sender, TaskAddedEventArgs e)
{
QueryCacheItem cachedQuery = _appInfo.GlobalQueryCache.GetCacheItem(Constants.AllTasksCacheItem);
if (cachedQuery != null)
{
// add the added item to the cached query results
List <Data.Task> allTasks = (List <Data.Task>)cachedQuery.Value;
Data.Task addedTask = _appInfo.GcContext.Tasks.FirstOrDefault(t => t.TaskID == e.NewTask.TaskId);
if (addedTask != null)
{
allTasks.Add(addedTask);
allTasks = SortList(allTasks);
_appInfo.GlobalQueryCache.UpdateCacheItem(Constants.AllTasksCacheItem, allTasks);
}
}
}
/// <summary>
/// Updates the all projects cached query results when a project is added
/// </summary>
void AllProjectsOnProjectAdded(object sender, ProjectAddedEventArgs e)
{
QueryCacheItem cachedQuery = _appInfo.GlobalQueryCache.GetCacheItem(Constants.AllProjectsCacheItem);
if (cachedQuery != null)
{
// add the added item to the cached query results
List <Data.Project> allProjects = (List <Data.Project>)cachedQuery.Value;
Data.Project addedProject = _appInfo.GcContext.Projects.FirstOrDefault(p => p.ProjectID == e.NewProject.ProjectId);
if (addedProject != null)
{
allProjects.Add(addedProject);
// sort the query results according to the sort column
allProjects = SortList(allProjects);
_appInfo.GlobalQueryCache.UpdateCacheItem(Constants.AllProjectsCacheItem, allProjects);
}
}
}
/// <summary>
/// Updates the active tasks cached query results when a task is updated
/// </summary>
void ActiveTasksOnTaskUpdated(object sender, TaskUpdatedEventArgs e)
{
QueryCacheItem cachedQuery = _appInfo.GlobalQueryCache.GetCacheItem(Constants.ActiveTasksCacheItem);
if (cachedQuery != null)
{
// updated the query results if needed
List <Data.Task> activeTasks = (List <Data.Task>)cachedQuery.Value;
if (e.UpdatedTask.IsActive)
{
Data.Task oldTask = activeTasks.FirstOrDefault(t => t.TaskID == e.UpdatedTask.TaskId);
Data.Task newTask = e.UpdatedDbTask;
if (oldTask != null && newTask != null)
{
activeTasks.Remove(oldTask);
activeTasks.Add(newTask);
}
else if (newTask != null)
{
activeTasks.Add(newTask);
}
activeTasks = SortList(activeTasks, new SortableProperty()
{
Description = "Sort Order", Name = "SortOrder"
});
}
else
{
// the updated task doesnt meet the filter term so remove if it exists in list
Data.Task oldTask = activeTasks.FirstOrDefault(t => t.TaskID == e.UpdatedTask.TaskId);
if (oldTask != null)
{
activeTasks.Remove(oldTask);
}
}
_appInfo.GlobalQueryCache.UpdateCacheItem(Constants.ActiveTasksCacheItem, activeTasks);
}
}
/// <summary>
/// Updates the active tasks cached query results when a task is added
/// </summary>
void ActiveTasksOnTaskAdded(object sender, TaskAddedEventArgs e)
{
QueryCacheItem cachedQuery = _appInfo.GlobalQueryCache.GetCacheItem(Constants.ActiveTasksCacheItem);
if (cachedQuery != null)
{
// check if the added item satisfies the filter term and is active
if (e.NewTask.IsActive)
{
// add the added item to the cached query results
List <Data.Task> activeTasks = (List <Data.Task>)cachedQuery.Value;
Data.Task addedTask = _appInfo.GcContext.Tasks.FirstOrDefault(t => t.TaskID == e.NewTask.TaskId);
if (addedTask != null)
{
activeTasks.Add(addedTask);
activeTasks = SortList(activeTasks, new SortableProperty()
{
Description = "Sort Order", Name = "SortOrder"
});
_appInfo.GlobalQueryCache.UpdateCacheItem(Constants.ActiveTasksCacheItem, activeTasks);
}
}
}
}
