public void UpdateFileLink(List <ModuleActionLink> selectedFilesID, List <long> linksId)
{
Task item = Service.GetTask(View.CurrentItemID);
if (item != null)
{
int IdCommunity = (item.Community == null ? 0 : item.Community.Id);
CoreModuleRepository moduleRepository = Service.GetCoreModuleRepository(UserContext.CurrentUserID, IdCommunity);
CoreItemPermission permission = GetTaskPermission(IdCommunity, item, moduleRepository);
//CHIEDERE NICOLA
List <long> assignedItemFileLinksId = Service.GetCoreTaskFileLinksId(item, permission.AllowEdit && permission.AllowAddFiles);
List <long> IdToRemove = (from ai in assignedItemFileLinksId where !linksId.Contains(ai) select ai).ToList();
if (IdToRemove != null && IdToRemove.Count > 0)
{
Service.UnLinkToCommunityFileFromTask(IdToRemove);
}
if (selectedFilesID != null && selectedFilesID.Count > 0)
{
Service.SaveTaskListFiles(item, IdCommunity, selectedFilesID, ModuleID, (int)ModuleTasklist.ObjectType.TaskLinkedFile, ModuleTasklist.UniqueID, false);
}
View.ReturnToFileManagement(IdCommunity, item.ID);
}
else
{
View.ReturnToProject(View.CurrentItemCommunityID, 0);
}
}
private Boolean AllowViewFileFromLink(ModuleCommunityDiary modulePermission, CoreItemPermission itemPermission, EventItemFile attachment, litePerson person)
{
Boolean iResponse = false;
iResponse = itemPermission.AllowViewFiles && (attachment.isVisible || attachment.IdItemOwner == person.Id || modulePermission.Administration);
return(iResponse);
}
private Boolean AllowViewFileFromLink(ModuleTasklist modulePermission, CoreItemPermission itemPermission, TaskListFile taskFile, Person person)
{
Boolean iResponse = false;
iResponse = itemPermission.AllowViewFiles && (taskFile.isVisible || taskFile.Owner == person || taskFile.TaskOwner.MetaInfo.CreatedBy == person || modulePermission.Administration);
return(iResponse);
}
public CoreItemPermission GetItemPermissionFromLink(long IdLink)
{
CoreItemPermission permission = new CoreItemPermission();
ModuleLink link = Manager.Get <ModuleLink>(IdLink);
if (link == null)
{
return(permission);
}
else
{
TaskListFile taskFileLink = (from ifl in Manager.GetAll <TaskListFile>(ifl => ifl.Link == link && ifl.Deleted == BaseStatusDeleted.None) select ifl).Skip(0).Take(1).ToList().FirstOrDefault();
if (taskFileLink == null || taskFileLink.TaskOwner == null)
{
return(permission);
}
else
{
int IdCommunity = taskFileLink.TaskOwner.Community == null ? 0 : taskFileLink.TaskOwner.Community.Id;
ModuleTasklist moduleDiary = ServicePermission(UC.CurrentUserID, IdCommunity);
CoreModuleRepository repository = GetCoreModuleRepository(UC.CurrentUserID, IdCommunity);
permission = GetTaskPermission(taskFileLink.TaskOwner, moduleDiary, repository);
return(permission);
}
}
}
public void LoadTaskFiles(Task task, CoreItemPermission moduleTask)
{
// = View.RepositoryPermission(CommunityId);
// CoreItemPermission oPermission
IList <iCoreItemFileLink <long> > files = Service.GetTaskFiles(task, moduleTask.AllowEdit);
View.LoadFilesToManage(task.ID, moduleTask, files, lm.Comol.Modules.TaskList.Domain.RootObject.PublishUrl());
}
public dtoDiaryItem(CoreItemPermission module, CommunityEventItem item, List <RepositoryAttachmentUploadActions> actions, RepositoryAttachmentUploadActions dAction)
{
Id = item.Id;
EventItem = item;
CommunityId = item.IdCommunityOwner;
IdEvent = (item.EventOwner != null ? item.EventOwner.Id : 0);
Permission = module;
UploadActions = actions;
DefaultUploadAction = dAction;
Attachments = new List <dtoAttachmentItem>();
}
private Boolean AllowViewDiaryItem(long idItem, Int32 idUser)
{
Boolean iResponse = false;
CommunityEventItem item = EventItemGet(idItem);
litePerson person = Manager.GetLitePerson(idUser);
if (item != null)
{
ModuleCommunityDiary modulePermission = GetPermissions(idUser, item.IdCommunityOwner);
lm.Comol.Core.FileRepository.Domain.ModuleRepository moduleRepository = GetCoreModuleRepository(idUser, item.IdCommunityOwner);
CoreItemPermission itemPermission = GetItemPermission(person, item, modulePermission, moduleRepository);
iResponse = (itemPermission.AllowView);
}
return(iResponse);
}
public CoreItemPermission GetTaskPermission(Person person, Task oItem, ModuleTasklist Permission, CoreModuleRepository repository)
{
CoreItemPermission iResponse = new CoreItemPermission();
iResponse.AllowView = Permission.Administration || Permission.ViewTaskList;
iResponse.AllowViewFiles = (Permission.ViewTaskList && (oItem.MetaInfo.CreatedBy == person)) || Permission.Administration;
//iResponse. = Permission.Administration;
iResponse.AllowAddFiles = (oItem.MetaInfo.CreatedBy == person) || Permission.Administration || Permission.UploadFile;
iResponse.AllowDelete = (oItem.MetaInfo.CreatedBy == person) || Permission.Administration;
iResponse.AllowEdit = (oItem.MetaInfo.CreatedBy == person) || Permission.Administration;
iResponse.AllowVirtualDelete = iResponse.AllowDelete;
iResponse.AllowUnDelete = (oItem.MetaInfo.CreatedBy == person) || Permission.Administration;
iResponse.AllowViewStatistics = iResponse.AllowViewFiles;
iResponse.AllowFilePublish = (repository != null && (repository.Administration || repository.UploadFile));
return(iResponse);
}
private Boolean AllowViewTask(long itemId, int UserID, int communityID, int RoleID)
{
Boolean iResponse = false;
Task item = GetTask(itemId);
Person person = Manager.GetPerson(UserID);
if (item != null)
{
communityID = item.Community == null ? 0 : item.Community.Id;
lm.Comol.Modules.TaskList.ModuleTasklist modulePermission = ServicePermission(UserID, communityID);
CoreModuleRepository moduleRepository = GetCoreModuleRepository(UserID, communityID);
CoreItemPermission itemPermission = GetTaskPermission(person, item, modulePermission, moduleRepository);
iResponse = (itemPermission.AllowView);
}
return(iResponse);
}
public dtoTask(int idCommunity, CoreItemPermission module, Task task, string description)
{
Id = task.ID;
CommunityId = idCommunity;
oTask = task;
Permission = module;
//LessonNumber = lessonNumber;
if (description == null)
{
description = "";
}
else if (string.IsNullOrEmpty(description))
{
description = "";
}
Description = description;
}
public dtoDiaryItem(int idCommunity, CoreItemPermission module, CommunityEventItem item, Int32 lessonNumber, String description, List <RepositoryAttachmentUploadActions> actions, RepositoryAttachmentUploadActions dAction)
{
Id = item.Id;
CommunityId = idCommunity;
IdEvent = (item.EventOwner != null ? item.EventOwner.Id : 0);
EventItem = item;
Permission = module;
LessonNumber = lessonNumber;
if (String.IsNullOrWhiteSpace(description))
{
description = "";
}
Description = description;
UploadActions = actions;
DefaultUploadAction = dAction;
Attachments = new List <dtoAttachmentItem>();
}
public void InitView()
{
int IdCommunity = UserContext.CurrentCommunityID;
View.CurrentItemCommunityID = IdCommunity;
View.CurrentItemID = 0;
View.AllowCommunityLink = false;
if (UserContext.isAnonymous)
{
View.NoPermissionToManagementFiles(IdCommunity, ModuleID);
}
else
{
Task item = Service.GetTask(View.PreloadedItemID);
if (item == null)
{
View.SetBackToProject(IdCommunity, 0);
View.NoPermissionToManagementFiles(IdCommunity, ModuleID);
}
else
{
IdCommunity = (item.Community == null ? 0 : item.Community.Id);
View.CurrentItemCommunityID = IdCommunity;
View.CurrentItemID = item.ID;
CoreModuleRepository moduleRepository = Service.GetCoreModuleRepository(UserContext.CurrentUserID, IdCommunity);
CoreItemPermission permission = GetTaskPermission(IdCommunity, item, moduleRepository);
if (permission.AllowAddFiles)
{
View.AllowCommunityLink = (moduleRepository.Administration || moduleRepository.UploadFile || moduleRepository.ListFiles || moduleRepository.DownLoad);
//List<long> IdFiles = Service.GetItemRepositoryFilesId(item,false);
View.InitializeFileSelector(IdCommunity, Service.GetTaskRepositoryFiles(item, permission.AllowEdit && permission.AllowAddFiles), (moduleRepository.Administration), (moduleRepository.Administration));
View.SetBackToManagementUrl(IdCommunity, item.ID);
}
else if (permission.AllowEdit)
{
View.ReturnToTask(IdCommunity, item.ID);
}
else
{
View.SetBackToProject(IdCommunity, 0);
View.NoPermissionToManagementFiles(IdCommunity, ModuleID);
}
}
}
}
public void InitView()
{
int IdCommunity = UserContext.CurrentCommunityID;
long preloadedItemId = View.PreloadedItemID;
View.CurrentItemCommunityID = IdCommunity;
if (!this.UserContext.isAnonymous)
{
Task item = Service.GetTask(preloadedItemId);
if (item == null)
{
View.NoPermissionToAddFiles(IdCommunity, ModuleID);
}
else
{
IdCommunity = (item.Community == null ? 0 : item.Community.Id);
CoreModuleRepository moduleRepository = View.RepositoryPermission(IdCommunity);
CoreItemPermission permission = GetItemPermission(IdCommunity, item);
if (permission.AllowAddFiles)
{
View.AllowCommunityUpload = moduleRepository.Administration || moduleRepository.UploadFile;
if (moduleRepository.Administration || moduleRepository.UploadFile)
{
View.InitializeCommunityUploader(IdCommunity, moduleRepository);
}
View.InitializeModuleUploader(IdCommunity);
View.SetUrlToFileManagement(IdCommunity, item.ID);
View.SetUrlToDiary(IdCommunity, item.ID);
View.AllowUpload = true;
View.SendInitAction(IdCommunity, ModuleID, item.ID);
View.CurrentItemID = item.ID;
View.CurrentItemCommunityID = IdCommunity;
}
else
{
View.ReturnToFileManagement(IdCommunity, preloadedItemId);
}
}
}
else
{
View.NoPermissionToAddFiles(IdCommunity, ModuleID);
}
}
public CoreItemPermission GetItemPermissionFromLink(long idLink)
{
CoreItemPermission permission = new CoreItemPermission();
liteModuleLink link = Manager.Get <liteModuleLink>(idLink);
if (link != null)
{
EventItemFile itemFileLink = (from f in Manager.GetIQ <EventItemFile>() where f.Link != null && f.Link.Id == idLink && f.Deleted == BaseStatusDeleted.None select f).Skip(0).Take(1).ToList().FirstOrDefault();
if (itemFileLink != null)
{
CommunityEventItem item = EventItemGet(itemFileLink.IdItemOwner);
if (item != null)
{
permission = GetItemPermission(item, ServicePermission(UC.CurrentUserID, itemFileLink.IdCommunity), GetCoreModuleRepository(UC.CurrentUserID, itemFileLink.IdCommunity));
}
}
}
return(permission);
}
private Boolean AllowDownloadFileLinkedToItem(long idAttachment, Int32 idUser)
{
Boolean iResponse = false;
EventItemFile attachment = Manager.Get <EventItemFile>(idAttachment);
litePerson person = Manager.GetLitePerson(idUser);
if (attachment != null && attachment.Item != null && attachment.Link != null)
{
CommunityEventItem item = EventItemGet(attachment.IdItemOwner);
if (item != null)
{
ModuleCommunityDiary modulePermission = GetPermissions(idUser, attachment.IdCommunity);
lm.Comol.Core.FileRepository.Domain.ModuleRepository moduleRepository = GetCoreModuleRepository(idUser, attachment.IdCommunity);
CoreItemPermission itemPermission = GetItemPermission(person, EventItemGet(attachment.IdItemOwner), modulePermission, moduleRepository);
iResponse = AllowViewFileFromLink(modulePermission, itemPermission, attachment, person) && (attachment.Item.IsDownloadable || (attachment.Item.IdOwner == idUser && attachment.Item.Availability != Core.FileRepository.Domain.ItemAvailability.notavailable));
}
}
return(iResponse);
}
private Boolean AllowEditMetadata(Int32 idUser, Int32 idRole, ModuleObject source, ModuleObject destination)
{
Boolean iResponse = false;
if (source.ObjectTypeID == (int)ModuleCommunityDiary.ObjectType.DiaryItemLinkedFile)
{
litePerson person = Manager.GetLitePerson(idUser);
EventItemFile attachment = Manager.Get <EventItemFile>(source.ObjectLongID);
if (attachment != null && attachment.Link != null && attachment.Item != null && source.ObjectLongID == attachment.Id)
{
ModuleCommunityDiary modulePermission = GetPermissions(idUser, attachment.IdCommunity);
lm.Comol.Core.FileRepository.Domain.ModuleRepository moduleRepository = GetCoreModuleRepository(idUser, attachment.IdCommunity);
CoreItemPermission itemPermission = GetItemPermission(person, EventItemGet(attachment.IdItemOwner), modulePermission, moduleRepository);
iResponse = ((attachment.Item.Type == Core.FileRepository.Domain.ItemType.ScormPackage || attachment.Item.Type == Core.FileRepository.Domain.ItemType.Multimedia) && (attachment.Item.Availability == Core.FileRepository.Domain.ItemAvailability.available || attachment.Item.Availability == Core.FileRepository.Domain.ItemAvailability.waitingsettings) && ((attachment.Item.IsInternal && itemPermission.AllowEdit) ||
(!attachment.Item.IsInternal && (moduleRepository.Administration || moduleRepository.EditOthersFiles || (moduleRepository.EditMyFiles && attachment.Item.IdOwner == person.Id)))));
}
}
return(iResponse);
}
private Boolean AllowEditMetadata(int UserID, int RoleID, ModuleObject source, ModuleObject destination)
{
Boolean iResponse = false;
if (source.ObjectTypeID == (int)ModuleTasklist.ObjectType.TaskLinkedFile)
{
Person person = Manager.GetPerson(UserID);
TaskListFile taskFile = Manager.Get <TaskListFile>(source.ObjectLongID);
if (taskFile != null && taskFile.Link != null && destination.ObjectLongID == taskFile.File.Id && destination.FQN == taskFile.File.GetType().FullName)
{
int IdCommunity = taskFile.CommunityOwner == null ? 0 : taskFile.CommunityOwner.Id;
ModuleTasklist modulePermission = ServicePermission(UserID, IdCommunity);
CoreModuleRepository moduleRepository = GetCoreModuleRepository(UserID, IdCommunity);
CoreItemPermission itemPermission = GetTaskPermission(person, taskFile.TaskOwner, modulePermission, moduleRepository);
iResponse = (taskFile.File.IsInternal && itemPermission.AllowEdit) ||
(!taskFile.File.IsInternal && (moduleRepository.Administration || (moduleRepository.Edit && taskFile.File.Owner == person)));
}
}
return(iResponse);
}
public CoreItemPermission GetItemPermission(litePerson person, CommunityEventItem item, ModuleCommunityDiary modulePermissions, lm.Comol.Core.FileRepository.Domain.ModuleRepository moduleRepository)
{
CoreItemPermission iResponse = new CoreItemPermission();
if (item != null)
{
Boolean AllowInternalEdit = item.AllowEdit;
iResponse.AllowViewFiles = (modulePermissions.ViewDiaryItems && (item.IsVisible || (item.IsVisible == false && item.Owner != null && item.Owner == person))) || modulePermissions.Administration;
iResponse.AllowAddFiles = AllowInternalEdit && ((item.Owner != null && item.Owner == person) || modulePermissions.Administration || modulePermissions.UploadFile);
iResponse.AllowDelete = AllowInternalEdit && ((modulePermissions.DeleteItem && item.Owner != null && item.Owner == person) || modulePermissions.Administration);
iResponse.AllowEdit = AllowInternalEdit && ((modulePermissions.DeleteItem && item.Owner != null && item.Owner == person) || modulePermissions.Administration);
iResponse.AllowUnDelete = AllowInternalEdit && ((modulePermissions.DeleteItem && item.Owner != null && item.Owner == person) || modulePermissions.Administration);
}
iResponse.AllowView = modulePermissions.Administration || modulePermissions.ViewDiaryItems;
iResponse.AllowVirtualDelete = iResponse.AllowDelete;
iResponse.AllowViewStatistics = iResponse.AllowViewFiles;
iResponse.AllowFilePublish = (moduleRepository != null && (moduleRepository.Administration || moduleRepository.UploadFile));
return(iResponse);
}
private Boolean AllowDownloadFileLinkedToItem(long itemFileLinkId, int UserID, int communityID, int RoleID)
{
Boolean iResponse = false;
TaskListFile taskFile = Manager.Get <TaskListFile>(itemFileLinkId);
Person person = Manager.GetPerson(UserID);
if (taskFile != null && taskFile.TaskOwner != null && taskFile.File != null && taskFile.Link != null)
{
Task task = taskFile.TaskOwner;
communityID = task.Community == null ? 0 : task.Community.Id;
lm.Comol.Modules.TaskList.ModuleTasklist modulePermission = ServicePermission(UserID, communityID);
CoreModuleRepository moduleRepository = GetCoreModuleRepository(UserID, communityID);
CoreItemPermission itemPermission = GetTaskPermission(person, task, modulePermission, moduleRepository);
//permission.Download = itemFileLink.File.IsDownloadable && itemPermissions.AllowViewFiles;
//permission.Play = (itemFileLink.File.isSCORM || itemFileLink.File.isVideocast) && itemPermissions.AllowViewFiles;
iResponse = AllowViewFileFromLink(modulePermission, itemPermission, taskFile, person);
}
return(iResponse);
}
private List <StandardActionType> GetAllowedStandardActionForFile(int idUser, ModuleObject source, ModuleObject destination)
{
List <StandardActionType> actions = new List <StandardActionType>();
litePerson person = Manager.GetLitePerson(idUser);
EventItemFile attachment = Manager.Get <EventItemFile>(source.ObjectLongID);
if (attachment != null && attachment.Link != null && source.ObjectLongID == attachment.Id)
{
ModuleCommunityDiary modulePermission = GetPermissions(idUser, attachment.IdCommunity);
lm.Comol.Core.FileRepository.Domain.ModuleRepository moduleRepository = GetCoreModuleRepository(idUser, attachment.IdCommunity);
CoreItemPermission itemPermission = GetItemPermission(person, EventItemGet(attachment.IdItemOwner), modulePermission, moduleRepository);
if (attachment.Item != null)
{
Boolean isMultimedia = attachment.Item.Type == Core.FileRepository.Domain.ItemType.Multimedia;
Boolean isScorm = attachment.Item.Type == Core.FileRepository.Domain.ItemType.ScormPackage;
Boolean isInternal = attachment.Item.IsInternal;
if ((isScorm || isMultimedia) && (attachment.Item.Availability == Core.FileRepository.Domain.ItemAvailability.available || attachment.Item.Availability == Core.FileRepository.Domain.ItemAvailability.waitingsettings) && ((isInternal && itemPermission.AllowEdit) ||
(!isInternal && (moduleRepository.Administration || moduleRepository.EditOthersFiles || (moduleRepository.EditMyFiles && attachment.Item.IdOwner == person.Id)))))
{
actions.Add(StandardActionType.EditMetadata);
}
if (AllowViewFileFromLink(modulePermission, itemPermission, attachment, person))
{
actions.Add(StandardActionType.Play);
if (isScorm)
{
actions.Add(StandardActionType.ViewPersonalStatistics);
}
}
if ((isScorm && attachment.Item.Availability == Core.FileRepository.Domain.ItemAvailability.available) && ((isInternal && itemPermission.AllowEdit) || (!isInternal && (moduleRepository.Administration || moduleRepository.EditOthersFiles || (moduleRepository.EditMyFiles && attachment.Item.IdOwner == person.Id)))))
{
actions.Add(StandardActionType.ViewAdvancedStatistics);
}
}
}
return(actions);
}
private dtoAttachmentPermission AttachmentGetPermissions(litePerson person, dtoAttachment attachment, CoreItemPermission permissions, lm.Comol.Core.FileRepository.Domain.ModuleRepository moduleRepository)
{
dtoAttachmentPermission result = new dtoAttachmentPermission();
if (attachment.File != null)
{
Boolean fileRepositoryOwner = (moduleRepository.Administration || (moduleRepository.EditOthersFiles || (moduleRepository.EditMyFiles && attachment.File.IdOwner == person.Id)));
result.Download = (attachment.File != null && (attachment.File.IsDownloadable || attachment.File.Type == FileRepository.Domain.ItemType.Link)) && permissions.AllowViewFiles;
result.Play = (attachment.File != null && (attachment.File.Type == FileRepository.Domain.ItemType.Multimedia || attachment.File.Type == FileRepository.Domain.ItemType.ScormPackage || attachment.File.Type == FileRepository.Domain.ItemType.VideoStreaming)) && permissions.AllowViewFiles;
result.EditVisibility = permissions.AllowEdit;
switch (attachment.File.Type)
{
case FileRepository.Domain.ItemType.Multimedia:
case FileRepository.Domain.ItemType.ScormPackage:
result.ViewMyStatistics = permissions.AllowViewStatistics;
result.SetMetadata = permissions.AllowEdit && (attachment.File.IsInternal || fileRepositoryOwner);
result.ViewOtherStatistics = permissions.AllowEdit && (attachment.File.IsInternal || fileRepositoryOwner);
break;
case FileRepository.Domain.ItemType.Link:
result.Play = result.Download;
break;
}
result.Edit = false;
result.EditRepositoryVisibility = permissions.AllowEdit && fileRepositoryOwner && !attachment.File.IsInternal;
result.EditRepositoryPermission = permissions.AllowEdit && fileRepositoryOwner && !attachment.File.IsInternal;
result.Delete = attachment.File.IsInternal && permissions.AllowDelete && (attachment.Deleted != BaseStatusDeleted.None);;
result.UnDelete = attachment.File.IsInternal && (attachment.Deleted != BaseStatusDeleted.None) && (permissions.AllowUnDelete);
result.VirtualDelete = attachment.File.IsInternal && (attachment.Deleted == BaseStatusDeleted.None) && permissions.AllowUnDelete;
result.Unlink = (!attachment.File.IsInternal && permissions.AllowAddFiles);
result.Publish = permissions.AllowFilePublish && attachment.File.IsInternal && attachment.Deleted == BaseStatusDeleted.None;
}
return(result);
}
public List <dtoAttachmentItem> AttachmentsGet(litePerson person, CommunityEventItem item, Boolean viewAlsoDeleted, CoreItemPermission permissions, lm.Comol.Core.FileRepository.Domain.ModuleRepository moduleRepository, String unknownUser)
{
List <dtoAttachmentItem> items = null;
try
{
if (item != null)
{
items = new List <dtoAttachmentItem>();
List <dtoAttachment> attachments = AttachmentsGet(person, item, viewAlsoDeleted, unknownUser);
items = attachments.Where(a => a.IdModuleLink > 0).OrderBy(a => a.DisplayOrder).ThenBy(a => a.DisplayName).Select(a => new dtoAttachmentItem()
{
Attachment = a, Permissions = AttachmentGetPermissions(person, a, permissions, moduleRepository)
}).ToList();
}
}
catch (Exception ex)
{
items = null;
}
return(items);
}
public void InitView()
{
int CommunityId = UserContext.CurrentCommunityID;
if (UserContext.isAnonymous)
{
View.NoPermissionToManagementFiles(CommunityId, ModuleID);
}
else
{
//CommunityEventItem oItem = Service.GetEventItem(this.View.PreloadedItemID);
Task oTask = Service.GetTask(this.View.PreloadedItemID);
if (oTask == null)
{
this.View.NoPermissionToManagementFiles(CommunityId, this.ModuleID);
}
else
{
View.ItemID = oTask.ID;
lm.Comol.Modules.TaskList.ModuleTasklist module = new ModuleTasklist();
if ((oTask.Community != null))
{
CommunityId = oTask.Community.Id;
module = (from p in View.CommunitiesPermission where p.ID == oTask.Community.Id select p.Permissions).FirstOrDefault();
if (module == null)
{
module = new ModuleTasklist();
}
}
else
{
CommunityId = 0;
module = ModuleTasklist.CreatePortalmodule(UserContext.UserTypeID);
}
CoreModuleRepository moduleRepository = View.RepositoryPermission(CommunityId);
CoreItemPermission oPermission = Service.GetTaskPermission(oTask, module, moduleRepository);
if (oPermission.AllowAddFiles || oPermission.AllowEdit)
{
if (oTask.Community == null)
{
View.AllowCommunityUpload = false;
View.AllowCommunityLink = false;
}
View.AllowCommunityUpload = oPermission.AllowEdit && (moduleRepository.Administration || moduleRepository.UploadFile);
View.AllowCommunityLink = oPermission.AllowEdit && (moduleRepository.Administration || moduleRepository.UploadFile || moduleRepository.ListFiles || moduleRepository.DownLoad);
if (oPermission.AllowEdit && (moduleRepository.Administration || moduleRepository.UploadFile))
{
View.InitializeCommunityUploader(0, CommunityId, moduleRepository);
}
if (oPermission.AllowEdit)
{
View.InitializeModuleUploader(CommunityId);
}
View.AllowUpload = oPermission.AllowAddFiles;
// this.View.BackToDiary = CommunityID;
View.SetBackToItemsUrl(CommunityId, oTask.ID);
View.SetBackToItemUrl(CommunityId, oTask.ID);
View.SetMultipleUploadUrl(oTask.ID);
LoadTaskFiles(oTask, oPermission);
}
else
{
this.View.ReturnToItemsList(CommunityId, oTask.ID);
}
}
}
View.ItemCommunityId = CommunityId;
}
public dtoTask(CoreItemPermission module, Task task)
{
Id = task.ID;
oTask = task;
Permission = module;
}
