Пример #1
0
        public JanelaAgente(Spartacus.Database.Generic p_database, Spartacus.Forms.Window p_pai)
            : base("Edição de Agente", 300, 200, p_pai)
        {
            this.v_database = p_database;

            this.v_id = new Spartacus.Forms.Textbox(this, "Código");
            this.v_id.Disable();
            this.Add(this.v_id);

            this.v_nome = new Spartacus.Forms.Textbox(this, "Nome");
            this.Add(this.v_nome);

            this.v_telefone = new Spartacus.Forms.Textbox(this, "Telefone");
            this.Add(this.v_telefone);

            this.v_buttons = new Spartacus.Forms.Buttons(this);
            this.v_buttons.AddButton("Salvar", this.ClickSalvar);
            this.v_buttons.AddButton("Cancelar", this.ClickCancelar);
            this.Add(this.v_buttons);

            this.v_insert = new Spartacus.Database.Command();
            this.v_insert.v_text = "insert into agentes (nome, telefone) values (#NOME#, #TELEFONE#)";
            this.v_insert.AddParameter("NOME", Spartacus.Database.Type.STRING);
            this.v_insert.AddParameter("TELEFONE", Spartacus.Database.Type.STRING);

            this.v_update = new Spartacus.Database.Command();
            this.v_update.v_text = "update agentes set nome = #NOME#, telefone = #TELEFONE# where id = #ID#";
            this.v_update.AddParameter("NOME", Spartacus.Database.Type.STRING);
            this.v_update.AddParameter("TELEFONE", Spartacus.Database.Type.STRING);
            this.v_update.AddParameter("ID", Spartacus.Database.Type.INTEGER);
        }
Пример #2
0
        public JanelaAgentes(Spartacus.Database.Generic p_database, Spartacus.Forms.Window p_pai)
            : base("Cadastro de Agentes", 600, 400, p_pai)
        {
            this.v_database = p_database;

            this.v_grid = new Spartacus.Forms.Grid(this, 330);
            this.v_grid.Populate(
                this.v_database,
                "select a.id,      " +
                "       a.nome,    " +
                "       a.telefone " +
                "from agentes a    " +
                "order by a.id     "
            );
            this.Add(this.v_grid);

            this.v_buttons = new Spartacus.Forms.Buttons(this);
            this.v_buttons.AddButton("Novo", this.ClickNovo);
            this.v_buttons.AddButton("Editar", this.ClickEditar);
            this.v_buttons.AddButton("Remover", this.ClickRemover);
            this.Add(this.v_buttons);

            this.v_janelaagente = new JanelaAgente(this.v_database, this);

            this.v_delete = new Spartacus.Database.Command();
            this.v_delete.v_text = "delete from agentes where id = #ID#";
            this.v_delete.AddParameter("ID", Spartacus.Database.Type.INTEGER);
        }
Пример #3
0
        /// <summary>
        /// Renderiza o Bloco em uma Página.
        /// </summary>
        /// <param name="p_font">Fonte.</param>
        /// <param name="p_posx">Posição X.</param>
        /// <param name="p_posy">Posição Y.</param>
        /// <param name="p_rightmargin">Margem direita.</param>
        /// <param name="p_pdf">Objeto PDF.</param>
        /// <param name="p_page">Página onde o Bloco será renderizado.</param>
        public void Render(Spartacus.Reporting.Font p_font, double p_posx, double p_posy, double p_rightmargin, PDFjet.NET.PDF p_pdf, PDFjet.NET.Page p_page)
        {
            PDFjet.NET.Line v_line;
            int k;

            // renderizando objetos do bloco
            for (k = 0; k < this.v_objects.Count; k++)
            {
                switch (((Spartacus.Reporting.Object)this.v_objects [k]).v_type)
                {
                    case Spartacus.Reporting.ObjectType.IMAGE:
                        this.RenderImage((Spartacus.Reporting.Object)this.v_objects [k], p_posx, p_posy, p_rightmargin, p_pdf, p_page);
                        break;
                    case Spartacus.Reporting.ObjectType.PAGENUMBER:
                        if (((Spartacus.Reporting.Object)this.v_objects [k]).v_font != null)
                            this.RenderPageNumber((Spartacus.Reporting.Object)this.v_objects [k], p_posx, p_posy, p_rightmargin, ((Spartacus.Reporting.Object)this.v_objects [k]).v_font, p_pdf, p_page);
                        else
                            this.RenderPageNumber((Spartacus.Reporting.Object)this.v_objects [k], p_posx, p_posy, p_rightmargin, p_font, p_pdf, p_page);
                        break;
                    case Spartacus.Reporting.ObjectType.TEXT:
                        if (((Spartacus.Reporting.Object)this.v_objects [k]).v_font != null)
                            this.RenderText((Spartacus.Reporting.Object)this.v_objects [k], p_posx, p_posy, p_rightmargin, ((Spartacus.Reporting.Object)this.v_objects [k]).v_font, p_pdf, p_page);
                        else
                            this.RenderText((Spartacus.Reporting.Object)this.v_objects [k], p_posx, p_posy, p_rightmargin, p_font, p_pdf, p_page);
                        break;
                    default:
                        break;
                }
            }

            // borda superior
            if (this.v_border.v_top)
            {
                v_line = new PDFjet.NET.Line(p_posx, p_posy, p_page.GetWidth() - p_rightmargin, p_posy);
                v_line.DrawOn(p_page);
            }

            // borda inferior
            if (this.v_border.v_bottom)
            {
                v_line = new PDFjet.NET.Line(p_posx, p_posy + this.v_height, p_page.GetWidth() - p_rightmargin, p_posy + this.v_height);
                v_line.DrawOn(p_page);
            }

            // borda esquerda
            if (this.v_border.v_left)
            {
                v_line = new PDFjet.NET.Line(p_posx, p_posy, p_posx, p_posy + this.v_height);
                v_line.DrawOn(p_page);
            }

            // borda direita
            if (this.v_border.v_right)
            {
                v_line = new PDFjet.NET.Line(p_page.GetWidth() - p_rightmargin, p_posy, p_page.GetWidth() - p_rightmargin, p_posy + this.v_height);
                v_line.DrawOn(p_page);
            }
        }
