Ejemplo n.º 1
0
 /// <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));
     }
 }
Ejemplo n.º 6
0
 /// <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
     }
 }
Ejemplo n.º 7
0
 /// <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);
 }
Ejemplo n.º 9
0
        /// <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);
        }
Ejemplo n.º 10
0
        /// <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);
 }
Ejemplo n.º 15
0
        /// <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);
        }
Ejemplo n.º 16
0
 /// <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);
        }
Ejemplo n.º 18
0
 /// <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);