private List <dtoNodeFolderItem> CreateFolderNodes(dtoNodeFolderItem father, dtoFolderTreeItem folder, long sizeToMove, List <long> idAvailable, Boolean forUpload)
{
List <dtoNodeFolderItem> results = new List <dtoNodeFolderItem>();
dtoNodeFolderItem cNode = CreateItemNode(father, folder, sizeToMove, idAvailable, forUpload);
dtoNodeFolderItem openNode = CreateOpenNode(cNode, folder.Children.Any());
results.Add(openNode);
results.Add(cNode);
if (folder.Children.Any(c => idAvailable.Contains(c.Id)))
{
results.Add(new dtoNodeFolderItem()
{
Type = NodeType.OpenChildren
});
folder.Children.Where(c => idAvailable.Contains(c.Id)).ToList().ForEach(n => results.AddRange(CreateFolderNodes(openNode, n, sizeToMove, idAvailable, forUpload)));
results.Add(new dtoNodeFolderItem()
{
Type = NodeType.CloseChildren
});
}
results.Add(new dtoNodeFolderItem()
{
Type = NodeType.CloseNode
});
return(results);
}
private dtoFolderTreeItem CreateRootFolderTreeItem(String filePath, long idCurrentFolder, IEnumerable <RepositoryItem> items, DiskSettings diskSpace, ModuleRepository permissions)
{
dtoFolderTreeItem root = new dtoFolderTreeItem()
{
Id = 0, IsHome = true, Name = "", IsCurrent = (idCurrentFolder == 0)
};
if (items.Any(i => i.Type != ItemType.Link && i.Deleted == BaseStatusDeleted.None))
{
root.Size = items.Where(i => i.Type != ItemType.Link && i.Deleted == BaseStatusDeleted.None).Select(i => i.Size).Sum();
}
if (items.Any(i => i.Deleted != BaseStatusDeleted.None))
{
root.DeletedSize = items.Where(i => i.Deleted == BaseStatusDeleted.Manual).Select(i => i.Size + i.VersionsSize).Sum();
}
if (items.Any(i => i.Type == ItemType.Folder && i.Deleted == BaseStatusDeleted.None && i.DeletedSize > 0))
{
root.DeletedSize += items.Where(i => i.Type == ItemType.Folder && i.Deleted == BaseStatusDeleted.None && i.DeletedSize > 0).Select(i => i.DeletedSize).Sum();
}
if (items.Any(i => i.Deleted == BaseStatusDeleted.None && i.HasVersions))
{
root.VersionsSize = items.Where(i => i.Deleted == BaseStatusDeleted.None && i.Type != ItemType.Folder && i.HasVersions).Select(i => i.VersionsSize).Sum();
}
root.Quota = CalculateRepositoryMaxSize(filePath, diskSpace, IsValidAdministrator(UC.CurrentUserID), root.FullSize);
root.UploadAvailable = root.MoveIntoAvailable && (permissions.Administration || permissions.ManageItems || permissions.UploadFile || permissions.EditOthersFiles);
return(root);
}
public dtoContainerQuota GetFolderQuota(String repositoryPath, long idFolder, liteRepositorySettings settings, ModuleRepository module, RepositoryType type, Int32 idRepositoryCommunity)
{
List <RepositoryItem> repositoryItems = GetFullQuery(type, idRepositoryCommunity).ToList();
dtoFolderTreeItem dFolder = FolderGetSizeInfoByFathers(idFolder, repositoryItems, settings, module, repositoryPath, idRepositoryCommunity);
return((dFolder == null) ? null : dFolder.Quota);
}
private dtoNodeFolderItem CreateItemNode(dtoNodeFolderItem father, dtoFolderTreeItem folder, long sizeToMove, List <long> idAvailable, Boolean forUpload)
{
dtoNodeFolderItem node = new dtoNodeFolderItem()
{
Type = NodeType.Item, IsCurrent = folder.IsCurrent
};
node.Id = folder.Id;
node.Name = folder.Name;
node.IsHome = folder.IsHome;
node.Selected = folder.IsCurrent;
node.Selectable = (sizeToMove == 0 || folder.ValidateSpace(sizeToMove, forUpload));
return(node);
}
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);
}
private dtoFolderTreeItem CreateFolderTreeItemByFathers(List <long> idFolders, RepositoryItem fItem, long idCurrentFolder, IEnumerable <RepositoryItem> items, dtoFolderTreeItem father, ModuleRepository permissions)
{
dtoFolderTreeItem folder = new dtoFolderTreeItem()
{
Id = fItem.Id, Name = fItem.Name, IsCurrent = (idCurrentFolder == fItem.Id), IsInCurrentPath = (father.IsCurrent || father.IsInCurrentPath || (idCurrentFolder == fItem.Id))
};
folder.Size = fItem.Size;
folder.VersionsSize = fItem.VersionsSize;
folder.DeletedSize = fItem.DeletedSize;
folder.Quota = dtoContainerQuota.Create(father.Quota, folder.FullSize);
folder.UploadAvailable = folder.MoveIntoAvailable && (permissions.Administration || permissions.ManageItems || permissions.UploadFile || permissions.EditOthersFiles || fItem.AllowUpload);
foreach (RepositoryItem child in items.Where(i => idFolders.Contains(i.Id) && i.Deleted == BaseStatusDeleted.None && i.Type == ItemType.Folder && i.IdFolder == folder.Id))
{
folder.Children.Add(CreateFolderTreeItemByFathers(idFolders, child, idCurrentFolder, items, folder, permissions));
}
return(folder);
}
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 <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);
}
private List <dtoFolderTreeItem> GetAllFoldersForSelect(String filePath, long idCurrentFolder, liteRepositorySettings settings, Int32 idCurrentUser, RepositoryType type, Int32 idCommunity, ModuleRepository permissions, String rootFolderName)
{
List <dtoFolderTreeItem> folders = new List <dtoFolderTreeItem>();
try
{
if (settings != null)
{
List <liteRepositoryItem> items = GetQuery(type, idCommunity).ToList();
dtoFolderTreeItem root = CreateRootFolderTreeItem(filePath, idCurrentFolder, items.Where(i => i.IdFolder == 0), settings.DiskSpace, permissions);
root.Name = rootFolderName;
folders.Add(root);
foreach (liteRepositoryItem fItem in items.Where(i => i.Type == ItemType.Folder && i.IdFolder == 0 && i.Deleted == BaseStatusDeleted.None).OrderBy(i => i.Name).ThenBy(i => i.Id))
{
root.Children.Add(CreateFolderTreeItem(fItem, idCurrentFolder, items.Where(i => i.IdFolder != 0), root, permissions));
}
}
}
catch (Exception ex)
{
folders = null;
}
return(folders);
}
public List <dtoModuleUploadedItem> FileAddToRepository(liteRepositorySettings settings, String istance, RepositoryIdentifier identifier, litePerson person, Boolean alwaysLastVersion, long idFolder, dtoFolderTreeItem folderQuota, IEnumerable <RepositoryItem> rpItems, List <dtoUploadedItem> itemsToAdd, Object obj, long idObject, Int32 idObjectType, String moduleCode, Int32 idModuleAjaxAction, Int32 idModuleAction = 0)
{
List <dtoModuleUploadedItem> files = null;
Boolean isInTransaction = Manager.IsInTransaction();
try
{
if (person != null)
{
DateTime date = DateTime.Now;
files = new List <dtoModuleUploadedItem>();
List <String> brothersFile = rpItems.Where(i => i.IdFolder == idFolder && i.Type != ItemType.Link && i.Type != ItemType.Folder && i.Deleted == BaseStatusDeleted.None).Select(f => f.DisplayName).ToList();
RepositoryItem father = rpItems.FirstOrDefault(i => i.Id == idFolder);
List <RepositoryItem> fathers = (idFolder == 0) ? new List <RepositoryItem>() : GetFullReverseFathers(idFolder, rpItems);
files.AddRange(itemsToAdd.Where(i => !i.IsValid).Select(i => new dtoModuleUploadedItem()
{
UploadedFile = i, Error = ItemUploadError.UnableToSaveFile
}).ToList());
Int32 idModule = Manager.GetModuleID(moduleCode);
Dictionary <ItemType, Boolean> defaultDownload = settings.GetDefaultAllowDownload();
Dictionary <ItemType, DisplayMode> defaultDisplayMode = settings.GetDefaultDisplayMode();
List <litePlayerSettings> players = (itemsToAdd.Any(i => i.IsValid && (i.Type == ItemType.Multimedia || i.Type == ItemType.ScormPackage || i.Type == ItemType.VideoStreaming)) ? PlayerGetSettings() : null);
foreach (dtoUploadedItem dto in itemsToAdd.Where(i => i.IsValid))
{
Boolean allowedByQuota = false;
ItemUploadError error = ItemUploadError.None;
RepositoryItem item = null;
RepositoryItemVersion version = null;
allowedByQuota = folderQuota.ValidateSpace(dto.Size, true);
if (allowedByQuota)
{
if (idFolder == 0 || father != null)
{
long displayOrder = GetCurrentDisplayOrder(idFolder, rpItems);
if (ItemHasDuplicate(brothersFile, dto.Name, ItemType.File, dto.Extension))
{
dto.OriginalName = dto.DisplayName;
dto.Name = ItemGetSuggestedName(brothersFile, dto.Name, ItemType.File, dto.Extension);
}
try
{
var queryAssignments = GetQueryAssignments(identifier).Where(a => a.Deleted == BaseStatusDeleted.None && a.Inherited);
if (!isInTransaction)
{
Manager.BeginTransaction();
}
item = RepositoryItem.CreateFile(idFolder, dto, defaultDownload[dto.Type], defaultDisplayMode[dto.Type], person, date, UC.IpAddress, UC.ProxyIpAddress, identifier);
item.DisplayOrder = displayOrder;
item.Thumbnail = dto.ThumbnailFileName;
if (!String.IsNullOrWhiteSpace(dto.ThumbnailFileName))
{
item.AutoThumbnail = true;
item.DisplayMode = DisplayMode.downloadOrPlayOrModal;
}
switch (item.Type)
{
case ItemType.VideoStreaming:
case ItemType.ScormPackage:
case ItemType.Multimedia:
item.IdPlayer = (players != null ? players.Where(p => p.Type == item.Type && p.EnableForUse && p.EnableForPlay).OrderByDescending(p => p.Id).Select(p => p.Id).FirstOrDefault() : 0);
break;
}
Manager.SaveOrUpdate(item);
version = item.CreateFirstVersion();
Manager.SaveOrUpdate(version);
item.IdVersion = version.Id;
Manager.SaveOrUpdate(item);
switch (item.Type)
{
case ItemType.VideoStreaming:
case ItemType.ScormPackage:
case ItemType.Multimedia:
FileTransferAdd(item, dto, person, date);
break;
}
if (!isInTransaction)
{
Manager.Commit();
}
if (!isInTransaction)
{
brothersFile.Add(dto.Name);
dto.Id = item.Id;
}
folderQuota.Size += item.Size;
if (fathers != null && fathers.Any())
{
isInTransaction = isInTransaction || isInTransaction;
if (!isInTransaction)
{
Manager.BeginTransaction();
}
RecalculateFatherSize(fathers, item.Size, item.VersionsSize, person.Id, date);
if (!isInTransaction)
{
Manager.Commit();
}
}
long permissions = (long)ModuleRepository.Base2Permission.DownloadOrPlay;
ItemAssignments assignment = AssignmentAddCommunity(item.Id, item.Repository, item.IdCommunity, false, false, permissions, person, date);
if (idFolder == 0)
{
assignment = AssignmentAddCommunity(item.Id, item.Repository, item.IdCommunity, false, true, permissions, person, date);
}
else
{
ApplyInheritedAssignment(item, GetQuery <ItemAssignments>().Where(a => a.Deleted == BaseStatusDeleted.None && a.Inherited), permissions, person, date);
}
if (isInTransaction)
{
brothersFile.Add(dto.Name);
dto.Id = item.Id;
}
}
catch (Exception ex)
{
if (!isInTransaction)
{
Manager.RollBack();
}
if (item != null && dto.Id == 0)
{
item = null;
}
}
}
else
{
error = ItemUploadError.UnableToAddFileToUnknownFolder;
}
}
else if (folderQuota.ValidateUploadSize(dto.Size))
{
error = ItemUploadError.UnavailableRepositorySpace;
}
else
{
error = ItemUploadError.InvalidFileSize;
}
if (item != null)
{
files.Add(new dtoModuleUploadedItem()
{
Link = CreateModuleAction((Int32)ModuleRepository.Base2Permission.DownloadOrPlay, alwaysLastVersion, Manager.Get <liteRepositoryItem>(item.Id), idModule), ItemAdded = Manager.Get <liteRepositoryItem>(item.Id), VersionAdded = (version != null ? Manager.Get <liteRepositoryItemVersion>(version.Id) : null), UploadedFile = dto, Error = error
});
}
else
{
files.Add(new dtoModuleUploadedItem()
{
UploadedFile = dto, Error = error
});
}
}
if (files.Any(i => i.IsValid && i.IsAdded && (i.ItemAdded.Type == ItemType.Multimedia || i.ItemAdded.Type == ItemType.VideoStreaming || i.ItemAdded.Type == ItemType.ScormPackage)))
{
FileTransferNotifyToTransferService(istance);
}
if (files.Any(i => i.IsAdded))
{
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(CacheKeys.Repository(identifier));
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(CacheKeys.UsersViewOfRepository(identifier));
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(CacheKeys.UsersSizeViewOfRepository(identifier));
}
}
}
catch (Exception ex)
{
}
return(files);
}