Пример #4
0
        public JanelaPrincipal(Spartacus.Database.Generic p_database)
            : base("Finanças Pessoais", 800, 600)
        {
            this.v_database = p_database;

            Spartacus.Forms.Menugroup v_group, v_group2;
            this.v_menu = new Spartacus.Forms.Menu(this);
            v_group = this.v_menu.AddGroup("Cadastro");
            this.v_menu.AddItem(v_group, "Agentes", this.MenuAgentes);
            this.Add(this.v_menu);
            v_group = this.v_menu.AddGroup("Relatórios");
            v_group2 = this.v_menu.AddGroup(v_group, "Listagem de Agentes");
            this.v_menu.AddItem(v_group2, "Excel", this.MenuAgentesExcel);
            this.v_menu.AddItem(v_group2, "PDF", this.MenuAgentesPDF);
            v_group2 = this.v_menu.AddGroup(v_group, "Listagem de Movimentação");
            this.v_menu.AddItem(v_group2, "Excel", this.MenuMovimentacaoExcel);
            this.v_menu.AddItem(v_group2, "PDF", this.MenuMovimentacaoPDF);

            this.v_grid = new Spartacus.Forms.Grid(this, 480);
            this.v_grid.Populate(
                this.v_database,
                "select m.id,         " +
                "       m.data,       " +
                "       a.nome,       " +
                "       m.descricao,  " +
                "       m.debito,     " +
                "       m.credito,    " +
                "       m.saldo       " +
                "from movimentos m    " +
                "inner join agentes a " +
                "on a.id = m.idagente " +
                "order by m.id desc   "
            );
            this.Add(this.v_grid);

            this.v_buttons = new Spartacus.Forms.Buttons(this);
            this.v_buttons.AddButton("Débito", this.ClickDebito);
            this.v_buttons.AddButton("Crédito", this.ClickCredito);
            this.v_buttons.AddButton("Estorno", this.ClickEstorno);
            this.v_buttons.AddButton("Atualizar", this.ClickAtualizar);
            this.Add(this.v_buttons);

            this.v_janelaagentes = new JanelaAgentes(this.v_database, this);
            this.v_janeladebito = new JanelaDebito(this.v_database, this);
            this.v_janelacredito = new JanelaCredito(this.v_database, this);

            this.v_cmd = new Spartacus.Database.Command();
            this.v_cmd.v_text = "insert into movimentos (idagente, data, debito, credito, saldo, descricao) values (#IDAGENTE#, #DATA#, #DEBITO#, #CREDITO#, #SALDO#, #DESCRICAO#)";
            this.v_cmd.AddParameter("IDAGENTE", Spartacus.Database.Type.INTEGER);
            this.v_cmd.AddParameter("DATA", Spartacus.Database.Type.INTEGER);
            this.v_cmd.AddParameter("DEBITO", Spartacus.Database.Type.REAL);
            this.v_cmd.SetLocale("DEBITO", Spartacus.Database.Locale.EUROPEAN);
            this.v_cmd.AddParameter("CREDITO", Spartacus.Database.Type.REAL);
            this.v_cmd.SetLocale("CREDITO", Spartacus.Database.Locale.EUROPEAN);
            this.v_cmd.AddParameter("SALDO", Spartacus.Database.Type.REAL);
            this.v_cmd.SetLocale("SALDO", Spartacus.Database.Locale.EUROPEAN);
            this.v_cmd.AddParameter("DESCRICAO", Spartacus.Database.Type.STRING);
        }
Пример #5
0
        /// <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++;
            }
        }
        /// <summary>
        /// Exporta as infromações da Query passada por parâmetro, para um arquivo XLSX
        /// </summary>
        /// <returns>The tabela para XLS.</returns>
        /// <param name="Caminho">Caminho em que será salvo o arquivo, completo, já com a extenção e o nome.</param>
        /// <param name="QuerySQL">Comando que será utilizado para gerar a tebela que será exportada.</param>
        public static string ExportarTabelaParaXLSX(String Caminho, Spartacus.Database.Command QuerySQL)
        {
            Spartacus.Database.Generic database;

            try
            {
                database = new Spartacus.Database.Sqlite(DB.GetStrConection());

                database.TransferToFile(QuerySQL.GetUpdatedText(), Caminho);

                return "Relatório gerado com sucesso!";

            }
            catch (Spartacus.Database.Exception ex)
            {
                return String.Format("Ocorreu um erro ao gerar o relatório: {0}", ex.v_message);
            }
        }
