public dtoContainerQuota GetFolderQuota(String repositoryPath, long idFolder, RepositoryType type, Int32 idRepositoryCommunity)
{
liteRepositorySettings settings = SettingsGetDefault(type, idRepositoryCommunity);
ModuleRepository module = GetPermissions(type, idRepositoryCommunity, UC.CurrentUserID);
return(GetFolderQuota(repositoryPath, idFolder, settings, module, type, idRepositoryCommunity));
}
public liteRepositorySettings SettingsGetByRepositoryIdentifier(RepositoryIdentifier item)
{
liteRepositorySettings result = null;
if (item != null)
{
try
{
switch (item.Type)
{
case RepositoryType.Portal:
result = SettingsGetDefault(SettingsGet(s => s.Deleted == DomainModel.BaseStatusDeleted.None && s.Status == ItemStatus.Active && (s.Type == SettingsType.Istance || s.Type == SettingsType.Portal)));
break;
default:
Int32 idOrganization = Manager.GetIdOrganizationFromCommunity(item.IdCommunity);
result = SettingsGetDefault(SettingsGet(s => s.Deleted == DomainModel.BaseStatusDeleted.None && s.Status == ItemStatus.Active && (s.Type == SettingsType.Istance || s.Type == SettingsType.Portal || (s.Type == SettingsType.Organization && s.IdOrganization == idOrganization) || (s.Type == SettingsType.Community && s.IdCommunity == item.IdCommunity))));
break;
}
}
catch (Exception ex)
{
}
}
return(result);
}
private List <dtoModuleActionControl> AnalyzeModuleLinkItem(liteRepositorySettings settings, dtoDisplayObjectRepositoryItem obj, Boolean getOnlyActions, dtoObjectRenderInitializer dto, DisplayActionMode dAction, StandardActionType actionsToDisplay)
{
List <dtoModuleActionControl> actions = new List <dtoModuleActionControl>();
if (obj.Link != null)
{
View.Availability = obj.Availability;
Boolean isReadyToPlay = (obj.Availability == ItemAvailability.available || obj.Availability == ItemAvailability.waitingsettings);
if (!getOnlyActions)
{
if (ValidateActionMode(dAction, DisplayActionMode.text) || ValidateActionMode(dAction, DisplayActionMode.textDefault) || !isReadyToPlay)
{
View.Display = DisplayActionMode.text;
DisplayTextInfo(obj);
}
else if (ValidateActionMode(dAction, DisplayActionMode.defaultAction) || ValidateActionMode(dAction, DisplayActionMode.adminMode))
{
DisplayDefaultAction(settings, obj, dto, dAction);
}
}
if (isReadyToPlay || ValidateActionMode(dAction, DisplayActionMode.adminMode))
{
actions = GenerateActions(settings, obj, dto, dAction);
}
if (ValidateActionMode(dAction, DisplayActionMode.actions) && actionsToDisplay != StandardActionType.None)
{
View.DisplayActions(actions.Where(a => ((int)a.ControlType & (int)actionsToDisplay) > 0).ToList());
}
}
return(actions);
}
public dtoContainerQuota GetFolderQuota(String repositoryPath, long idFolder, RepositoryIdentifier identifier)
{
liteRepositorySettings settings = SettingsGetByRepositoryIdentifier(identifier);
ModuleRepository module = GetPermissions(identifier, UC.CurrentUserID);
return(GetFolderQuota(repositoryPath, idFolder, settings, module, identifier.Type, identifier.IdCommunity));
}
public List <dtoNodeFolderItem> FoldersGetForSelection(String filePath, long idCurrentFolder, Int32 idCurrentUser, RepositoryType type, Int32 idCommunity, ModuleRepository permissions, String unkownUser, String rootFolderName, Boolean forUpload, long sizeToMove = 0, List <long> foldersToRemove = null, Boolean removeCurrent = false, List <dtoFolderTreeItem> folders = null)
{
List <dtoNodeFolderItem> nodes = new List <dtoNodeFolderItem>();
liteRepositorySettings settings = SettingsGetDefault(type, idCommunity);
if (folders == null)
{
folders = GetAllFoldersForSelect(filePath, idCurrentFolder, settings, idCurrentUser, type, idCommunity, permissions, rootFolderName);
}
if (folders != null)
{
Boolean admin = permissions.ManageItems || permissions.Administration;
List <dtoDisplayRepositoryItem> items = GetAvailableRepositoryItems(settings, idCurrentUser, RepositoryIdentifier.Create(type, idCommunity), unkownUser, permissions, admin, admin);
List <long> idAvailable = items.SelectMany(i => i.GetItems(ItemType.Folder, true)).Select(i => i.Id).ToList();
idAvailable.Add(0);
if (removeCurrent)
{
foldersToRemove.Add(idCurrentFolder);
}
if (foldersToRemove != null)
{
idAvailable = idAvailable.Except(foldersToRemove).ToList();
}
folders.ForEach(f => nodes.AddRange(CreateFolderNodes(null, f, sizeToMove, idAvailable, forUpload)));
}
return(nodes);
}
public List <dtoDisplayRepositoryItem> GetAvailableRepositoryItems(
liteRepositorySettings settings,
Int32 idCurrentPerson,
RepositoryType type,
Int32 idCommunity,
String unknownUser,
Dictionary <FolderType, String> fTranslations,
Dictionary <ItemType, String> iTranslations,
ModuleRepository permissions,
Boolean forAdmin = false,
Boolean alsoHidden = false,
Boolean onlyFolder = false,
Boolean useCache = true)
{
return(GetAvailableRepositoryItems(
settings,
idCurrentPerson,
RepositoryIdentifier.Create(type, idCommunity),
unknownUser,
fTranslations,
iTranslations,
permissions,
forAdmin,
alsoHidden,
onlyFolder,
useCache));
}
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);
}
public void ThumbnailsCreate(liteRepositorySettings settings, Guid itemUniqueId, dtoUploadedItem version)
{
if (!String.IsNullOrWhiteSpace(settings.AutoThumbnailForExtension))
{
version.ThumbnailFileName = ThumbnailCreateToDisk(ThumbnailGetItemIdentifier(itemUniqueId, version.UniqueId), version.SavedFullPath, version.ThumbnailPath, settings.AutoThumbnailWidth, settings.AutoThumbnailHeight);
version.AutoThumbnail = !(String.IsNullOrWhiteSpace(version.ThumbnailFileName));
}
}
private void ThumbnailsCreate(liteRepositorySettings settings, List <dtoUploadedItem> itemsToAdd)
{
if (!String.IsNullOrWhiteSpace(settings.AutoThumbnailForExtension))
{
List <String> extensions = settings.AutoThumbnailForExtension.Split(',').Select(e => (e.StartsWith(".") ? e : "." + e)).ToList();
foreach (var f in itemsToAdd.GroupBy(i => i.Extension).Where(e => !String.IsNullOrEmpty(e.Key) && extensions.Contains(e.Key.ToLower())))
{
foreach (dtoUploadedItem item in f.ToList())
{
item.ThumbnailFileName = ThumbnailCreateToDisk(ThumbnailGetItemIdentifier(item), item.SavedFullPath, item.ThumbnailPath, settings.AutoThumbnailWidth, settings.AutoThumbnailHeight);
item.AutoThumbnail = !(String.IsNullOrWhiteSpace(item.ThumbnailFileName));
}
}
}
}
protected List <dtoDisplayRepositoryItem> GetAvailableRepositoryItems(liteRepositorySettings settings, Int32 idCurrentPerson, RepositoryIdentifier identifier, String unknownUser, ModuleRepository permissions, Boolean forAdmin = false, Boolean alsoHidden = false, Boolean onlyFolder = false, Boolean useCache = true)
{
String key = CacheKeys.UserViewOfRepository(idCurrentPerson, identifier, onlyFolder);
List <dtoDisplayRepositoryItem> results = (useCache) ? lm.Comol.Core.DomainModel.Helpers.CacheHelper.Find <List <dtoDisplayRepositoryItem> >(key) : null;
if (results == null || !results.Any())
{
List <dtoRepositoryItem> fItems = GetFullRepository(identifier, unknownUser, useCache);
if (fItems == null)
{
return(null);
}
return(GetRepositoryItemsWithPermissions(settings, UC.CurrentUserID, identifier, fItems, permissions, forAdmin, alsoHidden, onlyFolder, useCache));
}
return(results);
}
public void InitView(Int32 idUploaderUser, RepositoryIdentifier identifier, Boolean allowAnonymousUpload)
{
View.IdUploaderUser = idUploaderUser;
View.RepositoryIdentifier = identifier;
if (identifier == null || (SessionTimeout() && !allowAnonymousUpload))
{
View.DisableControl();
return;
}
liteRepositorySettings settings = Service.SettingsGetByRepositoryIdentifier(identifier);
View.LoadItemTypes(((settings == null || settings.ItemTypes == null) ? new List <ItemType>()
{
ItemType.File
} : settings.ItemTypes.Where(t => t.Deleted == BaseStatusDeleted.None && t.Type != ItemType.Folder && t.Type != ItemType.Link && t.Type != ItemType.RootFolder).Select(t => t.Type).Distinct().ToList()));
}
public void InitView(long idFolder, RepositoryIdentifier identifier, Boolean allowAnonymousUpload, Boolean useAnonymous, Boolean usePublicUser)
{
Int32 idUploaderUser = UserContext.CurrentUserID;
View.RepositoryIdentifier = identifier;
if (identifier == null || (SessionTimeout() && !allowAnonymousUpload))
{
View.DisableControl();
View.DisplayUploadUnavailable();
return;
}
liteRepositorySettings settings = Service.SettingsGetByRepositoryIdentifier(identifier);
if (settings != null)
{
litePerson uploader = CurrentManager.GetLitePerson(idUploaderUser);
if (uploader == null && allowAnonymousUpload)
{
if (useAnonymous)
{
uploader = CurrentManager.GetLiteUnknownUser();
}
else if (usePublicUser)
{
uploader = CurrentManager.GetLitePublicUser(identifier.IdCommunity);
}
}
else if (uploader != null && (uploader.Id == 0 || uploader.TypeID == (int)UserTypeStandard.PublicUser && !usePublicUser))
{
uploader = null;
}
if (uploader != null)
{
View.IdUploaderUser = uploader.Id;
View.LoadItemTypes(((settings.ItemTypes == null) ? new List <ItemType>()
{
ItemType.File
} : settings.ItemTypes.Where(t => t.Deleted == BaseStatusDeleted.None && t.Type != ItemType.Folder && t.Type != ItemType.Link && t.Type != ItemType.RootFolder).Select(t => t.Type).Distinct().ToList()));
InitializeView(idFolder, identifier, Service.GetPermissions(identifier, idUploaderUser), settings, uploader);
}
}
else
{
View.DisableControl();
View.DisplayUploadUnavailable();
}
}
private List <dtoModuleActionControl> AnalyzeActions(Boolean getOnlyActions, dtoObjectRenderInitializer dto, DisplayActionMode dAction, StandardActionType actionsToDisplay)
{
List <dtoModuleActionControl> actions = new List <dtoModuleActionControl>();
if (dto.Link == null || dto.Link.DestinationItem == null)
{
if (getOnlyActions)
{
return(new List <dtoModuleActionControl>());
}
else
{
View.DisplayEmptyAction();
}
}
else
{
if (!getOnlyActions)
{
View.IdRequiredAction = dto.Link.Action;
View.Display = dAction;
}
liteRepositoryItem item = (dto.Link.DestinationItem.ObjectLongID == 0 ? null : Service.ItemGet(dto.Link.DestinationItem.ObjectLongID));
View.ItemType = (item == null ? ItemType.File : item.Type);
liteRepositoryItemVersion version = null;
if (dto.Link.DestinationItem.ObjectIdVersion > 0)
{
version = Service.VersionGet(dto.Link.DestinationItem.ObjectIdVersion);
}
if (!getOnlyActions && item == null)
{
View.DisplayRemovedObject();
}
else if (item != null)
{
liteRepositorySettings settings = Service.SettingsGetByRepositoryIdentifier(item.Repository);
dtoDisplayObjectRepositoryItem obj = Create(dto.Link, item, version);
View.ItemType = obj.Type;
if (dto.PlaceHolders.Where(p => !String.IsNullOrEmpty(p.Text)).Any() && (ValidateActionMode(dAction, DisplayActionMode.defaultAction) || ValidateActionMode(dAction, DisplayActionMode.text)))
{
View.DisplayPlaceHolders(dto.PlaceHolders.Where(p => !String.IsNullOrEmpty(p.Text)).ToList());
}
actions = AnalyzeModuleLinkItem(settings, obj, getOnlyActions, dto, dAction, actionsToDisplay);
}
}
return(actions);
}
public dtoContainerQuota FolderGetHomeAvailableSize(String filePath, liteRepositorySettings settings, ModuleRepository module, RepositoryIdentifier identifier)
{
dtoContainerQuota container = null;
try
{
IEnumerable <liteRepositoryItem> query = GetQuery(identifier);
long usedSize = query.Where(i => i.Deleted == BaseStatusDeleted.None).Select(i => i.Size + i.DeletedSize + i.VersionsSize).DefaultIfEmpty(0).Sum();
usedSize += query.Where(i => i.Deleted == BaseStatusDeleted.Manual).Select(i => i.DeletedSize).DefaultIfEmpty(0).Sum();
container = CalculateRepositoryMaxSize(filePath, settings, IsValidAdministrator(UC.CurrentUserID));
container.UsedSize = usedSize;
}
catch (Exception ex)
{
}
return(container);
}
public List <dtoModuleUploadedItem> FileAddToInternalRepository(liteRepositorySettings settings, String istance, RepositoryIdentifier identifier, litePerson person, Boolean alwaysLastVersion, List <dtoUploadedItem> itemsToAdd, Object obj, long idObject, Int32 idObjectType, String moduleCode, Int32 idModuleAjaxAction, Int32 idModuleAction = 0)
{
List <dtoModuleUploadedItem> files = null;
ThumbnailsCreate(settings, itemsToAdd);
files = FileAddToRepository(settings, istance, identifier, person, alwaysLastVersion, itemsToAdd, obj, idObject, idObjectType, moduleCode, idModuleAjaxAction, idModuleAction);
if (files == null)
{
itemsToAdd.Where(i => i.IsValid).ToList().ForEach(i => lm.Comol.Core.File.Delete.File(i.SavedFullPath));
itemsToAdd.Where(i => i.IsValid && i.HasThumbnail).ToList().ForEach(i => lm.Comol.Core.File.Delete.File(i.ThumbnailFullPath));
}
else if (files.Any(f => !f.IsAdded))
{
files.Where(f => !f.IsAdded).ToList().ForEach(f => lm.Comol.Core.File.Delete.File(f.UploadedFile.SavedFullPath));
files.Where(f => !f.IsAdded && f.UploadedFile.HasThumbnail).ToList().ForEach(i => lm.Comol.Core.File.Delete.File(i.UploadedFile.ThumbnailFullPath));
}
return(files);
}
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);
}
public List <dtoModuleUploadedItem> AddModuleInternalFiles(String istance, Int32 idUploaderUser, Boolean allowAnonymousUpload, RepositoryIdentifier identifier, List <dtoUploadedItem> items, Object obj, long idObject, Int32 idObjectType, String moduleCode, Int32 idModuleAjaxAction, Int32 idModuleAction = 0)
{
List <dtoModuleUploadedItem> addedFiles = new List <dtoModuleUploadedItem>();
if (!SessionTimeout() || allowAnonymousUpload)
{
litePerson person = (idUploaderUser > 0 ? CurrentManager.GetLitePerson(idUploaderUser) : null);
if (person == null && allowAnonymousUpload)
{
person = CurrentManager.GetLiteUnknownUser();
}
if (person != null)
{
liteRepositorySettings settings = Service.SettingsGetByRepositoryIdentifier(identifier);
addedFiles = Service.FileAddToInternalRepository(settings, istance, identifier, person, allowAnonymousUpload, items, obj, idObject, idObjectType, moduleCode, idModuleAjaxAction, idModuleAction);
}
}
return(addedFiles);
}
public dtoCreatedItem FileAddVersion(liteRepositorySettings settings, ModuleRepository module, String filePath, String istance, long idItem, dtoUploadedItem version)
{
dtoCreatedItem result = null;
if (version.IsValid)
{
RepositoryItem item = Manager.Get <RepositoryItem>(idItem);
if (item != null && item.Type != ItemType.Folder)
{
List <RepositoryItem> repositoryItems = GetFullQuery(item.Repository.Type, item.Repository.IdCommunity).ToList();
dtoFolderTreeItem dFolder = FolderGetSizeInfoByFathers(item.IdFolder, repositoryItems, settings, module, filePath, item.Repository.IdCommunity);
if (dFolder != null)
{
result = FileAddVersion(settings, item, version, dFolder, istance, repositoryItems);
}
}
else
{
result = new dtoCreatedItem()
{
ToAdd = version, Error = ItemUploadError.UnableToFindFile
}
};
}
else
{
result = new dtoCreatedItem()
{
ToAdd = version, Error = ItemUploadError.UnableToSaveVersion
}
};
if (result == null && version.IsValid || (result != null && result.IsValid && !result.IsAdded))
{
lm.Comol.Core.File.Delete.File(version.SavedFullPath);
if (version.HasThumbnail)
{
lm.Comol.Core.File.Delete.File(version.ThumbnailFullPath);
}
}
return(result);
}
public liteRepositorySettings SettingsGetDefault(lm.Comol.Core.FileRepository.Domain.RepositoryType type, Int32 idCommunity = -1)
{
liteRepositorySettings result = null;
switch (type)
{
case RepositoryType.Portal:
result = SettingsGetDefault(SettingsGet(s => s.Deleted == DomainModel.BaseStatusDeleted.None && s.Status == ItemStatus.Active && (s.Type == SettingsType.Istance || s.Type == SettingsType.Portal)));
break;
default:
if (idCommunity == -1)
{
idCommunity = UC.CurrentCommunityID;
}
Int32 idOrganization = Manager.GetIdOrganizationFromCommunity(idCommunity);
result = SettingsGetDefault(SettingsGet(s => s.Deleted == DomainModel.BaseStatusDeleted.None && s.Status == ItemStatus.Active && (s.Type == SettingsType.Istance || s.Type == SettingsType.Portal || (s.Type == SettingsType.Organization && s.IdOrganization == idOrganization) || (s.Type == SettingsType.Community && s.IdCommunity == idCommunity))));
break;
}
return(result);
}
public List <dtoFolderSize> GetRepositoryAvailabilityInfo(String filePath, liteRepositorySettings settings, Int32 idCurrentUser, RepositoryType type, Int32 idCommunity, ModuleRepository permissions, List <dtoDisplayRepositoryItem> treeItems, Boolean useCache = true)
{
String key = CacheKeys.UserSizeOfRepository(idCurrentUser, type, idCommunity);
List <dtoFolderSize> fItems = (useCache) ? lm.Comol.Core.DomainModel.Helpers.CacheHelper.Find <List <dtoFolderSize> >(key) : null;
if (fItems == null || !fItems.Any())
{
fItems = new List <dtoFolderSize>();
List <liteRepositoryItem> items = GetQuery(type, idCommunity).ToList();
fItems.Add(GetRepositoryAvailabilityInfo(filePath, (settings != null && settings.DiskSpace != null) ? settings.DiskSpace : null, items, GetAllItems(treeItems.AsQueryable(), i => (i.Type != ItemType.Folder || i.FolderType == FolderType.standard))));
foreach (dtoDisplayRepositoryItem folder in treeItems.Where(f => f.Type == ItemType.Folder))
{
fItems.AddRange(GetFolderAvailabilityInfo(fItems[0], fItems[0], folder, items));
}
if (fItems != null)
{
CacheHelper.AddToCache <List <dtoFolderSize> >(key, fItems, CacheExpiration.Day);
}
}
return(fItems);
}
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 <dtoDisplayRepositoryItem> GetAvailableRepositoryItems(
liteRepositorySettings settings,
Int32 idCurrentPerson,
RepositoryIdentifier identifier,
String unknownUser,
Dictionary <FolderType, String> fTranslations,
Dictionary <ItemType, String> iTranslations,
ModuleRepository permissions,
Boolean forAdmin = false,
Boolean alsoHidden = false,
Boolean onlyFolder = false,
Boolean useCache = true)
{
String key = CacheKeys.UserViewOfRepository(idCurrentPerson, identifier, onlyFolder);
List <dtoDisplayRepositoryItem> results = (useCache) ? lm.Comol.Core.DomainModel.Helpers.CacheHelper.Find <List <dtoDisplayRepositoryItem> >(key) : null;
if (results == null || !results.Any())
{
results = new List <dtoDisplayRepositoryItem>();
List <dtoRepositoryItem> fItems = GetFullRepository(identifier, unknownUser, useCache);
if (fItems == null)
{
return(null);
}
List <dtoDisplayRepositoryItem> items = GetRepositoryItemsWithPermissions(settings, UC.CurrentUserID, identifier, fItems, permissions, forAdmin, alsoHidden, onlyFolder, useCache);
results.AddRange(items);
if (permissions.Administration || permissions.ManageItems || permissions.DeleteMyFiles)
{
results.Add(GetRecycleBinFolder(fTranslations[FolderType.recycleBin], items));
}
if (results != null && useCache)
{
CacheHelper.AddToCache <List <dtoDisplayRepositoryItem> >(key, results, CacheExpiration.Day);
}
}
return(results);
}
public List <dtoModuleUploadedItem> FileAddToRepository(liteRepositorySettings settings, String istance, RepositoryIdentifier identifier, litePerson person, Boolean alwaysLastVersion, ModuleRepository module, String filePath, long idFolder, List <dtoUploadedItem> itemsToAdd, Object obj, long idObject, Int32 idObjectType, String moduleCode, Int32 idModuleAjaxAction, Int32 idModuleAction = 0)
{
List <dtoModuleUploadedItem> files = null;
List <RepositoryItem> repositoryItems = GetFullQuery(identifier).ToList();
dtoFolderTreeItem dFolder = FolderGetSizeInfoByFathers(idFolder, repositoryItems, settings, module, filePath, identifier.IdCommunity);
if (dFolder != null)
{
ThumbnailsCreate(settings, itemsToAdd);
files = FileAddToRepository(settings, istance, identifier, person, alwaysLastVersion, idFolder, dFolder, repositoryItems, itemsToAdd, obj, idObject, idObjectType, moduleCode, idModuleAjaxAction, idModuleAction);
}
if (files == null)
{
itemsToAdd.Where(i => i.IsValid).ToList().ForEach(i => lm.Comol.Core.File.Delete.File(i.SavedFullPath));
itemsToAdd.Where(i => i.IsValid && i.HasThumbnail).ToList().ForEach(i => lm.Comol.Core.File.Delete.File(i.ThumbnailFullPath));
}
else if (files.Any(f => !f.IsAdded))
{
files.Where(f => !f.IsAdded).ToList().ForEach(f => lm.Comol.Core.File.Delete.File(f.UploadedFile.SavedFullPath));
files.Where(f => !f.IsAdded && f.UploadedFile.HasThumbnail).ToList().ForEach(i => lm.Comol.Core.File.Delete.File(i.UploadedFile.ThumbnailFullPath));
}
return(files);
}
public List <dtoCreatedItem> FileAddToRepository(liteRepositorySettings settings, ModuleRepository module, String filePath, String istance, long idFolder, List <dtoUploadedItem> itemsToAdd, RepositoryType type, Int32 idCommunity)
{
List <dtoCreatedItem> files = null;
List <RepositoryItem> repositoryItems = GetFullQuery(type, idCommunity).ToList();
dtoFolderTreeItem dFolder = FolderGetSizeInfoByFathers(idFolder, repositoryItems, settings, module, filePath, idCommunity);
if (dFolder != null)
{
ThumbnailsCreate(settings, itemsToAdd);
files = FileAddToRepository(settings, dFolder, istance, idFolder, repositoryItems, itemsToAdd, type, idCommunity);
}
if (files == null)
{
itemsToAdd.Where(i => i.IsValid).ToList().ForEach(i => lm.Comol.Core.File.Delete.File(i.SavedFullPath));
itemsToAdd.Where(i => i.IsValid && i.HasThumbnail).ToList().ForEach(i => lm.Comol.Core.File.Delete.File(i.ThumbnailFullPath));
}
else if (files.Any(f => !f.IsAdded))
{
files.Where(f => !f.IsAdded).ToList().ForEach(f => lm.Comol.Core.File.Delete.File(f.ToAdd.SavedFullPath));
files.Where(f => !f.IsAdded && f.ToAdd.HasThumbnail).ToList().ForEach(i => lm.Comol.Core.File.Delete.File(i.ToAdd.ThumbnailFullPath));
}
return(files);
}
public List <dtoFolderSize> GetRepositoryAvailabilityInfo(String filePath, liteRepositorySettings settings, Int32 idCurrentPerson, RepositoryType type, Int32 idCommunity, String unknownUser, Dictionary <FolderType, String> fTranslations, Dictionary <ItemType, String> iTranslations, ModuleRepository permissions, Boolean forAdmin = false, Boolean alsoHidden = false, Boolean onlyFolder = false, Boolean useCache = true)
{
Boolean admin = permissions.ManageItems || permissions.Administration;
return(GetRepositoryAvailabilityInfo(
filePath,
settings,
idCurrentPerson,
type,
idCommunity,
permissions,
GetAvailableRepositoryItems(
settings,
idCurrentPerson,
type,
idCommunity,
unknownUser,
fTranslations,
iTranslations,
permissions,
admin,
admin),
useCache));
}
private List <dtoModuleActionControl> GenerateActions(liteRepositorySettings settings, dtoDisplayObjectRepositoryItem obj, dtoObjectRenderInitializer dto, DisplayActionMode dAction)
{
List <dtoModuleActionControl> actions = new List <dtoModuleActionControl>();
Int32 idModule = obj.Link.SourceItem.ServiceID;
String moduleCode = obj.Link.SourceItem.ServiceCode;
String baseUrl = View.GetIstanceFullUrl();
Boolean notSaveStat = (dAction == DisplayActionMode.adminMode);
DisplayMode mode = View.OverrideItemDisplayMode;
if (mode == DisplayMode.none)
{
mode = obj.DisplayMode;
}
switch (obj.Type)
{
case ItemType.Link:
actions.Add(new dtoModuleActionControl(View.SanitizeLinkUrl(obj.Url), StandardActionType.Play, true));
actions.Add(new dtoModuleActionControl(View.SanitizeLinkUrl(obj.Url), StandardActionType.DownloadItem, true));
break;
case ItemType.File:
if (obj.Availability == ItemAvailability.available)
{
actions.Add(new dtoModuleActionControl(RootObject.DownloadFromModule(baseUrl, obj.IdItem, obj.IdVersion, obj.DisplayName, mode, UserContext.WorkSessionID.ToString(), ((long)idModule), obj.Link.Id, (!dto.SaveObjectStatistics || notSaveStat)), StandardActionType.Play, true));
actions.Add(new dtoModuleActionControl(RootObject.DownloadFromModule(baseUrl, obj.IdItem, obj.IdVersion, obj.DisplayName, mode, UserContext.WorkSessionID.ToString(), ((long)idModule), obj.Link.Id, (!dto.SaveObjectStatistics || notSaveStat)), StandardActionType.DownloadItem, true));
}
break;
case ItemType.Multimedia:
case ItemType.ScormPackage:
if (obj.Availability == ItemAvailability.available)
{
Boolean onModalPage = dto.ForceOnModalPage || (mode == DisplayMode.downloadOrPlayOrModal || mode == DisplayMode.inModal);
Boolean setPrevious = dto.SetPreviousPage;
String backUrl = (setPrevious ? View.DestinationUrl : "");
setPrevious = setPrevious && !String.IsNullOrEmpty(backUrl);
String url = baseUrl + RootObject.PlayFromModule(obj.IdItem, obj.UniqueId, obj.IdVersion, obj.UniqueIdVersion, obj.Type, obj.Link.Id, UserContext.Language.Code, (!dto.SaveObjectStatistics || notSaveStat), dto.RefreshContainerPage, onModalPage, dto.SaveOwnerStatistics, setPrevious, backUrl);
actions.Add(new dtoModuleActionControl(url, StandardActionType.Play, !onModalPage)
{
OnModalPage = onModalPage, RefreshContainerPage = dto.RefreshContainerPage, SaveLinkStatistics = dto.SaveObjectStatistics
});
if (obj.Type == ItemType.ScormPackage)
{
actions.Add(new dtoModuleActionControl(baseUrl + RootObject.Statistics(ItemStatisticType.Scorm, obj.IdItem, obj.Link.DestinationItem.ObjectIdVersion, obj.Link.Id), StandardActionType.ViewAdvancedStatistics, false));
actions.Add(new dtoModuleActionControl(baseUrl + RootObject.UserStatistics(ItemStatisticType.Scorm, UserContext.CurrentUserID, obj.IdItem, obj.Link.DestinationItem.ObjectIdVersion, obj.Link.Id), StandardActionType.ViewUserStatistics, false));
actions.Add(new dtoModuleActionControl(baseUrl + RootObject.MyStatistics(ItemStatisticType.Scorm, obj.IdItem, obj.Link.DestinationItem.ObjectIdVersion, obj.Link.Id), StandardActionType.ViewPersonalStatistics, false));
}
}
if (obj.Availability == ItemAvailability.available || obj.Availability == ItemAvailability.waitingsettings)
{
switch (obj.Type)
{
case ItemType.Multimedia:
if (obj.Item.IsInternal)
{
actions.Add(new dtoModuleActionControl(baseUrl + RootObject.EditMultimediaSettings(obj.IdItem, obj.Link.DestinationItem.ObjectIdVersion, obj.Link.Id), StandardActionType.EditMetadata, false));
}
else
{
actions.Add(new dtoModuleActionControl(baseUrl + RootObject.EditMultimediaSettings(obj.IdItem, obj.Link.DestinationItem.ObjectIdVersion, obj.Item.IdFolder, ""), StandardActionType.EditMetadata, false));
}
break;
default:
if (obj.Item.IsInternal)
{
actions.Add(new dtoModuleActionControl(baseUrl + RootObject.EditScormSettings(obj.IdItem, obj.Link.DestinationItem.ObjectIdVersion, obj.Link.Id), StandardActionType.EditMetadata, false));
}
else
{
actions.Add(new dtoModuleActionControl(baseUrl + RootObject.EditScormSettings(obj.IdItem, obj.Link.DestinationItem.ObjectIdVersion, obj.Item.IdFolder, ""), StandardActionType.EditMetadata, false));
}
break;
}
}
if (obj.Availability == ItemAvailability.available && obj.IsDownlodable)
{
actions.Add(new dtoModuleActionControl(RootObject.DownloadFromModule(baseUrl, obj.IdItem, obj.Link.DestinationItem.ObjectIdVersion, obj.DisplayName, mode, UserContext.WorkSessionID.ToString(), ((long)idModule), obj.Link.Id, (!dto.SaveObjectStatistics || notSaveStat)), StandardActionType.DownloadItem, true));
}
break;
case ItemType.Folder:
break;
}
return(actions);
}
private void DisplayDefaultAction(
liteRepositorySettings settings,
dtoDisplayObjectRepositoryItem obj,
dtoObjectRenderInitializer dto,
DisplayActionMode dAction)
{
Int32 idModule = obj.Link.SourceItem.ServiceID;
String moduleCode = obj.Link.SourceItem.ServiceCode;
View.SourceIdModule = idModule;
View.SourceModuleCode = moduleCode;
Int32 idCommunity = obj.Item.IdCommunity;
Boolean notSaveStat = (dAction == DisplayActionMode.adminMode);
DisplayMode mode = View.OverrideItemDisplayMode;
if (mode == DisplayMode.none)
{
mode = obj.DisplayMode;
}
switch (obj.Link.Action)
{
case (int)ModuleRepository.ActionType.AddFolder:
case (int)ModuleRepository.ActionType.AddFile:
case (int)ModuleRepository.ActionType.AddLink:
case (int)ModuleRepository.ActionType.AddInternalFile:
View.DisplayActiveAction(obj.Name, ((ModuleRepository.ActionType)obj.Link.Action));
break;
case (int)ModuleRepository.ActionType.DownloadFile:
switch (obj.Type)
{
case ItemType.Link:
View.DisplayActiveAction(obj, mode, obj.Url, dto.RefreshContainerPage, false, dto.SaveObjectStatistics, dto.SaveOwnerStatistics);
break;
default:
if (obj.Item.IsDownloadable)
{
View.DisplayActiveAction(
obj,
mode,
RootObject.DownloadFromModule(
"",
obj.IdItem,
obj.IdVersion,
obj.DisplayName,
mode,
UserContext.WorkSessionID.ToString(),
((long)idModule),
obj.Link.Id,
(!dto.SaveObjectStatistics || notSaveStat)),
dto.RefreshContainerPage,
false,
dto.SaveObjectStatistics,
dto.SaveOwnerStatistics);
}
else
{
DisplayTextInfo(obj);
}
break;
}
break;
case (int)ModuleRepository.ActionType.PlayFile:
String url = "";
switch (obj.Type)
{
case ItemType.Multimedia:
case ItemType.ScormPackage:
Boolean onModalPage = dto.ForceOnModalPage || (mode == DisplayMode.downloadOrPlayOrModal || mode == DisplayMode.inModal);
Boolean setPrevious = dto.SetPreviousPage;
String backUrl = (setPrevious ? View.DestinationUrl : "");
setPrevious = setPrevious && !String.IsNullOrEmpty(backUrl);
url = RootObject.PlayFromModule(obj.IdItem, obj.UniqueId, obj.IdVersion, obj.UniqueIdVersion, obj.Type, obj.Link.Id, UserContext.Language.Code, (!dto.SaveObjectStatistics || notSaveStat), dto.RefreshContainerPage, onModalPage, dto.SaveOwnerStatistics, setPrevious, backUrl);
View.DisplayActiveAction(obj, mode, url, dto.RefreshContainerPage, onModalPage, dto.SaveObjectStatistics, dto.SaveOwnerStatistics);
break;
case ItemType.Link:
View.DisplayActiveAction(obj, mode, obj.Url, dto.RefreshContainerPage, false, dto.SaveObjectStatistics, dto.SaveOwnerStatistics);
break;
default:
DisplayTextInfo(obj);
break;
}
break;
}
}
private dtoContainerQuota CalculateRepositoryMaxSize(String filePath, liteRepositorySettings settings, Boolean overrideQuota, long usedSize = 0)
{
return(CalculateRepositoryMaxSize(filePath, (settings != null ? settings.DiskSpace : null), overrideQuota, usedSize));
}
public dtoContainerQuota FolderGetHomeAvailableSize(String filePath, liteRepositorySettings settings, ModuleRepository module, RepositoryType type, Int32 idCommunity)
{
return(FolderGetHomeAvailableSize(filePath, settings, module, RepositoryIdentifier.Create(type, idCommunity)));
}
public dtoFolderTreeItem FolderGetSizeInfoByFathers(long idFolder, IEnumerable <RepositoryItem> repositoryItems, liteRepositorySettings settings, ModuleRepository module, String filePath, Int32 idCommunity)
{
return(CreateRootFolderTreeItem(filePath, idFolder, repositoryItems.Where(i => i.IdFolder == 0), settings.DiskSpace, module));
}
