private static bool ExecutePriority(string connectionString, string priorityValue, out int status, out int ruleCount)
{
int tempStatus = 0;
bool executeRule = false;
List <lfa.pmgmt.data.DTO.BusinessRule.Load> loadList = new List <data.DTO.BusinessRule.Load>();
lfa.pmgmt.data.DAO.BusinessRule.Load loadDAO = new data.DAO.BusinessRule.Load();
loadDAO.ConnectionString = connectionString;
loadList = loadDAO.List();
int currentUnitLoad = 0;
if (loadList[0].ManualLoad > 0)
{
currentUnitLoad = loadList[0].ManualLoad;
}
else
{
currentUnitLoad = loadList[0].CurrentLoad;
}
lfa.pmgmt.data.DAO.BusinessRule.RuleSet ruleSetDAO = new data.DAO.BusinessRule.RuleSet();
ruleSetDAO.ConnectionString = connectionString;
List <lfa.pmgmt.data.DTO.BusinessRule.Priority> priorityRules = ruleSetDAO.ListPriority(priorityValue);
int tmpRuleCount = 0;
foreach (lfa.pmgmt.data.DTO.BusinessRule.Priority priorityRule in priorityRules)
{
if (priorityRule.PriorityType.ToLower().Equals(priorityValue.ToLower()))
{
lfa.pmgmt.data.DAO.BusinessRule.Rule ruleDAO = new data.DAO.BusinessRule.Rule();
ruleDAO.ConnectionString = connectionString;
List <lfa.pmgmt.data.DTO.BusinessRule.Rule> ruleDTOList = ruleDAO.GetFromRuleSet(priorityRule.Id_RuleSet);
tmpRuleCount = ruleDTOList.Count;
foreach (lfa.pmgmt.data.DTO.BusinessRule.Rule ruleDTO in ruleDTOList)
{
if (executeRule)
{
break;
}
string[] ruleArray = ruleDTO.Condition.Split(".".ToCharArray());
int unitId = int.Parse(ruleArray[0].ToString());
int deviceId = int.Parse(ruleArray[1].ToString());
string mathMetric = ruleArray[2].ToString();
int loadValue = int.Parse(ruleArray[3].ToString());
string[] resultArray = ruleDTO.Result.Split(".".ToCharArray());
tempStatus = int.Parse(resultArray[2].ToString());
switch (mathMetric)
{
case "<=":
executeRule = CurrentLoadSmallerThenEqualsValue(executeRule, loadValue, currentUnitLoad);
break;
case ">=":
executeRule = CurrentLoadBiggerThenEqualsValue(executeRule, loadValue, currentUnitLoad);
break;
case "<":
executeRule = CurrentLoadSmallerThenValue(executeRule, loadValue, currentUnitLoad);
break;
case ">":
executeRule = CurrentLoadBiggerThenValue(executeRule, loadValue, currentUnitLoad);
break;
case "==":
executeRule = CurrentLoadEqualsValue(executeRule, loadValue, currentUnitLoad);
break;
}
}
if (executeRule)
{
break;
}
}
if (executeRule)
{
break;
}
}
status = tempStatus;
ruleCount = tmpRuleCount;
return(executeRule);
}
private static bool ExecutePriority(string connectionString, string priorityValue, out int status, out int ruleCount)
{
int tempStatus = 0;
bool executeRule = false;
List<lfa.pmgmt.data.DTO.BusinessRule.Load> loadList = new List<data.DTO.BusinessRule.Load>();
lfa.pmgmt.data.DAO.BusinessRule.Load loadDAO = new data.DAO.BusinessRule.Load();
loadDAO.ConnectionString = connectionString;
loadList = loadDAO.List();
int currentUnitLoad = 0;
if (loadList[0].ManualLoad > 0)
{
currentUnitLoad = loadList[0].ManualLoad;
}
else
{
currentUnitLoad = loadList[0].CurrentLoad;
}
//System.Diagnostics.EventLog.WriteEntry("BUGGER", currentUnitLoad.ToString(), System.Diagnostics.EventLogEntryType.Warning);
lfa.pmgmt.data.DAO.BusinessRule.RuleSet ruleSetDAO = new data.DAO.BusinessRule.RuleSet();
ruleSetDAO.ConnectionString = connectionString;
List<lfa.pmgmt.data.DTO.BusinessRule.Priority> priorityRules = ruleSetDAO.ListPriority(priorityValue);
int tmpRuleCount = 0;
foreach (lfa.pmgmt.data.DTO.BusinessRule.Priority priorityRule in priorityRules)
{
if (priorityRule.PriorityType.ToLower().Equals(priorityValue.ToLower()))
{
lfa.pmgmt.data.DAO.BusinessRule.Rule ruleDAO = new data.DAO.BusinessRule.Rule();
ruleDAO.ConnectionString = connectionString;
List<lfa.pmgmt.data.DTO.BusinessRule.Rule> ruleDTOList = ruleDAO.GetFromRuleSet(priorityRule.Id_RuleSet);
tmpRuleCount = ruleDTOList.Count;
foreach (lfa.pmgmt.data.DTO.BusinessRule.Rule ruleDTO in ruleDTOList)
{
if (executeRule)
{
break;
}
string[] ruleArray = ruleDTO.Condition.Split(".".ToCharArray());
int unitId = int.Parse(ruleArray[0].ToString());
int deviceId = int.Parse(ruleArray[1].ToString());
string mathMetric = ruleArray[2].ToString();
int loadValue = int.Parse(ruleArray[3].ToString());
string[] resultArray = ruleDTO.Result.Split(".".ToCharArray());
tempStatus = int.Parse(resultArray[2].ToString());
switch (mathMetric)
{
case "<=":
executeRule = CurrentLoadSmallerThenEqualsValue(executeRule, loadValue, currentUnitLoad);
break;
case ">=":
executeRule = CurrentLoadBiggerThenEqualsValue(executeRule, loadValue, currentUnitLoad);
break;
case "<":
executeRule = CurrentLoadSmallerThenValue(executeRule, loadValue, currentUnitLoad);
break;
case ">":
executeRule = CurrentLoadBiggerThenValue(executeRule, loadValue, currentUnitLoad);
break;
case "==":
executeRule = CurrentLoadEqualsValue(executeRule, loadValue, currentUnitLoad);
break;
}
}
if (executeRule)
{
break;
}
}
if (executeRule)
{
break;
}
}
status = tempStatus;
ruleCount = tmpRuleCount;
return executeRule;
}
private static bool ExecutePriority(string connectionString, string priorityValue)
{
bool executeRule = false;
List <lfa.pmgmt.data.DTO.BusinessRule.Load> loadList = new List <data.DTO.BusinessRule.Load>();
lfa.pmgmt.data.DAO.BusinessRule.Load loadDAO = new data.DAO.BusinessRule.Load();
loadDAO.ConnectionString = connectionString;
loadList = loadDAO.List();
int currentUnitLoad = loadList[0].CurrentLoad;
lfa.pmgmt.data.DAO.BusinessRule.RuleSet ruleSetDAO = new data.DAO.BusinessRule.RuleSet();
ruleSetDAO.ConnectionString = connectionString;
List <lfa.pmgmt.data.DTO.BusinessRule.Priority> priorityRules = ruleSetDAO.ListPriority();
foreach (lfa.pmgmt.data.DTO.BusinessRule.Priority priorityRule in priorityRules)
{
if (priorityRule.PriorityType.ToLower().Equals(priorityValue.ToLower()))
{
lfa.pmgmt.data.DAO.BusinessRule.Rule ruleDAO = new data.DAO.BusinessRule.Rule();
ruleDAO.ConnectionString = connectionString;
lfa.pmgmt.data.DTO.BusinessRule.Rule ruleDTO = ruleDAO.GetFromRuleSet(priorityRule.Id_RuleSet);
string[] ruleArray = ruleDTO.Condition.Split(".".ToCharArray());
int unitId = int.Parse(ruleArray[0].ToString());
int deviceId = int.Parse(ruleArray[1].ToString());
string mathMetric = ruleArray[2].ToString();
int loadValue = int.Parse(ruleArray[3].ToString());
switch (mathMetric)
{
case "<=":
executeRule = CurrentLoadSmallerThenEqualsValue(executeRule, loadValue, currentUnitLoad);
break;
case ">=":
executeRule = CurrentLoadBiggerThenEqualsValue(executeRule, loadValue, currentUnitLoad);
break;
case "<":
executeRule = CurrentLoadSmallerThenValue(executeRule, loadValue, currentUnitLoad);
break;
case ">":
executeRule = CurrentLoadBiggerThenValue(executeRule, loadValue, currentUnitLoad);
break;
case "==":
executeRule = CurrentLoadEqualsValue(executeRule, loadValue, currentUnitLoad);
break;
}
}
}
#region OBSOLETE
//int currentUnitLoad = loadList[0].CurrentLoad;
//int maxLoad = loadList[0].MaximumLoad;
//if (currentUnitLoad >= maxLoad)
//{
// executePriority = true;
//}
#endregion
return(executeRule);
}
private static bool ExecutePriority(string connectionString, string priorityValue)
{
bool executeRule = false;
List<lfa.pmgmt.data.DTO.BusinessRule.Load> loadList = new List<data.DTO.BusinessRule.Load>();
lfa.pmgmt.data.DAO.BusinessRule.Load loadDAO = new data.DAO.BusinessRule.Load();
loadDAO.ConnectionString = connectionString;
loadList = loadDAO.List();
int currentUnitLoad = loadList[0].CurrentLoad;
lfa.pmgmt.data.DAO.BusinessRule.RuleSet ruleSetDAO = new data.DAO.BusinessRule.RuleSet();
ruleSetDAO.ConnectionString = connectionString;
List<lfa.pmgmt.data.DTO.BusinessRule.Priority> priorityRules = ruleSetDAO.ListPriority();
foreach (lfa.pmgmt.data.DTO.BusinessRule.Priority priorityRule in priorityRules)
{
if(priorityRule.PriorityType.ToLower().Equals(priorityValue.ToLower()))
{
lfa.pmgmt.data.DAO.BusinessRule.Rule ruleDAO = new data.DAO.BusinessRule.Rule();
ruleDAO.ConnectionString = connectionString;
lfa.pmgmt.data.DTO.BusinessRule.Rule ruleDTO = ruleDAO.GetFromRuleSet(priorityRule.Id_RuleSet);
string[] ruleArray = ruleDTO.Condition.Split(".".ToCharArray());
int unitId = int.Parse(ruleArray[0].ToString());
int deviceId = int.Parse(ruleArray[1].ToString());
string mathMetric = ruleArray[2].ToString();
int loadValue = int.Parse(ruleArray[3].ToString());
switch (mathMetric)
{
case "<=":
executeRule = CurrentLoadSmallerThenEqualsValue(executeRule, loadValue, currentUnitLoad);
break;
case ">=":
executeRule = CurrentLoadBiggerThenEqualsValue(executeRule, loadValue, currentUnitLoad);
break;
case "<":
executeRule = CurrentLoadSmallerThenValue(executeRule, loadValue, currentUnitLoad);
break;
case ">":
executeRule = CurrentLoadBiggerThenValue(executeRule, loadValue, currentUnitLoad);
break;
case "==":
executeRule = CurrentLoadEqualsValue(executeRule, loadValue, currentUnitLoad);
break;
}
}
}
#region OBSOLETE
//int currentUnitLoad = loadList[0].CurrentLoad;
//int maxLoad = loadList[0].MaximumLoad;
//if (currentUnitLoad >= maxLoad)
//{
// executePriority = true;
//}
#endregion
return executeRule;
}