Пример #7
0
        public JanelaDebito(Spartacus.Database.Generic p_database, Spartacus.Forms.Window p_pai)
            : base("Novo Débito", 600, 300, p_pai)
        {
            this.v_database = p_database;

            this.v_agente = new Spartacus.Forms.Lookup(this, "Agente", 40, 60);
            this.v_agente.Populate(
                this.v_database,
                "select a.id,   " +
                "       a.nome  " +
                "from agentes a " +
                "order by a.id  "
            );
            this.Add(this.v_agente);

            this.v_valor = new Spartacus.Forms.Textbox(this, "Valor");
            this.Add(this.v_valor);

            this.v_descricao = new Spartacus.Forms.Memobox(this, "Descrição", 150);
            this.Add(this.v_descricao);

            this.v_buttons = new Spartacus.Forms.Buttons(this);
            this.v_buttons.AddButton("Salvar", this.ClickSalvar);
            this.v_buttons.AddButton("Cancelar", this.ClickCancelar);
            this.Add(this.v_buttons);

            this.v_cmd = new Spartacus.Database.Command();
            this.v_cmd.v_text = "insert into movimentos (idagente, data, debito, credito, saldo, descricao) values (#IDAGENTE#, #DATA#, #DEBITO#, #CREDITO#, #SALDO#, #DESCRICAO#)";
            this.v_cmd.AddParameter("IDAGENTE", Spartacus.Database.Type.INTEGER);
            this.v_cmd.AddParameter("DATA", Spartacus.Database.Type.INTEGER);
            this.v_cmd.AddParameter("DEBITO", Spartacus.Database.Type.REAL);
            this.v_cmd.SetLocale("DEBITO", Spartacus.Database.Locale.EUROPEAN);
            this.v_cmd.AddParameter("CREDITO", Spartacus.Database.Type.REAL);
            this.v_cmd.SetLocale("CREDITO", Spartacus.Database.Locale.EUROPEAN);
            this.v_cmd.AddParameter("SALDO", Spartacus.Database.Type.REAL);
            this.v_cmd.SetLocale("SALDO", Spartacus.Database.Locale.EUROPEAN);
            this.v_cmd.AddParameter("DESCRICAO", Spartacus.Database.Type.STRING);
        }
        /// <summary>
        /// Inicializa uma instância da classe <see cref="Spartacus.Database.Parameter"/> .
        /// </summary>
        /// <param name='p_name'>
        /// Nome do parâmetro dentro do Comando SQL.
        /// </param>
        /// <param name='p_type'>
        /// Tipo de dados do parâmetro.
        /// </param>
        public Parameter(String p_name, Spartacus.Database.Type p_type)
        {
            this.v_name = p_name.ToUpper();
            this.v_type = p_type;

            this.v_value = "";
            this.v_null = true;

            this.v_description = "";
            this.v_lookup = "";
        }
        /// <summary>
        /// Inicializa uma nova instância da classe <see cref="Spartacus.Reporting.Report"/>.
        /// </summary>
        /// <param name="p_reportid">Código do Relatório.</param>
        /// <param name="p_filename">Nome do arquivo XML.</param>
        /// <param name="p_database">Objeto para conexão com o banco de dados.</param>
        /// <param name="p_calculate_groups">Se o gerador de relatórios deve calcular os valores agrupados ou não.</param>
        public Report(int p_reportid, string p_filename, Spartacus.Database.Generic p_database, bool p_calculate_groups)
        {
            this.v_reportid = p_reportid;

            this.v_header = new Spartacus.Reporting.Block();
            this.v_footer = new Spartacus.Reporting.Block();

            this.v_fields = new System.Collections.ArrayList();
            this.v_groups = new System.Collections.ArrayList();

            this.v_database = p_database;
            this.v_tabletemp = null;
            this.v_table = null;
            this.v_rendertable = null;

            this.v_calculate_groups = p_calculate_groups;

            this.v_progress = new Spartacus.Utils.ProgressEventClass();
            this.v_progress.FireEvent("Spartacus.Reporting.Report", "ExportPDF", 0.0, "Lendo XML do relatorio " + this.v_reportid.ToString());

            try
            {
                this.ReadXml(p_filename);
            }
            catch (Spartacus.Reporting.Exception e)
            {
                throw e;
            }
        }
Пример #10
0
 /// <summary>
 /// Transfere dados de um arquivo Excel para o banco de dados atual.
 /// Conexão com o banco atual precisa estar aberta.
 /// Não pára a execução se der um problema num comando de inserção específico.
 /// </summary>
 /// <returns>Número de linhas transferidas.</returns>
 /// <param name="p_filename">Nome do arquivo de origem.</param>
 /// <param name="p_newtable">Nome da nova tabela a ser criada no banco de dados.</param>
 /// <param name="p_progress">Evento de progresso.</param>
 /// <param name="p_error">Evento de erro.</param>
 public abstract uint TransferFromFile(string p_filename, string p_newtable, Spartacus.Utils.ProgressEventClass p_progress, Spartacus.Utils.ErrorEventClass p_error);
Пример #11
0
 /// <summary>
 /// Transfere dados de um arquivo Excel para o banco de dados atual.
 /// Conexão com o banco atual precisa estar aberta.
 /// Não pára a execução se der um problema num comando de inserção específico.
 /// </summary>
 /// <returns>Número de linhas transferidas.</returns>
 /// <param name="p_filename">Nome do arquivo de origem.</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>
 /// <param name="p_newtable">Nome da nova tabela a ser criada no banco de dados.</param>
 /// <param name="p_progress">Evento de progresso.</param>
 /// <param name="p_error">Evento de erro.</param>
 public abstract uint TransferFromFile(string p_filename, char p_separator, char p_delimitator, bool p_header, System.Text.Encoding p_encoding, string p_newtable, Spartacus.Utils.ProgressEventClass p_progress, Spartacus.Utils.ErrorEventClass p_error);
