public async Task <ActionResult <MethodDTO> > GetMethod(int id)
{
var method = await _context.Methods.FindAsync(id);
if (method == null)
{
return(NotFound());
}
var factors = _context.CharacterisationFactors
.Where(p => p.MethodId == id)
.Join(
_context.ElementaryFlows,
exc => exc.ElementaryFlowId,
flow => flow.Id,
(exc, flow) => new FactorDTO
{
Value = exc.Factor,
FlowName = flow.Name,
UnitName = flow.Unit.Name
}).ToList();
var p = new MethodDTO();
p.CharacterisationFactors = factors;
p.MethodInformation = method;
return(p);
}
public IEnumerable <MethodDTO> GetListByPlanDetail(Guid Id)
{
var result = new List <MethodDTO>();
SessionManager.DoWork(session =>
{
List <Method> list = session.Query <Method>().Where(d => d.PlanKPIDetail.Id == Id).OrderBy(d => d.OrderNumber).ToList();
foreach (Method m in list)
{
MethodDTO mdto = new MethodDTO()
{
Id = m.Id,
Name = m.Name,
OrderNumber = m.OrderNumber,
PlanKPIDetailId = m.PlanKPIDetail.Id,
StartTime = m.StartTime,
EndTime = m.EndTime,
StartTimeString = m.StartTime.ToShortDateString(),
EndTimeString = m.EndTime.ToShortDateString()
};
result.Add(mdto);
}
});
return(result);
}
public IDataTransferObject GetDataForm()
{
Dialog newMethodDialog = (Dialog)GetWidget();
MethodDTO methodDTO = null;
switch (newMethodDialog.Run())
{
case (int)ResponseType.Ok:
methodDTO = new MethodDTO();
methodDTO.MethodName = nameEntry.Text;
methodDTO.ReturnType = returnTypeEntry.Text;
TreeIter iter;
viewToResponseCombo.GetActiveIter(out iter);
methodDTO.ViewToResponse = (string)viewToResponseCombo.Model.GetValue(iter, 0);
methodDTO.ResponseMethod = responseMethodEntry.Text;
methodDTO.ParametersCollection = parameterTableModel.ListModel;
break;
case (int)ResponseType.Cancel:
break;
default:
break;
}
newMethodDialog.Destroy();
newMethodDialog = null;
return(methodDTO);
}
public void Add(IDataTransferObject dto)
{
if (dto is MethodDTO)
{
MethodDTO methodDTO = (MethodDTO)dto;
StringBuilder stringBuilder = new StringBuilder();
foreach (ParameterDTO parameterDTO in methodDTO.ParametersCollection)
{
stringBuilder = stringBuilder.Append(parameterDTO.TypeName);
stringBuilder = stringBuilder.Append(" ");
stringBuilder = stringBuilder.Append(parameterDTO.VarName);
stringBuilder = stringBuilder.Append(", ");
}
if (stringBuilder.Length != 0)
{
stringBuilder = stringBuilder.Remove(stringBuilder.Length - 2, 2);
}
listStore.AppendValues(
methodDTO.MethodName,
methodDTO.ReturnType,
methodDTO.ViewToResponse,
methodDTO.ResponseMethod,
stringBuilder.ToString()
);
list.Add(methodDTO);
}
}
public virtual void ExecuteVoidAJAX(MethodDTO pMethode)
{
//gb - Récupération de l'objet au format string
string lValue = ((string[])(pMethode.Parametrage))[0];
//gb - Convertion de l'objet au format JObject
Newtonsoft.Json.Linq.JObject lData = JsonConvert.DeserializeObject <dynamic>(lValue);
//gb - Convertion de l'objet au format choisi
pMethode.Parametrage = lData.ToObject(Type.GetType(String.Format(FormatStringDTO, pMethode.DTOStringType)));
//gb - Appel la méthode ExecuteVoid du métier
ExecuteVoidInternal(pMethode);
}
/* GUI Events */
private void OnNewMethodClicked(object sender, EventArgs args)
{
methodView = new MethodView();
ActionState = ActionState.Create;
methodView.LoadDataForm((ComponentDTO)GetDataForm());
MethodDTO methodDTO = (MethodDTO)methodView.GetDataForm();
if (methodDTO != null)
{
methodTableModel.Add(methodDTO);
}
methodView = null;
}
public virtual ActionResult ExecuteFunctionJson(MethodDTO pMethode)
{
try
{
var data = ExecuteFunctionInternal(pMethode);
return(JsonResult(data));
}
catch (Exception Ex)
{
// yl - retourne l'erreur en JSON
return(ThrowJSONError(Ex));
}
}
public MethodDTO GetObj(Guid id)
{
var result = new MethodDTO();
SessionManager.DoWork(session =>
{
Method method = session.Query <Method>().SingleOrDefault(a => a.Id == id);
if (method != null)
{
result = method.Map <MethodDTO>();
result.PlanKPIDetailId = method.PlanKPIDetail.Id;
}
});
return(result);
}
public IActionResult CreateMethod([FromBody] MethodDTO methodDTO)
{
long loggedInUserId = GetLoggedInUserIdMockUp();
if (loggedInUserId == -1)
{
return(Unauthorized());
}
CreateMethod createMethod =
new CreateMethod(methodDTO.Creator, methodDTO.Name, methodDTO.ApplicationRate, loggedInUserId);
_kafkaProducer.Produce(createMethod, METHODS_TOPIC);
return(Ok("Currently processing your request..."));
}
private void OnDeleteMethodClicked(object sender, EventArgs args)
{
TreeIter iter;
if (methodsTreeView.Selection.GetSelected(out iter))
{
string methodName = methodTableModel.ListStore.GetValue(iter, 0).ToString();
MethodDTO auxMethodDTO = null;
foreach (MethodDTO methodDTO in methodTableModel.ListModel)
{
if (methodDTO.MethodName.Equals(methodName))
{
auxMethodDTO = methodDTO;
break;
}
}
if (auxMethodDTO != null)
{
methodTableModel.ListModel.Remove(auxMethodDTO);
methodTableModel = new MethodTableModel(methodTableModel.ListModel);
methodsTreeView.Model = methodTableModel.ListStore;
}
}
}
/// <summary>
/// Fonction générique permettant d'appeler une fonction de la classe métier
/// </summary>
/// <param name="pMethode">Fonction à appeler</param>
/// <remarks>GB / YL - 2015-06-24 - Création</remarks>
private object ExecuteFunctionInternal(MethodDTO pMethode)
{
var objetMetier = new MetierType();
return(objetMetier.ExecuteFunction(this.GetInfoSession(), pMethode));
}
public virtual void ExecuteFunction(MethodDTO pMethode)
{
var data = ExecuteFunctionInternal(pMethode);
}
/// <summary>
/// Méthode générique permettant d'appeler une méthode de la classe métier
/// </summary>
/// <param name="pMethode">Méthode à appeler</param>
/// <remarks>GB / YL - 2015-06-24 - Création</remarks>
private void ExecuteVoidInternal(MethodDTO pMethode)
{
var objetMetier = new MetierType();
objetMetier.ExecuteVoid(this.GetInfoSession(), pMethode);
}
public virtual void ExecuteVoid(MethodDTO pMethode)
{
ExecuteVoidInternal(pMethode);
}
