Beispiel #1
0
        public IActionResult Consultar([FromBody] LogTransfer logDados)
        {
            LogModel    logModel;
            LogTransfer logRetorno;

            try {
                logModel = new LogModel();

                logRetorno = logModel.Listar(logDados);
            } catch (Exception ex) {
                logRetorno = new LogTransfer();

                logRetorno.Erro = true;
                logRetorno.IncluirMensagem("Erro em LogController Consultar [" + ex.Message + "]");
            } finally {
                logModel = null;
            }

            logRetorno.TratarLinks();

            if (logRetorno.Erro || !logRetorno.Validacao)
            {
                return(BadRequest(logRetorno));
            }
            else
            {
                return(Ok(logRetorno));
            }
        }
Beispiel #2
0
        public async Task <IActionResult> Consulta(LogTransfer pLog)
        {
            ViewData["Usuario"] = UsuarioNome;

            LogModel logModel = new LogModel(httpContext);

            LogTransfer logRes = new LogTransfer();

            logRes = await logModel.Consultar(pLog);

            return(View(logRes));
        }
Beispiel #3
0
        // public async Task<LogTransfer> Incluir(LogTransfer logTransfer, string pAutorizacao)
        // {
        //     LogTransfer log = null;
        //     HttpResponseMessage resposta = null;
        //     string mensagemRetono = null;

        //     try {
        //         httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", pAutorizacao);

        //         resposta = await httpClient.PostAsync($"{nomeServico}", new StringContent(JsonConvert.SerializeObject(logTransfer)));

        //         if (resposta.IsSuccessStatusCode) {
        //             log = JsonConvert.DeserializeObject<LogTransfer>(resposta.Content.ReadAsStringAsync().Result);
        //         } else if (resposta.StatusCode == HttpStatusCode.BadRequest) {
        //             log = JsonConvert.DeserializeObject<LogTransfer>(resposta.Content.ReadAsStringAsync().Result);
        //         } else if (resposta.StatusCode == HttpStatusCode.Unauthorized) {
        //             mensagemRetono = $"Acesso ao serviço {nomeServico} Incluir não autorizado";
        //         } else {
        //             mensagemRetono = $"Não foi possível acessar o serviço {nomeServico} Incluir";
        //         }

        //         if (!string.IsNullOrEmpty(mensagemRetono)) {
        //             log = new LogTransfer();

        //             log.Validacao = false;
        //             log.Erro = true;
        //             log.IncluirMensagem(mensagemRetono);
        //         }
        //     } catch (Exception ex) {
        //         log = new LogTransfer();

        //         log.Validacao = false;
        //         log.Erro = true;
        //         log.IncluirMensagem("Erro em LogService Incluir [" + ex.Message + "]");
        //     } finally {
        //         resposta = null;
        //     }

        //     return log;
        // }

        // public async Task<LogTransfer> Alterar(LogTransfer logTransfer, string pAutorizacao)
        // {
        //     LogTransfer log = null;
        //     HttpResponseMessage resposta = null;
        //     string mensagemRetono = null;

        //     try {
        //         httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", pAutorizacao);

        //         resposta = await httpClient.PutAsync($"{nomeServico}", new StringContent(JsonConvert.SerializeObject(logTransfer)));

        //         if (resposta.IsSuccessStatusCode) {
        //             log = JsonConvert.DeserializeObject<LogTransfer>(resposta.Content.ReadAsStringAsync().Result);
        //         } else if (resposta.StatusCode == HttpStatusCode.BadRequest) {
        //             log = JsonConvert.DeserializeObject<LogTransfer>(resposta.Content.ReadAsStringAsync().Result);
        //         } else if (resposta.StatusCode == HttpStatusCode.Unauthorized) {
        //             mensagemRetono = $"Acesso ao serviço {nomeServico} Alterar não autorizado";
        //         } else {
        //             mensagemRetono = $"Não foi possível acessar o serviço {nomeServico} Alterar";
        //         }

        //         if (!string.IsNullOrEmpty(mensagemRetono)) {
        //             log = new LogTransfer();

        //             log.Validacao = false;
        //             log.Erro = true;
        //             log.IncluirMensagem(mensagemRetono);
        //         }
        //     } catch (Exception ex) {
        //         log = new LogTransfer();

        //         log.Validacao = false;
        //         log.Erro = true;
        //         log.IncluirMensagem("Erro em LogService Alterar [" + ex.Message + "]");
        //     } finally {
        //         resposta = null;
        //     }

        //     return log;
        // }

        // public async Task<LogTransfer> Excluir(int pId, string pAutorizacao)
        // {
        //     LogTransfer log = null;
        //     HttpResponseMessage resposta = null;
        //     string mensagemRetono = null;

        //     try {
        //         httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", pAutorizacao);

        //         resposta = await httpClient.DeleteAsync($"{nomeServico}/{pId}");

        //         if (resposta.IsSuccessStatusCode) {
        //             log = JsonConvert.DeserializeObject<LogTransfer>(resposta.Content.ReadAsStringAsync().Result);
        //         } else if (resposta.StatusCode == HttpStatusCode.BadRequest) {
        //             log = JsonConvert.DeserializeObject<LogTransfer>(resposta.Content.ReadAsStringAsync().Result);
        //         } else if (resposta.StatusCode == HttpStatusCode.Unauthorized) {
        //             mensagemRetono = $"Acesso ao serviço {nomeServico} Excluir não autorizado";
        //         } else {
        //             mensagemRetono = $"Não foi possível acessar o serviço {nomeServico} Excluir";
        //         }

        //         if (!string.IsNullOrEmpty(mensagemRetono)) {
        //             log = new LogTransfer();

        //             log.Validacao = false;
        //             log.Erro = true;
        //             log.IncluirMensagem(mensagemRetono);
        //         }
        //     } catch (Exception ex) {
        //         log = new LogTransfer();

        //         log.Validacao = false;
        //         log.Erro = true;
        //         log.IncluirMensagem("Erro em LogService Excluir [" + ex.Message + "]");
        //     } finally {
        //         resposta = null;
        //     }

        //     return log;
        // }

        // public async Task<LogTransfer> ConsultarPorId(int pId, string pAutorizacao)
        // {
        //     LogTransfer log = null;
        //     HttpResponseMessage resposta = null;
        //     string mensagemRetono = null;

        //     try {
        //         httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", pAutorizacao);

        //         resposta = await httpClient.GetAsync($"{nomeServico}/{pId}");

        //         if (resposta.IsSuccessStatusCode) {
        //             log = JsonConvert.DeserializeObject<LogTransfer>(resposta.Content.ReadAsStringAsync().Result);
        //         } else if (resposta.StatusCode == HttpStatusCode.BadRequest) {
        //             log = JsonConvert.DeserializeObject<LogTransfer>(resposta.Content.ReadAsStringAsync().Result);
        //         } else if (resposta.StatusCode == HttpStatusCode.Unauthorized) {
        //             mensagemRetono = $"Acesso ao serviço {nomeServico} ConsultarPorId não autorizado";
        //         } else {
        //             mensagemRetono = $"Não foi possível acessar o serviço {nomeServico} ConsultarPorId";
        //         }

        //         if (!string.IsNullOrEmpty(mensagemRetono)) {
        //             log = new LogTransfer();

        //             log.Validacao = false;
        //             log.Erro = true;
        //             log.IncluirMensagem(mensagemRetono);
        //         }
        //     } catch (Exception ex) {
        //         log = new LogTransfer();

        //         log.Validacao = false;
        //         log.Erro = true;
        //         log.IncluirMensagem("Erro em LogService ConsultarPorId [" + ex.Message + "]");
        //     } finally {
        //         resposta = null;
        //     }

        //     return log;
        // }

        public async Task <LogTransfer> Consultar(LogTransfer pLogLista, string pAutorizacao)
        {
            LogTransfer         logLista = null;
            HttpResponseMessage resposta = null;
            string mensagemRetono        = null;

            try {
                httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", pAutorizacao);

                HttpContent content = new StringContent(JsonConvert.SerializeObject(pLogLista), Encoding.UTF8, "application/json");

                resposta = await httpClient.PostAsync($"{nomeServico}/lista", content);

                if (resposta.IsSuccessStatusCode)
                {
                    logLista = JsonConvert.DeserializeObject <LogTransfer>(resposta.Content.ReadAsStringAsync().Result);
                }
                else if (resposta.StatusCode == HttpStatusCode.BadRequest)
                {
                    logLista = JsonConvert.DeserializeObject <LogTransfer>(resposta.Content.ReadAsStringAsync().Result);
                }
                else if (resposta.StatusCode == HttpStatusCode.Unauthorized)
                {
                    mensagemRetono = $"Acesso ao serviço {nomeServico} Consultar não autorizado";
                }
                else
                {
                    mensagemRetono = $"Não foi possível acessar o serviço {nomeServico} Consultar";
                }

                if (!string.IsNullOrEmpty(mensagemRetono))
                {
                    logLista = new LogTransfer();

                    logLista.Validacao = false;
                    logLista.Erro      = true;
                    logLista.IncluirMensagem(mensagemRetono);
                }
            } catch (Exception ex) {
                logLista = new LogTransfer();

                logLista.Validacao = false;
                logLista.Erro      = true;
                logLista.IncluirMensagem("Erro em LogService Consultar [" + ex.Message + "]");
            } finally {
                resposta = null;
            }

            return(logLista);
        }
