private ICollection <IFolderContent> GetSubs(IFolderContent folderContent)
{
void GetAllSubs(IFolderContent fc, ICollection <IFolderContent> subs)
{
subs.Add(fc);
if (fc.Type != FolderContentType.Folder)
{
return;
}
var folder = _folderContentFolderService.GetFolder(fc.Name, fc.Path);
for (var i = 1; (folder != null && i <= folder.NumOfPhysicalPages); i++)
{
var page = _folderContentPageService.GetPhysicalFolderPage(folder, i);
foreach (var content in page.Content)
{
GetAllSubs(content, subs);
}
}
}
var allSubs = new List <IFolderContent>();
GetAllSubs(folderContent, allSubs);
return(allSubs);
}
public string ImportItem(string eclOrTcmUri, string folderUri, string schemaUri)
{
_folderUri = folderUri;
_schemaUri = schemaUri;
_username = ServiceSecurityContext.Current.WindowsIdentity.Name;
// create new tcm session for current user, so we can create an ecl session to get the ecl item and read its content
using (Session tcmSession = new Session(_username))
using (IEclSession eclSession = SessionFactory.CreateEclSession(tcmSession))
{
IEclUri eclUri = eclOrTcmUri.StartsWith("tcm:") ? eclSession.TryGetEclUriFromTcmUri(eclOrTcmUri) : eclSession.HostServices.CreateEclUri(eclOrTcmUri);
if (eclUri != null)
{
using (_eclContentLibraryContext = eclSession.GetContentLibrary(eclUri))
{
if (eclUri.ItemType == EclItemTypes.Folder)
{
// loop over all ECL items in this folder
IFolderContent items = _eclContentLibraryContext.GetFolderContent(eclUri, 0, EclItemTypes.File);
IList <string> ids = items.ChildItems.Select(item => ImportSingleItem(item.Id)).ToList();
return(string.Join(",", ids.ToArray()));
}
return(ImportSingleItem(eclUri));
}
}
}
throw new FaultException(string.Format("{0} does not exist.", eclOrTcmUri));
}
public void RemoveFolderContentFromPage(IFolder folder, IFolderContent folderContentToRemove, int page)
{
var possiblePhysicalPage = GetPossiblePhysicalPageFromLogicalPage(folder, page);
foreach (var physicalPage in possiblePhysicalPage)
{
var folderPage = GetPhysicalFolderPage(folder, physicalPage);
if (folderPage.Content == null)
{
continue;
}
if (!folderPage.Content.Any(fc => fc.Name == folderContentToRemove.Name &&
fc.Path == folderContentToRemove.Path &&
fc.Type == folderContentToRemove.Type))
{
continue;
}
var contentList = folderPage.Content.ToList();
contentList.RemoveAll(fc => fc.Name == folderContentToRemove.Name &&
fc.Path == folderContentToRemove.Path &&
fc.Type == folderContentToRemove.Type);
folderPage.Content = contentList.ToArray();
_folderContentPageRepository.CreateOrUpdateFolderPage(folder.Name, folder.Path, physicalPage, folderPage);
break;
}
PerformPhysicalPageCompression(folder);
}
public void UpdateFolderChildrenPath(IFolderContent folderContent, string newPathPrefix, string oldPathPrefix)
{
if (folderContent.Type != FolderContentType.Folder)
{
return;
}
var folder = _folderContentFolderRepository.GetFolder(folderContent.Name, folderContent.Path);
if (folder.Path.StartsWith(oldPathPrefix))
{
folder.Path = folder.Path.ReplacePrefixInString(oldPathPrefix, newPathPrefix);
}
_folderContentFolderRepository.CreateOrUpdateFolder(folder.Name, folder.Path, folder);
for (var i = 1; i <= folder.NumOfPhysicalPages; i++)
{
_folderContentPageService.UpdatePathOnPage(folder, i, oldPathPrefix, newPathPrefix);
var page = _folderContentPageService.GetPhysicalFolderPage(folder, i);
foreach (var fc in page.Content)
{
if (fc.Type == FolderContentType.File)
{
_folderContentFileService.UpdateFilePrefixPath(fc.Name, fc.Path, newPathPrefix, oldPathPrefix);
}
UpdateFolderChildrenPath(fc, newPathPrefix, oldPathPrefix);
}
}
}
public void AddToFolderPage(IFolder folder, int pageNum, IFolderContent folderContent)
{
var page = _folderContentPageRepository.GetFolderPage(folder.Name, folder.Path, pageNum);
var contentList = page.Content.ToList();
contentList.Add(folderContent);
page.Content = contentList.ToArray();
_folderContentPageRepository.CreateOrUpdateFolderPage(folder.Name, folder.Path, pageNum, page);
}
private void ValidateFolderNewNameInParentData(IFolderContent folder, string newName)
{
var parent = GetParentFolder(folder);
var oldName = folder.Name;
folder.Name = newName;
_folderContentPageService.ValidateUniquenessOnAllFolderPages(parent, folder);
folder.Name = oldName;
}
private void ValidateFileNameInParentData(IFolderContent file, string newName)
{
var parent = _folderContentFolderService.GetParentFolder(file);
var oldName = file.Name;
file.Name = newName;
_folderContentPageService.ValidateUniquenessOnAllFolderPages(parent, file);
file.Name = oldName;
}
public IFolderPage Map()
{
var content = new IFolderContent[Content.Length];
for (var i = 0; i < Content.Length; i++)
{
content[i] = Content[i].Map();
}
return(new FolderPage(Name, Path, content));
}
private void UpdateNewFolderInParentData(IFolderContent folder)
{
var parent = GetParentFolder(folder);
if (parent == null)
{
return;
}
UpdateNextPageToWrite(parent);
_folderContentPageService.AddToFolderPage(parent, parent.NextPhysicalPageToWrite, folder);
}
public IFolder GetParentFolder(IFolderContent folder)
{
if (folder.Name == _constance.HomeFolderName && folder.Path == _constance.HomeFolderPath)
{
return(null);
}
var parentName = GetParentName(folder);
var parentPath = GetParentPath(folder);
return(_folderContentFolderRepository.GetFolder(parentName, parentPath));
}
private string GetParentName(IFolderContent folder)
{
var path = folder.Path;
if (string.IsNullOrEmpty(path))
{
return(_constance.HomeFolderName);
}
var spittedPathArr = path.Split('/').ToList();
return(spittedPathArr.Last());
}
public void ValidateUniquenessOnAllFolderPages(IFolder folderToValidateIn, IFolderContent folderContentToValidate)
{
if (folderToValidateIn == null)
{
return;
}
for (var i = 1; i <= folderToValidateIn.NumOfPhysicalPages; i++)
{
var page = _folderContentPageRepository.GetFolderPage(folderToValidateIn.Name, folderToValidateIn.Path, i);
if (page.Content.Any(f => f.Name == folderContentToValidate.Name && f.Type == folderContentToValidate.Type))
{
throw new Exception("The name already exists in this folder!");
}
}
}
private string GetParentPath(IFolderContent folder)
{
var path = folder.Path;
if (string.IsNullOrEmpty(path))
{
return(string.Empty);
}
var spittedPathArr = path.Split('/').ToList();
if (spittedPathArr.Count == 1)
{
return(string.Empty);
}
spittedPathArr.RemoveAt(spittedPathArr.Count - 1);
return(spittedPathArr.Aggregate((i, j) => i + '/' + j));
}
private int CompareFolderContent(IFolderContent folderContent1, IFolderContent folderContent2, SortType sortType)
{
switch (sortType)
{
case SortType.Name:
return(string.Compare(folderContent1.Name, folderContent2.Name, StringComparison.Ordinal));
case SortType.Type:
return(folderContent1.Type.CompareTo(folderContent2.Type));
case SortType.DateCreated:
return(string.Compare(folderContent1.CreationTime, folderContent2.CreationTime, StringComparison.Ordinal));
case SortType.DateModified:
return(string.Compare(folderContent1.ModificationTime, folderContent2.ModificationTime, StringComparison.Ordinal));
default:
throw new ArgumentOutOfRangeException(nameof(sortType), sortType, null);
}
}
async Task IFolderContent.MoveGfysAsync(IFolderContent folderToMoveTo, IEnumerable <Gfy> gfysToMove, RequestOptions options)
=> await MoveGfysAsync(folderToMoveTo as Folder ?? throw new ArgumentException($"Can't move gfys from a folder into {folderToMoveTo.GetType()}"), gfysToMove, options).ConfigureAwait(false);
Task IFolderContent.MoveGfysAsync(IFolderContent folderToMoveTo, IEnumerable <Gfy> gfysToMove, RequestOptions options) => MoveGfysAsync(folderToMoveTo as BookmarkFolder ?? throw new ArgumentException($"Parent folder isn't a bookmark folder", nameof(folderToMoveTo)), gfysToMove, options);
public void RenameFolderContentInFolderPages(IFolder folder, string oldName, string newName, IFolderContent renamedObject)
{
for (var i = 1; i <= folder.NumOfPhysicalPages; i++)
{
var page = GetPhysicalFolderPage(folder, i);
if (page.Content == null)
{
continue;
}
var contentList = page.Content.ToList();
var childContent = contentList.FirstOrDefault(fc => fc.Name == oldName &&
fc.Path == renamedObject.Path &&
fc.Type == renamedObject.Type);
if (childContent == null)
{
continue;
}
childContent.Name = newName;
childContent.ModificationTime = $"{DateTime.Now:G}";
page.Content = contentList.ToArray();
_folderContentPageRepository.CreateOrUpdateFolderPage(folder.Name, folder.Path, i, page);
}
}
public FolderPage()
{
Type = FolderContentType.FolderPage;
Content = new IFolderContent[0];
}
async Task IFolderContent.MoveGfysAsync(IFolderContent folderToMoveTo, IEnumerable <Gfy> gfysToMove, RequestOptions options)
=> await MoveGfysAsync(folderToMoveTo as Album ?? throw new ArgumentException($"{nameof(folderToMoveTo)} must be an Album"), gfysToMove, options).ConfigureAwait(false);
