/// <summary>
/// Permite anular una Inspección
/// </summary>
/// <param name="">Entidad Observacion Planeada</param>
/// <returns>valor booleano con el resultado de la operacion</returns>
public JsonResult EliminarFormula(FormulaRequest data)
{
data.CodigoIdioma = obtenerCodigoIdioma();
var response = formulaService.EliminarFormula(data);
return(Json(response));
}
public ProcessResult <object> ReactivarFormula(FormulaRequest data)
{
ProcessResult <object> resultado = new ProcessResult <object>();
resultado.Result = "-1";
try
{
FormulaEntityRepository.Reactivar(data.CodigoFormula);
resultado.Result = FormulaEntityRepository.GuardarCambios();
}
catch (Exception e)
{
resultado.IsSuccess = false;
resultado.Exception = new ApplicationLayerException <FormulaService>(e.Message);
}
return(resultado);
}
public ProcessResult <object> EliminarFormula(FormulaRequest data)
{
ProcessResult <object> resultado = new ProcessResult <object>();
resultado.Result = "-1";
try
{
FormulaDetalleRequest oOEED = new FormulaDetalleRequest();
oOEED.CodigoFormula = data.CodigoFormula;
oOEED.CodigoIdioma = data.CodigoIdioma;
FormulaEntityRepository.Eliminar(data.CodigoFormula);
resultado.Result = FormulaEntityRepository.GuardarCambios();
}
catch (Exception e)
{
resultado.IsSuccess = false;
resultado.Exception = new ApplicationLayerException <FormulaService>(e.Message);
}
return(resultado);
}
public void TestParser2(string operation)
{
// Arrange
var input = $@"<request><expression><operation>{operation}</operation><operand><const>20</const></operand><operand>
<expression><operation>minus</operation><operand><const>10</const></operand><operand><const>5</const></operand>
</expression></operand></expression></request>";
var expected = new FormulaRequest
{
Expression = new Expression
{
Operation = operation,
Operands = new[] {
new Operand {
Value = 20
},
new Operand
{
Expression = new Expression
{
Operation = "minus",
Operands = new [] {
new Operand {
Value = 10
},
new Operand {
Value = 5
}
}
}
}
}
}
};
// Act
var parser = new XmlParser();
var result = parser.Parse <FormulaRequest>(input);
// Assert
result.ShouldDeepEqual(expected);
}
public ProcessResult <FormulaResponse> RegistrarFormula(FormulaRequest data)
{
ProcessResult <FormulaResponse> resultado = new ProcessResult <FormulaResponse>();
resultado.Result = new FormulaResponse();
try
{
using (TransactionScope ts = new TransactionScope())
{
FormulaEntity FormulaSincronizar = FormulaEntityRepository.GetById(data.CodigoFormula);
FormulaEntity FormulaGeneral = Mapper.Map <FormulaRequest, FormulaEntity>(data);
if (FormulaSincronizar != null)
{
Mapper.Map <FormulaEntity, FormulaEntity>(FormulaGeneral, FormulaSincronizar);
FormulaSincronizar.EstadoRegistro = DatosConstantes.EstadoRegistro.Activo;
FormulaEntityRepository.Editar(FormulaSincronizar);
resultado.Result.CodigoFormula = data.CodigoFormula;
resultado.Result.NombreFormula = data.NombreFormula;
resultado.Result.DescripcionFormula = data.NombreFormula;
resultado.Result.EstadoRegistro = DatosConstantes.EstadoRegistro.Activo;
}
else
{
FormulaEntityRepository.Insertar(FormulaGeneral);
bool registroExitoso = resultado.IsSuccess;
if (!registroExitoso)
{
resultado.IsSuccess = false;
resultado.Exception = new ApplicationLayerException <FormulaService>(MensajesSistemaResource.EtiquetaError);
}
resultado.Result.CodigoFormula = FormulaGeneral.CodigoFormula;
}
FormulaEntityRepository.GuardarCambios();
//BUSCA INDICADOR
IndicadorRequest IndReq = new IndicadorRequest();
IndReq.CodigoIndicador = data.CodigoIndicador;
IndReq.CodigoIdioma = data.CodigoIdioma;
var res = indicadorService.ObtenerIndicador(IndReq);
//ACTUALIZA EL CÓDIGO DE FORMULA EN EL INDICADOR Y LO ACTUALIZA
IndReq.CodigoFormula = resultado.Result.CodigoFormula;
var response = indicadorService.RegistrarIndicador(IndReq);
//posterior a ello registrar la formula detalle: (codigo desarrollado abajo)
List <BandejaVariableRequest> lstVariables = new List <BandejaVariableRequest>();
String pattern = @"\[([^\[\]]+)\]";
foreach (Match m in Regex.Matches(data.NombreFormula, pattern))
{
lstVariables.Add(new BandejaVariableRequest()
{
NombreVariable = m.Groups[1].Value, CodigoIdioma = data.CodigoIdioma
});
}
for (int i = 0; i < lstVariables.Count; i++)
{
lstVariables[i].CodigoVariable = variableService.BuscarVariable(lstVariables[i]).Result[0].CodigoVariable;
}
FormulaDetalleRequest objFormulaDetalle = new FormulaDetalleRequest();
for (int i = 0; i < lstVariables.Count; i++)
{
objFormulaDetalle.CodigoFormula = resultado.Result.CodigoFormula;
objFormulaDetalle.CodigoVariable = lstVariables[i].CodigoVariable;
objFormulaDetalle.DescripcionValor = "Valor" + (i + 1);
var results = formulaDetalleService.RegistrarFormulaDetalle(objFormulaDetalle);
}
ts.Complete();
}
}
catch (Exception ex)
{
resultado.IsSuccess = false;
resultado.Exception = new ApplicationLayerException <FormulaService>(ex.Message);
}
return(resultado);
}
public JsonResult ReactivarFormula(FormulaRequest data)
{
var response = formulaService.ReactivarFormula(data);
return(Json(response));
}
public ActionResult <Dictionary <int, double> > AddFormula([FromBody] FormulaRequest request)
{
try
{
var inputList = request.Operands.Where(x => x.Type == (int)OperandTypeValue.INPUT).ToList();
List <Operand> list = request.Operands.Where(x => x.Type != (int)OperandTypeValue.INPUT && x.OperandID == x.ID)
.OrderBy(x => x.Sequence).ToList();
var tmp = request.GroupValues.ToList();
foreach (var item in tmp)
{
var t = list.Where(x => x.Type == (int)OperandTypeValue.GROUP_VALUE && x.OperandID == item.OperandID).FirstOrDefault();
if (t != null)
{
list.Remove(t);
t.GroupValues.Add(item);
list.Add(t);
}
}
//parse inputed value
VariableSet vSetBaseFormula = new VariableSet();
var ep = new ExpressionParser();
foreach (var item in inputList)
{
//keyValuesOperand.Add(item.Name, item.Value);
vSetBaseFormula.RegisterVariable(OperandType.Double, item.Name, item.Value);
}
//-----------------------------
Dictionary <int, double> listResult = new Dictionary <int, double>();
Parallel.ForEach(request.testNumber, async(item) =>
{
foreach (var operand in list)
{
if (operand.Childs != null)
{
List <Operand> childs = operand.Childs.ToList();
if (childs.Count > 0)
{
Console.WriteLine(operand.Name + "x " + operand.Value);
vSetBaseFormula = await GetOperandChildsAsync(operand, vSetBaseFormula);
}
else
{
var compiledExpression = ep.Parse(operand.Expression);
var resultStack = compiledExpression.Evaluate(vSetBaseFormula);
var tmp = Convert.ToDouble(resultStack.Pop().GetValue());
if (vSetBaseFormula.Where(x => x.VariableName.Equals(operand.Name)).FirstOrDefault() == null)
{
vSetBaseFormula.RegisterVariable(OperandType.Double, operand.Name, tmp);
}
}
}
}
var ce = ep.Parse(request.baseFormula.Expression);
foreach (var param in vSetBaseFormula)
{
Console.WriteLine(param.VariableName + " " + param.Value);
}
var resul = ce.Evaluate(vSetBaseFormula);
double value = Convert.ToDouble(resul.Pop().GetValue());
listResult.Add(item, value);
}
);
_context.BaseFormulas.Add(request.baseFormula);
_context.Operands.AddRange(request.Operands);
var check = _context.SaveChanges() > 0;
if (check)
{
return(Ok(listResult));
}
else
{
return(BadRequest("Cannot save to db"));
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
FormulaResponse InvokeCommunicateWithFormula(FormulaRequest request)
{
return(onCommunicateWithFormula?.Invoke(request));
}
public decimal Calculate(string formula, OrderLine orderLine)
{
try
{
dynamic inputs = new ExpandoObject();
IDictionary <string, object> dictionary = (IDictionary <string, object>)inputs;
dictionary.Add("OrderLineQty", orderLine.Quantity);
IEnumerable <OrderLineOption> olOptions = orderLine.OrderLineOptions;
if (olOptions != null)
{
foreach (OrderLineOption olOption in olOptions)
{
string varName = GuidToVar(olOption.ProductOptionId);
if (dictionary.ContainsKey(varName))
{
continue; // duplicate product option values: should not happen (but it did)!!
}
if (!string.IsNullOrWhiteSpace(olOption.ProductOptionValueId))
{
string varValue = GuidToVar(olOption.ProductOptionValueId);
dictionary.Add(varName, varValue);
}
else
{
dictionary.Add(varName, olOption.ProductOptionValue);
}
}
}
FormulaRequest req = new FormulaRequest()
{
Formula = formula,
Inputs = inputs
};
using (var client = new System.Net.Http.HttpClient())
{
// client.BaseAddress = new Uri("http://localhost:5051/");
string webApiUrl = Properties.Settings.Default.WebApiUrl;
client.BaseAddress = new Uri(webApiUrl); // "http://webapi-openbiz-dev.azurewebsites.net/"
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response = client.PostAsJsonAsync("nodejs/execFormula.js", req).Result;
if (response.IsSuccessStatusCode)
{
var headers = response.Headers;
FormulaResult returnValue = response.Content.ReadAsAsync <FormulaResult>().Result;
return(returnValue.Result);
}
else
{
return(0);
}
}
}
catch (Exception ex)
{
throw;
}
}