Beispiel #4
0
        // public LogTransfer Incluir(LogTransfer logTransfer)
        // {
        //     LogData logData;
        //     LogTransfer cor;

        //     try {
        //         logData = new LogData(_contexto);
        //         cor = new LogTransfer(logTransfer);

        //         logData.Incluir(logTransfer.Cor);

        //         _contexto.SaveChanges();

        //         cor.Cor = new CorEntity(logTransfer.Cor);
        //         cor.Validacao = true;
        //         cor.Erro = false;
        //     } catch (Exception ex) {
        //         cor = new LogTransfer();

        //         cor.Validacao = false;
        //         cor.Erro = true;
        //         cor.IncluirMensagem("Erro em LogDataModel Incluir [" + ex.Message + "]");
        //     } finally {
        //         logData = null;
        //     }

        //     return cor;
        // }

        // public LogTransfer Alterar(LogTransfer logTransfer)
        // {
        //     LogData logData;
        //     LogTransfer cor;

        //     try {
        //         logData = new LogData(_contexto);
        //         cor = new LogTransfer();

        //         logData.Alterar(logTransfer.Cor);

        //         _contexto.SaveChanges();

        //         cor.Cor = new CorEntity(logTransfer.Cor);
        //         cor.Validacao = true;
        //         cor.Erro = false;
        //     } catch (Exception ex) {
        //         cor = new LogTransfer();

        //         cor.Validacao = false;
        //         cor.Erro = true;
        //         cor.IncluirMensagem("Erro em LogDataModel Alterar [" + ex.Message + "]");
        //     } finally {
        //         logData = null;
        //     }

        //     return cor;
        // }

        // public LogTransfer Excluir(int id)
        // {
        //     LogData logData;
        //     LogTransfer cor;

        //     try {
        //         logData = new LogData(_contexto);
        //         cor = new LogTransfer();

        //         cor.Cor = logData.ConsultarPorId(id);
        //         logData.Excluir(cor.Cor);

        //         _contexto.SaveChanges();

        //         cor.Validacao = true;
        //         cor.Erro = false;
        //     } catch (Exception ex) {
        //         cor = new LogTransfer();

        //         cor.Validacao = false;
        //         cor.Erro = true;
        //         cor.IncluirMensagem("Erro em LogDataModel Excluir [" + ex.Message + "]");
        //     } finally {
        //         logData = null;
        //     }

        //     return cor;
        // }

        // public LogTransfer ConsultarPorId(int id)
        // {
        //     LogData logData;
        //     LogTransfer cor;

        //     try {
        //         logData = new LogData(_contexto);
        //         cor = new LogTransfer();

        //         cor.Cor = logData.ConsultarPorId(id);
        //         cor.Validacao = true;
        //         cor.Erro = false;
        //     } catch (Exception ex) {
        //         cor = new LogTransfer();

        //         cor.Validacao = false;
        //         cor.Erro = true;
        //         cor.IncluirMensagem("Erro em LogDataModel ConsultarPorId [" + ex.Message + "]");
        //     } finally {
        //         logData = null;
        //     }

        //     return cor;
        // }

        public LogTransfer Listar(LogTransfer logDados)
        {
            LogData     logData;
            LogTransfer logRetorno;

            try {
                logData = new LogData(db);

                logRetorno = logData.Listar(logDados);

                db.ConfirmarTransacao();
            } catch (Exception ex) {
                logRetorno = new LogTransfer();

                logRetorno.Validacao = false;
                logRetorno.Erro      = true;
                logRetorno.IncluirMensagem("Erro em LogDataModel Consultar [" + ex.Message + "]");
            } finally {
                logData = null;
            }

            return(logRetorno);
        }