Пример #12
0
 /// <summary>
 /// Transfere dados de um arquivo Excel para o banco de dados atual.
 /// Conexão com o banco atual precisa estar aberta.
 /// Não pára a execução se der um problema num comando de inserção específico.
 /// </summary>
 /// <returns>Número de linhas transferidas.</returns>
 /// <param name="p_filename">Nome do arquivo de origem.</param>
 /// <param name="p_insert">Comando de inserção para inserir cada linha no banco de dados atual.</param>
 /// <param name="p_progress">Evento de progresso.</param>
 /// <param name="p_error">Evento de erro.</param>
 public abstract uint TransferFromFile(string p_filename, Spartacus.Database.Command p_insert, Spartacus.Utils.ProgressEventClass p_progress, Spartacus.Utils.ErrorEventClass p_error);
Пример #13
0
 /// <summary>
 /// Transfere dados de um arquivo Excel para o banco de dados atual.
 /// Conexão com o banco atual precisa estar aberta.
 /// Não pára a execução se der um problema num comando de inserção específico.
 /// </summary>
 /// <returns>Número de linhas transferidas.</returns>
 /// <param name="p_filename">Nome do arquivo de origem.</param>
 /// <param name="p_separator">Separador 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>
 /// <param name="p_insert">Comando de inserção para inserir cada linha no banco de dados atual.</param>
 /// <param name="p_progress">Evento de progresso.</param>
 /// <param name="p_error">Evento de erro.</param>
 public abstract uint TransferFromFile(string p_filename, char p_separator, bool p_header, System.Text.Encoding p_encoding, Spartacus.Database.Command p_insert, Spartacus.Utils.ProgressEventClass p_progress, Spartacus.Utils.ErrorEventClass p_error);
Пример #14
0
        /// <summary>
        /// Inicializa uma nova instância da classe <see cref="Spartacus.Utils.File"/>.
        /// </summary>
        /// <param name='p_type'>
        /// Indica se é um arquivo ou um diretório.
        /// </param>
        /// <param name='p_completename'>
        /// Nome completo, absoluto ou relativo, do arquivo ou diretório atual.
        /// </param>
        /// <param name='p_encryptedname'>
        /// Se o nome do arquivo está criptografado ou não.
        /// </param>
        /// <param name='p_separator'>
        /// Separador de diretórios do caminho completo do arquivo.
        /// </param>
        public File(Spartacus.Utils.FileType p_type, string p_completename, bool p_encryptedname, Spartacus.Utils.PathSeparator p_separator)
        {
            Spartacus.Utils.Cryptor v_cryptor;
            string v_completename;

            if (p_encryptedname)
            {
                try
                {
                    v_cryptor = new Spartacus.Utils.Cryptor("spartacus");
                    v_completename = v_cryptor.Decrypt(p_completename);
                }
                catch (System.Exception)
                {
                    v_completename = p_completename;
                }
            }
            else
                v_completename = p_completename;

            this.v_filetype = p_type;
            this.v_pathseparator = p_separator;
            this.v_name = this.GetBaseName(v_completename);
            this.v_extension = this.GetExtension(v_completename);
            this.v_path = this.GetPath(v_completename);
            this.v_size = -1;
            this.v_encoding = System.Text.Encoding.GetEncoding("utf-8");
            this.v_protected = false;
            this.v_hidden = this.GetHidden();
        }
Пример #15
0
        /// <summary>
        /// Transfere dados de um arquivo Excel para o banco de dados atual.
        /// Conexão com o banco atual precisa estar aberta.
        /// Não pára a execução se der um problema num comando de inserção específico.
        /// </summary>
        /// <returns>Número de linhas transferidas.</returns>
        /// <param name="p_filename">Nome do arquivo de origem.</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>
        /// <param name="p_newtable">Nome da nova tabela a ser criada no banco de dados.</param>
        /// <param name="p_progress">Evento de progresso.</param>
        /// <param name="p_error">Evento de erro.</param>
        public override uint TransferFromFile(string p_filename, char p_separator, char p_delimitator, bool p_header, System.Text.Encoding p_encoding, string p_newtable, Spartacus.Utils.ProgressEventClass p_progress, Spartacus.Utils.ErrorEventClass p_error)
        {
            Spartacus.Database.Command v_cmd;
            Spartacus.Utils.Excel v_excel = null;
            uint v_transfered = 0;
            string v_createtable;
            string v_insert;

            try
            {
                v_excel = new Spartacus.Utils.Excel();
                v_excel.Import(p_filename, p_separator, p_delimitator, p_header, p_encoding);

                v_createtable = "create table " + p_newtable + " (";
                for (int k = 0; k < v_excel.v_set.Tables[0].Columns.Count; k++)
                {
                    if (k < v_excel.v_set.Tables[0].Columns.Count-1)
                        v_createtable += v_excel.v_set.Tables[0].Columns[k].ColumnName.ToLower() + " varchar(4000),";
                    else
                        v_createtable += v_excel.v_set.Tables[0].Columns[k].ColumnName.ToLower() + " varchar(4000))";
                }
                try
                {
                    this.Execute(v_createtable);
                }
                catch (Spartacus.Database.Exception e)
                {
                    p_error.FireEvent(v_createtable + "\n" + e.v_message);
                }

                v_cmd = new Spartacus.Database.Command();
                v_cmd.v_text = "insert into " + p_newtable + " values (";
                for (int k = 0; k < v_excel.v_set.Tables[0].Columns.Count; k++)
                {
                    if (k < v_excel.v_set.Tables[0].Columns.Count-1)
                        v_cmd.v_text += "#" + v_excel.v_set.Tables[0].Columns[k].ColumnName.ToLower() + "#,";
                    else
                        v_cmd.v_text += "#" + v_excel.v_set.Tables[0].Columns[k].ColumnName.ToLower() + "#)";
                    v_cmd.AddParameter(v_excel.v_set.Tables[0].Columns[k].ColumnName.ToLower(), Spartacus.Database.Type.QUOTEDSTRING);
                }

                foreach (System.Data.DataRow r in v_excel.v_set.Tables[0].Rows)
                {
                    foreach (System.Data.DataColumn c in v_excel.v_set.Tables[0].Columns)
                        v_cmd.SetValue(c.ColumnName, r[c].ToString());

                    v_insert = v_cmd.GetUpdatedText();
                    try
                    {
                        this.Execute(v_insert);
                        v_transfered++;
                        p_progress.FireEvent(v_transfered);
                    }
                    catch (Spartacus.Database.Exception e)
                    {
                        p_error.FireEvent(v_insert + "\n" + e.v_message);
                    }
                }

                return v_transfered;
            }
            catch (Spartacus.Utils.Exception e)
            {
                throw new Spartacus.Database.Exception(e);
            }
            catch (Spartacus.Database.Exception e)
            {
                throw e;
            }
            finally
            {
                if (v_excel != null)
                {
                    v_excel.Clear();
                    v_excel = null;
                }
            }
        }
        /// <summary>
        /// Lê campos de um cabeçalho de grupo.
        /// </summary>
        /// <param name="p_reader">Objeto XML.</param>
        /// <param name="p_group">Grupo do relatório.</param>
        private void ReadGroupHeaderFields(System.Xml.XmlReader p_reader, Spartacus.Reporting.Group p_group)
        {
            System.Xml.XmlReader v_item;

            while (p_reader.Read())
            {
                if (p_reader.IsStartElement() && p_reader.Name == "headerfield")
                {
                    v_item = p_reader.ReadSubtree();
                    this.ReadGroupHeaderField(v_item, p_group);
                    v_item.Close();
                }
            }
        }
