/// <summary>
/// Serialize
/// </summary>
/// <param name="site">site</param>
/// <param name="path">path</param>
/// <returns></returns>
public void Serialize(Site site, string path)
{
if (site == null)
{
throw new ArgumentException("site");
}
if (string.IsNullOrWhiteSpace(path))
{
throw new ArgumentException("stream");
}
var tempPath = Path.GetTempPath() + "site.xml";
using (var stream = File.Create(tempPath))
{
var serializer = new XmlSerializer(typeof(Site));
serializer.Serialize(stream, site);
}
var packagePath = path + Path.DirectorySeparatorChar + site.Name + ".wbp";
if (File.Exists(packagePath))
{
File.Delete(packagePath);
}
using (ZipFile package = new ZipFile(packagePath, Console.Out))
{
package.AddFile(tempPath, string.Empty);
package.AddFiles(site.Resources.Select(r => r.TextData).Where(File.Exists), "resources");
package.Save();
}
}
/// <summary>
/// Renames all references in XML
/// </summary>
/// <param name="site">Whole site</param>
/// <param name="propertyText">Original property text</param>
/// <param name="oldName">Old reference to be removed</param>
/// <param name="newName">New reference</param>
/// <param name="typeId">Type id</param>
/// <returns></returns>
public void RenamePropertyReferences(Site site, string propertyText, string oldName, string newName, string typeId)
{
//propertyText.Replace("@Raw(Model." + oldName + ")", "@Raw(Model." + newName + ")");
foreach (var type in site.PageTypes)
{
if (type.ID.ToString() == typeId)
{
foreach (var definition in type.Definitions)
{
if (definition.Name == oldName)
{
definition.Name = newName;
definition.TemplateReference = "@Raw(Model." + newName + ")";
}
}
}
foreach (var template in site.Templates)
{
if (template != null && template.ID == type.TemplateID)
{
template.Text = template.Text.Replace("@Raw(Model." + oldName + ")", "@Raw(Model." + newName + ")");
}
}
}
}
/// <summary>
/// Recursively updates all pages and their properties
/// </summary>
/// <param name="parent">Node from which to start updating</param>
/// <param name="site">Whole site</param>
/// <param name="config">Website's config</param>
/// <returns></returns>
public void UpdateChildren(Page parent, Site site, WebsiteModel config)
{
foreach (var page in parent.Children.Reverse<Page>())
{
var pageModel = GetPage(page.ID.ToString(), config);
if (pageModel != null)
{
page.Name = pageModel.Title;
if (page.Properties.Any())
{
foreach (var property in page.Properties.Reverse<Property>())
{
var propertyModel = GetProperty(property.ID.ToString(), pageModel);
if (propertyModel != null)
{
if (property.Name != propertyModel.Name)
{
RenamePropertyReferences(site, property.Value, property.Name, propertyModel.Name, page.PageTypeID.ToString());
//RenamePropertiesName(site.Root, property.Name, propertyModel.Name, page.PageTypeID.ToString());
property.Name = propertyModel.Name;
}
property.Value = propertyModel.Html;
}
else
{
//RemovePropertiesFromPages(site.Root, property.Name, page.PageTypeID.ToString());
//RemovePropertyFromType(site, property.Name, page.PageTypeID.ToString());
//RemovePropertyReferences(site, property.Name);
RemovePropertyFromTypeDefinition(site, property.Name, page.PageTypeID.ToString());
page.Properties.Remove(property);
}
}
}
if (page.Children.Any())
{
UpdateChildren(page, site, config);
}
}
else
{
parent.Children.Remove(page);
}
}
}
/// <summary>
/// Import
/// </summary>
/// <param name="content">content</param>
/// <param name="umbApplication">umb Application</param>
/// <param name="appContext">app Context</param>
/// <returns></returns>
public void Import(Site site, ApplicationContext appContext)
{
references.Clear();
var mediaService = appContext.Services.MediaService;
var cts = appContext.Services.ContentTypeService;
var folderTypeID = cts.GetMediaType(Constants.Conventions.MediaTypes.Folder).Id;
var folders = mediaService.GetMediaOfMediaType(folderTypeID);
foreach (var folder in folders)
{
if (folder.Name == site.Name)
{
foreach (var media in mediaService.GetChildren(folder.Id))
{
mediaService.Delete(media);
}
mediaService.Delete(folder);
break;
}
}
var serializer = new SiteSerializer();
//Accents removal
byte[] tempBytes;
tempBytes = System.Text.Encoding.GetEncoding("ISO-8859-8").GetBytes(site.Name.ToLowerInvariant());
string siteAlias = System.Text.Encoding.UTF8.GetString(tempBytes);
siteAlias = siteAlias.Replace(" ", string.Empty);
//site.Root.Name = site.Name;
var fileService = appContext.Services.FileService;
var scriptPath = HostingEnvironment.MapPath("/scripts") + Path.DirectorySeparatorChar;
var cssPath = HostingEnvironment.MapPath("/css") + Path.DirectorySeparatorChar;
var resourcePath = site.Name + '/';
var mediaParent = mediaService.CreateMediaWithIdentity(site.Name, -1, Constants.Conventions.MediaTypes.Folder);
foreach (var resource in site.Resources)
{
var filePath = resource.TextData;
if (resource.ResourceType == ResourceType.Javascript)
{
try
{
var scripts = fileService.GetScripts(resource.TextData.ToLowerInvariant());
if (scripts != null && scripts.Any())
{
foreach (var item in scripts)
{
fileService.DeleteScript(item.Name);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
var newPath = scriptPath + Path.GetFileName(filePath);
if (!newPath.EndsWith(".js"))
{
newPath = newPath + ".js";
}
var script = new Script(filePath);
fileService.SaveScript(script);
System.IO.File.Copy(filePath, newPath, true);
AddToReferences(resource.TemplateReference, newPath, true);
}
else if (resource.ResourceType == ResourceType.Stylesheet)
{
try
{
var stylesheets = fileService.GetStylesheets(resource.TextData.ToLowerInvariant());
if (stylesheets != null && stylesheets.Any())
{
foreach (var item in stylesheets)
{
fileService.DeleteStylesheet(item.Name);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
var newPath = cssPath + Path.GetFileName(filePath);
if (!newPath.EndsWith(".css"))
{
newPath = newPath + ".css";
}
var stylesheet = new Stylesheet(newPath);
fileService.SaveStylesheet(stylesheet);
System.IO.File.Copy(filePath, newPath, true);
AddToReferences(resource.TemplateReference, newPath, true);
}
else if (resource.ResourceType == ResourceType.Image)
{
var media = mediaService.CreateMedia(resource.FileName, mediaParent.Id, Constants.Conventions.MediaTypes.Image);
using (var fs = System.IO.File.OpenRead(filePath))
{
media.SetValue(Constants.Conventions.Media.File, resource.FileName, fs);
}
mediaService.Save(media);
AddToReferences(resource.TemplateReference, media.GetValue<string>(Constants.Conventions.Media.File));
}
else if (resource.ResourceType == ResourceType.File)
{
var media = mediaService.CreateMedia(resource.FileName, mediaParent.Id, Constants.Conventions.MediaTypes.File);
using (var fs = System.IO.File.OpenRead(filePath))
{
media.SetValue(Constants.Conventions.Media.File, resource.FileName, fs);
}
mediaService.Save(media);
AddToReferences(resource.TemplateReference, media.GetValue<string>(Constants.Conventions.Media.File));
}
}
var rootCT = new ContentType(-1);
rootCT.Name = site.Name;
rootCT.Alias = siteAlias;
var oldCT = cts.GetContentType(rootCT.Alias);
if (oldCT != null)
{
foreach (var child in cts.GetContentTypeChildren(oldCT.Id))
{
cts.Delete(child);
}
cts.Delete(oldCT);
}
cts.Save(rootCT);
var templatePathFormat = HostingEnvironment
.MapPath("/Views") + Path.DirectorySeparatorChar + "{0}.cshtml";
var templates = new Dictionary<Guid, ITemplate>();
var templateTexts = new Dictionary<Guid, string>();
foreach (var template in site.Templates.WhereNotNull())
{
var templateAlias = siteAlias + template.Name.ToLowerInvariant();
if (fileService.GetTemplate(templateAlias) != null)
{
fileService.DeleteTemplate(templateAlias);
}
var templatePath = string.Format(templatePathFormat, templateAlias);
var templateModel = new Umbraco.Core.Models.Template(templatePath, template.Name, templateAlias);
fileService.SaveTemplate(templateModel);
templateTexts.Add(template.ID, template.Text);
templates.Add(template.ID, templateModel);
}
var contentTypes = new Dictionary<Guid, ContentType>();
foreach (var pageType in site.PageTypes)
{
var contentType = new ContentType(rootCT);
contentType.Name = pageType.Name;
contentType.Alias = siteAlias + pageType.Name;
contentType.Icon = "icon-umb-content";
cts.Save(contentType);
contentType.AddPropertyGroup(site.Name);
var propertyGroup = contentType.PropertyGroups[site.Name];
bool hasTemplate = pageType.TemplateID != Guid.Empty;
string templateBody = null;
ITemplate contentTypeTemplate = null;
if (hasTemplate)
{
contentTypeTemplate = templates[pageType.TemplateID];
templateBody = templateTexts[pageType.TemplateID];
}
foreach (var definition in pageType.Definitions)
{
var def = appContext.Services.DataTypeService
.GetDataTypeDefinitionByPropertyEditorAlias(Constants.PropertyEditors.TinyMCEAlias)
.First();
var pt = new PropertyType(def);
pt.Alias = siteAlias + definition.Name;
pt.Name = definition.Name;
contentType.AddPropertyType(pt, site.Name);
if (hasTemplate)
{
templateBody = templateBody.Replace(definition.TemplateReference, "@Umbraco.Field(\"" + pt.Alias + "\")");
}
}
if (hasTemplate)
{
contentTypeTemplate.Content = templateBody;
contentType.AllowedTemplates = contentTypeTemplate.AsEnumerableOfOne();
contentType.SetDefaultTemplate(contentTypeTemplate);
var templatePath = string.Format(templatePathFormat, contentTypeTemplate.Alias);
System.IO.File.WriteAllText(templatePath, templateBody, Encoding.UTF8);
}
cts.Save(contentType);
contentTypes.Add(pageType.ID, contentType);
}
IContent root = null;
var cs = appContext.Services.ContentService;
var pages = new Dictionary<Guid, IContent>();
var pageReferences = new Dictionary<string, IContent>();
foreach (var page in site.Root.GetDescendantsAndSelf())
{
if(page.Name == null)
{
page.Name = "unknown";
}
var parentID = page.ParentID == Guid.Empty ? -1 : pages[page.ParentID].Id;
var cnt = cs.CreateContent(page.Name, parentID, contentTypes[page.PageTypeID].Alias);
pages.Add(page.ID, cnt);
foreach (var prop in page.Properties)
{
//Accents removal
tempBytes = System.Text.Encoding.GetEncoding("ISO-8859-8").GetBytes(prop.Name);
string propName = System.Text.Encoding.UTF8.GetString(tempBytes);
propName = propName.Replace(" ", string.Empty);
cnt.Properties[siteAlias + propName].Value = prop.Value;
}
cs.Save(cnt);
if (page.ParentID == Guid.Empty)
{
root = cnt;
}
if (!string.IsNullOrWhiteSpace(page.TemplateReference))
{
pageReferences.Add(page.TemplateReference, cnt);
}
}
var pageRegex = new Regex(@"(@Raw\(Model\.Page\d+\))", RegexOptions.Compiled | RegexOptions.Multiline);
var resourceRegex = new Regex(@"(@Raw\(Model\.Resource\d+\))", RegexOptions.Compiled | RegexOptions.Multiline);
foreach (var page in root.Descendants().Where(c => c.Template != null))
{
foreach (var property in page.Properties)
{
var value = property.Value != null ? property.Value.ToString() : "";
value = pageRegex.Replace(value, m => "/{localLink:" + pageReferences[m.Value].Id + "}");
property.Value = resourceRegex.Replace(value, m => references[m.Value]);
}
cs.Save(page);
}
cs.PublishWithChildrenWithStatus(root, includeUnpublished: true);
foreach (var template in templates.Values)
{
var sb = new StringBuilder();
var templatePath = string.Format(templatePathFormat, template.Alias);
var newContent = pageRegex.Replace(template.Content, m => string.Format("@Umbraco.NiceUrl({0})", pageReferences[m.Value].Id));
newContent = resourceRegex.Replace(newContent, m => references[m.Value]);
System.IO.File.WriteAllText(templatePath, templatePrefix + newContent, Encoding.UTF8);
}
}
/// <summary>
/// Recursively creates list of pages starting with parent
/// </summary>
/// <param name="parent">Parent page</param>
/// <param name="site">Site</param>
/// <returns>
/// List of pages
/// </returns>
public List<WebpackUI.Models.PageModel> AddChildren(Page parent, Site site)
{
var children = new List<WebpackUI.Models.PageModel>();
foreach (var page in parent.Children)
{
var pageModel = new WebpackUI.Models.PageModel();
pageModel.Id = page.ID.ToString();
pageModel.ParentId = parent.ID.ToString();
pageModel.Title = page.Name;
foreach (var type in site.PageTypes)
{
if (type.ID == page.PageTypeID)
{
pageModel.Type = type.Name;
break;
}
}
foreach (var property in page.Properties)
{
var propertyModel = new PagePropertyModel();
propertyModel.Id = property.ID.ToString();
propertyModel.Name = property.Name;
propertyModel.Html = property.Value;
pageModel.Properties.Add(propertyModel);
}
pageModel.Children = AddChildren(page, site);
children.Add(pageModel);
}
return children;
}
/// <summary>
/// Remove property from types definition
/// </summary>
/// <param name="site">Site</param>
/// <param name="name">Property name</param>
/// <param name="typeId">Type id</param>
/// <returns></returns>
public void RemovePropertyFromTypeDefinition(Site site, string name, string typeId)
{
foreach (var type in site.PageTypes)
{
if (type.ID.ToString() == typeId)
{
foreach (var definition in type.Definitions.Reverse<Definition>())
{
if(definition.Name == name)
{
type.Definitions.Remove(definition);
}
}
}
// Remove references
foreach (var template in site.Templates)
{
if (template != null && template.ID == type.TemplateID)
{
template.Text = template.Text.Replace("@Raw(Model." + name + ")", "");
}
}
}
}
