/// <summary>
        ///		Copia los archivos
        /// </summary>
        private void CopyFiles(string sourcePath, string targetPath, NormalizedDictionary <object> parameters)
        {
            // Crea el directorio
            //? Sí, está dos veces, no sé porqué si se ejecuta dos veces consecutivas este método, la segunda vez no crea el directorio a menos que
            //? ejecute dos veces la instrucción
            HelperFiles.MakePath(targetPath);
            HelperFiles.MakePath(targetPath);
            // Copia los archivos
            foreach (string file in System.IO.Directory.EnumerateFiles(sourcePath))
            {
                if (MustCopy(file))
                {
                    string targetFile = System.IO.Path.Combine(targetPath, System.IO.Path.GetFileName(file));

                    // Copia los archivos de Python sin cambios, los de SQL los convierte
                    if (file.EndsWith(".py", StringComparison.CurrentCultureIgnoreCase))
                    {
                        SaveFileWithoutBom(targetFile, HelperFiles.LoadTextFile(file));
                    }
                    else if (file.EndsWith(".sql", StringComparison.CurrentCultureIgnoreCase))
                    {
                        SaveFileWithoutBom(targetFile, TransformSql(file, parameters));
                    }
                }
            }
        }
Exemple #2
0
        /// <summary>
        ///		Descarga los archivos
        /// </summary>
        public async Task DownloadFilesAsync()
        {
            var webClient = new LibCommonHelper.Communications.HttpWebClient();

            // Descarga los eventos
            foreach (MediaFileModel file in Files)
            {
                string fileName = GetDownloadFileName(file);

                // Descarga el archivo
                if (!string.IsNullOrEmpty(fileName) && !File.Exists(fileName))
                {
                    // Lanza el evento de descarga
                    RaiseEvent(file, Files.IndexOf(file), Files.Count);
                    // Crea el directorio
                    HelperFiles.MakePath(Path.GetDirectoryName(fileName));
                    // Descarga el archivo
                    try
                    {
                        // Descarga el archivo
                        await webClient.DownloadFileAsync(file.Url, fileName);

                        // Asigna el nombre del archivo descargado
                        file.FileName = fileName;
                    }
                    catch {}
                }
            }
            // Lanza el evento de fin
            EndDownload?.Invoke(this, EventArgs.Empty);
        }
        /// <summary>
        ///		Graba los datos
        /// </summary>
        protected override void Save()
        {
            if (ValidateData())
            {
                string targetPath = System.IO.Path.Combine(PathTarget, Name);
                string fileName   = HelperFiles.CombineFileName(targetPath, HelperFiles.Normalize(Name),
                                                                ProjectsDefinition.SelectedItem.Project.Extension);
                ProjectModel project;

                // Crea el directorio
                HelperFiles.MakePath(targetPath);
                // Crea el proyecto (después de crear el directorio)
                project = new ProjectModel(_solution, ProjectsDefinition.SelectedItem.Project, fileName);
                // Crea el archivo de proyecto (vacío)
                HelperFiles.SaveTextFile(fileName, "");
                // Añade el proyecto a la solución
                if (_folder == null)
                {
                    _solution.Projects.Add(project);
                }
                else
                {
                    _folder.Projects.Add(project);
                }
                // Crea el proyecto
                SourceEditorViewModel.Instance.MessagesController.OpenFile(project.Definition, project, true);
                // Cierra el formulario
                RaiseEventClose(true);
            }
        }