Пример #17
0
 /// <summary>
 /// Inicializa uma nova instância da classe <see cref="Spartacus.Utils.File"/>.
 /// </summary>
 /// <param name='p_type'>
 /// Indica se é um arquivo ou um diretório.
 /// </param>
 /// <param name='p_completename'>
 /// Nome completo, absoluto ou relativo, do arquivo ou diretório atual.
 /// </param>
 /// <param name='p_encoding'>
 /// Codificação do arquivo.
 /// </param>
 public File(Spartacus.Utils.FileType p_type, string p_completename, System.Text.Encoding p_encoding)
 {
     this.v_filetype = p_type;
     this.v_pathseparator = Spartacus.Utils.PathSeparator.SLASH;
     this.v_name = this.GetBaseName(p_completename);
     this.v_extension = this.GetExtension(p_completename);
     this.v_path = this.GetPath(p_completename);
     this.v_size = -1;
     this.v_encoding = p_encoding;
     this.v_protected = false;
     this.v_hidden = this.GetHidden();
 }
 /// <summary>
 /// Lê fonte.
 /// </summary>
 /// <param name="p_font">Objeto fonte, onde vai guardar as informações.</param>
 /// <param name="p_reader">Objeto XML.</param>
 private void ReadFont(Spartacus.Reporting.Font p_font, System.Xml.XmlReader p_reader)
 {
     while (p_reader.Read())
     {
         if (p_reader.IsStartElement())
         {
             switch (p_reader.Name)
             {
                 case "family":
                     p_font.SetFamily(p_reader.ReadString());
                     break;
                 case "size":
                     p_font.SetSize(p_reader.ReadString());
                     break;
                 case "bold":
                     if (p_reader.ReadString() == "TRUE")
                         p_font.v_bold = true;
                     else
                         p_font.v_bold = false;
                     break;
                 case "italic":
                     if (p_reader.ReadString() == "TRUE")
                         p_font.v_italic = true;
                     else
                         p_font.v_italic = false;
                     break;
                 default:
                     break;
             }
         }
     }
 }
 /// <summary>
 /// Adiciona um relatório associado a um nome de arquivo PDF de saída.
 /// </summary>
 /// <param name="p_report">Relatório.</param>
 /// <param name="p_filename">Nome do arquivo PDF de saída.</param>
 public void Add(Spartacus.Reporting.Report p_report, string p_filename)
 {
     this.v_reports.Add(p_report);
     this.v_filenames.Add(p_filename);
 }
 /// <summary>
 /// Adiciona um relatório.
 /// </summary>
 /// <param name="p_report">Relatório.</param>
 public void Add(Spartacus.Reporting.Report p_report)
 {
     this.v_reports.Add(p_report);
 }
