/// <summary>
 /// Adiciona uma auditoria a lista de auditorias
 /// </summary>
 /// <param name="p">Perfil</param>
 /// <param name="a">Auditoria</param>
 /// <returns></returns>
 public static bool AddAudit(Perfil p, auditoriaBO a)
 {
     if (p == Perfil.CHEFE || p == Perfil.COLABORADOR)
     {
         try
         {
             bool        b;
             AuditoriaDL aux = new AuditoriaDL(a);
             b = Auditorias.AdicionaAuditoria(aux);
             if (b)
             {
                 return(true);
             }
             else
             {
                 Console.WriteLine("A auditoria ja se encontra na lista de auditorias.\n");
                 return(false);
             }
         }
         catch (ArgumentNullException e)
         {
             Console.WriteLine("Error: " + e.Message);
         }
         catch (Exception e)
         {
             Console.WriteLine("Error: " + e.Message);
         }
     }
     return(false);
 }
 /// <summary>
 /// Edita a data de uma auditoria
 /// </summary>
 /// <param name="p">Perfil</param>
 /// <param name="codigoAud">Codigo da Auditoria</param>
 /// <param name="dt">Data</param>
 /// <returns></returns>
 public static bool EditarAuditoriaData(Perfil p, int codigoAud, DateTime dt)
 {
     if (p == Perfil.CHEFE)
     {
         try
         {
             bool b;
             b = Auditorias.EditarAuditoriaData(codigoAud, dt);
             if (b)
             {
                 return(true);
             }
             else
             {
                 Console.WriteLine("Insira um codigo valido.\n");
                 return(false);
             }
         }
         catch (ArgumentNullException e)
         {
             Console.WriteLine("Error: " + e.Message);
         }
         catch (Exception e)
         {
             Console.WriteLine("Error: " + e.Message);
         }
     }
     return(false);
 }
        public async Task <ActionResult> Edit(Auditorias auditorias)
        {
            auditorias.FechaMod   = DateTime.Now;
            auditorias.UsuarioMod = this.GetUserId(User);
            Planes pl = db.Planes.Find(auditorias.IdPlan);

            auditorias.Plan = pl;
            //ModelState.Clear();
            //TryValidateModel(auditorias);
            validatorAuditoria val = new validatorAuditoria();
            ValidationResult   mod = val.Validate(auditorias);

            if (ModelState.IsValid && mod.IsValid)
            {
                db.Entry(auditorias).State = EntityState.Modified;
                await db.SaveChangesAsync();

                var aux = db.Planes.Where(p => p.IdPlan == auditorias.IdPlan).First();
                return(RedirectToAction("Index", new { idPlan = auditorias.IdPlan, nombrePlan = aux.NombrePlan }));
            }
            foreach (ValidationFailure _error in mod.Errors)
            {
                ModelState.AddModelError(_error.PropertyName, _error.ErrorMessage);
            }
            var usuarios = db.Users.Where(u => u.Eliminado != true && u.Roles.Any(r => r.RoleId == "b41a5a37-b052-4099-a63c-8107fe061b78")).Where(u => u.Eliminado != true && u.Nombres != "Administrador" && u.Apellidos != "Administrador").OrderBy(u => u.Nombres).ThenBy(u => u.Apellidos);

            ViewBag.IdUsuarioRealiza       = new SelectList(usuarios, "Id", "NombreCompleto", auditorias.IdUsuarioRealiza);
            ViewBag.IdDepartamentoRealizar = new SelectList(db.Departamentos.Where(d => d.Eliminado != true), "IdDepartamento", "NombreDepartamento", auditorias.IdDepartamentoRealizar);
            var planAux = db.Planes.Where(p => p.IdPlan == auditorias.IdPlan).First();

            ViewBag.idPlan     = auditorias.IdPlan;
            auditorias.Plan    = planAux;
            ViewBag.nombrePlan = planAux.NombrePlan;
            return(View(auditorias));
        }
 public Auditorias AuditoriasGetById(long Id)
 {
     try
     {
         DataSet          ds        = new DataSet();
         Conexion         oConexion = new Conexion();
         OracleConnection cn        = oConexion.getConexion();
         cn.Open();
         string sqlSelect = "select * from Auditorias " +
                            "WHERE AUD_NUMERO=" + Id.ToString();
         cmd     = new OracleCommand(sqlSelect, cn);
         adapter = new OracleDataAdapter(cmd);
         cmd.ExecuteNonQuery();
         adapter.Fill(ds);
         DataTable dt;
         dt = ds.Tables[0];
         Auditorias NewEnt = new Auditorias();
         if (dt.Rows.Count > 0)
         {
             DataRow dr = dt.Rows[0];
             NewEnt = CargarAuditorias(dr);
         }
         return(NewEnt);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
        public List <Auditorias> AuditoriasGetAll()
        {
            List <Auditorias> lstAuditorias = new List <Auditorias>();

            try
            {
                ds = new DataSet();
                Conexion         oConexion = new Conexion();
                OracleConnection cn        = oConexion.getConexion();
                cn.Open();
                string sqlSelect = "select * from Auditorias ";
                cmd     = new OracleCommand(sqlSelect, cn);
                adapter = new OracleDataAdapter(cmd);
                cmd.ExecuteNonQuery();
                adapter.Fill(ds);
                DataTable dt = new DataTable();
                dt = ds.Tables[0];
                if (dt.Rows.Count > 0)
                {
                    for (int i = 0; dt.Rows.Count > i; i++)
                    {
                        DataRow    dr     = dt.Rows[i];
                        Auditorias NewEnt = new Auditorias();
                        NewEnt = CargarAuditorias(dr);
                        lstAuditorias.Add(NewEnt);
                    }
                }
                return(lstAuditorias);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
 public bool AuditoriasUpdate(Auditorias oAuditoria)
 {
     try
     {
         Conexion         oConexion = new Conexion();
         OracleConnection cn        = oConexion.getConexion();
         cn.Open();
         ds  = new DataSet();
         cmd = new OracleCommand("update Auditorias " +
                                 "SET USR_CODIGO='" + oAuditoria.UsrCodigo + "'," +
                                 "AUD_FECHA='" + oAuditoria.AudFecha + "'," +
                                 "AUD_TERMINAL='" + oAuditoria.AudTerminal + "'," +
                                 "TAB_NOMBRE='" + oAuditoria.TabNombre + "'," +
                                 "AUD_TIPO='" + oAuditoria.AudTipo + "'," +
                                 "COT_CLAVE_BUSQUEDA='" + oAuditoria.CotClaveBusqueda +
                                 "WHERE AUD_NUMERO=" + oAuditoria.AudNumero, cn);
         adapter  = new OracleDataAdapter(cmd);
         response = cmd.ExecuteNonQuery();
         cn.Close();
         return(response > 0);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
        public ActionResult FinalizarAuditoria(int id)
        {
            Auditorias auditoria = db.Auditorias.Find(id);

            if (auditoria == null)
            {
                return(HttpNotFound());
            }
            if ((int)auditoria.PorcentajeAvance == 100)
            {
                var fases = db.Fases.Where(f => f.IdAuditoria == auditoria.IdAuditoria && f.IdEstado == 1 && f.Eliminado != true).ToList();
                if (fases.Count() != 0)
                {
                    Session["MyAlert"] = "<script type='text/javascript'>alertify.error('No se puede finalizar la auditoría ya que hay fases sin cerrar.');</script>";
                }
                else
                {
                    auditoria.IdEstado        = 2;
                    auditoria.UsuarioMod      = GetUserId();
                    auditoria.FechaCierre     = DateTime.Now;
                    auditoria.FechaMod        = DateTime.Now;
                    db.Entry(auditoria).State = EntityState.Modified;
                    db.SaveChanges();
                    Session["MyAlert"] = "<script type='text/javascript'>alertify.success('La auditoría se finalizo con éxito.');</script>";
                }
            }
            else
            {
                Session["MyAlert"] = "<script type='text/javascript'>alertify.error('No se puede finalizar la auditoría ya que no alcanza el 100% de avance.');</script>";
            }
            return(RedirectToAction("Index", new { IdPlan = auditoria.IdPlan, nombrePlan = auditoria.Plan.NombrePlan }));
        }
 /// <summary>
 /// Associar vulnerabilidade a uma auditoria
 /// </summary>
 /// <param name="codigoAud">Codigo da Auditoria</param>
 /// <param name="codigoVul">Codigo da Vulnerabilidade</param>
 /// <returns></returns>
 public static bool AdicionarVulnerabilidadeAuditoria(int codigoAud, int codigoVul)
 {
     try
     {
         bool b;
         b = Auditorias.AdicionarVulnerabilidadeAuditoria(codigoAud, codigoVul);
         if (b)
         {
             return(true);
         }
         else
         {
             Console.WriteLine("Falha ao adicionar vulnerabilidade.");
             return(false);
         }
     }
     catch (IOException e)
     {
         Console.Write("Error: " + e.Message);
     }
     catch (Exception e)
     {
         Console.Write("Error: " + e.Message);
     }
     return(false);
 }
 public MainController()
 {
     f     = new Funcionario();
     fs    = new Funcionarios();
     es    = new Equipamentos();
     vs    = new Vulnerabilidades();
     audis = new Auditorias();
     os    = new Ocorrencias();
     LoadAll();
 }
        public async Task <ActionResult> DeleteConfirmed(int id)
        {
            Auditorias auditorias = await db.Auditorias.FindAsync(id);

            auditorias.Elimanado       = true;
            db.Entry(auditorias).State = EntityState.Modified;
            await db.SaveChangesAsync();

            return(RedirectToAction("Index", new { idplan = auditorias.IdPlan, nombrePlan = auditorias.Plan.NombrePlan }));
        }
        public ActionResult ReactivarAuditoria(int id)
        {
            Auditorias auditoria = db.Auditorias.Find(id);

            auditoria.IdEstado        = 1;
            auditoria.UsuarioMod      = GetUserId();
            auditoria.FechaMod        = DateTime.Now;
            db.Entry(auditoria).State = EntityState.Modified;
            db.SaveChanges();
            Session["MyAlert"] = "<script type='text/javascript'>alertify.success('La auditoría se reactivó con éxito.');</script>";
            return(RedirectToAction("Index", new { IdPlan = auditoria.IdPlan, nombrePlan = auditoria.Plan.NombrePlan }));
        }
        // GET: Auditorias/Delete/5
        public async Task <ActionResult> Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Auditorias auditorias = await db.Auditorias.FindAsync(id);

            if (auditorias == null)
            {
                return(HttpNotFound());
            }
            return(View(auditorias));
        }
 /// <summary>
 /// Regista uma auditoria verificando todas as regras e excecoes
 /// </summary>
 /// <param name="a"></param>
 /// <returns></returns>
 public static int RegistaAuditoria(Auditoria a)
 {
     try
     {
         return(Auditorias.RegistaAuditoria(a));
     }
     catch (IndexOutOfRangeException x)
     {
         throw new FormatException("ERRO: " + x.Message);
     }
     catch (Exception x)
     {
         throw new Exception("ERRO: " + x.Message);
     }
 }
 /// <summary>
 /// Carrega o ficheiro binário com a informação relativa à classe Auditoria
 /// </summary>
 /// <param name="fileName">Diretório do ficheiro</param>
 public static bool CarregarAuditorias(string fileName)
 {
     try
     {
         return(Auditorias.CarregarAuditorias(fileName));
     }
     catch (IOException x)
     {
         throw new IOException("ERRO: " + x.Message);
     }
     catch (Exception x)
     {
         throw new Exception("ERRO: " + x.Message);
     }
 }
 /// <summary>
 /// Edita as informações de uma auditoria
 /// </summary>
 /// <param name="cod">Código da auditoria a editar</param>
 /// <param name="dataRegisto">Nova data de Registo</param>
 /// <param name="duracao">Nova duração</param>
 /// <returns> True se as informações forem editadas corretamente
 /// False se as informações não forem editadas corretamente </returns>
 public static bool EditaAuditoria(int cod, DateTime dataRegisto, int duracao)
 {
     try
     {
         return(Auditorias.EditaAuditoria(cod, dataRegisto, duracao));
     }
     catch (IndexOutOfRangeException x)
     {
         throw new FormatException("ERRO: " + x.Message);
     }
     catch (Exception x)
     {
         throw new Exception("ERRO: " + x.Message);
     }
 }
 /// <summary>
 /// Adiciona uma nova vulnerabilidade a uma auditoria
 /// </summary>
 /// <param name="cod">Codigo de auditoria </param>
 /// <param name="codv">Codigo da Vulnerabilidade a adicionar </param>
 /// <returns> True se for adicionada
 /// False se não for adicionada</returns>
 public static bool AdicionaVulnerabilidadeAuditoria(int cod, int codv)
 {
     try
     {
         return(Auditorias.AdicionaVulnerabilidade(cod, codv));
     }
     catch (IndexOutOfRangeException x)
     {
         throw new FormatException("ERRO: " + x.Message);
     }
     catch (Exception x)
     {
         throw new Exception("ERRO: " + x.Message);
     }
 }
        // GET: Auditorias/Details/5
        public async Task <ActionResult> Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            //Auditorias auditorias = await db.Auditorias.FindAsync(id);
            Auditorias auditorias = await db.Auditorias.Where(a => a.IdAuditoria == id).Include(a => a.Fases).FirstOrDefaultAsync();

            if (auditorias == null)
            {
                return(HttpNotFound());
            }
            return(View(auditorias));
        }
Exemple #18
0
 /// <summary>
 /// Adiciona uma auditoria a lista
 /// </summary>
 /// <param name="a">auditoria a ser adicionada</param>
 /// <returns> Devolve true/false consoante adicione ou não a auditoria</returns>
 public static bool InsereAuditoria(Auditoria a)
 {
     try
     {
         Auditorias.InsereAuditorias(a);
         return(true);
     }
     catch (InsercaoException e)
     {
         throw new InsercaoException("ERRO! " + e.Message);
     }
     catch (Exception e)
     {
         throw new Exception("ERRO! " + e.Message);
     }
 }
        // GET: Auditorias/Create
        public ActionResult Create(int idplan, string nombrePlan)
        {
            ViewBag.idPlan     = idplan;
            ViewBag.nombrePlan = nombrePlan;
            Auditorias auditoria = new Auditorias();
            var        plan      = db.Planes.Find(idplan);

            auditoria.FechaInicio = plan.FechaInicio;
            auditoria.FechaFin    = auditoria.FechaInicio.AddDays(38);
            auditoria.IdPlan      = idplan;
            var usuarios = db.Users.Where(u => u.Eliminado != true && u.Roles.Any(r => r.RoleId == "b41a5a37-b052-4099-a63c-8107fe061b78")).Where(u => u.Eliminado != true && u.Nombres != "Administrador" && u.Apellidos != "Administrador").OrderBy(u => u.Nombres).ThenBy(u => u.Apellidos);

            ViewBag.IdUsuarioRealiza       = new SelectList(usuarios, "Id", "NombreCompleto", auditoria.IdUsuarioRealiza);
            ViewBag.IdDepartamentoRealizar = new SelectList(db.Departamentos.Where(d => d.Eliminado != true), "IdDepartamento", "NombreDepartamento", auditoria.IdDepartamentoRealizar);
            return(View(auditoria));
        }
Exemple #20
0
 /// <summary>
 /// Guarda todas as vulnerabilidades da lista de vulnerabilidades
 /// </summary>
 /// <param name="fileName">Ficheiro</param>
 /// <returns></returns>
 public static bool SaveVulnerabilidades(string fileName)
 {
     try
     {
         Auditorias.SaveAuditorias(fileName);
     }
     catch (IOException e)
     {
         Console.Write("Error: " + e.Message);
     }
     catch (Exception e)
     {
         Console.Write("Error: " + e.Message);
     }
     return(false);
 }
Exemple #21
0
 /// <summary>
 /// Carrega todas as auditorias para a lista de auditorias
 /// </summary>
 /// <param name="fileName">Ficheiro</param>
 /// <returns></returns>
 public static bool LoadAuditorias(string fileName)
 {
     try
     {
         Auditorias.LoadAuditorias(fileName);
     }
     catch (IOException e)
     {
         Console.Write("Error: " + e.Message);
     }
     catch (Exception e)
     {
         Console.Write("Error: " + e.Message);
     }
     return(false);
 }
Exemple #22
0
 /// <summary>
 /// Editar a duracao de uma auditoria
 /// </summary>
 /// <param name="p"></param>
 /// <param name="a"></param>
 /// <param name="dur"></param>
 /// <returns></returns>
 public static bool EditarAuditoriaDuracao(Perfil p, auditoriaBO a, float dur)
 {
     if (p == Perfil.CHEFE)
     {
         try
         {
             AuditoriaDL aux = new AuditoriaDL(a);
             Auditorias.EditarAuditoriaDuracao(aux, dur);
             return(true);
         }
         catch (Exception e)
         {
             throw e;
         }
     }
     return(false);
 }
Exemple #23
0
 /// <summary>
 /// Edita o colaborador de uma auditoria
 /// </summary>
 /// <param name="p">Perfil</param>
 /// <param name="a">Auditoria</param>
 /// <param name="c">Colaborador</param>
 /// <returns></returns>
 public static bool EditarAuditoriaColaborador(Perfil p, auditoriaBO a, colaboradorBO c)
 {
     if (p == Perfil.CHEFE)
     {
         try
         {
             AuditoriaDL aux = new AuditoriaDL(a);
             Auditorias.EditarAuditoriaColaborador(aux, c);
             return(true);
         }
         catch (Exception e)
         {
             throw e;
         }
     }
     return(false);
 }
Exemple #24
0
 /// <summary>
 /// Edita a data de uma auditoria
 /// </summary>
 /// <param name="p">Perfil</param>
 /// <param name="a">Auditoria</param>
 /// <param name="dt">Data</param>
 /// <returns></returns>
 public static bool EditarAuditoriaData(Perfil p, auditoriaBO a, DateTime dt)
 {
     if (p == Perfil.CHEFE)
     {
         try
         {
             AuditoriaDL aux = new AuditoriaDL(a);
             Auditorias.EditarAuditoriaData(aux, dt);
             return(true);
         }
         catch (Exception e)
         {
             throw e;
         }
     }
     return(false);
 }
Exemple #25
0
 /// <summary>
 /// Adiciona uma auditoria a lista de auditorias
 /// </summary>
 /// <param name="p">Perfil</param>
 /// <param name="a">Auditoria</param>
 /// <returns></returns>
 public static bool AddAudit(Perfil p, auditoriaBO a)
 {
     if (p == Perfil.CHEFE || p == Perfil.COLABORADOR)
     {
         try
         {
             AuditoriaDL aux = new AuditoriaDL(a);
             Auditorias.AdicionaAuditoria(aux);
             return(true);
         }
         catch (Exception e)
         {
             throw e;
         }
     }
     return(false);
 }
Exemple #26
0
 /// <summary>
 /// Resolve vulnerabilidade
 /// </summary>
 /// <param name="vuln">vulnerabilidade a ser resolvida</param>
 /// <returns> Devolve true/false consoante resolveu ou não </returns>
 public static bool ResolveVulnerabilidade(Vulnerabilidade vuln)
 {
     try
     {
         vuln.ResolveVulnerabilidade();
         Auditorias.RemoveVulnerabilidadeAuditoria(vuln.Codigo);
         Equipamentos.RemoveVulnerabilidadeEquipamento(vuln.Codigo);
         return(true);
     }
     catch (VulnerabilidadeInexistenteException e)
     {
         throw new VulnerabilidadeInexistenteException("ERRO! " + e.Message);
     }
     catch (Exception e)
     {
         throw new Exception("ERRO! " + e.Message);
     }
 }
        // GET: Auditorias/Edit/5
        public async Task <ActionResult> Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Auditorias auditorias = await db.Auditorias.FindAsync(id);

            if (auditorias == null)
            {
                return(HttpNotFound());
            }
            var usuarios = db.Users.Where(u => u.Eliminado != true && u.Roles.Any(r => r.RoleId == "b41a5a37-b052-4099-a63c-8107fe061b78")).Where(u => u.Eliminado != true && u.Nombres != "Administrador" && u.Apellidos != "Administrador").OrderBy(u => u.Nombres).ThenBy(u => u.Apellidos);

            ViewBag.IdUsuarioRealiza       = new SelectList(usuarios, "Id", "NombreCompleto", auditorias.IdUsuarioRealiza);
            ViewBag.IdDepartamentoRealizar = new SelectList(db.Departamentos.Where(d => d.Eliminado != true), "IdDepartamento", "NombreDepartamento", auditorias.IdDepartamentoRealizar);
            return(View(auditorias));
        }
Exemple #28
0
 /// <summary>
 /// Apresenta todos os dados relativos ao programa
 /// </summary>
 public static void ApresentarDados()
 {
     Console.WriteLine("\n==============================================================================================");
     Console.WriteLine("                                            MENU                                                ");
     Console.WriteLine("==============================================================================================\n");
     Console.WriteLine("    > Quantidade de Auditorias realizadas:          {0} \n", Auditorias.TotalAuditorias());
     Console.WriteLine("    > Auditoria com MAIS vulnerabilidades:          {0}, {1} falha(s), ({2}) \n", Auditorias.AuditoriaMaisVulnerabilidades().Codigo.ToString(),
                       Auditorias.AuditoriaMaisVulnerabilidades().CodVulns.Count.ToString(),
                       Auditorias.AuditoriaMaisVulnerabilidades().Data.ToShortDateString());
     Console.WriteLine("    > Auditoria com MENOS vulnerabilidades:         {0}, {1} falha(s), ({2}) \n", Auditorias.AuditoriaMenosVulnerabilidades().Codigo.ToString(),
                       Auditorias.AuditoriaMenosVulnerabilidades().CodVulns.Count.ToString(),
                       Auditorias.AuditoriaMenosVulnerabilidades().Data.ToShortDateString());
     Console.WriteLine("    > Media de vulnerabilidades das auditorias:     {0} \n\n\n", Auditorias.MediaVulnerabilidades().ToString());
     Auditorias.ApresentarAuditorias(); Console.WriteLine("");
     Auditorias.ApresentarVulneabilidadesAuditoria(); Console.WriteLine("");
     Colaboradores.ApresentarColaboradores(); Console.WriteLine("");
     Colaboradores.ApresentarAuditoriasColaborador(); Console.WriteLine("");
     Vulnerabilidades.ApresentarVulnerabilidades(); Console.WriteLine("");
     Equipamentos.ApresentarEquipamentos(); Console.WriteLine("");
     Equipamentos.ApresentarVulneabilidadesAuditoria(); Console.WriteLine("");
 }
 private Auditorias CargarAuditorias(DataRow dr)
 {
     try
     {
         Auditorias oObjeto = new Auditorias();
         oObjeto.AudNumero = long.Parse(dr["AUD_NUMERO"].ToString());
         oObjeto.UsrCodigo = dr["USR_CODIGO"].ToString();
         if (dr["AUD_FECHA"].ToString() != "")
         {
             oObjeto.AudFecha = DateTime.Parse(dr["AUD_FECHA"].ToString());
         }
         oObjeto.AudTerminal      = dr["AUD_TERMINAL"].ToString();
         oObjeto.TabNombre        = dr["TAB_NOMBRE"].ToString();
         oObjeto.AudTipo          = dr["AUD_TIPO"].ToString();
         oObjeto.CotClaveBusqueda = dr["COT_CLAVE_BUSQUEDA"].ToString();
         return(oObjeto);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Exemple #30
0
 /// <summary>
 /// Carrega os dados de um ficheiro binario
 /// </summary>
 public static bool Load(string fileAuditorias, string fileVulnerabilidades, string fileColaboradores, string fileEquipamentos)
 {
     try
     {
         Auditorias.Load(fileAuditorias);
         Colaboradores.Load(fileColaboradores);
         Vulnerabilidades.Load(fileVulnerabilidades);
         Equipamentos.Load(fileEquipamentos);
         return(true);
     }
     catch (FileLoadException e)
     {
         throw new FileLoadException("Erro: " + e.Message);
     }
     catch (IOException e)
     {
         throw new IOException("Erro: " + e.Message);
     }
     catch (Exception e)
     {
         throw new Exception("ERRO! " + e.Message);
     }
 }