//IO:2  <- OK
        /// <summary>
        /// Elenco di immagini di una skin (percorso fisico)
        /// </summary>
        /// <param name="BasePath">Indirizzo base</param>
        /// <param name="SkinId">Id skin</param>
        /// <returns></returns>
        public static IList <Domain.DTO.DtoSkinImage> GetImages(String BasePath, Int64 SkinId)
        {
            String ImagePath = GetImagePath(BasePath, SkinId);

            if (ImagePath == "")
            {
                return(null);
            }


            List <Domain.DTO.DtoSkinImage> Images = new List <Domain.DTO.DtoSkinImage>();

            //String[] files = Directory.GetFiles(ImagePath);

            String[] files = new String[] { };
            lm.Comol.Core.File.ContentOf.Directory(ImagePath, ref files, true);


            foreach (String FileName in files)
            {
                System.IO.FileInfo      File   = ContentOf.File_Info(FileName);//new FileInfo(FileName);
                Domain.DTO.DtoSkinImage Dtoimg = new Domain.DTO.DtoSkinImage();
                Dtoimg.Name     = File.Name;
                Dtoimg.SizeByte = File.Length;

                Images.Add(Dtoimg);
            }

            return(Images);
        }
        public List <ProfileColumnComparer <String> > GetAvailableColumns(dtoCsvSettings settings, dtoCSVfile file)
        {
            List <ProfileColumnComparer <String> > columns = new List <ProfileColumnComparer <String> >();

            if (file != null)
            {
                CsvFile header = ContentOf.LoadCsvFile(file.RealName, settings, 1);
                if (header != null)
                {
                    Dictionary <ProfileAttributeType, String> attributes = new Dictionary <ProfileAttributeType, String>();
                    foreach (ProfileAttributeType att in Enum.GetValues(typeof(ProfileAttributeType)))
                    {
                        attributes.Add(att, att.ToString().ToLower());
                    }
                    columns = (from c in header.ColumHeader
                               select new ProfileColumnComparer <String>
                    {
                        SourceColumn = (c.Empty) ? c.Number.ToString() : c.Value,
                        Number = c.Number,
                        DestinationColumn = (c.Empty || !attributes.Values.Contains(c.Value.ToLower())) ? Authentication.ProfileAttributeType.skip : attributes.ToList().Where(a => a.Value == c.Value.ToLower()).Select(a => a.Key).FirstOrDefault()
                    }).ToList();
                }
            }
            return(columns);
        }
        public ProfileExternalResource GetFileContent(List <ProfileColumnComparer <String> > columns, dtoCsvSettings settings, dtoCSVfile file)
        {
            CsvFile csvFile = ContentOf.LoadCsvFile(file.RealName, settings);
            ProfileExternalResource result = new ProfileExternalResource(columns, csvFile);

            return(result);
        }
        private dtoCSVfile GetCurrentFile(String filePath)
        {
            List <dtoFileSystemInfo> files = new List <dtoFileSystemInfo>();

            ContentOf.Directory(filePath, ref files, "*.csv.stored");

            dtoFileSystemInfo LastFile = files.OrderByDescending(f => f.CreationTime).Where(f => f.Exists).FirstOrDefault();

            return(GetCsvFile(LastFile));
        }
        private void ClearPreviousFiles(String filePath)
        {
            List <dtoFileSystemInfo> files = new List <dtoFileSystemInfo>();

            ContentOf.Directory(filePath, ref files, "*.csv.stored");
            foreach (dtoFileSystemInfo file in files)
            {
                Delete.File(file.FullName);
            }
        }
 public void Preview(dtoCsvSettings settings, dtoCSVfile file)
 {
     if (file != null)
     {
         View.PreviewRows(ContentOf.LoadCsvFile(file.RealName, settings, 8));
     }
     else
     {
         View.PreviewRows(null);
     }
 }
        public List <ExternalColumnComparer <String, Int32> > GetAvailableColumns(dtoCsvSettings settings, dtoCSVfile file)
        {
            List <ExternalColumnComparer <String, Int32> > columns = new List <ExternalColumnComparer <String, Int32> >();

            if (file != null)
            {
                CsvFile header = ContentOf.LoadCsvFile(file.RealName, settings, 1);
                if (header != null)
                {
                    columns = (from c in header.ColumHeader
                               select new ExternalColumnComparer <String, Int32>
                    {
                        SourceColumn = (c.Empty) ? c.Number.ToString() : c.Value,
                        Number = c.Number,
                        DestinationColumn = new DestinationItem <Int32>()
                        {
                            Id = -1, InputType = InputType.skip
                        },
                        InputType = InputType.skip
                    }).ToList();
                }
            }
            return(columns);
        }
        private dtoCSVfile GetUploadedFile(String filePath)
        {
            dtoFileSystemInfo uploaded = ContentOf.File_dtoInfo(filePath);

            return(GetCsvFile(uploaded));
        }