private List <dtoPlainTask> GetTasksAsAdministrator(Person person, dtoItemsFilter filter, Int32 idCommunity)
{
List <dtoPlainTask> tasks = new List <dtoPlainTask>();
try
{
List <long> idProjects = GetIdProjectsForTasksAsAdministrator(person, filter, idCommunity);
Dictionary <SummaryTimeLine, long> days = GetDaysOfYear(DateTime.Now.Date);
if (idProjects.Count() < maxItemsForQuery)
{
tasks.AddRange(GetTasks(GetTasksQuery(idProjects), days, filter, GetRolePermissions(ActivityRole.ProjectOwner)));
}
else
{
Int32 pageIndex = 0;
while (idProjects.Skip(pageIndex * maxItemsForQuery).Take(maxItemsForQuery).Any())
{
tasks.AddRange(GetTasks(GetTasksQuery(idProjects.Skip(pageIndex * maxItemsForQuery).Take(maxItemsForQuery).ToList()), days, filter, GetRolePermissions(ActivityRole.ProjectOwner)));
pageIndex++;
}
}
}
catch (Exception ex)
{
}
return(tasks);
}
private List <dtoPlainTask> GetTasksAsManager(Int32 idPerson, dtoItemsFilter filter, Int32 idCommunity, PageContainerType container, PageListType fromPage, PageListType displayPage, List <dtoProjectGroupInfo> projectsInfo = null)
{
List <dtoPlainTask> tasks = new List <dtoPlainTask>();
try
{
IEnumerable <ProjectResource> query = GetResourcesAsManager(idPerson, filter, idCommunity, false);
DateTime today = DateTime.Now.Date;
Dictionary <SummaryTimeLine, long> days = GetDaysOfYear(today);
if (query.Count() < maxItemsForQuery)
{
Dictionary <long, ActivityRole> projectRoles = query.ToDictionary(r => r.Project.Id, r => r.ProjectRole);
tasks.AddRange(GetTasks(GetTasksQuery(projectRoles.Keys.ToList()), days, filter, projectRoles, container, displayPage));
}
else
{
Int32 pageIndex = 0;
var pInfo = query.Select(i => new { IdProject = i.Project.Id, Role = i.ProjectRole }).ToList();
while (pInfo.Skip(pageIndex * maxItemsForQuery).Take(maxItemsForQuery).Any())
{
tasks.AddRange(GetTasks(GetTasksQuery(pInfo.Skip(pageIndex * maxItemsForQuery).Take(maxItemsForQuery).Select(p => p.IdProject).ToList()), days, filter, pInfo.Skip(pageIndex * maxItemsForQuery).Take(maxItemsForQuery).ToDictionary(p => p.IdProject, p => p.Role), container, displayPage));
pageIndex++;
}
}
}
catch (Exception ex)
{
}
return(tasks);
}
private List <dtoPlainTask> GetTasksAsResource(Int32 idPerson, dtoItemsFilter filter, Int32 idCommunity, PageContainerType container, PageListType fromPage, PageListType displayPage)
{
List <dtoPlainTask> tasks = new List <dtoPlainTask>();
try
{
Dictionary <ActivityRole, PmActivityPermission> permissions = (from e in Enum.GetValues(typeof(ActivityRole)).Cast <ActivityRole>() where e != ActivityRole.Manager && e != ActivityRole.ProjectOwner select e).ToDictionary(e => e, e => GetRolePermissions(e));
tasks = GetTasks(GetAssignmentsByUser(idPerson, filter, idCommunity), GetDaysOfYear(DateTime.Now.Date), filter, permissions);
Dictionary <Int32, String> cNames = null;
List <Int32> idCommunities = tasks.Select(t => t.ProjectInfo.IdCommunity).Distinct().ToList();
if (idCommunities.Count > maxItemsForQuery)
{
cNames = (from c in Manager.GetIQ <Community>() select new { IdCommunity = c.Id, Name = c.Name }).ToList().Where(c => idCommunities.Contains(c.IdCommunity)).ToDictionary(c => c.IdCommunity, c => c.Name);
}
else
{
cNames = (from c in Manager.GetIQ <Community>() where idCommunities.Contains(c.Id) select c).ToDictionary(c => c.Id, c => c.Name);
}
foreach (dtoPlainTask t in tasks.Where(t => !t.ProjectInfo.isPortal && !cNames.ContainsKey(t.ProjectInfo.IdCommunity)))
{
t.ProjectInfo.IdCommunity = -1;
}
foreach (dtoPlainTask t in tasks.Where(t => !t.ProjectInfo.isPortal && cNames.ContainsKey(t.ProjectInfo.IdCommunity)))
{
t.ProjectInfo.CommunityName = cNames[t.ProjectInfo.IdCommunity];
}
}
catch (Exception ex)
{
}
return(tasks);
}
public Boolean VirtualUndeleteProject(long idProject, dtoItemsFilter filter, ItemsGroupBy groupBy, PageListType currentPage, Int32 idCommunity, Int32 pageIndex, Int32 pageSize, ref long deleted)
{
Boolean result = false;
if (UserContext.isAnonymous)
{
View.DisplayPager(false);
View.LoadedNoProjects(currentPage);
}
else
{
result = Service.SetProjectVirtualDelete(idProject, false);
if (result)
{
View.SendUserAction(View.IdCurrentCommunityForList, CurrentIdModule, idProject, ModuleProjectManagement.ActionType.ProjectVirtualUndelete);
}
List <dtoPlainProject> projects = Service.GetProjects(UserContext.CurrentUserID, filter, currentPage, idCommunity, View.RoleTranslations);
deleted = projects.Count;
if (deleted > 0)
{
LoadProjects(Service.GetProjects(UserContext.CurrentUserID, filter, currentPage, idCommunity, View.RoleTranslations), groupBy, currentPage, filter.TimeLine, pageIndex, pageSize);
}
}
return(result);
}
public void InitView(dtoProjectContext context, Int32 idContainerCommunity, dtoItemsFilter filter, PageContainerType container, PageListType fromPage, PageListType currentPage, String unknownUser)
{
Person p = CurrentManager.GetPerson(UserContext.CurrentUserID);
View.PageContainer = container;
View.PageType = currentPage;
View.CurrentFromPage = fromPage;
View.IdContainerCommunity = idContainerCommunity;
View.PageContext = context;
if (UserContext.isAnonymous || p == null)
{
View.DisplayPager(false);
View.LoadedNoTasks();
}
else
{
View.IsInitialized = true;
if (filter.PageSize == 0)
{
filter.PageSize = View.CurrentPageSize;
}
View.CurrentOrderBy = filter.OrderBy;
View.CurrentAscending = filter.Ascending;
LoadTasks(context, filter, container, fromPage, currentPage, filter.PageIndex, filter.PageSize, unknownUser);
}
}
private void LoadFilters(Person user, dtoProjectContext context, dtoItemsFilter filter, PageContainerType containerType, PageListType currentPageType, PageListType fromPage, SummaryTimeLine timeline, long idProject = 0)
{
LoadAvailableStatus(user, context, filter, containerType, currentPageType, fromPage, timeline, idProject);
LoadAvailableGroupBy(context, filter, currentPageType, fromPage);
if (containerType != PageContainerType.ProjectDashboard)
{
LoadAvailableFiltersBy(user, context, filter, currentPageType);
}
}
private List <long> GetIdProjectsForTasksAsAdministrator(Person person, dtoItemsFilter filter, Int32 idCommunity)
{
List <long> results = new List <long>();
List <long> idProjects = (from r in Manager.GetIQ <ProjectResource>()
where r.Type == ResourceType.Internal && r.Person != null && r.Person.Id == person.Id &&
(r.ProjectRole == ActivityRole.ProjectOwner || r.ProjectRole == ActivityRole.Manager)
select r.Project.Id).ToList();
var query = (from p in Manager.GetIQ <Project>()
where ((filter.ProjectsStatus == ItemListStatus.Deleted && p.Deleted == BaseStatusDeleted.Manual) || (filter.ProjectsStatus != ItemListStatus.Deleted && p.Deleted == BaseStatusDeleted.None)) &&
p.isPersonal == false && !idProjects.Contains(p.Id)
select p);
query = query.Where(p => p.Availability != ProjectAvailability.Draft);
ModuleProjectManagement pPermissions = ModuleProjectManagement.CreatePortalmodule(person.TypeID);
ModuleProjectManagement cPermissions = new ModuleProjectManagement()
{
Administration = true
};
switch (filter.FilterBy)
{
case ProjectFilterBy.All:
if (pPermissions.Administration)
{
results.AddRange(query.Where(p => p.isPortal).Select(p => p.Id).ToList());
}
List <Int32> idCommunities = ServiceCommunityManagement.GetIdCommunityByModulePermissions(person.Id, new Dictionary <int, long>()
{
{ GetIdModule(), cPermissions.GetPermissions() }
});
if (idCommunities.Any())
{
results.AddRange(query.Where(p => !p.isPortal && p.Community != null && idCommunities.Contains(p.Community.Id)).Select(p => p.Id).ToList());
}
break;
case ProjectFilterBy.CurrentCommunity:
cPermissions = new ModuleProjectManagement(Manager.GetModulePermission(person.Id, idCommunity, idModule));
if (cPermissions.Administration)
{
results.AddRange(query.Where(p => !p.isPortal && p.Community != null && p.Community.Id == idCommunity).Select(p => p.Id).ToList());
}
break;
case ProjectFilterBy.FromPortal:
if (pPermissions.Administration)
{
results.AddRange(query.Where(p => p.isPortal).Select(p => p.Id).ToList());
}
break;
}
return(results);
}
public void LoadTasks(dtoProjectContext context, dtoItemsFilter filter, PageContainerType container, PageListType fromPage, PageListType currentPage, Int32 pageIndex, Int32 pageSize, String unknownUser)
{
if (UserContext.isAnonymous)
{
View.DisplayPager(false);
View.LoadedNoTasks();
}
else
{
LoadTasks(Service.GetTasks(UserContext.CurrentUserID, filter, context.IdCommunity, container, fromPage, currentPage), context, filter, container, fromPage, currentPage, pageIndex, pageSize, unknownUser);
}
}
public void LoadProjects(dtoItemsFilter filter, ItemsGroupBy groupBy, PageListType currentPage, Int32 idCommunity, Int32 pageIndex, Int32 pageSize)
{
if (UserContext.isAnonymous)
{
View.DisplayPager(false);
View.LoadedNoProjects(currentPage);
}
else
{
LoadProjects(Service.GetProjects(UserContext.CurrentUserID, filter, currentPage, idCommunity, View.RoleTranslations), groupBy, currentPage, filter.TimeLine, pageIndex, pageSize);
}
}
public void InitView(dtoProjectContext context, Int32 idContainerCommunity, dtoItemsFilter filter, PageContainerType container, PageListType fromPage, PageListType currentPage, String unknownUser)
{
Person p = CurrentManager.GetPerson(UserContext.CurrentUserID);
View.PageContainer = container;
View.PageType = currentPage;
View.CurrentFromPage = fromPage;
View.IdContainerCommunity = idContainerCommunity;
View.PageContext = context;
if (UserContext.isAnonymous || p == null)
{
View.DisplayPager(false);
View.LoadedNoTasks();
}
else
{
if (!View.IsInitialized && filter.GroupBy == ItemsGroupBy.EndDate)
{
filter.PageIndex = -1;
}
View.IsInitialized = true;
if (filter.PageSize == 0)
{
filter.PageSize = View.CurrentPageSize;
}
switch (filter.GroupBy)
{
case ItemsGroupBy.Community:
View.CurrentOrderBy = ProjectOrderBy.CommunityName;
View.CurrentAscending = true;
filter.OrderBy = ProjectOrderBy.CommunityName;
filter.Ascending = true;
break;
case ItemsGroupBy.EndDate:
View.CurrentOrderBy = ProjectOrderBy.EndDate;
View.CurrentAscending = false;
filter.OrderBy = ProjectOrderBy.EndDate;
filter.Ascending = false;
break;
case ItemsGroupBy.Project:
View.CurrentOrderBy = ProjectOrderBy.Name;
View.CurrentAscending = true;
filter.OrderBy = ProjectOrderBy.Name;
filter.Ascending = true;
break;
}
View.CurrentGroupBy = filter.GroupBy;
LoadTasks(unknownUser, context, idContainerCommunity, filter, container, fromPage, currentPage, filter.GroupBy, filter.PageIndex, filter.PageSize);
}
}
public void ReloadAvailableStatus(dtoItemsFilter filter, dtoProjectContext context, PageContainerType containerType, PageListType currentPageType, PageListType fromPage)
{
Person user = CurrentManager.GetPerson(UserContext.CurrentUserID);
if (UserContext.isAnonymous || user == null)
{
View.DisplaySessionTimeout();
}
else
{
LoadAvailableStatus(user, context, filter, containerType, currentPageType, fromPage, filter.TimeLine);
}
}
public void RefreshSummary(dtoItemsFilter filter, long idProject)
{
Person p = CurrentManager.GetPerson(UserContext.CurrentUserID);
if (UserContext.isAnonymous || p == null)
{
View.DisplaySessionTimeout();
}
else
{
dtoProjectContext context = View.PageContext;
LoadSummary(View.PageContext, View.IdContainerCommunity, View.PageType, View.CurrentFromPage, p, idProject, filter, View.CurrentTimeLine, View.CurrentDisplayMode, (context.IdCommunity > 0 ? context.IdCommunity : -100));
}
}
public void InitView(dtoProjectContext context, Int32 idContainerCommunity, Boolean loadFromCookies, TabListItem tab, PageContainerType container, PageListType fromPage, PageListType currentPageType, ItemsGroupBy preloadGroupBy, ProjectFilterBy pFilterBy, ItemListStatus pProjectsStatus, ItemListStatus pActivitiesStatus, SummaryTimeLine pFilterTimeLine = SummaryTimeLine.Week, SummaryDisplay pFilterDisplay = SummaryDisplay.All, long idProject = 0, UserActivityStatus pUserActivitiesStatus = UserActivityStatus.Ignore, SummaryTimeLine pUserActivitiesTimeLine = SummaryTimeLine.Week)
{
Person p = CurrentManager.GetPerson(UserContext.CurrentUserID);
View.PageContext = context;
View.PageContainer = container;
View.PageType = currentPageType;
View.CurrentFromPage = fromPage;
View.CurrendIdProject = idProject;
View.IdContainerCommunity = idContainerCommunity;
View.CurrentActivityStatus = pUserActivitiesStatus;
View.CurrentActivityTimeLine = pUserActivitiesTimeLine;
if (UserContext.isAnonymous || p == null)
{
View.DisplaySessionTimeout();
}
else
{
View.CookieName = View.CookieStartName + container.ToString() + tab.ToString();
dtoItemsFilter filter = null;
if (loadFromCookies)
{
filter = View.GetSavedFilters;
View.CurrentActivityStatus = filter.UserActivitiesStatus;
View.CurrentActivityTimeLine = filter.UserActivitiesTimeLine;
idProject = filter.IdProject;
View.CurrendIdProject = idProject;
}
if (filter == null)
{
filter = dtoItemsFilter.GenerateForGroup(container, (preloadGroupBy == ItemsGroupBy.None) ? ItemsGroupBy.Plain : preloadGroupBy);
if (preloadGroupBy != ItemsGroupBy.None)
{
filter.FilterBy = pFilterBy;
filter.ProjectsStatus = pProjectsStatus;
filter.Display = pFilterDisplay;
filter.TimeLine = pFilterTimeLine;
filter.ActivitiesStatus = pActivitiesStatus;
filter.UserActivitiesStatus = pUserActivitiesStatus;
filter.UserActivitiesTimeLine = pUserActivitiesTimeLine;
}
filter.IdProject = idProject;
}
LoadFilters(p, context, filter, container, currentPageType, fromPage, pFilterTimeLine, idProject);
View.SaveCurrentFilters(filter);
View.InitializeTabs(Service.GetAvailableTabs(p.Id, context, container), tab, filter, context);
LoadSummary(context, idContainerCommunity, currentPageType, fromPage, p, idProject, filter, pFilterTimeLine, pFilterDisplay, (context.IdCommunity > 0 ? context.IdCommunity : -100));
}
}
private void LoadAvailableGroupBy(dtoProjectContext context, dtoItemsFilter filter, PageListType currentPageType, PageListType fromPage)
{
List <ItemsGroupBy> availableItems = new List <ItemsGroupBy>();
switch (currentPageType)
{
case PageListType.DashboardAdministrator:
case PageListType.DashboardManager:
case PageListType.DashboardResource:
availableItems.Add(ItemsGroupBy.CommunityProject);
availableItems.Add(ItemsGroupBy.Project);
availableItems.Add(ItemsGroupBy.Community);
break;
case PageListType.ProjectDashboardManager:
case PageListType.ProjectDashboardResource:
break;
default:
availableItems.Add(ItemsGroupBy.Community);
break;
}
availableItems.Add(ItemsGroupBy.EndDate);
availableItems.Add(ItemsGroupBy.Plain);
if (!availableItems.Contains(filter.GroupBy))
{
filter.GroupBy = ItemsGroupBy.Plain;
}
Int32 idContainer = View.IdContainerCommunity;
List <dtoItemFilter <ItemsGroupBy> > items = (from i in availableItems select new dtoItemFilter <ItemsGroupBy>()
{
Url = GenerateItemUrl(currentPageType, fromPage, filter, context, idContainer, i, filter.GetContainerStatus(), View.CurrentActivityStatus), Value = i, Selected = (filter.GroupBy == i), DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.item
}).ToList();
if (items.Count == 1)
{
items[0].DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.first | lm.Comol.Core.DomainModel.ItemDisplayOrder.last;
}
else if (items.Any())
{
items.First().DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.first;
items.Last().DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.last;
}
View.LoadGroupByFilters(items);
}
public void InitView(dtoProjectContext context, dtoItemsFilter filter, PageListType currentPage)
{
Person p = CurrentManager.GetPerson(UserContext.CurrentUserID);
View.CurrentPageType = currentPage;
if (UserContext.isAnonymous || p == null)
{
View.DisplayPager(false);
View.LoadedNoProjects(currentPage);
}
else
{
if (!View.IsInitialized && filter.GroupBy == ItemsGroupBy.EndDate)
{
filter.PageIndex = -1;
}
View.IsInitialized = true;
View.IdCurrentCommunityForList = context.IdCommunity;
if (filter.PageSize == 0)
{
filter.PageSize = View.CurrentPageSize;
}
switch (filter.GroupBy)
{
case ItemsGroupBy.Community:
View.CurrentOrderBy = ProjectOrderBy.CommunityName;
View.CurrentAscending = true;
filter.OrderBy = ProjectOrderBy.CommunityName;
filter.Ascending = true;
break;
case ItemsGroupBy.EndDate:
View.CurrentOrderBy = ProjectOrderBy.EndDate;
View.CurrentAscending = false;
filter.OrderBy = ProjectOrderBy.EndDate;
filter.Ascending = false;
break;
}
View.CurrentGroupBy = filter.GroupBy;
//View.CurrentAscending = filter.Ascending;
LoadProjects(filter, filter.GroupBy, currentPage, context.IdCommunity, filter.PageIndex, filter.PageSize);
}
}
private void LoadAvailableFiltersBy(Person user, dtoProjectContext context, dtoItemsFilter filter, PageListType currentPageType)
{
List <ProjectFilterBy> fItems = Service.GetAvailableFilterBy(user.Id, context, currentPageType);
if (!fItems.Contains(filter.FilterBy))
{
filter.FilterBy = ProjectFilterBy.All;
}
String name = "";
if (fItems.Contains(ProjectFilterBy.CurrentCommunity))
{
Community community = CurrentManager.GetCommunity(context.IdCommunity);
if (community != null)
{
name = community.Name;
}
}
View.LoadFilterBy(fItems, filter.FilterBy, context.isForPortal, name);
}
public void Applyfilters(dtoItemsFilter filter, dtoProjectContext context, PageContainerType containerType, PageListType currentPageType, PageListType fromPage, Boolean summaryUpdate)
{
Person user = CurrentManager.GetPerson(UserContext.CurrentUserID);
if (UserContext.isAnonymous || user == null)
{
View.DisplaySessionTimeout();
}
else
{
long idProject = View.CurrendIdProject;
Int32 idCommunity = View.IdContainerCommunity;
if (summaryUpdate)
{
LoadSummary(context, idCommunity, currentPageType, fromPage, user, idProject, filter, filter.TimeLine, View.CurrentDisplayMode, (idCommunity > 0 ? idCommunity : -100));
}
LoadFilters(user, context, filter, containerType, currentPageType, fromPage, filter.TimeLine, idProject);
View.SaveCurrentFilters(filter);
}
}
private void LoadTasks(List <dtoPlainTask> tasks, dtoProjectContext context, dtoItemsFilter filter, PageContainerType container, PageListType fromPage, PageListType currentPage, Int32 pageIndex, Int32 pageSize, String unknownUser)
{
Int32 idContainerCommunity = View.IdContainerCommunity;
PagerBase pager = new PagerBase();
pager.PageSize = pageSize; //Me.View.CurrentPageSize
pager.Count = (tasks.Count > 0) ? tasks.Count - 1 : 0;
pager.PageIndex = pageIndex; // Me.View.CurrentPageIndex
View.Pager = pager;
pageIndex = (pageIndex > pager.PageIndex && pager.PageIndex >= 0) ? pager.PageIndex : pageIndex;
tasks = tasks.Skip(pageIndex * pageSize).Take(pageSize).ToList();
if (tasks.Any())
{
Dictionary <long, List <dtoResource> > resources = tasks.Select(t => t.ProjectInfo.Id).Distinct().ToDictionary(t => t, t => Service.GetAvailableResources(t, unknownUser));
if (currentPage != PageListType.ProjectDashboardManager && currentPage != PageListType.ProjectDashboardResource)
{
Int32 idContainer = View.IdContainerCommunity;
foreach (dtoPlainTask task in tasks.Where(t => t.ProjectInfo.Id > 0))
{
task.ProjectResources = (resources.ContainsKey(task.ProjectInfo.Id) ? resources[task.ProjectInfo.Id] : new List <dtoResource>());
task.ProjectInfo.ProjectDashboard = RootObject.ProjectDashboard(context, idContainer, task.ProjectInfo.Id, currentPage, currentPage, filter.TimeLine);
}
}
else
{
foreach (dtoPlainTask task in tasks)
{
task.ProjectResources = (resources.ContainsKey(task.ProjectInfo.Id) ? resources[task.ProjectInfo.Id] : new List <dtoResource>());
}
}
View.LoadTasks(tasks);
}
else
{
View.LoadedNoTasks();
}
SendDefaultAction(currentPage, filter.IdProject, context.IdCommunity);
}
public void InitView(dtoProjectContext context, dtoItemsFilter filter, PageListType currentPage)
{
Person p = CurrentManager.GetPerson(UserContext.CurrentUserID);
View.CurrentPageType = currentPage;
if (UserContext.isAnonymous || p == null)
{
View.DisplayPager(false);
View.LoadedNoProjects(currentPage);
}
else
{
View.IsInitialized = true;
View.IdCurrentCommunityForList = context.IdCommunity;
if (filter.PageSize == 0)
{
filter.PageSize = View.CurrentPageSize;
}
View.CurrentOrderBy = filter.OrderBy;
View.CurrentAscending = filter.Ascending;
LoadProjects(filter, currentPage, context.IdCommunity, filter.PageIndex, filter.PageSize);
}
}
//public void AddDeletedStatus(ref dtoItemsFilter filter, dtoProjectContext context, PageContainerType itemsView, PageListType currentView, Boolean moveToStatus)
//{
// if (moveToStatus) {
// filter.Status = ItemListStatus.Deleted;
// filter.PageIndex = 0;
// switch (filter.GroupBy) {
// case ItemsGroupBy.Plain:
// filter.OrderBy = ProjectOrderBy.Name;
// filter.Ascending = true;
// break;
// case ItemsGroupBy.EndDate:
// filter.OrderBy = ProjectOrderBy.EndDate;
// filter.Ascending = true;
// break;
// case ItemsGroupBy.Community:
// filter.OrderBy = ProjectOrderBy.CommunityName;
// filter.Ascending = true;
// break;
// }
// }
// ItemListStatus status = filter.Status;
// List<ItemListStatus> sItems = Service.GetAvailableFilterStatus(CurrentManager.GetPerson(UserContext.CurrentUserID), context, filter, currentView);
// sItems.Add(ItemListStatus.Deleted);
// Int32 idCommunity = View.IdCurrentCommunityForList;
// View.InitializeSummary(UserContext.CurrentUserID, filter.TimeLine, filter.Display, filter.FilterBy, filter.Status, (idCommunity > 0 ? idCommunity : -100));
// View.LoadStatus(GetStatusItems(sItems, context, filter, currentView));
// View.LoadGroupBy(GetGroupByItems(filter, context, itemsView, currentView));
// View.SaveCurrentFilters(filter);
//}
public void RemoveDeletedStatus(ref dtoItemsFilter filter, dtoProjectContext context, PageContainerType containerType, PageListType currentPageType, PageListType fromPage)
{
Person user = CurrentManager.GetPerson(UserContext.CurrentUserID);
if (UserContext.isAnonymous || user == null)
{
View.DisplaySessionTimeout();
}
else
{
long idProject = View.CurrendIdProject;
List <ItemListStatus> avalableStatus = Service.GetAvailableFilterStatus(user, context, filter, containerType, currentPageType, filter.TimeLine, idProject);
View.LoadStatusFilters(GetStatusItems(avalableStatus, context, filter, currentPageType, fromPage));
if (!avalableStatus.Contains(ItemListStatus.Deleted))
{
filter = dtoItemsFilter.GenerateForGroup(containerType, filter.GroupBy);
Int32 idCommunity = View.IdContainerCommunity;
LoadAvailableGroupBy(context, filter, currentPageType, fromPage);
LoadSummary(context, idCommunity, currentPageType, fromPage, user, idProject, filter, filter.TimeLine, View.CurrentDisplayMode, (idCommunity > 0 ? idCommunity : -100));
View.SaveCurrentFilters(filter);
}
}
}
private void LoadSummary(dtoProjectContext context, Int32 idContainerCommunity, PageListType currentPageType, PageListType fromPage, Person user, long idProject, dtoItemsFilter filter, SummaryTimeLine timeline, SummaryDisplay displayMode, Int32 idCommunity = -100)
{
if (idProject > 0)
{
LoadProjectSummary(context, idContainerCommunity, currentPageType, fromPage, user.Id, idProject, timeline, displayMode);
}
else if (displayMode == SummaryDisplay.Filtered)
{
if (filter.FilterBy != ProjectFilterBy.CurrentCommunity && filter.FilterBy != ProjectFilterBy.AllPersonalFromCurrentCommunity)
{
idCommunity = -100;
}
LoadSummary(context, idContainerCommunity, currentPageType, fromPage, user, timeline, displayMode, filter.FilterBy, filter.GetContainerStatus(), idCommunity);
}
else
{
LoadSummary(context, idContainerCommunity, currentPageType, fromPage, user, timeline, displayMode);
}
}
private Boolean UserHasActivitiesByStatus(UserActivityStatus status, Person p, dtoProjectContext context, dtoItemsFilter filter, PageListType pageType, SummaryTimeLine timeline, long idProject = 0)
{
switch (pageType)
{
case PageListType.ProjectDashboardManager:
return(ProjectHasActivitiesByStatus(status, idProject, timeline));
case PageListType.DashboardAdministrator:
if (idProject > 0)
{
return(ProjectHasActivitiesByStatus(status, idProject, timeline));
}
break;
default:
Int32 idCommunity = context.IdCommunity;
if (filter.FilterBy != ProjectFilterBy.CurrentCommunity && filter.FilterBy != ProjectFilterBy.AllPersonalFromCurrentCommunity)
{
idCommunity = -100;
}
List <dtoTimelineSummary> items = GetSummary(p.Id, idProject, filter.FilterBy, ItemListStatus.All, idCommunity);
if (pageType == PageListType.ProjectDashboardResource)
{
return(items != null && items.Where(i => i.DashboardPage == PageListType.DashboardResource && i.Activities.Where(a => a.TimeLine == timeline && a.Status == status).Any()).Any());
}
else
{
return(items != null && items.Where(i => i.DashboardPage == pageType && i.Activities.Where(a => a.TimeLine == timeline && a.Status == status).Any()).Any());
}
}
return(false);
}
private List <dtoPlainTask> GetTasks(IEnumerable <PmActivity> query, Dictionary <SummaryTimeLine, long> days, dtoItemsFilter filter, Dictionary <long, ActivityRole> projectRoles, PageContainerType container, PageListType displayPage)
{
List <dtoPlainTask> tasks = GetTasks(query, days, filter);
Dictionary <ActivityRole, PmActivityPermission> permissions = projectRoles.Values.Distinct().ToDictionary(v => v, v => GetRolePermissions(GetUserRoleByPage(v, container, displayPage)));
foreach (dtoPlainTask t in tasks)
{
t.SetPermissions(permissions[projectRoles[t.ProjectInfo.Id]]);
}
return(tasks);
}
private IEnumerable <liteProjectActivityAssignment> GetAssignmentsByUser(Int32 idPerson, dtoItemsFilter filter, Int32 idCommunity)
{
IEnumerable <liteProjectActivityAssignment> query = (from r in Manager.GetIQ <liteProjectActivityAssignment>()
where r.Deleted == BaseStatusDeleted.None && r.IdPerson == idPerson
select r);
if (filter.IdProject > 0)
{
query = query.Where(a => a.Project.Id == filter.IdProject);
}
switch (filter.FilterBy)
{
case ProjectFilterBy.AllPersonal:
query = query.Where(r => r.Project != null && r.Project.isPersonal && r.Resource.ProjectRole == ActivityRole.ProjectOwner);
break;
case ProjectFilterBy.AllPersonalFromCurrentCommunity:
query = query.Where(r => r.Project != null && r.Project.isPersonal && !r.Project.isPortal && r.Project.IdCommunity == idCommunity && r.Resource.ProjectRole == ActivityRole.ProjectOwner);
break;
case ProjectFilterBy.CurrentCommunity:
query = query.Where(r => r.Project != null && !r.Project.isPortal && r.Project.IdCommunity == idCommunity);
break;
case ProjectFilterBy.FromPortal:
query = query.Where(r => r.Project != null && r.Project.isPortal && !r.Project.isPersonal);
break;
}
query = query.Where(r => r.Project.Availability != ProjectAvailability.Draft);
//switch (filter.Status)
//{
// case ItemListStatus.All:
// query = query.Where(r => r.Project.Availability != ProjectAvailability.Draft);
// break;
// case ItemListStatus.Future:
// query = query.Where(r => (r.Project.Status != ProjectItemStatus.completed && r.Project.Availability != ProjectAvailability.Draft && r.Project.StartDate.Value.Ticks > DateTime.Now.Date.Ticks));
// break;
// case ItemListStatus.Active:
// query = query.Where(r => r.Project != null && !r.Project.IsCompleted && r.Project.Availability == ProjectAvailability.Active);
// break;
// case ItemListStatus.Completed:
// query = query.Where(r => r.Project != null && r.Project.IsCompleted);
// break;
//}
return(query);
}
private String GenerateItemUrl(PageListType currentPageType, PageListType fromPage, dtoItemsFilter filter, dtoProjectContext context, Int32 idContainerCommunity, ItemsGroupBy groupBy, ItemListStatus status, UserActivityStatus activitiesStatus = UserActivityStatus.Ignore)
{
switch (currentPageType)
{
case PageListType.ListAdministrator:
return(RootObject.ProjectListAdministrator(context.IdCommunity, context.isForPortal, context.isPersonal, false, 0, groupBy, filter.FilterBy, status, filter.TimeLine, filter.Display));
case PageListType.ListManager:
return(RootObject.ProjectListManager(context.IdCommunity, context.isForPortal, context.isPersonal, false, 0, groupBy, filter.FilterBy, status, filter.TimeLine, filter.Display));
case PageListType.ListResource:
return(RootObject.ProjectListResource(context.IdCommunity, context.isForPortal, context.isPersonal, false, 0, groupBy, filter.FilterBy, status, filter.TimeLine, filter.Display));
case PageListType.DashboardManager:
case PageListType.DashboardResource:
case PageListType.DashboardAdministrator:
return(RootObject.Dashboard(context, idContainerCommunity, View.PageContainer, fromPage, currentPageType, filter.TimeLine, filter.Display, filter.FilterBy, groupBy, status, activitiesStatus, View.CurrentActivityTimeLine));
case PageListType.ProjectDashboardResource:
case PageListType.ProjectDashboardManager:
return(RootObject.ProjectDashboard(context, idContainerCommunity, filter.IdProject, fromPage, currentPageType, groupBy, status, filter.TimeLine, activitiesStatus, View.CurrentActivityTimeLine));
default:
return("");
}
}
private List <dtoPlainTask> GetTasks(IEnumerable <liteProjectActivityAssignment> query, Dictionary <SummaryTimeLine, long> days, dtoItemsFilter filter, Dictionary <ActivityRole, PmActivityPermission> permissions)
{
List <dtoPlainTask> tasks = new List <dtoPlainTask>();
switch (filter.ActivitiesStatus)
{
case ItemListStatus.Active:
query = query.Where(a => (!a.IsApproved || a.Completeness < 100) && a.Activity.EarlyStartDate != null && a.Activity.EarlyStartDate.Value.Ticks >= days[SummaryTimeLine.Today] && a.Activity.EarlyStartDate.Value.Ticks <= days[filter.TimeLine]);
break;
case ItemListStatus.Completed:
query = query.Where(a => a.IsApproved && a.Completeness == 100);
break;
case ItemListStatus.Future:
query = query.Where(a => (!a.IsApproved || a.Completeness < 100) && a.Activity.EarlyStartDate != null && a.Activity.EarlyStartDate.Value.Ticks > days[filter.TimeLine]);
break;
case ItemListStatus.Late:
query = query.Where(a => (!a.IsApproved || a.Completeness < 100) && ((a.Activity.EarlyStartDate != null && a.Activity.EarlyFinishDate.Value.Ticks < days[SummaryTimeLine.Today]) || (a.Activity.Deadline != null && a.Activity.Deadline.Value.Ticks < days[SummaryTimeLine.Today])));
break;
case ItemListStatus.DueForCompletion:
query = query.Where(a => (!a.IsApproved || a.Completeness < 100) && a.Activity.EarlyStartDate != null && a.Activity.EarlyStartDate.Value.Ticks >= days[SummaryTimeLine.Today] && ((a.Activity.EarlyFinishDate.Value.Ticks <= days[filter.TimeLine]) || (a.Activity.Deadline != null && a.Activity.Deadline.Value.Ticks <= days[filter.TimeLine])));
break;
case ItemListStatus.Ignore:
switch (filter.UserActivitiesStatus)
{
case UserActivityStatus.Starting:
query = query.Where(a => a.Activity.EarlyStartDate != null && a.Completeness == 0 && a.Activity.EarlyStartDate.Value.Ticks >= days[SummaryTimeLine.Today] && a.Activity.EarlyStartDate.Value.Ticks <= days[filter.UserActivitiesTimeLine]);
break;
case UserActivityStatus.ToDo:
query = query.Where(a => a.Activity.EarlyStartDate != null && (!a.IsApproved || a.Completeness < 100) && a.Activity.EarlyStartDate.Value.Ticks >= days[SummaryTimeLine.Today] && a.Activity.EarlyStartDate.Value.Ticks <= days[filter.UserActivitiesTimeLine]);
break;
case UserActivityStatus.Expired:
query = query.Where(a => a.Activity.EarlyStartDate != null && (!a.IsApproved || a.Completeness < 100) && a.Activity.EarlyFinishDate != null && a.Activity.EarlyFinishDate.Value.Ticks < days[SummaryTimeLine.Today]);
break;
case UserActivityStatus.Expiring:
query = query.Where(a => a.Activity.EarlyStartDate != null && (!a.IsApproved || a.Completeness < 100) && a.Activity.EarlyFinishDate != null && a.Activity.EarlyFinishDate.Value.Ticks >= days[SummaryTimeLine.Today] && a.Activity.EarlyFinishDate.Value.Ticks <= days[filter.UserActivitiesTimeLine]);
break;
}
break;
}
tasks = query.ToList().Select(a => new dtoPlainTask(a, permissions)).ToList();
return(tasks);
}
public List <dtoPlainTask> GetTasks(Int32 idPerson, dtoItemsFilter filter, Int32 idCommunity, PageContainerType container, PageListType fromPage, PageListType displayPage)
{
List <dtoPlainTask> tasks = new List <dtoPlainTask>();
try
{
Person person = Manager.GetPerson(idPerson);
switch (container)
{
case PageContainerType.ProjectDashboard:
switch (displayPage)
{
case PageListType.ProjectDashboardManager:
if (IsProjectManager(filter.IdProject, idPerson))
{
tasks = GetTasksAsManager(idPerson, filter, idCommunity, container, fromPage, displayPage);
}
else if (IsProjectAdministrator(filter.IdProject, person))
{
tasks = GetProjectTasksAsAdministrator(person, filter, idCommunity);
}
break;
case PageListType.ProjectDashboardResource:
tasks = GetTasksAsResource(idPerson, filter, idCommunity, container, fromPage, displayPage);
break;
}
break;
case PageContainerType.Dashboard:
switch (displayPage)
{
case PageListType.DashboardManager:
tasks = GetTasksAsManager(idPerson, filter, idCommunity, container, fromPage, displayPage);
break;
case PageListType.DashboardAdministrator:
tasks = GetTasksAsAdministrator(person, filter, idCommunity);
break;
case PageListType.DashboardResource:
tasks = GetTasksAsResource(idPerson, filter, idCommunity, container, fromPage, displayPage);
break;
}
break;
}
#region "ApplyFilters"
switch (filter.GroupBy)
{
case ItemsGroupBy.Plain:
switch (filter.OrderBy)
{
case ProjectOrderBy.TaskName:
if (filter.Ascending)
{
tasks = tasks.OrderBy(p => p.Name).ThenByDescending(p => p.Deadline).ThenByDescending(p => p.EndDate).ToList();
}
else
{
tasks = tasks.OrderByDescending(p => p.Name).ThenByDescending(p => p.Deadline).ThenByDescending(p => p.EndDate).ToList();
}
break;
case ProjectOrderBy.Completion:
if (filter.Ascending)
{
tasks = tasks.OrderBy(p => p.Completeness).ThenBy(p => p.Name).ToList();
}
else
{
tasks = tasks.OrderByDescending(p => p.IsCompleted).ThenByDescending(p => p.Completeness).ThenBy(p => p.Name).ToList();
}
break;
case ProjectOrderBy.Deadline:
if (filter.Ascending)
{
tasks = tasks.OrderBy(p => p.VirtualDeadline).ThenBy(p => p.Name).ToList();
}
else
{
tasks = tasks.OrderBy(p => p.VirtualDeadline).ThenBy(p => p.Name).ToList();
}
break;
case ProjectOrderBy.EndDate:
if (filter.Ascending)
{
tasks = tasks.OrderBy(p => p.VirtualEndDate).ThenBy(p => p.Name).ToList();
}
else
{
tasks = tasks.OrderByDescending(p => p.VirtualEndDate).ThenBy(p => p.Name).ToList();
}
break;
}
break;
case ItemsGroupBy.EndDate:
if (filter.Ascending)
{
tasks = tasks.OrderBy(p => p.VirtualEndDate).ThenBy(p => p.Name).ToList();
}
else
{
tasks = tasks.OrderByDescending(p => p.VirtualEndDate).ThenBy(p => p.Name).ToList();
}
break;
case ItemsGroupBy.Community:
if (filter.Ascending)
{
tasks = tasks.OrderBy(p => p.ProjectInfo.VirtualCommunityName).ThenBy(p => p.VirtualDeadline).ToList();
}
else
{
tasks = tasks.OrderByDescending(p => p.ProjectInfo.VirtualCommunityName).ThenBy(p => p.VirtualDeadline).ToList();
}
break;
case ItemsGroupBy.Project:
if (filter.Ascending)
{
tasks = tasks.OrderBy(p => p.ProjectInfo.VirtualProjectName).ThenBy(p => p.VirtualDeadline).ToList();
}
else
{
tasks = tasks.OrderByDescending(p => p.ProjectInfo.VirtualProjectName).ThenBy(p => p.VirtualDeadline).ToList();
}
break;
}
#endregion
}
catch (Exception ex)
{
}
return(tasks);
}
private void LoadSummary(dtoProjectContext context, Int32 idContainerCommunity, PageListType currentPageType, PageListType fromPage, List <dtoTimelineSummary> items, SummaryTimeLine timeline, SummaryDisplay display)
{
List <dtoDisplayTimelineSummary> results = new List <dtoDisplayTimelineSummary>();
if (items != null)
{
List <dtoItemFilter <SummaryTimeLine> > timeLines = items.SelectMany(t => t.Activities.Select(a => a.TimeLine)).Distinct().Where(t => t != SummaryTimeLine.Today).Select(t => new dtoItemFilter <SummaryTimeLine>()
{
Value = t, Selected = (t == timeline)
}).ToList();
if (timeLines.Count == 1)
{
timeLines[0].DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.first | lm.Comol.Core.DomainModel.ItemDisplayOrder.last;
}
else if (timeLines.Count > 1)
{
timeLines[0].DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.first;
timeLines.Last().DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.last;
}
if (!timeLines.Where(t => t.Selected).Any())
{
timeline = timeLines.FirstOrDefault().Value;
timeLines.FirstOrDefault().Selected = true;
}
View.LoadTimeLines(timeLines);
List <dtoItemFilter <SummaryDisplay> > dItems = new List <dtoItemFilter <SummaryDisplay> >();
if (display == SummaryDisplay.Project)
{
dItems.Add(new dtoItemFilter <SummaryDisplay>()
{
DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.last, Value = SummaryDisplay.Project, Selected = (display == SummaryDisplay.Project)
});
}
else
{
if (View.PageContainer == PageContainerType.ProjectsList)
{
dItems.Add(new dtoItemFilter <SummaryDisplay>()
{
DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.first | ItemDisplayOrder.last, Value = SummaryDisplay.All, Selected = true
});
}
else
{
dItems.Add(new dtoItemFilter <SummaryDisplay>()
{
DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.first, Value = SummaryDisplay.All, Selected = (display == SummaryDisplay.All)
});
dItems.Add(new dtoItemFilter <SummaryDisplay>()
{
DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.last, Value = SummaryDisplay.Filtered, Selected = (display == SummaryDisplay.Filtered)
});
}
}
if (!dItems.Where(t => t.Selected).Any())
{
dItems.FirstOrDefault().Selected = true;
}
View.LoadDisplayMode(dItems);
UserActivityStatus aStatus = View.CurrentActivityStatus;
if (aStatus != UserActivityStatus.Ignore)
{
SummaryTimeLine aTimeline = View.CurrentActivityTimeLine;
if (items.Where(i => i.Activities.Where(a => a.Status == aStatus && a.TimeLine == aTimeline).Any()).Any())
{
View.CurrentStatus = ItemListStatus.Ignore;
}
else
{
View.CurrentActivityStatus = UserActivityStatus.Ignore;
}
}
dtoItemsFilter filters = View.GetCurrentFilters;
items.ForEach(i => results.Add(new dtoDisplayTimelineSummary(i,
new dtoDisplayTimelineContext(context, idContainerCommunity, View.PageContainer, currentPageType, fromPage, filters, (View.PageContainer != PageContainerType.ProjectsList && currentPageType == i.DashboardPage) ? ItemsGroupBy.None : ItemsGroupBy.Plain))));
}
View.LoadSummaries(results);
}
private List <dtoItemFilter <ItemListStatus> > GetStatusItems(List <ItemListStatus> availableStatus, dtoProjectContext context, dtoItemsFilter filter, PageListType currentPageType, PageListType fromPage)
{
Int32 idContainer = View.IdContainerCommunity;
ItemListStatus current = filter.GetContainerStatus();
switch (filter.Container)
{
case PageContainerType.ProjectsList:
if (!availableStatus.Contains(current))
{
current = (availableStatus.Contains(ItemListStatus.Active) ? ItemListStatus.Active : availableStatus.First());
}
break;
default:
if (!availableStatus.Contains(current))
{
current = (availableStatus.Contains(ItemListStatus.Active) ? ItemListStatus.Active : availableStatus.First());
}
break;
}
List <dtoItemFilter <ItemListStatus> > items = (from i in availableStatus select new dtoItemFilter <ItemListStatus>()
{
Url = GenerateItemUrl(currentPageType, fromPage, filter, context, idContainer, filter.GroupBy, i), Value = i, Selected = (filter.GetContainerStatus() == i), DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.item
}).ToList();
if (!items.Where(i => i.Selected).Any())
{
items.First().Selected = true;
switch (filter.Container)
{
case PageContainerType.ProjectsList:
filter.ProjectsStatus = items.First().Value;
break;
default:
filter.ActivitiesStatus = items.First().Value;
break;
}
}
items.First().DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.first;
items.Last().DisplayAs = lm.Comol.Core.DomainModel.ItemDisplayOrder.last;
return(items);
}
private void LoadAvailableStatus(Person user, dtoProjectContext context, dtoItemsFilter filter, PageContainerType containerType, PageListType currentPageType, PageListType fromPage, SummaryTimeLine timeline, long idProject = 0)
{
View.LoadStatusFilters(GetStatusItems(Service.GetAvailableFilterStatus(user, context, filter, containerType, currentPageType, timeline, idProject), context, filter, currentPageType, fromPage));
}
