public string NewMediaObject(FileData mediaObject)
{
var mediaFile = new WorkflowMediaFile
{
FileName = mediaObject.name,
Title = mediaObject.name,
Culture = DataLocalizationFacade.DefaultLocalizationCulture.Name,
Length = mediaObject.bits.Count(),
MimeType = MimeTypeInfo.GetCanonical(mediaObject.type)
};
if (mediaFile.MimeType == MimeTypeInfo.Default)
{
mediaFile.MimeType = MimeTypeInfo.GetCanonicalFromExtension(Path.GetExtension(mediaFile.FileName));
}
using (Stream readStream = new MemoryStream(mediaObject.bits))
{
using (Stream writeStream = mediaFile.GetNewWriteStream())
{
readStream.CopyTo(writeStream);
}
}
string folderPath = string.Format("/Blog/{0}/{1:yyyy-MM-dd}", Author.Name, DateTime.Now);
mediaFile.FolderPath = ForceGetMediaFolderPath(folderPath);
var addedFile = DataFacade.AddNew <IMediaFile>(mediaFile);
return(MediaUrlHelper.GetUrl(addedFile));
}
static string GetExtension(IMediaFile mediaFile)
{
string extension;
try
{
var fileName = mediaFile.FileName;
foreach (var ch in Path.GetInvalidFileNameChars())
{
fileName = fileName.Replace(ch, '_');
}
extension = Path.GetExtension(fileName);
}
catch (ArgumentException)
{
return(null);
}
if (string.IsNullOrEmpty(extension))
{
extension = MimeTypeInfo.GetExtensionFromMimeType(mediaFile.MimeType);
}
return(extension);
}
private IEnumerable <Element> GetSharedCodeElements(SearchToken searchToken)
{
var result = new List <Element>();
foreach (SharedFile sharedFile in PageTemplateFacade.GetSharedFiles())
{
string relativeFilePath = sharedFile.RelativeFilePath;
string fullPath = relativeFilePath.StartsWith("~") ? PathUtil.Resolve(relativeFilePath) : relativeFilePath;
var websiteFile = new WebsiteFile(fullPath);
Element element = new Element(_context.CreateElementHandle(new SharedCodeFileEntityToken(relativeFilePath)))
{
VisualData = new ElementVisualizedData()
{
Label = websiteFile.FileName,
ToolTip = websiteFile.FileName,
HasChildren = false,
Icon = FileElementProvider.WebsiteFileIcon(websiteFile.MimeType),
OpenedIcon = FileElementProvider.WebsiteFileIcon(websiteFile.MimeType)
}
};
element.PropertyBag.Add("Uri", PathUtil.GetWebsitePath(websiteFile.FullPath));
element.PropertyBag.Add("ElementType", websiteFile.MimeType);
// Adding "Edit" action for text-editable files
if (sharedFile.DefaultEditAction && MimeTypeInfo.IsTextFile(websiteFile.MimeType))
{
element.AddWorkflowAction(
"Composite.Plugins.Elements.ElementProviders.PageTemplateElementProvider.EditSharedCodeFileWorkflow",
new[] { PermissionType.Edit },
new ActionVisualizedData
{
Label = GetResourceString("EditSharedCodeFile.Label"),
ToolTip = GetResourceString("EditSharedCodeFile.ToolTip"),
Icon = CommonCommandIcons.Edit,
Disabled = websiteFile.IsReadOnly,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Edit,
IsInFolder = false,
IsInToolbar = true,
ActionGroup = EditCodeFileActionGroup
}
});
}
var customActions = sharedFile.GetActions();
foreach (var action in customActions)
{
element.AddAction(action);
}
result.Add(element);
}
return(result);
}
private void CopyFileData(IMediaFile from, IMediaFileData to)
{
to.CultureInfo = from.Culture;
to.Description = from.Description;
to.FileName = from.FileName;
to.FolderPath = from.FolderPath;
to.Length = from.Length;
to.MimeType = MimeTypeInfo.GetCanonical(from.MimeType);
to.Title = from.Title;
}
private IMediaFile ImportMedia(string src, string folder)
{
if (!ImportedImages.ContainsKey("src"))
{
ImportedImages[src] = null;
ForceMediaFolder(folder);
var client = new WebClient
{
Encoding = System.Text.Encoding.UTF8
};
client.Headers.Add("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; .NET CLR 1.0.3705;)");
var stream = client.OpenRead(src);
var filename = CleanFileName(Path.GetFileName(src));
var title = Path.GetFileNameWithoutExtension(src);
var mediaFile = new WorkflowMediaFile
{
FileName = Path.GetFileName(filename),
FolderPath = folder,
Title = title,
Description = string.Empty,
Culture = Composite.C1Console.Users.UserSettings.ActiveLocaleCultureInfo.Name,
MimeType = MimeTypeInfo.GetCanonicalFromExtension(Path.GetExtension(filename))
};
if (mediaFile.MimeType == MimeTypeInfo.Default)
{
mediaFile.MimeType = MimeTypeInfo.GetCanonical(client.ResponseHeaders["content-type"]);
}
using (Stream readStream = stream)
{
using (Stream writeStream = mediaFile.GetNewWriteStream())
{
readStream.CopyTo(writeStream);
}
}
int counter = 0;
string extension = Path.GetExtension(mediaFile.FileName);
string name = mediaFile.FileName.GetNameWithoutExtension();
while (Exists(mediaFile))
{
counter++;
mediaFile.FileName = name + counter.ToString() + extension;
}
IMediaFile addedFile = DataFacade.AddNew <IMediaFile>(mediaFile);
ImportedImages[src] = addedFile;
}
return(ImportedImages[src]);
}
private static bool IsEditActionAllowed(WebsiteEntity websiteEntity)
{
if (websiteEntity is WebsiteFile)
{
WebsiteFile websiteFile = websiteEntity as WebsiteFile;
return(MimeTypeInfo.IsTextFile(websiteFile.MimeType));
}
if (websiteEntity is WebsiteFolder)
{
return(false);
}
throw new NotImplementedException();
}
private static void Extract(string parentPath, Stream compressedStream,
out IList <IMediaFileFolder> folders, out IList <IMediaFile> files)
{
folders = new List <IMediaFileFolder>();
files = new List <IMediaFile>();
using (var zipArchive = new ZipArchive(compressedStream))
{
foreach (var entry in zipArchive.Entries)
{
if (entry.FullName.EndsWith("/"))
{
CreateFoldersRec(folders, parentPath, entry.FullName);
}
else
{
var directory = entry.FullName.GetDirectory('/');
string fileName = entry.Name;
var mediaFile = new WorkflowMediaFile
{
FileName = fileName,
Title = fileName.GetNameWithoutExtension(),
FolderPath = parentPath.Combine(directory, '/'),
CreationTime = DateTime.Now,
Culture = C1Console.Users.UserSettings.ActiveLocaleCultureInfo.Name,
LastWriteTime = DateTime.Now,
MimeType = MimeTypeInfo.GetCanonicalFromExtension(Path.GetExtension(fileName))
};
int length = CopyZipData(entry.Open(), mediaFile);
mediaFile.Length = length;
files.Add(mediaFile);
if (directory != "")
{
CreateFoldersRec(folders, parentPath, directory);
}
}
}
}
folders = folders.Distinct(new FolderComparer()).Where(x => x.Path != string.Empty).OrderBy(x => x.Path.Length).ToList();
}
private bool FilePreviewable(FileInfo fileInfo)
{
if (string.IsNullOrEmpty(fileInfo.Extension))
{
return(false);
}
string mimeType = MimeTypeInfo.GetCanonicalFromExtension(fileInfo.Extension);
if (string.IsNullOrEmpty(mimeType))
{
return(false);
}
return(MimeTypeInfo.IsBrowserPreviewableFile(mimeType) ||
(MimeTypeInfo.IsTextFile(mimeType) && fileInfo.Length < 1 << 20 /* 1 MB */));
}
private static string RemoveForbiddenCharactersAndNormalize(string path)
{
// Replacing dots with underscores, so IIS will not intercept requests in some scenarios
string legalFilePath = RemoveFilePathIllegalCharacters(path);
string extension = Path.GetExtension(legalFilePath);
if (!MimeTypeInfo.IsIisServeable(extension))
{
path = path.Replace('.', '_');
}
path = path.Replace('+', ' ');
foreach (var ch in ForbiddenUrlCharacters)
{
path = path.Replace(ch, '#');
}
path = path.Replace("#", string.Empty);
// Removing consecutive white spaces
while (path.Contains(" "))
{
path = path.Replace(" ", " ");
}
string[] parts = path.Split('/');
var result = new StringBuilder();
for (int i = 0; i < parts.Length; i++)
{
string trimmedPart = parts[i].Trim();
if (trimmedPart.Length > 0)
{
result.Append("/").Append(trimmedPart);
}
}
// Encoding white spaces
result.Replace(" ", "%20");
return(result.ToString());
}
private bool FilePreviewable(FileInfo fileInfo)
{
if (string.IsNullOrEmpty(fileInfo.Extension))
{
return(false);
}
string mimeType = MimeTypeInfo.GetCanonicalFromExtension(fileInfo.Extension);
if (string.IsNullOrEmpty(mimeType))
{
return(false);
}
return(MimeTypeInfo.IsBrowserPreviewableFile(mimeType) ||
(MimeTypeInfo.IsTextFile(mimeType) && fileInfo.Length < 1 << 20 /* 1 MB */) ||
fileInfo.Extension.Equals(".dll", StringComparison.OrdinalIgnoreCase));
}
private static void Extract(string parentPath, Stream compressedStream,
out IList <IMediaFileFolder> folders, out IList <IMediaFile> files)
{
folders = new List <IMediaFileFolder>();
files = new List <IMediaFile>();
using (ZipInputStream zipInputStream = new ZipInputStream(compressedStream))
{
ZipEntry theEntry;
while ((theEntry = zipInputStream.GetNextEntry()) != null)
{
if (theEntry.IsDirectory)
{
CreateFoldersRec(folders, parentPath, theEntry.Name);
}
else
{
string directory = theEntry.Name.GetDirectory('/');
WorkflowMediaFile mediaFile = new WorkflowMediaFile();
int length = CopyZipData(zipInputStream, mediaFile);
mediaFile.FileName = Path.GetFileName(theEntry.Name);
mediaFile.Title = mediaFile.FileName.GetNameWithoutExtension();
mediaFile.FolderPath = parentPath.Combine(directory, '/');
mediaFile.CreationTime = DateTime.Now;
mediaFile.Culture = C1Console.Users.UserSettings.ActiveLocaleCultureInfo.Name;
mediaFile.LastWriteTime = DateTime.Now;
mediaFile.Length = length;
mediaFile.MimeType = MimeTypeInfo.GetCanonicalFromExtension(Path.GetExtension(theEntry.Name));
files.Add(mediaFile);
if (directory != "")
{
CreateFoldersRec(folders, parentPath, directory);
}
}
}
}
folders = folders.Distinct(new FolderComparer()).Where(x => x.Path != string.Empty).OrderBy(x => x.Path.Length).ToList();
}
private void uploadCodeActivity_ExecuteCode(object sender, EventArgs e)
{
UpdateTreeRefresher updateTreeRefresher = this.CreateUpdateTreeRefresher(this.EntityToken);
FlowControllerServicesContainer flowControllerServicesContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
var managementConsoleMessageService = flowControllerServicesContainer.GetService <IManagementConsoleMessageService>();
UploadedFile uploadedFile = this.GetBinding <UploadedFile>("UploadedFile");
IMediaFile mediaFile = this.GetBinding <IMediaFile>("File");
if (uploadedFile.HasFile)
{
string mimeType = MimeTypeInfo.GetMimeType(uploadedFile);
// Image cannot be replaced with a file of not image mime type
string imageMimeTypePrefix = "image/";
if ((mediaFile.MimeType.StartsWith(imageMimeTypePrefix, StringComparison.OrdinalIgnoreCase) &&
!mimeType.StartsWith(imageMimeTypePrefix, StringComparison.OrdinalIgnoreCase)))
{
managementConsoleMessageService.CloseCurrentView();
string failure = StringResourceSystemFacade.GetString("Composite.Management", "UploadNewMediaFileWorkflow.UploadFailure");
string failureMessage = StringResourceSystemFacade.GetString("Composite.Management", "UploadNewMediaFileWorkflow.UploadFailureMessage");
managementConsoleMessageService.ShowMessage(DialogType.Message, failure, failureMessage);
return;
}
using (System.IO.Stream readStream = uploadedFile.FileStream)
{
using (System.IO.Stream writeStream = mediaFile.GetNewWriteStream())
{
readStream.CopyTo(writeStream);
}
}
}
DataFacade.Update(mediaFile);
SetSaveStatus(true);
SelectElement(mediaFile.GetDataEntityToken());
updateTreeRefresher.PostRefreshMesseges(mediaFile.GetDataEntityToken());
}
public BrowserViewSettings TryGetBrowserViewSettings(EntityToken entityToken, bool showPublishedView)
{
if (!(entityToken is DataEntityToken dataEntityToken) || dataEntityToken.InterfaceType != typeof(IMediaFile))
{
return(null);
}
var file = (IMediaFile)dataEntityToken.Data;
if (file == null || !MimeTypeInfo.IsBrowserPreviewableFile(file.MimeType))
{
return(null);
}
string url = MediaUrls.BuildUrl(file);
var urlBuilder = new UrlBuilder(url)
{
["download"] = "false"
};
return(new BrowserViewSettings {
Url = urlBuilder.ToString(), ToolingOn = false
});
}
private string GetTextToIndex(IMediaFile mediaFile)
{
var mimeType = MimeTypeInfo.GetCanonical(mediaFile.MimeType);
if (!IsIndexableMimeType(mimeType))
{
return(null);
}
// Checking if the parsing results are preserved in the cache
var outputFilePath = GetTextOutputFilePath(mediaFile);
var lastWriteTime = mediaFile.LastWriteTime ?? mediaFile.CreationTime;
if (File.Exists(outputFilePath) &&
lastWriteTime != null &&
File.GetCreationTime(outputFilePath) == lastWriteTime)
{
return(File.ReadAllText(outputFilePath));
}
string extension;
try
{
var fileName = mediaFile.FileName;
foreach (var ch in Path.GetInvalidFileNameChars())
{
fileName = fileName.Replace(ch, '_');
}
extension = Path.GetExtension(fileName);
}
catch (ArgumentException)
{
Log.LogWarning(LogTitle, $"Failed to extract extension from file: '{mediaFile.FileName}', mime type: '{mediaFile.MimeType}' ");
return(null);
}
if (string.IsNullOrEmpty(extension))
{
extension = MimeTypeInfo.GetExtensionFromMimeType(mediaFile.MimeType);
}
if (string.IsNullOrEmpty(extension))
{
Log.LogWarning(LogTitle, $"Failed to extract extension from file: '{mediaFile.FileName}', mime type: '{mediaFile.MimeType}' ");
return(null);
}
// Saving the file to a temp directory
var tempSourceFile = GetTempFileName(extension);
try
{
using (var mediaStream = mediaFile.GetReadStream())
using (var file = File.Create(tempSourceFile))
{
mediaStream.CopyTo(file);
}
}
catch (FileNotFoundException)
{
if (Interlocked.Increment(ref _missingFilesLogged) <= MaxMissingFilesLogMessages)
{
Log.LogWarning(LogTitle, $"Missing an underlying content file for the media file '{mediaFile.KeyPath}'");
}
return(null);
}
var exePath = PathUtil.Resolve(IFilterExecutableRelativePath);
var workingDirectory = Path.GetDirectoryName(exePath);
string stdout, stderr;
int exitCode;
using (var process = new Process
{
StartInfo =
{
WorkingDirectory = workingDirectory,
FileName = "\"" + exePath + "\"",
Arguments = $"\"{tempSourceFile}\" \"{outputFilePath}\"",
RedirectStandardOutput = true,
RedirectStandardError = true,
RedirectStandardInput = true,
CreateNoWindow = true,
StandardOutputEncoding = Encoding.UTF8,
UseShellExecute = false,
WindowStyle = ProcessWindowStyle.Hidden
}
})
{
process.Start();
stdout = process.StandardOutput.ReadToEnd();
stderr = process.StandardError.ReadToEnd();
process.WaitForExit();
exitCode = process.ExitCode;
}
C1File.Delete(tempSourceFile);
if (exitCode != 0)
{
var msg = $"Failed to parse the content of the media file '{Path.GetFileName(mediaFile.FileName)}'.";
if ((uint)exitCode == 0x80004005 /*E_FAIL*/)
{
Log.LogVerbose(LogTitle, msg + " Unspecified error.");
return(null);
}
if ((uint)exitCode == 0x80004002 /*E_NOINTERFACE*/)
{
Log.LogWarning(LogTitle, msg + " IFilter not found for the given file extension.");
return(null);
}
Log.LogWarning(LogTitle,
msg +
$"\r\nExit Code: {exitCode}\r\nOutput: {stdout}"
+ (!string.IsNullOrEmpty(stderr) ? $"\r\nError: {stderr}" : ""));
return(null);
}
if (!File.Exists(outputFilePath))
{
return(null);
}
if (lastWriteTime != null)
{
File.SetLastWriteTime(outputFilePath, lastWriteTime.Value);
}
return(File.ReadAllText(outputFilePath));
}
private void finalizeCodeActivity_Finalize_ExecuteCode(object sender, EventArgs e)
{
AddNewTreeRefresher addNewTreeRefresher = this.CreateAddNewTreeRefresher(this.EntityToken);
UploadedFile uploadedFile = this.GetBinding <UploadedFile>("UploadedFile");
string filename;
if (this.BindingExist("Filename"))
{
filename = this.GetBinding <string>("Filename");
}
else
{
filename = uploadedFile.FileName;
}
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
IMediaFileStore store = DataFacade.GetData <IMediaFileStore>(x => x.Id == this.StoreId).First();
IMediaFile existingFile = GetExistingFile(this.FolderPath, filename);
if (existingFile == null)
{
WorkflowMediaFile mediaFile = new WorkflowMediaFile();
mediaFile.FileName = System.IO.Path.GetFileName(filename);
mediaFile.FolderPath = this.FolderPath;
mediaFile.Title = this.GetBinding <string>("Title");
mediaFile.Description = this.GetBinding <string>("Description");
mediaFile.Tags = this.GetBinding <string>("Tags");
mediaFile.Culture = C1Console.Users.UserSettings.ActiveLocaleCultureInfo.Name;
mediaFile.Length = uploadedFile.ContentLength;
mediaFile.MimeType = MimeTypeInfo.GetMimeType(uploadedFile);
using (System.IO.Stream readStream = uploadedFile.FileStream)
{
using (System.IO.Stream writeStream = mediaFile.GetNewWriteStream())
{
readStream.CopyTo(writeStream);
}
}
IMediaFile addedFile = DataFacade.AddNew <IMediaFile>(mediaFile, store.DataSourceId.ProviderName);
addNewTreeRefresher.PostRefreshMesseges(addedFile.GetDataEntityToken());
SelectElement(addedFile.GetDataEntityToken());
}
else
{
Guid fileId = existingFile.Id;
IMediaFileData fileData = DataFacade.GetData <IMediaFileData>(file => file.Id == fileId).FirstOrDefault();
fileData.Title = this.GetBinding <string>("Title");
fileData.Description = this.GetBinding <string>("Description");
fileData.Tags = this.GetBinding <string>("Tags");
fileData.MimeType = MimeTypeInfo.GetMimeType(uploadedFile);
fileData.Length = uploadedFile.ContentLength;
using (System.IO.Stream readStream = uploadedFile.FileStream)
{
using (System.IO.Stream writeStream = existingFile.GetNewWriteStream())
{
readStream.CopyTo(writeStream);
}
}
DataFacade.Update(existingFile);
DataFacade.Update(fileData);
addNewTreeRefresher.PostRefreshMesseges(existingFile.GetDataEntityToken());
SelectElement(existingFile.GetDataEntityToken());
}
transactionScope.Complete();
}
}
private string GetTextToIndex(IMediaFile mediaFile)
{
var mimeType = MimeTypeInfo.GetCanonical(mediaFile.MimeType);
if (!IsIndexableMimeType(mimeType))
{
return(null);
}
// Checking if the parsing results are preserved in the cache
var outputFilePath = GetTextOutputFilePath(mediaFile);
var lastWriteTime = mediaFile.LastWriteTime ?? mediaFile.CreationTime;
if (File.Exists(outputFilePath) &&
lastWriteTime != null &&
File.GetCreationTime(outputFilePath) == lastWriteTime)
{
string text = File.ReadAllText(outputFilePath);
if (!string.IsNullOrEmpty(text))
{
return(text);
}
}
string extension = GetExtension(mediaFile);
if (string.IsNullOrEmpty(extension))
{
Log.LogWarning(LogTitle, $"Failed to extract extension from file: '{mediaFile.FileName}', mime type: '{mediaFile.MimeType}' ");
return(null);
}
// Saving the file to a temp directory
var tempSourceFile = GetTempFileName(extension);
try
{
using (var mediaStream = mediaFile.GetReadStream())
using (var file = File.Create(tempSourceFile))
{
mediaStream.CopyTo(file);
}
}
catch (FileNotFoundException)
{
if (Interlocked.Increment(ref _missingFilesLogged) <= MaxMissingFilesLogMessages)
{
Log.LogWarning(LogTitle, $"Missing an underlying content file for the media file '{mediaFile.KeyPath}'");
}
return(null);
}
bool success = ExtractText(tempSourceFile, outputFilePath, mediaFile);
C1File.Delete(tempSourceFile);
if (!success)
{
return(null);
}
if (lastWriteTime != null)
{
File.SetLastWriteTime(outputFilePath, lastWriteTime.Value);
}
var result = File.ReadAllText(outputFilePath);
if (result.Length == 0)
{
Log.LogWarning(LogTitle, $"Failed to extract text from media file '{mediaFile.FileName}', mime type: '{mediaFile.MimeType}', extension '{extension}'");
}
return(result);
}
private string GetLocalizedLabel(string mimeType) => MimeTypeInfo.TryGetLocalizedName(mimeType) ?? mimeType;
internal static ResourceHandle WebsiteFileIcon(string mimeType)
{
return(MimeTypeInfo.GetResourceHandleFromMimeType(MimeTypeInfo.GetCanonical(mimeType)));
}
