public static string IncrementNameSuffixToLastName(string currentName, int parentNodeId)
{
currentName = RepositoryPath.GetFileName(currentName);
var ext = Path.GetExtension(currentName);
string nameBase;
bool inValidNumber;
var fileName = Path.GetFileNameWithoutExtension(currentName);
ContentNamingHelper.ParseSuffix(fileName, out nameBase, out inValidNumber);
var lastName = DataProvider.Current.GetNameOfLastNodeWithNameBase(parentNodeId, nameBase, ext);
// if there is no suffixed name in db, return with first variant
if (lastName == null)
{
return(String.Format("{0}(1){1}", nameBase, ext));
}
// there was a suffixed name in db in the form namebase(x), increment it
// car(5)-> car(6), car(test)(5) -> car(test)(6), car(test) -> car(guid)
string newNameBase;
var newName = ContentNamingHelper.IncrementNameSuffix(lastName, out newNameBase);
// incremented name base differs from original name base (for example 'car(hello)(2)' and 'car(5)')
// edge case, use guid with original namebase
if (newNameBase != nameBase)
{
return(String.Format("{0}({1}){2}", nameBase, Guid.NewGuid().ToString(), ext));
}
// incremented name base and original name base are equal, so incremented name is correct (eg 'car(2)')
return(newName);
}
protected async Task <Content> EnsureContentAsync(string path, string typeName, Action <Content> setProperties)
{
var content = await Content.LoadAsync(path);
if (content == null)
{
var parentPath = RepositoryPath.GetParentPath(path);
var name = RepositoryPath.GetFileName(path);
content = Content.CreateNew(parentPath, typeName, name);
if (setProperties == null)
{
await content.SaveAsync();
return(content);
}
}
if (setProperties != null)
{
setProperties(content);
await content.SaveAsync();
}
return(content);
}
public void HandleMethod()
{
var parentPath = RepositoryPath.GetParentPath(_handler.GlobalPath);
var folderName = RepositoryPath.GetFileName(_handler.GlobalPath);
WebDavProvider.Current.AssertCreateContent(parentPath, folderName, "Folder");
try
{
var f = new Folder(Node.LoadNode(parentPath))
{
Name = folderName
};
f.Save();
_handler.Context.Response.StatusCode = 201;
}
catch (System.Security.SecurityException e) //logged
{
Logger.WriteException(e);
_handler.Context.Response.StatusCode = 403;
}
catch (ContentRepository.Storage.Security.SecurityException ee) //logged
{
Logger.WriteException(ee);
_handler.Context.Response.StatusCode = 403;
}
catch (Exception eee) //logged
{
Logger.WriteError(Portal.EventId.WebDav.FolderError, "Could not save folder. Error: " + eee.Message, properties: new Dictionary <string, object> {
{ "Parent path", parentPath }, { "Folder name", folderName }
});
_handler.Context.Response.StatusCode = 405;
}
}
/* ===================================================================================== TOOLS */
public byte[] GetBlobBytes(string repositoryPath, string propertyTypeName = null)
{
string fileContent;
if (repositoryPath.StartsWith("/Root/System/Schema/ContentTypes/", StringComparison.OrdinalIgnoreCase))
{
var ctdName = RepositoryPath.GetFileName(repositoryPath);
ContentTypeDefinitions.TryGetValue(ctdName, out fileContent);
}
else
{
var key = $"{propertyTypeName ?? "Binary"}:{repositoryPath}";
Blobs.TryGetValue(key, out fileContent);
}
if (fileContent == null)
{
return(Array.Empty <byte>());
}
if (GetAndRemoveHeader(ref fileContent) == "[bytes]")
{
// bytes
return(ParseHexDump(fileContent));
}
// text
var byteCount = Encoding.UTF8.GetByteCount(fileContent);
var bom = Encoding.UTF8.GetPreamble();
var bytes = new byte[bom.Length + byteCount];
bom.CopyTo(bytes, 0);
Encoding.UTF8.GetBytes(fileContent, 0, fileContent.Length, bytes, bom.Length);
return(bytes);
}
//===========================================================================================================
public void HandleMethod()
{
var parentPath = RepositoryPath.GetParentPath(_handler.GlobalPath);
var fileName = RepositoryPath.GetFileName(_handler.GlobalPath);
var parentNode = Node.LoadNode(parentPath);
var node = Node.LoadNode(_handler.GlobalPath);
switch (_handler.WebdavType)
{
case WebdavType.File:
case WebdavType.Folder:
case WebdavType.Page:
if (node == null || node is IFile)
{
HandleFile(parentPath, fileName, parentNode, node);
}
return;
case WebdavType.Content:
HandleContent(parentPath, fileName, parentNode, node);
return;
case WebdavType.ContentType:
InstallContentType();
return;
default:
throw new NotImplementedException("Unknown WebdavType" + _handler.WebdavType);
}
}
/* ===================================================================================== TOOLS */
public byte[] GetBlobBytes(string repositoryPath, string propertyTypeName = null)
{
string fileContent = null;
if (repositoryPath.StartsWith("/Root/System/Schema/ContentTypes/", StringComparison.OrdinalIgnoreCase))
{
var ctdName = RepositoryPath.GetFileName(repositoryPath);
ContentTypeDefinitions.TryGetValue(ctdName, out fileContent);
}
else
{
var key = $"{propertyTypeName}:{repositoryPath}";
Blobs.TryGetValue(key, out fileContent);
}
if (fileContent == null)
{
return(new byte[0]);
}
var byteCount = Encoding.UTF8.GetByteCount(fileContent);
var bom = Encoding.UTF8.GetPreamble();
var bytes = new byte[bom.Length + byteCount];
bom.CopyTo(bytes, 0);
Encoding.UTF8.GetBytes(fileContent, 0, fileContent.Length, bytes, bom.Length);
return(bytes);
}
public void HandleMethod()
{
var parentPath = RepositoryPath.GetParentPath(_handler.GlobalPath);
var folderName = RepositoryPath.GetFileName(_handler.GlobalPath);
try
{
var f = new Folder(Node.LoadNode(parentPath))
{
Name = folderName
};
f.Save();
_handler.Context.Response.StatusCode = 201;
}
catch (SecurityException e) //logged
{
Logger.WriteException(e);
_handler.Context.Response.StatusCode = 403;
}
catch (SenseNetSecurityException ee) //logged
{
Logger.WriteException(ee);
_handler.Context.Response.StatusCode = 403;
}
catch (Exception eee) //logged
{
Logger.WriteException(eee);
_handler.Context.Response.StatusCode = 405;
}
_handler.Context.Response.Flush();
}
private void EnsureNode(SystemFolder testRoot, string relativePath)
{
string path = DecodePath(testRoot, relativePath);
if (Node.Exists(path))
{
return;
}
string name = RepositoryPath.GetFileName(path);
string parentPath = RepositoryPath.GetParentPath(path);
EnsureNode(testRoot, parentPath);
switch (name)
{
case "ContentList":
case "SourceContentList":
CreateContentList(parentPath, name, _listDef1);
break;
case "TargetContentList":
CreateContentList(parentPath, name, _listDef2);
break;
case "Folder":
case "Folder1":
case "Folder2":
case "SourceFolder":
case "SourceItemFolder":
case "SourceItemFolder1":
case "SourceItemFolder2":
case "TargetFolder":
case "TargetFolder1":
case "TargetFolder2":
case "TargetItemFolder":
CreateNode(parentPath, name, "Folder");
break;
case "(apps)":
case "SystemFolder":
case "SystemFolder1":
case "SystemFolder2":
case "SystemFolder3":
CreateNode(parentPath, name, "SystemFolder");
break;
case "SourceContentListItem":
CreateContentListItem(parentPath, name, "Car");
break;
case "SourceNode":
CreateNode(parentPath, name, "Car");
break;
default:
CreateNode(parentPath, name, "Car");
break;
}
}
internal static int EnsureNode(string path)
{
if (Node.Exists(path))
{
return(-1);
}
var name = RepositoryPath.GetFileName(path);
var parentPath = RepositoryPath.GetParentPath(path);
EnsureNode(parentPath);
var type = GetLeadingChars(name);
if (ContentType.GetByName(type) == null)
{
throw new InvalidOperationException(String.Concat(type + " type doesn't exist!"));
}
switch (type)
{
default:
CreateNode(parentPath, name, type);
break;
}
var node = Node.LoadNode(path);
return(node.Id);
}
internal void ProcessCurrent()
{
if (_handler.Path == string.Empty)
{
ProcessRoot();
return;
}
var node = Node.LoadNode(_handler.GlobalPath);
if (node == null)
{
var parentPath = RepositoryPath.GetParentPath(_handler.GlobalPath);
var currentName = RepositoryPath.GetFileName(_handler.GlobalPath);
node = Node.LoadNode(parentPath);
var binaryPropertyName = string.Empty;
var foundNode = WebDavHandler.GetNodeByBinaryName(node, currentName, out binaryPropertyName);
if (foundNode != null)
{
node = foundNode;
}
else
{
//content type check
//LATER: CTD handling
//var parentIsContentType = (node != null && node is ContentType);
//if (!parentIsContentType)
//{
// desktop.ini, thumbs.db, and other files that are not present are mocked instead of returning 404
if ((Config.MockExistingFiles != null) && (Config.MockExistingFiles.Contains(currentName)))
{
_writer = Common.GetXmlWriter();
_writer.WriteStartElement(XmlNS.DAV_Prefix, "multistatus", XmlNS.DAV);
_writer.WriteEndElement(); // multistatus
_handler.Context.Response.Flush();
return;
}
_handler.Context.Response.StatusCode = 404;
_handler.Context.Response.Flush();
return;
//}
// parent is contenttype, continue operation on parent (foldernode's name is valid CTD name)
}
}
_writer = Common.GetXmlWriter();
_writer.WriteStartElement(XmlNS.DAV_Prefix, "multistatus", XmlNS.DAV);
WriteItem(node);
_writer.WriteEndElement(); // multistatus
}
/// <summary>
/// Returns an OData path that can request the entity identified by the given path. This path is part of the OData entity request. For example
/// "/Root/MyFolder/MyDocument.doc" will be transformed to "/Root/MyFolder('MyDocument.doc')"
/// </summary>
/// <param name="path">This path will be transformed</param>
/// <returns>An OData path.</returns>
public static string GetODataPath(string path)
{
if (String.Compare(path, Repository.Root.Path, true) == 0)
{
return(string.Empty);
}
return(GetODataPath(RepositoryPath.GetParentPath(path), RepositoryPath.GetFileName(path)));
}
/// <summary>
/// Returns an OData path that can request the entity identified by the given path. This path is part of the OData entity request. For example
/// "/Root/MyFolder/MyDocument.doc" will be transformed to "/Root/MyFolder('MyDocument.doc')"
/// </summary>
/// <param name="path">This path will be transformed.</param>
/// <returns>An OData path.</returns>
public static string GetODataPath(string path)
{
if (string.Compare(path, Identifiers.RootPath, StringComparison.OrdinalIgnoreCase) == 0)
{
return(string.Empty);
}
return(GetODataPath(RepositoryPath.GetParentPath(path), RepositoryPath.GetFileName(path)));
}
private Exception GetUniqueUserException(string domainPath)
{
var message = string.Format(SR.GetString(SR.Exceptions.User.Error_NonUnique),
RepositoryPath.GetFileName(domainPath.TrimEnd(RepositoryPath.PathSeparator[0])),
Name,
LoginName);
return(new InvalidOperationException(message));
}
public void HandleMethod()
{
var node = Node.LoadNode(_handler.GlobalPath);
var binaryPropertyName = "Binary";
if (node == null)
{
var parentPath = RepositoryPath.GetParentPath(_handler.GlobalPath);
var currentName = RepositoryPath.GetFileName(_handler.GlobalPath);
node = Node.LoadNode(parentPath);
var foundNode = WebDavHandler.GetNodeByBinaryName(node, currentName, out binaryPropertyName);
if (foundNode != null)
{
node = foundNode;
}
else
{
binaryPropertyName = "Binary";
// check if parent is contenttype
//(contenttypes are listed under their own folder, so the node exists only virtually)
var parentIsContentType = (node != null && node is ContentType);
if (!parentIsContentType)
{
_handler.Context.Response.StatusCode = 404;
_handler.Context.Response.Flush();
}
// parent is contenttype, continue operation on parent (foldernode's name is valid CTD name)
}
}
// load specific version
if (node != null && !string.IsNullOrEmpty(PortalContext.Current.VersionRequest))
{
VersionNumber version;
if (VersionNumber.TryParse(PortalContext.Current.VersionRequest, out version))
{
var nodeVersion = Node.LoadNode(node.Id, version);
if (nodeVersion != null && nodeVersion.SavingState == ContentSavingState.Finalized)
{
node = nodeVersion;
}
}
}
ConverterPattern.DoTransform(node, _handler, binaryPropertyName);
_handler.Context.Response.Flush();
return;
}
internal static string GetAttachmentName(Node node, string propertyName)
{
var binaryName = RepositoryPath.GetFileName(System.IO.Path.GetFileName(((BinaryData)node[propertyName]).FileName));
if (string.IsNullOrEmpty(binaryName) || binaryName.StartsWith("."))
{
binaryName = node.Name + binaryName;
}
return(binaryName);
}
public string GetFileName(string path)
{
if (path.Contains("\\"))
{
return(Path.GetFileName(path));
}
else
{
return(RepositoryPath.GetFileName(path));
}
}
protected override void OnModified(object sender, NodeEventArgs e)
{
base.OnModified(sender, e);
var oldName = RepositoryPath.GetFileName(e.OriginalSourcePath);
if (oldName.CompareTo(e.SourceNode.Name) != 0 || this.DisplayName.CompareTo(_oldDisplayName) != 0)
{
WikiTools.RefreshArticlesAsync(this, oldName, _oldDisplayName);
}
}
public static void EnsurePath(string path)
{
if (!Node.Exists(path))
{
var parentPath = RepositoryPath.GetParentPath(path);
EnsurePath(parentPath);
Folder folder = new Folder(Node.LoadNode(parentPath));
folder.Name = RepositoryPath.GetFileName(path);
folder.Save();
}
}
public static string IncrementNameSuffix(string name, out string nameBase)
{
name = RepositoryPath.GetFileName(name);
var ext = Path.GetExtension(name);
var fileName = Path.GetFileNameWithoutExtension(name);
bool inValidNumber;
var index = ContentNamingHelper.ParseSuffix(fileName, out nameBase, out inValidNumber);
var newName = (inValidNumber) ?
String.Format("{0}({1}){2}", nameBase, Guid.NewGuid().ToString(), ext) :
String.Format("{0}({1}){2}", nameBase, ++index, ext);
return(newName);
}
public static string RenderIconTagFromPath(string path, string overlay, int size, string title)
{
var iconclasses = "sn-icon sn-icon" + size;
if (string.IsNullOrEmpty(overlay))
{
return(string.Format(SimpleFormat, string.Empty, path, iconclasses, title));
}
else
{
var overlaypath = ResolveIconPath(OverlayPrefix + overlay, size);
return(string.Format(OverlayFormat, RepositoryPath.GetFileName(path), path, overlay, overlaypath, iconclasses, title));
}
}
public static string IncrementNameSuffix(string name)
{
name = RepositoryPath.GetFileName(name);
var ext = Path.GetExtension(name);
var fileName = Path.GetFileNameWithoutExtension(name);
string nameBase;
var index = ParseSuffix(fileName, out nameBase);
if (index < 0)
{
index = 0;
}
return(String.Format("{0}({1}){2}", nameBase, ++index, ext));
}
private static Content EnsureContainer(string path, string containerTypeName)
{
if (Node.Exists(path))
{
return(null);
}
var name = RepositoryPath.GetFileName(path);
var parentPath = RepositoryPath.GetParentPath(path);
// recursive call to create parent containers
EnsureContainer(parentPath, containerTypeName);
return(CreateContent(parentPath, name, containerTypeName));
}
public static async Task EnsurePath(string path, string containerTypeName = null)
{
if (!await Content.ExistsAsync(path))
{
var parentPath = RepositoryPath.GetParentPath(path);
// ensure parent
await EnsurePath(parentPath, containerTypeName);
var name = RepositoryPath.GetFileName(path);
var folder = Content.CreateNew(parentPath, containerTypeName ?? "Folder", name);
await folder.SaveAsync();
}
}
private void EnsureNode(string encodedPath, string typeName)
{
string path = DecodePath(encodedPath);
if (Node.Exists(path))
{
return;
}
string name = RepositoryPath.GetFileName(path);
string parentPath = RepositoryPath.GetParentPath(path);
EnsureNode(parentPath, "Folder");
CreateNode(parentPath, name, typeName);
}
private static Content LoadContentOrVirtualChild(ODataRequest odataReq)
{
var content = Content.Load(odataReq.RepositoryPath);
if (content == null)
{
// try to load a virtual content
var parentPath = RepositoryPath.GetParentPath(odataReq.RepositoryPath);
var name = RepositoryPath.GetFileName(odataReq.RepositoryPath);
if (Node.LoadNode(parentPath) is ISupportsVirtualChildren vp)
{
content = vp.GetChild(name);
}
}
return(content);
}
public Stream GetStreamForRead(BlobStorageContext context)
{
var path = (string)context.BlobProviderData;
string fileContent = null;
if (path.StartsWith(Repository.ContentTypesFolderPath))
{
var ctdName = RepositoryPath.GetFileName(path);
fileContent = _dataFile.ContentTypeDefinitions[ctdName];
}
else
{
var key = $"{ActiveSchema.PropertyTypes.GetItemById(context.PropertyTypeId).Name}:{path}";
_dataFile.Blobs.TryGetValue(key, out fileContent);
}
var stream = RepositoryTools.GetStreamFromString(fileContent);
return(stream);
}
public static string IncrementNameSuffixToLastName(string currentName, int parentNodeId)
{
currentName = RepositoryPath.GetFileName(currentName);
var ext = Path.GetExtension(currentName);
string nameBase;
var fileName = Path.GetFileNameWithoutExtension(currentName);
var count = ContentNamingHelper.ParseSuffix(fileName, out nameBase);
var lastName = DataProvider.Current.GetNameOfLastNodeWithNameBase(parentNodeId, nameBase, ext);
// if there is no suffixed name in db, return with first variant
if (lastName == null)
{
return(String.Format("{0}(1){1}", nameBase, ext));
}
// there was a suffixed name in db in the form namebase(x), increment it
// car(5)-> car(6), car(test)(5) -> car(test)(6), car(test) -> car(guid)
return(ContentNamingHelper.IncrementNameSuffix(lastName));
}
public static string IncrementNameSuffixToLastName(string currentName, int parentNodeId)
{
currentName = RepositoryPath.GetFileName(currentName);
var ext = Path.GetExtension(currentName);
var fileName = Path.GetFileNameWithoutExtension(currentName);
var count = ParseSuffix(fileName, out var nameBase);
var lastName = DataStore.GetNameOfLastNodeWithNameBaseAsync(parentNodeId, nameBase, ext, CancellationToken.None)
.GetAwaiter().GetResult();
// if there is no suffixed name in db, return with first variant
if (lastName == null)
{
return($"{nameBase}(1){ext}");
}
// there was a suffixed name in db in the form namebase(x), increment it
// car(5)-> car(6), car(test)(5) -> car(test)(6), car(test) -> car(guid)
return(IncrementNameSuffix(lastName));
}
public static Folder LoadOrCreateFolder(string path)
{
var folder = (Folder)Node.LoadNode(path);
if (folder != null)
{
return(folder);
}
var parentPath = RepositoryPath.GetParentPath(path);
var parentFolder = (Folder)Node.LoadNode(parentPath) ?? LoadOrCreateFolder(parentPath);
folder = new Folder(parentFolder)
{
Name = RepositoryPath.GetFileName(path)
};
folder.Save();
return(folder);
}
public void HandleMethod()
{
var node = Node.LoadNode(_handler.GlobalPath);
var binaryPropertyName = "Binary";
if (node == null)
{
var parentPath = RepositoryPath.GetParentPath(_handler.GlobalPath);
var currentName = RepositoryPath.GetFileName(_handler.GlobalPath);
node = Node.LoadNode(parentPath);
var foundNode = WebDavHandler.GetNodeByBinaryName(node, currentName, out binaryPropertyName);
if (foundNode != null)
{
node = foundNode;
}
else
{
binaryPropertyName = "Binary";
// check if parent is contenttype
//(contenttypes are listed under their own folder, so the node exists only virtually)
var parentIsContentType = (node != null && node is ContentType);
if (!parentIsContentType)
{
_handler.Context.Response.StatusCode = 404;
_handler.Context.Response.Flush();
}
// parent is contenttype, continue operation on parent (foldernode's name is valid CTD name)
}
}
ConverterPattern.DoTransform(node, _handler, binaryPropertyName);
_handler.Context.Response.Flush();
return;
}
