public static void UpdateTemplate(AnimalListItem obj)
{
var templateAnimal = FFPresenterModel.LoadActualTemplate(EidssSiteContext.Instance.CountryID, obj.idfsDiagnosisForCs, FFTypeEnum.LivestockAnimalCS);
obj.FFPresenterCs.SetProperties(templateAnimal, obj.idfAnimal);
obj.idfsFormTemplate = templateAnimal.idfsFormTemplate;
}
public void SetTemplateTest()
{
var target = new FFPresenterModel();
target.SetTemplate(GetTemplate(249540000000));
Assert.IsNotNull(target.TemplateFlexNode);
}
/// <summary>
///
/// </summary>
/// <param name="ffPresenter"></param>
/// <param name="form"></param>
/// <param name="errMessage"></param>
/// <returns></returns>
public static bool UpdateModelRoutines(FFPresenterModel ffPresenter, FormCollection form, out string errMessage)
{
bool isDatesValid = DateTimeHelper.TryParseCustomDates(form, out errMessage);
if (!isDatesValid)
{
return(false);
}
errMessage = String.Empty;
var result = true;
m_Error = string.Empty;
ffPresenter.Validation += ffPresenter_Validation;
ffPresenter.ErrorValueType += ffPresenter_ErrorValueType;
ffPresenter.ParseFormCollection(form);
ffPresenter.Validate();
ffPresenter.ErrorValueType -= ffPresenter_ErrorValueType;
ffPresenter.Validation -= ffPresenter_Validation;
if (!String.IsNullOrWhiteSpace(m_Error))
{
errMessage = m_Error;
result = false;
}
return(result);
}
public static string GetClinicalSigns(FFPresenterModel presenter)
{
string result = string.Empty;
if (presenter.CurrentTemplate.ParameterTemplatesLookup.Count(p => p.ParameterType == FFParameterTypes.Boolean) > 0)
{
var list = presenter.CurrentTemplate.ParameterTemplatesLookup.Where(p => p.ParameterType == FFParameterTypes.Boolean)
.Join(presenter.ActivityParameters, x => x.idfsParameter, y => y.idfsParameter, (x, y) => new { LabelText = x.NationalName, Checked = y.ToBool() })
.Where(v => v.Checked)
.Select(s => s.LabelText)
.ToArray();
if (list.Length > 0)
{
foreach (var s in list)
{
result += String.Format(", {0}", s);
}
if (result.Length > 0)
{
result = result.Substring(2);
}
}
}
return(result);
}
//protected new List<FlexNode> ChildList { get; set; }
public FlexNode(FlexNode parentNode, FlexItem ffObject, EditableList <ActivityParameter> activityParameters, FFPresenterModel model)
: base(parentNode, ffObject)
{
m_ActivityParameters = activityParameters;
m_Model = model;
UseFullPath = false;
idfRow = -1;
}
public static void UpdateTemplate(VetFarmTree obj)
{
var templateSpecies = FFPresenterModel.LoadActualTemplate(EidssSiteContext.Instance.CountryID,
obj.idfsDiagnosisForCs,
(obj._HACode == (int)HACode.Livestock)
? FFTypeEnum.LivestockSpeciesCS
: FFTypeEnum.AvianSpeciesCS);
obj.FFPresenterCs.SetProperties(templateSpecies, obj.idfFarm);
obj.idfsFormTemplate = templateSpecies.idfsFormTemplate;
}
public ActionResult ShowFlexibleFormDirect(long root, long key, FFPresenterModel ffpresenter, bool canUpdate = true)
{
//TODO определиться, нужен ли этот метод вообще
if ((ffpresenter != null) && (ffpresenter.CurrentTemplate != null))
{
if (ViewBag.GridName == null)
{
ViewBag.GridName = String.Empty;
}
ffpresenter.Settings.WindowMode = false;
ModelStorage.Put(Session.SessionID, root, root, ffpresenter.CurrentObservation.ToString(), ffpresenter);
ModelStorage.Put(Session.SessionID, root, key, ffpresenter.CurrentObservation.ToString(), ffpresenter);
ViewBag.FFKey = key;
ViewBag.FFpresenterId = ffpresenter.CurrentObservation.Value;
ViewBag.CanUpdate = canUpdate;
return(PartialView("ShowFlexibleForm", ffpresenter));
}
return(PartialView("Empty"));
}
public FlexNode Insert(object ffObject, int index, FFPresenterModel model)
{
return(Add(ffObject, null, index, model));
}
public static FlexNode CreateFlexNodeForTemplate(this FFPresenterModel model)
{
return(model.CurrentTemplate.CreateFlexNodeForTemplate(model.CurrentObservation ?? 0, model.ActivityParameters, null, model));
}
/// <summary>
/// Create FlexNode For Section
/// </summary>
/// <param name="parentNode"></param>
/// <param name="parentSection"></param>
/// <param name="template"></param>
/// <param name="activityParameters"></param>
/// <param name="predefinedStubRows"></param>
/// <param name="model"></param>
/// <returns></returns>
private static void CreateFlexNodeForSection(FlexNode parentNode, SectionTemplate parentSection, Template template, EditableList <ActivityParameter> activityParameters, List <PredefinedStub> predefinedStubRows, FFPresenterModel model)
{
//для табличной секции верхнего уровня следует добавить пользовательские данные
var sectionList = parentSection != null
? template.GetSectionTemplateChildren(parentSection).ToList()
: template.GetSectionTemplateRoot().ToList();
var parameterList = parentSection != null
? template.GetParameterTemplateChildren(parentSection).ToList()
: template.GetParameterTemplateRoot().ToList();
var labelList = parentSection != null
? template.GetLabelChildren(parentSection).ToList()
: template.GetLabelRoot().ToList();
//рекурсивно транслируем в узлы каждую секцию с её содержимым
foreach (var sectionTemplate in sectionList)
{
FlexNode node;
if (sectionTemplate.blnGrid && (parentSection == null))
{
node = parentNode.Add(sectionTemplate, activityParameters, model);
if (predefinedStubRows != null)
{
sectionTemplate.PredefinedStubRows = predefinedStubRows;
#region Добавление параметров-столбцов боковика
//параметры боковика не имеют секции над собой, всегда крайние слева
//вынимаем уникальные параметры из данных боковика (spGetPredefinedStub)
var usedParams = new List <long>();
//for (var index = predefinedStubRows.Count - 1; index >= 0; index--)
var nodes = new List <FlexNode>();
foreach (var predefinedStubRow in predefinedStubRows)
{
if (!predefinedStubRow.idfsParameter.HasValue)
{
continue;
}
if (usedParams.Contains(predefinedStubRow.idfsParameter.Value))
{
continue;
}
usedParams.Add(predefinedStubRow.idfsParameter.Value);
predefinedStubRow.intOrder = usedParams.Count - 1;
var nodePred = node.Add(predefinedStubRow, null, predefinedStubRow.intOrder, model);
nodePred.Order = predefinedStubRow.intOrder;
nodes.Add(nodePred);
}
//у каждого нода боковика должен быть отрицательный индекс в порядке возрастания
for (var index = 0; index < nodes.Count; index++)
{
nodes[index].Order = index - nodes.Count;
}
#endregion
}
}
else
{
node = parentNode.Add(sectionTemplate, activityParameters, model);
}
if (sectionTemplate.intOrder.HasValue)
{
node.Order = sectionTemplate.intOrder.Value;
}
node.FormKey = parentNode.FormKey;
CreateFlexNodeForSection(node, sectionTemplate, template, activityParameters, predefinedStubRows, model);
}
//транслируем все параметры, находящиеся на этом уровне
foreach (var parameterTemplate in parameterList)
{
//parameterTemplate.RootKeyID = template.RootKeyID;
var node = parentNode.Add(parameterTemplate, activityParameters, model);
node.FormKey = parentNode.FormKey;
node.Order = parameterTemplate.intOrder;
}
//транслируем лейблы
foreach (var label in labelList)
{
parentNode.Add(label, model);
}
}
/// <summary>
///
/// </summary>
/// <param name="ffPresenterModel"></param>
/// <returns></returns>
private long GetAdditionalKeyFFPresenter(FFPresenterModel ffPresenterModel)
{
return(ffPresenterModel.CurrentObservation.HasValue ? ffPresenterModel.CurrentObservation.Value : 0);
}
public void LoadAggregateTemplate(AggregateCaseSectionEnum matrixId, long idfObservation)
{
var idfVersion = FFPresenterModel.LoadObservationVersion(idfObservation);
Model.PrepareAggregateCase(matrixId, idfVersion ?? 0);
}
public void LoadTemplate(List <long> observations, long idfsFormTemplate)
{
Model.SetProperties(FFPresenterModel.LoadActualTemplate(idfsFormTemplate), observations, 0);
}
/// <summary>
/// Создаёт образ шаблона в древовидной форме
/// </summary>
/// <param name="template"></param>
/// <param name="idfObservation"></param>
/// <param name="activityParameters"></param>
/// <param name="model"></param>
/// <returns></returns>
public static FlexNode CreateFlexNodeForTemplate(this Template template, long?idfObservation, EditableList <ActivityParameter> activityParameters, FFPresenterModel model)
{
return(template.CreateFlexNodeForTemplate(idfObservation, activityParameters, null, model));
}
public void RulesCheckRoutines(List <Rule> rules, FFPresenterModel ff, out List <Rule> executedRules, out List <Rule> enablingRules)
{
//правила, которые выполнились
executedRules = new List <Rule>();
//правила, которые не выполнились, но по которым надо разблокировать контролы
enablingRules = new List <Rule>();
if (!ff.CurrentObservation.HasValue)
{
return;
}
var idObservation = ff.CurrentObservation.Value;
foreach (var rule in rules)
{
//получаем значение параметра
//если значение не задано, то правило игнорируется
//TODO обработать табличные значения
var value1 = ff.ActivityParameters.GetActivityParameter(false, idObservation, rule.ParametersLookup[0].idfsParameter);
//if ((rule.idfsRuleFunction != (long)FFRuleFunctions.Empty || rule.idfsRuleFunction != (long)FFRuleFunctions.Value) && (Utils.IsEmpty(value1) || Utils.IsEmpty(value1.varValue))) return;
if (Utils.IsEmpty(value1) || Utils.IsEmpty(value1.varValue))
{
if (!(
(rule.idfsRuleFunction == (long)FFRuleFunctions.Empty) ||
(rule.idfsRuleFunction == (long)FFRuleFunctions.Value)
))
{
return;
}
}
ActivityParameter value2 = null;
if (rule.intNumberOfParameters == 2)
{
value2 = ff.ActivityParameters.GetActivityParameter(false, idObservation, rule.ParametersLookup[1].idfsParameter);
if (Utils.IsEmpty(value2) || Utils.IsEmpty(value2.varValue))
{
return;
}
}
//метка того, что условия для срабатывания правила выполнились
var conditionsDone = false; //изначально не соблюдены
//выполняем действия в зависимости от типа правила
switch (rule.idfsRuleFunction)
{
case (long)FFRuleFunctions.CurrentDate:
var dt = ((DateTime)value1.varValue).Date;
if (dt <= DateTime.Now.Date)
{
conditionsDone = true;
}
break;
case (long)FFRuleFunctions.Empty:
if (Utils.IsEmpty(value1) || Utils.IsEmpty(value1.varValue))
{
conditionsDone = true;
}
break;
case (long)FFRuleFunctions.Value:
//если есть константы, с которыми надо сравнивать, то сравним с каждой из них
foreach (var constant in rule.ConstantsLookup)
{
if (Utils.IsEmpty(constant.varConstant) || constant.varConstant.ToString() == "-1")
{
if (value1 == null || Utils.IsEmpty(value1.varValue))
{
conditionsDone = true;
break;
}
}
else if (value1 != null && value1.varValue != null)
{
//сравним как строки
if (constant.varConstant.ToString().Equals(value1.varValue.ToString()))
{
conditionsDone = true;
break;
}
}
}
break;
case (long)FFRuleFunctions.Greater:
double d1;
double d2;
DateTime dt1;
DateTime dt2;
if (value2 != null)
{
var p1 = value1.varValue.ToString();
var p2 = value2.varValue.ToString();
if (Double.TryParse(p1, out d1) &&
Double.TryParse(p2, out d2))
{
if (d1 > d2)
{
conditionsDone = true;
}
}
else if (DateTime.TryParse(p1, out dt1) &&
DateTime.TryParse(p2, out dt2))
{
if (dt1 > dt2)
{
conditionsDone = true;
}
}
}
break;
case (long)FFRuleFunctions.GreaterEqual:
if (value2 != null)
{
var p1 = value1.varValue.ToString();
var p2 = value2.varValue.ToString();
if (Double.TryParse(p1, out d1) &&
Double.TryParse(p2, out d2))
{
if (d1 >= d2)
{
conditionsDone = true;
}
}
else if (DateTime.TryParse(p1, out dt1) &&
DateTime.TryParse(p2, out dt2))
{
if (dt1 >= dt2)
{
conditionsDone = true;
}
}
}
break;
}
//накладываем условие отрицания, если оно есть
if (rule.blnNot)
{
conditionsDone = !conditionsDone;
}
if (conditionsDone)
{
executedRules.Add(rule);
}
else if (rule.ActionsLookup.Any(c => c.idfsRuleAction == (long)FFRuleActions.Disabled))
{
enablingRules.Add(rule);
}
}
}
public FlexNode Add(object ffObject, FFPresenterModel model)
{
return(Add(ffObject, null, model));
}
public FlexNode Add(object ffObject, EditableList <ActivityParameter> activityParameters, FFPresenterModel model)
{
return(Add(ffObject, activityParameters, -1, model));
}
//TODO сделать добавление для лейблов и линий(?)
//public void Add(FlexibleFormsDS.LinesRow row)
//{
// FlexLineItem item = new FlexLineItem(row);
// mChildList.Add(new FlexNode(this, item));
//}
///// <summary>
/////
///// </summary>
///// <param name="row"></param>
//public void Add(FlexibleFormsDS.LabelsRow row)
//{
// FlexLabelItem item = new FlexLabelItem(row);
// mChildList.Add(new FlexNode(this, item));
//}
/// <summary>
///
/// </summary>
/// <param name="ffObject"></param>
/// <param name="activityParameters"></param>
/// <param name="index">Индекс для вставки</param>
/// <param name="model"></param>
public FlexNode Add(object ffObject, EditableList <ActivityParameter> activityParameters, int index, FFPresenterModel model)
{
var flexNode = new FlexNode(this, new FlexItem(ffObject), activityParameters, model);
if (index == -1)
{
ChildList.Add(flexNode);
}
else
{
ChildList.Insert(0, flexNode);
}
return(flexNode);
}
public TemplateHelper()
{
Model = new FFPresenterModel();
}
public static FlexNode CreateFlexNodeForTemplate(this Template template, long?idfObservation, EditableList <ActivityParameter> activityParameters, List <PredefinedStub> predefinedStubRows, FFPresenterModel model)
{
var rootNode = new FlexNode(null, null, null, null)
{
FormKey = idfObservation.HasValue
? DataHelper.GetFFParameterKey(template.idfsFormTemplate, idfObservation.Value)
: DataHelper.GetFFParameterSimpleKey(template.idfsFormTemplate)
};
//начинаем с корня шаблона и внутрь
CreateFlexNodeForSection(rootNode, null, template, activityParameters, predefinedStubRows, model);
//рекурсивная сортировка узлов
rootNode.SortRecursive();
//динамические параметры
FlexNode dynamicSectNode = null;
if (idfObservation.HasValue)
{
var deletedFromTemplates = FFHelper.GetDeletedParameters(activityParameters, idfObservation.Value, template);
if (deletedFromTemplates.Count > 0 || model.DynamicParameterEnabled)
{
FlexNode prevNode = rootNode.ChildListCount == 0 ? null : (FlexNode)rootNode.ChildList[rootNode.ChildListCount - 1];
var sectCaption = new SectionDeletedFromTemplate(EidssMessages.Get("DynamicParametersGroupControlCaption"));
sectCaption.intLeft = prevNode == null ? 4 : prevNode.Coord.X;
sectCaption.intTop = prevNode == null ? 4 : prevNode.Coord.Y + prevNode.Height;
sectCaption.intOrder = prevNode == null ? 1 : prevNode.Order + 1;
sectCaption.intHeight = 0;
//создаём псевдосекцию, в которой будем размещать эти параметры
dynamicSectNode = new FlexNode(null, new FlexItem(sectCaption), activityParameters, model);
for (var i = 0; i < deletedFromTemplates.Count; i++)
{
var dp = deletedFromTemplates[i];
// calculate section size from its content
if (sectCaption.intWidth == null || dp.intWidth > sectCaption.intWidth)
{
sectCaption.intWidth = dp.intWidth;
}
dp.intTop = sectCaption.Height + 4;
sectCaption.intHeight += dp.intHeight + 4;
dp.intLeft = sectCaption.Left;
var ap = activityParameters.FirstOrDefault(c => c.idfsParameter == dp.idfsParameter);
if (ap != null)
{
ap.IsDynamicParameter = true;
}
var node = dynamicSectNode.Add(dp, activityParameters, model);
node.FormKey = dynamicSectNode.FormKey;
node.Order = i;
}
//если динамическая секция есть, то добавляем её в самый конец списка
if (dynamicSectNode != null)
{
rootNode.Add(dynamicSectNode);
}
}
}
return(rootNode);
}
