public LocalVariableComponentsFactory(
oval_system_characteristics systemCharacteristics,
IEnumerable<VariableType> variablesOfDefinitions,
Modulo.Collect.OVAL.Variables.oval_variables externalVariables = null)
{
this.variablesOfDefinitions = variablesOfDefinitions;
this.systemCharacteristics = systemCharacteristics;
this.ExternalVariables = externalVariables;
}
public void ConsigoSaberSeUmUsuarioPodeAcessarUmModulo()
{
var perfil = PerfilBuilder.DadoUmPerfil().Build();
var modulo = new Modulo { Perfils = new List<Perfil> { perfil } };
var usuario = UsuarioBuilder.DadoUmUsuario().ComOPerfil(perfil).Build();
var permitido = modulo.TemPermissao(usuario);
Assert.IsTrue(permitido);
}
private void AddTargetParametersInCollectRequest(Request collectRequestDTO, Modulo.Collect.Service.Entities.Target target)
{
if (collectRequestDTO.TargetParameters != null)
{
foreach (KeyValuePair<string, string> parameter in collectRequestDTO.TargetParameters)
{
TargetParameter targetParameter = CreateTargetParametersFromCollectRequestDTO(parameter.Key, parameter.Value);
target.Parameters.Add(targetParameter);
}
}
}
public LocalVariableEvaluator(
VariablesTypeVariableLocal_variable variable,
oval_system_characteristics systemCharacteristics,
IEnumerable<VariableType> variablesOfDefinitions,
Modulo.Collect.OVAL.Variables.oval_variables externalVariables = null)
{
this.variable = variable;
this.systemCharacteristics = systemCharacteristics;
this.localVariableComponentFactory = new LocalVariableComponentsFactory(systemCharacteristics, variablesOfDefinitions, externalVariables);
this.variablesOfDefinitions = variablesOfDefinitions;
}
public void ConsigoAdicionarPermissaoParaUmModulo()
{
var modulo = new Modulo();
var grupo = GrupoBuilder.DadoUmGrupo().Build();
var perfil = new Perfil(grupo);
perfil.PermitirModulo(modulo);
CollectionAssert.Contains(perfil.ModulosPermitidos, modulo);
}
public void EliminarModulo(Modulo obj)
{
try
{
Dat_Modulos acceso = new Dat_Modulos();
acceso.BorrarBD(obj.CodigoSistema, obj.Codigo, System.Web.HttpContext.Current.User.Identity.Name, System.Web.HttpContext.Current.Request.UserHostAddress);
}
catch (Exception)
{
throw;
}
}
public void AgregarModulo(Modulo obj)
{
try
{
Dat_Modulos acceso = new Dat_Modulos();
acceso.AgregarBD(obj.CodigoSistema, obj.Codigo, obj.Nombre, obj.Descripcion, (char)obj.Estado, 1, 1, 'S', 'N', String.Empty, String.Empty, System.Web.HttpContext.Current.User.Identity.Name, System.Web.HttpContext.Current.Request.UserHostAddress);
}
catch (Exception)
{
throw;
}
}
public LocalVariableVariablesComponent(
VariableType localVariable,
VariableComponentType variable,
IEnumerable<VariableType> variablesOfOvalDefinitions,
oval_system_characteristics systemCharacteristics,
Modulo.Collect.OVAL.Variables.oval_variables externalVariables = null)
{
this.variablesOfDefinitions = variablesOfOvalDefinitions;
this.variable = variable;
this.systemCharacteristics = systemCharacteristics;
this.localVariable = localVariable;
this.variableEvaluator = new VariableEvaluator(variablesOfDefinitions, systemCharacteristics, externalVariables);
}
public void ConsigoSaberSeUmPerfilTemPermissaoAUmModulo()
{
var modulo = new Modulo();
var grupo = GrupoBuilder.DadoUmGrupo().Build();
var perfil = new Perfil(grupo);
perfil.PermitirModulo(modulo);
var permitido = perfil.ModuloEhPermitido(modulo);
Assert.IsTrue(permitido);
}
public List<Modulo> ListarModulos(int codigoSistema)
{
try
{
Dat_Modulos acceso = new Dat_Modulos();
CGP.clsListaCondiciones condiciones = new CGP.clsListaCondiciones();
List<CGP.clsCondicion> listaCondiciones = new List<CGP.clsCondicion>();
CGP.clsCondicion condicionSistema = new CGP.clsCondicion()
{
Campo = new CGP.clsCampo()
{
Nombre = "CodigoSistema",
TipoDato = CGP.TTipo.Entero,
NombreBD = "CodigoSistema"
},
Operador = CGP.TOperadorLogico.Igual,
Valor = codigoSistema,
};
listaCondiciones.Add(condicionSistema);
condiciones.Lista = listaCondiciones.ToArray();
DataSet datos = acceso.TraerListaTotalBD(condiciones, 0, System.Web.HttpContext.Current.User.Identity.Name, System.Web.HttpContext.Current.Request.UserHostAddress);
List<Modulo> lista = null;
if (datos != null && datos.Tables.Count > 0 && datos.Tables[0].Rows.Count > 0)
{
lista = new List<Modulo>();
foreach (DataRow row in datos.Tables[0].Rows)
{
Modulo obj = new Modulo();
obj.Codigo = Int32.Parse(row["CodigoModulo"].ToString());
obj.CodigoSistema = Int32.Parse(row["CodigoSistema"].ToString());
obj.Nombre = row["Nombre"].ToString();
obj.Descripcion = row["Descripcion"].ToString();
obj.Estado = ((EnumEstadosBase)(Char.Parse(row["Estado"].ToString())));
lista.Add(obj);
}
}
return lista;
}
catch (Exception)
{
throw;
}
}
protected override IEnumerable<CollectedItem> collectDataForSystemItem(Modulo.Collect.OVAL.SystemCharacteristics.ItemType systemItem)
{
var fileItem = (file_item)systemItem;
try
{
var completeFilepath = GetCompleteFilepath(fileItem);
var collectedVariableValue = this.TryToCollectFile(completeFilepath);
var shortFileTime = this.ToShortFileTime(collectedVariableValue.LastModified);
fileItem.m_time = OvalHelper.CreateItemEntityWithIntegerValue(shortFileTime);
fileItem.filepath = OvalHelper.CreateItemEntityWithStringValue(completeFilepath);
fileItem.size = OvalHelper.CreateItemEntityWithIntegerValue(collectedVariableValue.FileSize.ToString());
fileItem.type = OvalHelper.CreateItemEntityWithStringValue(collectedVariableValue.FileType);
fileItem.suid = OvalHelper.CreateBooleanEntityItemFromBoolValue((collectedVariableValue.Mode & 0x0800) != 0);
fileItem.sgid = OvalHelper.CreateBooleanEntityItemFromBoolValue((collectedVariableValue.Mode & 0x0400) != 0);
fileItem.sticky = OvalHelper.CreateBooleanEntityItemFromBoolValue((collectedVariableValue.Mode & 0x0200) != 0);
fileItem.uread = OvalHelper.CreateBooleanEntityItemFromBoolValue((collectedVariableValue.Mode & 0x0100) != 0);
fileItem.uwrite = OvalHelper.CreateBooleanEntityItemFromBoolValue((collectedVariableValue.Mode & 0x0080) != 0);
fileItem.uexec = OvalHelper.CreateBooleanEntityItemFromBoolValue((collectedVariableValue.Mode & 0x0040) != 0);
fileItem.gread = OvalHelper.CreateBooleanEntityItemFromBoolValue((collectedVariableValue.Mode & 0x0020) != 0);
fileItem.gwrite = OvalHelper.CreateBooleanEntityItemFromBoolValue((collectedVariableValue.Mode & 0x0010) != 0);
fileItem.gexec = OvalHelper.CreateBooleanEntityItemFromBoolValue((collectedVariableValue.Mode & 0x0008) != 0);
fileItem.oread = OvalHelper.CreateBooleanEntityItemFromBoolValue((collectedVariableValue.Mode & 0x0004) != 0);
fileItem.owrite = OvalHelper.CreateBooleanEntityItemFromBoolValue((collectedVariableValue.Mode & 0x0002) != 0);
fileItem.oexec = OvalHelper.CreateBooleanEntityItemFromBoolValue((collectedVariableValue.Mode & 0x0001) != 0);
fileItem.group_id = OvalHelper.CreateItemEntityWithIntegerValue(collectedVariableValue.Group);
fileItem.user_id = OvalHelper.CreateItemEntityWithIntegerValue(collectedVariableValue.Owner);
}
catch (FileNotExistsException)
{
base.SetDoesNotExistStatusForItemType(systemItem, String.Format("{0}/{1}", fileItem.path.Value, fileItem.filename.Value));
}
return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog());
}
public List <Modulo> ListarModuloRol(int nRolId)
{
try
{
List <Modulo> ListaModulo = new List <Modulo>();
DbCommand oDbCommand = oDatabase.GetStoredProcCommand(Procedimiento.stp_sel_ModuloRol);
oDatabase.AddInParameter(oDbCommand, "@nRolId", DbType.Int32, (object)nRolId ?? DBNull.Value);
using (IDataReader oIDataReader = oDatabase.ExecuteReader(oDbCommand))
{
int inMenuId = oIDataReader.GetOrdinal("nMenuId");
int inModId = oIDataReader.GetOrdinal("nModId");
int icMenuDesc = oIDataReader.GetOrdinal("cModDesc");
int inValor = oIDataReader.GetOrdinal("nValor");
while (oIDataReader.Read())
{
Modulo oModulo = new Modulo();
oModulo.nMenuId = DataUtil.DbValueToDefault <Int32>(oIDataReader[inMenuId]);
oModulo.nModId = DataUtil.DbValueToDefault <Int32>(oIDataReader[inModId]);
oModulo.cModDesc = DataUtil.DbValueToDefault <String>(oIDataReader[icMenuDesc]);
oModulo.bEstado = DataUtil.DbValueToDefault <Boolean>(oIDataReader[inValor]);
ListaModulo.Add(oModulo);
}
}
return(ListaModulo);
}
catch (Exception)
{
throw;
}
}
//listarModulosRole
public List <Modulo> listarModulosRole(string id)
{
var cn = cnx.getConexion();
List <Modulo> lista = new List <Modulo>();
cn.Open();
SqlCommand cmd = new SqlCommand("SP_LISTAR_MODULOS_ROLE", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@idRole", id);
SqlDataReader dr = cmd.ExecuteReader();
while (dr.Read())
{
Modulo md = new Modulo();
md.idModulo = dr.GetInt32(0);
md.controlador = dr.GetString(1);
md.titulo = dr.GetString(2);
md.descripcion = dr.GetString(3);
lista.Add(md);
}
cn.Close();
return(lista);
}
public static Estoria Criar(WexDb contexto, Modulo modulo, Beneficiado beneficiado, string titulo, uint tamanho, string emAnalise)
{
Estoria estoria = new Estoria();
//Projeto projeto = modulo.Projeto;
estoria.OidModulo = modulo.Oid;
estoria.OidBeneficiado = beneficiado.Oid;
//estoria.OidCiclo = projeto.CicloDesenvs.FirstOrDefault(o=>o.NbCiclo )
estoria.TxTitulo = titulo;
estoria.NbTamanho = tamanho;
if (emAnalise.ToUpper().Equals("SIM"))
{
estoria.CsEmAnalise = true;
estoria.CsSituacao = Convert.ToInt32(CsEstoriaDomain.EmAnalise);
}
else
{
estoria.CsEmAnalise = false;
estoria.CsSituacao = Convert.ToInt32(CsEstoriaDomain.NaoIniciado);
}
EstoriaDAO.SalvarEstoria(contexto, estoria);
return(estoria);
}
public int MantenimientoModulo(Modulo objModulop)
{
int r = 0;
using (SqlConnection conn = DataContext.GetConnection())
{
var listaParams = new List <SqlParameter>();
listaParams.Add(new SqlParameter("@IdModulo", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input, Value = objModulop.IdModulo
});
listaParams.Add(new SqlParameter("@Nombre", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input, Value = objModulop.Nombre
});
listaParams.Add(new SqlParameter("@Descripcion", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input, Value = objModulop.Descripcion
});
listaParams.Add(new SqlParameter("@Posicion", SqlDbType.Int)
{
Direction = ParameterDirection.Input, Value = objModulop.Posicion
});
listaParams.Add(new SqlParameter("@Icono", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input, Value = objModulop.Icono
});
listaParams.Add(new SqlParameter("@IdEstado", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input, Value = objModulop.IdEstado
});
r = SQLHelper.ExecuteNonQuery(conn, System.Data.CommandType.StoredProcedure, @"Sp_ModuloMantenimiento", listaParams.ToArray());
}
return(r);
}
protected override Expression VisitMember(MemberExpression m)
{
if (m.Expression != null && m.Expression.NodeType == ExpressionType.Parameter)
{
string typeField = Modulo.GetColumnName(this.tipo, m.Member.Name);
sb.Append($"t{_selectIndex}." + typeField);
return(m);
}
string[] strExpression = m.ToString().Split('.');
if (strExpression.Length > 0 && strExpression[0] == parameterWhere)
{
strExpression[0] = null;
string typeField = string.Join(".", strExpression, 1, strExpression.Length - 1);
var field = MQB.lstFields.FirstOrDefault(t => t.TypeField == typeField);
sb.Append($"{field.Table}.{field.DbField}");
return(m);
}
if (m.Expression == null ||
(m.Expression != null && m.Expression.NodeType == ExpressionType.Constant) ||
m.NodeType == ExpressionType.MemberAccess)
{
LambdaExpression lambda = Expression.Lambda(m);
Delegate fn = lambda.Compile();
var ConstantExp = Expression.Constant(fn.DynamicInvoke(null), m.Type);
sb.Append(ConstantValue(ConstantExp));
return(ConstantExp);
}
throw new NotSupportedException(string.Format("The member '{0}' is not supported", m.Member.Name));
}
/// <summary>
/// Salva os dados do Módulo
/// </summary>
/// <param name="mod">Nome do Módulo</param>
/// <param name="usu_id">Id do Usuário logado</param>
/// <param name="ip">IP do Usuário logado</param>
/// <returns>int</returns>
public int Modulo_Salvar(Modulo mod, int usu_id, string ip)
{
try
{
using (SqlConnection con = new SqlConnection(strConn))
{
con.Open();
SqlCommand com = new SqlCommand();
com.CommandText = "STP_UPD_MODULO";
com.Connection = con;
com.CommandType = CommandType.StoredProcedure;
com.Parameters.Clear();
System.Data.SqlClient.SqlParameter p_return = new System.Data.SqlClient.SqlParameter();
p_return.Direction = System.Data.ParameterDirection.ReturnValue;
com.Parameters.Add(p_return);
com.Parameters[0].Size = 32000;
com.Parameters.AddWithValue("@mod_id", mod.mod_id);
com.Parameters.AddWithValue("@mod_nome_modulo", mod.mod_nome_modulo);
com.Parameters.AddWithValue("@mod_descricao", mod.mod_descricao);
com.Parameters.AddWithValue("@mod_ativo", mod.mod_ativo);
com.Parameters.AddWithValue("@usu_id", usu_id);
com.Parameters.AddWithValue("@ip", ip);
com.ExecuteScalar();
return(Convert.ToInt32(p_return.Value));
}
}
catch (Exception ex)
{
int id = 0;
new LogSistemaDAO().InserirLogErro(new LogErro(ex, this.GetType().Name, new StackTrace().GetFrame(0).GetMethod().Name), out id);
throw new Exception(ex.Message);
}
}
public void Update(Modulo mod)
{
try
{
this.OpenConnection();
SqlCommand cmdModuloUpdate = new SqlCommand(
"update modulos " +
"set desc_modulo = @desc_modulo, ejecuta = @ejecuta " +
"where id_modulo = @id;", SqlConn);
cmdModuloUpdate.Parameters.Add("@id", SqlDbType.Int).Value = mod.ID;
cmdModuloUpdate.Parameters.Add("@desc_modulo", SqlDbType.VarChar, 50).Value = mod.Descripcion;
cmdModuloUpdate.Parameters.Add("@ejecuta", SqlDbType.VarChar, 50).Value = mod.Ejecuta;
cmdModuloUpdate.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
finally
{
this.CloseConnection();
}
}
public void InserirArea()
{
using (SqlServerDao dao = new SqlServerDao())
{
Usuario usuario = dao.BuscarPorId <Usuario>(1);
Modulo modulo = new Modulo()
{
Nome = "Administrador"
};
Privilegio privilegio = new Privilegio()
{
Nivel = 'A',
Modulo = modulo,
Usuario = usuario
};
modulo.Privilegios.Add(privilegio);
dao.Inserir <Modulo>(modulo);
Area area = new Area()
{
Nome = "Area teste",
Descricao = "Area usada no teste unitário, para incluir privilégios"
};
area.Privilegios.Add(privilegio);
dao.Inserir <Area>(area);
var test = dao.ListarTodos <Area>();
Assert.AreNotEqual(test.Count, 0);
}
}
public override void MapearADatos()
{
switch (Modo)
{
case ModoForm.Alta:
ModuloActual = new Modulo();
ModuloActual.Descripcion = tbDesc.Text;
ModuloActual.State = BusinessEntity.States.New;
break;
case ModoForm.Modificacion:
ModuloActual.Descripcion = tbDesc.Text;
ModuloActual.State = BusinessEntity.States.Modified;
break;
case ModoForm.Baja:
ModuloActual.State = BusinessEntity.States.Deleted;
break;
case ModoForm.Consulta:
ModuloActual.State = BusinessEntity.States.Modified;
break;
}
}
public void OnAuthorization(AuthorizationFilterContext filterContext)
{
String nombreOperacion = "";
String nombreModulo = "";
try
{
this.usuario = filterContext.HttpContext.Session.GetComplexData <Usuario>("DatosUsuario");
if (usuario != null)
{
int cantOperaciones = ConsultaUsuario.Leer_Rol_Operacion(usuario.Rol.Id, idOperacion);
if (cantOperaciones < 1)
{
Operacion operacion = ConsultasGenerales.Leer_Operacion(idOperacion);
Modulo modulo = ConsultasGenerales.Leer_Modulo(operacion.IdModulo);
nombreOperacion = operacion.Nombre;
nombreModulo = modulo.Nombre;
filterContext.Result = new RedirectResult("~/Error/OperacionNoAutorizada?operacion=" + nombreOperacion + "&modulo=" + nombreModulo + "&msjeErrorExcepcion=");
}
}
else
{
Operacion operacion = ConsultasGenerales.Leer_Operacion(idOperacion);
Modulo modulo = ConsultasGenerales.Leer_Modulo(operacion.IdModulo);
nombreOperacion = operacion.Nombre;
nombreModulo = modulo.Nombre;
filterContext.Result = new RedirectResult("~/Error/OperacionNoAutorizada?operacion=" + nombreOperacion + "&modulo=" + nombreModulo + "&msjeErrorExcepcion=");
}
}
catch (Exception ex)
{
//RedirectToAction("OperacionNoAutorizada", "Error", new { @operacion = nombreOperacion, @modulo = nombreModulo, @msjeErrorExcepcion = ex.Message });
filterContext.Result = new RedirectResult("~/Error/OperacionNoAutorizada?operacion=" + nombreOperacion + "&modulo=" + nombreModulo + "&msjeErrorExcepcion=" + ex.Message);
}
}
public override void GuardarCambios()
{
ModuloLogic modLogic = new ModuloLogic();
if (this.Modo == ModoForm.Alta)
{
Modulo modNuevo = new Modulo();
this.ModuloActual = modNuevo;
}
if (this.Modo == ModoForm.Alta || this.Modo == ModoForm.Modificacion)
{
try
{
this.MapearADatos();
modLogic.Save(this.ModuloActual);
}
catch (Exception e)
{
this.Notificar(this.Text, e.Message, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else if (this.Modo == ModoForm.Baja)
{
//buscar modulos_usuario con id_modulo a eliminar.
//Si cantidad>0 , entonces avisar que no se puede eliminar
//Si cantidad == 0 eliminar el modulo requerido.
try
{
modLogic.Delete(ModuloActual.Id);
}
catch (Exception e)
{
this.Notificar(this.Text, e.Message, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
protected void Insert(Modulo modulo)
{
try
{
this.OpenConnection();
SqlCommand cmdSave = new SqlCommand(
"insert into modulos (desc_modulo) " +
"values (@desc_modulo) " +
"select @@identity", //esta línea es para recuperar el ID que asignó el sql automáticamente
SqlConn);
cmdSave.Parameters.Add("@desc_modulo", SqlDbType.VarChar, 50).Value = modulo.Descripcion;
modulo.ID = Decimal.ToInt32((decimal)cmdSave.ExecuteScalar());
//Así se obtiene el ID que asignó al BD automáticamente
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al crear modulo", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
}
/// <summary>
/// método TestarAtualizarPontosDeUmModulo
/// </summary>
//[TestMethod]
public void TestarAtualizarPontosDeUmModulo()
{
/**
* Cenário 6: Serão atualizados os pontos de um módulo e o sistema deverá registrar essa atualização
*/
Projeto projeto1 = ProjetoFactory.Criar(SessionTest, 0, "", true);
Modulo modulo = ModuloFactory.CriarTeste(SessionTest, projeto1, "", 20, 3, 72, 38, 5, 132, true);
Assert.AreEqual(modulo._NbPercNaoIniciado, 15, 1);
Assert.AreEqual(modulo._NbPercPronto, 28, 8);
Assert.AreEqual(modulo._NbPercEmAnalise, 1, 5);
Assert.AreEqual(modulo._NbPercEmDesenv, 54, 5);
Assert.AreEqual(modulo._NbPercDesvio, 3, 8);
Assert.AreEqual(modulo._TxSituacao, "Não Iniciado: " + modulo._NbPercNaoIniciado + "%; Pronto: " + modulo._NbPercPronto + "%; Em Análise: "
+ modulo._NbPercEmAnalise + "%; Em Desenv: " + modulo._NbPercEmDesenv + "%; Desvio: " + modulo._NbPercDesvio + "%");
Modulo modulo2 = ModuloFactory.CriarTeste(SessionTest, projeto1, "", 0, 22, 72, 38, 0, 132, true);
Assert.AreEqual(modulo2._NbPercEmAnalise, 16, 7);
Assert.AreEqual(modulo._TxSituacao, "Não Iniciado: " + modulo._NbPercNaoIniciado + "%; Pronto: " + modulo._NbPercPronto + "%; Em Análise: "
+ modulo._NbPercEmAnalise + "%; Em Desenv: " + modulo._NbPercEmDesenv + "%; Desvio: " + modulo._NbPercDesvio + "%");
}
public async Task <IActionResult> Create([Bind("Id,ModuloId,NumeroAula,Descricao,Video,MaterialApoio,ArquivosApoio")] Aula aula)
{
if (ModelState.IsValid)
{
var seq = await _context.Aulas.Where(a => a.ModuloId == aula.ModuloId).OrderByDescending(a => a.NumeroAula).FirstOrDefaultAsync();
if (aula.Video != null && aula.Video.Contains("https://youtu.be/"))
{
string newPath = aula.Video.Replace("https://youtu.be/", "https://www.youtube.com/watch?v=");
aula.Video = newPath;
}
if (seq == null)
{
aula.NumeroAula = 1;
}
else
{
aula.NumeroAula = seq.NumeroAula + 1;
}
aula.Modulo = null;
_context.Add(aula);
await _context.SaveChangesAsync();
Modulo modulo = _context.Modulos.Find(aula.ModuloId);
return(RedirectToAction("Index", "Cursos", new { id = modulo.CursoId, moduloId = aula.ModuloId }));
}
ViewData["CursoId"] = new SelectList(_context.Cursos, "Id", "Nome");
ViewData["ModuloId"] = new SelectList(_context.Modulos, "Id", "Descricao", aula.ModuloId);
return(View(aula));
}
public void Modificar()
{
try
{
Console.Clear();
Console.Write("Ingrese el ID del Módulo a modificar: ");
int ID = int.Parse(Console.ReadLine());
Modulo modulo = ModuloNegocio.GetOne(ID);
if (modulo == null)
{
Console.WriteLine("No existe Especialidad");
}
else
{
Console.Write("Ingrese nueva descripción: ");
modulo.Descripcion = Console.ReadLine();
modulo.State = BusinessEntity.States.Modified;
ModuloNegocio.Save(modulo);
}
}
catch (FormatException fe)
{
Console.WriteLine();
Console.WriteLine("La ID ingresada debe ser un número entero.");
}
catch (Exception e)
{
Console.WriteLine();
Console.WriteLine(e.Message);
}
finally
{
Console.WriteLine("Presione una tecla para continuar...");
Console.ReadKey();
}
}
//-----------------------------------------------------------------------------------------------
// C A J A S D E T E X T O
//-----------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------
// E V E N T O S
//-----------------------------------------------------------------------------------------------
private void Asignar_Proceso_Load(object sender, EventArgs e)
{
//cierra formularios abiertos
FormCollection formulariosApp = Application.OpenForms;
foreach (Form f in formulariosApp)
{
if (f.Name != this.Name)
{
f.Hide();
}
}
//llena etiqueta de usuario
lblusuario.Text = LoginInfo.Nombre;
Utilerias.cargaimagen(ptbimgusuario);
// Diccionario Permisos x Pantalla
DataTable dtPermisos = Modulo.ObtenerPermisosxUsuario(LoginInfo.IdTrab, this.Name);
Permisos.dcPermisos = Utilerias.CrearListaPermisoxPantalla(dtPermisos);
//////////////////////////////////////////////////////
// resize
Utilerias.ResizeForm(this, Utilerias.PantallaSistema());
///////////////////////////////////////////////////////////////////////////////////////////////////
LlenaGridUsuarios("%", 0, "", "", 0, "", "", 11);
LlenaGridProcesos("", "%", 0, "0", "", 8);
cbAsignaPassword.Visible = false;
cbAsignaPassword.Checked = false;
pnlPassword.Visible = false;
}
protected RespuestaServidor Insert(Modulo modulo)
{
try
{
this.OpenConnection();
SqlCommand cmdSave = new SqlCommand("INSERT into modulos (desc_modulo, ejecuta) " +
"values (@desc_modulo, @ejecuta)" +
" select @@identity", Con);
cmdSave.Parameters.Add("@desc_modulo", SqlDbType.VarChar, 50).Value = modulo.Descripcion;
cmdSave.Parameters.Add("@ejecuta", SqlDbType.VarChar, 50).Value = modulo.Ejecuta;
modulo.Id = Decimal.ToInt32((decimal)cmdSave.ExecuteScalar());
rs.Mensaje = "Modulo agregada con éxito";
}
catch (Exception Ex)
{
rs.AgregarExcepcion(Ex);
}
finally
{
this.CloseConnection();
}
return(rs);
}
public Modulo GetOne(int ID)
{
Modulo m = new Modulo();
try
{
this.OpenConnection();
SqlCommand cmdModulos = new SqlCommand("SELECT * from modulos where id_modulo=@id", sqlConn);
cmdModulos.Parameters.Add("@id", SqlDbType.Int).Value = ID;
SqlDataReader drModulos = cmdModulos.ExecuteReader();
if (drModulos.Read())
{
m.ID = (int)drModulos["id_modulo"];
m.Descripcion = (String)drModulos["desc_modulo"];
m.Ejecuta = (String)drModulos["ejecuta"];
}
drModulos.Close();
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al recuperar datos del modulo", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(m);
}
public void CriarSequenciaPasso()
{
/**
* Cenário 1: Serão criados 3 passos para um caso de teste.
* O sistema deverá cria-los com a sequencia 1, 2, 3 respectivamente.
*/
Projeto projeto1 = ProjetoFactory.Criar(SessionTest, 0, "", true);
Modulo modulo1 = ModuloFactory.Criar(SessionTest, projeto1, "", true);
Requisito requisito1 = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
CasoTeste casoteste1 = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
CasoTestePasso casotestePasso1 = CasoTestePassoFactory.Criar(SessionTest, casoteste1, "", true);
Assert.AreEqual(1, casotestePasso1.NbSequencia, "A sequência deveria ser 1");
CasoTestePasso casotestePasso2 = CasoTestePassoFactory.Criar(SessionTest, casoteste1, "", true);
Assert.AreEqual(2, casotestePasso2.NbSequencia, "A sequência deveria ser 1");
CasoTestePasso casotestePasso3 = CasoTestePassoFactory.Criar(SessionTest, casoteste1, "", true);
Assert.AreEqual(3, casotestePasso3.NbSequencia, "A sequência deveria ser 1");
}
public List <Modulo> GetAll()
{
List <Modulo> modulos = new List <Modulo>();
try
{
this.OpenConnection();
SqlCommand cmdModulos = new SqlCommand("SELECT * FROM modulos", sqlConn);
SqlDataReader drModulos = cmdModulos.ExecuteReader();
while (drModulos.Read())
{
Modulo mod = new Modulo();
mod.ID = (int)drModulos["id_modulo"];
mod.Descripcion = (string)drModulos["desc_modulo"];
modulos.Add(mod);
}
drModulos.Close();
}
catch (Exception Ex)
{
Exception ExcepcionManejada =
new Exception("Error al recuperar lista de modulos", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(modulos);
}
public ModuloDesktop(int ID, ModoForm modo) : this()
{
Modo = modo;
ModuloActual = new ModuloLogic().getOne(ID);
MapearDeDatos();
}
public double Execute(Operation operation,
IFunctionRegistry functionRegistry,
IConstantRegistry constantRegistry,
IDictionary <string, double> variables)
{
if (operation == null)
{
throw new ArgumentNullException("operation");
}
if (operation.GetType() == typeof(IntegerConstant))
{
IntegerConstant constant = (IntegerConstant)operation;
return(constant.Value);
}
else if (operation.GetType() == typeof(FloatingPointConstant))
{
FloatingPointConstant constant = (FloatingPointConstant)operation;
return(constant.Value);
}
else if (operation.GetType() == typeof(Variable))
{
Variable variable = (Variable)operation;
double value;
bool variableFound = variables.TryGetValue(variable.Name, out value);
if (variableFound)
{
return(value);
}
else
{
throw new VariableNotDefinedException(string.Format("The variable \"{0}\" used is not defined.", variable.Name));
}
}
else if (operation.GetType() == typeof(Multiplication))
{
Multiplication multiplication = (Multiplication)operation;
return(Execute(multiplication.Argument1, functionRegistry, constantRegistry, variables) * Execute(multiplication.Argument2, functionRegistry, constantRegistry, variables));
}
else if (operation.GetType() == typeof(Addition))
{
Addition addition = (Addition)operation;
return(Execute(addition.Argument1, functionRegistry, constantRegistry, variables) + Execute(addition.Argument2, functionRegistry, constantRegistry, variables));
}
else if (operation.GetType() == typeof(Subtraction))
{
Subtraction addition = (Subtraction)operation;
return(Execute(addition.Argument1, functionRegistry, constantRegistry, variables) - Execute(addition.Argument2, functionRegistry, constantRegistry, variables));
}
else if (operation.GetType() == typeof(Division))
{
Division division = (Division)operation;
return(Execute(division.Dividend, functionRegistry, constantRegistry, variables) / Execute(division.Divisor, functionRegistry, constantRegistry, variables));
}
else if (operation.GetType() == typeof(Modulo))
{
Modulo division = (Modulo)operation;
return(Execute(division.Dividend, functionRegistry, constantRegistry, variables) % Execute(division.Divisor, functionRegistry, constantRegistry, variables));
}
else if (operation.GetType() == typeof(Exponentiation))
{
Exponentiation exponentiation = (Exponentiation)operation;
return(Math.Pow(Execute(exponentiation.Base, functionRegistry, constantRegistry, variables), Execute(exponentiation.Exponent, functionRegistry, constantRegistry, variables)));
}
else if (operation.GetType() == typeof(UnaryMinus))
{
UnaryMinus unaryMinus = (UnaryMinus)operation;
return(-Execute(unaryMinus.Argument, functionRegistry, constantRegistry, variables));
}
else if (operation.GetType() == typeof(And))
{
And and = (And)operation;
var operation1 = Execute(and.Argument1, functionRegistry, constantRegistry, variables) != 0;
var operation2 = Execute(and.Argument2, functionRegistry, constantRegistry, variables) != 0;
return((operation1 && operation2) ? 1.0 : 0.0);
}
else if (operation.GetType() == typeof(Or))
{
Or or = (Or)operation;
var operation1 = Execute(or.Argument1, functionRegistry, constantRegistry, variables) != 0;
var operation2 = Execute(or.Argument2, functionRegistry, constantRegistry, variables) != 0;
return((operation1 || operation2) ? 1.0 : 0.0);
}
else if (operation.GetType() == typeof(LessThan))
{
LessThan lessThan = (LessThan)operation;
return((Execute(lessThan.Argument1, functionRegistry, constantRegistry, variables) < Execute(lessThan.Argument2, functionRegistry, constantRegistry, variables)) ? 1.0 : 0.0);
}
else if (operation.GetType() == typeof(LessOrEqualThan))
{
LessOrEqualThan lessOrEqualThan = (LessOrEqualThan)operation;
return((Execute(lessOrEqualThan.Argument1, functionRegistry, constantRegistry, variables) <= Execute(lessOrEqualThan.Argument2, functionRegistry, constantRegistry, variables)) ? 1.0 : 0.0);
}
else if (operation.GetType() == typeof(GreaterThan))
{
GreaterThan greaterThan = (GreaterThan)operation;
return((Execute(greaterThan.Argument1, functionRegistry, constantRegistry, variables) > Execute(greaterThan.Argument2, functionRegistry, constantRegistry, variables)) ? 1.0 : 0.0);
}
else if (operation.GetType() == typeof(GreaterOrEqualThan))
{
GreaterOrEqualThan greaterOrEqualThan = (GreaterOrEqualThan)operation;
return((Execute(greaterOrEqualThan.Argument1, functionRegistry, constantRegistry, variables) >= Execute(greaterOrEqualThan.Argument2, functionRegistry, constantRegistry, variables)) ? 1.0 : 0.0);
}
else if (operation.GetType() == typeof(Equal))
{
Equal equal = (Equal)operation;
return((Execute(equal.Argument1, functionRegistry, constantRegistry, variables) == Execute(equal.Argument2, functionRegistry, constantRegistry, variables)) ? 1.0 : 0.0);
}
else if (operation.GetType() == typeof(NotEqual))
{
NotEqual notEqual = (NotEqual)operation;
return((Execute(notEqual.Argument1, functionRegistry, constantRegistry, variables) != Execute(notEqual.Argument2, functionRegistry, constantRegistry, variables)) ? 1.0 : 0.0);
}
else if (operation.GetType() == typeof(Function))
{
Function function = (Function)operation;
FunctionInfo functionInfo = functionRegistry.GetFunctionInfo(function.FunctionName);
double[] arguments = new double[functionInfo.IsDynamicFunc ? function.Arguments.Count : functionInfo.NumberOfParameters];
for (int i = 0; i < arguments.Length; i++)
{
arguments[i] = Execute(function.Arguments[i], functionRegistry, constantRegistry, variables);
}
return(Invoke(functionInfo.Function, arguments));
}
else
{
throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation");
}
}
public ModuloPessoaTests()
{
testOutputHelper = new Mock <ITestOutputHelper>();
_modulo = new PessoaModulo(testOutputHelper.Object);
}
void MulDivMod(out Expression exp)
{
Expression second;
UnaryOperator(out exp);
while (la.kind == 42 || la.kind == 43 || la.kind == 44) {
if (la.kind == 42) {
Get();
} else if (la.kind == 43) {
Get();
} else {
Get();
}
Token tok = t;
UnaryOperator(out second);
if (!ExpectInt(exp, tok, false)) { return; }
if (!ExpectInt(second, tok, true)) { return; }
if (tok.val == "*") {
exp = new Multiplication((TypedExpression<int>)exp, (TypedExpression<int>)second);
} else if (tok.val == "/") {
exp = new Division((TypedExpression<int>)exp, (TypedExpression<int>)second);
} else if (tok.val == "%") {
exp = new Modulo((TypedExpression<int>)exp, (TypedExpression<int>)second);
}
}
}
public async Task <IActionResult> Run(int?id)
{
MyLogger.Log(messaggio: $"Richiesta GET con id {id}", controller: "ProgettoController", metodo: "Run");
var progetto = await _context.Progetti
.Include(list => list.ModuliProgetto)
.ThenInclude(mod => mod.Modulo)
.AsNoTracking()
.SingleOrDefaultAsync(m => m.ID == id);
//List<string> result = new List<string>();
var data = DateTime.Now;
Report report = new Report
{
ProgettoID = progetto.ID,
Data = data
};
List <string> percorsi = new List <string>();
string cartellaProgetto = Globals.CreaCartellaScan(progetto.Nome, data);
foreach (ModuliProgetto modprog in progetto.ModuliProgetto)
{
Modulo modulo = modprog.Modulo;
string nomeFile = CreaNomeFile(modulo.Applicazione, modulo.Nome);
string comando = CreaComando(modulo, modprog.Target, Path.Combine(progetto.Nome, data.ToString("dd-MM-yyyy_HH-mm")), nomeFile, percorsi);
MyLogger.Log(messaggio: $"\tModulo {modulo.Applicazione.ToString()} - {modulo.Nome}, esecuzione comando: {comando} ...", controller: "ProgettoController", metodo: "Run");
comando.EseguiCLI(cartellaProgetto);
MyLogger.Log(messaggio: $"\tFine esecuzione comando", controller: "ProgettoController", metodo: "Run");
}
_context.Report.Add(report);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.)
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists, " +
"see your system administrator.");
}
foreach (var percorso in percorsi)
{
Globals.AggiungiIntestazione(percorso, _context);
}
var ID = _context.Report.SingleOrDefault(x => x.ProgettoID == progetto.ID && x.Data == data).ID;
foreach (var percorso in percorsi)
{
_context.PercorsiReport.Add(new PercorsiReport
{
ReportID = ID,
Percorso = percorso
});
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.)
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists, " +
"see your system administrator.");
}
MyLogger.Log(messaggio: $"\tFine esecuzione scan. Report con id {ID} salvato.", controller: "ProgettoController", metodo: "Run");
//return View(new RisultatoVM { NomeProgetto = progetto.Nome, risultati = risultati });
return(Redirect(Url.Action($"Details/{report.ID}", "Report").Replace("%2F", "/")));
}
private void GenerateMethodBody(ILGenerator generator, Operation operation,
IFunctionRegistry functionRegistry)
{
if (operation == null)
{
throw new ArgumentNullException("operation");
}
if (operation.GetType() == typeof(IntegerConstant))
{
IntegerConstant constant = (IntegerConstant)operation;
generator.Emit(OpCodes.Ldc_I4, constant.Value);
generator.Emit(OpCodes.Conv_R8);
}
else if (operation.GetType() == typeof(FloatingPointConstant))
{
FloatingPointConstant constant = (FloatingPointConstant)operation;
generator.Emit(OpCodes.Ldc_R8, constant.Value);
}
else if (operation.GetType() == typeof(Variable))
{
Type dictionaryType = typeof(IDictionary <string, double>);
Variable variable = (Variable)operation;
Label throwExceptionLabel = generator.DefineLabel();
Label returnLabel = generator.DefineLabel();
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Callvirt, typeof(FormulaContext).GetProperty("Variables").GetGetMethod());
generator.Emit(OpCodes.Ldstr, variable.Name);
generator.Emit(OpCodes.Ldloca_S, (byte)0);
generator.Emit(OpCodes.Callvirt, dictionaryType.GetMethod("TryGetValue", new Type[] { typeof(string), typeof(double).MakeByRefType() }));
generator.Emit(OpCodes.Ldc_I4_0);
generator.Emit(OpCodes.Ceq);
generator.Emit(OpCodes.Brtrue_S, throwExceptionLabel);
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Br_S, returnLabel);
generator.MarkLabel(throwExceptionLabel);
generator.Emit(OpCodes.Ldstr, string.Format("The variable \"{0}\" used is not defined.", variable.Name));
generator.Emit(OpCodes.Newobj, typeof(VariableNotDefinedException).GetConstructor(new Type[] { typeof(string) }));
generator.Emit(OpCodes.Throw);
generator.MarkLabel(returnLabel);
}
else if (operation.GetType() == typeof(Multiplication))
{
Multiplication multiplication = (Multiplication)operation;
GenerateMethodBody(generator, multiplication.Argument1, functionRegistry);
GenerateMethodBody(generator, multiplication.Argument2, functionRegistry);
generator.Emit(OpCodes.Mul);
}
else if (operation.GetType() == typeof(Addition))
{
Addition addition = (Addition)operation;
GenerateMethodBody(generator, addition.Argument1, functionRegistry);
GenerateMethodBody(generator, addition.Argument2, functionRegistry);
generator.Emit(OpCodes.Add);
}
else if (operation.GetType() == typeof(Subtraction))
{
Subtraction addition = (Subtraction)operation;
GenerateMethodBody(generator, addition.Argument1, functionRegistry);
GenerateMethodBody(generator, addition.Argument2, functionRegistry);
generator.Emit(OpCodes.Sub);
}
else if (operation.GetType() == typeof(Division))
{
Division division = (Division)operation;
GenerateMethodBody(generator, division.Dividend, functionRegistry);
GenerateMethodBody(generator, division.Divisor, functionRegistry);
generator.Emit(OpCodes.Div);
}
else if (operation.GetType() == typeof(Modulo))
{
Modulo modulo = (Modulo)operation;
GenerateMethodBody(generator, modulo.Dividend, functionRegistry);
GenerateMethodBody(generator, modulo.Divisor, functionRegistry);
generator.Emit(OpCodes.Rem);
}
else if (operation.GetType() == typeof(Exponentiation))
{
Exponentiation exponentation = (Exponentiation)operation;
GenerateMethodBody(generator, exponentation.Base, functionRegistry);
GenerateMethodBody(generator, exponentation.Exponent, functionRegistry);
generator.Emit(OpCodes.Call, typeof(Math).GetMethod("Pow"));
}
else if (operation.GetType() == typeof(UnaryMinus))
{
UnaryMinus unaryMinus = (UnaryMinus)operation;
GenerateMethodBody(generator, unaryMinus.Argument, functionRegistry);
generator.Emit(OpCodes.Neg);
}
else if (operation.GetType() == typeof(LessThan))
{
LessThan lessThan = (LessThan)operation;
Label ifLabel = generator.DefineLabel();
Label endLabel = generator.DefineLabel();
GenerateMethodBody(generator, lessThan.Argument1, functionRegistry);
GenerateMethodBody(generator, lessThan.Argument2, functionRegistry);
generator.Emit(OpCodes.Blt_S, ifLabel);
generator.Emit(OpCodes.Ldc_R8, 0.0);
generator.Emit(OpCodes.Br_S, endLabel);
generator.MarkLabel(ifLabel);
generator.Emit(OpCodes.Ldc_R8, 1.0);
generator.MarkLabel(endLabel);
}
else if (operation.GetType() == typeof(LessOrEqualThan))
{
LessOrEqualThan lessOrEqualThan = (LessOrEqualThan)operation;
Label ifLabel = generator.DefineLabel();
Label endLabel = generator.DefineLabel();
GenerateMethodBody(generator, lessOrEqualThan.Argument1, functionRegistry);
GenerateMethodBody(generator, lessOrEqualThan.Argument2, functionRegistry);
generator.Emit(OpCodes.Ble_S, ifLabel);
generator.Emit(OpCodes.Ldc_R8, 0.0);
generator.Emit(OpCodes.Br_S, endLabel);
generator.MarkLabel(ifLabel);
generator.Emit(OpCodes.Ldc_R8, 1.0);
generator.MarkLabel(endLabel);
}
else if (operation.GetType() == typeof(GreaterThan))
{
GreaterThan greaterThan = (GreaterThan)operation;
Label ifLabel = generator.DefineLabel();
Label endLabel = generator.DefineLabel();
GenerateMethodBody(generator, greaterThan.Argument1, functionRegistry);
GenerateMethodBody(generator, greaterThan.Argument2, functionRegistry);
generator.Emit(OpCodes.Bgt_S, ifLabel);
generator.Emit(OpCodes.Ldc_R8, 0.0);
generator.Emit(OpCodes.Br_S, endLabel);
generator.MarkLabel(ifLabel);
generator.Emit(OpCodes.Ldc_R8, 1.0);
generator.MarkLabel(endLabel);
}
else if (operation.GetType() == typeof(GreaterOrEqualThan))
{
GreaterOrEqualThan greaterOrEqualThan = (GreaterOrEqualThan)operation;
Label ifLabel = generator.DefineLabel();
Label endLabel = generator.DefineLabel();
GenerateMethodBody(generator, greaterOrEqualThan.Argument1, functionRegistry);
GenerateMethodBody(generator, greaterOrEqualThan.Argument2, functionRegistry);
generator.Emit(OpCodes.Bge_S, ifLabel);
generator.Emit(OpCodes.Ldc_R8, 0.0);
generator.Emit(OpCodes.Br_S, endLabel);
generator.MarkLabel(ifLabel);
generator.Emit(OpCodes.Ldc_R8, 1.0);
generator.MarkLabel(endLabel);
}
else if (operation.GetType() == typeof(Equal))
{
Equal equal = (Equal)operation;
Label ifLabel = generator.DefineLabel();
Label endLabel = generator.DefineLabel();
GenerateMethodBody(generator, equal.Argument1, functionRegistry);
GenerateMethodBody(generator, equal.Argument2, functionRegistry);
generator.Emit(OpCodes.Beq_S, ifLabel);
generator.Emit(OpCodes.Ldc_R8, 0.0);
generator.Emit(OpCodes.Br_S, endLabel);
generator.MarkLabel(ifLabel);
generator.Emit(OpCodes.Ldc_R8, 1.0);
generator.MarkLabel(endLabel);
}
else if (operation.GetType() == typeof(NotEqual))
{
NotEqual notEqual = (NotEqual)operation;
Label ifLabel = generator.DefineLabel();
Label endLabel = generator.DefineLabel();
GenerateMethodBody(generator, notEqual.Argument1, functionRegistry);
GenerateMethodBody(generator, notEqual.Argument2, functionRegistry);
generator.Emit(OpCodes.Beq, ifLabel);
generator.Emit(OpCodes.Ldc_R8, 1.0);
generator.Emit(OpCodes.Br_S, endLabel);
generator.MarkLabel(ifLabel);
generator.Emit(OpCodes.Ldc_R8, 0.0);
generator.MarkLabel(endLabel);
}
else if (operation.GetType() == typeof(Function))
{
Function function = (Function)operation;
FunctionInfo functionInfo = functionRegistry.GetFunctionInfo(function.FunctionName);
Type funcType = GetFuncType(functionInfo.NumberOfParameters);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Callvirt, typeof(FormulaContext).GetProperty("FunctionRegistry").GetGetMethod());
generator.Emit(OpCodes.Ldstr, function.FunctionName);
generator.Emit(OpCodes.Callvirt, typeof(IFunctionRegistry).GetMethod("GetFunctionInfo", new Type[] { typeof(string) }));
generator.Emit(OpCodes.Callvirt, typeof(FunctionInfo).GetProperty("Function").GetGetMethod());
generator.Emit(OpCodes.Castclass, funcType);
for (int i = 0; i < functionInfo.NumberOfParameters; i++)
{
GenerateMethodBody(generator, function.Arguments[i], functionRegistry);
}
generator.Emit(OpCodes.Call, funcType.GetMethod("Invoke"));
}
else
{
throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation");
}
}
internal void AddModulo(Modulo toAdd)
{
modulos.Add(toAdd);
}
public virtual void Visit(Modulo node)
{
}
public UsuarioModuloId(Usuario usuario, Modulo modulo)
{
this._usuario= usuario;
this._modulo= modulo;
}
private IEnumerable<string> EvaluateVariable(Modulo.Collect.OVAL.Definitions.EntityObjectStringType variableNameEntity, VariablesEvaluated variables)
{
var variableEvaluator = new VariableEntityEvaluator(variables);
return variableEvaluator.EvaluateVariableForEntity(variableNameEntity);
}
private void CmdIzquierdaClick(object sender, EventArgs e)
{
foreach (var item in lstDestino.SelectedItems)
{
if (item == null)
{
continue;
}
var perfil = item as UsuarioModulo;
var modulo = new Modulo();
modulo = perfil.Id.Modulo;
(bsOrigen.DataSource as List<Modulo>).Add(modulo);
(bsDestino.DataSource as List<UsuarioModulo>).Remove(perfil);
lstOrigen.Refresh();
lstDestino.Refresh();
}
}
public void TestSimpleModule()
{
var mod = new Modulo(new Property("Left"), new Property("Right"));
Assert.That(mod.Evaluate(new Reflection(this)), Is.EqualTo(7));
}
internal void RemoveModulo(Modulo toRemove)
{
modulos.Remove(toRemove);
}
protected override set GetSetElement(Modulo.Collect.OVAL.Definitions.ObjectType objectType)
{
var setElement = ((file_object)objectType).GetItemValue(file_object_ItemsChoices.set);
return (set)setElement;
}
private Expression GenerateMethodBody(Operation operation, ParameterExpression contextParameter,
IFunctionRegistry functionRegistry)
{
if (operation == null)
{
throw new ArgumentNullException("operation");
}
if (operation.GetType() == typeof(IntegerConstant))
{
IntegerConstant constant = (IntegerConstant)operation;
double value = constant.Value;
return(Expression.Constant(value, typeof(double)));
}
else if (operation.GetType() == typeof(FloatingPointConstant))
{
FloatingPointConstant constant = (FloatingPointConstant)operation;
return(Expression.Constant(constant.Value, typeof(double)));
}
else if (operation.GetType() == typeof(Variable))
{
Variable variable = (Variable)operation;
Func <string, FormulaContext, double> getVariableValueOrThrow = PrecompiledMethods.GetVariableValueOrThrow;
return(Expression.Call(null,
getVariableValueOrThrow.GetMethodInfo(),
Expression.Constant(variable.Name),
contextParameter));
}
else if (operation.GetType() == typeof(Multiplication))
{
Multiplication multiplication = (Multiplication)operation;
Expression argument1 = GenerateMethodBody(multiplication.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(multiplication.Argument2, contextParameter, functionRegistry);
return(Expression.Multiply(argument1, argument2));
}
else if (operation.GetType() == typeof(Addition))
{
Addition addition = (Addition)operation;
Expression argument1 = GenerateMethodBody(addition.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(addition.Argument2, contextParameter, functionRegistry);
return(Expression.Add(argument1, argument2));
}
else if (operation.GetType() == typeof(Subtraction))
{
Subtraction addition = (Subtraction)operation;
Expression argument1 = GenerateMethodBody(addition.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(addition.Argument2, contextParameter, functionRegistry);
return(Expression.Subtract(argument1, argument2));
}
else if (operation.GetType() == typeof(Division))
{
Division division = (Division)operation;
Expression dividend = GenerateMethodBody(division.Dividend, contextParameter, functionRegistry);
Expression divisor = GenerateMethodBody(division.Divisor, contextParameter, functionRegistry);
return(Expression.Divide(dividend, divisor));
}
else if (operation.GetType() == typeof(Modulo))
{
Modulo modulo = (Modulo)operation;
Expression dividend = GenerateMethodBody(modulo.Dividend, contextParameter, functionRegistry);
Expression divisor = GenerateMethodBody(modulo.Divisor, contextParameter, functionRegistry);
return(Expression.Modulo(dividend, divisor));
}
else if (operation.GetType() == typeof(Exponentiation))
{
Exponentiation exponentation = (Exponentiation)operation;
Expression @base = GenerateMethodBody(exponentation.Base, contextParameter, functionRegistry);
Expression exponent = GenerateMethodBody(exponentation.Exponent, contextParameter, functionRegistry);
return(Expression.Call(null, typeof(Math).GetRuntimeMethod("Pow", new Type[] { typeof(double), typeof(double) }), @base, exponent));
}
else if (operation.GetType() == typeof(UnaryMinus))
{
UnaryMinus unaryMinus = (UnaryMinus)operation;
Expression argument = GenerateMethodBody(unaryMinus.Argument, contextParameter, functionRegistry);
return(Expression.Negate(argument));
}
else if (operation.GetType() == typeof(And))
{
And and = (And)operation;
Expression argument1 = Expression.NotEqual(GenerateMethodBody(and.Argument1, contextParameter, functionRegistry), Expression.Constant(0.0));
Expression argument2 = Expression.NotEqual(GenerateMethodBody(and.Argument2, contextParameter, functionRegistry), Expression.Constant(0.0));
return(Expression.Condition(Expression.And(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(Or))
{
Or and = (Or)operation;
Expression argument1 = Expression.NotEqual(GenerateMethodBody(and.Argument1, contextParameter, functionRegistry), Expression.Constant(0.0));
Expression argument2 = Expression.NotEqual(GenerateMethodBody(and.Argument2, contextParameter, functionRegistry), Expression.Constant(0.0));
return(Expression.Condition(Expression.Or(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(LessThan))
{
LessThan lessThan = (LessThan)operation;
Expression argument1 = GenerateMethodBody(lessThan.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(lessThan.Argument2, contextParameter, functionRegistry);
return(Expression.Condition(Expression.LessThan(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(LessOrEqualThan))
{
LessOrEqualThan lessOrEqualThan = (LessOrEqualThan)operation;
Expression argument1 = GenerateMethodBody(lessOrEqualThan.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(lessOrEqualThan.Argument2, contextParameter, functionRegistry);
return(Expression.Condition(Expression.LessThanOrEqual(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(GreaterThan))
{
GreaterThan greaterThan = (GreaterThan)operation;
Expression argument1 = GenerateMethodBody(greaterThan.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(greaterThan.Argument2, contextParameter, functionRegistry);
return(Expression.Condition(Expression.GreaterThan(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(GreaterOrEqualThan))
{
GreaterOrEqualThan greaterOrEqualThan = (GreaterOrEqualThan)operation;
Expression argument1 = GenerateMethodBody(greaterOrEqualThan.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(greaterOrEqualThan.Argument2, contextParameter, functionRegistry);
return(Expression.Condition(Expression.GreaterThanOrEqual(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(Equal))
{
Equal equal = (Equal)operation;
Expression argument1 = GenerateMethodBody(equal.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(equal.Argument2, contextParameter, functionRegistry);
return(Expression.Condition(Expression.Equal(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(NotEqual))
{
NotEqual notEqual = (NotEqual)operation;
Expression argument1 = GenerateMethodBody(notEqual.Argument1, contextParameter, functionRegistry);
Expression argument2 = GenerateMethodBody(notEqual.Argument2, contextParameter, functionRegistry);
return(Expression.Condition(Expression.NotEqual(argument1, argument2),
Expression.Constant(1.0),
Expression.Constant(0.0)));
}
else if (operation.GetType() == typeof(Function))
{
Function function = (Function)operation;
FunctionInfo functionInfo = functionRegistry.GetFunctionInfo(function.FunctionName);
Type funcType;
Type[] parameterTypes;
Expression[] arguments;
if (functionInfo.IsDynamicFunc)
{
funcType = typeof(DynamicFunc <double, double>);
parameterTypes = new Type[] { typeof(double[]) };
Expression[] arrayArguments = new Expression[function.Arguments.Count];
for (int i = 0; i < function.Arguments.Count; i++)
{
arrayArguments[i] = GenerateMethodBody(function.Arguments[i], contextParameter, functionRegistry);
}
arguments = new Expression[1];
arguments[0] = NewArrayExpression.NewArrayInit(typeof(double), arrayArguments);
}
else
{
funcType = GetFuncType(functionInfo.NumberOfParameters);
parameterTypes = (from i in Enumerable.Range(0, functionInfo.NumberOfParameters)
select typeof(double)).ToArray();
arguments = new Expression[functionInfo.NumberOfParameters];
for (int i = 0; i < functionInfo.NumberOfParameters; i++)
{
arguments[i] = GenerateMethodBody(function.Arguments[i], contextParameter, functionRegistry);
}
}
Expression getFunctionRegistry = Expression.Property(contextParameter, "FunctionRegistry");
ParameterExpression functionInfoVariable = Expression.Variable(typeof(FunctionInfo));
Expression funcInstance;
if (!functionInfo.IsOverWritable)
{
funcInstance = Expression.Convert(
Expression.Property(
Expression.Call(
getFunctionRegistry,
typeof(IFunctionRegistry).GetRuntimeMethod("GetFunctionInfo", new Type[] { typeof(string) }),
Expression.Constant(function.FunctionName)),
"Function"),
funcType);
}
else
{
funcInstance = Expression.Constant(functionInfo.Function, funcType);
}
return(Expression.Call(
funcInstance,
funcType.GetRuntimeMethod("Invoke", parameterTypes),
arguments));
}
else
{
throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation");
}
}
public Rol CargaRolPermisos(int nRolId)
{
List <Menu> ListMenu = oConfiguracionAD.ListarMenuRol(nRolId);
List <Modulo> ListModulo = oConfiguracionAD.ListarModuloRol(nRolId);
List <Permiso> ListPermiso = oConfiguracionAD.ListarPermisoRol(nRolId);
var RolPermisos = from lm in ListMenu
select new
{
lm.nMenuId,
lm.cMenuDesc,
lm.bEstado,
ListaModulos = from lmo1 in ListModulo
join lm2 in ListMenu
on lmo1.nMenuId equals lm2.nMenuId
where lmo1.nMenuId == lm.nMenuId
select new
{
lmo1.nModId,
lmo1.nMenuId,
lmo1.cModDesc,
lmo1.bEstado,
ListaPermisos = from lp in ListPermiso
join lmo2 in ListModulo
on lp.nModId equals lmo2.nModId
where lp.nModId == lmo1.nModId
select new
{
lp.nPermId,
lp.nModId,
lp.cPermDesc,
lp.bEstado
}
}
};
Rol oRolPermisos = new Rol();
oRolPermisos.nRolId = nRolId;
foreach (var menu in RolPermisos)
{
Menu oMenu = new Menu();
oMenu.nMenuId = menu.nMenuId;
oMenu.cMenuDesc = menu.cMenuDesc;
oMenu.bEstado = menu.bEstado;
foreach (var modulo in menu.ListaModulos)
{
Modulo oModulo = new Modulo();
oModulo.nModId = modulo.nModId;
oModulo.nMenuId = modulo.nMenuId;
oModulo.cModDesc = modulo.cModDesc;
oModulo.bEstado = modulo.bEstado;
foreach (var permiso in modulo.ListaPermisos)
{
Permiso oPermiso = new Permiso();
oPermiso.nPermId = permiso.nPermId;
oPermiso.nModId = permiso.nModId;
oPermiso.cPermDesc = permiso.cPermDesc;
oPermiso.bEstado = permiso.bEstado;
oModulo.ListaPermisos.Add(oPermiso);
}
oMenu.ListaModulos.Add(oModulo);
}
oRolPermisos.ListaMenus.Add(oMenu);
}
return(oRolPermisos);
}
public static void Inicializa(AppDbContext context)
{
context.Database.EnsureCreated();
#region Usuarios
if (context.Usuarios.Any())
{
return;
}
var usuarios = new Usuario[]
{
new Usuario {
Codigo = 1, Nome = "LUCIO", Login = "******", Senha = "123", Status = true
},
new Usuario {
Codigo = 2, Nome = "MARCO", Login = "******", Senha = "123", Status = true
},
new Usuario {
Codigo = 3, Nome = "EDUARDO", Login = "******", Senha = "123", Status = true
}
};
foreach (Usuario p in usuarios)
{
context.Usuarios.Add(p);
}
context.SaveChanges();
#endregion
#region Perfis
if (context.Perfis.Any())
{
return;
}
var perfis = new Perfil[]
{
new Perfil {
Codigo = 1, Nome = "DIRETORIA"
},
new Perfil {
Codigo = 2, Nome = "GERENTE"
},
new Perfil {
Codigo = 3, Nome = "CAIXA"
}
};
foreach (Perfil p in perfis)
{
context.Perfis.Add(p);
}
context.SaveChanges();
#endregion
#region Modulos
if (context.Modulos.Any())
{
return;
}
var modulos = new Modulo[]
{
new Modulo {
Codigo = "TAB009A", Nome = "CADASTRO DE PRODUTOS", Status = true
},
new Modulo {
Codigo = "TAB001A", Nome = "CADASTRO DE CLIENTES", Status = true
},
new Modulo {
Codigo = "TAB002A", Nome = "CADASTRO DE FORNECEDORES", Status = true
}
};
foreach (Modulo p in modulos)
{
context.Modulos.Add(p);
}
context.SaveChanges();
#endregion
}
public VariableCalcurator Execute(Operation operation, IFunctionRegistry functionRegistry,
IDictionary <string, VariableCalcurator> variables)
{
VariableCalcurator.defaultVariables = variables;
if (operation == null)
{
throw new ArgumentNullException("operation");
}
/*
* if (operation.GetType() == typeof(IntegerConstant))
* {
* IntegerConstant constant = (IntegerConstant)operation;
* return constant.Value;
* }
* else if (operation.GetType() == typeof(FloatingPointConstant))
* {
* FloatingPointConstant constant = (FloatingPointConstant)operation;
* return constant.Value;
* }
* else*/
if (operation.GetType() == typeof(VariableCalcurator))
{
VariableCalcurator variable = (VariableCalcurator)operation;
/*
* if (variable.DataType == DataType.Literal)
* return new VariableCalcurator(DataType.Literal, variable.Literal());
* else if(variable.DataType == DataType.Identifier)
* {
* bool variableFound = variables.ContainsKey(variable.Literal());
*
* if (variableFound)
* return variables[variable.Literal()];
*
* else
* return variable;
* throw new VariableNotDefinedException(string.Format("The variable \"{0}\" used is not defined.", variable.Literal()));
* }
*/
return(variable);
}
else if (operation.GetType() == typeof(Multiplication))
{
Multiplication multiplication = (Multiplication)operation;
return(Execute(multiplication.Argument1, functionRegistry, variables).GetInstance() * Execute(multiplication.Argument2, functionRegistry, variables).GetInstance());
}
else if (operation.GetType() == typeof(Addition))
{
Addition addition = (Addition)operation;
return(Execute(addition.Argument1, functionRegistry, variables).GetInstance() + Execute(addition.Argument2, functionRegistry, variables).GetInstance());
}
else if (operation.GetType() == typeof(Subtraction))
{
Subtraction addition = (Subtraction)operation;
return(Execute(addition.Argument1, functionRegistry, variables).GetInstance() - Execute(addition.Argument2, functionRegistry, variables).GetInstance());
}
else if (operation.GetType() == typeof(Division))
{
Division division = (Division)operation;
return(Execute(division.Dividend, functionRegistry, variables).GetInstance() / Execute(division.Divisor, functionRegistry, variables).GetInstance());
}
else if (operation.GetType() == typeof(Modulo))
{
Modulo division = (Modulo)operation;
return(Execute(division.Dividend, functionRegistry, variables).GetInstance() % Execute(division.Divisor, functionRegistry, variables).GetInstance());
}
else if (operation.GetType() == typeof(Exponentiation))
{
Exponentiation exponentiation = (Exponentiation)operation;
return(new VariableCalcurator((float)Math.Pow(Execute(exponentiation.Base, functionRegistry, variables).GetInstance().Float(), Execute(exponentiation.Exponent, functionRegistry, variables).GetInstance().Float())));
}
else if (operation.GetType() == typeof(UnaryMinus))
{
UnaryMinus unaryMinus = (UnaryMinus)operation;
return(-Execute(unaryMinus.Argument, functionRegistry, variables).GetInstance());
}
else if (operation.GetType() == typeof(LessThan))
{
LessThan lessThan = (LessThan)operation;
return(Execute(lessThan.Argument1, functionRegistry, variables).GetInstance() < Execute(lessThan.Argument2, functionRegistry, variables).GetInstance());
}
else if (operation.GetType() == typeof(LessOrEqualThan))
{
LessOrEqualThan lessOrEqualThan = (LessOrEqualThan)operation;
return(Execute(lessOrEqualThan.Argument1, functionRegistry, variables).GetInstance() <= Execute(lessOrEqualThan.Argument2, functionRegistry, variables).GetInstance());
}
else if (operation.GetType() == typeof(GreaterThan))
{
GreaterThan greaterThan = (GreaterThan)operation;
return(Execute(greaterThan.Argument1, functionRegistry, variables).GetInstance() > Execute(greaterThan.Argument2, functionRegistry, variables).GetInstance());
}
else if (operation.GetType() == typeof(GreaterOrEqualThan))
{
GreaterOrEqualThan greaterOrEqualThan = (GreaterOrEqualThan)operation;
return(Execute(greaterOrEqualThan.Argument1, functionRegistry, variables).GetInstance() >= Execute(greaterOrEqualThan.Argument2, functionRegistry, variables).GetInstance());
}
else if (operation.GetType() == typeof(Equal))
{
Equal equal = (Equal)operation;
return(Execute(equal.Argument1, functionRegistry, variables).GetInstance() == Execute(equal.Argument2, functionRegistry, variables).GetInstance());
}
else if (operation.GetType() == typeof(NotEqual))
{
NotEqual notEqual = (NotEqual)operation;
return(Execute(notEqual.Argument1, functionRegistry, variables).GetInstance() != Execute(notEqual.Argument2, functionRegistry, variables).GetInstance());
}
else if (operation.GetType() == typeof(Index))
{
Index index = (Index)operation;
return(Index(Execute(index.Argument1, functionRegistry, variables), Execute(index.Argument2, functionRegistry, variables), variables));
}
else if (operation.GetType() == typeof(Substitution))
{
Substitution substitution = (Substitution)operation;
return(Substitute(Execute(substitution.Argument1, functionRegistry, variables), Execute(substitution.Argument2, functionRegistry, variables), variables));
}
/*
* else if (operation.GetType() == typeof(Function))
* {
* Function function = (Function)operation;
*
* FunctionInfo functionInfo = functionRegistry.GetFunctionInfo(function.FunctionName);
*
* double[] arguments = new double[functionInfo.IsDynamicFunc ? function.Arguments.Count : functionInfo.NumberOfParameters];
* for (int i = 0; i < arguments.Length; i++)
* arguments[i] = Execute(function.Arguments[i], functionRegistry, variables);
*
* return Invoke(functionInfo.Function, arguments);
* }
*/
else
{
throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation");
}
}
private string CreaComando(Modulo mod, string target, string cartella, string nomeFile, List <string> percorsi)
{
//Controllo di che tipo è il modulo
string regex = "s/\x1B\\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]//g";
if (mod is ModuloNMAP)
{
// Inserisco il comando generato dal modulo, il target e la direttiva
// per esportare un xml con nome derivato dal timestamp e dal nome del modulo
string comando = $"touch {nomeFile}.xml ; sudo {mod.Comando} -oX {nomeFile}.xml --webxml {target}";
var percorsoFile = Path.Combine(cartella, nomeFile + ".xml");
percorsi.Add(percorsoFile);
return(comando);
}
if (mod is ModuloSERVER || mod is ModuloOPENVAS)
{
// Qui non viene usato il comando perché si verrà reindirizzati fuori tramite python,
// soluzione compatibile con quasi tutti i SO
return("python -mwebbrowser " + mod.Comando);
}
if (mod is ModuloDNSRECON)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "dnsrecon");
string comando = $"python {percorsoExec}/{mod.Comando} -d {target} --xml {nomeFile}.xml";
percorsi.Add(Path.Combine(cartella, nomeFile + ".xml"));
return(comando);
}
if (mod is ModuloFIERCE)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "fierce", "fierce");
string comando = $"python3 -u {percorsoExec}/{mod.Comando} --domain {target} | sed -r \"{regex}\" | tee {nomeFile}.txt";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
if (mod is ModuloDROOPE)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "droopescan");
string comando = $"python -u {percorsoExec}/{mod.Comando} -u {target} | sed -r \"{regex}\" | tee {nomeFile}.txt";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
if (mod is ModuloINFOGA)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "Infoga");
string comando = $"python3 -u {percorsoExec}/{mod.Comando} -d {target} | sed -r \"{regex}\" | tee {nomeFile}.txt";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
if (mod is ModuloINFOGAEMAIL)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "Infoga");
string comando = $"python3 -u {percorsoExec}/{mod.Comando} --info {target} | sed -r \"{regex}\" | tee {nomeFile}.txt";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
if (mod is ModuloSUBLIST3R)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "Sublist3r");
string comando = $"python {percorsoExec}/{mod.Comando} -d {target} -o {nomeFile}.txt";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
if (mod is ModuloWAPITI)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "wapiti");
string comando = $"python3 {percorsoExec}/{mod.Comando} -u {target} -f txt -o {nomeFile}.txt";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
if (mod is ModuloOPENDOOR)
{
string comando = $"cd /usr/local/bin && {mod.Comando} --host {target} | sed -r \"{regex}\" | tee {Path.Combine(Globals.CARTELLAREPORT, cartella, nomeFile).Replace(" ",@"\ ")}.txt ";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
if (mod is ModuloSQLMAP)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "sqlmap");
string comando = $"python {percorsoExec}/{mod.Comando} -u {target} | sed -r \"{regex}\" | tee {nomeFile}.txt ";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
if (mod is ModuloWIFITE)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "wifite2");
string comando = $"sudo python {percorsoExec}/{mod.Comando}";
return(comando);
}
if (mod is ModuloNOSQL)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "NoSQLMap");
string comando = $"python {percorsoExec}/{mod.Comando}";
return(comando);
}
if (mod is ModuloJOOMSCAN)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "joomscan");
string comando = $"perl {percorsoExec}/{mod.Comando} -u {target} | sed -r \"{regex}\" | tee {nomeFile}.txt ";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
if (mod is ModuloWPSCAN)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "wpscan");
string comando = $"ruby {percorsoExec}/{mod.Comando} -u {target} --log {Path.Combine(Globals.CARTELLAREPORT, cartella, nomeFile).Replace(" ", @"\ ")}.txt ";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
if (mod is ModuloWASCAN)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "WAScan");
string comando = $"python -u {percorsoExec}/{mod.Comando} -u {target} | sed -r \"{regex}\" | tee {nomeFile}.txt ";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
if (mod is ModuloDNSENUM)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "dnsenum");
string comando = $"perl {percorsoExec}/{mod.Comando} {target} -o {nomeFile}.xml ";
percorsi.Add(Path.Combine(cartella, nomeFile + ".xml"));
return(comando);
}
if (mod is ModuloODAT)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "odat");
string comando = $"python -u {percorsoExec}/{mod.Comando} -s {target} | sed -r \"{regex}\" | tee {nomeFile}.txt ";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
if (mod is ModuloTHEHARVESTER)
{
string percorsoExec = Path.Combine(Globals.CartellaWEBMVA, "Programmi", "theHarvester");
string comando = $"python2 -u {percorsoExec}/{mod.Comando} -d {target} -f {nomeFile}.html";
percorsi.Add(Path.Combine(cartella, nomeFile + ".html"));
return(comando);
}
if (mod is ModuloAMASS)
{
string comando = $"{mod.Comando} -d {target} -o {nomeFile}.txt -visjs {nomeFile}.visjs.html ";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
percorsi.Add(Path.Combine(cartella, nomeFile + ".visjs.html"));
return(comando);
}
if (mod is ModuloDRUPWN)
{
string comando = $"{mod.Comando} {target} | sed -r \"{regex}\" | tee {nomeFile}.txt";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
if (mod is ModuloWHOIS)
{
string comando = $"{mod.Comando} {target} | sed -r \"{regex}\" | tee {nomeFile}.txt";
percorsi.Add(Path.Combine(cartella, nomeFile + ".txt"));
return(comando);
}
else
{
return("");
}
}
public ActionResult CreateModulo(ModuloViewModel model)
{
if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
return RedirectToAction("Index", "Home");
if (!ModelState.IsValid)
{
ViewBag.Title = Resources.ModuloResource.CreateModuloPageTitle;
ViewBag.PageHeader = Resources.ModuloResource.CreateModuloHeaderPage;
return View(model);
}
using (SeguricelEntities db = new SeguricelEntities())
{
Modulo modulo = new Modulo
{
Action = model.Action,
Activo = model.Activo,
Controller = model.Controller,
IdModulo = model.IdModulo,
IdModuloPadre = (((eTipoElementoMenu)model.IdTipoElemento) != eTipoElementoMenu.Nivel1 ? model.IdModuloPadre : (int?)null),
IdTipoElemento = model.IdTipoElemento,
Nombre = model.Nombre
};
db.Modulo.Add(modulo);
db.SaveChanges();
ClasesVarias.AddBitacoraUsuario(db,
"Módulo " + model.Nombre,
105000003,
"Agregar");
}
return RedirectToAction("Modulos");
}
