protected override bool Retrieve(IPersistence persistence, ref ePersistence phase)
{
base.Retrieve(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
DataPersistence.Retrieve(persistence);
string json = persistence.GetFieldValue(Constants.ModelDatasource, "");
if (json != "")
{
Dictionary <string, List <string> > fromJson = JsonConvert.DeserializeObject <Dictionary <string, List <string> > >(json);
foreach (string key in fromJson.Keys)
{
IMapping mapping = new IMappingImpl();
mapping.DecisionModelNode = Tree.GetNodeByReference(key);
mapping.FromStringArray(fromJson[key]);
DecisionModelDataSources.Add(mapping);
}
}
break;
}
return(true);
}
protected override bool Persist(IPersistence persistence, ref ePersistence phase)
{
base.Persist(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
DataPersistence.Persist(persistence);
Dictionary <string, List <string> > toJson = new Dictionary <string, List <string> >();
foreach (IMapping mapping in DecisionModelDataSources)
{
toJson.Add(mapping.DecisionModelNode.Reference, mapping.ToStringArray());
}
string json = "";
if (toJson.Count > 0)
{
json = JsonConvert.SerializeObject(toJson);
}
persistence.UpsertField(Constants.ModelDatasource, json);
break;
}
return(true);
}
protected override bool Retrieve(IPersistence persistence, ref ePersistence phase)
{
base.Retrieve(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
_ShortName = persistence.GetFieldValue(Constants.Domain_Short_Name, "");
string relativePath = persistence.GetFieldValue(Constants.Domain_Sub_Model, "");
_Model = persistence.GetFullPath(relativePath);
if (_Model != "")
{
Tree.AddSubModel(this);
}
_Methods.Clear();
_Methods.AddRange(persistence.GetFieldValues(Constants.Domain_Methods, ""));
DataPersistence.Retrieve(persistence);
break;
}
return(true);
}
protected override bool Retrieve(IPersistence persistence, ref ePersistence phase)
{
Persistence = persistence;
while (persistence.NextRecord())
{
string type = persistence.GetFieldValue(Constants.BaseNode_ClassType, Constants.BaseNode_Type);
if (type == "sakwa.IBaseNodeImpl")
{
type = "sakwa.IRootNodeImpl";
}
RootNode = IDecisionTreeInterface.CreateNewNode(type);
RootNode.Parent = this;
RootNode.Tree = this;
phase = ePersistence.Final;
RootNode.NodeLoaded += RootNode_NodeLoaded;
return(RootNode.Retrieve(persistence));
}
return(false);
}
protected virtual bool Persist(IPersistence persistence, ref ePersistence phase)
{
switch (phase)
{
case ePersistence.Initial:
persistence.UpsertField(Constants.BaseNode_Reference, Reference);
persistence.UpsertField(Constants.BaseNode_NodeCount, IsReadOnly() ? "0" : Nodes.Count.ToString());
persistence.UpsertField(Constants.BaseNode_Type, NodeType.ToString());
persistence.UpsertField(Constants.BaseNode_Name, _Name);
persistence.UpsertField(Constants.BaseNode_Description, _Description);
break;
case ePersistence.Final:
if (!IsReadOnly())
{
foreach (IBaseNode node in Nodes)
{
if (persistence.AddRecord())
{
string type = Tree.BaseNodePersistName(node);
persistence.UpsertField(Constants.BaseNode_ClassType, type);
node.Persist(persistence);
}
}
}
break;
}
return(true);
}
protected override bool Retrieve(IPersistence persistence, ref ePersistence phase)
{
base.Retrieve(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
//Retrieve lVal
string Reference = persistence.GetFieldValue(Constants.Domain_Reference, "");
lVal.Domain = Tree.GetDomainObjectByReference(Reference) as IDomainObject;
Reference = persistence.GetFieldValue(Constants.Variable_Reference, "");
if (lVal.Domain != null)
{
foreach (IBaseNode node in lVal.Domain.Nodes)
{
if (node.Reference == Reference)
{
lVal.Variable = node as IVariableDef;
}
}
}
else
{
lVal.Variable = Tree.GetVariableByReference(Reference) as IVariableDef;
}
lVal.Value = persistence.GetFieldValue(Constants.Value, "");
//Retrieve rVal
Reference = persistence.GetFieldValue(Constants.Domain_Reference + "-r", "");
rVal.Domain = Tree.GetDomainObjectByReference(Reference) as IDomainObject;
Reference = persistence.GetFieldValue(Constants.Variable_Reference + "-r", "");
if (rVal.Domain != null)
{
foreach (IBaseNode node in rVal.Domain.Nodes)
{
if (node.Reference == Reference)
{
rVal.Variable = node as IVariableDef;
}
}
}
else
{
rVal.Variable = Tree.GetVariableByReference(Reference) as IVariableDef;
}
rVal.Value = persistence.GetFieldValue(Constants.Value + "-r", "");
_BranchEvaluation = (BranchEvaluation)Enum.Parse(typeof(BranchEvaluation),
persistence.GetFieldValue(Constants.Branch_Evaluation, BranchEvaluation.Once.ToString()));
_Expression = persistence.GetFieldValue(Constants.Expression, "");
break;
}
return(true);
}
protected override bool Retrieve(IPersistence persistence, ref ePersistence phase)
{
base.Retrieve(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
//Retrieve lVal
string Reference = persistence.GetFieldValue(Constants.Domain_Reference, "");
lVal.Domain = Tree.GetDomainObjectByReference(Reference) as IDomainObject;
Reference = persistence.GetFieldValue(Constants.Variable_Reference, "");
if (lVal.Domain != null)
{
foreach (IBaseNode node in lVal.Domain.Nodes)
{
if (node.Reference == Reference)
{
lVal.Variable = node as IVariableDef;
}
}
}
else
{
lVal.Variable = Tree.GetVariableByReference(Reference) as IVariableDef;
}
lVal.Value = persistence.HasField(Constants.Value)
? persistence.GetFieldValue(Constants.Value, "")
: _Name;
//Retieve rValue
Reference = persistence.GetFieldValue(Constants.Domain_Reference + "-r", "");
rVal.Domain = Tree.GetDomainObjectByReference(Reference) as IDomainObject;
Reference = persistence.GetFieldValue(Constants.Variable_Reference + "-r", "");
if (rVal.Domain != null)
{
foreach (IBaseNode node in rVal.Domain.Nodes)
{
if (node.Reference == Reference)
{
rVal.Variable = node as IVariableDef;
}
}
}
else
{
rVal.Variable = Tree.GetVariableByReference(Reference) as IVariableDef;
}
rVal.Value = persistence.GetFieldValue(Constants.Value + "-r", "");
_Expression = persistence.GetFieldValue(Constants.Expression, "");
break;
}
return(true);
}
protected override bool Persist(IPersistence persistence, ref ePersistence phase)
{
base.Persist(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
persistence.UpsertField(Constants.Variable_Type, _VariableType.ToString());
break;
}
return(true);
}
protected override bool Retrieve(IPersistence persistence, ref ePersistence phase)
{
base.Retrieve(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
_VariableType = (eVariableType)Enum.Parse(typeof(eVariableType), persistence.GetFieldValue(Constants.Variable_Type, eVariableType.character.ToString()), true);
break;
}
return(true);
}
protected override bool Retrieve(IPersistence persistence, ref ePersistence phase)
{
base.Retrieve(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
_Value = persistence.GetFieldValue(Constants.CharVariable_Value, "");
break;
}
return(true);
}
protected override bool Persist(IPersistence persistence, ref ePersistence phase)
{
base.Persist(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
persistence.UpsertField(Constants.EnumVariable_Value, _Value.ToString());
persistence.UpsertFieldArray(Constants.EnumVariable_Choices, _Elements.ToArray());
break;
}
return(true);
}
protected override bool Persist(IPersistence persistence, ref ePersistence phase)
{
if (persistence.AddRecord())
{
string type = IDecisionTreeInterface.BaseNodePersistName(RootNode);
persistence.UpsertField(Constants.BaseNode_ClassType, type);
phase = ePersistence.Final;
return(RootNode.Persist(persistence));
}
return(false);
}
protected override bool Retrieve(IPersistence persistence, ref ePersistence phase)
{
base.Retrieve(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
_Value = persistence.GetFieldValue(Constants.EnumVariable_Value, "");
_Elements.Clear();
_Elements.AddRange(persistence.GetFieldValues(Constants.EnumVariable_Choices, ""));
break;
}
return(true);
}
protected override bool Retrieve(IPersistence persistence, ref ePersistence phase)
{
base.Retrieve(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
string relativePath = persistence.GetFieldValue(Constants.Root_Template, "");
_DomainTemplate = persistence.GetFullPath(relativePath);
break;
}
return(true);
}
protected override bool Persist(IPersistence persistence, ref ePersistence phase)
{
base.Persist(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
string relativePath = persistence.GetRelativePath(_DomainTemplate);
persistence.UpsertField(Constants.Root_Template, relativePath);
break;
}
return(true);
}
protected override bool Persist(IPersistence persistence, ref ePersistence phase)
{
base.Persist(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
persistence.UpsertField(Constants.IntVariable_Value, _Value.ToString());
persistence.UpsertField(Constants.IntVariable_MinValue, MinValue.ToString());
persistence.UpsertField(Constants.IntVariable_MaxValue, MaxValue.ToString());
persistence.UpsertField(Constants.IntVariable_StepValue, StepValue.ToString());
break;
}
return(true);
}
protected override bool Retrieve(IPersistence persistence, ref ePersistence phase)
{
base.Retrieve(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
_Value = persistence.GetFieldValue(Constants.IntVariable_Value, 0m);
MinValue = persistence.GetFieldValue(Constants.IntVariable_MinValue, 0m);
MaxValue = persistence.GetFieldValue(Constants.IntVariable_MaxValue, 0m);
StepValue = persistence.GetFieldValue(Constants.IntVariable_StepValue, 1m);
break;
}
return(true);
}
bool IBaseNode.Retrieve(IPersistence persistence)
{
ePersistence phase = ePersistence.Initial;
if (Retrieve(persistence, ref phase))
{
if (phase == ePersistence.Initial)
{
phase = ePersistence.Final;
return(Retrieve(persistence, ref phase));
}
return(true);
}
return(false);
}
protected override bool Persist(IPersistence persistence, ref ePersistence phase)
{
base.Persist(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
List <string> data = new List <string>();
foreach (IDataDefinitionExport export in Exports)
{
string json = JsonConvert.SerializeObject(export);
data.Add(json);
}
persistence.UpsertFieldArray(Constants.DataDefinitionExport, data.ToArray <string>());
break;
}
return(true);
}
protected override bool Retrieve(IPersistence persistence, ref ePersistence phase)
{
base.Retrieve(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
string dataSourceFactory = persistence.GetFieldValue(Constants.DataNode_DataSourceFactory, "");
if (dataSourceFactory != "" && _DataSourceManager != null)
{
_DataSourceFactory = _DataSourceManager.GetDataSourceFactory(dataSourceFactory);
if (_DataSourceFactory != null)
{
_ConnectionProperties = _DataSourceFactory.ConnectionProperties;
}
}
string json = persistence.GetFieldValue(Constants.DataNode_DataSourceProperties, "");
if (json != "")
{
try
{
Dictionary <string, string> props = JsonConvert.DeserializeObject <Dictionary <string, string> >(json);
foreach (string name in props.Keys)
{
IProperty prop = getProperty(name);
if (prop != null)
{
prop.Value = props[name];
}
}
}
catch (Exception ex)
{
log.Debug(ex.ToString());
}
}
break;
}
return(true);
}
protected override bool Persist(IPersistence persistence, ref ePersistence phase)
{
base.Persist(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
persistence.UpsertField(Constants.Domain_Short_Name, _ShortName);
string relativePath = persistence.GetRelativePath(_Model);
persistence.UpsertField(Constants.Domain_Sub_Model, relativePath);
persistence.UpsertFieldArray(Constants.Domain_Methods, _Methods.ToArray());
DataPersistence.Persist(persistence);
break;
}
return(true);
}
protected override bool Persist(IPersistence persistence, ref ePersistence phase)
{
base.Persist(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
string dataSource = _DataSourceFactory != null
? _DataSourceFactory.Name
: "";
persistence.UpsertField(Constants.DataNode_DataSourceFactory, dataSource);
persistence.UpsertField(Constants.DataNode_DataSourceProperties,
coreSupport.PropertiesAsJson(_ConnectionProperties));
break;
}
return(true);
}
protected virtual bool Retrieve(IPersistence persistence, ref ePersistence phase)
{
switch (phase)
{
case ePersistence.Initial:
Reference = persistence.GetFieldValue(Constants.BaseNode_Reference, new Guid().ToString());
count = persistence.GetFieldValue(Constants.BaseNode_NodeCount, 0);
if (NodeType == eNodeType.unknown)
{
NodeType = (eNodeType)Enum.Parse(typeof(eNodeType), persistence.GetFieldValue(Constants.BaseNode_Type, eNodeType.unknown.ToString()), true);
}
_Name = persistence.GetFieldValue(Constants.BaseNode_Name, "");
_Description = persistence.GetFieldValue(Constants.BaseNode_Description, "");
break;
case ePersistence.Final:
if (!IsReadOnly())
{
for (int i = 0; i < count; i++)
{
if (persistence.NextRecord())
{
string type = persistence.GetFieldValue(Constants.BaseNode_ClassType, Constants.BaseNode_ClassType);
IBaseNode node = Tree.CreateNewNode(type);
node.NodeLoaded += NodeLoaded;
node.Parent = this;
Nodes.Add(node);
node.Retrieve(persistence);
}
}
OnNodeLoaded();
}
break;
}
return(true);
}
protected override bool Persist(IPersistence persistence, ref ePersistence phase)
{
base.Persist(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
//Persist lVal
if (lVal.Domain != null)
{
persistence.UpsertField(Constants.Domain_Reference, lVal.Domain.Reference);
}
if (lVal.Variable != null)
{
persistence.UpsertField(Constants.Variable_Reference, lVal.Variable.Reference);
}
persistence.UpsertField(Constants.Value, lVal.Value);
//Persist rVal
if (rVal.Domain != null)
{
persistence.UpsertField(Constants.Domain_Reference + "-r", rVal.Domain.Reference);
}
if (rVal.Variable != null)
{
persistence.UpsertField(Constants.Variable_Reference + "-r", rVal.Variable.Reference);
}
persistence.UpsertField(Constants.Value + "-r", rVal.Value);
persistence.UpsertField(Constants.Branch_Evaluation, _BranchEvaluation.ToString());
persistence.UpsertField(Constants.Expression, _Expression);
break;
}
return(true);
}
protected override bool Retrieve(IPersistence persistence, ref ePersistence phase)
{
base.Retrieve(persistence, ref phase);
switch (phase)
{
case ePersistence.Initial:
List <string> data = new List <string>();
data.AddRange(persistence.GetFieldValues(Constants.DataDefinitionExport, ""));
foreach (string json in data)
{
if (json != "")
{
IDataDefinitionExportImpl export = JsonConvert.DeserializeObject <IDataDefinitionExportImpl>(json);
Exports.Add(export);
}
}
break;
}
return(true);
}
