public bool EntireLoadShed()
{
bool hasShedAll = 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();
if (loadList.Count > 0)
{
int current = loadList[0].CurrentLoad;
int maxLoad = loadList[0].MaximumLoad;
if (current >= maxLoad)
{
List <lfa.pmgmt.data.DTO.Configuration.Zone> zones = new List <data.DTO.Configuration.Zone>();
lfa.pmgmt.data.DAO.Configuration.Zone zoneDAO = new data.DAO.Configuration.Zone();
zoneDAO.ConnectionString = _connectionString;
zones = zoneDAO.List();
foreach (lfa.pmgmt.data.DTO.Configuration.Zone zone in zones)
{
List <lfa.pmgmt.data.DTO.Configuration.Unit> units = new List <data.DTO.Configuration.Unit>();
lfa.pmgmt.data.DAO.Configuration.Unit unitDAO = new data.DAO.Configuration.Unit();
unitDAO.ConnectionString = _connectionString;
units = unitDAO.List(zone.Id);
foreach (lfa.pmgmt.data.DTO.Configuration.Unit unit in units)
{
List <lfa.pmgmt.data.DTO.Configuration.Device> devices = new List <data.DTO.Configuration.Device>();
lfa.pmgmt.data.DAO.Configuration.Device deviceDAO = new data.DAO.Configuration.Device();
deviceDAO.ConnectionString = _connectionString;
devices = deviceDAO.List(unit.Id);
foreach (lfa.pmgmt.data.DTO.Configuration.Device device in devices)
{
SwitchDeviceOnOff(2, device.Id, device.Id_Unit);
UpdateDeviceStatus(device.Id, 2);
}
}
}
hasShedAll = true;
}
}
return(hasShedAll);
}
public bool EntireLoadShed()
{
bool hasShedAll = 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();
if (loadList.Count > 0)
{
int current = loadList[0].CurrentLoad;
int maxLoad = loadList[0].MaximumLoad;
if (current >= maxLoad)
{
List<lfa.pmgmt.data.DTO.Configuration.Zone> zones = new List<data.DTO.Configuration.Zone>();
lfa.pmgmt.data.DAO.Configuration.Zone zoneDAO = new data.DAO.Configuration.Zone();
zoneDAO.ConnectionString = _connectionString;
zones = zoneDAO.List();
foreach (lfa.pmgmt.data.DTO.Configuration.Zone zone in zones)
{
List<lfa.pmgmt.data.DTO.Configuration.Unit> units = new List<data.DTO.Configuration.Unit>();
lfa.pmgmt.data.DAO.Configuration.Unit unitDAO = new data.DAO.Configuration.Unit();
unitDAO.ConnectionString = _connectionString;
units = unitDAO.List(zone.Id);
foreach (lfa.pmgmt.data.DTO.Configuration.Unit unit in units)
{
List<lfa.pmgmt.data.DTO.Configuration.Device> devices = new List<data.DTO.Configuration.Device>();
lfa.pmgmt.data.DAO.Configuration.Device deviceDAO = new data.DAO.Configuration.Device();
deviceDAO.ConnectionString = _connectionString;
devices = deviceDAO.List(unit.Id);
foreach (lfa.pmgmt.data.DTO.Configuration.Device device in devices)
{
SwitchDeviceOnOff(2, device.Id, device.Id_Unit);
UpdateDeviceStatus(device.Id, 2);
}
}
}
hasShedAll = true;
}
}
return hasShedAll;
}
private static int GetLoadReportFromAPI(string unitAddress, string connectionString)
{
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;
return(currentUnitLoad);
}
public bool EntireLoadShed(int zoneId, int status)
{
bool hasShedAll = 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();
if (loadList.Count > 0)
{
List <lfa.pmgmt.data.DTO.Configuration.Zone> zones = new List <data.DTO.Configuration.Zone>();
lfa.pmgmt.data.DAO.Configuration.Zone zoneDAO = new data.DAO.Configuration.Zone();
zoneDAO.ConnectionString = _connectionString;
lfa.pmgmt.data.DTO.Configuration.Zone zone = zoneDAO.Get(zoneId);
List <lfa.pmgmt.data.DTO.Configuration.Unit> units = new List <data.DTO.Configuration.Unit>();
lfa.pmgmt.data.DAO.Configuration.Unit unitDAO = new data.DAO.Configuration.Unit();
unitDAO.ConnectionString = _connectionString;
units = unitDAO.List(zone.Id);
foreach (lfa.pmgmt.data.DTO.Configuration.Unit unit in units)
{
List <lfa.pmgmt.data.DTO.Configuration.Device> devices = new List <data.DTO.Configuration.Device>();
lfa.pmgmt.data.DAO.Configuration.Device deviceDAO = new data.DAO.Configuration.Device();
deviceDAO.ConnectionString = _connectionString;
devices = deviceDAO.List(unit.Id);
foreach (lfa.pmgmt.data.DTO.Configuration.Device device in devices)
{
SwitchDeviceOnOff(status, device.Id, device.Id_Unit);
UpdateDeviceStatus(device.Id, status);
}
}
hasShedAll = true;
}
return(hasShedAll);
}
private void btnOK_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(txtZoneName.Text))
{
Exception ex = new Exception("Validation Exception : Please provide the current electricity load!");
HandleException(ex);
}
else if (string.IsNullOrEmpty(textBox1.Text))
{
Exception ex = new Exception("Validation Exception : Please provide the maximum electricity load!");
HandleException(ex);
}
else
{
try
{
if (radioButton1.Checked)
{
string loadValue = textBox1.Text;
lfa.pmgmt.data.DAO.BusinessRule.Load loadDAO = new data.DAO.BusinessRule.Load();
loadDAO.ConnectionString = _connectionString;
loadDAO.InsertManual(int.Parse(txtZoneName.Text), int.Parse(textBox1.Text));
}
else
{
lfa.pmgmt.data.DAO.BusinessRule.Load loadDAO = new data.DAO.BusinessRule.Load();
loadDAO.ConnectionString = _connectionString;
loadDAO.Insert(int.Parse(txtZoneName.Text), int.Parse(textBox1.Text));
}
HandleInformationMesssage("Data successfully saved! Please refresh the form data!");
this.Close();
}
catch (Exception ex)
{
HandleException(ex);
}
}
}
private void btnOK_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(txtZoneName.Text))
{
Exception ex = new Exception("Validation Exception : Please provide the current electricity load!");
HandleException(ex);
}
else if (string.IsNullOrEmpty(textBox1.Text))
{
Exception ex = new Exception("Validation Exception : Please provide the maximum electricity load!");
HandleException(ex);
}
else
{
try
{
if (radioButton1.Checked)
{
string loadValue = textBox1.Text;
lfa.pmgmt.data.DAO.BusinessRule.Load loadDAO = new data.DAO.BusinessRule.Load();
loadDAO.ConnectionString = _connectionString;
loadDAO.InsertManual(int.Parse(txtZoneName.Text), int.Parse(textBox1.Text));
}
else
{
lfa.pmgmt.data.DAO.BusinessRule.Load loadDAO = new data.DAO.BusinessRule.Load();
loadDAO.ConnectionString = _connectionString;
loadDAO.Insert(int.Parse(txtZoneName.Text), int.Parse(textBox1.Text));
}
HandleInformationMesssage("Data successfully saved! Please refresh the form data!");
this.Close();
}
catch (Exception ex)
{
HandleException(ex);
}
}
}
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)
{
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, 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;
}
public bool EntireLoadShed(int zoneId, int status)
{
bool hasShedAll = 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();
if (loadList.Count > 0)
{
List<lfa.pmgmt.data.DTO.Configuration.Zone> zones = new List<data.DTO.Configuration.Zone>();
lfa.pmgmt.data.DAO.Configuration.Zone zoneDAO = new data.DAO.Configuration.Zone();
zoneDAO.ConnectionString = _connectionString;
lfa.pmgmt.data.DTO.Configuration.Zone zone = zoneDAO.Get(zoneId);
List<lfa.pmgmt.data.DTO.Configuration.Unit> units = new List<data.DTO.Configuration.Unit>();
lfa.pmgmt.data.DAO.Configuration.Unit unitDAO = new data.DAO.Configuration.Unit();
unitDAO.ConnectionString = _connectionString;
units = unitDAO.List(zone.Id);
foreach (lfa.pmgmt.data.DTO.Configuration.Unit unit in units)
{
List<lfa.pmgmt.data.DTO.Configuration.Device> devices = new List<data.DTO.Configuration.Device>();
lfa.pmgmt.data.DAO.Configuration.Device deviceDAO = new data.DAO.Configuration.Device();
deviceDAO.ConnectionString = _connectionString;
devices = deviceDAO.List(unit.Id);
foreach (lfa.pmgmt.data.DTO.Configuration.Device device in devices)
{
SwitchDeviceOnOff(status, device.Id, device.Id_Unit);
UpdateDeviceStatus(device.Id, status);
}
}
hasShedAll = true;
}
return hasShedAll;
}
private static int GetLoadReportFromAPI(string unitAddress, string connectionString)
{
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;
return currentUnitLoad;
}
