private void InitializeView(Boolean forAdministration, Int32 idProfile, List <Int32> unloadIdCommunities, CommunityAvailability availability, List <Int32> onlyFromOrganizations, Dictionary <Int32, long> requiredPermissions = null)
{
View.IdProfile = idProfile;
litePerson currentUser = CurrentManager.GetLitePerson(UserContext.CurrentUserID);
litePerson person = CurrentManager.GetLitePerson(idProfile);
View.OnlyFromOrganizations = onlyFromOrganizations;
View.SelectedIdCommunities = new List <int>();
View.CurrentAvailability = availability;
View.ExcludeCommunities = unloadIdCommunities;
List <lm.Comol.Core.DomainModel.Filters.Filter> fToLoad = ServiceCommunities.GetDefaultFilters(idProfile, "", -1, -1, null, null, availability, -2, unloadIdCommunities, onlyFromOrganizations, requiredPermissions).OrderBy(f => f.DisplayOrder).ToList();
View.LoadDefaultFilters(fToLoad, requiredPermissions, unloadIdCommunities, availability, onlyFromOrganizations);
if (fToLoad != null && fToLoad.Any())
{
dtoCommunitiesFilters filters = new lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters(fToLoad, availability);
filters.AvailableIdOrganizations = onlyFromOrganizations;
filters.OnlyFromAvailableOrganizations = (onlyFromOrganizations != null && onlyFromOrganizations.Any());
filters.RequiredPermissions = (requiredPermissions == null)? new List <dtoModulePermission>() : requiredPermissions.Select(r => new dtoModulePermission()
{
IdModule = r.Key, Permissions = r.Value
}).ToList();
LoadCommunities(idProfile, filters, unloadIdCommunities, 0, View.CurrentPageSize, false);
View.HasAvailableCommunities = true;
}
else
{
View.LoadNothing();
}
}
public void EnrollTo(Int32 idCommunity, String name, String path, lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters)
{
Int32 idPerson = UserContext.CurrentUserID;
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout();
}
else
{
Boolean reloadCommunities = false;
ModuleDashboard.ActionType dAction = ModuleDashboard.ActionType.None;
dtoCommunityInfoForEnroll item = Service.GetEnrollingItem(idPerson, idCommunity, path);
litePerson person = CurrentManager.GetLitePerson(idPerson);
if (item != null && item.Id > 0 && person != null && person.Id > 0)
{
if (!item.AllowEnroll)
{
dAction = ModuleDashboard.ActionType.EnrollNotAllowed;
View.DisplayEnrollMessage(item, dAction);
}
else
{
if (!item.HasConstraints && item.AllowUnsubscribe)
{
dtoEnrollment enrollment = Service.EnrollTo(idPerson, item);
if (enrollment == null)
{
dAction = ModuleDashboard.ActionType.UnableToEnroll;
View.DisplayEnrollMessage(item, dAction);
}
else
{
View.DisplayEnrollMessage(enrollment, enrollment.IdCommunity, person, Service.GetTranslatedProfileType(person), CurrentManager.GetUserDefaultOrganizationName(idPerson));
reloadCommunities = true;
dAction = (enrollment.Status == EnrolledStatus.NeedConfirm) ? ModuleDashboard.ActionType.EnrollToCommunityWaitingConfirm : ModuleDashboard.ActionType.EnrollToCommunity;
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(lm.Comol.Core.BaseModules.CommunityManagement.Domain.CacheKeys.UserCommunitiesTree(idPerson));
}
}
else
{
dAction = ModuleDashboard.ActionType.RequireEnrollConfirm;
View.DisplayConfirmMessage(item);
}
}
}
else
{
dAction = ModuleDashboard.ActionType.UnableToEnroll;
View.DisplayUnknownCommunity(name);
}
View.SendUserAction(0, CurrentIdModule, idCommunity, dAction);
if (reloadCommunities)
{
LoadTree(filters, View.AdvancedMode, View.ReferenceIdCommunity, false);
}
}
}
private void LoadTree(lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters, Boolean advancedMode, Int32 idReferenceCommunity = 0, Boolean useCache = true)
{
litePerson p = CurrentManager.GetLitePerson(UserContext.CurrentUserID);
List <dtoCommunityNodeItem> nodes = Service.GetTree(p, filters, advancedMode, idReferenceCommunity, useCache);
List <Int32> idCommunities = View.GetIdcommunitiesWithNews(nodes.Where(n => n.Type == NodeType.Community && n.Details.Permissions.AccessTo).Select(n => n.IdCommunity).Distinct().ToList(), UserContext.CurrentUserID);
nodes.Where(n => idCommunities.Contains(n.IdCommunity)).ToList().ForEach(n => n.Details.Permissions.ViewNews = true);
View.LoadTree(nodes);
}
public void LoadCommunities(Int32 itemsForPage, RangeSettings range, lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters, OrderItemsToSubscribeBy orderBy, Boolean ascending, Int32 pageIndex)
{
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout();
}
else
{
InternalLoadCommunities(itemsForPage, range, filters, orderBy, ascending, true, pageIndex, ModuleDashboard.ActionType.EnrollPageChangePageIndex);
}
}
public void LoadCommunities(Int32 idProfile, lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters, List <Int32> unloadIdCommunities, Int32 pageIndex, Int32 pageSize, Boolean useCache = true)
{
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout();
}
else
{
List <Int32> selectedItems = View.SelectedIdCommunities;
Dictionary <Boolean, List <Int32> > selections = View.GetCurrentSelection();
selectedItems = selectedItems.Except(selections[false]).ToList();
selectedItems.AddRange(selections[true]);
View.SelectedIdCommunities = selectedItems.Distinct().ToList();
View.SearchFilters = filters;
List <dtoCommunityPlainItem> items = ServiceCommunities.GetPlainCommunities(idProfile, filters, unloadIdCommunities, useCache);
if (items == null)
{
View.LoadNothing();
}
else
{
Int32 itemsCount = items.Count();
PagerBase pager = new PagerBase();
pager.PageSize = pageSize;
pager.Count = (itemsCount > 0) ? itemsCount - 1 : 0;
pager.PageIndex = pageIndex;
View.Pager = pager;
items = ServiceCommunities.GetCommunities(items, pageIndex, pageSize, Core.Dashboard.Domain.OrderItemsBy.Name, true);
if (items != null)
{
Language l = CurrentManager.GetDefaultLanguage();
Dictionary <Int32, List <String> > tags = ServiceTags.GetCommunityAssociationToString(items.Select(i => i.Community.Id).ToList(), UserContext.Language.Id, l.Id, true);
if (tags.Any())
{
foreach (dtoCommunityPlainItem item in items.Where(i => tags.ContainsKey(i.Community.Id)))
{
item.Community.Tags = tags[item.Community.Id];
}
}
View.LoadItems(items);
}
else
{
View.LoadItems(new List <dtoCommunityPlainItem>());
}
}
}
}
private void InitializeColumns(lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters, List <dtoEnrollingItem> items)
{
List <searchColumn> columns = new List <searchColumn>();
columns.Add(searchColumn.info);
columns.Add(searchColumn.name);
if (items.Where(i => i.Community.SubscriptionStartOn.HasValue).Any())
{
columns.Add(searchColumn.startsubscriptionon);
}
if (items.Where(i => i.Community.SubscriptionEndOn.HasValue).Any())
{
columns.Add(searchColumn.endsubscriptionon);
}
if (items != null && items.Where(i => i.AllowSubscribe).Any())
{
columns.Add(searchColumn.actions);
if (items.Where(i => i.AllowSubscribe).Count() > 0)
{
columns.Add(searchColumn.select);
}
}
switch (filters.IdcommunityType)
{
case (int)CommunityTypeStandard.Degree:
if (filters.IdDegreeType < 1)
{
columns.Add(searchColumn.degreetype);
}
break;
case (int)CommunityTypeStandard.UniversityCourse:
if (filters.Year < 1)
{
columns.Add(searchColumn.year);
}
if (filters.IdCourseTime < 1)
{
columns.Add(searchColumn.coursetime);
}
break;
}
//if (filters.IdResponsible<1)
columns.Add(searchColumn.owner);
if (items != null && items.Where(i => i.Community.MaxUsersWithDefaultRole > 0).Any())
{
columns.Add(searchColumn.maxsubscribers);
}
View.AvailableColumns = columns;
}
public void EnrollTo(dtoCommunityInfoForEnroll community, lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters, Boolean advancedMode, Int32 idReferenceCommunity)
{
Int32 idPerson = UserContext.CurrentUserID;
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout();
}
else
{
Boolean reloadCommunities = false;
if (community != null)
{
reloadCommunities = true;
litePerson person = CurrentManager.GetLitePerson(idPerson);
String profileType = Service.GetTranslatedProfileType(person);
String organizationName = CurrentManager.GetUserDefaultOrganizationName(idPerson);
dtoEnrollment enrollment = Service.EnrollTo(idPerson, community);
if (enrollment != null)
{
switch (enrollment.Status)
{
case EnrolledStatus.Available:
case EnrolledStatus.NeedConfirm:
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(lm.Comol.Core.BaseModules.CommunityManagement.Domain.CacheKeys.UserCommunitiesTree(idPerson));
//View.NotifyEnrollment(enrollment, person, profileType, organizationName);
View.SendUserAction(0, CurrentIdModule, community.Id, (enrollment.Status == EnrolledStatus.Available) ? ModuleDashboard.ActionType.EnrollToCommunity : ModuleDashboard.ActionType.EnrollToCommunityWaitingConfirm);
reloadCommunities = true;
break;
}
View.DisplayEnrollMessage(enrollment, enrollment.IdCommunity, person, Service.GetTranslatedProfileType(person), CurrentManager.GetUserDefaultOrganizationName(idPerson));
}
if (reloadCommunities)
{
LoadTree(filters, advancedMode, idReferenceCommunity, false);
}
}
else
{
View.SendUserAction(0, CurrentIdModule, ModuleDashboard.ActionType.NoSelectedCommunitiesToEnroll);
}
}
}
public void ApplyFilters(Int32 itemsForPage, RangeSettings range, lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters, OrderItemsToSubscribeBy orderBy)
{
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout();
}
else
{
InternalLoadCommunities(itemsForPage, range, filters, orderBy, GetDefaultAscending(orderBy), false, 0, ModuleDashboard.ActionType.EnrollPageApplyFilters, true);
View.CurrentFilters = filters;
liteTile tile = null;
if (filters.IdcommunityType > -1)
{
tile = Service.GetTileForCommunityType(filters.IdcommunityType);
}
}
}
public dtoTreeCommunityNode InternalFilter(dtoCommunitiesFilters filter, Int32 IdDefaultOrganization, List <Int32> onlyFromOrganizations = null)
{
dtoTreeCommunityNode root = (dtoTreeCommunityNode)this.Clone();
if (root.Type != dtoCommunityNodeType.Root && filter.Status != CommunityStatus.None && filter.Status != this.Status)
{
root.Type = dtoCommunityNodeType.NotSelectable;
}
if (root.Type != dtoCommunityNodeType.Root && root.Type != dtoCommunityNodeType.NotSelectable && filter.Availability != CommunityAvailability.All)
{
root.Type = (filter.Availability == CommunityAvailability.NotSubscribed && this.Selected) ? dtoCommunityNodeType.NotSelectable
: this.Type;
}
if (root.Type != dtoCommunityNodeType.NotSelectable && this.IdOrganization == IdDefaultOrganization && this.IdFather == 0)
{
root.Type = dtoCommunityNodeType.NotSelectable;
}
if (root.Type != dtoCommunityNodeType.Root && !HasNodes(filter))
{
return(root);
}
else
{
foreach (dtoTreeCommunityNode n in this.Nodes.Where(n => onlyFromOrganizations == null || (onlyFromOrganizations != null && onlyFromOrganizations.Contains(n.IdOrganization))).OrderBy(nn => nn.Name).ToList())
{
if (n.HasNodes(filter))
{
dtoTreeCommunityNode subNode = n.InternalFilter(filter, IdDefaultOrganization, onlyFromOrganizations);
if (subNode != null)
{
root.Nodes.Add(subNode);
}
}
}
if (root.Type == dtoCommunityNodeType.Root)
{
root.Type = dtoCommunityNodeType.Root;
}
return(root);
}
}
public void EnrollTo(List <dtoCommunityToEnroll> sCommunities, Boolean applyToAll, Int32 itemsForPage, RangeSettings range, lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters, OrderItemsToSubscribeBy orderBy, Boolean ascending, Int32 pageIndex)
{
Int32 idPerson = UserContext.CurrentUserID;
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout();
}
else
{
ModuleDashboard.ActionType dAction = ModuleDashboard.ActionType.None;
Boolean reloadCommunities = false;
List <dtoCommunityToEnroll> cCommunities = View.CurrentSelectedItems;
if (sCommunities.Where(i => !i.Selected).Any())
{
cCommunities = cCommunities.Where(c => !sCommunities.Where(s => s.Id == c.Id).Any() || sCommunities.Where(s => s.Selected && s.Id == c.Id).Any()).ToList();
}
if (sCommunities.Where(i => i.Selected).Any())
{
List <Int32> idCommunities = cCommunities.Select(c => c.Id).ToList();
cCommunities.AddRange(sCommunities.Where(s => s.Selected && !idCommunities.Contains(s.Id)).ToList());
}
List <dtoCommunityInfoForEnroll> items = Service.GetEnrollingItems(idPerson, cCommunities);
if (items != null && items.Where(i => i.Id > 0).Any())
{
if (!items.Where(i => i.AllowEnroll).Any())
{
dAction = ModuleDashboard.ActionType.EnrollNotAllowed;
if (items.Count == 1)
{
View.DisplayEnrollMessage(items.FirstOrDefault(), dAction);
}
else
{
View.DisplayEnrollMessage(items.Count, dAction);
}
}
else
{
reloadCommunities = true;
litePerson person = CurrentManager.GetLitePerson(idPerson);
String profileType = Service.GetTranslatedProfileType(person);
String organizationName = CurrentManager.GetUserDefaultOrganizationName(idPerson);
List <dtoEnrollment> enrollments = new List <dtoEnrollment>();
foreach (dtoCommunityInfoForEnroll cm in items.Where(i => i.AllowEnroll && !i.HasConstraints))
{
dtoEnrollment enrollment = Service.EnrollTo(idPerson, cm);
if (enrollment != null)
{
enrollments.Add(enrollment);
}
}
if (enrollments.Where(e => e.Status == EnrolledStatus.Available || e.Status == EnrolledStatus.NeedConfirm).Any())
{
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(lm.Comol.Core.BaseModules.CommunityManagement.Domain.CacheKeys.UserCommunitiesTree(idPerson));
enrollments.Where(e => e.Status == EnrolledStatus.Available || e.Status == EnrolledStatus.NeedConfirm).ToList().ForEach(e => View.NotifyEnrollment(e, person, profileType, organizationName));
}
if ((enrollments.Any() && enrollments.Where(s => s.Status == EnrolledStatus.NotAvailable || s.Status == EnrolledStatus.UnableToEnroll).Any()) ||
items.Where(i => i.HasConstraints || !i.AllowUnsubscribe).Any())
{
UpdateSelectedItems(enrollments.Where(e => e.Status == EnrolledStatus.Available || e.Status == EnrolledStatus.NeedConfirm || e.Status == EnrolledStatus.PreviousEnrolled || e.Status == EnrolledStatus.UnableToEnroll).Select(e => e.IdCommunity).ToList());
View.DisplayConfirmMessage(enrollments.Where(e => e.Status != EnrolledStatus.NotAvailable && e.Status != EnrolledStatus.UnableToEnroll).ToList(),
enrollments.Where(e => e.Status == EnrolledStatus.NotAvailable || e.Status == EnrolledStatus.UnableToEnroll).ToList(),
items.Where(i => !enrollments.Where(e => e.IdCommunity == i.Id).Any()).ToList(), person, profileType, organizationName);
View.SendUserAction(0, CurrentIdModule, items.Where(i => !enrollments.Where(e => e.IdCommunity == i.Id).Any()).Select(c => c.Id).ToList(), ModuleDashboard.ActionType.RequireEnrollConfirm);
}
else
{
if (enrollments.Where(e => e.Status == EnrolledStatus.Available).Any())
{
View.SendUserAction(0, CurrentIdModule, enrollments.Where(e => e.Status == EnrolledStatus.Available).Select(c => c.IdCommunity).ToList(), ModuleDashboard.ActionType.EnrollToCommunities);
}
if (enrollments.Where(e => e.Status == EnrolledStatus.NeedConfirm).Any())
{
View.SendUserAction(0, CurrentIdModule, enrollments.Where(e => e.Status == EnrolledStatus.NeedConfirm).Select(c => c.IdCommunity).ToList(), ModuleDashboard.ActionType.EnrollToCommunitiesWaitingConfirm);
}
UpdateSelectedItems(enrollments.Where(e => e.Status == EnrolledStatus.Available || e.Status == EnrolledStatus.NeedConfirm || e.Status == EnrolledStatus.PreviousEnrolled || e.Status == EnrolledStatus.UnableToEnroll).Select(e => e.IdCommunity).ToList());
if (enrollments.Any() && enrollments.Count == items.Count)
{
View.DisplayEnrollMessage(enrollments);
}
else
{
View.DisplayEnrollMessage(enrollments, items.Where(i => !enrollments.Where(e => e.IdCommunity == i.Id).Any()).Select(c => c.Name).ToList());
}
}
}
}
else
{
View.SendUserAction(0, CurrentIdModule, sCommunities.Select(c => c.Id).ToList(), ModuleDashboard.ActionType.UnableToEnroll);
}
if (reloadCommunities)
{
InternalLoadCommunities(itemsForPage, range, filters, orderBy, ascending, true, pageIndex, ModuleDashboard.ActionType.EnrollPageLoadcommunitiesAfterEnrolling);
}
}
}
public void EnrollTo(Int32 idCommunity, String name, String path, Int32 itemsForPage, RangeSettings range, lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters, OrderItemsToSubscribeBy orderBy, Boolean ascending, Int32 pageIndex)
{
Int32 idPerson = UserContext.CurrentUserID;
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout();
}
else
{
Boolean reloadCommunities = false;
ModuleDashboard.ActionType dAction = ModuleDashboard.ActionType.None;
dtoCommunityInfoForEnroll item = Service.GetEnrollingItem(idPerson, idCommunity, path);
litePerson person = CurrentManager.GetLitePerson(idPerson);
if (item != null && item.Id > 0 && person != null && person.Id > 0)
{
if (!item.AllowEnroll)
{
dAction = ModuleDashboard.ActionType.EnrollNotAllowed;
View.DisplayEnrollMessage(item, dAction);
}
else
{
if (!item.HasConstraints && item.AllowUnsubscribe)
{
dtoEnrollment enrollment = Service.EnrollTo(idPerson, item);
if (enrollment == null)
{
dAction = ModuleDashboard.ActionType.UnableToEnroll;
View.DisplayEnrollMessage(item, dAction);
}
else
{
View.DisplayEnrollMessage(enrollment, enrollment.IdCommunity, person, Service.GetTranslatedProfileType(person), CurrentManager.GetUserDefaultOrganizationName(idPerson));
UpdateSelectedItems(new List <Int32>()
{
enrollment.IdCommunity
});
reloadCommunities = true;
dAction = (enrollment.Status == EnrolledStatus.NeedConfirm) ? ModuleDashboard.ActionType.EnrollToCommunityWaitingConfirm : ModuleDashboard.ActionType.EnrollToCommunity;
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(lm.Comol.Core.BaseModules.CommunityManagement.Domain.CacheKeys.UserCommunitiesTree(idPerson));
}
}
else
{
dAction = ModuleDashboard.ActionType.RequireEnrollConfirm;
View.DisplayConfirmMessage(item);
}
}
}
else
{
dAction = ModuleDashboard.ActionType.UnableToEnroll;
View.DisplayUnknownCommunity(name);
}
View.SendUserAction(0, CurrentIdModule, idCommunity, dAction);
if (reloadCommunities)
{
InternalLoadCommunities(itemsForPage, range, filters, orderBy, ascending, true, pageIndex, ModuleDashboard.ActionType.EnrollPageLoadcommunitiesAfterEnrolling);
}
}
}
public void ApplyFilters(lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters, Boolean advancedMode, Int32 idReferenceCommunity)
{
View.CurrentFilters = filters;
LoadTree(filters, advancedMode, idReferenceCommunity, true);
}
private void InternalLoadCommunities(Int32 itemsForPage, RangeSettings range, lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters, OrderItemsToSubscribeBy orderBy, Boolean ascending, Boolean useCache, Int32 pageIndex, ModuleDashboard.ActionType action = ModuleDashboard.ActionType.EnrollPageApplyFilters, Boolean applyFilters = false)
{
View.CurrentFilters = filters;
List <dtoItemFilter <OrderItemsToSubscribeBy> > orderItems = GetOrderByItems(filters.IdcommunityType, orderBy);
View.InitializeOrderBySelector(orderItems);
List <dtoEnrollingItem> items = Service.GetCommunitiesToEnroll(UserContext.CurrentUserID, filters, useCache);
Int32 itemsCount = (items == null) ? 0 : items.Count;
Int32 pageSize = CalculatePageSize(itemsForPage, range, itemsCount);
View.CurrentPageSize = pageSize;
InitializeColumns(filters, items);
if (items == null)
{
View.DisplayErrorFromDB();
View.CurrentOrderBy = orderBy;
View.CurrentAscending = ascending;
}
else
{
if (pageSize == 0)
{
pageSize = View.DefaultPageSize;
}
PagerBase pager = new PagerBase();
pager.PageSize = pageSize;
pager.Count = (itemsCount > 0) ? itemsCount - 1 : 0;
pager.PageIndex = pageIndex;
View.Pager = pager;
List <dtoCommunityToEnroll> cItems = null;
if (applyFilters)
{
cItems = new List <dtoCommunityToEnroll>();
}
else
{
cItems = View.CurrentSelectedItems;
List <dtoCommunityToEnroll> sItems = View.GetSelectedItems();
if (sItems.Where(i => !i.Selected).Any())
{
cItems = cItems.Where(c => !sItems.Where(s => s.Id == c.Id).Any() || sItems.Where(s => s.Selected && s.Id == c.Id).Any()).ToList();
}
if (sItems.Where(i => i.Selected).Any())
{
List <Int32> idCommunities = cItems.Select(c => c.Id).ToList();
cItems.AddRange(sItems.Where(s => s.Selected && !idCommunities.Contains(s.Id)).ToList());
}
}
View.CurrentSelectedItems = cItems;
View.KeepOpenBulkActions = (cItems.Count > 0);
View.InitializeBulkActions(itemsCount > pageSize, cItems);
items = Service.GetCommunities(UserContext.CurrentUserID, items, pageIndex, pageSize, orderBy, ascending);
if (items != null)
{
Language l = CurrentManager.GetDefaultLanguage();
Dictionary <Int32, List <String> > tags = ServiceTags.GetCommunityAssociationToString(items.Select(i => i.Community.Id).ToList(), UserContext.Language.Id, l.Id, true);
if (tags.Any())
{
foreach (dtoEnrollingItem item in items.Where(i => tags.ContainsKey(i.Community.Id)))
{
item.Community.Tags = tags[item.Community.Id];
}
}
View.LoadItems(items, orderBy, ascending);
//View.SendUserAction(0, CurrentIdModule, action);
}
else
{
View.LoadItems(new List <dtoEnrollingItem>(), orderBy, ascending);
}
}
}
public void InitView(Boolean advancedMode, lm.Comol.Core.BaseModules.CommunityManagement.CommunityAvailability availability = CommunityManagement.CommunityAvailability.Subscribed, Int32 idReferenceCommunity = 0, String referencePath = "")
{
View.AdvancedMode = advancedMode;
View.ReferenceIdCommunity = idReferenceCommunity;
View.IsFirstLoad = true;
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout();
}
else
{
ModuleDashboard.ActionType action = (idReferenceCommunity > 0) ? ModuleDashboard.ActionType.TreeNoChildrenToLoad : ModuleDashboard.ActionType.TreeUnableToLoad;
List <lm.Comol.Core.DomainModel.Filters.Filter> fToLoad = null;
switch (availability)
{
case CommunityManagement.CommunityAvailability.Subscribed:
fToLoad = Service.GetDefaultFilters(UserContext.CurrentUserID, "", -1, -1, null, null, availability).OrderBy(f => f.DisplayOrder).ToList();
View.LoadDefaultFilters(fToLoad);
break;
}
if (fToLoad != null && fToLoad.Any())
{
lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters = new lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters(fToLoad, availability);
View.CurrentFilters = filters;
action = (idReferenceCommunity > 0) ? ModuleDashboard.ActionType.TreeLoadChildren : ModuleDashboard.ActionType.TreeLoad;
LoadTree(filters, advancedMode, idReferenceCommunity, false);
}
else
{
View.DisplayNoTreeToLoad((idReferenceCommunity > 0) ? CurrentManager.GetCommunityName(idReferenceCommunity) : "");
}
View.SendUserAction(idReferenceCommunity, CurrentIdModule, action);
}
}
public dtoTreeCommunityNode Filter(dtoCommunitiesFilters filter, Int32 IdDefaultOrganization, List <Int32> onlyFromOrganizations = null)
{
//return FullClone(this, null).InternalFilter(filter, IdDefaultOrganization, onlyFromOrganizations);
return(InternalFilter(filter, IdDefaultOrganization, onlyFromOrganizations));
}
public void EnrollTo(List <dtoCommunityInfoForEnroll> sCommunities, Int32 itemsForPage, RangeSettings range, lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters, OrderItemsToSubscribeBy orderBy, Boolean ascending, Int32 pageIndex)
{
Int32 idPerson = UserContext.CurrentUserID;
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout();
}
else
{
Boolean reloadCommunities = false;
if (sCommunities.Any())
{
reloadCommunities = true;
litePerson person = CurrentManager.GetLitePerson(idPerson);
String profileType = Service.GetTranslatedProfileType(person);
String organizationName = CurrentManager.GetUserDefaultOrganizationName(idPerson);
List <dtoEnrollment> enrollments = new List <dtoEnrollment>();
foreach (dtoCommunityInfoForEnroll cm in sCommunities)
{
dtoEnrollment enrollment = Service.EnrollTo(idPerson, cm);
if (enrollment != null)
{
enrollments.Add(enrollment);
}
}
if (enrollments.Any())
{
if (enrollments.Where(e => e.Status == EnrolledStatus.Available || e.Status == EnrolledStatus.NeedConfirm).Any())
{
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(lm.Comol.Core.BaseModules.CommunityManagement.Domain.CacheKeys.UserCommunitiesTree(idPerson));
enrollments.Where(e => e.Status == EnrolledStatus.Available || e.Status == EnrolledStatus.NeedConfirm).ToList().ForEach(e => View.NotifyEnrollment(e, person, profileType, organizationName));
reloadCommunities = true;
}
if (enrollments.Where(e => e.Status == EnrolledStatus.Available).Any())
{
View.SendUserAction(0, CurrentIdModule, enrollments.Where(e => e.Status == EnrolledStatus.Available).Select(c => c.IdCommunity).ToList(), ModuleDashboard.ActionType.EnrollToCommunities);
}
if (enrollments.Where(e => e.Status == EnrolledStatus.NeedConfirm).Any())
{
View.SendUserAction(0, CurrentIdModule, enrollments.Where(e => e.Status == EnrolledStatus.NeedConfirm).Select(c => c.IdCommunity).ToList(), ModuleDashboard.ActionType.EnrollToCommunitiesWaitingConfirm);
}
UpdateSelectedItems(enrollments.Where(e => e.Status == EnrolledStatus.Available || e.Status == EnrolledStatus.NeedConfirm || e.Status == EnrolledStatus.PreviousEnrolled || e.Status == EnrolledStatus.UnableToEnroll).Select(e => e.IdCommunity).ToList());
View.DisplayEnrollMessage(enrollments);
}
if (reloadCommunities)
{
InternalLoadCommunities(itemsForPage, range, filters, orderBy, ascending, true, pageIndex, ModuleDashboard.ActionType.EnrollPageLoadcommunitiesAfterEnrolling, true);
}
}
else
{
View.SendUserAction(0, CurrentIdModule, ModuleDashboard.ActionType.NoSelectedCommunitiesToEnroll);
}
}
}
public void UnsubscribeFromCommunity(Int32 idCommunity, String path, RemoveAction action, lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters)
{
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout();
}
else
{
lm.Comol.Core.BaseModules.CommunityManagement.dtoUnsubscribeTreeNode node = Service.UnsubscribeInfo(UserContext.CurrentUserID, idCommunity, path);
if (node != null)
{
switch (action)
{
case RemoveAction.None:
break;
default:
ModuleDashboard.ActionType dAction = ModuleDashboard.ActionType.UnableToUnsubscribe;
List <liteSubscriptionInfo> subscriptions = Service.UnsubscribeFromCommunity(UserContext.CurrentUserID, node, action);
if (subscriptions == null && !subscriptions.Any())
{
switch (action)
{
case RemoveAction.FromCommunity:
dAction = ModuleDashboard.ActionType.UnableToUnsubscribeFromCommunity;
View.DisplayUnableToUnsubscribe(node.Name);
break;
case RemoveAction.FromAllSubCommunities:
dAction = ModuleDashboard.ActionType.UnableToUnsubscribeFromCommunities;
View.DisplayUnsubscriptionMessage(new List <String>(), node.GetAllNodes().Where(n => n.AllowUnsubscribe()).Select(n => n.Name).ToList());
break;
}
}
else
{
switch (action)
{
case RemoveAction.FromCommunity:
dAction = ModuleDashboard.ActionType.UnsubscribeFromCommunity;
View.DisplayUnsubscribedFrom(node.Name);
break;
case RemoveAction.FromAllSubCommunities:
dAction = ModuleDashboard.ActionType.UnsubscribeFromCommunities;
View.DisplayUnsubscriptionMessage(node.GetAllNodes().Where(n => n.AllowUnsubscribe() && subscriptions.Where(s => s.IdCommunity == n.Id && s.IdRole < 1).Any()).Select(n => n.Name).ToList(),
node.GetAllNodes().Where(n => n.AllowUnsubscribe() && subscriptions.Where(s => s.IdCommunity == n.Id && s.IdRole > 0).Any()).Select(n => n.Name).ToList()
);
break;
}
}
View.SendUserAction(0, CurrentIdModule, idCommunity, dAction);
switch (dAction)
{
case ModuleDashboard.ActionType.UnsubscribeFromCommunity:
case ModuleDashboard.ActionType.UnsubscribeFromCommunities:
LoadTree(filters, View.AdvancedMode, View.ReferenceIdCommunity, false);
break;
}
break;
}
}
else
{
String name = CurrentManager.GetCommunityName(idCommunity);
if (!String.IsNullOrEmpty(name))
{
View.DisplayUnableToUnsubscribe(name);
}
View.SendUserAction(0, CurrentIdModule, idCommunity, ModuleDashboard.ActionType.UnableToUnsubscribe);
}
}
}
public void UnsubscribeFromCommunity(Int32 idCommunity, String path, lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters)
{
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout();
}
else
{
lm.Comol.Core.BaseModules.CommunityManagement.dtoUnsubscribeTreeNode node = Service.UnsubscribeInfo(UserContext.CurrentUserID, idCommunity, path);
if (node != null)
{
ModuleDashboard.ActionType dAction = ModuleDashboard.ActionType.None;
List <lm.Comol.Core.BaseModules.CommunityManagement.dtoUnsubscribeTreeNode> nodes = node.GetAllNodes();
if (!nodes.Where(n => n.AllowUnsubscribe()).Any())
{
View.DisplayUnableToUnsubscribe(CurrentManager.GetCommunityName(idCommunity));
dAction = ModuleDashboard.ActionType.UnableToUnsubscribeFromCommunity;
}
else
{
List <RemoveAction> actions = new List <RemoveAction>();
actions.Add(RemoveAction.None);
actions.Add(RemoveAction.FromCommunity);
if (nodes.Where(n => n.AllowUnsubscribe()).Count() > 1)
{
actions.Add(RemoveAction.FromAllSubCommunities);
}
if (node == null)
{
View.DisplayUnableToUnsubscribe(CurrentManager.GetCommunityName(idCommunity));
dAction = ModuleDashboard.ActionType.UnableToUnsubscribeFromCommunity;
}
else if (!node.AllowUnsubscribe())
{
View.DisplayUnsubscribeNotAllowed(node.Name);
dAction = ModuleDashboard.ActionType.UnsubscribeNotallowed;
}
else if (node.AllowUnsubscribe() && (!node.CommunityAllowSubscription || node.MaxUsersWithDefaultRole > 0 || (node.CommunitySubscriptionEndOn.HasValue && DateTime.Now.AddDays(30) > node.CommunitySubscriptionEndOn.Value)))
{
View.DisplayConfirmMessage(idCommunity, path, node, actions, RemoveAction.None, nodes.Where(n => n.AllowUnsubscribe() && n.Id != idCommunity).ToList());
dAction = ModuleDashboard.ActionType.RequireUnsubscribeConfirm;
}
else
{
if (nodes.Where(n => n.AllowUnsubscribe()).Count() > 1)
{
View.DisplayConfirmMessage(idCommunity, path, node, actions, RemoveAction.FromCommunity, nodes.Where(n => n.AllowUnsubscribe() && n.Id != idCommunity).ToList());
dAction = ModuleDashboard.ActionType.RequireUnsubscribeConfirmFromSubCommunities;
}
else
{
List <liteSubscriptionInfo> subscriptions = Service.UnsubscribeFromCommunity(UserContext.CurrentUserID, node, RemoveAction.FromCommunity);
if (subscriptions != null && subscriptions.Any() && subscriptions.Count == 1 && subscriptions[0].IdRole < 1)
{
View.DisplayUnsubscribedFrom(node.Name);
dAction = ModuleDashboard.ActionType.UnsubscribeFromCommunity;
}
else
{
View.DisplayUnableToUnsubscribe(node.Name);
dAction = ModuleDashboard.ActionType.UnableToUnsubscribeFromCommunity;
}
}
}
}
View.SendUserAction(0, CurrentIdModule, idCommunity, dAction);
if (dAction == ModuleDashboard.ActionType.UnsubscribeFromCommunity)
{
LoadTree(filters, View.AdvancedMode, View.ReferenceIdCommunity, false);
}
}
else
{
String name = CurrentManager.GetCommunityName(idCommunity);
if (!String.IsNullOrEmpty(name))
{
View.DisplayUnableToUnsubscribe(CurrentManager.GetCommunityName(idCommunity));
}
View.SendUserAction(0, CurrentIdModule, idCommunity, ModuleDashboard.ActionType.UnableToUnsubscribe);
}
}
}
private void InitializeView(Int32 itemsForPage, RangeSettings range, Int32 preloadIdCommunityType, String searchText, Boolean preloadList)
{
View.DefaultPageSize = itemsForPage;
View.DefaultRange = range;
View.IsInitialized = true;
View.FirstLoad = true;
litePerson person = CurrentManager.GetLitePerson(UserContext.CurrentUserID);
if (person != null)
{
List <lm.Comol.Core.DomainModel.Filters.Filter> fToLoad = Service.GetDefaultFilters(UserContext.CurrentUserID, searchText, preloadIdCommunityType, -1, null, null, CommunityAvailability.NotSubscribed).OrderBy(f => f.DisplayOrder).ToList();
View.LoadDefaultFilters(fToLoad);
if (fToLoad != null && fToLoad.Any())
{
//lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters = Service.GetDefaultFilters(person, CommunityManagement.CommunityAvailability.NotSubscribed, false, preloadIdCommunityType);
lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters filters = new lm.Comol.Core.BaseModules.CommunityManagement.dtoCommunitiesFilters(fToLoad, CommunityAvailability.NotSubscribed, preloadIdCommunityType);
if (preloadIdCommunityType > -1)
{
filters.IdcommunityType = preloadIdCommunityType;
}
View.CurrentFilters = filters;
if (preloadList)
{
InternalLoadCommunities(itemsForPage, range, filters, OrderItemsToSubscribeBy.Name, true, false, 0, ModuleDashboard.ActionType.EnrollPageLoadWithCommunities);
}
else
{
View.CurrentOrderBy = OrderItemsToSubscribeBy.Name;
View.CurrentAscending = true;
InitializeColumns(filters, new List <dtoEnrollingItem>());
View.LoadItems(new List <dtoEnrollingItem>(), OrderItemsToSubscribeBy.Name, true);
}
View.SendUserAction(0, CurrentIdModule, ModuleDashboard.ActionType.EnrollPageLoad);
}
SetListTitle(preloadIdCommunityType, (fToLoad != null && fToLoad.Any()));
}
else
{
View.DisplaySessionTimeout();
}
}
public Boolean HasNodes(dtoCommunitiesFilters filter)
{
Boolean result = false;
var query = (from n in this.Nodes select n);
if (filter.IdOrganization > 0)
{
query = query.Where(n => n.IdOrganization == filter.IdOrganization);
}
else if (filter.OnlyFromAvailableOrganizations)
{
query = query.Where(n => filter.AvailableIdOrganizations.Contains(n.IdOrganization));
}
if (filter.IdcommunityType > -1)
{
query = query.Where(n => n.IdCommunityType == filter.IdcommunityType);
}
else if (filter.IdRemoveCommunityType > -1)
{
query = query.Where(n => n.IdCommunityType != filter.IdRemoveCommunityType);
}
if (filter.Status != CommunityStatus.None)
{
query = query.Where(n => n.Status == filter.Status);
}
if (filter.IdResponsible != -1)
{
query = query.Where(n => n.IdResponsible == filter.IdResponsible);
}
if (filter.Availability != CommunityAvailability.All)
{
query = query.Where(n => (filter.Availability == CommunityAvailability.Subscribed && n.Selected) || (filter.Availability == CommunityAvailability.NotSubscribed && !n.Selected));
}
if (filter.IdCourseTime > 0)
{
query = query.Where(n => n.IdCourseTime == filter.IdCourseTime);
}
if (filter.IdDegreeType > 0)
{
query = query.Where(n => n.IdCourseTime == filter.IdDegreeType);
}
if (!String.IsNullOrEmpty(filter.CourseCode))
{
query = query.Where(n => !String.IsNullOrEmpty(n.CourseCode) && n.CourseCode.ToLower().Contains(filter.CourseCode.Trim().ToLower()));
}
if (filter.Year > 0)
{
query = query.Where(n => n.Year == filter.Year);
}
if (filter.IdTags.Any() && IsTagsSet)
{
query = query.Where(n => n.IdTags.Where(t => filter.IdTags.Contains(t)).Any());
}
if (filter.SearchBy != SearchCommunitiesBy.All)
{
switch (filter.SearchBy)
{
case SearchCommunitiesBy.Contains:
if (!String.IsNullOrEmpty(filter.Value))
{
query = query.Where(n => !String.IsNullOrEmpty(n.Name) && n.Name.ToLower().Contains(filter.Value.ToLower()));
}
break;
case SearchCommunitiesBy.NameStartAs:
if (!String.IsNullOrEmpty(filter.Value))
{
query = query.Where(n => !String.IsNullOrEmpty(n.Name) && n.Name.ToLower().StartsWith(filter.Value.ToLower()));
}
break;
case SearchCommunitiesBy.StartAs:
if (filter.StartWith != "#")
{
query = query.Where(n => string.Compare(n.FirstLetter, filter.StartWith.ToLower(), true) == 0);
}
else
{
query = query.Where(n => DefaultOtherChars().Contains(n.FirstLetter));
}
break;
}
}
Boolean hasSubNodes = query.Any();
if (filter.IdOrganization > 0)
{
result = (this.IdOrganization == filter.IdOrganization || hasSubNodes);
}
else if (filter.OnlyFromAvailableOrganizations && filter.AvailableIdOrganizations.Any())
{
result = (filter.AvailableIdOrganizations.Contains(this.IdOrganization) || hasSubNodes);
}
else
{
result = true;
}
// TO CHECK !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if (filter.IdcommunityType >= 0)
{
result = result && (((!filter.OnlyFromAvailableOrganizations && filter.IdOrganization < 1) || result) &&
((this.IdCommunityType == filter.IdcommunityType) || hasSubNodes));
}
else if (filter.IdRemoveCommunityType > -1)
{
result = result && (((!filter.OnlyFromAvailableOrganizations && filter.IdOrganization < 1) || result) &&
(this.IdCommunityType != filter.IdRemoveCommunityType || hasSubNodes));
}
/* result = (((filter.OnlyFromAvailableOrganizations ) || (!filter.OnlyFromAvailableOrganizations && filter.IdOrganization < 1)) || result)
* && (this.IdCommunityType == filter.IdcommunityType || hasSubNodes);*/
if (filter.IdTags.Any() && IsTagsSet)
{
result = (result && (IdTags.Where(t => filter.IdTags.Contains(t)).Any() || hasSubNodes));
}
if (filter.Status != CommunityStatus.None)
{
result = result && (((filter.IdcommunityType < 1 && filter.IdcommunityType < 0) || result) &&
(this.Status == filter.Status || hasSubNodes));
}
if (filter.Availability != CommunityAvailability.All)
{
result = result && (((filter.IdcommunityType < 1 && filter.IdcommunityType < 0 && filter.Status == CommunityStatus.None) || result) &&
(
((filter.Availability == CommunityAvailability.Subscribed && this.Selected) ||
(filter.Availability == CommunityAvailability.NotSubscribed && !this.Selected)) || hasSubNodes
));
}
if (filter.SearchBy != SearchCommunitiesBy.All && !String.IsNullOrEmpty(this.Name))
{
switch (filter.SearchBy)
{
case SearchCommunitiesBy.Contains:
if (!String.IsNullOrEmpty(filter.Value))
{
result = (result && Name.ToLower().Contains(filter.Value.ToLower()) || hasSubNodes);
}
break;
case SearchCommunitiesBy.NameStartAs:
if (!String.IsNullOrEmpty(filter.Value))
{
result = (result && Name.ToLower().StartsWith(filter.Value.ToLower()) || hasSubNodes);
}
break;
case SearchCommunitiesBy.StartAs:
if (filter.StartWith != "#")
{
result = ((result && string.Compare(FirstLetter, filter.StartWith.ToLower(), true) == 0) || hasSubNodes);
}
else
{
result = ((result && DefaultOtherChars().Contains(FirstLetter)) || hasSubNodes);
}
break;
}
}
if (filter.IdResponsible != -1)
{
result = ((result && filter.IdResponsible == IdResponsible) || hasSubNodes);
}
if (result)
{
return(result);
}
else if (Nodes.Count > 0)
{
foreach (dtoTreeCommunityNode n in this.Nodes)
{
result = n.HasNodes(filter);
if (result == true)
{
break;
}
}
}
return(result);
}
