/// <summary>
/// Get a datatable with all tables.
/// </summary>
public override System.Data.DataTable QueryTables(bool p_all_schemas)
{
System.Data.DataTable v_table;
System.Data.DataRow v_row;
System.Collections.Generic.List <string> v_tmpfiles;
System.IO.DirectoryInfo v_info;
v_table = new System.Data.DataTable("Tables");
v_table.Columns.Add("table_name");
v_tmpfiles = new System.Collections.Generic.List <string>();
v_info = new System.IO.DirectoryInfo(this.v_service);
if (v_info.Exists)
{
v_tmpfiles.AddRange(System.IO.Directory.GetFiles(this.v_service, "*.csv", System.IO.SearchOption.TopDirectoryOnly));
v_tmpfiles.AddRange(System.IO.Directory.GetFiles(this.v_service, "*.CSV", System.IO.SearchOption.TopDirectoryOnly));
v_tmpfiles.AddRange(System.IO.Directory.GetFiles(this.v_service, "*.dbf", System.IO.SearchOption.TopDirectoryOnly));
v_tmpfiles.AddRange(System.IO.Directory.GetFiles(this.v_service, "*.DBF", System.IO.SearchOption.TopDirectoryOnly));
v_tmpfiles.AddRange(System.IO.Directory.GetFiles(this.v_service, "*.xlsx", System.IO.SearchOption.TopDirectoryOnly));
v_tmpfiles.AddRange(System.IO.Directory.GetFiles(this.v_service, "*.XLSX", System.IO.SearchOption.TopDirectoryOnly));
foreach (string s in v_tmpfiles)
{
v_row = v_table.NewRow();
Spartacus.Utils.File f = new Spartacus.Utils.File(Spartacus.Utils.FileType.FILE, s);
v_row["table_name"] = "[" + f.v_name + "]";
v_table.Rows.Add(v_row);
}
}
return(v_table);
}
/// <summary>
/// Inicializa uma nova instância da classe <see cref="Spartacus.Utils.FileArray"/>.
/// </summary>
/// <param name="p_directorynames">String contendo nomes de diretórios separados por ponto-e-vírgula.</param>
/// <param name="p_filter">Filtro de extensão de arquivos.</param>
/// <param name="p_searchoption">Opção de busca no diretório.</param>
public FileArray(string p_directorynames, string p_filter, System.IO.SearchOption p_searchoption)
{
Spartacus.Utils.File v_file;
string[] v_directorynames;
string[] v_filenames;
int k;
this.v_files = new System.Collections.Generic.List <Spartacus.Utils.File>();
v_directorynames = p_directorynames.Split(';');
k = 1;
foreach (string v_directoryname in v_directorynames)
{
v_filenames = this.FilterList(v_directoryname, p_filter, p_searchoption);
foreach (string v_filename in v_filenames)
{
v_file = new Spartacus.Utils.File(k, 1, Spartacus.Utils.FileType.FILE, v_filename);
this.v_files.Add(v_file);
k++;
}
}
}
/// <summary>
/// Inicializa uma nova instância da classe <see cref="Spartacus.Utils.FileArray"/>.
/// </summary>
/// <param name="p_filenames">Lista de nomes de arquivos ou diretórios.</param>
/// <param name="p_filetype">Tipo dos nomes, se são arquivos ou diretórios.</param>
public FileArray(System.Collections.Generic.List <string> p_filenames, Spartacus.Utils.FileType p_filetype)
{
Spartacus.Utils.File v_file;
int k;
this.v_files = new System.Collections.Generic.List <Spartacus.Utils.File>();
k = 1;
foreach (string v_filename in p_filenames)
{
v_file = new Spartacus.Utils.File(k, 1, p_filetype, v_filename);
this.v_files.Add(v_file);
k++;
}
}
/// <summary>
/// Inicializa uma nova instância da classe <see cref="Spartacus.Utils.FileArray"/>.
/// </summary>
/// <param name="p_filenames">Lista de nomes de arquivos ou diretórios.</param>
/// <param name="p_filetype">Tipo dos nomes, se são arquivos ou diretórios.</param>
public FileArray(System.Collections.ArrayList p_filenames, Spartacus.Utils.FileType p_filetype)
{
Spartacus.Utils.File v_file;
int k;
this.v_files = new System.Collections.ArrayList();
k = 1;
foreach (string v_filename in p_filenames)
{
v_file = new Spartacus.Utils.File(k, 1, p_filetype, v_filename);
this.v_files.Add(v_file);
k++;
}
}
public static void Main(string[] args)
{
Spartacus.Utils.FileExplorer v_explorer;
Spartacus.Utils.File v_directory;
Spartacus.Utils.ProgressEventClass v_progress;
v_explorer = new Utils.FileExplorer(".");
v_directory = new Spartacus.Utils.File(Spartacus.Utils.FileType.DIRECTORY, "./Data");
v_progress = new Spartacus.Utils.ProgressEventClass();
v_progress.ProgressEvent += OnProgress;
Console.Write("Compressing into Data_ZipStorer.zip...");
v_explorer.CompressDirectory("Data_ZipStorer.zip", v_directory);
Console.WriteLine();
Console.WriteLine();
Console.Write("Compressing into Data_DotNetZip.zip...");
v_explorer.CompressDirectory("Data_DotNetZip.zip", v_directory, v_progress);
Console.WriteLine();
}
/// <summary>
/// Entra no diretório especificado.
/// </summary>
/// <param name='p_id'>
/// Código do diretório dentro da lista de arquivos e diretórios.
/// </param>
/// <exception cref="Spartacus.Utils.Exception">Exceção acontece quando o item referenciado não é um diretório.</exception>
public void Enter(int p_id)
{
Spartacus.Utils.File v_file;
try
{
v_file = (Spartacus.Utils.File) this.v_files[p_id-1];
if (v_file.v_filetype != Spartacus.Utils.FileType.DIRECTORY)
{
throw new Spartacus.Utils.Exception("{0} não é um diretório.", v_file.CompleteFileName());
}
else
{
this.v_current = new Spartacus.Utils.File(0, 0, Spartacus.Utils.FileType.DIRECTORY, v_file.CompleteFileName());
this.v_current.v_protected = v_file.v_protected;
this.v_currentlevel++;
this.v_returnhistory.Add(this.v_current.CompleteFileName());
}
}
catch (System.Exception e)
{
throw new Spartacus.Utils.Exception(e);
}
}
/// <summary>
/// Cria um arquivo ZIP a partir de um diretório, no diretório pai do mesmo diretório.
/// </summary>
/// <returns>Arquivo ZIP.</returns>
/// <param name="p_zipfilename">Nome do arquivo ZIP a ser criado.</param>
/// <param name="p_directory">Diretório a ser compactado.</param>
public Spartacus.Utils.File CompressDirectory(string p_zipfilename, Spartacus.Utils.File p_directory)
{
Spartacus.ThirdParty.ZipStorer v_zipstorer;
Spartacus.Utils.File v_zipfiletmp, v_zipfile;
Spartacus.Utils.FileArray v_filearray;
System.IO.FileInfo v_fileinfo;
if (p_directory.v_pathseparator == Spartacus.Utils.PathSeparator.SLASH)
v_zipfiletmp = new Spartacus.Utils.File(1, 1, Spartacus.Utils.FileType.FILE, p_directory.v_path + "/" + p_zipfilename);
else
v_zipfiletmp = new Spartacus.Utils.File(1, 1, Spartacus.Utils.FileType.FILE, p_directory.v_path + "\\" + p_zipfilename);
try
{
v_zipstorer = Spartacus.ThirdParty.ZipStorer.Create(v_zipfiletmp.CompleteFileName(), "Generated with ZipStorer (by Jaime Olivares) embedded in Spartacus (by William Ivanski)");
v_zipstorer.EncodeUTF8 = true;
v_filearray = new Spartacus.Utils.FileArray(p_directory.CompleteFileName(), "*", System.IO.SearchOption.AllDirectories);
foreach (Spartacus.Utils.File v_file in v_filearray.v_files)
v_zipstorer.AddFile(Spartacus.ThirdParty.ZipStorer.Compression.Deflate, v_file.CompleteFileName(), v_file.CompleteFileName().Replace(p_directory.v_path, ""), "");
v_zipstorer.Close();
v_fileinfo = new System.IO.FileInfo(v_zipfiletmp.CompleteFileName());
v_zipfile = new Spartacus.Utils.File(1, 1, Spartacus.Utils.FileType.FILE, v_zipfiletmp.CompleteFileName(), v_fileinfo.LastWriteTime, v_fileinfo.Length);
}
catch (System.Exception e)
{
throw new Spartacus.Utils.Exception(e);
}
return v_zipfile;
}
/// <summary>
/// Inicializa uma nova instância da classe <see cref="Spartacus.Utils.FileExplorer"/>.
/// </summary>
/// <param name='p_root'>
/// Pasta raiz do explorador de arquivos.
/// </param>
/// <param name='p_pathseparator'>
/// Separador de diretórios.
/// </param>
public FileExplorer(string p_root, Spartacus.Utils.PathSeparator p_pathseparator)
{
this.v_root = p_root;
this.v_pathseparator = p_pathseparator;
this.v_current = new Spartacus.Utils.File(0, 0, Spartacus.Utils.FileType.DIRECTORY, this.v_root, this.v_pathseparator);
this.v_currentlevel = 0;
this.v_protectedminlevel = -1; // proteção a princípio está desabilitada
this.v_showpatterntype = Spartacus.Utils.ShowPatternType.SHOWALL; // padrão é mostrar todos os arquivos
this.v_protectpattern = "";
this.v_showhiddenfiles = false; // padrão é não mostrar arquivos e pastas ocultos
this.v_current.v_protected = true; // raiz sempre é protegida
this.v_files = new System.Collections.ArrayList();
this.v_returnhistory = new System.Collections.ArrayList();
this.v_returnhistory_font = new PDFjet.NET.Font(PDFjet.NET.CoreFont.HELVETICA);
this.v_returnhistory_font.SetSize(12.0);
this.v_returnhistory_root = "Diretorio Raiz";
this.v_returnhistory_sep = " > ";
this.v_returnhistory_first = "...";
this.v_returnhistory_maxwidth = 800.0;
this.v_returnhistory.Add(p_root);
}
/// <summary>
/// Seta a pasta raiz do explorador de arquivos.
/// </summary>
/// <param name='p_root'>
/// Pasta raiz do explorador de arquivos.
/// </param>
public void SetRoot(string p_root)
{
this.v_root = p_root;
this.v_current = new Spartacus.Utils.File(0, 0, Spartacus.Utils.FileType.DIRECTORY, this.v_root, this.v_pathseparator);
this.v_currentlevel = 0;
this.v_current.v_protected = true; // raiz sempre é protegida
this.v_returnhistory.Add(p_root);
}
/// <summary>
/// Constrói lista de arquivos e diretorios contidos no diretório atual.
/// </summary>
/// <exception cref="Spartacus.Utils.Exception">Exceção acontece quando não conseguir listar o conteúdo do diretório atual.</exception>
public void List()
{
Spartacus.Utils.File v_file, v_directory;
System.IO.DirectoryInfo v_directoryinfo;
System.IO.FileInfo v_fileinfo;
int k;
try
{
this.v_files.Clear();
k = 1;
foreach (string v_item in System.IO.Directory.GetDirectories(this.v_current.CompleteFileName()))
{
switch (this.v_showpatterntype)
{
case Spartacus.Utils.ShowPatternType.SHOWALL:
v_directoryinfo = new System.IO.DirectoryInfo(v_item);
v_directory = new Spartacus.Utils.File(k, 0, Spartacus.Utils.FileType.DIRECTORY, v_item, this.v_pathseparator, v_directoryinfo.LastWriteTime);
if (v_item.Contains(this.v_protectpattern) || this.v_currentlevel < this.v_protectedminlevel)
v_directory.v_protected = true;
if (v_directory.v_hidden)
{
if (this.v_showhiddenfiles)
{
this.v_files.Add(v_directory);
k++;
}
}
else
{
this.v_files.Add(v_directory);
k++;
}
break;
case Spartacus.Utils.ShowPatternType.SHOWALLEXCEPTPATTERN:
if (! v_item.Contains(this.v_protectpattern)) // só vai mostrar se não contiver o padrão
{
v_directoryinfo = new System.IO.DirectoryInfo(v_item);
v_directory = new Spartacus.Utils.File(k, 0, Spartacus.Utils.FileType.DIRECTORY, v_item, this.v_pathseparator, v_directoryinfo.LastWriteTime);
if (this.v_currentlevel < this.v_protectedminlevel)
v_directory.v_protected = true;
if (v_directory.v_hidden)
{
if (this.v_showhiddenfiles)
{
this.v_files.Add(v_directory);
k++;
}
}
else
{
this.v_files.Add(v_directory);
k++;
}
}
break;
case Spartacus.Utils.ShowPatternType.SHOWONLYPATTERN:
// só vai mostrar se contiver o padrão ou se o nivel atual for menor que o nivel minimo protegido
if (v_item.Contains(this.v_protectpattern) || this.v_currentlevel < this.v_protectedminlevel)
{
v_directoryinfo = new System.IO.DirectoryInfo(v_item);
v_directory = new Spartacus.Utils.File(k, 0, Spartacus.Utils.FileType.DIRECTORY, v_item, this.v_pathseparator, v_directoryinfo.LastWriteTime);
if (v_item.Contains(this.v_protectpattern) || this.v_currentlevel < this.v_protectedminlevel)
v_directory.v_protected = true;
if (v_directory.v_hidden)
{
if (this.v_showhiddenfiles)
{
this.v_files.Add(v_directory);
k++;
}
}
else
{
this.v_files.Add(v_directory);
k++;
}
}
break;
case Spartacus.Utils.ShowPatternType.SHOWALLPROTECTED:
// mostra todos os arquivos, mas todos estao protegidos
v_directoryinfo = new System.IO.DirectoryInfo(v_item);
v_directory = new Spartacus.Utils.File(k, 0, Spartacus.Utils.FileType.DIRECTORY, v_item, this.v_pathseparator, v_directoryinfo.LastWriteTime);
v_directory.v_protected = true;
if (v_directory.v_hidden)
{
if (this.v_showhiddenfiles)
{
this.v_files.Add(v_directory);
k++;
}
}
else
{
this.v_files.Add(v_directory);
k++;
}
break;
}
}
foreach (string v_item in System.IO.Directory.GetFiles(this.v_current.CompleteFileName()))
{
v_fileinfo = new System.IO.FileInfo(v_item);
v_file = new Spartacus.Utils.File(k, 0, Spartacus.Utils.FileType.FILE, v_item, this.v_pathseparator, v_fileinfo.LastWriteTime, v_fileinfo.Length);
if (v_item.Contains(this.v_protectpattern) || this.v_currentlevel < this.v_protectedminlevel || this.v_showpatterntype == ShowPatternType.SHOWALLPROTECTED)
v_file.v_protected = true;
if (v_file.v_hidden)
{
if (this.v_showhiddenfiles)
{
this.v_files.Add(v_file);
k++;
}
}
else
{
this.v_files.Add(v_file);
k++;
}
}
}
catch (System.Exception e)
{
throw new Spartacus.Utils.Exception(e);
}
}
/// <summary>
/// Exporta todas as <see cref="System.Data.DataTable"/> dentro de um <see cref="System.Data.DataSet"/> para um arquivo Excel.
/// O markup do cabeçalho sempre é substituído.
/// </summary>
/// <param name="p_filename">Nome do arquivo XLSX ou CSV a ser exportado.</param>
/// <param name="p_templatenames">Nome do arquivo XLSX a ser usado como template.</param>
/// <exception cref="Spartacus.Utils.Exception">Exceção acontece quando não conseguir escrever no arquivo de destino, ou quando ocorrer qualquer problema na SejExcel.</exception>
public void Export(string p_filename, System.Collections.ArrayList p_templatenames)
{
Spartacus.Utils.File v_file;
string v_markup;
v_file = new Spartacus.Utils.File(1, 1, Spartacus.Utils.FileType.FILE, p_filename);
try
{
switch (v_file.v_extension.ToLower())
{
case "xlsx":
v_markup = this.ReplaceMarkup(p_templatenames);
this.ExportXLSX(p_filename, v_markup);
(new System.IO.FileInfo(v_markup)).Delete();
break;
case "csv":
this.ExportCSV(p_filename, ';', System.Text.Encoding.Default);
break;
default:
throw new Spartacus.Utils.Exception("Extensao {0} desconhecida.", v_file.v_extension.ToLower());
}
}
catch (Spartacus.Utils.Exception e)
{
throw new Spartacus.Utils.Exception("Erro ao salvar o DataSet no arquivo {0}.", e, p_filename);
}
catch (System.Exception e)
{
throw new Spartacus.Utils.Exception("Erro ao salvar o DataSet no arquivo {0}.", e, p_filename);
}
}
/// <summary>
/// Importa um arquivo DBF para um <see cref="System.Data.DataTable"/>.
/// </summary>
/// <param name="p_filename">Nome do arquivo DBF.</param>
private void ImportDBF(string p_filename)
{
Spartacus.Utils.File v_file;
System.Data.DataTable v_table;
System.Data.DataRow v_row;
SocialExplorer.IO.FastDBF.DbfFile v_dbf;
SocialExplorer.IO.FastDBF.DbfRecord v_record;
try
{
v_file = new Spartacus.Utils.File(1, 1, Spartacus.Utils.FileType.FILE, p_filename);
v_table = new System.Data.DataTable(v_file.v_name.Replace("." + v_file.v_extension, ""));
v_dbf = new SocialExplorer.IO.FastDBF.DbfFile(System.Text.Encoding.UTF8);
v_dbf.Open(p_filename, System.IO.FileMode.Open);
for (int i = 0; i < v_dbf.Header.ColumnCount; i++)
{
if (v_dbf.Header[i].ColumnType != SocialExplorer.IO.FastDBF.DbfColumn.DbfColumnType.Binary &&
v_dbf.Header[i].ColumnType != SocialExplorer.IO.FastDBF.DbfColumn.DbfColumnType.Memo)
v_table.Columns.Add(v_dbf.Header[i].Name, typeof(string));
}
v_record = new SocialExplorer.IO.FastDBF.DbfRecord(v_dbf.Header);
while (v_dbf.ReadNext(v_record))
{
if (! v_record.IsDeleted)
{
v_row = v_table.NewRow();
for (int i = 0; i < v_record.ColumnCount; i++)
{
if (v_dbf.Header[i].ColumnType != SocialExplorer.IO.FastDBF.DbfColumn.DbfColumnType.Binary &&
v_dbf.Header[i].ColumnType != SocialExplorer.IO.FastDBF.DbfColumn.DbfColumnType.Memo)
{
v_row[i] = v_record[i].Trim();
}
}
v_table.Rows.Add(v_row);
}
}
v_dbf.Close();
this.v_set.Tables.Add(v_table);
}
catch (Spartacus.Utils.Exception e)
{
throw new Spartacus.Utils.Exception("Erro ao carregar o arquivo {0}.", e, p_filename);
}
catch (System.Exception e)
{
throw new Spartacus.Utils.Exception("Erro ao carregar o arquivo {0}.", e, p_filename);
}
}
/// <summary>
/// Inicializa uma nova instância da classe <see cref="Spartacus.Utils.FileArray"/>.
/// </summary>
/// <param name="p_directorynames">Lista de nomes de diretórios.</param>
/// <param name="p_filter">Filtro de extensão de arquivos.</param>
public FileArray(System.Collections.ArrayList p_directorynames, string p_filter)
{
Spartacus.Utils.File v_file;
string[] v_filenames;
int k;
this.v_files = new System.Collections.ArrayList();
k = 1;
foreach (string v_directoryname in p_directorynames)
{
System.Console.WriteLine("Entrou " + v_directoryname);
v_filenames = this.FilterList(v_directoryname, p_filter, System.IO.SearchOption.TopDirectoryOnly);
foreach (string v_filename in v_filenames)
{
v_file = new Spartacus.Utils.File(k, 1, Spartacus.Utils.FileType.FILE, v_filename);
this.v_files.Add(v_file);
k++;
}
}
}
/// <summary>
/// Inicializa uma nova instância da classe <see cref="Spartacus.Utils.FileArray"/>.
/// </summary>
/// <param name="p_directorynames">String contendo nomes de diretórios separados por ponto-e-vírgula.</param>
/// <param name="p_filter">Filtro de extensão de arquivos.</param>
/// <param name="p_searchoption">Opção de busca no diretório.</param>
public FileArray(string p_directorynames, string p_filter, System.IO.SearchOption p_searchoption)
{
Spartacus.Utils.File v_file;
string[] v_directorynames;
string[] v_filenames;
int k;
this.v_files = new System.Collections.ArrayList();
v_directorynames = p_directorynames.Split(';');
k = 1;
foreach (string v_directoryname in v_directorynames)
{
v_filenames = this.FilterList(v_directoryname, p_filter, p_searchoption);
foreach (string v_filename in v_filenames)
{
v_file = new Spartacus.Utils.File(k, 1, Spartacus.Utils.FileType.FILE, v_filename);
this.v_files.Add(v_file);
k++;
}
}
}
/// <summary>
/// Entra no diretório especificado.
/// </summary>
/// <param name='p_completename'>
/// Caminho completo do diretório.
/// </param>
/// <param name='p_protected'>
/// Se o diretório é protegido ou não.
/// </param>
/// <param name="p_pathseparator">
/// Separador de diretórios.
/// </param>
public void Enter(string p_completename, bool p_protected, Spartacus.Utils.PathSeparator p_pathseparator)
{
string[] v_path;
string v_tmp;
char v_ch;
try
{
this.v_current = new Spartacus.Utils.File(0, 0, Spartacus.Utils.FileType.DIRECTORY, p_completename, p_pathseparator);
this.v_current.v_protected = p_protected;
if (p_pathseparator == Spartacus.Utils.PathSeparator.SLASH)
v_ch = '/';
else
v_ch = '\\';
v_path = p_completename.Replace(this.v_root, this.v_returnhistory_root).Split(v_ch);
this.v_returnhistory.Clear();
v_tmp = v_path[0];
this.v_returnhistory.Add(v_tmp);
for (int k = 1; k < v_path.Length; k++)
{
v_tmp += v_ch + v_path[k];
this.v_returnhistory.Add(v_tmp);
}
this.v_currentlevel = v_path.Length - 1;
}
catch (System.Exception e)
{
throw new Spartacus.Utils.Exception(e);
}
}
/// <summary>
/// Trata o histórico de retorno para pastas pai, conforme fonte e tamanho máximo do texto a ser renderizado.
/// </summary>
/// <returns>Vetor de histórico de retorno.</returns>
/// <param name="p_overflow">.</param>
public System.Collections.ArrayList GetReturnHistory(out bool p_overflow, out int p_start)
{
System.Collections.ArrayList v_handledhistory;
Spartacus.Utils.File v_directory;
string v_text;
int k;
v_handledhistory = new System.Collections.ArrayList();
p_overflow = false;
k = this.v_returnhistory.Count - 1;
v_text = "";
while (k > 0 && !p_overflow)
{
v_directory = new Spartacus.Utils.File(1, 1, Spartacus.Utils.FileType.DIRECTORY, (string)this.v_returnhistory [k]);
v_text += this.v_returnhistory_sep + (v_directory.v_name);
if (this.v_returnhistory_font.StringWidth(this.v_returnhistory_root + v_text) > this.v_returnhistory_maxwidth)
{
v_handledhistory.Insert(0, this.v_returnhistory_first);
p_overflow = true;
}
else
{
v_handledhistory.Insert(0, v_directory.v_name);
k--;
}
}
v_handledhistory.Insert(0, this.v_returnhistory_root);
p_start = k - 1;
return v_handledhistory;
}
/// <summary>
/// Exporta todas as <see cref="System.Data.DataTable"/> dentro de um <see cref="System.Data.DataSet"/> para um arquivo Excel.
/// </summary>
/// <param name="p_filename">Nome do arquivo XLSX ou CSV a ser exportado.</param>
/// <param name="p_separator">Separador de campos do arquivo CSV.</param>
/// <param name="p_encoding">Codificação de escrita do arquivo CSV.</param>
/// <exception cref="Spartacus.Utils.Exception">Exceção acontece quando não conseguir escrever no arquivo de destino, ou quando ocorrer qualquer problema na SejExcel.</exception>
public void Export(string p_filename, char p_separator, System.Text.Encoding p_encoding)
{
Spartacus.Utils.File v_file;
v_file = new Spartacus.Utils.File(1, 1, Spartacus.Utils.FileType.FILE, p_filename);
try
{
switch (v_file.v_extension.ToLower())
{
case "xlsx":
this.ExportXLSX(p_filename, "template.xlsx");
break;
case "csv":
this.ExportCSV(p_filename, p_separator, p_encoding);
break;
default:
throw new Spartacus.Utils.Exception("Extensao {0} desconhecida.", v_file.v_extension.ToLower());
}
}
catch (Spartacus.Utils.Exception e)
{
throw new Spartacus.Utils.Exception("Erro ao salvar o DataSet no arquivo {0}.", e, p_filename);
}
catch (System.Exception e)
{
throw new Spartacus.Utils.Exception("Erro ao salvar o DataSet no arquivo {0}.", e, p_filename);
}
}
/// <summary>
/// Retorna para um diretório anterior qualquer no histórico.
/// </summary>
/// <param name="p_history">Índice do histórico.</param>
/// <exception cref="Spartacus.Utils.Exception">Exceção acontece quando o diretório atual também é a raiz do explorador de arquivos.</exception>
public void Return(int p_history)
{
string v_parent;
if (this.v_current.CompleteFileName() == this.v_root)
{
throw new Spartacus.Utils.Exception("Já está no diretório raiz.");
}
else
{
v_parent = this.v_current.v_path;
this.v_current = new Spartacus.Utils.File(0, 0, Spartacus.Utils.FileType.DIRECTORY, v_parent);
this.v_currentlevel--;
if (v_parent.Contains(this.v_protectpattern) || this.v_currentlevel <= this.v_protectedminlevel)
this.v_current.v_protected = true;
this.v_returnhistory.RemoveAt(this.v_returnhistory.Count-1);
if (p_history < this.v_returnhistory.Count - 1)
this.Return(p_history);
}
}
/// <summary>
/// Importa todas as planilhas de um arquivo Excel para várias <see cref="System.Data.DataTable"/> dentro de um <see cref="System.Data.DataSet"/>.
/// </summary>
/// <param name="p_filename">Nome do arquivo CSV a ser importado.</param>
/// <param name="p_separator">Separador de campos do arquivo CSV.</param>
/// <param name="p_delimitator">Delimitador de campos do arquivo CSV.</param>
/// <param name="p_header">Se deve considerar a primeira linha como cabeçalho ou não.</param>
/// <param name="p_encoding">Codificação para leitura do arquivo CSV.</param>
/// <exception cref="Spartacus.Utils.Exception">Exceção acontece quando não conseguir ler o arquivo de origem, ou quando ocorrer qualquer problema na SejExcel.</exception>
public void Import(string p_filename, char p_separator, char p_delimitator, bool p_header, System.Text.Encoding p_encoding)
{
System.IO.FileInfo v_fileinfo;
Spartacus.Utils.File v_file;
v_fileinfo = new System.IO.FileInfo(p_filename);
if (! v_fileinfo.Exists)
{
throw new Spartacus.Utils.Exception(string.Format("Arquivo {0} nao existe.", p_filename));
}
else
{
try
{
v_file = new Spartacus.Utils.File(1, 1, Spartacus.Utils.FileType.FILE, p_filename);
switch (v_file.v_extension.ToLower())
{
case "xlsx":
this.ImportXLSX(p_filename);
break;
case "csv":
this.ImportCSV(p_filename, p_separator, p_delimitator, p_header, p_encoding);
break;
case "dbf":
this.ImportDBF(p_filename);
break;
default:
throw new Spartacus.Utils.Exception("Extensao {0} desconhecida.", v_file.v_extension.ToLower());
}
}
catch (Spartacus.Utils.Exception e)
{
throw new Spartacus.Utils.Exception("Erro ao converter para DataSet o arquivo {0}.", e, p_filename);
}
catch (System.Exception e)
{
throw new Spartacus.Utils.Exception("Erro ao converter para DataSet o arquivo {0}.", e, p_filename);
}
}
}
/// <summary>
/// Inicializa uma nova instância da classe <see cref="Spartacus.Database.Oledb"/>.
/// Cria a string de conexão ao banco.
/// </summary>
/// <param name='p_provider'>
/// SGBD que fornece o banco de dados.
/// </param>
/// <param name='p_host'>
/// Hostname ou IP onde o banco de dados está localizado.
/// </param>
/// <param name='p_port'>
/// Porta TCP para conectar-se ao SGBG.
/// </param>
/// <param name='p_service'>
/// Nome do serviço que representa o banco ao qual desejamos nos conectar.
/// </param>
/// <param name='p_user'>
/// Usuário ou schema para se conectar ao banco de dados.
/// </param>
/// <param name='p_password'>
/// A senha do usuário ou schema.
/// </param>
public Oledb(string p_provider, string p_host, string p_port, string p_service, string p_user, string p_password)
: base(p_host, p_port, p_service, p_user, p_password)
{
Spartacus.Utils.File v_file;
switch (p_provider)
{
case "Oracle":
this.v_connectionstring = "Provider=OraOLEDB.Oracle;Data Source=(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST="
+ this.v_host + ")(PORT="
+ this.v_port + ")))(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME="
+ this.v_service + ")));User Id="
+ this.v_user + ";Password="******"Access":
v_file = new Spartacus.Utils.File(1, 1, Spartacus.Utils.FileType.FILE, v_service);
if (v_file.v_extension.ToLower() == "accdb")
this.v_connectionstring = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" + this.v_service + ";Persist Security Info=False;";
else
this.v_connectionstring = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + this.v_service + ";User Id=admin;Password=;";
break;
default:
this.v_connectionstring = "Provider="
+ p_provider + ";Addr="
+ this.v_host + ";Port="
+ this.v_port + ";Database="
+ this.v_service + ";User Id="
+ this.v_user + ";Password="
+ this.v_password;
break;
}
this.v_con = null;
this.v_cmd = null;
this.v_reader = null;
}
/// <summary>
/// Importa um arquivo CSV para um <see cref="System.Data.DataTable"/>.
/// </summary>
/// <param name="p_filename">Nome do arquivo CSV.</param>
/// <param name="p_separator">Separador de campos do arquivo CSV.</param>
/// <param name="p_delimitator">Delimitador de campos do arquivo CSV.</param>
/// <param name="p_header">Se deve considerar a primeira linha como cabeçalho ou não.</param>
/// <param name="p_encoding">Codificação para leitura do arquivo CSV.</param>
private void ImportCSV(string p_filename, char p_separator, char p_delimitator, bool p_header, System.Text.Encoding p_encoding)
{
Spartacus.Utils.File v_file;
System.IO.StreamReader v_reader = null;
System.Data.DataTable v_table;
System.Data.DataRow v_row;
string[] v_line;
int i, j;
try
{
v_file = new Spartacus.Utils.File(1, 1, Spartacus.Utils.FileType.FILE, p_filename);
v_table = new System.Data.DataTable(v_file.v_name.Replace("." + v_file.v_extension, ""));
v_reader = new System.IO.StreamReader(p_filename, p_encoding);
i = 0;
while (! v_reader.EndOfStream)
{
v_line = v_reader.ReadLine().Split(p_separator);
if (i == 0)
{
if (p_header)
{
for (j = 0; j < v_line.Length; j++)
v_table.Columns.Add(v_line [j].Trim(p_delimitator));
}
else
{
for (j = 0; j < v_line.Length; j++)
v_table.Columns.Add("col" + j.ToString());
v_row = v_table.NewRow();
for (j = 0; j < v_table.Columns.Count; j++)
v_row[j] = v_line[j].Trim(p_delimitator);
v_table.Rows.Add(v_row);
}
}
else
{
v_row = v_table.NewRow();
for (j = 0; j < System.Math.Min(v_table.Columns.Count, v_line.Length); j++)
v_row[j] = v_line[j].Trim(p_delimitator);
v_table.Rows.Add(v_row);
}
i++;
}
this.v_set.Tables.Add(v_table);
}
catch (Spartacus.Utils.Exception e)
{
throw new Spartacus.Utils.Exception("Erro ao carregar o arquivo {0}.", e, p_filename);
}
catch (System.Exception e)
{
throw new Spartacus.Utils.Exception("Erro ao carregar o arquivo {0}.", e, p_filename);
}
finally
{
if (v_reader != null)
{
v_reader.Close();
v_reader = null;
}
}
}
