public string Execute([NotNull] string databaseName, [NotNull] string id)
{
var database = Factory.GetDatabase(databaseName);
if (database == null)
{
throw new Exception("Database not found");
}
var item = database.GetItem(id);
Debug.Assert(item != null, "Item \"" + id + "\" not found.");
var fileName = FileUtil.MapPath(TempFolder.GetFilename("export.json"));
using (var writer = new StreamWriter(fileName))
{
using (var output = new JsonTextWriter(writer))
{
output.Formatting = Formatting.Indented;
output.WriteStartObject();
Export(output, new[] { item }, true);
output.WriteEndObject();
}
}
return(fileName);
}
/// <summary>Unpacks to file.</summary>
/// <param name="args">The arguments.</param>
/// <param name="file">The file.</param>
private static void UnpackToFile(UploadArgs args, HttpPostedFile file)
{
Assert.ArgumentNotNull((object)args, "args");
Assert.ArgumentNotNull((object)file, "file");
string filename = FileUtil.MapPath(TempFolder.GetFilename("temp.zip"));
file.SaveAs(filename);
using (ZipReader zipReader = new ZipReader(filename))
{
foreach (ZipEntry entry in zipReader.Entries)
{
string str = FileUtil.MakePath(args.Folder, entry.Name, '\\');
if (entry.IsDirectory)
{
Directory.CreateDirectory(str);
}
else
{
if (!args.Overwrite)
{
str = FileUtil.GetUniqueFilename(str);
}
Directory.CreateDirectory(Path.GetDirectoryName(str));
lock (FileUtil.GetFileLock(str))
FileUtil.CreateFile(str, entry.GetStream(), true);
}
}
}
}
public string Execute([NotNull] string databaseName, [NotNull] string id)
{
var database = Factory.GetDatabase(databaseName);
if (database == null)
{
throw new Exception("Database not found");
}
var item = database.GetItem(id);
Debug.Assert(item != null, "Item \"" + id + "\" not found.");
var fileName = FileUtil.MapPath(TempFolder.GetFilename("export.yaml"));
var languages = item.Database.Languages;
var templates = TemplateManager.GetTemplates(database).Values;
var duplicateTemplateNames = templates.Where(t => templates.Any(d => d != t && string.Equals(d.Name, t.Name, StringComparison.OrdinalIgnoreCase))).Select(t => t.Name);
using (var writer = new StreamWriter(fileName))
{
Export(new YamlTextWriter(writer), item, languages, duplicateTemplateNames, true);
}
return(fileName);
}
public string Execute([NotNull] string databaseName, [NotNull] string itemList)
{
Assert.ArgumentNotNull(databaseName, nameof(databaseName));
Assert.ArgumentNotNull(itemList, nameof(itemList));
var database = Factory.GetDatabase(databaseName);
if (database == null)
{
throw new Exception("Database not found");
}
var fileName = TempFolder.GetFilename("package.zip");
var items = GetItems(database, itemList);
var package = new ZipPackageBuilder(fileName);
foreach (var item in items)
{
package.Items.Add(item);
}
var result = package.Build();
return(WebUtil.GetServerUrl() + result);
}
public string Execute([NotNull] string databaseName, [NotNull] string xslt)
{
Assert.ArgumentNotNull(databaseName, nameof(databaseName));
Assert.ArgumentNotNull(xslt, nameof(xslt));
var database = Factory.GetDatabase(databaseName);
if (database == null)
{
throw new Exception("Database not found");
}
var item = database.GetRootItem();
var fileName = TempFolder.GetFilename("TransformCodeGeneration.xslt");
var path = FileUtil.MapPath(fileName);
File.WriteAllText(path, xslt, Encoding.UTF8);
var xslFile = new XslFile
{
Path = fileName
};
xslFile.XslExtensions["http://www.sitecore.net/codegeneration"] = new Helper();
var result = xslFile.Transform(item);
File.Delete(path);
return(result);
}
/// <summary>
/// Unpacks to file.
/// </summary>
/// <param name="args">The arguments.</param>
/// <param name="file">The file.</param>
private static void UnpackToFile(UploadArgs args, HttpPostedFile file)
{
Assert.ArgumentNotNull(args, "args");
Assert.ArgumentNotNull(file, "file");
string filename = FileUtil.MapPath(TempFolder.GetFilename("temp.zip"));
file.SaveAs(filename);
using (ZipReader zipReader = new ZipReader(filename))
{
foreach (ZipEntry current in zipReader.Entries)
{
string text = FileUtil.MakePath(args.Folder, current.Name, '\\');
if (current.IsDirectory)
{
System.IO.Directory.CreateDirectory(text);
}
else
{
if (!args.Overwrite)
{
text = FileUtil.GetUniqueFilename(text);
}
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(text));
lock (FileUtil.GetFileLock(text))
{
FileUtil.CreateFile(text, current.GetStream(), true);
}
}
}
}
}
public string Execute([NotNull] string databaseName, [NotNull] string batchScript, [NotNull] string xslt)
{
Assert.ArgumentNotNull(databaseName, nameof(databaseName));
Assert.ArgumentNotNull(batchScript, nameof(batchScript));
Assert.ArgumentNotNull(xslt, nameof(xslt));
var database = Factory.GetDatabase(databaseName);
if (database == null)
{
throw new Exception("Database not found");
}
var doc = GetXmlDocument(databaseName, batchScript);
var fileName = TempFolder.GetFilename("Report.xslt");
var xslFile = FileUtil.MapPath(fileName);
File.WriteAllText(xslFile, xslt, Encoding.UTF8);
var result = XmlUtil.Transform(doc, xslFile, true);
File.Delete(xslFile);
return(result);
}
public string Execute([NotNull] string page, [NotNull] string name, [NotNull] string parameters)
{
Assert.ArgumentNotNull(page, nameof(page));
Assert.ArgumentNotNull(name, nameof(name));
Assert.ArgumentNotNull(parameters, nameof(parameters));
var fileName = TempFolder.GetFilename(name);
var path = Path.ChangeExtension(FileUtil.MapPath(fileName), ".aspx");
File.WriteAllText(path, page, Encoding.UTF8);
var writer = new StringWriter();
var httpContext = HttpContext.Current;
httpContext.Session["SC_CODEGENERATOR_PARAMETERS"] = parameters;
httpContext.Server.Execute(fileName, writer);
var result = writer.ToString();
httpContext.Session.Remove("SC_CODEGENERATOR_PARAMETERS");
File.Delete(path);
return(result);
}
public string Execute([NotNull] string databaseName, [NotNull] string itemId)
{
Assert.ArgumentNotNull(databaseName, nameof(databaseName));
Assert.ArgumentNotNull(itemId, nameof(itemId));
var url = itemId;
var database = Factory.GetDatabase(databaseName);
Assert.IsNotNull(database, typeof(Database));
Item item;
try
{
item = database.GetItem(itemId);
}
catch
{
item = null;
}
if (item != null)
{
url = GetItemUrl(databaseName, itemId);
if (string.IsNullOrEmpty(url))
{
return(string.Empty);
}
}
var filename = TempFolder.GetFilename("thumbnail.png");
var htmlCapture = new HtmlCapture
{
Url = url,
FileName = filename
};
if (htmlCapture.Capture())
{
return(filename);
}
return(string.Empty);
}
private string Upload([NotNull] string uploadedFile)
{
Debug.ArgumentNotNull(uploadedFile, nameof(uploadedFile));
var tempFileName = TempFolder.GetFilename("package.zip");
var fileName = FileUtil.MapPath(tempFileName);
using (var source = new MemoryStream(System.Convert.FromBase64String(uploadedFile)))
{
Directory.CreateDirectory(Path.GetDirectoryName(fileName));
using (var target = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.None))
{
FileUtil.CopyStream(source, target);
}
}
return(FileUtil.UnmapPath(fileName, false));
}
/// <summary>
/// Unpacks to database.
///
/// </summary>
private void UnpackToDatabase(List <S3MediaUploadResult> list)
{
Assert.ArgumentNotNull((object)list, "list");
string str = FileUtil.MapPath(TempFolder.GetFilename("temp.zip"));
this.File.SaveAs(str);
try
{
using (ZipReader zipReader = new ZipReader(str))
{
foreach (ZipEntry zipEntry in zipReader.Entries)
{
if (!zipEntry.IsDirectory)
{
S3MediaUploadResult S3MediaUploadResult = new S3MediaUploadResult();
list.Add(S3MediaUploadResult);
S3MediaUploadResult.Path = FileUtil.MakePath(this.Folder, zipEntry.Name, '/');
S3MediaUploadResult.ValidMediaPath = MediaPathManager.ProposeValidMediaPath(S3MediaUploadResult.Path);
MediaCreatorOptions options = new MediaCreatorOptions()
{
Language = this.Language,
Versioned = this.Versioned,
KeepExisting = !this.Overwrite,
Destination = S3MediaUploadResult.ValidMediaPath,
FileBased = this.FileBased,
Database = this.Database
};
options.Build(GetMediaCreatorOptionsArgs.UploadContext);
Stream stream = zipEntry.GetStream();
S3MediaUploadResult.Item = MediaManager.Creator.CreateFromStream(stream, S3MediaUploadResult.Path, options);
}
}
}
}
finally
{
FileUtil.Delete(str);
}
}
private void UnpackToDatabase(HttpPostedFile originalFile, UploadArgs args, bool isFileBased)
{
string str = FileUtil.MapPath(TempFolder.GetFilename("temp.zip"));
originalFile.SaveAs(str);
try
{
using (ZipReader zipReader = new ZipReader(str))
{
foreach (ZipEntry entry in zipReader.Entries)
{
if (!entry.IsDirectory)
{
UploadToDatabase(entry.Name, (MemoryStream)entry.GetStream(), args, isFileBased);
}
}
}
}
finally
{
FileUtil.Delete(str);
}
}
protected string Build([NotNull] string itemList, [NotNull] string fileList, [NotNull] string packageName, [NotNull] string author, [NotNull] string version, [NotNull] string publisher, [NotNull] string license, [NotNull] string comment, [NotNull] string readme, [NotNull] string targetFileFolder)
{
Debug.ArgumentNotNull(itemList, nameof(itemList));
Debug.ArgumentNotNull(fileList, nameof(fileList));
Debug.ArgumentNotNull(packageName, nameof(packageName));
Debug.ArgumentNotNull(author, nameof(author));
Debug.ArgumentNotNull(version, nameof(version));
Debug.ArgumentNotNull(publisher, nameof(publisher));
Debug.ArgumentNotNull(license, nameof(license));
Debug.ArgumentNotNull(comment, nameof(comment));
Debug.ArgumentNotNull(readme, nameof(readme));
Debug.ArgumentNotNull(targetFileFolder, nameof(targetFileFolder));
var fileName = TempFolder.GetFilename("package.zip");
var package = GetBuilder(fileName);
package.PackageName = packageName;
package.Author = author;
package.Version = version;
package.Publisher = publisher;
package.License = license;
package.Comment = comment;
package.Readme = readme;
package.TargetFileFolder = targetFileFolder;
foreach (var part in itemList.Split('|'))
{
if (string.IsNullOrEmpty(part))
{
continue;
}
var tuple = part.Split(',');
var database = Factory.GetDatabase(tuple[0]);
if (database == null)
{
continue;
}
var item = database.GetItem(tuple[1]);
if (item != null)
{
package.Items.Add(item);
}
}
foreach (var part in fileList.Split('|'))
{
if (string.IsNullOrEmpty(part))
{
continue;
}
if (FileUtil.Exists(part) || FileUtil.FolderExists(part))
{
package.Files.Add(part);
}
}
var result = package.Build();
var unmappedFileName = FileUtil.UnmapPath(result, false);
if (unmappedFileName.Contains(":"))
{
return(unmappedFileName);
}
return(WebUtil.GetServerUrl() + unmappedFileName);
}
