public void Initialize()
{
var flowRuleRepo = new SqlFlowRuleRepo();
var provRuleRepo = new SqlProvRuleRepo();
_provRules = provRuleRepo.GetAllRules();
var scriptBuilder = new StringBuilder();
foreach (ProvisionRule provRule in _provRules.Where(rule => rule.RuleType == RuleType.Python))
{
string pyFunc = FuncCreator.GenerateFunction(provRule.Name, "entry", provRule.Condition);
scriptBuilder.Append(pyFunc);
scriptBuilder.Append(Environment.NewLine);
}
Core.RegisterProvisionScript(scriptBuilder.ToString());
var flowRules = flowRuleRepo.GetAllRules();
var flowBuilder = new StringBuilder();
foreach (FlowRule flowRule in flowRules.Where(rule => rule.RuleType == ExpressionType.Python))
{
string pyFunc = FuncCreator.GenerateFunction(flowRule.Name, "source, target", flowRule.Expression);
flowBuilder.Append(pyFunc);
flowBuilder.Append(Environment.NewLine);
}
Core.RegisterFlowScript(flowBuilder.ToString());
}
public object Test(ProvRuleTest test)
{
test.ProvisionRule.Condition = test.ProvisionRule.Condition;
string dummyId = "testId" + Guid.NewGuid().ToString().Replace("-", "");
var func = FuncCreator.GenerateFunction(dummyId, "entry", test.ProvisionRule.Condition);
Core.RegisterFlowScript(func);
var pyFunc = Core.GetFlowFunction(dummyId);
return(pyFunc(test.MVEntry));
}
public object Test(RuleTest test)
{
test.FlowRule.Expression = test.FlowRule.Expression.TrimEnd('"').TrimStart('"');
string dummyId = "testId" + Guid.NewGuid().ToString().Replace("-", "");
var func = FuncCreator.GenerateFunction(dummyId, "source, target", test.FlowRule.Expression);
Core.RegisterFlowScript(func);
var pyFunc = Core.GetFlowFunction(dummyId);
pyFunc(test.Source, test.Target);
return(test.Target);
}
public void Register_and_get_function()
{
string funcScript = FuncCreator.GenerateFunction(testFuncName, testVariables, testExpression);
Core.RegisterFlowScript(funcScript);
var func = Core.GetFlowFunction(testFuncName);
Assert.IsNotNull(func);
int result = func(4);
Assert.AreEqual(6, result);
}
public void Dictionary_variable_works_in_function()
{
const string expression = "dic['givenName'] + ' lund'";
var dic = new Dictionary <string, string>();
dic.Add("givenName", "per");
string script = FuncCreator.GenerateFunction("dicTest", "dic", expression);
Core.RegisterFlowScript(script);
var func = Core.GetFlowFunction("dicTest");
string name = func(dic);
Assert.AreEqual("per lund", name);
}
public void MIM_attribs_work_in_function()
{
MVEntry entry = new MockMventry();
entry["firstName"].Value = "espen";
entry["lastName"].Value = "askeladd";
const string expression = "entry['firstName'].Value + ' ' + entry['lastName'].Value";
string script = FuncCreator.GenerateFunction("entryTest", "entry", expression);
Core.RegisterFlowScript(script);
var func = Core.GetFlowFunction("entryTest");
string name = func(entry);
Assert.AreEqual("espen askeladd", name);
}
public void Initialize()
{
//var ruleLoader = new FileFlowRuleRepo(@"C:\Config\flowRules.json");
//_flows = ruleLoader.GetAllRules();
_flows = new SqlFlowRuleRepo().GetAllRules();
var scriptBuilder = new StringBuilder();
foreach (FlowRule flowRule in _flows.Where(rule => rule.RuleType == ExpressionType.Python))
{
string pyFunc = FuncCreator.GenerateFunction(flowRule.Name, "source, target", flowRule.Expression);
scriptBuilder.Append(pyFunc);
scriptBuilder.Append(Environment.NewLine);
}
Core.RegisterFlowScript(scriptBuilder.ToString());
}
public static T Create <T>(Type type, IDefaultData defaultValue, ObjectCreationStrategy objectCreationStrategy)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var genericTypeParam = type.GetGenericArguments().FirstOrDefault();
if (genericTypeParam != null)
{
var returnValue = FuncCreator.Create <T>(genericTypeParam, defaultValue, objectCreationStrategy);
var result = typeof(TaskCreator).InvokeGenericMethod(nameof(FromResult), new[] { genericTypeParam }, returnValue);
return((T)result);
}
return((T)(object)Task.FromResult(0));
}
public void ProvRules_python_rules_generate_condition_funcs()
{
var provRule = new SimpleMIM.ProvisionExt.ProvisionRule()
{
Name = "nana",
RuleType = RuleType.Python,
Agent = "TestAgent",
Condition = "entry['FirstName'].Value == per",
SourceObject = "person",
TargetObject = "HRMUser"
};
string script = FuncCreator.GenerateFunction(provRule.Name, "entry", provRule.Condition);
Core.RegisterProvisionScript(script);
var func = Core.GetProvisionFunction(provRule.Name);
Assert.IsNotNull(func);
}
public void ProvRules_handles_condition()
{
var provRule = new SimpleMIM.ProvisionExt.ProvisionRule()
{
Name = "nunu",
RuleType = RuleType.Python,
Agent = "TestAgent",
Condition = "entry['FirstName'].Value == 'per'",
SourceObject = "person",
TargetObject = "HRMUser",
InitialFlows = new[] { new FlowRule()
{
Name = "UpperCaser"
} }
};
var flowRules = new FileFlowRuleRepo("Samples\\pyFlowRules.json").GetAllRules();
RuleFactory.SetRules(new List <ProvisionRule>()
{
provRule
}, flowRules);
string script = FuncCreator.GenerateFunction(provRule.Name, "entry", provRule.Condition);
Core.RegisterProvisionScript(script);
var func = Core.GetProvisionFunction(provRule.Name);
Assert.IsNotNull(func);
var mventry = new MockMventry("person");
mventry["FirstName"].Value = "per";
Assert.IsTrue(ProvisionEval.PassesCondition(provRule, mventry));
var mventryInvalid = new MockMventry("person");
mventryInvalid["FirstName"].Value = "sitrus";
Assert.IsFalse(ProvisionEval.PassesCondition(provRule, mventryInvalid));
}
public static T Create <T>(IDefaultData defaultData, ObjectCreationStrategy objectCreationStrategy)
{
var type = typeof(T);
var defaultValue = type.GetDefaultValue(defaultData);
if (defaultValue != null)
{
return((T)defaultValue);
}
if (type.IsInterface)
{
return(InterfaceCreator.Create <T>(type, defaultData, objectCreationStrategy));
}
if (type.IsAbstract)
{
return(AbstractClassCreator.Create <T>(type, defaultData, objectCreationStrategy));
}
if (type.IsArray)
{
return(ArrayCreator.Create <T>(type, defaultData, objectCreationStrategy));
}
if (type.IsAction())
{
return(ActionCreator.Create <T>(type));
}
if (type.IsFunc())
{
return(FuncCreator.Create <T>(type, defaultData, objectCreationStrategy));
}
if (type.IsTask())
{
return(TaskCreator.Create <T>(type, defaultData, objectCreationStrategy));
}
return(UnknownTypeCreator.CreateDynamicFrom <T>(type, defaultData, objectCreationStrategy));
}
public void ProvRules_initialflows_are_set()
{
var provRule = new SimpleMIM.ProvisionExt.ProvisionRule()
{
Name = "nunu",
RuleType = RuleType.Python,
Agent = "TestAgent",
Condition = "entry['FirstName'].Value == per",
SourceObject = "person",
TargetObject = "HRMUser",
InitialFlows = new [] { new FlowRule()
{
Name = "UpperCaser"
} }
};
var flowRules = new FileFlowRuleRepo("Samples\\pyFlowRules.json").GetAllRules();
RuleFactory.SetRules(new List <ProvisionRule>()
{
provRule
}, flowRules);
string script = FuncCreator.GenerateFunction(provRule.Name, "entry", provRule.Condition);
Core.RegisterProvisionScript(script);
var func = Core.GetProvisionFunction(provRule.Name);
Assert.IsNotNull(func);
var mventry = new MockMventry();
mventry["FirstName"].Value = "Espen";
mventry["LastName"].Value = "Askeladd";
var csentry = new MockCsentry();
ProvisionEval.ApplyInitialFlows(provRule, csentry, mventry);
Assert.AreEqual("ESPEN ASKELADD", csentry["DisplayName"].Value);
}
public List <ProvisionRule> GetAllRules()
{
var flowRules = new List <ProvisionRule>();
string rulesText = File.ReadAllText(_filename);
List <ProvisionRule> flowRulesFromFile = JsonConvert.DeserializeObject <List <ProvisionRule> >(rulesText);
flowRules.AddRange(flowRulesFromFile);
var scriptBuilder = new StringBuilder();
foreach (ProvisionRule flowRule in flowRules.Where(rule => rule.RuleType == RuleType.Python))
{
string pyFunc = FuncCreator.GenerateFunction(flowRule.Name, "entry", flowRule.Condition);
scriptBuilder.Append(pyFunc);
scriptBuilder.Append(Environment.NewLine);
}
Core.RegisterProvisionScript(scriptBuilder.ToString());
return(flowRules);
}
public List <FlowRule> GetAllRules()
{
var flowRules = new List <FlowRule>();
for (int i = 0; i < _fileNames.Count; i++)
{
string rulesText = File.ReadAllText(_fileNames[i]);
List <FlowRule> flowRulesFromFile = JsonConvert.DeserializeObject <List <FlowRule> >(rulesText);
flowRules.AddRange(flowRulesFromFile);
}
var scriptBuilder = new StringBuilder();
foreach (FlowRule flowRule in flowRules.Where(rule => rule.RuleType == ExpressionType.Python))
{
string pyFunc = FuncCreator.GenerateFunction(flowRule.Name, "entry", flowRule.Expression);
scriptBuilder.Append(pyFunc);
scriptBuilder.Append(Environment.NewLine);
}
Core.RegisterFlowScript(scriptBuilder.ToString());
return(flowRules);
}
public void Generate_function_string()
{
string func = FuncCreator.GenerateFunction(testFuncName, testVariables, testExpression);
Assert.IsTrue(func.Contains(testFuncName) && func.Contains("return " + testExpression));
}
public void Compile(PythonCompilation compilation)
{
string func = FuncCreator.GenerateFunction(compilation.Name, "entry", compilation.Script);
Core.RegisterFlowScript(func);
}