Beispiel #5
0
        public LogTransfer Listar(LogTransfer logDados)
        {
            DbDataReader dr  = null;
            LogTransfer  ret = null;
            LogComando   cmd = db.Comando();

            int pular = 0;
            int registrosPorPagina = 0;
            int totalRegistros     = 0;

            if (logDados.Paginacao.RegistrosPorPagina < 1)
            {
                registrosPorPagina = 30;
            }
            else if (logDados.Paginacao.RegistrosPorPagina > 200)
            {
                registrosPorPagina = 30;
            }
            else
            {
                registrosPorPagina = logDados.Paginacao.RegistrosPorPagina;
            }

            pular  = (logDados.Paginacao.PaginaAtual < 2 ? 0 : logDados.Paginacao.PaginaAtual - 1);
            pular *= registrosPorPagina;

            string sqlSelect     = $"SELECT l.*, qq.qtd AS qtd_query FROM Log l ";
            string sqlWhere      = "";
            string sqlJoin       = "CROSS JOIN (";
            string sqlSelectJoin = "SELECT Count(*) AS qtd FROM Log ";
            string sqlOrder      = ") AS qq ORDER BY l.id ";
            string sqlPaginacao  = "OFFSET " + pular + " ROWS FETCH NEXT " + registrosPorPagina + " ROWS ONLY";

            string sqlComando = sqlSelect + sqlWhere + sqlJoin + sqlSelectJoin + sqlWhere + sqlOrder + sqlPaginacao;

            cmd.Comando(sqlComando);

            dr = cmd.ExecutarComandoLista();

            if (dr != null)
            {
                ret = new LogTransfer();

                if (dr.HasRows)
                {
                    while (dr.Read())
                    {
                        LogEntity log = new LogEntity();

                        log.Sistema  = Conversao.RetornarString(dr["sistema"]);
                        log.Data     = Conversao.RetornarInt32(dr["data"]);
                        log.Hora     = Conversao.RetornarInt32(dr["hora"]);
                        log.Controle = Conversao.RetornarString(dr["controle"]);
                        log.Ip       = Conversao.RetornarString(dr["ip"]);
                        log.Tipo     = Conversao.RetornarInt32(dr["tipo"]);
                        log.Mensagem = Conversao.RetornarString(dr["mensagem"]);
                        log.Pilha    = Conversao.RetornarString(dr["pilha"]);
                        log.Origem   = Conversao.RetornarString(dr["origem"]);
                        log.Critico  = Conversao.RetornarBoolean(dr["critico"]);

                        totalRegistros = Conversao.RetornarInt32(dr["qtd_query"]);

                        ret.Incluir(log);
                    }

                    ret.Paginacao.RegistrosPorPagina = registrosPorPagina;
                    ret.Paginacao.TotalRegistros     = totalRegistros;
                }
            }

            dr.Dispose();

            return(ret);
        }