Пример #21
0
        /// <summary>
        /// Transfere dados do banco de dados atual para um banco de dados de destino.
        /// Conexão com o banco de destino precisa estar aberta.
        /// </summary>
        /// <returns>Número de linhas transferidas.</returns>
        /// <param name="p_query">Consulta SQL para buscar os dados no banco atual.</param>
        /// <param name="p_insert">Comando de inserção para inserir cada linha no banco de destino.</param>
        /// <param name="p_destdatabase">Conexão com o banco de destino.</param>
        public override uint Transfer(string p_query, Spartacus.Database.Command p_insert, Spartacus.Database.Generic p_destdatabase)
        {
            uint v_transfered = 0;

            if (this.v_con == null)
            {
                try
                {
                    this.v_con = new MySql.Data.MySqlClient.MySqlConnection(this.v_connectionstring);
                    this.v_con.Open();
                    this.v_cmd = new MySql.Data.MySqlClient.MySqlCommand(p_query, this.v_con);
                    this.v_reader = this.v_cmd.ExecuteReader();

                    while (v_reader.Read())
                    {
                        for (int i = 0; i < v_reader.FieldCount; i++)
                            p_insert.SetValue(this.FixColumnName(v_reader.GetName(i)).ToLower(), v_reader[i].ToString());

                        p_destdatabase.Execute(p_insert.GetUpdatedText());
                        v_transfered++;
                    }

                    return v_transfered;
                }
                catch (MySql.Data.MySqlClient.MySqlException e)
                {
                    throw new Spartacus.Database.Exception(e);
                }
                finally
                {
                    if (this.v_reader != null)
                    {
                        this.v_reader.Close();
                        this.v_reader = null;
                    }
                    if (this.v_cmd != null)
                    {
                        this.v_cmd.Dispose();
                        this.v_cmd = null;
                    }
                    if (this.v_con != null)
                    {
                        this.v_con.Close();
                        this.v_con = null;
                    }
                }
            }
            else
            {
                try
                {
                    this.v_cmd.CommandText = p_query;
                    this.v_reader = this.v_cmd.ExecuteReader();

                    while (v_reader.Read())
                    {
                        for (int i = 0; i < v_reader.FieldCount; i++)
                            p_insert.SetValue(this.FixColumnName(v_reader.GetName(i)).ToLower(), v_reader[i].ToString());

                        p_destdatabase.Execute(p_insert.GetUpdatedText());
                        v_transfered++;
                    }

                    return v_transfered;
                }
                catch (MySql.Data.MySqlClient.MySqlException e)
                {
                    throw new Spartacus.Database.Exception(e);
                }
                finally
                {
                    if (this.v_reader != null)
                    {
                        this.v_reader.Close();
                        this.v_reader = null;
                    }
                }
            }
        }
Пример #22
0
        /// <summary>
        /// Realiza uma consulta no banco de dados, armazenando os dados de retorno em um <see cref="System.Data.DataTable"/>.
        /// </summary>
        /// <param name='p_sql'>
        /// Código SQL a ser consultado no banco de dados.
        /// </param>
        /// <param name='p_tablename'>
        /// Nome virtual da tabela onde deve ser armazenado o resultado, para fins de cache.
        /// </param>
        /// <param name='p_progress'>Evento de progresso da execução da consulta.</param>
        /// <returns>Retorna uma <see cref="System.Data.DataTable"/> com os dados de retorno da consulta.</returns>
        public override System.Data.DataTable Query(string p_sql, string p_tablename, Spartacus.Utils.ProgressEventClass p_progress)
        {
            System.Data.DataTable v_table = null;
            System.Data.DataRow v_row;
            uint v_counter = 0;

            p_progress.FireEvent(v_counter);

            if (this.v_con == null)
            {
                try
                {
                    this.v_con = new MySql.Data.MySqlClient.MySqlConnection(this.v_connectionstring);
                    this.v_con.Open();
                    this.v_cmd = new MySql.Data.MySqlClient.MySqlCommand(p_sql, this.v_con);
                    this.v_reader = this.v_cmd.ExecuteReader();

                    v_table = new System.Data.DataTable(p_tablename);
                    for (int i = 0; i < v_reader.FieldCount; i++)
                        v_table.Columns.Add(this.FixColumnName(this.v_reader.GetName(i)), typeof(string));

                    while (this.v_reader.Read())
                    {
                        v_row = v_table.NewRow();
                        for (int i = 0; i < this.v_reader.FieldCount; i++)
                            v_row[i] = this.v_reader[i].ToString();
                        v_table.Rows.Add(v_row);

                        v_counter++;
                        p_progress.FireEvent(v_counter);
                    }

                    return v_table;
                }
                catch (MySql.Data.MySqlClient.MySqlException e)
                {
                    throw new Spartacus.Database.Exception(e);
                }
                finally
                {
                    if (this.v_reader != null)
                    {
                        this.v_reader.Close();
                        this.v_reader = null;
                    }
                    if (this.v_cmd != null)
                    {
                        this.v_cmd.Dispose();
                        this.v_cmd = null;
                    }
                    if (this.v_con != null)
                    {
                        this.v_con.Close();
                        this.v_con = null;
                    }
                }
            }
            else
            {
                try
                {
                    this.v_cmd.CommandText = p_sql;
                    this.v_reader = this.v_cmd.ExecuteReader();

                    v_table = new System.Data.DataTable(p_tablename);
                    for (int i = 0; i < v_reader.FieldCount; i++)
                        v_table.Columns.Add(this.FixColumnName(this.v_reader.GetName(i)), typeof(string));

                    while (this.v_reader.Read())
                    {
                        v_row = v_table.NewRow();
                        for (int i = 0; i < this.v_reader.FieldCount; i++)
                            v_row[i] = this.v_reader[i].ToString();
                        v_table.Rows.Add(v_row);

                        v_counter++;
                        p_progress.FireEvent(v_counter);
                    }

                    return v_table;
                }
                catch (MySql.Data.MySqlClient.MySqlException e)
                {
                    throw new Spartacus.Database.Exception(e);
                }
                finally
                {
                    if (this.v_reader != null)
                    {
                        this.v_reader.Close();
                        this.v_reader = null;
                    }
                }
            }
        }
        /// <summary>
        /// Lê um único campo de um cabeçalho de grupo.
        /// </summary>
        /// <param name="p_reader">Objeto XML.</param>
        /// <param name="p_group">Grupo do relatório.</param>
        private void ReadGroupHeaderField(System.Xml.XmlReader p_reader, Spartacus.Reporting.Group p_group)
        {
            Spartacus.Reporting.Field v_field;
            System.Xml.XmlReader v_item;

            v_field = new Spartacus.Reporting.Field();

            while (p_reader.Read())
            {
                if (p_reader.IsStartElement())
                {
                    switch (p_reader.Name)
                    {
                        case "title":
                            v_field.v_title = p_reader.ReadString();
                            break;
                        case "column":
                            v_field.v_column = p_reader.ReadString();
                            break;
                        case "align":
                            switch (p_reader.ReadString())
                            {
                                case "LEFT":
                                    v_field.v_align = Spartacus.Reporting.FieldAlignment.LEFT;
                                    break;
                                case "RIGHT":
                                    v_field.v_align = Spartacus.Reporting.FieldAlignment.RIGHT;
                                    break;
                                case "CENTER":
                                    v_field.v_align = Spartacus.Reporting.FieldAlignment.CENTER;
                                    break;
                                default:
                                    break;
                            }
                            break;
                        case "fill":
                            v_field.v_fill = double.Parse(p_reader.ReadString());
                            break;
                        case "type":
                            v_field.SetType(p_reader.ReadString());
                            break;
                        case "groupedvalue":
                            if (p_reader.ReadString() == "FALSE")
                                v_field.v_groupedvalue = false;
                            else
                                v_field.v_groupedvalue = true;
                            break;
                        case "row":
                            v_field.v_row = System.Convert.ToInt32(p_reader.ReadString());
                            break;
                        case "format":
                            v_field.v_format = p_reader.ReadString();
                            break;
                        case "border":
                            v_field.v_border = new Spartacus.Reporting.Border(p_reader.ReadString());
                            break;
                        case "blank":
                            v_field.v_blank = p_reader.ReadString();
                            break;
                        case "font":
                            v_field.v_font = new Spartacus.Reporting.Font();
                            v_item = p_reader.ReadSubtree();
                            this.ReadFont(v_field.v_font, v_item);
                            v_item.Close();
                            break;
                        default:
                            break;
                    }
                }
            }

            if ((v_field.v_row + 1) > p_group.v_numrowsheader)
                p_group.v_numrowsheader = v_field.v_row + 1;

            p_group.v_headerfields.Add(v_field);
        }
