/// <summary>
/// Comprueba si debe copiar el archivo
/// </summary>
private bool MustCopy(FileTargetModel file)
{
return((file.File.FileType == Model.Solutions.FileModel.DocumentType.Image ||
file.File.FileType == Model.Solutions.FileModel.DocumentType.File) &&
!file.File.Extension.EqualsIgnoreCase(".scss") &&
!file.File.FileName.EqualsIgnoreCase(Model.Solutions.ProjectModel.FileName));
}
/// <summary>
/// Reemplaza la cadena interna
/// </summary>
private string ReplaceInner(FileTargetModel file, string content)
{
Match match = Regex.Match(content, @"[""'](?<1>[^""']*)[""']");
string result = null;
// Cambia la cadena entre comillas
if (match.Success)
{
string inQuotes = match.Value.Trim().Substring(1, match.Value.Trim().Length - 2).ToUpper();
// Busca el nombre de archivo
if (_files.ContainsKey(inQuotes))
{
FileTargetModel objRelative = _files [inQuotes];
// Transforma la URL
result = content.Substring(0, match.Index);
result += "\"" + GetUrlRelative(file.RelativeFullFileNameTarget, objRelative.RelativeFullFileNameTarget) + "\"";
result += content.Substring(match.Index + match.Length);
}
}
// Devuelve el resultado
if (!result.IsEmpty())
{
return(result);
}
else
{
return(content);
}
}
/// <summary>
/// Reemplaza las URLs de un archivo por las URL relativas
/// </summary>
private StringBuilder ReplaceUrls(FileTargetModel file, string content)
{
StringBuilder builder = new StringBuilder();
Match match = Regex.Match(content, @"\s*(href|src)\s*=\s*(?:[""'](?<1>[^""']*)[""']|(?<1>\S+))");
int lastPosition = 0;
// Mientras se encuentre una cadena
while (match.Success)
{
// Añade a la cadena de salida lo anterior
builder.Append(content.Substring(lastPosition, match.Index - lastPosition));
// Añade el contenido
builder.Append(ReplaceInner(file, match.Value));
// Guarda la posición actual
lastPosition = match.Index + match.Length;
// Obtiene la siguiente coincidencia
match = match.NextMatch();
}
// Añade el resto de la cadena
if (lastPosition < content.Length)
{
builder.Append(content.Substring(lastPosition));
}
// Devuelve el contenido
return(builder);
}
/// <summary>
/// Graba el archivo temporal
/// </summary>
private void Save(FileTargetModel file, string content)
{
string fileName = file.GetFullFileNameCompiledTemporal(Processor);
// Crea el directorio
LibCommonHelper.Files.HelperFiles.MakePath(System.IO.Path.GetDirectoryName(fileName));
// Graba el archivo
LibCommonHelper.Files.HelperFiles.SaveTextFile(fileName, content);
}
/// <summary>
/// Obtiene un FileTargetModel "falso" para indicar la página siguiente o anterior
/// </summary>
private FileTargetModel GetPage(FileTargetModel fileCategory, int pageIndex, int totalPages)
{
if (pageIndex < 0 || pageIndex > totalPages - 1)
{
return(null);
}
else
{
return(CreateFile(fileCategory, pageIndex));
}
}
/// <summary>
/// Nombre del documento para una página
/// </summary>
protected override string GetDocumentFileName(FileTargetModel category, int pageIndex)
{
if (pageIndex == 0)
{
return(category.DocumentFileName);
}
else
{
return($"{category.DocumentFileName} ?.?_ {pageIndex}"); // ... evita los errores cuando en los textos ponga Seccion 2 1
}
}
/// <summary>
/// Preprocesa el archivo de categoría
/// </summary>
protected override void Preprocess(FileTargetModel file, DocumentModel category)
{
// Inicializa el nombre de archivo destino con el nombre de la carpeta
file.FileNameTarget = System.IO.Path.GetFileNameWithoutExtension(file.FileNameTarget) + ".htm";
// Inicializa los datos básicos del documento
file.Title = category.Title;
file.FileNameImage = category.URLImageSummary;
file.FileNameThumbnail = category.URLThumbImageSummary;
file.ShowMode = DocumentModel.ShowChildsMode.SortByDate;
file.IsRecursive = true;
file.ShowAtRss = false;
// Llama al método base
base.Preprocess(file, category);
}
/// <summary>
/// Cambia las URL del texto
/// </summary>
private string ChangeUrl(FileTargetModel file, string content)
{
// Convierte las Url
if (!content.IsEmpty())
{
// Cambia las variables globales de URL principal, URL de imagen y URL de thumb
content = content.ReplaceWithStringComparison(SectionSourceModel.VariableMainUrlPage, file.GetAbsoluteUrlPage(Processor));
content = content.ReplaceWithStringComparison(SectionSourceModel.VariableMainUrlImage, file.GetAbsoluteUrlImage(Processor));
// Reemplaza las URL
content = ReplaceUrls(file, content).ToString();
}
// Devuelve el contenido
return(content);
}
/// <summary>
/// Obtiene las páginas anterior y posterior
/// </summary>
private FilesIndexComposition GetIndexPages(FileTargetModel file, DocumentModel document)
{
FilesIndexComposition index = new FilesIndexComposition();
FileTargetModelCollection siblings = Data.Files.GetSiblings(file, false);
// Asigna los datos
index.PageTop = Data.Files.GetParent(file);
index.PagePrevious = siblings.GetPreviousPage(file);
index.PageNext = siblings.GetNextPage(file);
index.PagesRelated = GetPagesRelated(file, document);
index.FilesBreadCrumb = Data.Files.GetParents(file);
index.Normalize();
// Devuelve el índice
return(index);
}
/// <summary>
/// Compila la página
/// </summary>
private string Compile(FileTargetModel file, DocumentModel document)
{
SectionSourceModel templateArticle = Data.Templates.GetTemplate(document, TemplatesArrayModel.TemplateType.Article);
SectionSourceModel templateMain = Data.Templates.GetTemplate(document, TemplatesArrayModel.TemplateType.Main);
string content, fullTitle = document.Title;
// Obtiene el título completo de la página
if (Processor.Project.AddWebTitle)
{
fullTitle += $" - {Processor.Project.Title}";
}
// Compila la página
content = Data.NhamlCompiler.Compile(document, file.DateUpdate, templateArticle,
GetIndexPages(file, document));
// Compila el contenido con la plantilla principal
content = templateMain.ReplaceVariablesPageTemplate(content, null, document.Title, document.Title,
document.Description, document.KeyWords);
// Devuelve el valor compilando
return(content);
}
/// <summary>
/// Postprocesa un archivo temporal
/// </summary>
private void PostProcess(FileTargetModel file, string fileName)
{
string content;
string fileNameTarget = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(fileName),
System.IO.Path.GetFileNameWithoutExtension(fileName));
// Si es una plantilla, cambia la extensión
if (fileNameTarget.EndsWith(Model.Solutions.FileModel.SiteMapExtension, StringComparison.CurrentCultureIgnoreCase))
{
fileNameTarget = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(fileNameTarget),
System.IO.Path.GetFileNameWithoutExtension(fileNameTarget) + ".htm");
}
// Cambia las URL
content = ChangeUrl(file, LibCommonHelper.Files.HelperFiles.LoadTextFile(fileName));
// Graba el archivo
LibCommonHelper.Files.HelperFiles.SaveTextFile(fileNameTarget, content);
// Cambia la fecha de creación del archivo
System.IO.File.SetCreationTime(fileNameTarget, file.DateUpdate);
System.IO.File.SetLastWriteTime(fileNameTarget, file.DateUpdate);
}
/// <summary>
/// Procesa las categorías
/// </summary>
protected void ProcessCategories(int intItemsPerPage)
{
// Ordena los elementos por directorio / nombre
Data.Files.SortByFullFileName(true);
// Recorre los elementos al revés, comenzando por el final para compilar primero las categorías internas
for (int index = Data.Files.Count - 1; index >= 0; index--)
{
FileTargetModel file = Data.Files [index];
if (CheckIsCategory(file))
{
DocumentModel category = new DocumentBussiness().Load(file.File);
// Preprocesa el archivo si es necesario
Preprocess(file, category);
// Compila las páginas y las añade a la colección
Data.Files.AddRange(Compile(file, category, GetChilds(file, category), intItemsPerPage));
// Elimina la categoría
Data.Files.RemoveAt(index);
}
}
}
/// <summary>
/// Crea un archivo para la categoría
/// </summary>
private FileTargetModel CreateFile(FileTargetModel fileCategory, int pageIndex)
{
FileTargetModel file = fileCategory.Clone();
// Clona los datos básicos
file.ShowMode = DocumentModel.ShowChildsMode.SortByDate;
file.DateUpdate = fileCategory.DateUpdate.AddMinutes(pageIndex);
file.FileNameImage = fileCategory.FileNameImage;
file.FileNameThumbnail = fileCategory.FileNameThumbnail;
file.PreviousTitle = fileCategory.Title;
file.Title = $"Página {pageIndex + 1}";
file.Page = pageIndex;
// Cambia el nombre del archivo destino
if (pageIndex > 0)
{
file.FileNameTarget = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(file.FileNameTarget),
System.IO.Path.GetFileNameWithoutExtension(file.FileNameTarget) + " " + pageIndex +
System.IO.Path.GetExtension(file.FileNameTarget));
}
file.FileNameSource = GetDocumentFileName(fileCategory, pageIndex);
// Devuelve el archivo creado
return(file);
}
/// <summary>
/// Comprueba si un archivo se debe procesar como una categoría para esta paso
/// </summary>
protected override bool CheckIsCategory(FileTargetModel file)
{
return(file.File.FileType == Model.Solutions.FileModel.DocumentType.Document &&
file.ShowMode != DocumentModel.ShowChildsMode.None);
}
/// <summary>
/// Obtiene las páginas relacionadas
/// </summary>
private System.Collections.Generic.List <DocumentTargetModel> GetPagesRelated(FileTargetModel file, DocumentModel document)
{
System.Collections.Generic.List <DocumentTargetModel> documents = new System.Collections.Generic.List <DocumentTargetModel>();
FileTargetModelCollection filesRelated = Data.Files.GetPagesRelated(file, document);
// Carga los archivos y rellena la lista
foreach (FileTargetModel fileRelated in filesRelated)
{
documents.Add(new DocumentTargetModel
{
FileTarget = fileRelated,
Document = new DocumentBussiness().Load(Processor.Project,
fileRelated.GetFullFileNameCompiledShort(Processor))
});
}
// Devuelve la colección de archivos
return(documents);
}
/// <summary>
/// Obtiene los elementos hijo de la categoría
/// </summary>
protected override FileTargetModelCollection GetChilds(FileTargetModel file, DocumentModel document)
{
return(Data.Files.GetChildsSitemap(file, document));
}
/// <summary>
/// Crea las páginas de una categoría
/// </summary>
private FileTargetModelCollection Compile(FileTargetModel fileCategory, DocumentModel category,
FileTargetModelCollection childs, int intItemsPerPage)
{
FileTargetModelCollection filesCompiled = new FileTargetModelCollection(Processor);
SectionSourceModel templateMain = Data.Templates.GetTemplate(category, TemplatesArrayModel.TemplateType.Main);
SectionSourceModel templateHeader = Data.Templates.GetTemplate(category, TemplatesArrayModel.TemplateType.CategoryHeader);
// Si no hay ninguna plantilla añade el error
if (templateHeader == null)
{
Processor.Errors.Add(fileCategory.File.DocumentFileName, "No se encuentra ninguna plantilla para la cabecera de la categoría");
}
else
{
SectionSourceModel templateItems = GetTemplateItems(category);
if (templateItems == null)
{
Processor.Errors.Add(fileCategory.File.DocumentFileName, "No se encuentra ninguna plantilla para los elementos de la categoría");
}
else
{
string contentHeader = Data.NhamlCompiler.Compile(category, fileCategory.DateUpdate, templateHeader, null);
int pageIndex = 0;
int numberPages = CountPages(childs.Count, intItemsPerPage);
if (childs.Count == 0)
{
string content;
// Compila con la cabecera de la plantilla
content = templateMain.ReplaceVariablesPageTemplate(contentHeader, null,
category.Title, category.Title,
category.Description, category.KeyWords);
// Crea el archivo
filesCompiled.Add(CreateFile(fileCategory, 0));
// Graba en el archivo compilado el contenido de la cabecera
Save(filesCompiled [filesCompiled.Count - 1], content);
}
else
{
// Ordena los archivos
if (fileCategory.ShowMode == DocumentModel.ShowChildsMode.SortByDate)
{
childs.SortByDate(false);
}
else
{
childs.SortByName(true);
}
// Compila el contenido
for (int top = 0; top < childs.Count; top += intItemsPerPage, pageIndex++)
{
string content;
FilesIndexComposition fileIndex = new FilesIndexComposition();
// Obtiene las páginas de índice
fileIndex.PageTop = Data.Files.GetParent(fileCategory);
fileIndex.PagePrevious = GetPage(fileCategory, pageIndex - 1, numberPages);
fileIndex.PageNext = GetPage(fileCategory, pageIndex + 1, numberPages);
// Normaliza el índice
fileIndex.Normalize();
// Compila los elementos de la categoría
content = Data.NhamlCompiler.CompileItemsCategory(category, templateItems,
childs.Slice(top, intItemsPerPage),
fileIndex);
// Compila con la cabecera de la plantilla
content = templateMain.ReplaceVariablesPageTemplate(contentHeader, content, category.Title, category.Title,
category.Description, category.KeyWords);
// Crea el archivo
filesCompiled.Add(CreateFile(fileCategory, pageIndex));
// Graba el archivo compilado
Save(filesCompiled [filesCompiled.Count - 1], content);
}
}
}
}
// Devuelve la colección de páginas
return(filesCompiled);
}
/// <summary>
/// Comprueba si un archivo se debe procesar como una categoría para esta paso
/// </summary>
protected override bool CheckIsCategory(FileTargetModel file)
{
return(file.File.FileType == Model.Solutions.FileModel.DocumentType.SiteMap);
}
/// <summary> /// Obtiene los archivos hijo de una categoría /// </summary> protected abstract FileTargetModelCollection GetChilds(FileTargetModel file, DocumentModel document);
/// <summary> /// Comprueba si un archivo se debe procesar como una categoría para esta paso /// </summary> protected abstract bool CheckIsCategory(FileTargetModel file);
/// <summary>
/// Preprocesa el archivo si es necesario (hace los cambios para el directorio destino y demás...
/// </summary>
protected virtual void Preprocess(FileTargetModel file, DocumentModel category)
{
}
/// <summary>
/// Obtiene los elementos hijo de la categoría
/// </summary>
protected override FileTargetModelCollection GetChilds(FileTargetModel file, DocumentModel document)
{
return(Data.Files.GetChildsCategory(file, file.IsRecursive));
}
/// <summary> /// Nombre del documento para una página /// </summary> protected abstract string GetDocumentFileName(FileTargetModel category, int pageIndex);