Beispiel #6
0
        // public LogTransfer Incluir(LogTransfer pLog)
        // {
        //     // LogDataModel logDataModel;
        //     LogTransfer logValidacao;
        //     LogTransfer logInclusao;

        //     try {
        //         // logBusiness = new LogBusiness();
        //         // logDataModel = new LogDataModel();

        //         // logValidacao = logBusiness.Validar(pLog);
        //         logValidacao = new LogTransfer();

        //         if (!logValidacao.Erro) {
        //             if (logValidacao.Validacao) {
        //                 // logInclusao = logDataModel.Incluir(logValidacao);
        //                 logInclusao = new LogTransfer();
        //             } else {
        //                 logInclusao = new LogTransfer(logValidacao);
        //             }
        //         } else {
        //             logInclusao = new LogTransfer(logValidacao);
        //         }
        //     } catch (Exception ex) {
        //         logInclusao = new LogTransfer();

        //         logInclusao.Validacao = false;
        //         logInclusao.Erro = true;
        //         logInclusao.IncluirMensagem("Erro em LogModel Incluir [" + ex.Message + "]");
        //     } finally {
        //         // logDataModel = null;
        //         // logBusiness = null;
        //         logValidacao = null;
        //     }

        //     return logInclusao;
        // }

        // public LogTransfer Alterar(LogTransfer pLog)
        // {
        //     // LogDataModel logDataModel;
        //     // LogBusiness logBusiness;
        //     LogTransfer logValidacao;
        //     LogTransfer logAlteracao;

        //     try {
        //         // logBusiness = new LogBusiness();
        //         // logDataModel = new LogDataModel();

        //         // logValidacao = logBusiness.Validar(pLog);
        //         logValidacao = new LogTransfer();

        //         if (!logValidacao.Erro) {
        //             if (logValidacao.Validacao) {
        //                 // logAlteracao = logDataModel.Alterar(logValidacao);
        //                 logAlteracao = new LogTransfer();
        //             } else {
        //                 logAlteracao = new LogTransfer(logValidacao);
        //             }
        //         } else {
        //             logAlteracao = new LogTransfer(logValidacao);
        //         }
        //     } catch (Exception ex) {
        //         logAlteracao = new LogTransfer();

        //         logAlteracao.Validacao = false;
        //         logAlteracao.Erro = true;
        //         logAlteracao.IncluirMensagem("Erro em LogModel Alterar [" + ex.Message + "]");
        //     } finally {
        //         // logDataModel = null;
        //         // logBusiness = null;
        //         logValidacao = null;
        //     }

        //     return logAlteracao;
        // }

        // public LogTransfer Excluir(int pId)
        // {
        //     // LogDataModel logDataModel;
        //     LogTransfer log;

        //     try {
        //         // logDataModel = new LogDataModel();

        //         // log = logDataModel.Excluir(pId);
        //         log = new LogTransfer();
        //     } catch (Exception ex) {
        //         log = new LogTransfer();

        //         log.Validacao = false;
        //         log.Erro = true;
        //         log.IncluirMensagem("Erro em LogModel Excluir [" + ex.Message + "]");
        //     } finally {
        //         // logDataModel = null;
        //     }

        //     return log;
        // }

        // public LogTransfer ConsultarPorId(int pId)
        // {
        //     // LogDataModel logDataModel;
        //     LogTransfer log;

        //     try {
        //         // logDataModel = new LogDataModel();

        //         // log = logDataModel.ConsultarPorId(pId);
        //         log = new LogTransfer();
        //     } catch (Exception ex) {
        //         log = new LogTransfer();

        //         log.Validacao = false;
        //         log.Erro = true;
        //         log.IncluirMensagem("Erro em LogModel ConsultarPorId [" + ex.Message + "]");
        //     } finally {
        //         // logDataModel = null;
        //     }

        //     return log;
        // }

        public LogTransfer Listar(LogTransfer logDados)
        {
            LogDataModel logDataModel;
            LogTransfer  logValidacao;
            LogTransfer  logRetorno;

            try {
                logDataModel = new LogDataModel();

                logValidacao = new LogTransfer(logDados);

                if (!logValidacao.Erro)
                {
                    if (logValidacao.Validacao)
                    {
                        logRetorno = logDataModel.Listar(logValidacao);

                        if (logRetorno != null)
                        {
                            if (logRetorno.Paginacao.TotalRegistros > 0)
                            {
                                if (logRetorno.Paginacao.RegistrosPorPagina < 1)
                                {
                                    logRetorno.Paginacao.RegistrosPorPagina = 30;
                                }
                                else if (logRetorno.Paginacao.RegistrosPorPagina > 200)
                                {
                                    logRetorno.Paginacao.RegistrosPorPagina = 30;
                                }
                                logRetorno.Paginacao.PaginaAtual  = (logDados.Paginacao.PaginaAtual < 1 ? 1 : logDados.Paginacao.PaginaAtual);
                                logRetorno.Paginacao.TotalPaginas =
                                    Convert.ToInt32(Math.Ceiling(Convert.ToDecimal(logRetorno.Paginacao.TotalRegistros)
                                                                 / @Convert.ToDecimal(logRetorno.Paginacao.RegistrosPorPagina)));
                                if (logRetorno.Paginacao.PaginaAtual > logRetorno.Paginacao.TotalPaginas)
                                {
                                    logRetorno.Paginacao.PaginaAtual = logRetorno.Paginacao.TotalPaginas;
                                }
                            }
                        }
                    }
                    else
                    {
                        logRetorno = new LogTransfer(logValidacao);
                    }
                }
                else
                {
                    logRetorno = new LogTransfer(logValidacao);
                }
            } catch (Exception ex) {
                logRetorno = new LogTransfer();

                logRetorno.Validacao = false;
                logRetorno.Erro      = true;
                logRetorno.IncluirMensagem("Erro em LogModel Consultar [" + ex.Message + "]");
            } finally {
                logDataModel = null;
                logValidacao = null;
            }

            return(logRetorno);
        }
        /// <summary>
        /// Loads a form to the panel
        /// </summary>
        /// <param name="tag">The tag of the button - Here is stored what type of form is supposed to be opened</param>
        private void LoadForm(string tag)
        {
            var yEnd = new YearEnd();

            if (yEnd.InventoryRequired(false))
            {
                switch (VisibilitySetting.HandleUnits)
                {
                case 1:
                    yEnd.GenerateAutomaticInventory();
                    break;

                case 2:
                    yEnd.GenerateAutomaticInventoryByUnit();
                    break;

                case 3:
                    yEnd.GenerateAutomaticInventoryByUnit();
                    break;
                }
            }

            Form frm;

            switch (tag)
            {
            case "Receives":
                frm = new ReceivingForm();
                AddTab("Receiving Form", frm);
                break;

            case "Issues":
                frm = new IssueForm();
                AddTab("Issue Form", frm);
                break;

            case "AMCs":
                frm = new AMCView();
                AddTab("AMC Report", frm);
                break;

            case "menuItemPriceOnlyReport":
                frm = new ItemPriceOnlyReport();
                AddTab("Item Price Only", frm);
                break;

            case "Facility Settings":
                frm = new Hospital();
                AddTab("Facility Settings", frm);
                break;

            case "Drug List":
                frm = new ManageItems();
                AddTab("Manage Drug List", frm);
                break;

            case "Supplies List":
                //frm = new ManageItems();
                frm = new ManageSupplies();
                AddTab("Manage Supplies List", frm);
                break;

            case "Item Consolidator":
                //frm = new ManageItems();
                frm = new ItemConsolidator();
                AddTab("Update Items List From The Directory Service", frm);
                break;

            case "Customize Druglist":
                frm = new CustomDrugList();
                AddTab("Customize Drug List", frm);
                break;

            case "System Settings":
                frm = new SystemSetting();
                AddTab("System Settings", frm);
                break;

            case "Facility Details":
                frm = new HospitalSettings();
                AddTab("Facility Details", frm);
                break;

            case "User Accounts":
                frm = new UserAccounts();
                AddTab("Manage Users", frm);
                break;

            case "Pipeline":
                frm = new Pipeline();
                AddTab("Pipeline", frm);
                break;

            case "Change Password":
                frm = new ChangePassword(UserId);
                AddTab("Change Password", frm);
                break;

            case "Transfer Log":
                frm = new LogTransfer();
                AddTab("Transfer Log", frm);
                break;


            case "VRF Form":
                frm = new vrfmainForm();
                AddTab("Vaccine Requistion and Report Form", frm);
                break;

            case "Losses/Adjustment":
                frm = new LossesAdjustment();
                AddTab("Losses and Adjustment", frm);
                break;

            case "Receive Log":
                frm = new LogReceive();
                AddTab("Receive Transaction Log", frm);
                break;

            case "Issue Log":
                frm = new LogIssues();
                AddTab("Issue Transaction Log", frm);
                break;

            case "Adjustment Log":
                frm = new LogAdjustment();
                AddTab("Loss / Adjustment Transaction Log", frm);
                break;

            case "Inventory Log":
                frm = new LogInventory();
                AddTab("Inventory Log", frm);
                break;

            case "Stock Status":
                frm = new ItemReport();
                AddTab("Stock Status", frm);
                break;

            case "Over Stocked":
                frm = new OtherItemReport("Over Stocked");
                AddTab("Over Stock Items", frm);
                break;

            case "Transfers":
                frm = new TransferForm();
                AddTab("Transfer Form", frm);
                break;

            case "Stock Out":
                frm = new OtherItemReport("Stock Out");
                AddTab("Stocked Out Items", frm);
                break;

            case "ConsumptionTrend":
                frm = new ConsumptionTrendReport();
                AddTab("Consumption Trend", frm);
                break;

            case "Issues By Receiving Unit":
                frm = new IssuesByDep();
                AddTab("Issues By Receiving Unit", frm);
                break;

            case "Expired Products":
                frm = new ExpiredProducts();
                AddTab("Expired Products", frm);
                break;

            case "Near Expiry":
                frm = new NearlyExpired();
                AddTab("Near Expiry Products", frm);
                break;

            case "SOH Trend":
                frm = new SOHTrend();
                AddTab("SOH Trend", frm);
                break;

            case "Receive Trend":
                frm = new ReceiveTrend();
                AddTab("Receive Trend", frm);
                break;

            case "Balance":
                frm = new BalanceReport();
                AddTab("Balance", frm);
                break;

            case "Summary Report":
                frm = new GeneralReport();
                AddTab("Summary Report", frm);
                break;

            case "Cost Summary":
                frm = new GeneralCostChart();
                AddTab("Cost Summary", frm);
                break;

            case "Wastage Rate":
                frm = new WastageRate();
                AddTab("Wastage Rate", frm);
                break;

            case "Summary Chart":
                frm = new GeneralChart();
                AddTab("General Chart", frm);
                break;

            case "Activity Log Reports":
                frm = new ActivityLogReports();
                AddTab("Activity Log", frm);
                break;

            case "ECLS":
                frm = new ECLS();
                AddTab("CS Stock Status", frm);
                break;

            case "Year End Process":
                frm = new YearEndProcess();
                AddTab("Inventory", frm);
                break;

            case "Default Year End Process":
                frm = new YearEndProcess(true);
                AddTab("Inventory", frm);
                break;

            case "Stock Expiry Status":
                frm = new GeneralExpiryChart();
                AddTab("Stock Status", frm);
                break;

            case "DataBase":
                frm = new DatabaseActions();
                AddTab("Database Actions", frm);
                break;

            case "PDA":
                frm = new ItemReport();
                AddTab("Stock Status", frm);
                break;

            case "Consumables List":
                frm = new ManageSupplies();
                AddTab("Supplies List", frm);
                break;

            case "RRF Form":
                frm = new RRFForm();
                AddTab("Report and Requisition Form", frm);
                break;

            case "LossReport":
                frm = new ExpiredProductsReport();
                AddTab("Loss / Adjustment Reporting View", frm);
                break;

            case "CostReport":
                frm = new CostReport();
                AddTab("Cost Report", frm);
                break;

            case "ConsumptionByUnit":
                frm = new ConsumptionByUnits();
                AddTab("Consumption By Dispensary Unit", frm);
                break;

            case "About":
                Program.ShowHCMISVersionInfoMessageBox();
                break;
            }
        }