Пример #24
0
 /// <summary>
 /// Realiza uma consulta no banco de dados, armazenando os dados de retorno em um <see creg="System.Data.DataTable"/>.
 /// </summary>
 /// <param name='p_sql'>
 /// Código SQL a ser consultado no banco de dados.
 /// </param>
 /// <param name='p_tablename'>
 /// Nome virtual da tabela onde deve ser armazenado o resultado, para fins de cache.
 /// </param>
 /// <param name='p_progress'>
 /// Evento de progresso da execução da consulta.
 /// </param>
 public abstract System.Data.DataTable Query(string p_sql, string p_tablename, Spartacus.Utils.ProgressEventClass p_progress);
Пример #25
0
 /// <summary>
 /// Inicializa uma nova instância da classe <see cref="Spartacus.Utils.File"/>.
 /// </summary>
 /// <param name='p_id'>
 /// Identificador único do arquivo ou diretório (se aplicável).
 /// </param>
 /// <param name='p_parentid'>
 /// Identificador do diretório pai do arquivo ou diretório (se aplicável).
 /// </param>
 /// <param name='p_type'>
 /// Indica se é um arquivo ou um diretório.
 /// </param>
 /// <param name='p_completename'>
 /// Nome completo, absoluto ou relativo, do arquivo ou diretório atual.
 /// </param>
 /// <param name='p_lastwritedate'>
 /// Data da última modificação do arquivo ou diretório.
 /// </param>
 /// <param name='p_size'>
 /// Tamanho do arquivo.
 /// </param>
 public File(int p_id, int p_parentid, Spartacus.Utils.FileType p_type, string p_completename, System.DateTime p_lastwritedate, long p_size)
 {
     this.v_id = p_id;
     this.v_parentid = p_parentid;
     this.v_filetype = p_type;
     this.v_pathseparator = Spartacus.Utils.PathSeparator.SLASH;
     this.v_name = this.GetBaseName(p_completename);
     this.v_extension = this.GetExtension(p_completename);
     this.v_path = this.GetPath(p_completename);
     this.v_lastwritedate = p_lastwritedate;
     this.v_size = p_size;
     this.v_encoding = System.Text.Encoding.GetEncoding("utf-8");
     this.v_protected = false;
     this.v_hidden = this.GetHidden();
 }
Пример #26
0
 /// <summary>
 /// Transfere dados do banco de dados atual para um banco de dados de destino.
 /// Conexão com o banco de destino precisa estar aberta.
 /// Não pára a execução se der um problema num comando de inserção específico.
 /// </summary>
 /// <returns>Número de linhas transferidas.</returns>
 /// <param name="p_query">Consulta SQL para buscar os dados no banco atual.</param>
 /// <param name="p_insert">Comando de inserção para inserir cada linha no banco de destino.</param>
 /// <param name="p_destdatabase">Conexão com o banco de destino.</param>
 /// <param name="p_log">Log de inserção.</param>
 public abstract uint Transfer(string p_query, Spartacus.Database.Command p_insert, Spartacus.Database.Generic p_destdatabase, out string p_log);
