public void SelectTabs(int tabIndex, RuleSetTypes ruleType = RuleSetTypes.PreValidate)
{
switch (tabIndex)
{
case 0:
tabControl1.SelectedTab = tabPage1;
break;
case 1:
tabControl1.SelectedTab = tabPage2;
idpeRulesEditorControl1.SelectTabs(ruleType);
break;
case 2:
tabControl1.SelectedTab = tabPage3;
break;
case 3:
tabControl1.SelectedTab = tabPage4;
break;
case 4:
tabControl1.SelectedTab = tabPage5;
break;
}
}
public void SelectTabs(RuleSetTypes ruleType)
{
if (ruleType == RuleSetTypes.PreValidate)
{
tabControl.SelectedTab = tabPage1;
}
else if (ruleType == RuleSetTypes.RowPreparing)
{
tabControl.SelectedTab = tabPage2;
}
else if (ruleType == RuleSetTypes.RowPrepared)
{
tabControl.SelectedTab = tabPage3;
}
else if (ruleType == RuleSetTypes.RowValidate)
{
tabControl.SelectedTab = tabPage4;
}
else if (ruleType == RuleSetTypes.PostValidate)
{
tabControl.SelectedTab = tabPage5;
}
else if (ruleType == RuleSetTypes.SqlPullInit)
{
tabControl.SelectedTab = tabPage6;
}
}
private void BindData()
{
Manager manager = new Manager();
DataTable table = manager.GetRuleDependencies(RuleId);
this.Text = "Rule Dependencies - " + manager.GetRule(RuleId).Name;
lvwDataSources.Items.Clear();
foreach (DataRow row in table.Rows)
{
string dataSourceName = row[1].ToString();
if (!string.IsNullOrEmpty(txtSearch.Text))
{
if (!(dataSourceName.ToLower().Contains(txtSearch.Text.ToLower())))
{
continue;
}
}
ListViewItem item = new ListViewItem(dataSourceName);
RuleSetTypes ruleSetType = (RuleSetTypes)int.Parse(row[2].ToString());
item.SubItems.Add(ruleSetType.ToString());
item.Tag = row[0].ToString();
lvwDataSources.Items.Add(item);
}
}
private GSearchResultCube FormatResultRule(GSearchResultCube result)
{
bool isErrored = false;
string info = new SqlClientManager(ConnectionString, IdpeKeyTypes.ConnectionStringSqlCe)
.ExecuteQuery("select name, rulesettype from idpedatasource ds inner join idperuledatasource rds on rds.datasourceid = ds.id where ruleid = " + result.ReferenceId
, ref isErrored);
if ((info == "NULL") || (string.IsNullOrEmpty(info)))
{
result.DataSource = "0-General";
result.Where = "Master";
}
else
{
info = info.Replace("NULL", string.Empty);
result.DataSource = info.Split("|".ToCharArray())[0];
string strRuleType = info.Split("|".ToCharArray())[1];
int ruleType = 0;
if (int.TryParse(strRuleType, out ruleType))
{
RuleSetTypes ruleSetTypes = (RuleSetTypes)ruleType;
result.Param1 = ruleSetTypes.ToString();
result.Where = "Rule - " + ruleSetTypes.ToString();
}
else
{
result.Where = "Unknown";
}
}
result.Value = string.Empty;
return(result);
}
public BusinessRule(string ruleSetAsXaml, int priority, RuleSetTypes ruleSetType)
{
this.Priority = priority;
this.RuleSetType = ruleSetType;
Stream stream = new MemoryStream(ASCIIEncoding.Default.GetBytes(ruleSetAsXaml));
this.Activity = ActivityXamlServices.Load(stream) as DynamicActivity;
}
/// <summary>
/// Executes business rules based on ruleSetType. Executes all business rules if ruleSetType is not passed
/// </summary>
/// <param name="job">The job in context</param>
/// <param name="data">The worker data in context</param>
/// <param name="ruleSetType">The ruleSetType (Executes all business rules if ruleSetType is not passed)</param>
public void Execute(Job job, WorkerData data, RuleSetTypes ruleSetType = RuleSetTypes.Unknown)
{
List <BusinessRule> businessRules = ruleSetType == RuleSetTypes.Unknown ? this : this.Where(bs => bs.RuleSetType == ruleSetType).ToList();
foreach (BusinessRule businessRule in businessRules)
{
businessRule.Execute(job, data);
}
}
void ExportRuleNames(List <IdpeRule> allRules, RuleSetTypes ruleSetType)
{
List <IdpeRule> rules = allRules.Where(r => r.RuleSetType == (int)ruleSetType).ToList();
foreach (IdpeRule rule in rules)
{
RuleNames.Add(string.Format("{0}({1}):{2}", ruleSetType.ToString().PadRight(12), rule.Priority, rule.Name));
}
}
/// <summary>
/// Executes business rules based on ruleSetType. Executes all business rules if ruleSetType is not passed
/// </summary>
/// <param name="job">The job in context</param>
/// <param name="data">The worker data in context</param>
/// <param name="ruleSetType">The ruleSetType (Executes all business rules if ruleSetType is not passed)</param>
public void Execute(Job job, WorkerData data, RuleSetTypes ruleSetType = RuleSetTypes.Unknown)
{
List <BusinessRule> businessRules = ruleSetType == RuleSetTypes.Unknown ? this : this.Where(bs => bs.RuleSetType == ruleSetType).OrderBy(bp => bp.Priority).ToList();
foreach (BusinessRule businessRule in businessRules)
{
businessRule.Execute(job, data);
//businessRule.ExceptionOccurred = true;
//this.ExceptionOccurred = true;
}
}
public void DeleteRuleFromDataSource(int dataSourceId, int ruleId, RuleSetTypes ruleSetType, bool deleteRule = false)
{
string sqlStatement = "delete from [IdpeRuleDataSource] ";
sqlStatement += string.Format("where (DataSourceId = {0}) and (RuleId = {1}) and (RuleSetType = {2})", dataSourceId, ruleId, (int)ruleSetType);
CoreDatabaseObjects.Instance.ExecuteStatement(sqlStatement);
if (deleteRule)
{
sqlStatement = "delete from [IdpeRule] ";
sqlStatement += string.Format("where Id = {0}", ruleId);
CoreDatabaseObjects.Instance.ExecuteStatement(sqlStatement);
}
}
protected override void Execute(CodeActivityContext context)
{
Job job = context.GetValue(this.Job);
WorkerData data = context.GetValue(this.Data);
RuleSetTypes ruleSetType = context.GetValue(this.RuleSetType);
int originalPosition = context.GetValue(this.OriginalPostion);
job = job == null ? data.Job : job;
StartPerformanceCounter(job, ruleSetType, originalPosition);
job.DataSource.BusinessRules.Execute(job, data, ruleSetType);
//if (job.DataSource.BusinessRules.ExceptionOccurred)
//{
// job.AbortRequested = true;
// job.AbortReason = Services.Job.AbortReasons.BusinessRuleFailed;
//}
StopPerformanceCounter(job, ruleSetType, originalPosition);
}
private void tabControl_SelectedIndexChanged(object sender, EventArgs e)
{
if (!ShowSqlInitRules)
{
switch (tabControl.SelectedIndex)
{
case 0:
selectedRuleListView = lvPreValidate;
selectedRuleSetType = RuleSetTypes.PreValidate;
break;
case 1:
selectedRuleListView = lvRowPreparing;
selectedRuleSetType = RuleSetTypes.RowPreparing;
break;
case 2:
selectedRuleListView = lvRowPrepared;
selectedRuleSetType = RuleSetTypes.RowPrepared;
break;
case 3:
selectedRuleListView = lvRowValidate;
selectedRuleSetType = RuleSetTypes.RowValidate;
break;
case 4:
selectedRuleListView = lvPostValidate;
selectedRuleSetType = RuleSetTypes.PostValidate;
break;
}
}
else
{
selectedRuleListView = lvSqlInit;
selectedRuleSetType = RuleSetTypes.SqlPullInit;
}
}
private void StartPerformanceCounter(Job job, RuleSetTypes ruleSetType, int originalPosition)
{
if (ruleSetType == RuleSetTypes.PreValidate)
{
job.PerformanceCounter.Start(job.JobIdentifier, JobPerformanceTaskNames.PreValidate);
}
else if (ruleSetType == RuleSetTypes.RowPreparing)
{
job.PerformanceCounter.Start(job.JobIdentifier, RowPerformanceTaskNames.RowPreparing, originalPosition);
}
else if (ruleSetType == RuleSetTypes.RowPrepared)
{
job.PerformanceCounter.Start(job.JobIdentifier, RowPerformanceTaskNames.RowPrepared, originalPosition);
}
else if (ruleSetType == RuleSetTypes.RowValidate)
{
job.PerformanceCounter.Start(job.JobIdentifier, RowPerformanceTaskNames.RowValidate, originalPosition);
}
else if (ruleSetType == RuleSetTypes.PostValidate)
{
job.PerformanceCounter.Start(job.JobIdentifier, JobPerformanceTaskNames.PostValidate);
}
}
public MainWindow(IdpeRule idpeRule, RuleSetTypes ruleSetType)
{
if (!String.IsNullOrEmpty(idpeRule.Name))
{
string sname = idpeRule.Name.Replace("-", "").Replace(" ", "");
this.WindowName = sname;
}
this._TemplateWithJob = System.IO.Path.Combine(Information.TempDirectoryIdpe, "WithJob.xml");
this._TemplateWithData = System.IO.Path.Combine(Information.TempDirectoryIdpe, "WithData.xml");
if (!File.Exists(_TemplateWithJob))
{
using (Stream stream = Assembly.GetExecutingAssembly()
.GetManifestResourceStream("Eyedia.IDPE.Interface.RuleEditor.Templates.WithJob.xml"))
{
using (StreamReader reader = new StreamReader(stream))
{
using (StreamWriter sw = new StreamWriter(_TemplateWithJob))
{
sw.Write(reader.ReadToEnd());
sw.Close();
}
}
}
}
if (!File.Exists(_TemplateWithData))
{
using (Stream stream = Assembly.GetExecutingAssembly()
.GetManifestResourceStream("Eyedia.IDPE.Interface.RuleEditor.Templates.WithData.xml"))
{
using (StreamReader reader = new StreamReader(stream))
{
using (StreamWriter sw = new StreamWriter(_TemplateWithData))
{
sw.Write(reader.ReadToEnd());
sw.Close();
}
}
}
}
//when new reference added, .new file will be created
if (File.Exists(_TemplateWithJob + ".New"))
{
if (File.Exists(_TemplateWithJob))
{
File.Delete(_TemplateWithJob);
}
File.Copy(_TemplateWithJob + ".New", _TemplateWithJob);
File.Delete(_TemplateWithJob + ".New");
}
if (File.Exists(_TemplateWithData + ".New"))
{
if (File.Exists(_TemplateWithData))
{
File.Delete(_TemplateWithData);
}
File.Copy(_TemplateWithData + ".New", _TemplateWithData);
File.Delete(_TemplateWithData + ".New");
}
_idpeRule = idpeRule;
_ruleSetTemplate = ruleSetType;
TransactionMode = idpeRule.Id == 0 ? "INSERT" : "UPDATE";
InitializeComponent();
LoadDocument();
}