Beispiel #8
0
        // public async Task<LogTransfer> Incluir(LogTransfer logTransfer)
        // {
        //     LogService logService;
        //     LogTransfer cor;
        //     AutenticaModel autenticaModel;
        //     string autorizacao;

        //     try {
        //         logService = new LogService();
        //         autenticaModel = new AutenticaModel(httpContext);

        //         autorizacao = autenticaModel.ObterToken();

        //         cor = await logService.Incluir(logTransfer, autorizacao);
        //     } catch (Exception ex) {
        //         cor = new LogTransfer();

        //         cor.Validacao = false;
        //         cor.Erro = true;
        //         cor.IncluirMensagem("Erro em LogModel Incluir [" + ex.Message + "]");
        //     } finally {
        //         logService = null;
        //         autenticaModel = null;
        //     }

        //     return cor;
        // }

        // public async Task<LogTransfer> Alterar(LogTransfer logTransfer)
        // {
        //     LogService logService;
        //     LogTransfer cor;
        //     AutenticaModel autenticaModel;
        //     string autorizacao;

        //     try {
        //         logService = new LogService();
        //         autenticaModel = new AutenticaModel(httpContext);

        //         autorizacao = autenticaModel.ObterToken();

        //         cor = await logService.Alterar(logTransfer, autorizacao);
        //     } catch (Exception ex) {
        //         cor = new LogTransfer();

        //         cor.Validacao = false;
        //         cor.Erro = true;
        //         cor.IncluirMensagem("Erro em LogModel Alterar [" + ex.Message + "]");
        //     } finally {
        //         logService = null;
        //         autenticaModel = null;
        //     }

        //     return cor;
        // }

        // public async Task<LogTransfer> Excluir(int pId)
        // {
        //     LogService logService;
        //     LogTransfer cor;
        //     AutenticaModel autenticaModel;
        //     string autorizacao;

        //     try {
        //         logService = new LogService();
        //         autenticaModel = new AutenticaModel(httpContext);

        //         autorizacao = autenticaModel.ObterToken();

        //         cor = await logService.Excluir(pId, autorizacao);
        //     } catch (Exception ex) {
        //         cor = new LogTransfer();

        //         cor.Validacao = false;
        //         cor.Erro = true;
        //         cor.IncluirMensagem("Erro em LogModel Excluir [" + ex.Message + "]");
        //     } finally {
        //         logService = null;
        //         autenticaModel = null;
        //     }

        //     return cor;
        // }

        // public async Task<LogTransfer> ConsultarPorId(int pId)
        // {
        //     LogService logService;
        //     LogTransfer cor;
        //     AutenticaModel autenticaModel;
        //     string autorizacao;

        //     try {
        //         logService = new LogService();
        //         autenticaModel = new AutenticaModel(httpContext);

        //         autorizacao = autenticaModel.ObterToken();

        //         cor = await logService.ConsultarPorId(pId, autorizacao);
        //     } catch (Exception ex) {
        //         cor = new LogTransfer();

        //         cor.Validacao = false;
        //         cor.Erro = true;
        //         cor.IncluirMensagem("Erro em LogModel ConsultarPorId [" + ex.Message + "]");
        //     } finally {
        //         logService = null;
        //         autenticaModel = null;
        //     }

        //     return cor;
        // }

        public async Task <LogTransfer> Consultar(LogTransfer pLogLista)
        {
            LogService     logService;
            LogTransfer    logLista;
            AutenticaModel autenticaModel;
            string         autorizacao;
            int            dif      = 0;
            int            qtdExibe = 5;

            try {
                logService     = new LogService();
                autenticaModel = new AutenticaModel(httpContext);

                autorizacao = autenticaModel.ObterToken();

                logLista = await logService.Consultar(pLogLista, autorizacao);

                if (logLista != null)
                {
                    if (logLista.Paginacao.TotalRegistros > 0)
                    {
                        if (logLista.Paginacao.RegistrosPorPagina < 1)
                        {
                            logLista.Paginacao.RegistrosPorPagina = 30;
                        }
                        else if (logLista.Paginacao.RegistrosPorPagina > 200)
                        {
                            logLista.Paginacao.RegistrosPorPagina = 30;
                        }

                        logLista.Paginacao.PaginaAtual  = (logLista.Paginacao.PaginaAtual < 1 ? 1 : logLista.Paginacao.PaginaAtual);
                        logLista.Paginacao.TotalPaginas =
                            Convert.ToInt32(Math.Ceiling(Convert.ToDecimal(logLista.Paginacao.TotalRegistros)
                                                         / @Convert.ToDecimal(logLista.Paginacao.RegistrosPorPagina)));
                        logLista.Paginacao.TotalPaginas = (logLista.Paginacao.TotalPaginas < 1 ? 1 : logLista.Paginacao.TotalPaginas);
                        if (logLista.Paginacao.PaginaAtual > logLista.Paginacao.TotalPaginas)
                        {
                            logLista.Paginacao.PaginaAtual = logLista.Paginacao.TotalPaginas;
                        }

                        qtdExibe = (qtdExibe > logLista.Paginacao.TotalPaginas ? logLista.Paginacao.TotalPaginas : qtdExibe);

                        logLista.Paginacao.PaginaInicial = logLista.Paginacao.PaginaAtual - (Convert.ToInt32(Math.Floor(qtdExibe / 2.0)));
                        logLista.Paginacao.PaginaFinal   = logLista.Paginacao.PaginaAtual + (Convert.ToInt32(Math.Floor(qtdExibe / 2.0)));
                        logLista.Paginacao.PaginaFinal   = ((qtdExibe % 2) == 0 ? (logLista.Paginacao.PaginaFinal - 1) : logLista.Paginacao.PaginaFinal);

                        if (logLista.Paginacao.PaginaInicial < 1)
                        {
                            dif = 1 - logLista.Paginacao.PaginaInicial;
                            logLista.Paginacao.PaginaInicial += dif;
                            logLista.Paginacao.PaginaFinal   += dif;
                        }

                        if (logLista.Paginacao.PaginaFinal > logLista.Paginacao.TotalPaginas)
                        {
                            dif = logLista.Paginacao.PaginaFinal - logLista.Paginacao.TotalPaginas;
                            logLista.Paginacao.PaginaInicial -= dif;
                            logLista.Paginacao.PaginaFinal   -= dif;
                        }

                        logLista.Paginacao.PaginaInicial = (logLista.Paginacao.PaginaInicial < 1 ? 1 : logLista.Paginacao.PaginaInicial);
                        logLista.Paginacao.PaginaFinal   = (logLista.Paginacao.PaginaFinal > logLista.Paginacao.TotalPaginas ?
                                                            logLista.Paginacao.TotalPaginas : logLista.Paginacao.PaginaFinal);
                    }
                }
            } catch (Exception ex) {
                logLista = new LogTransfer();

                logLista.Validacao = false;
                logLista.Erro      = true;
                logLista.IncluirMensagem("Erro em LogModel Consultar [" + ex.Message + "]");
            } finally {
                logService     = null;
                autenticaModel = null;
            }

            return(logLista);
        }