public void InitView(Boolean editMode, dtoDisplayRepositoryItem item, String unknownUser, String repositoryPath)
{
if (!SessionTimeout())
{
LoadVersions(editMode, item, unknownUser, repositoryPath);
}
}
public void TryToSave(long idItem, List <dtoEditAssignment> assignments, Dictionary <AssignmentType, String> tTranslations, Dictionary <PermissionsTranslation, String> translations, Dictionary <ModuleRepository.Base2Permission, String> pTranslations)
{
if (!SessionTimeout())
{
liteRepositoryItem rItem = Service.ItemGet(idItem);
Int32 idCommunity = UserContext.CurrentCommunityID;
ModuleRepository.ObjectType oType = ModuleRepository.ObjectType.File;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.VersionUnableToAdd;
if (rItem != null)
{
ModuleRepository module = Service.GetPermissions(rItem.Repository, UserContext.CurrentUserID);
idCommunity = rItem.Repository.IdCommunity;
dtoDisplayRepositoryItem dItem = Service.GetItemWithPermissions(idItem, UserContext.CurrentUserID, rItem.Repository, View.GetUnknownUserName());
if (dItem == null)
{
View.DisplayUserMessage(UserMessageType.detailsNoPermissionToSave);
oType = ModuleRepository.GetObjectType(rItem.Type);
uAction = ModuleRepository.ActionType.UnknownItemFound;
}
else if (rItem.Type == ItemType.Folder)
{
View.AskUserForApply(rItem.DisplayName);
}
else
{
SaveAssignments(idItem, assignments, false, tTranslations, translations, pTranslations);
}
}
else
{
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction, idItem, oType);
}
}
}
private void InitializeSelectors(dtoDisplayRepositoryItem item)
{
Boolean allowAddRole = item.Permissions.EditPermission && item.Repository.Type == RepositoryType.Community;
Boolean allowAddUsers = item.Permissions.EditPermission;
if (allowAddRole)
{
List <lm.Comol.Core.DomainModel.dtoTranslatedRoleType> roles = Service.AssignmentNotAssignedRoles(item.Id, item.Repository);
allowAddRole = (roles != null && roles.Any());
View.InitializeRolesSelector(roles);
}
if (allowAddUsers)
{
switch (item.Repository.Type)
{
case RepositoryType.Community:
View.InitializeUsersSelector(item.Repository.IdCommunity, Service.AssignmentAssignedUsersId(item.Id, item.Repository));
break;
case RepositoryType.Portal:
View.InitializePortalUsersSelector(Service.AssignmentAssignedUsersId(item.Id, item.Repository));
break;
default:
allowAddUsers = false;
break;
}
}
View.AllowUpload = item.AllowUpload;
View.InitializeCommands(allowAddRole, allowAddUsers);
}
private void AddChildren(List <dtoRepositoryItem> children, dtoDisplayRepositoryItem father, liteRepositorySettings settings, Int32 idCurrentUser, Int32 idRole, Int32 idProfileType, ModuleRepository permissions, Boolean forAdmin = false, Boolean alsoHidden = false, Boolean onlyFolder = false, List <liteItemAssignments> assignments = null)
{
foreach (dtoRepositoryItem item in children.Where(i => (!onlyFolder || (onlyFolder && i.Type == ItemType.Folder)) && (forAdmin || alsoHidden || (i.IsVisible || i.IdOwner == idCurrentUser))))
{
dtoDisplayRepositoryItem child = null;
if (forAdmin)
{
child = new dtoDisplayRepositoryItem(item, idCurrentUser, settings, permissions, forAdmin);
}
else
{
child = new dtoDisplayRepositoryItem(item, idCurrentUser, settings, permissions, forAdmin, HasValidAssignments(item.Id, idCurrentUser, idRole, idProfileType, assignments));
}
child.HasDefaultPermissions = !(assignments != null && assignments.Any(a => a.IdItem == child.Id && a.Type != AssignmentType.community));
if (child.IsUserAvailable)
{
child.Father = father;
if (item.Children.Any())
{
AddChildren(item.Children, child, settings, idCurrentUser, idRole, idProfileType, permissions, forAdmin, alsoHidden, onlyFolder, assignments);
}
father.Children.Add(child);
}
}
}
public List <dtoModuleUploadedItem> AddFiles(String istanceIdentifier, Int32 idUploaderUser, Boolean allowAnonymousUpload, Boolean alwaysLastVersion, RepositoryIdentifier identifier, long idFolder, List <dtoUploadedItem> files, Object obj, long idObject, Int32 idObjectType, String moduleCode, Int32 idModuleAjaxAction, Int32 idModuleAction = 0)
{
List <dtoModuleUploadedItem> items = new List <dtoModuleUploadedItem>();
if (!SessionTimeout() || allowAnonymousUpload && idUploaderUser > 0)
{
litePerson person = Service.GetValidPerson(idUploaderUser);
liteRepositorySettings settings = Service.SettingsGetByRepositoryIdentifier(identifier);
ModuleRepository module = Service.GetPermissions(identifier, idUploaderUser);
ModuleRepository.ObjectType oType = ModuleRepository.ObjectType.File;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.UnableToAddFile;
liteRepositoryItem item = (idFolder > 0 ? Service.ItemGet(idFolder) : null);
if (person == null || (item == null && idFolder > 0))
{
View.DisplayError(ItemUploadError.UnableToAddFileToUnknownFolder);
uAction = ModuleRepository.ActionType.UnknownItemFound;
InitializeView(idFolder, identifier, module, settings, CurrentManager.GetLitePerson(idUploaderUser));
}
else
{
Boolean allowAdd = module.Administration || module.ManageItems || module.UploadFile;
dtoDisplayRepositoryItem dItem = Service.GetItemWithPermissions(idFolder, UserContext.CurrentUserID, identifier, View.GetUnknownUserName());
if (dItem != null)
{
oType = ModuleRepository.GetObjectType(dItem.Type);
allowAdd = allowAdd || dItem.Permissions.GetActions().Contains(ItemAction.upload);
}
else if (idFolder == 0)
{
oType = ModuleRepository.ObjectType.Folder;
}
String folderName = (idFolder == 0 ? View.GetRootFolderName() : dItem.Name);
if (!allowAdd)
{
View.DisplayError(ItemUploadError.MissingPermissionsToAddFile, folderName, "", ItemType.Folder);
uAction = ModuleRepository.ActionType.UnavailableItem;
}
else
{
Boolean executed = false;
items = Service.FileAddToRepository(settings, istanceIdentifier, identifier, person, alwaysLastVersion, module, View.GetRepositoryDiskPath(), idFolder, files, obj, idObject, idObjectType, moduleCode, idModuleAjaxAction, idModuleAction);
executed = (items != null && items.Any(a => a.IsAdded));
uAction = (executed ? (items.Any(a => !a.IsAdded) ? ModuleRepository.ActionType.UnableToAddSomeFile : ModuleRepository.ActionType.AddFile) : ModuleRepository.ActionType.UnableToAddFile);
if (executed)
{
View.NotifyAddedItems(Service.GetIdModule(), idFolder, folderName, RootObject.RepositoryItems(identifier.Type, identifier.IdCommunity, -1, (dItem == null ? 0 : dItem.Id)), items.Where(a => a.ItemAdded != null).Select(f => f.ItemAdded).ToList());
}
else
{
View.DisplayError(ItemUploadError.UnableToAddFile, folderName, (items == null) ? null : items.Where(a => !a.IsAdded).Select(a => a.UploadedFile).ToList());
}
}
}
View.SendUserAction(identifier.IdCommunity, Service.GetIdModule(), uAction, idFolder, oType);
}
return(items);
}
private dtoDisplayRepositoryItem GetRecycleBinFolder(String name, List <dtoDisplayRepositoryItem> items)
{
dtoDisplayRepositoryItem folder = dtoDisplayRepositoryItem.GenerateFolder(FolderType.recycleBin, name);
folder.IdCommunity = items.Select(i => i.IdCommunity).FirstOrDefault();
items.ForEach(i => folder.Children.AddRange(i.GetDeletedItems()));
folder.Children = folder.Children.OrderBy(c => c.Path).ThenBy(c => c.Name).ToList();
return(folder);
}
public dtoDisplayRepositoryItem GetItemWithPermissions(long idItem, List <dtoDisplayRepositoryItem> items)
{
dtoDisplayRepositoryItem item = items.Where(i => i.Type != ItemType.Folder || (i.FolderType == FolderType.standard || i.FolderType == FolderType.recycleBin)).Select(c => c.GetItem(idItem)).Where(i => i != null).FirstOrDefault();
if (item != null && (item.Type == ItemType.ScormPackage || item.Type == ItemType.Multimedia))
{
ItemRefreshAvailability(item);
}
return(item);
}
public void SaveAssignments(long idItem, List <dtoEditAssignment> assignments, Boolean applyToContent, Dictionary <AssignmentType, String> tTranslations, Dictionary <PermissionsTranslation, String> translations, Dictionary <ModuleRepository.Base2Permission, String> pTranslations)
{
if (!SessionTimeout())
{
liteRepositoryItem rItem = Service.ItemGet(idItem);
Int32 idCommunity = UserContext.CurrentCommunityID;
ModuleRepository.ObjectType oType = ModuleRepository.ObjectType.File;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.VersionUnableToAdd;
if (rItem != null)
{
oType = ModuleRepository.GetObjectType(rItem.Type);
ModuleRepository module = Service.GetPermissions(rItem.Repository, UserContext.CurrentUserID);
Boolean reloadItems = false;
idCommunity = rItem.Repository.IdCommunity;
dtoDisplayRepositoryItem dItem = Service.GetItemWithPermissions(idItem, UserContext.CurrentUserID, rItem.Repository, View.GetUnknownUserName());
if (dItem == null)
{
View.DisplayUserMessage(UserMessageType.detailsNoPermissionToSave);
uAction = ModuleRepository.ActionType.UnknownItemFound;
}
else
{
oType = ModuleRepository.GetObjectType(dItem.Type);
applyToContent = applyToContent && dItem.Type == ItemType.Folder;
if (!dItem.Permissions.EditPermission)
{
View.DisplayUserMessage(UserMessageType.permissionsNoPermissionToSave);
uAction = ModuleRepository.ActionType.UnavailableItem;
}
else if (!assignments.Any(a => !a.Denyed))
{
View.DisplayUserMessage(UserMessageType.permissionsNoItemToSave);
uAction = ModuleRepository.ActionType.PermissionsNothingToSave;
}
else
{
long permissions = (long)((rItem.AllowUpload) ? ModuleRepository.Base2Permission.DownloadOrPlay | ModuleRepository.Base2Permission.Upload : ModuleRepository.Base2Permission.DownloadOrPlay);
assignments.Where(a => !a.Denyed && a.Permissions == 0).ToList().ForEach(a => a.Permissions = permissions);
reloadItems = Service.AssignmentsAddToItem(idItem, assignments.Where(a => !a.IsDeleted).ToList(), applyToContent);
View.HasPendingChanges = !reloadItems;
uAction = (reloadItems ? ModuleRepository.ActionType.PermissionsSaved : ModuleRepository.ActionType.PermissionsNotSaved);
View.DisplayUserMessage((reloadItems? UserMessageType.permissionsSaved : UserMessageType.permissionsUnableToSave));
}
}
if (reloadItems)
{
InitializeSelectors(dItem);
LoadAssignments(true, dItem.Id, tTranslations, translations, pTranslations);
}
}
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction, idItem, oType);
}
}
public void InitView(Boolean editMode, dtoDisplayRepositoryItem item, String unknownUser, Dictionary <AssignmentType, String> tTranslations, Dictionary <PermissionsTranslation, String> translations, Dictionary <ModuleRepository.Base2Permission, String> pTranslations)
{
if (!SessionTimeout())
{
if (editMode)
{
InitializeSelectors(item);
}
LoadAssignments(editMode, item.Id, tTranslations, translations, pTranslations);
}
}
private void LoadVersions(liteRepositoryItem item, String unknownUser, String repositoryPath)
{
dtoDisplayRepositoryItem dItem = Service.GetItemWithPermissions(item.Id, UserContext.CurrentUserID, item.Repository, View.GetUnknownUserName());
if (dItem == null)
{
View.DisplayUserMessage(UserMessageType.versionItemNoPermission);
View.SendUserAction(item.IdCommunity, Service.GetIdModule(), ModuleRepository.ActionType.NoPermission, item.Id, ModuleRepository.GetObjectType(item.Type));
}
else
{
LoadVersions(true, dItem, unknownUser, repositoryPath);
}
}
public dtoDisplayRepositoryItem GetItemWithPermissionsAndStatistics(long idItem, List <dtoDisplayRepositoryItem> items, Int32 idPerson)
{
dtoDisplayRepositoryItem item = GetItemWithPermissions(idItem, items);
if (item != null)
{
item.Downloaded = (from i in Manager.GetIQ <liteRepositoryItem>() where i.Id == idItem select i.Downloaded).Skip(0).Take(1).ToList().FirstOrDefault();
item.MyDownloads = DownloadsCountForItem(idItem, idPerson);
if (item.MyDownloads > item.Downloaded)
{
item.MyDownloads = DownloadsCountForItem(idItem);
}
ItemRefreshAvailability(item);
}
return(item);
}
private void SetRecycleBinInfo(dtoFolderSize folder, dtoDisplayRepositoryItem treeFolder, List <liteRepositoryItem> items)
{
long fileSize = 0;
long folderSize = 0;
long viewSize = 0;
long usedSize = 0;
if (items.Any(i => i.Deleted == BaseStatusDeleted.Manual))
{
usedSize = items.Where(i => i.Deleted == BaseStatusDeleted.Manual).Select(i => i.VersionsSize + i.Size).Sum();
}
if (treeFolder.Children.Any(i => i.Deleted == BaseStatusDeleted.Manual && i.Type == ItemType.Folder))
{
folderSize = treeFolder.Children.Where(i => i.Deleted == BaseStatusDeleted.Manual && i.Type == ItemType.Folder).Select(f => f.Size + f.VersionsSize).Sum();
}
if (treeFolder.Children.Any(i => i.Deleted == BaseStatusDeleted.Manual && i.Type != ItemType.Folder))
{
fileSize = treeFolder.Children.Where(i => i.Deleted == BaseStatusDeleted.Manual && i.Type != ItemType.Folder).Select(f => f.Size + f.VersionsSize).Sum();
}
folder.Items.Add(new FolderSizeItem()
{
Number = treeFolder.Children.Where(i => i.Deleted == BaseStatusDeleted.Manual && i.Type == ItemType.Folder).Count(), Type = FolderSizeItemType.folder, Size = folderSize
});
folder.Items.Add(new FolderSizeItem()
{
Number = treeFolder.Children.Where(i => i.Deleted == BaseStatusDeleted.Manual && i.Type != ItemType.Folder && i.Type != ItemType.Link).Count(), Type = FolderSizeItemType.file, Size = fileSize
});
viewSize = fileSize + folderSize;
if (items.Any(i => i.Deleted != BaseStatusDeleted.None && i.Type == ItemType.Link))
{
folder.Items.Add(new FolderSizeItem()
{
Number = treeFolder.Children.Where(i => i.Deleted == BaseStatusDeleted.Manual && i.Type == ItemType.Link).Count(), Type = FolderSizeItemType.link
});
}
if (viewSize < usedSize)
{
folder.Items.Add(new FolderSizeItem()
{
Number = items.Where(i => i.Deleted == BaseStatusDeleted.Manual && !treeFolder.Children.Any(it => it.Id == i.Id)).Count(), Type = FolderSizeItemType.unavailableItems, Size = usedSize - viewSize
});
}
}
private List <dtoDisplayRepositoryItem> GetRepositoryItemsWithPermissions(liteRepositorySettings settings, Int32 idCurrentUser, RepositoryIdentifier identifier, List <dtoRepositoryItem> fItems, ModuleRepository permissions, Boolean forAdmin = false, Boolean alsoHidden = false, Boolean onlyFolder = false, Boolean useCache = true)
{
Int32 idRole = (Int32)RoleTypeStandard.Guest;
Int32 idProfileType = Manager.GetIdProfileType(idCurrentUser);
List <dtoDisplayRepositoryItem> results = new List <dtoDisplayRepositoryItem>();
List <liteItemAssignments> assignments = new List <liteItemAssignments>();
switch (identifier.Type)
{
case RepositoryType.Community:
case RepositoryType.Portal:
assignments = GetAssignments(fItems.SelectMany(f => f.GetAllId()).Distinct().ToList());
idRole = (identifier.Type == RepositoryType.Community) ? Manager.GetActiveSubscriptionIdRole(UC.CurrentUserID, identifier.IdCommunity) : idRole;
break;
}
foreach (dtoRepositoryItem item in fItems.Where(i => (!onlyFolder || (onlyFolder && i.Type == ItemType.Folder)) && (forAdmin || alsoHidden || (i.IsVisible || i.IdOwner == idCurrentUser))))
{
dtoDisplayRepositoryItem dItem = null;
if (forAdmin)
{
dItem = new dtoDisplayRepositoryItem(item, idCurrentUser, settings, permissions, forAdmin);
}
else
{
dItem = new dtoDisplayRepositoryItem(item, idCurrentUser, settings, permissions, forAdmin, HasValidAssignments(item.Id, idCurrentUser, idRole, idProfileType, assignments));
}
dItem.HasDefaultPermissions = !(assignments != null && assignments.Any(a => a.IdItem == dItem.Id && a.Type != AssignmentType.community));
if (dItem.IsUserAvailable)
{
if (item.Children.Any())
{
AddChildren(item.Children, dItem, settings, idCurrentUser, idRole, idProfileType, permissions, forAdmin, alsoHidden, onlyFolder, assignments);
}
results.Add(dItem);
}
}
if (!onlyFolder)
{
SetForTreeItemsPermissions(results, settings, idCurrentUser, permissions);
}
return(results);
}
private void LoadVersions(Boolean editMode, dtoDisplayRepositoryItem item, String unknownUser, String repositoryPath)
{
Boolean allowAddVersion = editMode && item.Permissions.AddVersion;
List <dtoDisplayVersionItem> items = Service.ItemGetVersions(editMode, item, unknownUser);
if (!editMode)
{
items = items.Where(i => !i.IsDeleted).ToList();
}
if (!allowAddVersion)
{
View.LoadVersions(items);
}
else
{
View.LoadVersions(items, item, Service.GetFolderQuota(repositoryPath, 0, item.Repository));
}
}
public void CurrentVersionUpdated(long idItem)
{
if (!SessionTimeout())
{
RepositoryIdentifier rIdentifier = Service.ItemGetRepositoryIdentifier(idItem);
if (rIdentifier == null)
{
View.InitializeHeader();
View.DisplayUnknownItem();
}
else
{
Int32 idCurrentUser = UserContext.CurrentUserID;
liteRepositorySettings settings = Service.SettingsGetByRepositoryIdentifier(rIdentifier);
ModuleRepository module = Service.GetPermissions(rIdentifier, idCurrentUser);
Boolean admin = module.ManageItems || module.Administration;
dtoDisplayRepositoryItem dto = Service.GetItemWithPermissionsAndStatistics(idItem, Service.GetAvailableRepositoryItems(settings, UserContext.CurrentUserID, rIdentifier.Type, rIdentifier.IdCommunity, View.GetUnknownUserName(), View.GetFolderTypeTranslation(), View.GetTypesTranslations(), module, admin, admin), UserContext.CurrentUserID);
View.UpdateItemDetails(dto, settings.AutoThumbnailWidth, settings.AutoThumbnailHeight, settings.AutoThumbnailForExtension);
}
}
}
public List <dtoDisplayVersionItem> ItemGetVersions(Boolean editMode, dtoDisplayRepositoryItem item, String unknownUser)
{
List <dtoDisplayVersionItem> versions = new List <dtoDisplayVersionItem>();
try
{
versions = (from v in Manager.GetIQ <liteRepositoryItemVersion>()
where v.IdItem == item.Id
select v).ToList().OrderByDescending(v => v.CreatedOn).Select(v =>
new dtoDisplayVersionItem(v)
{
Repository = item.Repository
}).ToList();
if (versions.Any())
{
List <Int32> idUsers = versions.Select(v => v.IdCreatedBy).Distinct().ToList();
idUsers.AddRange(versions.Select(v => v.IdModifiedBy).Distinct().ToList());
List <litePerson> persons = Manager.GetLitePersons(idUsers.Where(i => i > 0).Distinct().ToList());
long displayOrder = 0;
foreach (dtoDisplayVersionItem v in versions.OrderBy(v => v.Number).ThenBy(v => v.Id))
{
v.Author = persons.Where(p => p.Id == v.IdCreatedBy).Select(p => p.SurnameAndName).DefaultIfEmpty(unknownUser).FirstOrDefault();
if (v.ModifiedOn.HasValue)
{
v.ModifyBy = persons.Where(p => p.Id == v.IdModifiedBy).Select(p => p.SurnameAndName).DefaultIfEmpty(unknownUser).FirstOrDefault();
}
v.DisplayOrder = displayOrder;
v.Permissions.Download = item.Permissions.Download && (!v.IsDeleted || (v.IsDeleted && (item.Permissions.RemoveVersion || item.Permissions.SetVersion || item.Permissions.AddVersion)));
v.Permissions.Play = item.Permissions.Play && (!v.IsDeleted || (v.IsDeleted && (item.Permissions.RemoveVersion || item.Permissions.SetVersion || item.Permissions.AddVersion)));
v.Permissions.SetActive = !v.IsActive && item.Permissions.SetVersion;
}
}
}
catch (Exception ex)
{
return(null);
}
return(versions);
}
public void AddVersionToFile(String istanceIdentifier, long idItem, dtoUploadedItem version, String unknownUser, String repositoryPath)
{
if (!SessionTimeout())
{
liteRepositoryItem rItem = Service.ItemGet(idItem);
Int32 idCommunity = UserContext.CurrentCommunityID;
ModuleRepository.ObjectType oType = ModuleRepository.ObjectType.File;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.VersionUnableToAdd;
if (rItem != null)
{
ModuleRepository module = Service.GetPermissions(rItem.Repository, UserContext.CurrentUserID);
Boolean reloadItems = false;
idCommunity = rItem.Repository.IdCommunity;
dtoDisplayRepositoryItem dItem = Service.GetItemWithPermissions(idItem, UserContext.CurrentUserID, rItem.Repository, View.GetUnknownUserName());
if (dItem == null)
{
View.DisplayUserMessage(UserMessageType.versionItemNoPermission);
uAction = ModuleRepository.ActionType.UnknownItemFound;
}
else
{
Boolean allowAdd = dItem.Permissions.GetActions().Contains(ItemAction.addVersion);
oType = ModuleRepository.GetObjectType(dItem.Type);
if (!allowAdd)
{
View.DisplayUserMessage(UserMessageType.versionItemNoPermission);
uAction = ModuleRepository.ActionType.UnavailableItem;
}
else
{
liteRepositorySettings settings = Service.SettingsGetByRepositoryIdentifier(rItem.Repository);
Service.ThumbnailsCreate(settings, dItem.UniqueId, version);
dtoCreatedItem addedVersion = Service.FileAddVersion(settings, module, repositoryPath, istanceIdentifier, idItem, version);
reloadItems = (addedVersion != null && addedVersion.IsAdded);
uAction = (reloadItems ? ModuleRepository.ActionType.VersionAddedToFile : ModuleRepository.ActionType.VersionUnableToAdd);
if (reloadItems)
{
View.DisplayUserMessage(UserMessageType.versionAdded);
dItem.IdVersion = addedVersion.Added.Id;
dItem.UniqueIdVersion = addedVersion.Added.UniqueIdVersion;
dItem.Thumbnail = addedVersion.Added.Thumbnail;
dItem.AutoThumbnail = addedVersion.Added.AutoThumbnail;
View.CurrentVersionUpdated(dItem, settings.AutoThumbnailWidth, settings.AutoThumbnailHeight, settings.AutoThumbnailForExtension);
String folderName = (dItem.IdFolder == 0 ? View.GetRootFolderFullname() : Service.FolderGetName(dItem.IdFolder));
View.NotifyAddedVersion(Service.GetIdModule(), dItem.IdFolder, folderName, RootObject.RepositoryItems(dItem.Repository.Type, dItem.Repository.IdCommunity, dItem.Id, dItem.IdFolder), addedVersion);
}
else
{
View.DisplayUserMessage(UserMessageType.versionNotAdded);
}
}
}
if (reloadItems)
{
LoadVersions(true, dItem, unknownUser, repositoryPath);
}
}
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction, idItem, oType);
}
}
private List <dtoFolderSize> GetFolderAvailabilityInfo(dtoFolderSize repository, dtoFolderSize father, dtoDisplayRepositoryItem folder, List <liteRepositoryItem> items)
{
List <dtoFolderSize> folders = new List <dtoFolderSize>();
dtoFolderSize rFolder = new dtoFolderSize()
{
IdFolder = folder.Id, Name = folder.Name, IdentifierPath = folder.IdentifierPath, FolderType = folder.FolderType
};
switch (folder.FolderType)
{
case FolderType.recycleBin:
SetRecycleBinInfo(rFolder, folder, items);
break;
case FolderType.standard:
SetStandardFolderInfo(rFolder, folder, items);
break;
}
if (rFolder.Items.Any())
{
rFolder.Size = rFolder.Items.Select(i => i.Size).Sum();
}
rFolder.Quota = dtoContainerQuota.Create(father.Quota, rFolder.Size);
rFolder.UploadAvailable = (rFolder.FolderType == FolderType.standard) && (rFolder.Quota.AvailableSize == -1 || rFolder.FreeSpace > 0);
switch (rFolder.FolderType)
{
case FolderType.standard:
case FolderType.recycleBin:
rFolder.Items.Add(new FolderSizeItem()
{
Number = 0, Type = FolderSizeItemType.fullSize, Size = rFolder.Size
});
break;
}
rFolder.SetPercentage();
switch (folder.FolderType)
{
case FolderType.recycleBin:
break;
case FolderType.standard:
foreach (dtoDisplayRepositoryItem child in folder.Children.Where(f => f.Type == ItemType.Folder && f.Deleted == BaseStatusDeleted.None))
{
folders.AddRange(GetFolderAvailabilityInfo(repository, rFolder, child, items));
}
break;
}
folders.Insert(0, rFolder);
return(folders);
}
public void InitView(Boolean isEditPage, long idItem, long idFolder, String path, Boolean setBackUrl, String backUrl)
{
RepositoryIdentifier rIdentifier = Service.ItemGetRepositoryIdentifier(idItem);
Int32 idCommunity = UserContext.CurrentCommunityID;
View.IdItem = idItem;
View.IdCurrentFolder = idFolder;
View.CurrentFolderIdentifierPath = path;
if (setBackUrl && String.IsNullOrEmpty(backUrl))
{
backUrl = View.GetPreviousRelativeUrl();
if (!IsValidPreviousUrl(backUrl))
{
backUrl = "";
setBackUrl = false;
}
if (backUrl.StartsWith(RootObject.BaseRepositoryUrl(), StringComparison.InvariantCultureIgnoreCase) && rIdentifier != null)
{
cookieRepository cookie = View.GetRepositoryCookie(rIdentifier);
if (cookie != null)
{
backUrl = RootObject.RepositoryItems(rIdentifier.Type, rIdentifier.IdCommunity, 0, cookie.IdFolder, cookie.Type, cookie.ItemsOrderBy, cookie.Ascending, cookie.IdentifierPath);
}
}
SetLogoutUrl(isEditPage, View.GetCurrentUrl(), setBackUrl, backUrl);
}
else
{
View.DefaultLogoutUrl = View.GetCurrentUrl();
}
View.BackUrl = (setBackUrl ? backUrl : "");
View.SetPageBackUrl(backUrl);
View.PageIdentifier = Guid.NewGuid();
if (SessionTimeout())
{
return;
}
View.IsInitialized = true;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.None;
if (rIdentifier == null)
{
View.InitializeHeader();
uAction = (isEditPage) ? ModuleRepository.ActionType.EditDetailsTryToLoad : ModuleRepository.ActionType.ViewDetailsTryToLoad;
View.DisplayUnknownItem();
}
else
{
Int32 idCurrentUser = UserContext.CurrentUserID;
liteRepositorySettings settings = Service.SettingsGetByRepositoryIdentifier(rIdentifier);
ModuleRepository module = Service.GetPermissions(rIdentifier, idCurrentUser);
View.RepositoryIdentifier = CacheKeys.RepositoryIdentifierKey(rIdentifier.Type, rIdentifier.IdCommunity);
View.RepositoryIdCommunity = rIdentifier.IdCommunity;
idCommunity = rIdentifier.IdCommunity;
View.RepositoryType = rIdentifier.Type;
View.SetTitle(Service.ItemGetType(idItem));
View.IsInitialized = true;
if (settings != null)
{
Boolean admin = module.ManageItems || module.Administration;
dtoDisplayRepositoryItem dto = Service.GetItemWithPermissionsAndStatistics(idItem, Service.GetAvailableRepositoryItems(settings, UserContext.CurrentUserID, rIdentifier.Type, rIdentifier.IdCommunity, View.GetUnknownUserName(), View.GetFolderTypeTranslation(), View.GetTypesTranslations(), module, admin, admin), UserContext.CurrentUserID);
if (dto != null)
{
if (!isEditPage && dto.Permissions.Edit)
{
View.SetUrlForEdit(RootObject.EditItem(idItem, idFolder, path, ItemAction.edit, (!String.IsNullOrWhiteSpace(backUrl)), backUrl));
}
else if (isEditPage)
{
View.SetUrlForView(RootObject.Details(idItem, idFolder, path, ItemAction.edit, (!String.IsNullOrWhiteSpace(backUrl)), backUrl));
}
if (!isEditPage || (isEditPage && dto.Permissions.Edit))
{
View.AllowSave = dto.Permissions.Edit && isEditPage;
View.AllowHideItem = dto.Permissions.Hide && isEditPage;
View.AllowShowItem = dto.Permissions.Show && isEditPage;
View.DisplayItemDetails(isEditPage, dto, settings.AutoThumbnailWidth, settings.AutoThumbnailHeight, settings.AutoThumbnailForExtension);
if (dto.Permissions.ViewPermission || dto.Permissions.EditPermission)
{
View.DisplayItemPermissions(isEditPage, dto);
}
if (isEditPage)
{
View.InitializeDefaultTags(ServiceTags.GetAvailableTags(rIdentifier.IdPerson, idCommunity, CurrentIdModule, ModuleRepository.UniqueCode));
}
else
{
View.InitializeHeader();
}
uAction = (isEditPage) ? ModuleRepository.ActionType.EditDetailsLoaded : ModuleRepository.ActionType.ViewDetailsLoaded;
}
else if (isEditPage)
{
View.SendUserAction(idCommunity, Service.GetIdModule(), ModuleRepository.ActionType.EditDetailsTryToLoad);
View.GoToUrl(RootObject.Details(idItem, idFolder, path, ItemAction.details, setBackUrl, backUrl));
}
}
else
{
if (isEditPage)
{
View.SetUrlForView(RootObject.Details(idItem, idFolder, path, ItemAction.edit, (!String.IsNullOrWhiteSpace(backUrl)), backUrl));
}
View.InitializeHeader();
View.DisplayNoPermission(idCommunity, Service.GetIdModule());
uAction = (isEditPage) ? ModuleRepository.ActionType.EditDetailsNoPermissions : ModuleRepository.ActionType.ViewDetailsNoPermissions;
}
}
else
{
View.InitializeHeader();
uAction = (isEditPage) ? ModuleRepository.ActionType.EditDetailsTryToLoad : ModuleRepository.ActionType.ViewDetailsTryToLoad;
View.DisplayUnknownItem();
}
}
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction);
}
private void SetStandardFolderInfo(dtoFolderSize folder, dtoDisplayRepositoryItem treeFolder, List <liteRepositoryItem> items)
{
long viewSize = 0;
long usedSize = treeFolder.Size;
long versionSize = 0;
long deletedSize = 0;
long deletedChildrenSize = 0;
long childrenSize = treeFolder.Children.Where(i => i.Deleted == BaseStatusDeleted.None && i.IsUserAvailable && i.Type == ItemType.Folder).Select(i => i.Size).DefaultIfEmpty().Sum();
folder.Items.Add(new FolderSizeItem()
{
Number = treeFolder.Children.Where(c => c.Deleted == BaseStatusDeleted.None && c.Type == ItemType.Folder && c.IsUserAvailable).Count(), Type = FolderSizeItemType.folder, Size = childrenSize
});
if (treeFolder.Children.Any(i => i.Deleted == BaseStatusDeleted.None && i.IsUserAvailable && i.Type != ItemType.Folder && i.Type != ItemType.Link))
{
viewSize = treeFolder.Children.Where(i => i.Deleted == BaseStatusDeleted.None && i.IsUserAvailable && i.Type != ItemType.Folder && i.Type != ItemType.Link).Select(i => i.Size).Sum();
}
folder.Items.Add(new FolderSizeItem()
{
Number = treeFolder.Children.Where(c => c.Deleted == BaseStatusDeleted.None && c.Type != ItemType.Folder && c.Type != ItemType.Link).Count(), Type = FolderSizeItemType.file, Size = viewSize
});
viewSize += childrenSize;
if (treeFolder.Children.Any(c => c.Deleted == BaseStatusDeleted.None && c.Type == ItemType.Link))
{
folder.Items.Add(new FolderSizeItem()
{
Number = treeFolder.Children.Where(c => c.Deleted == BaseStatusDeleted.None && c.Type == ItemType.Link).Count(), Type = FolderSizeItemType.link, Size = deletedSize
});
}
if (treeFolder.Children.Any(i => i.Deleted != BaseStatusDeleted.None))
{
deletedSize = treeFolder.Children.Where(i => i.Deleted == BaseStatusDeleted.Manual).Select(i => i.Size + i.VersionsSize).Sum();
folder.Items.Add(new FolderSizeItem()
{
Number = treeFolder.Children.Where(i => i.Deleted == BaseStatusDeleted.Manual).Count(),
Type = FolderSizeItemType.deleted,
Size = deletedSize
});
}
if (treeFolder.Children.Any(i => i.Deleted == BaseStatusDeleted.None && i.HasVersions))
{
versionSize = treeFolder.Children.Where(i => i.Deleted == BaseStatusDeleted.None && i.Type != ItemType.Folder && i.HasVersions).Select(i => i.VersionsSize).Sum();
folder.Items.Add(new FolderSizeItem()
{
Number = treeFolder.Children.Where(i => i.Deleted == BaseStatusDeleted.None && i.Type != ItemType.Folder && i.HasVersions).Count(),
Type = FolderSizeItemType.version,
Size = versionSize
});
}
deletedChildrenSize = treeFolder.Children.Where(i => i.Deleted == BaseStatusDeleted.None && i.IsUserAvailable && i.Type == ItemType.Folder).Select(i => i.DeletedSize).DefaultIfEmpty(0).Sum();
if (deletedChildrenSize > 0)
{
folder.Items.Add(new FolderSizeItem()
{
Number = treeFolder.Children.Count(i => i.Deleted == BaseStatusDeleted.None && i.IsUserAvailable && i.Type == ItemType.Folder && i.DeletedSize > 0), Type = FolderSizeItemType.deletedonsubfolders, Size = deletedChildrenSize
});
}
if ((viewSize + versionSize + deletedSize + deletedChildrenSize) < usedSize)
{
folder.Items.Add(new FolderSizeItem()
{
Number = items.Where(i => i.IdFolder == folder.IdFolder && !treeFolder.Children.Any(it => it.Id == i.Id)).Count(), Type = FolderSizeItemType.unavailableItems, Size = usedSize - (viewSize + versionSize + deletedSize + deletedChildrenSize)
});
}
}
public void InitView(long idSettings, long idLink, long idItem, long idVersion)
{
RepositoryIdentifier rIdentifier = Service.ItemGetRepositoryIdentifier(idItem);
Int32 idCommunity = UserContext.CurrentCommunityID;
View.IdItem = idItem;
View.IdVersion = idVersion;
View.IdLink = idLink;
View.PageIdentifier = Guid.NewGuid();
if (SessionTimeout())
{
return;
}
View.IsInitialized = true;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.None;
if (rIdentifier == null)
{
uAction = ModuleRepository.ActionType.ScormSettingsTryToLoad;
View.DisplayUnknownItem();
}
else
{
Int32 idCurrentUser = UserContext.CurrentUserID;
liteRepositoryItem item = Service.ItemGet(idItem);
liteRepositoryItemVersion version = Service.ItemGetVersion(idItem, idVersion);
if (version == null)
{
uAction = ModuleRepository.ActionType.ScormSettingsTryToLoad;
View.DisplayUnknownItem();
}
else if (version.Type != ItemType.ScormPackage)
{
idCommunity = version.IdCommunity;
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.scormSettingsInvalidType);
uAction = ModuleRepository.ActionType.ScormSettingsInvalidType;
}
else
{
idVersion = version.Id;
View.IdVersion = idVersion;
idCommunity = version.IdCommunity;
if (version.Availability == ItemAvailability.available || version.Availability == ItemAvailability.waitingsettings)
{
ItemPermission permissions = null;
if (idLink == 0)
{
dtoDisplayRepositoryItem dto = Service.GetItemWithPermissions(idItem, idCurrentUser, item.Repository, View.GetUnknownUserName());
if (dto != null)
{
permissions = dto.Permissions;
}
}
else
{
liteModuleLink link = CurrentManager.Get <liteModuleLink>(idLink);
if (link == null)
{
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.scormSettingsNoPermission);
}
else
{
permissions = View.GetLinkPermissions(link, idCurrentUser);
idCommunity = link.SourceItem.CommunityID;
}
}
if (permissions != null && (permissions.Edit || permissions.EditSettings || permissions.ViewMyStatistics || permissions.ViewOtherStatistics))
{
uAction = ModuleRepository.ActionType.ScormSettingsView;
if (version.Availability == ItemAvailability.waitingsettings)
{
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.scormSettingsWaitingToSet);
}
dtoScormPackageSettings settings = Service.ScormPackageGetDtoCompletionSettings(idItem, idVersion, idSettings);
if (settings == null)
{
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.scormSettingsNotFound);
}
else
{
View.IdSettings = settings.Id;
View.LoadSettings(item.UniqueIdVersion.ToString(), item.DisplayName, settings, true, true);
}
}
else
{
uAction = ModuleRepository.ActionType.ScormSettingsNoPermissions;
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.scormSettingsNoPermission);
}
}
else
{
uAction = ModuleRepository.ActionType.ScormSettingsStatusError;
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.scormSettingsInvalidStatus, version.Availability);
}
}
View.RepositoryIdentifier = CacheKeys.RepositoryIdentifierKey(rIdentifier.Type, rIdentifier.IdCommunity);
View.RepositoryIdCommunity = rIdentifier.IdCommunity;
View.RepositoryType = rIdentifier.Type;
View.IsInitialized = true;
}
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction);
}
public void InitView(long idLink, long idItem, long idVersion, long idFolder, String path, Boolean setBackUrl, String backUrl)
{
RepositoryIdentifier rIdentifier = Service.ItemGetRepositoryIdentifier(idItem);
Int32 idCommunity = UserContext.CurrentCommunityID;
View.IdItem = idItem;
View.IdVersion = idVersion;
View.IdLink = idLink;
View.IdCurrentFolder = idFolder;
View.CurrentFolderIdentifierPath = path;
if (setBackUrl && String.IsNullOrEmpty(backUrl))
{
backUrl = View.GetPreviousRelativeUrl();
if (!IsValidPreviousUrl(backUrl))
{
backUrl = "";
setBackUrl = false;
}
if (backUrl.StartsWith(RootObject.BaseRepositoryUrl(), StringComparison.InvariantCultureIgnoreCase) && rIdentifier != null)
{
cookieRepository cookie = View.GetRepositoryCookie(rIdentifier);
if (cookie != null)
{
backUrl = RootObject.RepositoryItems(rIdentifier.Type, rIdentifier.IdCommunity, 0, cookie.IdFolder, cookie.Type, cookie.ItemsOrderBy, cookie.Ascending, cookie.IdentifierPath);
}
}
SetLogoutUrl(View.GetCurrentUrl(), setBackUrl, backUrl);
}
else
{
View.DefaultLogoutUrl = View.GetCurrentUrl();
}
View.BackUrl = (setBackUrl ? backUrl : "");
View.SetPageBackUrl(backUrl);
View.PageIdentifier = Guid.NewGuid();
if (SessionTimeout())
{
return;
}
View.IsInitialized = true;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.None;
if (rIdentifier == null)
{
uAction = ModuleRepository.ActionType.MultimedaSettingsTryToLoad;
View.DisplayUnknownItem();
}
else
{
Int32 idCurrentUser = UserContext.CurrentUserID;
liteRepositoryItem item = Service.ItemGet(idItem);
liteRepositoryItemVersion version = Service.ItemGetVersion(idItem, idVersion);
if (version == null)
{
uAction = ModuleRepository.ActionType.MultimedaSettingsTryToLoad;
View.DisplayUnknownItem();
}
else if (version.Type != ItemType.Multimedia)
{
idCommunity = version.IdCommunity;
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.multimediaSettingsInvalidType);
uAction = ModuleRepository.ActionType.MultimedaSettingsInvalidType;
}
else
{
idVersion = version.Id;
View.IdVersion = idVersion;
idCommunity = version.IdCommunity;
if (version.Availability == ItemAvailability.available || version.Availability == ItemAvailability.waitingsettings)
{
ItemPermission permissions = null;
if (idLink == 0)
{
dtoDisplayRepositoryItem dto = Service.GetItemWithPermissions(idItem, idCurrentUser, item.Repository, View.GetUnknownUserName());
if (dto != null)
{
permissions = dto.Permissions;
}
}
else
{
liteModuleLink link = CurrentManager.Get <liteModuleLink>(idLink);
if (link == null)
{
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.multimediaSettingsNoPermission);
}
else
{
permissions = View.GetLinkPermissions(link, idCurrentUser);
idCommunity = link.SourceItem.CommunityID;
}
}
if (permissions != null)
{
if (permissions.EditSettings)
{
if (version.Availability == ItemAvailability.waitingsettings)
{
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.multimediaSettingsNoDefaultDocument);
}
List <dtoMultimediaFileObject> items = Service.MultimediaGetItems(idItem, idVersion);
View.AllowSave = (items != null && items.Any());
View.LoadItems(item.UniqueIdVersion.ToString(), item.DisplayName, items, (items == null ? null : items.Where(i => i.IsDefaultDocument).FirstOrDefault()));
}
else
{
uAction = ModuleRepository.ActionType.MultimedaSettingsNoPermissions;
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.multimediaSettingsNoPermission);
}
}
else
{
uAction = ModuleRepository.ActionType.MultimedaSettingsStatusError;
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.multimediaSettingsInvalidStatus, version.Availability);
}
}
else
{
uAction = ModuleRepository.ActionType.MultimedaSettingsStatusError;
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.multimediaSettingsInvalidStatus, version.Availability);
}
}
View.RepositoryIdentifier = CacheKeys.RepositoryIdentifierKey(rIdentifier.Type, rIdentifier.IdCommunity);
View.RepositoryIdCommunity = rIdentifier.IdCommunity;
View.RepositoryType = rIdentifier.Type;
View.IsInitialized = true;
}
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction);
}
public VersionErrors AddVersionToFile(String istanceIdentifier, long idItem, dtoUploadedItem version, String unknownUser, String repositoryPath, RepositoryIdentifier identifier, Boolean allowManage, Boolean allowView, Boolean updateLinks)
{
VersionErrors error = VersionErrors.unabletoadd;
liteRepositoryItem rItem = ItemGet(idItem);
ModuleRepository.ObjectType oType = ModuleRepository.ObjectType.File;
dtoDisplayRepositoryItem dItem = null;
if (rItem != null)
{
ModuleRepository module = GetPermissions(rItem.Repository, UC.CurrentUserID);
Boolean allowCreate = false;
Int32 idCommunity = rItem.Repository.IdCommunity;
if (rItem.IsInternal)
{
allowCreate = true;
}
else
{
dItem = GetItemWithPermissions(idItem, UC.CurrentUserID, rItem.Repository, unknownUser, allowManage, allowView);
if (dItem == null)
{
error = VersionErrors.unavailableItem;
}
else
{
Boolean allowAdd = dItem.Permissions.GetActions().Contains(ItemAction.addVersion);
oType = ModuleRepository.GetObjectType(dItem.Type);
if (!allowAdd)
{
error = VersionErrors.nopermission;
}
else
{
allowCreate = true;
}
}
}
if (allowCreate)
{
liteRepositorySettings settings = SettingsGetByRepositoryIdentifier(rItem.Repository);
ThumbnailsCreate(settings, rItem.UniqueId, version);
dtoCreatedItem addedVersion = FileAddVersion(settings, module, repositoryPath, istanceIdentifier, idItem, version);
if (addedVersion != null && addedVersion.IsAdded)
{
if (dItem != null)
{
dItem.IdVersion = addedVersion.Added.IdVersion;
dItem.UniqueIdVersion = addedVersion.Added.UniqueIdVersion;
}
if (updateLinks)
{
List <liteModuleLink> links = (from l in GetQuery <liteModuleLink>()
where
l.DestinationItem.ServiceCode == ModuleRepository.UniqueCode &&
l.DestinationItem.ObjectLongID == idItem &&
l.DestinationItem.ObjectIdVersion > 0
select l).ToList();
if (links.Any())
{
links.ForEach(l => l.DestinationItem.ObjectIdVersion = addedVersion.Added.IdVersion);
Manager.SaveOrUpdateList(links);
}
}
error = VersionErrors.none;
}
else
{
error = VersionErrors.unabletoadd;
}
}
}
return(error);
}