Пример #27
0
 /// <summary>
 /// Inicializa uma nova instância da classe <see cref="Spartacus.Utils.File"/>.
 /// </summary>
 /// <param name='p_type'>
 /// Indica se é um arquivo ou um diretório.
 /// </param>
 /// <param name='p_completename'>
 /// Nome completo, absoluto ou relativo, do arquivo ou diretório atual.
 /// </param>
 /// <param name='p_separator'>
 /// Separador de diretórios do caminho completo do arquivo.
 /// </param>
 /// <param name='p_lastwritedate'>
 /// Data da última modificação do arquivo ou diretório.
 /// </param>
 /// <param name='p_size'>
 /// Tamanho do arquivo.
 /// </param>
 /// <param name='p_encoding'>
 /// Codificação do arquivo.
 /// </param>
 public File(Spartacus.Utils.FileType p_type, string p_completename, Spartacus.Utils.PathSeparator p_separator, System.DateTime p_lastwritedate, long p_size, System.Text.Encoding p_encoding)
 {
     this.v_filetype = p_type;
     this.v_pathseparator = p_separator;
     this.v_name = this.GetBaseName(p_completename);
     this.v_extension = this.GetExtension(p_completename);
     this.v_path = this.GetPath(p_completename);
     this.v_lastwritedate = p_lastwritedate;
     this.v_size = p_size;
     this.v_encoding = p_encoding;
     this.v_protected = false;
     this.v_hidden = this.GetHidden();
 }
Пример #28
0
 /// <summary>
 /// Transfere dados do banco de dados atual para um banco de dados de destino.
 /// Conexão com o banco de destino precisa estar aberta.
 /// Não pára a execução se der um problema num comando de inserção específico.
 /// </summary>
 /// <returns>Número de linhas transferidas.</returns>
 /// <param name="p_query">Consulta SQL para buscar os dados no banco atual.</param>
 /// <param name="p_table">Nome da tabela de destino.</param>
 /// <param name="p_insert">Comando de inserção para inserir cada linha no banco de destino.</param>
 /// <param name="p_destdatabase">Conexão com o banco de destino.</param>
 /// <param name="p_log">Log de inserção.</param>
 /// <param name='p_startrow'>Número da linha inicial.</param>
 /// <param name='p_endrow'>Número da linha final.</param>
 /// <param name='p_hasmoredata'>Indica se ainda há mais dados a serem lidos.</param>
 public abstract uint Transfer(string p_query, string p_table, Spartacus.Database.Command p_insert, Spartacus.Database.Generic p_destdatabase, ref string p_log, uint p_startrow, uint p_endrow, out bool p_hasmoredata);
Пример #29
0
        /// <summary>
        /// Inicializa uma nova instância da classe <see cref="Spartacus.Utils.File"/>.
        /// </summary>
        /// <param name='p_type'>
        /// Indica se é um arquivo ou um diretório.
        /// </param>
        /// <param name='p_completename'>
        /// Nome completo, absoluto ou relativo, do arquivo ou diretório atual.
        /// </param>
        /// <param name='p_encryptedname'>
        /// Se o nome do arquivo está criptografado ou não.
        /// </param>
        /// <param name='p_lastwritedate'>
        /// Data da última modificação do arquivo ou diretório.
        /// </param>
        /// <param name='p_size'>
        /// Tamanho do arquivo.
        /// </param>
        /// <param name='p_encoding'>
        /// Codificação do arquivo.
        /// </param>
        public File(Spartacus.Utils.FileType p_type, string p_completename, bool p_encryptedname, System.DateTime p_lastwritedate, long p_size, System.Text.Encoding p_encoding)
        {
            Spartacus.Utils.Cryptor v_cryptor;
            string v_completename;

            if (p_encryptedname)
            {
                try
                {
                    v_cryptor = new Spartacus.Utils.Cryptor("spartacus");
                    v_completename = v_cryptor.Decrypt(p_completename);
                }
                catch (System.Exception)
                {
                    v_completename = p_completename;
                }
            }
            else
                v_completename = p_completename;

            this.v_filetype = p_type;
            this.v_pathseparator = Spartacus.Utils.PathSeparator.SLASH;
            this.v_name = this.GetBaseName(v_completename);
            this.v_extension = this.GetExtension(v_completename);
            this.v_path = this.GetPath(v_completename);
            this.v_lastwritedate = p_lastwritedate;
            this.v_size = p_size;
            this.v_encoding = p_encoding;
            this.v_protected = false;
            this.v_hidden = this.GetHidden();
        }
Пример #30
0
 /// <summary>
 /// Transfere dados do banco de dados atual para um banco de dados de destino.
 /// Conexão com o banco de destino precisa estar aberta.
 /// Não pára a execução se der um problema num comando de inserção específico.
 /// </summary>
 /// <returns>Número de linhas transferidas.</returns>
 /// <param name="p_query">Consulta SQL para buscar os dados no banco atual.</param>
 /// <param name="p_insert">Comando de inserção para inserir cada linha no banco de destino.</param>
 /// <param name="p_destdatabase">Conexão com o banco de destino.</param>
 /// <param name="p_progress">Evento de progresso.</param>
 /// <param name="p_error">Evento de erro.</param>
 public abstract uint Transfer(string p_query, Spartacus.Database.Command p_insert, Spartacus.Database.Generic p_destdatabase, Spartacus.Utils.ProgressEventClass p_progress, Spartacus.Utils.ErrorEventClass p_error);