//Inicializa o dataset com as consultas que pertencem ao relatorio
private DataSet initDsConsultas()
{
try
{
using (var ctx = new ReportContext())
{
this.dsConsultasReport = new DataSet("dsReport");
ConnectionFactoryIts conn = new ConnectionFactoryIts(ctx.NameOrConnectionString, 90);
foreach (var item in sourceReport)
{
var myTable = new DataTable();
myTable = conn.ExecuteQueryDataTable(item.Consulta.CorpoQuery);
myTable.TableName = "table_" + item.Consulta.CodigoQuery;
dsConsultasReport.Tables.Add(myTable);
}
return(dsConsultasReport);
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
return(null);
}
}
/// <summary>
/// Converter a string em número decimal
/// </summary>
/// <param colName="o"></param>
/// <returns></returns>
public static Decimal ToDecimal(object stringValue)
{
if (IsValidText(stringValue))
{
try
{
stringValue = prepareStringToConvertDecimal(stringValue);
return(Convert.ToDecimal(stringValue));
}
catch (OverflowException ex)
{
LoggerUtilIts.ShowExceptionLogs(ex);
}
catch (InvalidCastException ex)
{
XMessageIts.ExceptionMessage(ex, "Objeto informado não pode ser convertido em decimal\nInforme um texto", "Falha crítica de cast");
}
catch (FormatException ex2)
{
Console.WriteLine(ex2.InnerException);
}
}
return(0.000m);
}
private void barBtnRemoveConta_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
try
{
using (var ctx = new BalcaoContext())
{
var selectedConta = gridView1.GetFocusedRow <ContaContabil>();
//verifica o uso da conta
var usoCred = ctx.PartidaContabilDao.Where(p => p.IdContaContabilCred == selectedConta.IdContaContabil).Count();
var usoDeb = ctx.PartidaContabilDao.Where(p => p.IdContaContabilDeb == selectedConta.IdContaContabil).Count();
if (usoCred >= 1 || usoDeb >= 1)
{
XMessageIts.Advertencia("Conta contábil já utilizada em lançamentos contábeis, não é possível a exclusão!");
return;
}
var msg = "Certeza que deseja excluir a conta " + selectedConta.CodigoContaContabil + "?";
if (XMessageIts.Confirmacao(msg) == System.Windows.Forms.DialogResult.Yes)
{
var conta = ctx.ContaContabilDao.Find(selectedConta.IdContaContabil);
if (ctx.ContaContabilDao.Delete(conta))
{
XMessageIts.Mensagem("Conta excluída com sucesso!");
}
}
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
public bool SaveContaContabil(ContaContabil conta)
{
try
{
if (VerifyCodReduzido(conta.CodigoReduzido))
{
XMessageIts.Advertencia("Código reduzido já utilizado, por favor utilize outro.");
return(false);
}
using (var ctx = new BalcaoContext())
{
conta.Matriz = null;
conta.Nivel = GetNivelContaContabil(conta.CodigoContaContabil);
var result = ctx.ContaContabilDao.Save(conta);
if (result)
{
XMessageIts.Mensagem("Conta contábil incluída com sucesso!");
return(result);
}
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
return(false);
}
private ITSolution.Scheduler.EntidadesBd.TaskIts indexarTarefa()
{
var proccessSelected = cbProcesso.SelectedItem as ITSolution.Scheduler.EntidadesBd.ProcessIts;
if (proccessSelected != null)
{
memDescProcess.Text = proccessSelected.DescricaoProcesso;
if (proccessSelected.CodigoProcesso == "INS_TSTE")
{
}
else if (proccessSelected.CodigoProcesso == "FEC_FOLHA")
{
try
{
//var schedulerControl = new Scheduler.Manager.SchedulerControl();
ISchedulerControl scd = ITSActivator.OpenConnection <ISchedulerControl>(Consts.FrameworkSchedulerClass);
scd.CreateTask(this.control.SchedulerJob, cts);
return(this.control.SchedulerJob);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
return(null);
}
return(null);
}
/// <summary>
/// Retorna um DataTable com todos os dados da planilha do índice 0, independentemente do colName da mesma
/// <param colName="excelFile"></param> Arquivo do excel xls, xlsx.
/// </summary>
/// <returns>Objeto DataTable preenchido</returns>
public DataTable GetDataTableFromIndexZero()
{
DataTable dataTable = new DataTable();
try
{
using (var connection = new OleDbConnection(this.ConnectionString))
{
connection.Open();
DataTable worksheets = connection.GetSchema("Tables");
if ((worksheets != null) && (worksheets.Rows.Count > 0))
{
var rows = worksheets.Rows;
var tableName = worksheets.Rows[0]["TABLE_NAME"].ToString();
// Seleciono todos os dados de uma determinada planilha do arquivo, independentemente do colName da mesma
var da = new OleDbDataAdapter(string.Format("SELECT * FROM [{0}]", tableName), this.ConnectionString);
da.Fill(dataTable);
}
}
return(dataTable);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
return(dataTable);
}
}
private void btnRemoveQuery_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
try
{
using (var ctx = new ReportContext())
{
var selectedQuery = gridViewQueris.GetFocusedRow <SqlQueryIts>();
var op = XMessageIts.Confirmacao("Certeza que deseja excluir a consulta selecionada?!", "Confirmação");
if (op == DialogResult.Yes)
{
var resultDelete = ctx.SqlQueryItsDao.Delete(selectedQuery);
if (resultDelete)
{
XMessageIts.Mensagem("Consulta excluída com sucesso!");
}
}
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
public void Start()
{
try
{
//add behavior
//ativa o wsdl do servicos() exposto
//customiza a execucao do servico, caracts. de exec do servico etc...
//
base.Description.Behaviors.Add(new ServiceMetadataBehavior()
{
HttpGetEnabled = true
});
//contratos visiveis para os clientes.. expondo os contratos disponiveis no endpoint abaixo
//contrato, forma de binding (http), endereco.. tipo: lochst..:9090/
//sHost.AddServiceEndpoint(typeof(IReportContract), new NetTcpBinding(), "svc1");
base.AddServiceEndpoint(typeof(IReportContract), new BasicHttpBinding(), "ReportService");
//expondo o WSDL do contrato a partir de um ponto http.. esta acessivel em lochst..:9090/
base.AddServiceEndpoint(typeof(IReportContract), MetadataExchangeBindings.CreateMexHttpBinding(), "ReportServiceWSDL");
//abrindo o host.. deixando o servico pronto para receber requests..
base.Open();
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
public bool ReabrirCompetencia(CompetenciaFolha competencia)
{
try
{
//verifica se a competencia é valida. se não é retorne falso
if (!IsCompetenciaValid(competencia))
{
return(false);
}
using (var ctx = new BalcaoContext())
{
var compUpdate = ctx.CompetenciaFolhaDao.Find(competencia.IdCompetencia);
compUpdate.DataFechamento = null;
//compUpdate.ValorLiquidoFechamento = compUpdate.FuncionariosCompetencia.Sum(f => f.ValorLiquido);
compUpdate.Status = TypeStatusCompetencia.EmEdicao;
var ok = ctx.CompetenciaFolhaDao.Update(compUpdate);
if (ok)
{
return(true);
}
}
return(false);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
return(false);
}
}
public bool ExcluirCompetencia(CompetenciaFolha competencia)
{
try
{
using (var ctx = new BalcaoContext())
{
foreach (var funcionario in competencia.FuncionariosCompetencia)
{
foreach (var fichaFuncionario in funcionario.FichaFinanceiraFuncionario)
{
var fichaRemover = ctx.FichaFinanceiraFuncionarioDao.Find(fichaFuncionario.IdFichaFinanFunc);
ctx.FichaFinanceiraFuncionarioDao.Delete(fichaRemover);
}
var funcRemover = ctx.FuncionarioCompetenciaDao.Find(funcionario.IdFuncionarioCompetencia);
ctx.FuncionarioCompetenciaDao.Delete(funcRemover);
}
var compRemover = ctx.CompetenciaFolhaDao.Find(competencia.IdCompetencia);
var ok = ctx.CompetenciaFolhaDao.Delete(compRemover);
if (ok)
{
return(true);
}
}
return(false);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
return(false);
}
}
private void btnSalvar_Click(object sender, EventArgs e)
{
try
{
var ctx = new BalcaoContext();
var extAdd = IndexarExtrato();
extAdd.CentroCusto = null;
extAdd.ContaBancaria = null;
extAdd.FilialExtrato = null;
if (_acao == FormTypeAction.Salvar)
{
if (ctx.ExtratoBancarioDao.Save(extAdd))
{
XMessageIts.Mensagem("Extrato incluido com sucesso!");
this.Dispose();
}
}
else //atualizar
{
var extratoUpd = ctx.ExtratoBancarioDao.Find(_extratoAnt.IdExtrato);
extratoUpd.Update(extAdd);
_extratoAnt.Update(extAdd);
if (ctx.ExtratoBancarioDao.Update(extratoUpd))
{
XMessageIts.Mensagem("Extrato atualizado com sucesso!");
this.Dispose();
}
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
private void barBtnCancelarMov_ItemClick(object sender, ItemClickEventArgs e)
{
var comp = gridViewCompetencias.GetFocusedRow <CompetenciaFolha>();
if (comp.Status == TypeStatusCompetencia.EmEdicao)
{
var msg = "Tem certeza que deseja excluir a competência selecionada? \n Este processo é irreversível.";
var manager = new FolhaDaoManager();
var confirm = XMessageIts.Confirmacao(msg);
try
{
if (confirm == DialogResult.Yes)
{
if (manager.ExcluirCompetencia(comp))
{
XMessageIts.Mensagem("Exclusão realizada com sucesso!");
}
barBtnRefresh_ItemClick(null, null);
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
else
{
XMessageIts.Advertencia("Não é possível excluir uma competência já encerrada!");
}
}
private void barBtnUpdateDll_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
OpenFileDialog op = new OpenFileDialog {
Filter = "ITE Solution|*.exe"
};
try
{
if (op.ShowDialog() == DialogResult.OK && op.FileName.EndsWith("ITE.Forms.exe"))
{
string tarjet = Path.GetDirectoryName(op.FileName);
//diretorio do diretorio
new TaskUpdateManager().UpdateSystemDLLs(null, tarjet);
XMessageIts.Mensagem("Atualização terminada !", "DLLs Atualizadas");
}
else
{
XMessageIts.Advertencia("Selecione o executavél do programa ITE Solution", "Atenção");
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
public bool UpdateTipoMovimento(TipoMovimento tpMovNovo, TipoMovimento tpMovAntiga)
{
try
{
using (var ctx = new BalcaoContext())
{
var tpMovUpdate = ctx.TipoMovimentoDao.Find(tpMovAntiga.IdTipoMovimento);
tpMovUpdate.Update(tpMovNovo);
tpMovUpdate.CentroCusto = null;
tpMovUpdate.FormaPagamento = null;
tpMovUpdate.LocalEstoque = null;
var result = ctx.TipoMovimentoDao.Update(tpMovUpdate);
if (result)
{
XMessageIts.Mensagem("Parametrização de tipo de movimento atualizada com sucesso!");
return(result);
}
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
return(false);
}
private void barBtnReabrir_ItemClick(object sender, ItemClickEventArgs e)
{
var comp = gridViewCompetencias.GetFocusedRow <CompetenciaFolha>();
if (comp.Status == TypeStatusCompetencia.Encerrada || comp.Status == TypeStatusCompetencia.EncerradaFinanceiro)
{
var msg = "Tem certeza que deseja reabrir a competência selecionada?";
var manager = new FolhaDaoManager();
var confirm = XMessageIts.Confirmacao(msg);
try
{
if (confirm == DialogResult.Yes)
{
if (manager.ReabrirCompetencia(comp))
{
XMessageIts.Mensagem("Reabertura realizada com sucesso!");
}
barBtnRefresh_ItemClick(null, null);
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
else
{
XMessageIts.Advertencia("Não é possível reabrir uma competência ainda em edição!");
}
}
public bool AddInformationUpdate(Package pacote, UpdateInfo updateInfo, AppConfigIts app)
{
try
{
using (var ctx = new AdminContext(app.ConnectionString))
{
try
{
//busca o pacote
var current = ctx.UpdateInfoDao.Where(u => u.NumeroPacote == pacote.NumeroPacote &&
u.Status == TypeStatusUpdate.Erro)
.First();
current.Update(updateInfo);
return(ctx.UpdateInfoDao.Update(current));
}
catch (Exception)
{
return(ctx.UpdateInfoDao.Save(updateInfo));
}
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex, "Falha ao inserir log de aplicação de pacote", "Aplicação de Pacote");
return(false);
}
}
private void navBarItemSelectMotorista_LinkClicked(object sender, DevExpress.XtraNavBar.NavBarLinkEventArgs e)
{
try
{
using (var ctx = new SlateContext())
{
ctx.LazyLoading(false);
var x = XFrmFindEntity.ShowDialogFindEntity <Motorista>(new ParamsFindEntity()
{
Context = ctx,
Columns = new string[] { "IdMotorista", "NomeMotorista" },
DynamicObject = _motorista,
Title = "Localizar Motorista"
});
//var x = XFrmFindEntity.ShowDiaglogFindEntity<Motorista>(ctx,
// new string[] { "IdMotorista", "NomeMotorista" }, _motorista,
// "Selecionar Motorista");
if (x != null)
{
//recupera o cliente
this._motorista = ctx.MotoristaDao.Find(x.IdMotorista);
this.lblMotorista.Text = this._motorista.NomeMotorista;
}
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
public void ExportDatabase(GridView gridView, String file)
{
try
{
//implementar
ConnectionDbf cdbf = new ConnectionDbf(file);
var dt = cdbf.GetDataTable();
var lista = DataGridViewUtil.ConvertToList <Produto>(dt);
foreach (var item in lista)
{
foreach (var c in COLUMNS)
{
//terminar
}
Console.WriteLine(item);
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
//return Task.Run(()delegate);
}
private void simpleButton1_Click(object sender, EventArgs e)
{
try
{
decimal percent = ParseUtil.ToDecimal(txtPorcetagemPromocao.Text);
var ctx = new BalcaoContext();
int vCount = list.Count;
int i = 0;
foreach (var p in list)
{
var pFind = ctx.ProdutoDao.Find(p.IdProduto);
var alteracao = new AlteracaoProduto(p.IdProduto, "P", percent, DateTime.Now,
p.PrecoVenda, p.PrecoCompra, p.QuantidadeProduto);
pFind.PrecoVenda = pFind.PrecoVenda - ((pFind.PrecoVenda * percent) / 100);
pFind.MargemLucro = pFind.CalcularMargemLucro(pFind.PrecoVenda, pFind.PrecoCompra);
pFind.AlteracoesProduto.Add(alteracao);
ctx.ProdutoDao.Update(pFind);
i++;
}
if (i == vCount)
{
XMessageIts.Mensagem("Promoção Lançada " +
"=> Devemos criar um estrategia para voltar todos os itens ao normal apos um determinado periodo");
this.Dispose();
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
public bool EncerramentoCompetencia(CompetenciaFolha competencia, bool gerarFinanceiro = false)
{
try
{
//verifica se a competencia é valida. se não é retorne falso
if (!IsCompetenciaValid(competencia))
{
return(false);
}
using (var ctx = new BalcaoContext())
{
var compUpdate = ctx.CompetenciaFolhaDao.Find(competencia.IdCompetencia);
compUpdate.DataFechamento = DateTime.Now;
compUpdate.ValorLiquidoFechamento = compUpdate.FuncionariosCompetencia.Sum(f => f.ValorLiquido);
compUpdate.Status = gerarFinanceiro == true ? TypeStatusCompetencia.EncerradaFinanceiro : TypeStatusCompetencia.Encerrada;
var ok = ctx.CompetenciaFolhaDao.Update(compUpdate);
if (ok)
{
return(true);
}
}
return(false);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
return(false);
}
}
private void barBtnFecharCompetencia_ItemClick(object sender, ItemClickEventArgs e)
{
var comp = gridViewCompetencias.GetFocusedRow <CompetenciaFolha>();
if (comp.Status == Entidades.Enumeradores.RHEnum.TypeStatusCompetencia.EmEdicao)
{
var msg = "Tem certeza que deseja encerrar a competência selecionada? \n Não será possível lançar novos eventos após o fechamento.";
var manager = new FolhaDaoManager();
var confirm = XMessageIts.Confirmacao(msg);
try
{
if (confirm == DialogResult.Yes)
{
var wiz = new XFrmWizardFinancRH(comp, userLogado, filialCurrent);
wiz.ShowDialog();
//if (manager.EncerramentoCompetencia(comp))
// XMessageIts.Mensagem("Encerramento realizado com sucesso!");
barBtnRefresh_ItemClick(null, null);
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
else
{
XMessageIts.Mensagem("Competência já encerrada. Verifique o Status da linha selecionada.");
}
}
private void navBarItemSelecionarCliente_LinkClicked(object sender, DevExpress.XtraNavBar.NavBarLinkEventArgs e)
{
try
{
using (var ctx = new BalcaoContext(false))
{
//carrega o layout dentro do projeto
var layoutStream = GridViewUtil.GetLayoutStreamFromResource(Assembly.GetExecutingAssembly(),
"ITE.Vendas.GridLayout.cliente_basico.xml");
var x = XFrmFindEntity.ShowDiaglogFindEntity <CliFor>(ctx,
new string[] { "IdCliFor", "RazaoSocial", "TipoCliente", "CpfCnpj" }, cliFor, layoutStream,
"Selecionar Cliente", addCliFor());
if (x != null)
{
//recupera o cliente
this.cliFor = ctx.CliForDao.Find(x.IdCliFor);
this.lblCliente.Text = this.cliFor.RazaoSocial.ToString();
}
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
private void btnCompensarExtrato_Click(object sender, EventArgs e)
{
try
{
var ctx = new BalcaoContext();
foreach (var extr in _extratos)
{
var extUpd = ctx.ExtratoBancarioDao.Find(extr.IdExtrato);
if (chkDtExtrato.Checked)
{
extUpd.CompensarExtrato(extr.DataExtrato);
extr.CompensarExtrato(extr.DataExtrato);
}
else
{
extUpd.CompensarExtrato(dtCompensacao.DateTime);
extr.CompensarExtrato(dtCompensacao.DateTime);
}
ctx.ExtratoBancarioDao.Update(extUpd);
}
XMessageIts.Mensagem("Extratos compensados com sucesso!");
this.Dispose();
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
/// <summary>
/// Lista somentes os diretórios do diretório informado
/// </summary>
/// <param name="pathFile"></param>
/// <returns></returns>
public static List <string> ToDirs(string pathFile)
{
if (!Directory.Exists(pathFile))
{
Console.WriteLine("Arquivo " + pathFile + " não existe.");
return(null);
}
List <String> lista = new List <String>();
try
{
//Marca o diretório a ser listado
DirectoryInfo diretorio = new DirectoryInfo(@pathFile);
//Executa função GetFile(Lista os arquivos desejados de acordo com o parametro)
var diretorios = diretorio.GetDirectories();
//Começamos a listar os arquivos
foreach (var fileinfo in diretorios)
{
lista.Add(fileinfo.FullName);
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
return(lista);
}
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);
}
}
}
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);
}
public bool PublicarPacote(Package pacote)
{
try
{
using (var ctx = new AdminContext())
{
var pkgCurrent = ctx.PackageDao.Find(pacote.IdPacote);
var pkgNew = new Package();
//passa tudo do pacote atual pro novo
pkgNew.Update(pkgCurrent);
//novo status
pkgNew.Status = Enumeradores.TypeStatusPackage.Publicado;
foreach (var anx in pacote.Anexos)
{
var anxSalvar = new AnexoPackage(anx.DataFile, anx.FileName, anx.PathFile);
pkgNew.Anexos.Add(anxSalvar);
}
var bytes = SerializeIts.SerializeObject(pkgNew);
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = "IT Solution package| *.itspkg";
//sfd.FilterIndex = 0;
//sfd.DefaultExt = ".itsPkg";
sfd.FileName = "ITS_Package_" + pkgNew.NumeroPacote;
var op = sfd.ShowDialog();
if (op == DialogResult.OK)
{
if (FileManagerIts.WriteBytesToFile(sfd.FileName, bytes))
{
//publicar o pacote
pkgCurrent.Publish(DateTime.Now, bytes);
var transation = ctx.PackageDao.Update(pkgCurrent);
if (transation)
{
XMessageIts.Mensagem("Pacote publicado com sucesso!");
pacote.Update(pkgCurrent);
return(transation);
}
}
}
return(false);
}
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex, "Falha ao publicar pacote", "Publicação de Pacote");
return(false);
}
}
/// <summary>
/// Ação de Login para RbbFrmLogin
/// Verifica se o usuário existe no banco de dados
/// </summary>
/// <returns></returns>
public bool Login(string logon, string senha)
{
try
{
Usuario user = null;
//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 (StringUtilIts.IsContainsLetters(logon))
{
//busca o User com a senha codificada
user = ctx.UsuarioDao
.Where(u => u.NomeUtilizador == logon && u.Senha == result)
.FirstOrDefault();
}
else
{
//tente pelo ID
var id = ParseUtil.ToInt(logon);
user = ctx.UsuarioDao
.Where(u => u.IdUsuario == id && u.Senha == result).FirstOrDefault();
}
if (!this.XFrmLogin.IsDisposed)
{
this.XFrmLogin.Dispose();
}
//True Valido
//False invalido
var isLogado = user != null;
if (isLogado)
{
this.XFrmLogin.UserName = user.NomeUsuario;
}
return(isLogado);
}
}
catch (System.Reflection.TargetInvocationException ex)
{
XMessageIts.ExceptionMessage(ex);
return(false);
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
return(false);
}
}
private void btnMath_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
try
{
//ITSTools.OpenConnection<IMath>("Servers.Math.MathController").TestConnection();
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}
public FolhaDaoManager(string idTask) : this()
{
try
{
var ctx = SchedulerContextGeneric <TaskIts> .Instance;
var ts = ctx.Dao.Find(idTask);
this.itsTask = ts;
}
catch (Exception ex)
{
XMessageIts.ExceptionMessage(ex);
}
}