/// <summary>
/// Visualiza um relatório.
/// <br>
/// O relatório sempre será escrito no disco.
/// </br>
/// O designer é montando manualmente.
/// </summary>
/// <param name="report"></param>
public static void PrintReportOverwrite(ReportImage report)
{
try
{
using (var ctx = new ReportContext())
{
var current = ctx.ReportImageDao.Find(report.IdReport);
string path = Path.Combine(Application.StartupPath, "Reports", current.ReportName + ".repx");
FileManagerIts.WriteBytesToFile(path, current.ReportImageData);
//carregue a estrutura do relatório
XtraReport xreport = XtraReport.FromFile(path, true);
//objeto para gerar a tela de parametros
ReportPrintTool reportPrintTool = new ReportPrintTool(xreport);
//chama a tela de parametros
xreport.CreateDocument();
//gera o relatorio
PrintPreviewFormEx preview = new PrintPreviewFormEx();
preview.PrintingSystem = xreport.PrintingSystem;
//exibe o relatorio
preview.ShowDialog();
}
}
catch (Exception ex)
{
XMessageIts.Erro("Falha gerar relatório\n\n" + ex.Message, "Atenção!!!");
LoggerUtilIts.GenerateLogs(ex);
}
}
private void btnSelecionarUpdateFile_Click(object sender, EventArgs e)
{
var op = openFilePkg.ShowDialog();
if (op == DialogResult.OK)
{
string pkgFile = openFilePkg.FileName;
txtUpdateFile.Text = pkgFile;
try
{
var bytesFile = FileManagerIts.GetBytesFromFile(openFilePkg.FileName);
this._pacote = SerializeIts.DeserializeObject <Package>(bytesFile);
loadPackage(this._pacote);
}
catch (Exception ex)
{
string msg = "O pacote de atualização informado é inválido!"
+ "\n\nContate o administrador para aplicar atualização.";
XMessageIts.ExceptionMessageDetails(ex, msg, "Atenção");
LoggerUtilIts.GenerateLogs(ex, msg);
}
}
}
public int CheckVendasLancamentos()
{
using (var ctx = new BalcaoContext())
{
ctx.LazyLoading(false);
try
{
string database = ctx.Database.Connection.Database;
//efetiva o status do venda no banco
string procedure1 = "[" + database + "].[dbo].[P_ATUALIZAR_VENDAS]";
//efetiva o status do lançamento no banco
string procedure2 = "[" + database + "].[dbo].[P_ATUALIZAR_LANCAMENTOS]";
//SqlParameter parametro = new SqlParameter("@Nome", ano);
//new SqlParameter[] { parametro }
ctx.ConnectionSql.ExecuteProcedure(procedure1);
ctx.ConnectionSql.ExecuteProcedure(procedure2);
//obtem e atualiza as cotações do sistema
new WSBacenCambio().GetCurrencyExchange();
return(new VendaFilterManager().FindVendasEmAberto());
}
catch (Exception ex)
{
LoggerUtilIts.GenerateLogs(ex);
throw ex;
}
}
}
/// <summary>
/// Retorna todos os dados da empresa relacionados ao CNPJ informado
/// </summary>
/// <param name="cnpj"></param>CNPJ
/// <returns></returns>LayoutReceitaWS
public static LayoutReceitaWS GetDataFromCNPJ(string cnpj)
{
try
{
cnpj = cnpj.FixString();
string json = JSONHelper.GetJSONString(receitaWsUrl + cnpj);
LayoutReceitaWS r = JsonConvert.DeserializeObject <LayoutReceitaWS>(json);
if (r.Status == "ERROR")
{
return(null);
}
return(r);
}
catch (Exception ex)
{
Console.WriteLine("WS not responding " + ex.Message);
LoggerUtilIts.ShowExceptionMessage(ex);
LoggerUtilIts.GenerateLogs(ex);
return(null);
}
} /// <summary>
public void UpdateParamFromCodigo(Parametro param)
{
try
{
using (var ctx = new BalcaoContext())
{
var current = ctx.ParametroDao.Where(p =>
p.CodigoParametro == param.CodigoParametro)
.First();
current.Update(param);
ctx.ParametroDao.Update(current);
}
}
catch (Exception ex)
{
LoggerUtilIts.GenerateLogs(ex);
if (!string.IsNullOrEmpty(param.DescricaoParametro))
{
XMessageIts.Erro("Não foi possível atualizar a preferência:\n" + param.DescricaoParametro);
}
else
{
XMessageIts.Erro("Não foi possível atualizar uma ou mais preferência");
}
}
}
/// <summary>
/// Escreve um array de bytes no arquivo selecionado
/// </summary>
/// <param name="pathFile"></param>Arquivo a ser escrito
/// <param name="_ByteArray"></param>bytes a ser escritos
/// <returns></returns>true se escrito com sucesso caso contrário false
public static bool WriteBytesToFile(string pathFile, byte[] _ByteArray)
{
//http://www.digitalcoding.com/Code-Snippets/C-Sharp/C-Code-Snippet-Save-byte-array-to-file.html
try
{
// Open file for reading
FileStream fs = new FileStream(pathFile, FileMode.Create, FileAccess.Write);
// Writes a block of bytes to this stream using data from a byte array.
fs.Write(_ByteArray, 0, _ByteArray.Length);
// close file stream
fs.Close();
return(true);
}
catch (Exception _Exception)
{
// Error
Console.WriteLine("Exception caught in process: {0}", _Exception.ToString());
LoggerUtilIts.GenerateLogs(_Exception);
// error occured, return false
return(false);
}
}
/// <summary>
/// Criar/Alterar relatorio carregado para o cache
/// </summary>
/// <param name="reportImageAnt"></param>
public RbbFrmReportEditorNew(ReportImage reportImageAnt)
: this()
{
this.reportImageAnt = reportImageAnt;
try
{
if (reportImageAnt.IdReport == 0)
{
reportDesigner1.CreateNewReport();
reportDesigner1.ActiveDesignPanel.Report.DisplayName = reportImageAnt.ReportDescription;
}
else
{
//abri o relatório selecionado
var path = new ReportDaoManager().LoadToCache(this.reportImageAnt);
reportDesigner1.OpenReport(path);
reportDesigner1.ActiveDesignPanel.Name = this.reportImageAnt.ReportName;
reportDesigner1.ActiveDesignPanel.Report.Name = this.reportImageAnt.ReportName;
}
this.sqlDataSource = new SqlDataSource(ReportUtil.GetParamDataSource());
reportDesigner1.ActiveDesignPanel.Report.DataSource = sqlDataSource;
}
catch (Exception ex)
{
LoggerUtilIts.GenerateLogs(ex);
}
}
/// <summary>
/// Abre a conexão com o banco
/// </summary>
/// <returns></returns>
public virtual bool OpenConnection()
{
Exception erro = null;
try
{
this.connection = new SqlConnection(connectionString);
//app.Catalog;
this.connection.Open();
}
catch (ConfigurationErrorsException ec)
{
erro = ec;
}
catch (SqlException es)
{
erro = es;
}
catch (InvalidOperationException ex)
{
erro = ex;
}
if (erro != null)
{
LoggerUtilIts.GenerateLogs(erro, "Falha ao criar uma conexão!");
return(false);
}
return(true);
}
private void wizardPage1_PageCommit(object sender, EventArgs e)
{
XFrmWait.ShowSplashScreen("Gerando lançamentos");
this.completionWizardPage1.AllowFinish = false;
var manager = new LancamentoDaoManager();
this._lancamentoList.ForEach(delegate(LancamentoFinanceiro lan)
{
try
{
if (_action == FormTypeAction.Salvar)
{
manager.SaveLancamento(lan);
}
else
{
manager.Reparcelar(_lancamentoAtual, lan);
}
}
catch (Exception ex)
{
XMessageIts.Erro("Falha no parcelamento !\nVerifique a pasta de logs ou contate o administrador", "Operação cancelada");
LoggerUtilIts.GenerateLogs(ex);
this.Dispose();
return;
}
});
this.completionWizardPage1.AllowFinish = true;
XFrmWait.CloseSplashScreen();
}
/// <summary>
/// Aguarde o fim da tarefa e invoca o menu se o contexto foi iniciado e o usuário logado corretamente
/// </summary>
private void waitRun()
{
try
{
_taskLogin.Wait();
}
catch (Exception ex)
{
string msg = "Ocorreu um erro não identificado !";
LoggerUtilIts.GenerateLogs(ex, msg);
XMessageIts.ExceptionJustMessage(ex, msg, "Falha no sistema !");
throw ex;
}//se nao conseguiu logar deu ruim
if (this._xFrmLogin.IsLogin == false)
{
//faz tudo denovo mas dessa vez fica amarrado
//ou seja nao vai fechar o form ate logar corretamente
this._xFrmLogin.ShowDialog();
}
Console.WriteLine("Task Done");
if (this._xFrmMatrizFilial == null || this._xFrmMatrizFilial.IsFilial == false || this._xFrmMatrizFilial.IsCancel)
{
Application.Exit();
}
else
{
Usuario user = _taskLogin.Result;
//se algum deles existe
if (user != null || UnitWork.Usuario != null)
{
//se o primeiro usuario falhou
if (user == null)
{
//entao esse aqui ta ok
user = UnitWork.Usuario;
}
//garante o fim da Task
_taskLogin.Dispose();
//invoka a thread que amarra o menu principal
var licManager = new LicenseDaoManager();
var lic = licManager.GetValidLicense();
if (lic != null)
{
var menu = new XFrmMenu(user, _application);
verifyMenu(menu, lic.LicenseDataUnSerialized.ActiveMenus);
Application.Run(menu);
}
else
{
Application.Exit();
}
}
}
}
public bool isCancelarVenda(Venda venda)
{
if (venda.StatusVenda == TypeStatusVenda.Cancelada)
{
XMessageIts.Advertencia("A venda \"" + venda.IdVenda + "\" já está cancelada",
"Atenção");
return(false);
}
else if (venda.StatusVenda != TypeStatusVenda.Paga || venda.StatusVenda == TypeStatusVenda.Parcial)
{
using (var ctx = new BalcaoContext())
{
try
{
var v = ctx.VendaDao.Find(venda.IdVenda);
var parcelas = v.Parcelas.ToList();
var parcela = parcelas.First();
//se a primeira parcela foi paga
if (parcela.DataPagamento != null)
{
//faz quantos dias q foi pago
var dias = DataUtil.CalcularDias(parcela.DataPagamento.Value, DateTime.Now);
//prazo maximo para cancelamento
if (dias > 19)
{
XMessageIts.Advertencia("O prazo para cancelamento é no máximo 15 dias utéis !",
"Atenção limite de tempo para cancelamento estogato!");
return(false);
}
}
//se
//se todas as parcela foram pagas
if (parcelas.Count(p => p.DataPagamento != null) == parcelas.Count)
{
XMessageIts.Erro("A venda \"" + venda.IdVenda + "\" foi totalmente paga e não pode cancelada !",
"Atenção");
return(false);
}
}
catch (Exception ex)
{
LoggerUtilIts.GenerateLogs(ex, "Falha na checagem de cancelamento de vendas");
return(true);
}
}
}
else
{
XMessageIts.Advertencia("Status da venda \"" + venda.IdVenda + "\" não permite cancelamento !");
return(false);
}
return(true);
}
public Usuario IsLogin(string logon, string senha)
{
Usuario user = null;
try
{
//codifica a senha pois ela foi criptografa no banco
//entao nao sabemos qual é a verdadeira senha
var result = ASCIIEncodingIts.Coded(senha);
using (var ctx = new BalcaoContext())
{
if (logon.IsContainsLetters())
{
//busca o User com a senha codificada
user = ctx.UsuarioDao
.Where(u => u.NomeUtilizador == logon && u.Senha == result).First();
}
else
{
//tente pelo ID
var id = ParseUtil.ToInt(logon);
user = ctx.UsuarioDao
.Where(u => u.IdUsuario == id && u.Senha == result).First();
}
//pega ele
return(user);
}
}
// Exceptions:
// T:System.ArgumentNullException:
// source is null.
//
// T:System.InvalidOperationException:
// The source sequence is empty.
catch (ArgumentNullException ex)
{
LoggerUtilIts.GenerateLogs(ex);
}
catch (InvalidOperationException ex)
{
LoggerUtilIts.GenerateLogs(ex);
}
catch (System.Reflection.TargetInvocationException ex)
{
LoggerUtilIts.GenerateLogs(ex);
XMessageIts.ExceptionMessage(ex);
}
catch (Exception ex)
{
LoggerUtilIts.GenerateLogs(ex);
XMessageIts.ExceptionMessage(ex);
}
return(user);
}
/// <summary>
/// Digitaliza uma imagem na impressora padrão
/// </summary>
/// <returns></returns>
public static string Scanning()
{
try
{
//get list of devices available
List <string> devices = WIAScanner.GetDevices();
List <string> devicesNames = new List <string>();
foreach (string device in devices)
{
devicesNames.Add(device);
}
//check if device is not available
if (devicesNames.Count == 0)
{
XMessageIts.Advertencia("Nenhum dispositivo(s) impressora(s) ativo foi encontrado.", "Aviso");
return(null);
}
var deviceName = devicesNames[0];
//get images from scanner
List <Image> images = WIAScanner.Scan(deviceName);
//nome aleatorio
string pathDigitalizacao = getPathDigitalizacao();
string pathTemp = getPathTemp(pathDigitalizacao);
foreach (Image image in images)
{
//save scanned image into specific folder
//salva toda imagem digitalizada no disco ridigo
image.Save(pathDigitalizacao, ImageFormat.Jpeg);
//salva o temporario
image.Save(pathTemp, ImageFormat.Jpeg);
return(pathTemp);
}
}
catch (NullReferenceException ex)
{
//foi cancelado durante a digitalização
Console.WriteLine("Digitalização cancelada: " + ex.Message);
}
catch (System.Runtime.InteropServices.COMException ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha na comunicação com a impressora\n\n" +
"Certifique que possui uma impressora padrão local e ativa", "Atenção");
LoggerUtilIts.GenerateLogs(ex);
}
catch (Exception exc)
{
XMessageIts.ExceptionMessageDetails(exc, "Falha na digitalização", "Falha crítica - Erro não identificado");
LoggerUtilIts.GenerateLogs(exc);
}
return(null);
}
/// <summary>
/// Obtem a cotação das principais moedas referidas no sistema.
/// </summary>
/// <returns></returns>
public CurrencyExchange GetCurrencyExchange()
{
CurrencyExchange cotacao = new CurrencyExchange();
using (var ctx = new CambioContext())
{
DateTime data = DateTime.Now.ToDateZerada();
if (data.DayOfWeek == DayOfWeek.Saturday)
{
data = data.AddDays(-1);
}
else if (data.DayOfWeek == DayOfWeek.Sunday)
{
data = data.AddDays(-2);
}
//localize as cotações do dia
var cotExist = ctx.CotacaoMonetariaDao
.Where(c => c.DataCotacao.ToDateZerada() == data)
.ToList();
if (cotExist.Count >= 9)
{
//localizei primeiro a cotação no banco
//isso aqui eh mais rapido q obter da internet
cotacao.Cotacoes.AddRange(cotExist);
}
else
{
var moedas = ctx.MoedaDao.FindAll();
foreach (var m in moedas)
{
try
{
//obtem do webservice mesmo
//persiste a cotação
CotacaoMonetaria cotNew = getCotacao((TypeCodigoBacen)m.CodigoWSCompra,
(TypeCodigoBacen)m.CodigoWSVenda);
//sempre add
cotacao.AddCurrencyExchange(cotNew);
SaveCotacaoMonetaria(ctx, cotNew);
}
catch (Exception ex)
{
LoggerUtilIts.GenerateLogs(ex, "Falha no WSBacenCambio", "Falha na cotação cambial.");
}
}
}
}
return(cotacao);
}
/// <summary>
/// Obtém a lista de todos os elementos da tabela.
///
/// EntityFramework cannot convert DateTime.Date to SQL.
/// So, it fails to generate expected SQL.
/// Instead of that you can use DbFunctions.TruncateTime() method if you want to get Date part only:
/// DbFunctions.TruncateTime(prop)
/// </summary>
/// <returns>A Queryable com todos os dados do objeto do banco de dados</returns>
public DbSet <T> Controller()
{
try
{
return(DbSet);
}
catch (Exception ex)
{
LoggerUtilIts.GenerateLogs(ex, "Falha ao retorna o controlador do dao.");
}
return(null);
}
/// <summary>
/// Salva o relatorio que está aberto no banco
/// </summary>
/// <param name="reportDesigner"></param>
/// <param name="report"></param>
public ReportImage SaveReport(XRDesignMdiController reportDesigner, ReportImage report)
{
try
{
using (var ctx = new ReportContext())
{
//objeto designer do relatório
var xtraReport = reportDesigner.ActiveDesignPanel.Report;
//nome setado no relatório
//report.DefaultName = xtraReport.Name;
//gera um nome aleatorio utilizando o nome setado no dashboard
string reportPath = generatePath(report, ctx);
using (MemoryStream ms = new MemoryStream())
{
//salva o relatorio
reportDesigner.ActiveDesignPanel.SaveReport(reportPath);
//salva o layout em memoria
xtraReport.SaveLayout(ms);
xtraReport.SaveLayoutToXml(reportPath + ".xml");
//salva o relatorio no disco em formato repx
xtraReport.SaveLayout(reportPath);
//obtem os bytes do relatorio
var bytes = ms.GetBuffer();
//gerar os bytes do arquivo
report.ReportImageData = bytes;
if (ctx.ReportImageDao.Save(report))
{
return(report);
}
}
}
}
catch (Exception ex)
{
XMessageIts.Advertencia("Houve um erro ao salvar relatório.\n\n"
+ ex.Message);
LoggerUtilIts.GenerateLogs(ex);
}
return(null);
}
private void setCurrentUser(Usuario user)
{
this._currentUser = user;
if (user == null)
{
MessageBoxBlack.Advertencia("Usuário operador não informado ao menu prinicpal", "Atenção");
LoggerUtilIts.GenerateLogs(new Exception("User not found for XFrmMenu"));
Application.Exit();
}
if (UnitWork.Filial == null)
{
navBarUnitWork_LinkClicked(null, null);
}
UnitWork.Usuario = user;
//Define o skin do menu utilizado pelo usuário
string skin = user.Skin;
//se existe um
if (!string.IsNullOrEmpty(skin))
{
SkinHelper.InitSkinGallery(skinRibbonGalleryBarItem1);
defaultLookAndFeel1.LookAndFeel.SkinName = skin;
}
//DevExpress.LookAndFeel.UserLookAndFeel.Default.SkinName = skin;
//DevExpress.LookAndFeel.UserLookAndFeel.Default.SkinName = "Visual Studio 2013 Blue";
//DevExpress.LookAndFeel.UserLookAndFeel.Default.SkinName = "Office 2013 Light Gray";
//Eh mais elegante e legivel o nome da pessoa do que o nickname
this.lbUserLogado.Caption = user.NomeUsuario;
this.dtAtual.Caption = DateTime.Now.Date.ToShortDateString();
//somente eu poss usar essa funcionalidade
if (user.NomeUtilizador == "filipe" /*
|| user.NomeUtilizador == "admin"
|| user.NomeUtilizador == "gercy" && user.IsAdmin*/)
{
this.ribbonPageGroupInformatica.Visible = true;
this.ribbonPageGroupSystem.Visible = true;
this.ribbonPageGroupUtil.Visible = true;
this.barBtnRestauracao.Visibility = BarItemVisibility.Always;
}
}
/// <summary>
/// Salva ou atualiza cotação
/// </summary>
/// <param name="ctx"></param> Contexto
/// <param name="cot"></param>Cotação a ser salva
private void SaveCotacaoMonetaria(CambioContext ctx, CotacaoMonetaria cotacao)
{
//use o codigo de compra mesmo
long codigo = cotacao.Moeda.CodigoWSCompra;
try
{
//recupera a moeda pelo codigo de compra/venda
Moeda moeda = cotacao.Moeda;
if (moeda == null || moeda.IdMoeda == 0)
{
moeda = ctx.MoedaDao.First(m =>
m.CodigoWSCompra == codigo ||
m.CodigoWSVenda == codigo);
}
try
{
//recupera a cotação
var current = ctx.CotacaoMonetariaDao
.First(c => c.DataCotacao.Date == cotacao.DataCotacao &&
c.IdMoeda == moeda.IdMoeda);
//e atualiza ela
current.ValorCompra = cotacao.ValorCompra;
current.ValorVenda = cotacao.ValorVenda;
current.DataCotacao = cotacao.DataCotacao;
//atualiza no banco
ctx.CotacaoMonetariaDao.Update(current);
}
catch (Exception ex)
{
//nao tem cotação add
Console.WriteLine("Criando um nova cotação: =>" + ex.Message);
//FK
cotacao.IdMoeda = moeda.IdMoeda;
//salva no banco
ctx.CotacaoMonetariaDao.Save(cotacao);
}
}
catch (Exception ex)
{
string msg = "Moeda não foi localizada";
string title = "Problema na rotina de atualização cambial";
XMessageIts.Advertencia(msg, title);
LoggerUtilIts.GenerateLogs(ex, msg + "\n" + title);
}
}
internal void SetParams(XtraReport report)
{
try
{
ParameterCollection newParams = new ParameterCollection();
foreach (Parameter p in report.Parameters)
{
Parameter param = new Parameter();
param.Name = p.Name;
// Specify other parameter properties.
param.Type = p.Type;
//description
param.Description = p.Description;
//nao consegui usar manipulavel aqui entao vai ficar assim
//deixe os paramentros visiveis
param.Visible = true;
if (param.Name.Equals("pDataInicial"))
{
param.Value = this.DataInicio.Date;
}
else if (param.Name.Equals("pDataFinal"))
{
param.Value = this.DataFim.Date;
}
else if (param.Name.Equals("pConta"))
{
param.Value = this.CodConta;
}
newParams.Add(param);
}
report.RequestParameters = false;
report.Parameters.Clear();
//add os novos parametros
foreach (var p in newParams)
{
report.Parameters.Add(p);
p.Visible = false;
}
}
catch (Exception ex)
{
XMessageIts.Mensagem("Um ou mais parâmentros do relátorio não foram setados.");
LoggerUtilIts.GenerateLogs(ex);
}
}
/// <summary>
/// Cria um XtraReport a partir do nome do relatório salvo no banco.
/// </summary>
/// <param name="reportName"></param>
/// <param name="showParams"></param>
/// <returns></returns>
public static XtraReport CreateReportByName(string reportName, bool showParams = true)
{
using (var ctx = new ReportContext())
{
try
{
var current = ctx.ReportImageDao.First(r => r.ReportName == reportName);
string dir = Path.GetTempPath().Replace("Temp", "Reports");
FileManagerIts.CreateDirectory(dir);
string path = Path.Combine(dir, current.ReportName + ".repx");
//salva o report no disco
FileManagerIts.WriteBytesToFile(path, current.ReportImageData);
//carregue a estrutura do relatório
XtraReport report = XtraReport.FromFile(path, true);
if (showParams == false)
{
//nao exibe
foreach (var p in report.Parameters)
{
p.Visible = false;
}
}
//objeto para chamar a tela de parametros
ReportPrintTool reportPrintTool = new ReportPrintTool(report);
ReportUtil.SetParamDataSource(report.DataSource as SqlDataSource, AppConfigManager.Configuration.AppConfig);
//criar o documento
report.CreateDocument();
//libera memoria da ferramenta
reportPrintTool.Dispose();
//retorna o relatorio
return(report);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Impossível gerar relatório !", "Falha ao gerar relatório");
LoggerUtilIts.GenerateLogs(ex);
return(null);
}
}
}
//Chamado internamente
private async static void startTask(Task task, string taskName = null, Form form = null)
{
if (form != null)
{
form.Enabled = false;
}
TaskName = taskName;
try
{
//enfilera a tarefa
Task taskWork = Task.Run(() => task);
//exibie a barra de progresso
try { SplashScreenManager.ShowForm(form, typeof(XFrmWait)); }
catch (Exception ex)
{
/*Nao importa*/
Console.WriteLine("Exceção lançada ao exibir SplashScreenManager => TaskName->" + taskName
+ "\nmsg -> " + ex.Message);
}
//espera a task acabar
await taskWork;
//delay
Thread.Sleep(100);
//termine a barra de progresso
try { SplashScreenManager.CloseForm(); }
catch (Exception ex)
{
/*Nao importa*/
Console.WriteLine("Exceção lançada ao fechar SplashScreenManager => TaskName->" + taskName
+ "\nmsg -> " + ex.Message);
}
}
catch (Exception ex)
{
LoggerUtilIts.GenerateLogs(ex, "Tarefa : " + taskName);
XMessageIts.ExceptionMessageDetails(ex, "Falha na execução da tarefa!");
}
if (form != null)
{
form.Enabled = true;
}
}
private bool showDashboard()
{
if (this._dashboardImage != null)
{
try {
new DashboardDaoManager().LoadDashboard(_dashboardImage, dashboardViewer1);
}
catch (Exception ex)
{
LoggerUtilIts.GenerateLogs(ex);
XMessageIts.Erro("Dashboard não pode ser carregado!");
}
}
return(true);
}
public static ContaBancaria GetContaBancaria()
{
using (var ctx = new BalcaoContext())
{
try
{
return(ctx.ContaBancariaDao.First());
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
LoggerUtilIts.GenerateLogs(ex, "Conta bancária do sistema não encontrada");
return(null);
}
}
}
/// <summary>
/// Atualiza o dashboard existente no banco
/// </summary>
/// <param name="dashboardDesigner">Designer do dashboard</param>
/// <param name="dash">Dashboard a ser persistido</param>
/// <returns>O Dashboard persistido no banco ou null</returns>
public bool UpdateDashboard(DashboardDesigner dashboardDesigner, DashboardImage dash)
{
try
{
using (var ctx = new ReportContext())
{
//nome padrão
dash.DefaultName = dashboardDesigner.ActiveControl.Name;
//gera um nome aleatorio utilizando o nome setado no dashboard
string dashPath = generatePath(dash, ctx);
// using (MemoryStream ms = new MemoryStream())
//objeto designer do dashboard
var designer = dashboardDesigner.Dashboard;
FileManagerIts.DeleteFile(dashPath);
//salva o layout em memoria
//designer.SaveToXml(ms);
//salva o dashboard no disco em formato xml
designer.SaveToXml(dashPath);
var bytes = FileManagerIts.GetBytesFromFile(dashPath); //ms.GetBuffer();
//passando objeto pro contexto
var current = ctx.DashboardImageDao.Find(dash.IdReport);
//atualiza o dashboard
current.Update(dash);
//garante a atualização
current.ReportImageData = bytes;
//efetiva no banco
return(ctx.DashboardImageDao.Update(current));
}
}
catch (Exception ex)
{
XMessageIts.Advertencia("Houve um erro na atualização do dashboard.\n\n"
+ ex.Message);
LoggerUtilIts.GenerateLogs(ex);
return(false);
}
}
/// <summary>
/// Salva o dashboard no banco
/// </summary>
/// <param name="dashboardDesigner">Designer do dashboard</param>
/// <param name="dash">Dashboard a ser persistido</param>
/// <returns>O Dashboard persistido no banco ou null</returns>
public DashboardImage SaveDashboard(DashboardDesigner dashboardDesigner, DashboardImage dash)
{
try
{
using (var ctx = new ReportContext())
{
//nome informado no dashboard
dash.DefaultName = dashboardDesigner.ActiveControl.Name;
//gera um nome aleatorio utilizando o nome setado no dashboard
string dashPath = generatePath(dash, ctx);
using (MemoryStream ms = new MemoryStream())
{
//objeto designer do dashboard
var designer = dashboardDesigner.Dashboard;
//salva o layout em memoria
designer.SaveToXml(ms);
//salva o dashboard no disco em formato xml
designer.SaveToXml(dashPath);
//obtem os bytes do dashboard
var bytes = ms.GetBuffer();
//passa os bytes do dashboard pro objeto dashboard
dash.ReportImageData = bytes;
//persiste o objeto no banco
if (ctx.DashboardImageDao.Save(dash))
{
return(dash);
}
}
}
}
catch (Exception ex)
{
XMessageIts.Advertencia("Houve um erro ao salvar o dashboard.\n\n"
+ ex.Message);
LoggerUtilIts.GenerateLogs(ex);
}
return(null);
}
/// <summary>
/// Gera um relatório pelo ID
/// </summary>
/// <param name="id">ID do relatório</param>
/// <param name="requestParameters"></param>
/// <param name="visibleParameters"></param>
/// <param name="ribbon"></param>
/// <returns></returns>
public static void PrintReportById(int id, bool requestParameters = true, bool visibleParameters = true, bool ribbon = false)
{
try
{
using (var ctx = new ReportContext())
{
var current = ctx.ReportImageDao.Find(id);
printReport(current, requestParameters, visibleParameters, ribbon);
}
}
catch (Exception ex)
{
XMessageIts.Advertencia("Relatório não encontrado !");
LoggerUtilIts.GenerateLogs(ex, "Method: PrintReportById");
}
}
public void Run(string logon = null)
{
try
{
logon = retryLogon(logon);
this._xFrmLogin.Text = "Acesso ao sistema:";
this._isLoginAutoFailed = false;
//se nao informe
if (string.IsNullOrEmpty(logon))
{
//action form do login dispara o invokeMenu
//faça login primeiro
this._xFrmLogin.ShowDialog();
//se foi cancelado
if (this._xFrmLogin.IsCancel)
{
//termina aplicação
Application.Exit();
return;
}
else
{
//espera e invoca
waitRun();
}
}
else
{
//chama a task
_taskLogin = Task.Run(() => doWorkAsync(logon, null));
//espera e invoca
waitRun();
}
}
catch (Exception ex)
{
string msg = "Erro desconhecido!. Contate o administrador ou verifique o log de eventos!";
LoggerUtilIts.GenerateLogs(ex, msg);
XMessageIts.ExceptionMessageDetails(ex, msg);
//Environment.Exit(0); //nao fechar a aplicação em TODAS as exceptions
}
}
/// <summary>
/// Remove o dashboard do banco
/// </summary>
/// <param name="dashboard"></param>
/// <returns></returns>
public bool RemoveDashboard(DashboardImage dashboard)
{
using (var ctx = new ReportContext())
{
//remove o dash do banco
var current = ctx.DashboardImageDao.Find(dashboard.IdReport);
try
{
return(ctx.DashboardImageDao.Delete(current));
}
catch (Exception ex)
{
XMessageIts.Erro("Não foi possível remover o dashboard!");
LoggerUtilIts.GenerateLogs(ex, "Falha ao remover dashboard!");
return(false);
}
}
}
public static void PrintReportWithParams(ReportImage rptImage)
{
try
{
/*
* Forma de geração do relatório.
*
* 1 = Gera e visualiza sem gravar no spool,
* 2 = Gera e visualiza gravando no spool,
* 3 = Gera somente em spool.
*/
var param = ParametroManager.GetValorParamByCodigo("report_eng");
if (param == "1")
{
//new ReportSpoolDaoManager().PrintReportSpool(rptSelected.IdReport);
//usar esse aqui no azure pq nao tenho espaco pro spool por enquanto
//acho q faz mais sentido salvar a ref do relatorio gerado
//do q os bytes do relatorio uma vez que o relatorio ja existe
//entao so a pk dele ja seria o suficiente
ReportUtil.PrintReport(rptImage);
}
else if (param == "2")
{
new ReportSpoolDaoManager().PrintReportSpool(rptImage.IdReport);
}
else if (param == "3")
{
new ReportSpoolDaoManager().PrintReportSpool(rptImage.IdReport, false);
}
else
{
LoggerUtilIts.GenerateLogs(new Exception("Paramentro report_eng não existe."));
}
//nao acontece nada
//nao podemos impedir a rotina de funcionar
}
catch (Exception ex)
{
XMessageIts.ExceptionJustMessage(ex, "Falha ao gerar o relatório.");
}
}
private async void loadDashboard()
{
if (dashboardImageAnt.ReportImageData != null)
{
Task <string> path = Task.Run(() => new DashboardDaoManager().LoadToChache(dashboardImageAnt, true));
try
{
//Abre o DashboardImage para edição
//DashboardDesigner onde será exibido o dashboardImage
dashboardDesigner1.Name = dashboardImageAnt.ReportName;
dashboardDesigner1.LoadDashboard(await path);
}
catch (Exception ex)
{
LoggerUtilIts.GenerateLogs(ex);
XMessageIts.Erro("Dashboard não pode ser carregado!");
}
}
}