private void setImagemPictureImage(string file)
{
if (file != null && File.Exists(file))
{
try
{
//Carrega imagem no picture box e define a propriedade size da imagem como normal
this.picImagem.Load(file);
//informe no label
this.lblFileName.Text = Path.GetFileName(file);
//salva a referencia da imagem
this._util.AddImage(file);
//Retorna a lagura e altura da imagem
string imgSize = "Resolução: " + picImagem.Width + " x " + picImagem.Height;
lblResolucao.Text = imgSize;
//atualiza o indice da pagina
this.barStaticPageIndex.Caption = this.DigitalizacoesPath.Count.ToString();
//atualiza o numero de paginas
this.barStaticPagesCount.Caption = this.DigitalizacoesPath.Count.ToString();
}
catch (ArgumentException ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha na digitalização.");
}
}
}
/// <summary>
/// Realiza backup de uma base dados do SQL server.
/// Backup Full
/// </summary>
/// <param name="appConfig"></param>
/// <param name="directory"></param>
public bool BackupFullFromDatabase(AppConfigIts appConfig, string directory = null)
{
Backup bkpDbFull = createBackup(appConfig, directory);
string serverName = appConfig.ServerName;
//Servidor onde devo disparar a ação
Server server = new Server(serverName);
try
{
/* SqlBackup method starts to take back up
* You can also use SqlBackupAsync method to perform the backup
* operation asynchronously */
bkpDbFull.SqlBackup(server);
return(true);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha durante o processo de backup!");
return(false);
}
}
private void addArquivo(string file)
{
if (file != null && File.Exists(file))
{
try
{
this.util.ImagesPath.Add(file);
//Carrega imagem no picture box e define a propriedade size da imagem como normal
this.picImagem.Load(file);
this.Files.Add(file);
this.lblFileName.Text = file;
//atualiza o indice da pagina
this.barStaticPageIndex.Caption = this.Files.Count.ToString();
//atualiza o numero de paginas
this.barStaticPagesCount.Caption = this.Files.Count.ToString();
}
catch (ArgumentException ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha na digitalização.");
}
}
}
public bool Sincbd(List <ItsVersionControl> assemblies)
{
try
{
var ctx = ITEGenericContext <ItsVersionControl> .Instance;
foreach (var asm in assemblies)
{
var current = ctx.Dao.Find(asm.FullName.Trim());
if (current == null)
{
var version = new ItsVersionControl(asm.ClassName, asm.Version, asm.FullName.Trim());
ctx.Dao.Save(version);
}
}
return(true);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Erro critico");
return(false);
}
}
/// <summary>
/// Imprimi na impressora selecionada ou exibe caixa de dialogo para selecionar um dispositivo
/// </summary>
/// <param name="printDocument"></param>
/// <param name="printerName"></param>
public static void PrintTo(string printerName, PrintDocument printDocument)
{
PrintDialog dialogo = new PrintDialog();
if (printerName != null)
{
//define a impressora pros objetos
dialogo.PrinterSettings.PrinterName = printerName;
printDocument.PrinterSettings.PrinterName = printerName;
}
//se nao vai selecionar a impressora
var op = dialogo.ShowDialog();
if (op == DialogResult.OK)
{
try
{
//informe os documentos a serem impressos
dialogo.Document = printDocument;
//agora imprima
printDocument.Print();
}
catch (InvalidPrinterException ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha na impressão !");
}
}
}
public List <ItsVersionControl> AssembliesCarregados(Type type)
{
List <ItsVersionControl> assembliesITS = new List <ItsVersionControl>();
try
{
var asm = type.Assembly;
var assemblies = asm.GetReferencedAssemblies();
foreach (var assembly in assemblies)
{
if (assembly.FullName.StartsWith("ITE") || assembly.FullName.StartsWith("ITS"))
{
var version = new ItsVersionControl(assembly.Name, assembly.Version.ToString(), assembly.FullName);
assembliesITS.Add(version);
}
}
return(assembliesITS);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Erro critico");
return(assembliesITS);
}
}
private void btnSalvar_Click(object sender, EventArgs e)
{
try
{
using (var ctx = new BalcaoContext())
{
var novo = indexarDados();
if (novo.IdContaBancaria == 0)
{
if (ctx.ContaBancariaDao.Save(novo))
{
XMessageIts.Mensagem("Conta aberta com sucesso!");
this.Dispose();
}
}
else
{
var current = ctx.ContaBancariaDao.Find(novo.IdContaBancaria);
current.Update(novo);
if (ctx.ContaBancariaDao.Update(current))
{
XMessageIts.Mensagem("Conta atualizada com sucesso!");
this.Dispose();
}
}
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha ao salvar conta!");
}
}
private void btnSaveLancamento_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
var manager = new LancamentoContabilDaoManager();
try
{
//adicao
if (_lancamentoCurrent == null)
{
var newLancto = indexarLancamento();
if (manager.SaveLancamento(newLancto))
{
XMessageIts.Mensagem("Lançamento criado com sucesso.");
this.Dispose();
}
}
else
{
var lancEdit = indexarLancamento();
if (manager.Update(lancEdit))
{
XMessageIts.Mensagem("Lançamento atualizado com sucesso.");
this.Dispose();
}
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Erro ao salvar lançamento.");
return;
}
}
/// <summary>
/// SaveLayout as alteracoes na imagem
/// </summary>
private void setChangesImage()
{
try
{
//se houve alteracao
var op = XMessageIts.Confirmacao("A imagem foi alterada!\nEfetivar alterações", "SaveLayout alterações");
//pega o path da imagem q esta selecionada
var path = this.picImagem.ImageLocation;
//novo arquivo
var fileName = Path.GetFileName(Path.GetTempFileName()) + ".jpeg";
string novo = Path.GetTempPath() + "\\" + fileName;
var img = this.picImagem.Image;
img.Save(novo);
if (File.Exists(novo))
{
//indice da imagem alterada
var index = ParseUtil.ToInt(barStaticPageIndex.Caption) - 1;
//remove o arquivo atual
this.DigitalizacoesPath.RemoveAt(index);
//adiciona o novo
this.DigitalizacoesPath.Insert(index, novo);
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha ao efetivar alterações");
}
}
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);
}
}
}
/// <summary>
/// Gerar a nota fiscal eletronica no painel de NFe
/// </summary>
/// <param name="movimento"></param>
/// <returns></returns>
public bool GerarNFe(Movimento movimento)
{
try
{
using (var ctx = new BalcaoContext())
{
var xml = GerarXml(movimento);
var nfeEstadual = new NFeEstadual()
{
ChaveAcesso = movimento.ChaveAcessoNf,
IdMovimento = movimento.IdMovimento,
StatusXml = TypeStatusEnvioNFe.XmlGerado,
XmlNfe = xml
};
if (ctx.NFeEstadualDao.Save(nfeEstadual))
{
return(true);
}
}
return(false);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Erro ao gerar NFe!");
return(false);
}
}
private void showImage(int index)
{
if (this.Files.Count > 0 && index - 1 >= 0)
{
try
{
var path = this.Files[index - 1];
try
{
this.picImagem.Load(path);
this.lblFileName.Text = path;
this.barStaticPageIndex.Caption = index.ToString();
this.picImagem.Invalidate();
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha ao carregar imagem !");
}
}
catch (ArgumentOutOfRangeException)
{
}
}
}
public static void ImportReportFromFiles(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 rptDeserializado = SerializeIts.DeserializeObject <ReportImage>(bytesFile);
var rptCreateUpdate = ctx.ReportImageDao.Where(r =>
r.ReportName == rptDeserializado.ReportName)
.FirstOrDefault();
//relatorio ja existe
if (rptCreateUpdate != null)
{
var msg = "O relatório selecionado já existe, deseja atualiza-lo?";
var confirm = XMessageIts.Confirmacao(msg);
if (confirm == DialogResult.Yes)
{
rptCreateUpdate.Update(rptDeserializado);
var traUpd = ctx.ReportImageDao.Update(rptCreateUpdate);
if (traUpd)
{
XMessageIts.Mensagem("Relatório atualizado com sucesso!");
}
}
}
//relatorio nao existe, entao vai criar
else
{
var newReport = new ReportImage();
newReport.IdGrpReport = rptDeserializado.IdGrpReport;
newReport.ReportDescription = rptDeserializado.ReportDescription;
newReport.ReportImageData = rptDeserializado.ReportImageData;
newReport.ReportName = rptDeserializado.ReportName;
importados.Add(newReport.ReportName, ctx.ReportImageDao.Save(newReport));
}
}
if (importados.Where(i => i.Value == false).Count() == 0)
{
XMessageIts.Mensagem("Relatórios importado com sucesso!");
}
else
{
XMessageIts.Advertencia("Ocorreram erros ao importar o(s) dashboard(s) !");
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha ao importar o relatório");
}
}
}
/// <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);
}
public bool TransferirEstoque(List <Movimento> movimentos)
{
try
{
using (
TransactionScope ts =
new TransactionScope(TransactionScopeOption.Required,
new TransactionOptions {
IsolationLevel = IsolationLevel.Serializable
}))
{
var i = 0;
var result = false;
foreach (var movimento in movimentos)
{
if (movimento.TipoMovimento != null && movimento.TipoMovimento.GeraMovimentoFiscal)
{
//cria os impostos
movimento.ItensMovimento.ToList().ForEach(it => { CriarImpostosItemNF(it); });
//calcula o icms que fica na capa
movimento.CalculaValoresIcms();
}
//cancela as referencias para o Save
CancelarReferenciaNfInclusao(movimento);
var ctx = new BalcaoContext();
var transaction = ctx.MovimentoDao.Save(movimento);
if (transaction)
{
new ProdutoDaoManager().AddMovimentacaoProduto(movimento, movimento.IdMovimento);
i++;
}
}
if (i == movimentos.Count)
{
ts.Complete();
result = true;
}
return(result);
}
}
catch (DbUpdateException db)
{
XMessageIts.ExceptionMessageDetails(db,
"Dados em duplicidade! Vefique todos os campos e se já não existe uma nota fiscal com os mesmos dados!");
return(false);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Ocorreu um erro na inclusão/atualização da nota fiscal");
return(false);
}
}
private void btnDigitalizarPara_Click(object sender, EventArgs e)
{
try
{
var file = PrinterUtilIts.ScanningTo();
this.setImagemPictureImage(file);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Erro na digitalização");
}
}
public override TaskIts IndexScheduleJob()
{
try
{
List <TaskParamIts> parameters = new List <TaskParamIts>();
var dtPeriodo = (cbPeriodo.SelectedItem as CalendarMonth).DateTime;
dtPeriodo = DataUtil.GetDataFinalDoMes(dtPeriodo);
var grupoSelect = cbGrupoEvento.SelectedItem as GrupoEvento;
var tpFechamento = IndexTipoFechamento();
var consGrpEvtFunc = chkConsGrpFunc.Checked;
var cts = new CancellationTokenSource();
var usuario = new Usuario()
{
IdUsuario = userLogado.IdUsuario,
NomeUsuario = userLogado.NomeUsuario,
NomeUtilizador = userLogado.NomeUtilizador
};
var classe = "ITE.Entidades.DaoManager.RHDaoManager.FolhaDaoManager, ITE.Entidades, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
var descricaoTarefa = "Calculo Folha Pagamento";
var metodo = "ExecutaCalculoFolha";
var idProcess = "{BA501F85-6216-466F-8534-C650F6E57A94}";
var p_periodo = new TaskParamIts(dtPeriodo.GetType(), "periodo", dtPeriodo);
var p_usuario = new TaskParamIts(usuario.GetType(), "usuario", usuario);
var p_tipoFech = new TaskParamIts(tpFechamento.GetType(), "tipoFechamento", tpFechamento);
var p_grpEvento = new TaskParamIts(grupoSelect.GetType(), "grupoEvento", grupoSelect);
var p_cnsGf = new TaskParamIts(consGrpEvtFunc.GetType(), "considerGrpFunc", consGrpEvtFunc);
var p_cancel = new TaskParamIts(typeof(CancellationTokenSource), "cts", cts.ToString());
parameters.Add(p_periodo);
parameters.Add(p_usuario);
parameters.Add(p_tipoFech);
parameters.Add(p_grpEvento);
parameters.Add(p_cnsGf);
parameters.Add(p_cancel);
var bytes = SerializeIts.SerializeObject(parameters);
base.SchedulerJob = new TaskIts(Guid.NewGuid().ToString(), 1, 1, userLogado.IdUsuario, classe, metodo,
descricaoTarefa, idProcess, bytes);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Por favor preencha todos os parametros");
}
return(base.SchedulerJob);
}
/// <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;
}
}
public TaskIts GetTaskById(string idTask)
{
try
{
var ctx = SchedulerContextGeneric <TaskIts> .Instance;
ctx.ProxyCreation(false);
var taskBd = ctx.Dao.Find(idTask);
return(taskBd);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha ao obter a tarefa pelo ID");
return(null);
}
}
private void btnStartExec_ItemClick(object sender, ItemClickEventArgs e)
{
try
{
var taskSel = GridViewUtil.GetFocusedRow <ITSolution.Scheduler.EntidadesBd.TaskIts>(gridViewTasks);
ISchedulerControl sc = ITSActivator.OpenConnection <ISchedulerControl>(Consts.FrameworkSchedulerClass);
this.cts = new CancellationTokenSource();
sc.Execute(taskSel.IdTask, cts);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Erro ao iniciar a tarefa!");
}
}
private string getNewLoteEnvioNFeNumber()
{
try
{
using (var ctx = new BalcaoContext())
{
var nextNumber = ctx.ConnectionSql.ExecuteQueryDataTable("SELECT NEXT VALUE FOR SEQ_NUM_LOTE_NFE").Rows[0][0];
return(nextNumber.ToString());
}
}
catch (SqlException ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha ao obter a numeração do lote.", "Erro ao obter sequência");
return(string.Empty);
}
}
public Municipios GetMunicipioByNome(string municipio)
{
try
{
using (var ctx = new BalcaoContext())
{
var cidade = ctx.MunicipiosDao.Where(m => m.NomeMunicipio.ToUpper() == municipio.ToUpper()).FirstOrDefault();
return(cidade);
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha ao obter a município");
return(null);
}
}
public UnidadeFederacao GetUfByCodigo(string codUF)
{
try
{
using (var ctx = new BalcaoContext())
{
var uf = ctx.UnidadeFederacaoDao.Where(u => u.CodigoUF == codUF).FirstOrDefault();
return(uf);
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha ao obter a UF");
return(null);
}
}
private void btnRemove_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
try
{
var selected = gridViewItens.GetFocusedRow <dynamic>();
if (selected != null)
{
produtos.Remove(selected);
}
gridControlItens.RefreshDataSource();
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, ex.Message);
}
}
public bool Update(LoteContabil novo)
{
try
{
using (var ctx = new BalcaoContext())
{
var current = ctx.LoteContabilDao.Find(novo.IdLote);
current.Update(novo);
return(ctx.LoteContabilDao.Update(current));
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Ocorreu um erro ao salvar o lote.", "Erro");
return(false);
}
}
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
}
}
private void barSubGerarXML_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
try
{
using (var ctx = new BalcaoContext())
{
var notaFiscal = GridViewUtil.GetFocusedRow <Movimento>(gridViewEntradas);
var manager = new NfeManager();
manager.GerarNFe(notaFiscal);
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "");
}
}
/// <summary>
/// Realiza backup de uma base dados do SQL server.
/// Backup Full utilizando instrução SQL
/// </summary>
/// <param name="appConfig"></param>
/// <param name="directory"></param>
public bool BackupNativoFullFromDatabase(AppConfigIts appConfig, string directory)
{
//seta o path de backup
createBackup(appConfig, directory);
try
{
var scriptSql = new StringBuilder();
scriptSql.Append("BACKUP DATABASE ");
scriptSql.Append(appConfig.Database);
scriptSql.Append(" TO DISK = ");
scriptSql.Append("'");
scriptSql.Append(_pathBackup);
scriptSql.Append("' ");
scriptSql.Append("WITH NO_COMPRESSION, NAME = ");
scriptSql.Append("'");
scriptSql.Append(appConfig.Database);
scriptSql.Append("-Full Database backup', FORMAT, INIT, NOREWIND, NOUNLOAD, STATS = 1");
try
{
var a = new ConnectionLocalSql(appConfig.ConnectionString).ExecuteQuery(scriptSql.ToString());
if (File.Exists(this._pathBackup))
{
//se o arquivo foi compactado
if (ZipUtil.CompressFile(this._pathBackup))
{
File.Delete(this._pathBackup);
}
}
}
catch (SqlException sqle)
{
XMessageIts.ExceptionMessageDetails(sqle, "Falha durante o processo de backup!");
return(false);
}
return(true);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessageDetails(ex, "Falha durante o processo de backup!");
return(false);
}
}
/// <summary>
/// Cria uma tarefa no banco de dados.
/// Retorna o guid da tarefa criada
/// </summary>
/// <returns>ID Tarefa</returns>
public string CreateTask(TaskIts task, CancellationTokenSource cts)
{
try
{
var ctx = SchedulerContextGeneric <TaskIts> .Instance;
ctx.Dao.Save(task);
return(task.IdTask);
}
catch (SerializationException se)
{
XMessageIts.ExceptionMessageDetails(se, "Erro");
return("Ocorreu um erro!\n" + se.Message);
}
catch (Exception ex)
{
return("Ocorreu um erro!\n" + ex.Message);
}
}