Exemple #4
0
 /// <summary>
 ///		Graba un archivo de texto
 /// </summary>
 internal void Save(string fileName, string content)
 {
     // Crea el directorio de salida
     HelperFiles.MakePath(Path);
     // Graba el contenido
     HelperFiles.SaveTextFile(System.IO.Path.Combine(Path, fileName), content);
 }
        /// <summary>
        ///		Copia los archivos del proyecto que no precisan compilación
        /// </summary>
        internal override void Process()
        {
            foreach (FileTargetModel file in Data.Files)
            {
                if (MustCopy(file))
                {
                    string fileName = file.GetFullFileName(Processor);

                    // Crea el directorio destino
                    HelperFiles.MakePath(System.IO.Path.GetDirectoryName(fileName));
                    // Copia el archivo
                    HelperFiles.CopyFile(file.File.FullFileName, fileName);
                }
            }
        }
        /// <summary>
        ///		Copia las imágenes de un libro
        /// </summary>
        private void CopyImages(Book book, string pathTemp, string pathTarget)
        {
            foreach (PageFile file in book.Files)
            {
                if (!file.FileName.IsEmpty() && IsImage(file.FileName))
                {
                    string fileNameTarget = Path.Combine(pathTarget, RemoveFirstPath(file.FileName));

                    // Crea el directorio destino
                    HelperFiles.MakePath(Path.GetDirectoryName(fileNameTarget));
                    // Copia el archivo
                    HelperFiles.CopyFile(Path.Combine(pathTemp, file.FileName), fileNameTarget);
                }
            }
        }
 /// <summary>
 ///		Copia los archivos
 /// </summary>
 private void CopyFiles(string sourcePath, string targetPath)
 {
     // Crea el directorio
     //? Sí, está dos veces, no sé porqué si se ejecuta dos veces consecutivas este método, la segunda vez no crea el directorio a menos que
     //? ejecute dos veces la instrucción
     HelperFiles.MakePath(targetPath);
     HelperFiles.MakePath(targetPath);
     // Copia los archivos
     foreach (string file in System.IO.Directory.EnumerateFiles(sourcePath))
     {
         if (MustCopy(file))
         {
             GetFileTransformer(targetPath, file).Transform();
         }
     }
 }
        /// <summary>
        ///		Copia un directorio o crea una referencia
        /// </summary>
        private void Copy(ProjectModel projectSource, ProjectModel projectTarget, string fileSource, string pathTarget, bool isRecursive)
        {
            if (Directory.Exists(fileSource))
            {
                string [] files = Directory.GetFiles(fileSource);

                // Copia los archivos
                foreach (string fileName in files)
                {
                    Copy(projectSource, projectTarget, fileName, pathTarget, isRecursive);
                }
                // Copia los directorios
                if (isRecursive)
                {
                    // Obtiene los directorios
                    files = Directory.GetDirectories(fileSource);
                    // Copia los archivos
                    foreach (string fileName in files)
                    {
                        Copy(projectSource, projectTarget, fileName, Path.Combine(pathTarget, Path.GetFileName(fileName)), isRecursive);
                    }
                }
            }
            else if (File.Exists(fileSource))
            {
                string fileTarget = Path.Combine(pathTarget, Path.GetFileName(fileSource));

                if (!File.Exists(fileTarget))
                {
                    ReferenceModel reference;

                    // Cambia la extensión al archivo final de referencia
                    fileTarget = fileTarget + new Model.Solutions.FileModel(null).GetExtension(FileModel.DocumentType.Reference);
                    // Crea el objeto de referencia
                    reference                   = new ReferenceModel(new Solutions.FileFactory().GetInstance(projectTarget, fileTarget));
                    reference.ProjectName       = projectSource.Name;
                    reference.FileNameReference = HelperFiles.GetFileNameRelative(projectSource.File.Path, fileSource);
                    // Crea el directorio
                    HelperFiles.MakePath(pathTarget);
                    // Crea el archivo de referencia
                    new ReferenceRepository().Save(reference);
                }
            }
        }
Exemple #9
0
        /// <summary>
        ///		Graba los datos de una conexión
        /// </summary>
        internal void Save(FtpConnectionModel connection, string fileName)
        {
            MLFile fileML = new MLFile();
            MLNode nodeML = fileML.Nodes.Add(TagConnection);

            // Crea el directorio
            HelperFiles.MakePath(System.IO.Path.GetDirectoryName(fileName));
            // Añade los atributos de la conexión
            nodeML.Attributes.Add(TagGlobalId, connection.GlobalId);
            nodeML.Attributes.Add(TagServer, connection.Server);
            nodeML.Attributes.Add(TagProtocol, (int)connection.FtpProtocol);
            nodeML.Attributes.Add(TagPort, connection.Port);
            nodeML.Attributes.Add(TagTimeOut, connection.TimeOut);
            // Añade los nodos de la conexión
            nodeML.Nodes.Add(TagName, connection.Name);
            nodeML.Nodes.Add(TagDescription, connection.Description);
            nodeML.Nodes.Add(TagServer, connection.Server);
            nodeML.Nodes.Add(TagUser, connection.User);
            nodeML.Nodes.Add(TagPassword, connection.Password);
            // Graba el archivo
            new XMLWriter().Save(fileName, fileML);
        }