/// <summary>
/// Constructor from Model Entity
/// Framework BE --> Edm Entity Model
/// </summary>
/// <param name="pTipoParametro">Edm Model BE</param>
public TipoParametroBE(TipoParametro pTipoParametro)
{
_IdTipoParametro = pTipoParametro.IdTipoParametro;
_Nombre = pTipoParametro.Nombre;
_IdTipoParametroRelacion = pTipoParametro.IdTipoParametroRelacion;
_Descripcion = pTipoParametro.Descripcion;
}
public TipoParametrosModel Create(TipoParametro tipoParametro)
{
return(new TipoParametrosModel()
{
Url = _UrlHelper.Link("tipoParametro", new { id = tipoParametro.Id }),
Id = tipoParametro.Id,
Nombre = tipoParametro.Nombre,
Vigente = tipoParametro.Vigente
});
}
public double GetParametro(TipoParametro tp)
{
if (tp == TipoParametro.PA)
{
return(this.parametroA);
}
else
{
return(this.parametroB);
}
}
public void SetParametro(TipoParametro tp, double valor)
{
if (tp == TipoParametro.PA)
{
this.parametroA = valor;
}
else
{
this.parametroB = valor;
}
}
public ActionResult SalvarEdicao(TipoParametro objeto)
{
try
{
Salvar(objeto, true);
this.FlashSuccess("Tipo de Parâmetro editado com sucesso.");
}
catch (Exception ex)
{
this.FlashError(ex.Message);
}
return(RedirectToAction("Index"));
}
public ActionResult Salvar(TipoParametro objeto, bool editar = false)
{
try
{
if (!ModelState.IsValid)
{
var msg = string.Empty;
ModelState.Values.SelectMany(v => v.Errors).ForEach(m => msg = string.Concat(m.ErrorMessage.ToString(), @"\n"));
if (!msg.IsNullOrWhiteSpace())
{
this.FlashWarning(msg);
}
return(View("Adicionar", objeto));
}
TipoParametro tipoParametro;
if (editar)
{
db.Entry(objeto).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
else
{
tipoParametro = new TipoParametro()
{
Descricao = Request.Form.Get("tipo_parametro_descricao"),
};
db.TipoParametro.Add(tipoParametro);
db.SaveChanges();
this.FlashSuccess("Tipo de Parâmetro adicionado com sucesso!.");
}
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException.InnerException != null && ex.InnerException.InnerException.Message.ToString().Contains("AK_Parametro_Descricao"))
{
this.FlashError("Já existe um Tipo de Parâmetro com essa descrição.");
}
else
{
this.FlashError(ex.Message);
}
}
return(RedirectToAction("Index"));
}
public TipoParametro Parse(TipoParametrosModel model)
{
try
{
var tipoParametro = new TipoParametro()
{
Id = model.Id,
Nombre = model.Nombre,
Vigente = model.Vigente,
};
return(tipoParametro);
}
catch (Exception)
{
return(null);
}
}
public ActionResult Remover(int id)
{
var result = new JsonResult()
{
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
try
{
TipoParametro tipoParametro = db.TipoParametro.SingleOrDefault(a => a.Id == id);
db.TipoParametro.Remove(tipoParametro);
db.SaveChanges();
result.Data = new { Result = "Tipo de Parâmetro removido com sucesso.", Status = (int)WebExceptionStatus.Success };
}
catch (Exception ex)
{
result.Data = new { Result = ex.Message, Status = (int)WebExceptionStatus.UnknownError };
}
return(result);
}
private static bool IsTipo(Parametro p, TipoParametro tipo)
{
return(p.Nome.ToLower() == Enum.GetName(typeof(TipoParametro), tipo).ToLower());
}
public override int GetHashCode()
{
return(TipoParametro != null?TipoParametro.GetHashCode() : 0);
}
public void AdicionarParametro(string nombre, object valor, DireccionParametro direccion, TipoParametro tipo, int longitud)
{
ParametroDTO parametro = new ParametroDTO();
parametro.Nombre = nombre;
parametro.Direccion = direccion.ToString();
parametro.Tipo = tipo.ToString();
parametro.Valor = valor;
parametro.Longitud = longitud;
arregloParametros.Add(parametro);
}
public Configuracion(TipoParametro tipoParametro, string Parametro, string Valor)
{
this._TipoParametro = tipoParametro;
this._Parametro = Parametro;
this._Valor = Valor;
}
public DatabaseParametro(string nomeParametro, Object valorParametro, TipoParametro tipo)
{
this.NomeParametro = nomeParametro;
this.ValorParametro = valorParametro;
this.TipoParametro = tipo;
}
public Configuracion(TipoParametro tipoParametro, string Parametro, string Valor)
{
this._TipoParametro = tipoParametro;
this._Parametro = Parametro;
this._Valor = Valor;
}
public static void AgregarParametro(DbCommand command, string parameterName, object parameterValue, TipoParametro parameterType, Direccion direction)
{
// create a new parameter
DbParameter param = command.CreateParameter();
param.ParameterName = parameterName;
param.Value = parameterValue;
switch (parameterType.ToString().Trim().ToUpper())
{
case "INT":
{
param.DbType = DbType.Int32;
break;
}
case "STR":
{
param.DbType = DbType.String;
break;
}
case "DT":
{
param.DbType = DbType.DateTime;
break;
}
case "BIT":
{
param.DbType = DbType.Byte;
break;
}
case "DBL":
{
param.DbType = DbType.Double;
break;
}
case "DCL":
{
param.DbType = DbType.Decimal;
break;
}
}
switch (direction.ToString().Trim().ToUpper())
{
case "INPUT":
{
param.Direction = ParameterDirection.Input;
break;
}
case "OUTPUT":
{
param.Direction = ParameterDirection.Output;
break;
}
case "INPUTOUTPUT":
{
param.Direction = ParameterDirection.InputOutput;
break;
}
case "VALUE":
{
param.Direction = ParameterDirection.ReturnValue;
break;
}
}
command.Parameters.Add(param);
}
public ActionResult Editar(int idEncadeamento)
{
Encadeamento enc = db.Encadeamento.Where(x => x.Id == idEncadeamento).FirstOrDefault();
EncadeamentoVO encVo = new EncadeamentoVO();
if (enc != null)
{
encVo.IdEncadeamento = enc.Id;
encVo.Descricao = enc.Descricao;
List <Encadeamento_TestData> enctds = db.Encadeamento_TestData.Where(x => x.IdEncadeamento == enc.Id).OrderByDescending(x => x.Ordem).ToList();
encVo.qtdTds = enctds.Count();
List <EncadeamentoVO.TestDataEncadeamento> testDatas = new List <EncadeamentoVO.TestDataEncadeamento>();
foreach (Encadeamento_TestData enctd in enctds)
{
TestData td = db.TestData.Where(x => x.Id == enctd.IdTestData).FirstOrDefault();
DataPool dp = db.DataPool.Where(x => x.Id == td.IdDataPool).FirstOrDefault();
AUT aut = db.AUT.Where(x => x.Id == dp.IdAut).FirstOrDefault();
List <ParametroScript> ListParametroScript = db.ParametroScript.Where(x => x.IdScript_CondicaoScript == td.IdScript_CondicaoScript).ToList();
List <EncadeamentoVO.TestDataEncadeamento.ParametroEncadeamento> parametros = new List <EncadeamentoVO.TestDataEncadeamento.ParametroEncadeamento>();
foreach (ParametroScript ps in ListParametroScript)
{
Parametro par = db.Parametro.Where(x => x.Id == ps.IdParametro).FirstOrDefault();
TipoParametro tp = db.TipoParametro.Where(x => x.Id == ps.IdTipoParametro).FirstOrDefault();
ParametroValor pv = db.ParametroValor.Where(x => x.IdParametroScript == ps.Id).Where(x => x.IdTestData == td.Id).FirstOrDefault();
EncadeamentoVO.TestDataEncadeamento.ParametroEncadeamento p = new EncadeamentoVO.TestDataEncadeamento.ParametroEncadeamento
{
Descricao = enc.Descricao,
DescricaoParametro = par.Descricao,
DescricaoTestData = td.Descricao,
DescricaoTipoParametro = tp.Descricao,
IdParametroScript = ps.Id,
IdParametroValor = pv.Id,
IdParametroValor_Origem = pv.IdParametroValor_Origem,
IdTestData = td.Id,
IdTipoParametro = tp.Id,
Obrigatorio = ps.Obrigatorio,
IdParametro = par.Id,
Tipo = tp.Descricao,
Valor = pv.Valor
};
parametros.Add(p);
}
EncadeamentoVO.TestDataEncadeamento testData = new EncadeamentoVO.TestDataEncadeamento
{
Descricao = td.Descricao,
Id = enctd.Id,
IdTestData = td.Id,
Ordem = enctd.Ordem,
DescricaoAut = aut.Descricao,
parametros = parametros,
IdAmbienteExecucao = enctd.IdAmbienteExecucao,
};
testDatas.Add(testData);
}
encVo.testDatas = testDatas;
}
Usuario user = GetLoggedUser();
ViewBag.listaTDMs = (from t in db.TDM
join tdm in db.TDM_Usuario on t.Id equals tdm.IdTDM
where tdm.IdUsuario == user.Id
select new TDMVO
{
IdTestData = t.Id,
Descricao = t.Descricao
}
).ToList();
return(View(encVo));
}
