internal static ContentType LoadOrCreateNew(IXPathNavigable contentTypeDefinitionXml)
{
// ==== saves and puts the holder
// #1 Determine name and parent's name
XPathNavigator nav = contentTypeDefinitionXml.CreateNavigator().SelectSingleNode("/*[1]");
string name = nav.GetAttribute("name", "");
string parentTypeName = nav.GetAttribute("parentType", "");
// #2 Load ContentType
ContentType contentType = ContentTypeManager.Current.GetContentTypeByName(name);
// #3 Parent Node: if it is loaded yet use it (ReferenceEqals)
Node parentNode;
if (String.IsNullOrEmpty(parentTypeName))
{
parentNode = (Folder)Node.LoadNode(Repository.ContentTypesFolderPath);
}
else
{
parentNode = ContentTypeManager.Current.GetContentTypeByName(parentTypeName);
if (parentNode == null)
{
throw new ApplicationException(String.Concat(SR.Exceptions.Content.Msg_UnknownContentType, ": ", parentTypeName));
}
}
// #4 Create ContentType if it does not exist
if (contentType == null)
{
contentType = new ContentType(parentNode);
contentType.Name = name;
}
// #5 Update hierarchy if parent is changed
if (contentType.ParentId != parentNode.Id)
{
throw new SnNotSupportedException("Change ContentType hierarchy is not supported");
}
// #6 Set Binary data
BinaryData binaryData = new BinaryData();
binaryData.FileName = new BinaryFileName(name, ContentType.ContentTypeFileNameExtension);
binaryData.SetStream(RepositoryTools.GetStreamFromString(contentTypeDefinitionXml.CreateNavigator().OuterXml));
contentType.Binary = binaryData;
return(contentType);
}
public File LoadTestFile()
{
if (_testFileId == 0)
{
var folder = CreateFolder();
var file = new File(folder)
{
Name = Guid.NewGuid().ToString()
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString(OriginalFileContent));
file.Save();
_testFileId = file.Id;
}
return(Node.Load <File>(_testFileId));
}
public void Cache_Builtin_DeleteParent_SubtreeRemoved()
{
Test((builder) => { builder.UseCacheProvider(new SnMemoryCache()); },
() =>
{
// create structure
var root = Repository.Root;
var rootHead = NodeHead.Get(root.Id);
var testRoot = CreateTestRoot();
var testRootHead = NodeHead.Get(testRoot.Id);
var file = new File(testRoot)
{
Name = "file"
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString("Lorem ipsum..."));
file.Save();
var fileHead = NodeHead.Get(file.Id);
var binaryData = file.Binary;
// reset cache
Cache.Reset();
root = Node.Load <PortalRoot>(root.Id);
testRoot = Node.Load <SystemFolder>(testRoot.Id);
file = Node.Load <File>(file.Id);
var stream = file.Binary.GetStream();
Assert.IsTrue(IsInCache(root.Data));
Assert.IsTrue(IsInCache(rootHead));
Assert.IsTrue(IsInCache(testRoot.Data));
Assert.IsTrue(IsInCache(testRootHead));
Assert.IsTrue(IsInCache(file.Data));
Assert.IsTrue(IsInCache(fileHead));
Assert.IsTrue(IsInCache(binaryData));
//var keysBefore = Cache.WhatIsInTheCache();
testRoot.ForceDelete();
Assert.IsTrue(IsInCache(root.Data));
Assert.IsTrue(IsInCache(rootHead));
Assert.IsFalse(IsInCache(testRoot.Data));
Assert.IsFalse(IsInCache(testRootHead));
Assert.IsFalse(IsInCache(file.Data));
Assert.IsFalse(IsInCache(fileHead));
Assert.IsFalse(IsInCache(binaryData));
});
}
public void Indexing_XmlFile_Wellformed()
{
Test(() =>
{
var testRoot = new SystemFolder(Repository.Root)
{
Name = "TestRoot"
};
testRoot.Save();
// Create an xml file
var file = new File(testRoot)
{
Name = "TestFile.xml"
};
// Write a well-formed xml into the file's binary.
var text = "<rootelement42><xmlelement42 attr42='attrvalue'>elementtext1 elementtext2 elementtext3</xmlelement42></rootelement42>";
var binaryData = new BinaryData()
{
FileName = file.Name
};
binaryData.SetStream(RepositoryTools.GetStreamFromString(text));
file.Binary = binaryData;
// Save the file.
file.Save();
var fileId = file.Id;
// Check the index with queries by well known words in the default (_Text) field.
var results = new[]
{
CreateSafeContentQuery("rootelement42").Execute().Nodes.ToArray(),
CreateSafeContentQuery("xmlelement42").Execute().Nodes.ToArray(),
CreateSafeContentQuery("attr42").Execute().Nodes.ToArray(),
CreateSafeContentQuery("elementtext1").Execute().Nodes.ToArray(),
CreateSafeContentQuery("elementtext2").Execute().Nodes.ToArray(),
CreateSafeContentQuery("elementtext3").Execute().Nodes.ToArray(),
CreateSafeContentQuery("attrvalue").Execute().Nodes.ToArray(),
};
var expectedCounts = "0, 0, 0, 1, 1, 1, 0";
var actualCounts = string.Join(", ", results.Select(r => r.Length.ToString()).ToArray());
Assert.AreEqual(expectedCounts, actualCounts);
});
}
public Stream RemovePasswords(Stream stream)
{
// This method is an instance method and not static because
// it needs to access the cached password values.
if (stream == null)
{
return(null);
}
if (_cachedPasswords == null)
{
return(stream);
}
var settings = DeserializeToJObject(stream);
var servers = settings["Servers"] as JArray;
if (servers == null || servers.Count == 0)
{
return(stream);
}
foreach (var server in servers)
{
var credentials = server["LogonCredentials"];
if (credentials == null)
{
continue;
}
var pw = (string)credentials["Password"];
if (string.IsNullOrEmpty(pw))
{
continue;
}
if (!_cachedPasswords.Values.Contains(pw))
{
continue;
}
// erase the password before sending the json to the client
credentials["Password"] = string.Empty;
}
return(RepositoryTools.GetStreamFromString(settings.ToString()));
}
private void SaveMasterPage(MasterPage masterPage, string textData)
{
BinaryData binaryData = new BinaryData();
if (masterPage.Binary != null)
{
masterPage.Binary.SetStream(RepositoryTools.GetStreamFromString(textData));
masterPage.Binary.FileName = new BinaryFileName(ASPX);
}
else
{
binaryData.SetStream(RepositoryTools.GetStreamFromString(textData));
binaryData.FileName = new BinaryFileName(ASPX);
masterPage.Binary = binaryData;
}
masterPage.Save();
}
private void BinaryCacheEntityTest(string fileContent, int sizeLimit)
{
using (new SystemAccount())
using (new SizeLimitSwindler(this, sizeLimit))
{
var testRoot = CreateTestRoot();
var file = new File(testRoot)
{
Name = "File1.file"
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString(fileContent));
file.Save();
var versionId = file.VersionId;
var binaryPropertyId = file.Binary.Id;
var fileId = file.Binary.FileId;
var propertyTypeId = PropertyType.GetByName("Binary").Id;
// action
var binaryCacheEntity = BlobStorage.LoadBinaryCacheEntityAsync(
file.VersionId, propertyTypeId, CancellationToken.None).GetAwaiter().GetResult();
// assert
Assert.AreEqual(binaryPropertyId, binaryCacheEntity.BinaryPropertyId);
Assert.AreEqual(fileId, binaryCacheEntity.FileId);
Assert.AreEqual(fileContent.Length + 3, binaryCacheEntity.Length);
Assert.AreEqual(versionId, binaryCacheEntity.Context.VersionId);
Assert.AreEqual(propertyTypeId, binaryCacheEntity.Context.PropertyTypeId);
Assert.AreEqual(fileId, binaryCacheEntity.Context.FileId);
Assert.AreEqual(fileContent.Length + 3, binaryCacheEntity.Context.Length);
if (NeedExternal(BlobStoragePlatform.ExpectedBlobProviderDataType, fileContent, sizeLimit))
{
Assert.IsTrue(binaryCacheEntity.Context.Provider.GetType() == BlobStoragePlatform.ExpectedExternalBlobProviderType);
Assert.IsTrue(binaryCacheEntity.Context.BlobProviderData.GetType() == BlobStoragePlatform.ExpectedBlobProviderDataType);
Assert.AreEqual(fileContent, GetStringFromBytes(BlobStoragePlatform.GetExternalData(binaryCacheEntity.Context)));
}
else
{
Assert.AreEqual(fileContent, GetStringFromBytes(binaryCacheEntity.RawData));
}
}
}
protected override void ImportData(XmlNode fieldNode, ImportContext context)
{
XmlAttribute attachmentAttr = fieldNode.Attributes["attachment"];
BinaryData binaryData = this.GetData() as BinaryData;
if (binaryData == null)
{
binaryData = new BinaryData();
}
if (attachmentAttr == null)
{
binaryData.SetStream(RepositoryTools.GetStreamFromString(fieldNode.InnerXml));
binaryData.FileName = String.Concat(this.Content.ContentHandler.Name, ".", this.Name, ".txt");
}
else
{
string path = context.UnescapeFileName(attachmentAttr.Value);
binaryData.FileName = Path.Combine(context.CurrentDirectory, path);
// webdav request: we don't have a binary file
// next to the content as an attachment, so ignore the value
bool webdav = false;
if (HttpContext.Current != null)
{
string trans = HttpContext.Current.Request.Headers["Translate"];
webdav = (!string.IsNullOrEmpty(trans) && trans.ToLower().CompareTo("f") == 0);
}
if (!webdav)
{
var stream = context.GetAttachmentStream(path);
if (stream == null)
{
return;
}
binaryData.SetStream(stream);
}
}
this.SetData(binaryData);
}
public async Task Cors_HttpContext_PolicyFound()
{
await Test(async() =>
{
// set allowed domains for test
var setting = await Node.LoadAsync <Settings>(
RepositoryPath.Combine(Repository.SettingsFolderPath, "Portal.settings"), CancellationToken.None);
var currentSettingText = RepositoryTools.GetStreamString(setting.Binary.GetStream());
var newSettingText = EditJson(currentSettingText, @"
{
""AllowedOriginDomains"": [
""localhost:*"",
""*.sensenet.com""
]
}
");
setting.Binary.SetStream(RepositoryTools.GetStreamFromString(newSettingText));
setting.Save(SavingMode.KeepVersion);
// default settings support localhost and sensenet.com
var p = await AssertOriginPrivate("localhost", true);
Assert.IsTrue(p.SupportsCredentials);
p = await AssertOriginPrivate("localhost:123", true);
Assert.IsTrue(p.SupportsCredentials);
p = await AssertOriginPrivate("example.sensenet.com", true);
Assert.IsTrue(p.SupportsCredentials);
await AssertOriginPrivate("sensenet.com", false);
await AssertOriginPrivate("example.com", false);
});
async Task <CorsPolicy> AssertOriginPrivate(string origin, bool expected)
{
var cpp = new SnCorsPolicyProvider(null);
var context = new DefaultHttpContext();
context.Request.Headers["Origin"] = origin;
var p = await cpp.GetPolicyAsync(context, SnCorsPolicyProvider.DefaultSenseNetCorsPolicyName);
Assert.AreEqual(expected, p.Origins.Contains(origin));
return(p);
}
}
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 BinaryData GetASPXBinaryByPageTemplate(Page page, PageTemplate pageTemplate)
{
if (page == null)
{
throw new ArgumentNullException("page");
}
if (pageTemplate == null)
{
throw new ArgumentNullException("pageTemplate");
}
BinaryData binaryData = new BinaryData();
if (page.Binary != null)
{
binaryData = page.Binary;
}
string pageTmp = RepositoryTools.GetStreamString(pageTemplate.Binary.GetStream());
IList <object> fragments = SplitPageTemplate(pageTmp);
StringBuilder aspx = new StringBuilder();
// MasterPage is inside the PageTemplates folder.
var parentPath = RepositoryPath.GetParentPath(pageTemplate.Path);
aspx.AppendFormat(ASPXHEADER, string.Concat("/", GetFileNameWithoutExt(pageTemplate.Name), MASTER), parentPath);
for (int i = 0; i < fragments.Count; i++)
{
if (fragments[i] is PageZone)
{
PageZone zone = fragments[i] as PageZone;
aspx.AppendFormat(WEBPARTZONE, zone.Name, zone.InnerText, zone.AttrListText);
}
}
binaryData.SetStream(RepositoryTools.GetStreamFromString(aspx.ToString()));
binaryData.FileName = new BinaryFileName(ASPX);
binaryData.ContentType = ASPXCONTENTTYPE;
return(binaryData);
}
public void Indexing_SimpleSerializationWhenSaveNode()
{
int GetCountOfTraceMessages(TestSnTracer tracer, int versionId)
{
var lines = tracer.Lines.ToArray();
var msg = $"Serialize IndexDocument. VersionId: {versionId}";
return(lines.Count(x => x.Split('\t').Last() == msg));
}
Test(() =>
{
using (new Swindler <bool>(true,
() => SnTrace.Index.Enabled,
value => { SnTrace.Index.Enabled = value; }))
{
var localTracer = new TestSnTracer();
try
{
SnTrace.SnTracers.Add(localTracer);
localTracer.Lines.Clear();
var root = CreateTestRoot();
// Expectation: 2 lines: start and end of a trace operation.
Assert.AreEqual(2, GetCountOfTraceMessages(localTracer, root.VersionId));
var file = new File(root)
{
Name = Guid.NewGuid().ToString()
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString("fileContent"));
localTracer.Lines.Clear();
file.Save();
Assert.AreEqual(2, GetCountOfTraceMessages(localTracer, file.VersionId));
}
finally
{
SnTrace.SnTracers.Remove(localTracer);
}
}
});
}
public void Versioning_History_Bug1308Test()
{
Test(() =>
{
const string fileName = "bug1308.xml";
const string fileBinary =
@"<?xml version='1.0' encoding='utf-8'?> <ContentType><Fields /></ContentType>";
var root = new SystemFolder(Repository.Root)
{
Name = Guid.NewGuid().ToString()
};
root.Save();
var file = new File(root)
{
Name = fileName
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString(fileBinary));
file.Binary.FileName = fileName;
file.Save();
//1. checkout
file.CheckOut();
//2. checkin
var exceptionOccured = false;
try
{
file.UndoCheckOut();
}
catch (NullReferenceException)
{
exceptionOccured = true;
}
// assert
var errorMessage = String.Concat("Version history should be V1.0.A instead of: ",
GetVersionHistoryString(NodeHead.Get(file.Id)));
Assert.IsFalse(exceptionOccured, String.Concat("An exception occured during execution.", errorMessage));
AssertVersionHistory(file, "V1.0.A", errorMessage);
});
}
public FileOperation(string fileName = null)
{
var fileContainer = Node.Load <SystemFolder>("/Root/TestFiles");
if (fileContainer == null)
{
fileContainer = new SystemFolder(Repository.Root)
{
Name = "TestFiles"
};
fileContainer.Save();
}
TheFile = new File(fileContainer)
{
Name = fileName ?? Guid.NewGuid().ToString()
};
TheFile.Binary.SetStream(RepositoryTools.GetStreamFromString("Lorem ipsum..."));
TheFile.Save();
}
private void InstallResourceFile(string fileName, string xml)
{
var localizationFolder = Node.LoadNode("/Root/Localization");
if (localizationFolder == null)
{
localizationFolder = new SystemFolder(Repository.Root, "Resources")
{
Name = "Localization"
};
localizationFolder.Save();
}
var resourceNode = new Resource(localizationFolder)
{
Name = fileName
};
resourceNode.Binary.SetStream(RepositoryTools.GetStreamFromString(xml));
resourceNode.Save();
SenseNetResourceManager.Reset();
}
public void File_Create_NoExtension_ExplicitMime()
{
Test(() =>
{
var root = CreateTestRoot();
var file = new File(root)
{
Name = "FILE",
Binary = { ContentType = "text/plain" }
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString("Lorem ipsum dolor sit amet."));
file.Save();
// check mime type
file = Node.Load <File>(file.Id);
Assert.AreEqual("text/plain", file.Binary.ContentType);
// check searchability
var queryResult = CreateSafeContentQuery("dolor").Execute();
Assert.AreEqual(0, queryResult.Count);
});
}
private void CreateSamplePreviewImages(SystemFolder root, string version)
{
var imgContainer = new SystemFolder(root)
{
Name = version
};
imgContainer.Save();
var img = new Image(imgContainer, "PreviewImage")
{
Name = "thumbnail1.png"
};
img.Binary.SetStream(RepositoryTools.GetStreamFromString(new string('-', 144)));
img.Save();
img = new Image(imgContainer, "PreviewImage")
{
Name = "preview1.png"
};
img.Binary.SetStream(RepositoryTools.GetStreamFromString(new string('-', 145)));
img.Save();
img = new Image(imgContainer, "PreviewImage")
{
Name = "thumbnail2.png"
};
img.Binary.SetStream(RepositoryTools.GetStreamFromString(new string('-', 146)));
img.Save();
img = new Image(imgContainer, "PreviewImage")
{
Name = "preview2.png"
};
img.Binary.SetStream(RepositoryTools.GetStreamFromString(new string('-', 147)));
img.Save();
}
private DbFile CreateFileTest(Node testRoot, string fileContent, int sizeLimit)
{
using (new SystemAccount())
using (new SizeLimitSwindler(this, sizeLimit))
{
var file = new File(testRoot)
{
Name = "File1.file"
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString(fileContent));
// action
file.Save();
// assert
var dbFiles = BlobStoragePlatform.LoadDbFiles(file.VersionId);
Assert.AreEqual(1, dbFiles.Length);
var dbFile = dbFiles[0];
if (NeedExternal(BlobStoragePlatform.ExpectedExternalBlobProviderType, fileContent, sizeLimit))
{
Assert.AreEqual(BlobStoragePlatform.ExpectedExternalBlobProviderType.FullName, dbFile.BlobProvider);
Assert.IsNotNull(dbFile.BlobProviderData);
}
else
{
Assert.IsNull(dbFile.BlobProvider);
Assert.IsNull(dbFile.BlobProviderData);
}
Assert.AreEqual(false, dbFile.IsDeleted);
Assert.AreEqual(false, dbFile.Staging);
Assert.AreEqual(0, dbFile.StagingVersionId);
Assert.AreEqual(0, dbFile.StagingPropertyTypeId);
Assert.AreEqual(fileContent.Length + 3, dbFile.Size);
return(dbFile);
}
}
private List <byte[]> SplitFile(string text, int chunkSize, out int fullSize)
{
var stream = (IO.MemoryStream)RepositoryTools.GetStreamFromString(text);
var buffer = stream.GetBuffer();
var bytes = new byte[text.Length + 3];
fullSize = bytes.Length;
Array.Copy(buffer, 0, bytes, 0, bytes.Length);
var chunks = new List <byte[]>();
//var bytes = Encoding.UTF8.GetBytes(text);
var p = 0;
while (p < bytes.Length)
{
var size = Math.Min(chunkSize, bytes.Length - p);
var chunk = new byte[size];
Array.Copy(bytes, p, chunk, 0, size);
chunks.Add(chunk);
p += chunkSize;
}
return(chunks);
}
public void FieldIndexHandler_BinaryIndexHandler()
{
Test(() =>
{
var binaryData = new BinaryData();
binaryData.FileName = "file1.txt";
binaryData.SetStream(RepositoryTools.GetStreamFromString("Stream data."));
var folder = new SystemFolder(Repository.Root)
{
Name = "Folder1"
};
folder.Save();
var file = new File(folder)
{
Name = "file1.txt", Binary = binaryData
};
file.Save();
var content = Content.Load(file.Id);
var contentName = content.Name;
var snField = content.Fields["Binary"];
var fieldIndexHandler = new BinaryIndexHandler();
fieldIndexHandler.OwnerIndexingInfo = snField.FieldSetting.IndexingInfo;
var indexed = fieldIndexHandler.GetIndexFields(snField, out _);
Assert.AreEqual(IndexValueType.String, indexed.First().Type);
var parsed = fieldIndexHandler.Parse("Word1");
Assert.AreEqual(IndexValueType.String, parsed.Type);
var termValue = fieldIndexHandler.ConvertToTermValue("Word1");
Assert.AreEqual(parsed.Type, termValue.Type);
// get back is not supported
});
}
// ======================================================================== Public API
public async Task <object> ExecuteAsync(CancellationToken cancellationToken)
{
// 1st allowed types check: if allowed content types list is empty, no upload is allowed
if (!AllowCreationForEmptyAllowedContentTypes(Content.ContentHandler))
{
throw new Exception(SenseNetResourceManager.Current.GetString("Action", "UploadExceptionEmptyAllowedChildTypes"));
}
// the create parameter is sent in the url
if (Create.HasValue)
{
var uploadedContent = await GetContentAsync(Content, cancellationToken).ConfigureAwait(false);
// check if the content is locked by someone else
if (uploadedContent.ContentHandler.Locked && uploadedContent.ContentHandler.LockedBy.Id != User.Current.Id)
{
throw new Exception(SenseNetResourceManager.Current.GetString("Action", "UploadExceptionLocked"));
}
var chunkToken = string.Empty;
// If the content is not locked at the start of this process, it will be checked out by the multistep saving mechanism below
// and it will be checked in at the end (either manually or by the finalizer method).
var mustCheckIn = uploadedContent.IsNew || !uploadedContent.ContentHandler.Locked;
// At the end we will finalize only if we started the multistep save.
var mustFinalize = uploadedContent.ContentHandler.SavingState == ContentSavingState.Finalized;
if (UseChunkRequestValue)
{
// Start the multistep saving process only if it was not started by
// somebody else before (e.g. with an initial POST request through OData).
if (mustFinalize)
{
uploadedContent.Save(SavingMode.StartMultistepSave);
}
chunkToken = BinaryData.StartChunk(uploadedContent.Id, FileLength, PropertyName);
}
return(string.Format("{0}*{1}*{2}*{3}", uploadedContent.Id, chunkToken, mustFinalize, mustCheckIn));
}
else
{
// handle uploaded chunks/stream/text
IFormFile file = null;
if (string.IsNullOrEmpty(FileText))
{
file = _httpContext.Request.Form.Files.Count > 0 ? _httpContext.Request.Form.Files[0] : null;
}
if (file != null && file.Length == 0)
{
// create content for an empty file if necessary
var emptyFile = await GetContentAsync(Content, cancellationToken).ConfigureAwait(false);
if (emptyFile != null && emptyFile.IsNew)
{
emptyFile.Save();
return(GetJsonFromContent(emptyFile, file));
}
return(null);
}
if (file == null && string.IsNullOrEmpty(FileText))
{
return(null);
}
var contentId = 0;
var chunkToken = string.Empty;
var mustFinalize = false;
var mustCheckIn = false;
// collect data only if this is a real file, not a text
if (file != null)
{
CollectUploadData(out contentId, out chunkToken, out mustFinalize, out mustCheckIn);
}
// load the content using the posted chunk token or create a new one
// (in case of a small file, when no chunk upload is used)
var uploadedContent = UseChunk
? await Content.LoadAsync(contentId, cancellationToken).ConfigureAwait(false)
: await GetContentAsync(Content, cancellationToken).ConfigureAwait(false);
// in case we just loaded this content
SetPreviewGenerationPriority(uploadedContent);
if (file != null)
{
await SaveFileToRepositoryAsync(uploadedContent, Content, chunkToken,
mustFinalize, mustCheckIn, file, cancellationToken);
}
else
{
// handle text data
var binData = new BinaryData {
FileName = new BinaryFileName(uploadedContent.Name)
};
// set content type only if we were unable to recognise it
if (string.IsNullOrEmpty(binData.ContentType))
{
binData.ContentType = "text/plain";
}
binData.SetStream(RepositoryTools.GetStreamFromString(FileText));
uploadedContent[PropertyName] = binData;
uploadedContent.Save();
}
return(GetJsonFromContent(uploadedContent, file));
}
}
public void OData_UserAvatarUpdateInnerDataToRef()
{
Test(() =>
{
var testDomain = new Domain(Repository.ImsFolder)
{
Name = "Domain1"
};
testDomain.Save();
var testUser = new User(testDomain)
{
Name = "User1"
};
testUser.Save();
var testSite = CreateTestSite();
var testAvatars = new Folder(testSite)
{
Name = "demoavatars"
};
testAvatars.Save();
var testAvatar = new Image(testAvatars)
{
Name = "user1.jpg"
};
testAvatar.Binary = new BinaryData {
FileName = "user1.jpg"
};
testAvatar.Binary.SetStream(RepositoryTools.GetStreamFromString("abcdefgh"));
testAvatar.Save();
var avatarBinaryData = new BinaryData {
FileName = "user2.jpg"
};
avatarBinaryData.SetStream(RepositoryTools.GetStreamFromString("ijklmnop"));
// set avatar of User1
var userContent = Content.Load(testUser.Id);
var avatarData = new ImageField.ImageFieldData(null, null, avatarBinaryData);
userContent["Avatar"] = avatarData;
userContent.Save();
// ACTION
var result = ODataPATCH <ODataEntity>($"/OData.svc/Root/IMS/{testDomain.Name}('{testUser.Name}')",
"metadata=no&$select=Avatar,ImageRef,ImageData",
$"(models=[{{\"Avatar\": {testAvatar.Id}}}])");
// ASSERT
if (result is ODataError error)
{
Assert.AreEqual("", error.Message);
}
var entity = result as ODataEntity;
if (entity == null)
{
Assert.Fail($"Result is {result.GetType().Name} but ODataEntity is expected.");
}
var avatarString = entity.AllProperties["Avatar"].ToString();
Assert.IsTrue(avatarString.Contains("Url"));
Assert.IsTrue(avatarString.Contains(testAvatar.Path));
});
}
public OperationContext WopiSave(string lockValue, string newContent)
{
WopiHandler.ProcessPutFileRequest(LoadTestFile(), lockValue, RepositoryTools.GetStreamFromString(newContent));
return(this);
}
private DbFile UpdateFileTest(Node testRoot, string initialContent, string updatedContent, int sizeLimit)
{
using (new SystemAccount())
using (new SizeLimitSwindler(this, sizeLimit))
{
var file = new File(testRoot)
{
Name = "File1.file"
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString(initialContent));
file.Save();
var fileId = file.Id;
var blobProviderBefore = file.Binary.BlobProvider;
var fileRowIdBefore = file.Binary.FileId;
file = Node.Load <File>(fileId);
file.Binary.SetStream(RepositoryTools.GetStreamFromString(updatedContent));
// action
file.Save();
// assert
var blobProviderAfter = file.Binary.BlobProvider;
var fileRowIdAfter = file.Binary.FileId;
// if blob provider before and after is built-in, the existing file row is updated, else re-created.
if (blobProviderAfter == null && blobProviderBefore == null)
{
Assert.AreEqual(fileRowIdBefore, fileRowIdAfter);
}
else
{
Assert.AreNotEqual(fileRowIdBefore, fileRowIdAfter);
}
var dbFiles = BlobStoragePlatform.LoadDbFiles(file.VersionId);
Assert.AreEqual(1, dbFiles.Length);
var dbFile = dbFiles[0];
//Assert.AreNotEqual(initialBlobId, file.Binary.FileId);
if (NeedExternal(BlobStoragePlatform.ExpectedBlobProviderDataType, updatedContent, sizeLimit))
{
Assert.AreEqual(BlobStoragePlatform.ExpectedExternalBlobProviderType.FullName, dbFile.BlobProvider);
Assert.IsNotNull(dbFile.BlobProviderData);
}
else
{
Assert.IsNull(dbFile.BlobProvider);
Assert.IsNull(dbFile.BlobProviderData);
}
Assert.AreEqual(false, dbFile.IsDeleted);
Assert.AreEqual(false, dbFile.Staging);
Assert.AreEqual(0, dbFile.StagingVersionId);
Assert.AreEqual(0, dbFile.StagingPropertyTypeId);
if (updatedContent.Length == 0)
{
Assert.AreEqual(0, dbFile.Size);
}
else
{
Assert.AreEqual(updatedContent.Length + 3, dbFile.Size);
}
return(dbFile);
}
}
private DbFile[] CopyFileRowTest(string initialContent, string updatedText, int sizeLimit)
{
using (new SystemAccount())
using (new SizeLimitSwindler(this, sizeLimit))
{
var testRoot = CreateTestRoot();
var target = new SystemFolder(testRoot)
{
Name = "Target"
};
target.Save();
var file = new File(testRoot)
{
Name = "File1.file"
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString(initialContent));
file.Save();
// action
file.CopyTo(target);
// assert
var copy = Node.Load <File>(RepositoryPath.Combine(target.Path, file.Name));
Assert.AreNotEqual(file.Id, copy.Id);
Assert.AreNotEqual(file.VersionId, copy.VersionId);
Assert.AreEqual(file.Binary.FileId, copy.Binary.FileId);
// action 2
copy.Binary.SetStream(RepositoryTools.GetStreamFromString(updatedText));
copy.Save();
// assert 2
Assert.AreNotEqual(file.Binary.FileId, copy.Binary.FileId);
var dbFiles = new DbFile[2];
var loadedDbFiles = BlobStoragePlatform.LoadDbFiles(file.VersionId);
Assert.AreEqual(1, loadedDbFiles.Length);
dbFiles[0] = loadedDbFiles[0];
loadedDbFiles = BlobStoragePlatform.LoadDbFiles(copy.VersionId);
Assert.AreEqual(1, loadedDbFiles.Length);
dbFiles[1] = loadedDbFiles[0];
if (NeedExternal(BlobStoragePlatform.ExpectedBlobProviderDataType, initialContent, sizeLimit))
{
Assert.AreEqual(BlobStoragePlatform.ExpectedExternalBlobProviderType.FullName, dbFiles[0].BlobProvider);
Assert.IsNotNull(dbFiles[0].BlobProviderData);
}
else
{
Assert.IsNull(dbFiles[0].BlobProvider);
Assert.IsNull(dbFiles[0].BlobProviderData);
}
Assert.AreEqual(false, dbFiles[0].IsDeleted);
Assert.AreEqual(false, dbFiles[0].Staging);
Assert.AreEqual(0, dbFiles[0].StagingVersionId);
Assert.AreEqual(0, dbFiles[0].StagingPropertyTypeId);
Assert.AreEqual(initialContent.Length + 3, dbFiles[0].Size);
if (NeedExternal(BlobStoragePlatform.ExpectedBlobProviderDataType, updatedText, sizeLimit))
{
Assert.AreEqual(BlobStoragePlatform.ExpectedExternalBlobProviderType.FullName, dbFiles[1].BlobProvider);
Assert.IsNotNull(dbFiles[1].BlobProviderData);
}
else
{
Assert.IsNull(dbFiles[1].BlobProvider);
Assert.IsNull(dbFiles[1].BlobProviderData);
}
Assert.AreEqual(false, dbFiles[1].IsDeleted);
Assert.AreEqual(false, dbFiles[1].Staging);
Assert.AreEqual(0, dbFiles[1].StagingVersionId);
Assert.AreEqual(0, dbFiles[1].StagingPropertyTypeId);
Assert.AreEqual(updatedText.Length + 3, dbFiles[1].Size);
return(dbFiles);
}
}
public override void Execute(ExecutionContext context)
{
context.AssertRepositoryStarted();
if (string.IsNullOrEmpty(ContentName))
{
throw new PackagingException(string.Format(SR.Errors.Content.InvalidContentName_1, ContentName));
}
if (string.IsNullOrEmpty(ClassName))
{
throw new PackagingException(string.Format(SR.Errors.Resource.AttributeIsMissing_1, "ClassName"));
}
if (Resources == null || !Resources.Any())
{
context.Console.WriteLine("Resources list is empty, no content was modified.");
return;
}
var resource = Node.Load <Resource>(RepositoryPath.Combine(RepositoryStructure.ResourceFolderPath, ContentName));
// if the resource content does not exist, create it
if (resource == null)
{
resource = new Resource(Node.LoadNode(RepositoryStructure.ResourceFolderPath))
{
Name = ContentName
};
var binData = new BinaryData {
FileName = new BinaryFileName(ContentName)
};
binData.SetStream(RepositoryTools.GetStreamFromString(EMPTY_RESOURCE));
resource.Binary = binData;
resource.Save();
context.Console.WriteLine("NEW resource content: {0}", resource.Path);
}
else
{
context.Console.WriteLine("Adding resources to {0}.", resource.Path);
}
// load original resource xml
var xDoc = new XmlDocument();
using (var resStream = resource.Binary.GetStream())
{
xDoc.Load(resStream);
}
// load or create the class element
var resClassElement = LoadOrAddElement(xDoc.DocumentElement, string.Format("ResourceClass[@name='{0}']", ClassName), "ResourceClass",
new Dictionary <string, string>
{
{ "name", ClassName }
},
@"<Languages></Languages>");
// iterate through the resource elements in the step definition
foreach (var resourceElement in Resources)
{
// check step metadata
var keyAttr = resourceElement.Attributes["key"];
var langAttr = resourceElement.Attributes["lang"];
if (keyAttr == null || string.IsNullOrEmpty(keyAttr.Value))
{
throw new PackagingException(string.Format(SR.Errors.Resource.AttributeIsMissing_1, "key"));
}
if (langAttr == null || string.IsNullOrEmpty(langAttr.Value))
{
throw new PackagingException(string.Format(SR.Errors.Resource.AttributeIsMissing_1, "lang"));
}
// main operation: add or modify xml elements for one resource
AddOrEditResource(resClassElement, ClassName, langAttr.Value, keyAttr.Value, resourceElement.InnerXml, context);
}
// save the resource content
using (var resStream = RepositoryTools.GetStreamFromString(xDoc.OuterXml))
{
resource.Binary.SetStream(resStream);
resource.Save(SavingMode.KeepVersion);
}
}
protected override void Execute(NativeActivityContext context)
{
var message = Message.Get(context);
var parentPath = ParentPath.Get(context);
var overwrite = OverwriteExistingContent.Get(context);
var displayName = ContentDisplayName.Get(context);
var name = ContentName.Get(context);
if (string.IsNullOrEmpty(name))
{
name = ContentNamingProvider.GetNameFromDisplayName(displayName) + ".eml";
}
var parent = Node.LoadNode(parentPath);
if (parent == null)
{
throw new ApplicationException("Cannot create content because parent does not exist. Path: " + parentPath);
}
// check existing file
var node = Node.LoadNode(RepositoryPath.Combine(parentPath, name));
File file;
if (node == null)
{
// file does not exist, create new one
file = new File(parent);
if (!string.IsNullOrEmpty(displayName))
{
file.DisplayName = displayName;
}
file.Name = name;
}
else
{
// file exists
if (overwrite)
{
// overwrite it, so we open it
file = node as File;
// node exists and it is not a file -> delete it and create a new one
if (file == null)
{
try
{
node.ForceDelete();
}
catch
{
SnLog.WriteError("Mail processor workflow: content could not be deleted during saving the email. Path: " + node.Path);
return;
}
file = new File(parent);
}
file.DisplayName = displayName;
file.Name = name;
}
else
{
// do not overwrite it
file = new File(parent);
if (!string.IsNullOrEmpty(displayName))
{
file.DisplayName = displayName;
}
file.Name = name;
file.AllowIncrementalNaming = true;
}
}
try
{
var binaryData = new BinaryData()
{
FileName = name
};
binaryData.SetStream(RepositoryTools.GetStreamFromString(message.Body));
file.Binary = binaryData;
file.Save();
}
catch (Exception ex)
{
SnLog.WriteException(ex);
}
}
public void Versioning_History_LongHistory()
{
Test(() =>
{
//SnTrace.Test.Write("<?--------------------------------- 01 Start");
const string fileName = "LongHistory.txt";
const string fileBinary = @"Lorem ipsum ...";
var root = new SystemFolder(Repository.Root)
{
Name = Guid.NewGuid().ToString()
};
root.Save();
var test = new File(root)
{
Name = fileName
};
test.Binary.SetStream(RepositoryTools.GetStreamFromString(fileBinary));
test.Binary.FileName = fileName;
test.Save();
//------------ Approving: False, Versioning: None
test.VersioningMode = VersioningType.None;
test.ApprovingMode = ApprovingType.False;
//SnTrace.Test.Write("<?--------------------------------- Versioning: None, Approving False");
test.Description = "Init_Value";
//SnTrace.Test.Write("<?--------------------------------- 02 Save");
test.Save();
AssertVersionHistory(test, "V1.0.A", "#1");
AssertPropertyValues(test, false, "Init_Value", "#1");
//SnTrace.Test.Write("<?--------------------------------- 03 CheckOut");
test.CheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.L", "#2");
test.Description = "After-CheckOut";
test.TrashDisabled = true;
//SnTrace.Test.Write("<?--------------------------------- 04 Save");
test.Save();
AssertVersionHistory(test, "V1.0.A V2.0.L", "#3");
AssertPropertyValues(test, true, "After-CheckOut", "#3");
//SnTrace.Test.Write("<?--------------------------------- 05 CheckIn");
test.CheckIn();
AssertVersionHistory(test, "V1.0.A", "#4");
//SnTrace.Test.Write("<?--------------------------------- 06 CheckOut");
test.CheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.L", "#5");
test.Description = "Before-Undo";
test.TrashDisabled = false;
//SnTrace.Test.Write("<?--------------------------------- 07 Save");
test.Save();
AssertVersionHistory(test, "V1.0.A V2.0.L", "#6");
AssertPropertyValues(test, false, "Before-Undo", "#6");
//SnTrace.Test.Write("<?--------------------------------- 08 UndoCheckOut");
test.UndoCheckOut();
AssertVersionHistory(test, "V1.0.A", "#7");
AssertPropertyValues(test, true, "After-CheckOut", "#7");
//------------ Approving: False, Versioning: Major
test.VersioningMode = VersioningType.MajorOnly;
test.ApprovingMode = ApprovingType.False;
//SnTrace.Test.Write("<?--------------------------------- Versioning: MajorOnly, Approving False");
//SnTrace.Test.Write("<?--------------------------------- 09 Save");
test.Save(SavingMode.KeepVersion);
AssertVersionHistory(test, "V1.0.A", "#8");
//SnTrace.Test.Write("<?--------------------------------- 10 CheckOut");
test.CheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.L", "#9");
//SnTrace.Test.Write("<?--------------------------------- 11 Save");
test.Save();
AssertVersionHistory(test, "V1.0.A V2.0.L", "#10");
//SnTrace.Test.Write("<?--------------------------------- 12 CheckIn");
test.CheckIn();
AssertVersionHistory(test, "V1.0.A V2.0.A", "#11");
test.Description = "OFF-Major-BeforeCheckOut";
test.TrashDisabled = false;
//SnTrace.Test.Write("<?--------------------------------- 13 Save");
test.Save();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A", "#12");
AssertPropertyValues(test, false, "OFF-Major-BeforeCheckOut", "#12");
//SnTrace.Test.Write("<?--------------------------------- 14 CheckOut");
test.CheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V4.0.L", "#13");
test.Description = "OFF-Major-BeforeUndo";
test.TrashDisabled = true;
//SnTrace.Test.Write("<?--------------------------------- 15 Save");
test.Save();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V4.0.L", "#14");
AssertPropertyValues(test, true, "OFF-Major-BeforeUndo", "#14");
//SnTrace.Test.Write("<?--------------------------------- 16 UndoCheckOut");
test.UndoCheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A", "#15");
AssertPropertyValues(test, false, "OFF-Major-BeforeCheckOut", "#15");
//------------ Approving: False, Versioning: MajorAndMinor
test.VersioningMode = VersioningType.MajorAndMinor;
test.ApprovingMode = ApprovingType.False;
//SnTrace.Test.Write("<?--------------------------------- Versioning: MajorAndMinor, Approving False");
//SnTrace.Test.Write("<?--------------------------------- 17 Save");
test.Save(SavingMode.KeepVersion);
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A", "#16");
//SnTrace.Test.Write("<?--------------------------------- 18 CheckOut");
test.CheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.L", "#17");
//SnTrace.Test.Write("<?--------------------------------- 19 Save");
test.Save();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.L", "#18");
//SnTrace.Test.Write("<?--------------------------------- 20 CheckIn");
test.CheckIn();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D", "#19");
//SnTrace.Test.Write("<?--------------------------------- 21 CheckOut");
test.CheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.L", "#20");
//SnTrace.Test.Write("<?--------------------------------- 22 Save");
test.Save();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.L", "#21");
//SnTrace.Test.Write("<?--------------------------------- 23 UndoCheckOut");
test.UndoCheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D", "#22");
//SnTrace.Test.Write("<?--------------------------------- 24 Save");
test.Save(SavingMode.RaiseVersionAndLock);
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.L", "#23");
//SnTrace.Test.Write("<?--------------------------------- 25 CheckIn");
test.CheckIn();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.D", "#24");
//SnTrace.Test.Write("<?--------------------------------- 26 Save");
test.Save(SavingMode.RaiseVersionAndLock);
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.D V3.3.L", "#25");
//SnTrace.Test.Write("<?--------------------------------- 27 UndoCheckOut");
test.UndoCheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.D", "#26");
//SnTrace.Test.Write("<?--------------------------------- 28 CheckOut");
test.CheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.D V3.3.L", "#27");
//SnTrace.Test.Write("<?--------------------------------- 29 Save");
test.Save();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.D V3.3.L", "#28");
//SnTrace.Test.Write("<?--------------------------------- 30 CheckIn");
test.CheckIn();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.D V3.3.D", "#29");
//SnTrace.Test.Write("<?--------------------------------- 31 CheckOut");
test.CheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.D V3.3.D V3.4.L", "#30");
//SnTrace.Test.Write("<?--------------------------------- 32 Save");
test.Save();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.D V3.3.D V3.4.L", "#31");
//SnTrace.Test.Write("<?--------------------------------- 33 CheckIn");
test.CheckIn();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.D V3.3.D V3.4.D", "#32");
//------------ Approving: True, Versioning: None
test.VersioningMode = VersioningType.None;
test.ApprovingMode = ApprovingType.True;
//SnTrace.Test.Write("<?--------------------------------- Versioning: None, Approving True");
//SnTrace.Test.Write("<?--------------------------------- 34 Save");
test.Save(SavingMode.KeepVersion);
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.D V3.3.D V3.4.D", "#33");
//SnTrace.Test.Write("<?--------------------------------- 35 CheckOut");
test.CheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.D V3.3.D V3.4.D V4.0.L", "#34");
test.Description = "ON-None-Before-CheckOut";
test.TrashDisabled = false;
//SnTrace.Test.Write("<?--------------------------------- 36 CheckIn");
test.CheckIn();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V4.0.P", "#35");
AssertPropertyValues(test, false, "ON-None-Before-CheckOut", "#35");
//SnTrace.Test.Write("<?--------------------------------- 37 Reject");
test.Reject();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V4.0.R", "#36");
//SnTrace.Test.Write("<?--------------------------------- 38 CheckOut");
test.CheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V4.0.R V5.0.L", "#37");
//SnTrace.Test.Write("<?--------------------------------- 39 Save");
test.Save();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V4.0.R V5.0.L", "#38");
//SnTrace.Test.Write("<?--------------------------------- 40 CheckIn");
test.CheckIn();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V4.0.R V5.0.P", "#39");
//SnTrace.Test.Write("<?--------------------------------- 41 Approve");
test.Approve();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A", "#40");
//------------ Approving: True, Versioning: MajorAndMinor
test.VersioningMode = VersioningType.MajorAndMinor;
test.ApprovingMode = ApprovingType.True;
//SnTrace.Test.Write("<?--------------------------------- Versioning: MajorAndMinor, Approving True");
//SnTrace.Test.Write("<?--------------------------------- 42 Save");
test.Save();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D", "#41");
//SnTrace.Test.Write("<?--------------------------------- 43 CheckOut");
test.CheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.L", "#42");
test.Description = "ON-MajorMinor-BeforeCheckIn";
test.TrashDisabled = true;
//SnTrace.Test.Write("<?--------------------------------- 44 CheckIn");
test.CheckIn();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.D", "#43");
AssertPropertyValues(test, true, "ON-MajorMinor-BeforeCheckIn", "#43");
//SnTrace.Test.Write("<?--------------------------------- 45 Publish");
test.Publish();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.P", "#44");
AssertPropertyValues(test, true, "ON-MajorMinor-BeforeCheckIn", "#44");
//SnTrace.Test.Write("<?--------------------------------- 46 Reject");
test.Reject();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.R", "#45");
//SnTrace.Test.Write("<?--------------------------------- 47 CheckOut");
test.CheckOut();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.R V3.3.L", "#46");
//SnTrace.Test.Write("<?--------------------------------- 48 Publish");
test.Publish();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.R V3.3.P", "#47");
//SnTrace.Test.Write("<?--------------------------------- 49 Approve");
test.Approve();
AssertVersionHistory(test, "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.R V4.0.A", "#48");
//this must never change
const string oldHistory = "V1.0.A V2.0.A V3.0.A V3.1.D V3.2.R ";
//SnTrace.Test.Write("<?--------------------------------- 50 CheckOut");
test.CheckOut();
AssertVersionHistory(test, oldHistory + "V4.0.A V4.1.L", "#49");
//SnTrace.Test.Write("<?--------------------------------- 51 CheckIn");
test.CheckIn();
AssertVersionHistory(test, oldHistory + "V4.0.A V4.1.D", "#50");
//SnTrace.Test.Write("<?--------------------------------- 52 CheckOut");
test.CheckOut();
AssertVersionHistory(test, oldHistory + "V4.0.A V4.1.D V4.2.L", "#51");
//SnTrace.Test.Write("<?--------------------------------- 53 Publish");
test.Publish();
AssertVersionHistory(test, oldHistory + "V4.0.A V4.1.D V4.2.P", "#52");
//SnTrace.Test.Write("<?--------------------------------- 54 Reject");
test.Reject();
AssertVersionHistory(test, oldHistory + "V4.0.A V4.1.D V4.2.R", "#53");
//SnTrace.Test.Write("<?--------------------------------- 55 Publish");
test.Publish();
AssertVersionHistory(test, oldHistory + "V4.0.A V4.1.D V4.2.R V4.3.P", "#54");
//SnTrace.Test.Write("<?--------------------------------- 56 Reject");
test.Reject();
AssertVersionHistory(test, oldHistory + "V4.0.A V4.1.D V4.2.R V4.3.R", "#54");
//SnTrace.Test.Write("<?--------------------------------- 57 CheckOut");
test.CheckOut();
AssertVersionHistory(test, oldHistory + "V4.0.A V4.1.D V4.2.R V4.3.R V4.4.L", "#55");
//------------ Approving: True, Versioning: Major
test.VersioningMode = VersioningType.MajorOnly;
test.ApprovingMode = ApprovingType.True;
//SnTrace.Test.Write("<?--------------------------------- Versioning: MajorOnly, Approving True");
//SnTrace.Test.Write("<?--------------------------------- 58 CheckIn");
test.CheckIn();
AssertVersionHistory(test, oldHistory + "V4.0.A V4.1.D V4.2.R V4.3.R V4.4.P", "#56");
//SnTrace.Test.Write("<?--------------------------------- 59 Reject");
test.Reject();
AssertVersionHistory(test, oldHistory + "V4.0.A V4.1.D V4.2.R V4.3.R V4.4.R", "#57");
//SnTrace.Test.Write("<?--------------------------------- 60 CheckOut");
test.CheckOut();
AssertVersionHistory(test, oldHistory + "V4.0.A V4.1.D V4.2.R V4.3.R V4.4.R V5.0.L", "#58");
test.Description = "ON-Major-Before-CheckIn";
test.TrashDisabled = false;
//SnTrace.Test.Write("<?--------------------------------- 61 CheckIn");
test.CheckIn();
AssertVersionHistory(test, oldHistory + "V4.0.A V4.1.D V4.2.R V4.3.R V4.4.R V5.0.P", "#59");
AssertPropertyValues(test, false, "ON-Major-Before-CheckIn", "#59");
//SnTrace.Test.Write("<?--------------------------------- 62 Approve");
test.Approve();
AssertVersionHistory(test, oldHistory + "V4.0.A V5.0.A", "#60");
AssertPropertyValues(test, false, "ON-Major-Before-CheckIn", "#60");
});
}
public void Indexing_TextExtraction()
{
Test(() =>
{
// Define a custom filename extension.
var ext = "testext";
// Create custom textextractor with log and IsSlow = true.
var extractor = new CustomTextExtractor();
// Hack textextractor for filename custom extension.
var extractorSettings = @"{TextExtractors: {""" + ext + @""": """ + typeof(CustomTextExtractor).FullName + @"""}}";
var settingsFile = Settings.GetSettingsByName <IndexingSettings>(IndexingSettings.SettingsName, Repository.RootPath);
settingsFile.Binary.SetStream(RepositoryTools.GetStreamFromString(extractorSettings));
settingsFile.Save();
try
{
// Create file with the custom filename extension.
var testRoot = new SystemFolder(Repository.Root)
{
Name = "TestRoot"
};
testRoot.Save();
var file = new File(testRoot)
{
Name = "TestFile." + ext
};
// Write some well known words into the file's binary.
var text = "tema tis rolod muspi meroL";
var binaryData = new BinaryData()
{
FileName = file.Name
};
binaryData.SetStream(RepositoryTools.GetStreamFromString(text));
file.Binary = binaryData;
// Save the file.
file.Save();
var fileId = file.Id;
// Check and reset the custom extractor's log.
var called = CustomTextExtractor.Called;
var extraction = CustomTextExtractor.Extraction;
CustomTextExtractor.Reset();
Assert.IsTrue(called);
Assert.AreEqual(text, extraction);
// Check the index with queries by well known words in the default (_Text) and "Binary" field.
var words = text.Split(' ');
var results = new []
{
CreateSafeContentQuery($"+{words[4]} +Name:{file.Name} .AUTOFILTERS:OFF").Execute().Nodes.ToArray(),
CreateSafeContentQuery($"+{words[0]} +{words[2]} +Name:{file.Name} .AUTOFILTERS:OFF").Execute().Nodes.ToArray(),
CreateSafeContentQuery($"+{words[1]} +{words[3]} +Name:{file.Name} .AUTOFILTERS:OFF").Execute().Nodes.ToArray(),
};
Assert.AreEqual(1, results[0].Length);
Assert.AreEqual(1, results[1].Length);
Assert.AreEqual(1, results[2].Length);
var expectedIds = $"{fileId}, {fileId}, {fileId}";
var actualIds = string.Join(", ", results.Select(r => r.First().Id.ToString()).ToArray());
Assert.AreEqual(expectedIds, actualIds);
}
finally
{
// Remove the hack.
settingsFile.Binary.SetStream(RepositoryTools.GetStreamFromString(null));
settingsFile.Save();
}
});
}
private void CreateStructure(User user, out SystemFolder myFolder, out File myFile)
{
using (CurrentUserBlock(user))
{
using (new SystemAccount())
{
var contentFolder = Node.LoadNode("/Root/Content");
myFolder = new SystemFolder(contentFolder)
{
Name = "MyFolder",
Description = "Sample folder...",
InheritableVersioningMode = InheritableVersioningType.MajorAndMinor,
Version = new VersionNumber(1, 0, VersionStatus.Approved)
};
myFolder.Save();
myFile = new File(myFolder)
{
Name = "MyFile.txt", Description = "Sample file...."
};
myFile.Binary.SetStream(RepositoryTools.GetStreamFromString(new string('-', 42)));
myFile.Save();
myFile.Publish(); // 1.0.A
myFile.CheckOut();
myFile.Binary.SetStream(RepositoryTools.GetStreamFromString(new string('-', 43)));
myFile.Save();
myFile.CheckIn(); // 1.1.D
myFile.CheckOut();
myFile.Binary.SetStream(RepositoryTools.GetStreamFromString(new string('-', 44)));
myFile.Save();
myFile.CheckIn(); // 1.2.D
myFile.Publish(); // 2.0.A
myFile.CheckOut();
myFile.Binary.SetStream(RepositoryTools.GetStreamFromString(new string('-', 45)));
myFile.Save();
myFile.CheckIn(); // 2.1.D
myFile.CheckOut();
myFile.Binary.SetStream(RepositoryTools.GetStreamFromString(new string('-', 46)));
myFile.Save();
myFile.CheckIn(); // 2.2.D
myFile.CheckOut();
myFile.Binary.SetStream(RepositoryTools.GetStreamFromString(new string('-', 47)));
myFile.Save();
myFile.CheckIn(); // 2.3.D
}
}
var previewRoot = new SystemFolder(myFile)
{
Name = "Previews",
VersioningMode = VersioningType.None,
InheritableVersioningMode = InheritableVersioningType.None
};
previewRoot.Save();
CreateSamplePreviewImages(previewRoot, "V1.0.A");
CreateSamplePreviewImages(previewRoot, "V1.1.D");
CreateSamplePreviewImages(previewRoot, "V2.0.A");
CreateSamplePreviewImages(previewRoot, "V2.1.D");
CreateSamplePreviewImages(previewRoot, "V2.2.D");
CreateSamplePreviewImages(previewRoot, "V2.3.D");
}
