private void mnuBool_Click(object sender, EventArgs e)
{
IDataRule aBool = BuildRules.InitializeBase(FieldTypes.Bool, false, "NA", "NA", false);
aBool.Description = "Bool-1";
AddRule(aBool);
}
private void guidToolStripMenuItem_Click(object sender, EventArgs e)
{
IDataRule aGuid = BuildRules.InitializeBase(FieldTypes.GUID, false, "NA", "NA", false);
aGuid.Description = "Guid-1";
AddRule(aGuid);
}
private void BuildInternal(RuleLibraryBuilder Rules)
{
List <string> wrapperCSFiles = new List <string>();
for (int i = 0; i < Rules.Rules.Length; ++i)
{
BuildRules rule = Rules.Rules[i];
sourceBuilders[rule.ModuleName] = new SourceBuilder(rule, Path.GetDirectoryName(Rules.RulesFiles[i]) + EnvironmentHelper.PathSeparator, wrapperCSFiles);
}
BuildSources();
BuildWrapperLibrary(wrapperCSFiles);
}
public override bool ApplyDataToRuleSet()
{
bool valid = true;
InitializeCommonRule();
try
{
BuildRules.Buildrule((CollectionRule)Properties.Result, collectionTypes.SelectedItem.ToString(), valueRule, keyRule, Assemblyname, AssemblyPath);
}
catch (Exception e)
{
valid = ErrorMessage(e);
}
return(valid);
}
public override bool ApplyDataToRuleSet()
{
bool valid = true;
InitializeCommonRule();
try
{
BuildRules.Buildrule((BoolRule)Properties.Result, rbTrue.Checked, rbFalse.Checked);
}
catch (Exception e)
{
valid = ErrorMessage(e);
}
return(valid);
}
public override bool ApplyDataToRuleSet()
{
bool valid = true;
InitializeCommonRule();
try
{
BuildRules.Buildrule((NumberRule)Properties.Result, txtStart.Text, txtEnd.Text, txtNumIncrement.Text);
}
catch (Exception e)
{
valid = ErrorMessage(e);
}
return(valid);
}
public override bool ApplyDataToRuleSet()
{
bool valid = true;
Properties.GeneralType = Enums.FieldTypes.Enumerator;
InitializeCommonRule();
try
{
BuildRules.Buildrule((EnumeratorRule)Properties.Result, rbRandom.Checked, enumeratorList.SelectedItem.ToString(), lblAssemblyName.Text);
}
catch (Exception e)
{
valid = ErrorMessage(e);
}
return(valid);
}
public override bool ApplyDataToRuleSet()
{
bool valid = true;
Properties.GeneralType = Enums.FieldTypes.MappedSource;
InitializeCommonRule();
try
{
BuildRules.Buildrule((MappedSourceRule)Properties.Result, currentMappedSource);
}
catch (Exception e)
{
valid = ErrorMessage(e);
}
return(valid);
}
public override bool ApplyDataToRuleSet()
{
bool valid = true;
InitializeCommonRule();
try
{
string[] entries = new string[lstEntries.Items.Count];
lstEntries.Items.CopyTo(entries, 0);
BuildRules.Buildrule((StringRule)Properties.Result, rbRandomPosition.Checked, txtStringLength.Text, entries);
}
catch (Exception e)
{
valid = ErrorMessage(e);
}
return(valid);
}
public override bool ApplyDataToRuleSet()
{
bool valid = true;
Properties.GeneralType = FieldTypes.MultiColumn;
InitializeCommonRule();
try
{
BuildRules.Buildrule((MultiFieldDataSourceRule)Properties.Result, SourceType, int.Parse(txtMaxRecords.Text), selectionCtrl.SearchFields, selectionCtrl.DataFields, ListCtrlType.Grid);
}
catch (Exception e)
{
valid = ErrorMessage(e);
}
return(valid);
}
public override bool ApplyDataToRuleSet()
{
bool valid = true;
Properties.Random = rangeCtrl.Random;
Properties.GeneralType = FieldTypes.SingleColumn;
InitializeCommonRule();
try
{
BuildRules.Buildrule((SingleFieldDataSourceRule)Properties.Result, SourceType, int.Parse(txtMaxRecords.Text), rangeCtrl.Start, rangeCtrl.End, regularExpressionCtrl.RegularExpression);
}
catch (Exception e)
{
valid = ErrorMessage(e);
}
return(valid);
}
public override bool ApplyDataToRuleSet()
{
bool valid = true;
InitializeCommonRule();
try
{
List <IDataRule> rules = new List <IDataRule>();
foreach (ListViewItem aItem in lstTupleSet.Items)
{
rules.Add((IDataRule)aItem.Tag);
}
BuildRules.Buildrule((TupleRule)Properties.Result, rules);
}
catch (Exception e)
{
valid = ErrorMessage(e);
}
return(valid);
}
public override bool ApplyDataToRuleSet()
{
bool valid = true;
InitializeCommonRule();
try
{
switch (Properties.GeneralType)
{
case FieldTypes.Date:
BuildRules.Buildrule((DateRule)Properties.Result, startDatePicker.Value, endDatePicker.Value, txtTimeDateIncrement.Text, BoxUtl.CboBoxItem(cboRate));
break;
case FieldTypes.Time:
BuildRules.Buildrule((TimeRule)Properties.Result, startDatePicker.Value, endDatePicker.Value, txtTimeDateIncrement.Text, BoxUtl.CboBoxItem(cboRate));
break;
}
}
catch (Exception e)
{
valid = ErrorMessage(e);
}
return(valid);
}
public SourceBuilder(BuildRules Rules, string SourcePathRoot, List <string> WrapperCSFiles)
{
BuildRule = Rules;
wrapperCSFiles = WrapperCSFiles;
foreach (BuildRules.RuleBase rule in BuildRule.Rules)
{
if (((int)rule.Configuration & (int)BuildSystem.BuildConfiguration) != (int)BuildSystem.BuildConfiguration)
{
continue;
}
if (((int)rule.Platform & (int)BuildSystem.PlatformType) != (int)BuildSystem.PlatformType)
{
continue;
}
SelectedRule = rule;
break;
}
sourcePathRoot = SourcePathRoot;
intermediateModulePath = EnvironmentHelper.IntermediateDirectory + Rules.ModuleName + EnvironmentHelper.PathSeparator;
generatedFilesPath = intermediateModulePath + "Generated" + EnvironmentHelper.PathSeparator;
if (SelectedRule.LibraryUseType != BuildRules.LibraryUseTypes.UseOnly)
{
if (!Directory.Exists(generatedFilesPath))
{
Directory.CreateDirectory(generatedFilesPath);
}
}
compiler.ErrorRaised += ErrorRaised;
}
protected void InitializeCommonRule()
{
Properties.Result = BuildRules.InitializeBase(Properties.GeneralType, Properties.Random, Properties.FieldDisplay, Properties.TypeDisplay, false);
Properties.Result.Description = Properties.Description;
}
public bool Build()
{
string projectDir = EnvironmentHelper.IntermediateDirectory + ProjectName + EnvironmentHelper.PathSeparator;
if (!Directory.Exists(projectDir))
{
Directory.CreateDirectory(projectDir);
}
CSProject csproj = new CSProject();
CSProject.Profile profile = (CSProject.Profile)csproj.CreateProfile();
profile.FrameworkVersion = CSProject.Profile.FrameworkVersions.v4_5;
profile.AssemblyName = ProjectName;
profile.OutputPath = projectDir + "Build" + EnvironmentHelper.PathSeparator;
profile.IntermediatePath = projectDir;
profile.OutputType = ProjectBase.ProfileBase.OutputTypes.DynamicLinkLibrary;
csproj.AddReferenceBinaryFile(Assembly.GetExecutingAssembly().Location);
string[] files = FileSystemUtilites.GetAllFiles(processDirectory, "*" + BuildRules.BuildRuleFilePostfix);
DateTime startTime = DateTime.Now;
ConsoleHelper.WriteInfo("Building rules starts at " + startTime.ToString());
ConsoleHelper.WriteInfo("Found rules :");
if (files.Length == 0)
{
ConsoleHelper.WriteInfo("No building rules found, aborting process");
return(false);
}
foreach (string rules in files)
{
csproj.AddCompileFile(rules);
ConsoleHelper.WriteInfo("\t" + Path.GetFileName(rules));
}
Compiler compiler = new Compiler();
compiler.ErrorRaised += OnError;
if (compiler.Build(profile))
{
Assembly rulesLibrary = Assembly.LoadFile(profile.OutputPath + ProjectName + EnvironmentHelper.DynamicLibraryExtentions);
List <string> buildRulesFiles = new List <string>();
List <BuildRules> buildRules = new List <BuildRules>();
foreach (string buildRuleName in files)
{
string fileName = Path.GetFileNameWithoutExtension(buildRuleName);
string typeName = fileName.Replace(".", "");
Type type = rulesLibrary.GetType(BuildRules.NamespacePrefix + typeName);
if (type == null)
{
ConsoleHelper.WriteWarning("In " + fileName + ", type " + typeName + " doesn't exists, building related module will be ignore");
continue;
}
buildRulesFiles.Add(buildRuleName);
BuildRules buildRule = (BuildRules)Activator.CreateInstance(type);
buildRule.Path = FileSystemUtilites.PathSeperatorCorrection(Path.GetDirectoryName(buildRuleName)) + EnvironmentHelper.PathSeparator;
Type[] types = buildRule.GetType().GetNestedTypes();
buildRule.Rules = new BuildRules.RuleBase[types.Length];
for (int i = 0; i < types.Length; ++i)
{
buildRule.Rules[i] = (BuildRules.RuleBase)Activator.CreateInstance(types[i]);
}
buildRules.Add(buildRule);
}
RulesFiles = buildRulesFiles.ToArray();
Rules = buildRules.ToArray();
return(true);
}
ConsoleHelper.WriteInfo("Building rules takes " + (DateTime.Now - startTime).ToHHMMSS());
return(false);
}
