/// <summary>
/// Carrega um .xml em disco
/// </summary>
/// <param name="dash"></param>Objeto DashboardImage
/// <returns></returns>Obtém o path do dashboard no banco
public string LoadToChache(DashboardImage dash, bool overwrite = false)
{
using (var ctx = new ReportContext())
{
try
{
//recupera o objeto do banco para alteração dos campos
dash = ctx.DashboardImageDao.Find(dash.IdReport);
//caminho do dashboard
string dashboardPath = generatePath(dash, ctx);
if (overwrite)
{
FileManagerIts.DeleteFile(dashboardPath);
}
//gera o arquivo atraves dos bytes salvos no banco e gera um arquivo em disco
if (!File.Exists(dashboardPath))
{
FileManagerIts.WriteBytesToFile(dashboardPath, dash.ReportImageData);
}
//caso contrario vou carregar diretamente do disco
return(dashboardPath);
}
catch (Exception)
{
return(null);
}
}
}
public static void ExportDashboardList(List <DashboardImage> reports)
{
string outReports = Path.Combine(FileManagerIts.DeskTopPath, "Dashboards ITS");
if (!Directory.Exists(outReports))
{
FileManagerIts.CreateDirectory(outReports);
}
bool flag = false;
foreach (var rpt in reports)
{
var novo = new DashboardImage();
//gera um novo
novo.Update(rpt);
string file = outReports + "\\" + rpt.ReportName + ".itsdsh";
//serializa p relatorio
var bytes = SerializeIts.SerializeObject(novo);
flag = FileManagerIts.WriteBytesToFile(file, bytes);
}
if (flag)
{
XMessageIts.Mensagem("Dashboards exportados com sucesso!");
}
else
{
XMessageIts.Erro("Dashboards exportados com erro!");
}
}
public static void DuplicateDashboard(DashboardImage dsImage)
{
var op = XMessageIts.Confirmacao("Certeza que deseja criar uma cópia do dashboard selecionado?");
if (op == DialogResult.Yes)
{
using (var ctx = new ReportContext())
{
//novo
var novo = new DashboardImage();
//gera um novo
novo.Update(dsImage);
var count = ctx.DashboardImageDao.Where(r => r.ReportName == novo.ReportName).Count();
novo.ReportName = novo.ReportName + "_" + count;
novo.ReportDescription = novo.ReportDescription + "(Duplicado)";
if (ctx.DashboardImageDao.Save(novo))
{
XMessageIts.Mensagem("Dashboard duplicado com sucesso!");
}
else
{
XMessageIts.Erro("Erro na cópia do dashboard!");
}
}
}
}
/// <summary>
/// Criar/Alterar o DashboardImage
/// </summary>
/// <param name="dashboardImage"></param>
public XFrmAddReport(DashboardImage dashboardImage) : this()
{
this.ReportImage = null;
this.DashboardImage = dashboardImage;
this.cbGrupoRelatorio.Properties.Items.Add(dashboardImage.Grupo);
this.cbGrupoRelatorio.SelectedIndex = 0;
this.txtDescricaoRelatorio.Text = dashboardImage.ReportDescription;
}
public static void ImportDashboardFromFiles(params string[] filesReports)
{
using (var ctx = new ReportContext())
{
try
{
Dictionary <string, bool> importados = new Dictionary <string, bool>();
foreach (var file in filesReports)
{
var bytesFile = FileManagerIts.GetBytesFromFile(file);
var dashDeserializado = SerializeIts.DeserializeObject <DashboardImage>(bytesFile);
var dashCreateUpdate = ctx.DashboardImageDao.Where(r =>
r.ReportDescription == dashDeserializado.ReportDescription)
.FirstOrDefault();
//relatorio ja existe
if (dashCreateUpdate != null)
{
var msg = "O dashboard selecionado já existe, deseja atualiza-lo?";
var confirm = XMessageIts.Confirmacao(msg);
if (confirm == DialogResult.Yes)
{
dashCreateUpdate.Update(dashDeserializado);
var traUpd = ctx.DashboardImageDao.Update(dashCreateUpdate);
if (traUpd)
{
XMessageIts.Mensagem("Dashboard atualizado com sucesso!");
}
}
}
//relatorio nao existe, entao vai criar
else
{
var newDashboard = new DashboardImage();
newDashboard.IdGrpReport = dashDeserializado.IdGrpReport;
newDashboard.ReportDescription = dashDeserializado.ReportDescription;
newDashboard.ReportImageData = dashDeserializado.ReportImageData;
newDashboard.ReportName = dashDeserializado.ReportName;
importados.Add(newDashboard.ReportName, ctx.DashboardImageDao.Save(newDashboard));
}
}
if (importados.Where(i => i.Value == false).Count() == 0)
{
XMessageIts.Mensagem("Dashboard importado com sucesso!");
}
else
{
XMessageIts.Advertencia("Ocorreram erros ao importar o(s) dashboard(s) !");
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
}
private string generatePath(DashboardImage dash, ReportContext ctx)
{
//acompanha o Pk do dashboard que nunca se repete
if (dash.IdReport != 0)
{
dash.ReportName = "Dashboard" + dash.IdReport;
}
else
{
dash.ReportName = "Dashboard" + (ctx.DashboardImageDao.FindAll().Count + 1);
}
var path = string.Format("{0}\\{1}{2}", _dashboardDir, dash.ReportName, ".xml");
return(path);
}
/// <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>
/// 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>
/// 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 void LoadDashboard(DashboardImage _dashboardImage, DashboardViewer dashboardViewer1)
{
using (var ctx = new ReportContext())
{
string path = LoadToChache(_dashboardImage);
Dashboard ds = new Dashboard();
ds.LoadFromXml(path);
DataSourceCollection dsCollection = ds.DataSources;
var appConf = new AppConfigIts(ctx.NameOrConnectionString);
foreach (DashboardSqlDataSource dsSql in dsCollection)
{
ReportUtil.SetParamDataSource(dsSql, appConf);
}
dashboardViewer1.Dashboard = ds;
dashboardViewer1.ReloadData();
}
}
private void barBtnSaveDashboard_ItemClick(object sender, ItemClickEventArgs e)
{
var dbManager = new DashboardDaoManager();
//salve o dashboard
if (dashboardImageAnt.IdReport == 0)
{
dashboardImageAnt = dbManager.SaveDashboard(this.dashboardDesigner1, this.dashboardImageAnt);
//se o objeto passar a ser diferente de null então foi salvo
//e agora passarei a editar
if (dashboardImageAnt != null)
{
XMessageIts.Mensagem("Dashboard salvo com sucesso!");
}
}//atualize o dashboard
else
{
if (dbManager.UpdateDashboard(dashboardDesigner1, dashboardImageAnt))
{
XMessageIts.Mensagem("Dashboard atualizado com sucesso!");
}
}
}
public static void ExportDashaboard(DashboardImage dash)
{
var bytes = SerializeIts.SerializeObject(dash);
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = DashboardFilter;
sfd.FileName = "Export_" + dash.ReportDescription;
var op = sfd.ShowDialog();
if (op == DialogResult.OK)
{
//sfd.FileName = Path.ChangeExtension(sfd.FileName, "iteReport");
if (FileManagerIts.WriteBytesToFile(sfd.FileName, bytes))
{
XMessageIts.Mensagem("Arquivo salvo com sucesso!");
}
else
{
XMessageIts.Erro("Erro");
}
}
}
/// <summary>
/// Alterar um dashboard existente
/// </summary>
/// <param name="dashboardImage"></param>
public RbbFrmDashboardEditorNew(DashboardImage dashboardImage) : this()
{
this.dashboardImageAnt = dashboardImage;
}
/// <summary>
/// Exibe um dashboard
/// </summary>
/// <param name="dashBoardImage"></param>Dashboard a ser visualizado
public RbbFrmDashboardView(DashboardImage dashBoardImage) : this()
{
this._dashboardImage = dashBoardImage;
showDashboard();
}
