public FieldSettings(FieldTypes generalType)
 {
     InitializeComponent();
     descriptionCtrl.DescriptionChange = DescriptionChange;
     EnablePanel(generalType);
     Result = null;
 }
        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);
        }
        public override void EditRule(IDataRule aRule)
        {
            base.EditRule(aRule);
            chkConvertToString.Checked = aRule.ConvertToString;
            rbRandomDateTime.Checked   = aRule.IsRandom;
            rbDateTimeInc.Checked      = !aRule.IsRandom;
            string inc = String.Empty;
            int    idx = -1;

            if (aRule.RuleType == FieldTypes.Time)
            {
                TimeRule tRule = (TimeRule)aRule;
                startDatePicker.Value = tRule.Start;
                endDatePicker.Value   = tRule.End;
                idx = cboRate.Items.IndexOf(tRule.RateType.ToString());
                inc = tRule.Increment.ToString();
            }
            else
            {
                DateRule dRule = (DateRule)aRule;
                startDatePicker.Value = dRule.Start;
                endDatePicker.Value   = dRule.End;
                idx = cboRate.Items.IndexOf(dRule.RateType.ToString());
                inc = dRule.Increment.ToString();
            }
            cboRate.SelectedIndex     = idx;
            txtTimeDateIncrement.Text = inc;
        }
        public SqdDataFacadeImpl(IDataRule dataRule)
        {
            this.DataRule = dataRule;
            Biz           = DataRule.Sqd;

            mbr = new MbrBisFacade(dataRule);
            grp = new GrpBisFacade(dataRule);
        }
Esempio n. 6
0
        public EngineV2(IDataRule dataRule)
        {
            this.DataRule = dataRule;

            DataRule.SlnChanged  += this.OnDataRuleSlnChanged;
            DataRule.DataChanged += this.OnDataRuleDataChanged;
            DataRule.RuleChanged += this.OnDataRuleRuleChanged;
        }
 public FieldSettings(IDataRule editRule) : this(editRule.RuleType)
 {
     fieldRuleCtrl.EditRule(editRule);
     Result = editRule;
     descriptionCtrl.Description  = editRule.Description;
     descriptionCtrl.TypeDisplay  = editRule.FieldDataType;
     descriptionCtrl.FieldDisplay = editRule.FieldName;
 }
Esempio n. 8
0
 public TupleDialog(IDataRule editRule)
     : this()
 {
     tupleCtrl.EditRule(editRule);
     descriptionCtrl.Description  = editRule.Description;
     descriptionCtrl.TypeDisplay  = editRule.FieldDataType;
     descriptionCtrl.FieldDisplay = editRule.FieldName;
 }
        public TchDataFacadeImpl(IDataRule dataRule)
        {
            this.DataRule = dataRule;
            Biz           = DataRule.Tch;

            mbr = new MbrBisFacade(DataRule);
            grp = new GrpBisFacade(DataRule);
        }
Esempio n. 10
0
 public static void Buildrule(CollectionRule aRule, String genericType, IDataRule valueRule, IDataRule keyRule, String assembly, String assemblyPath)
 {
     aRule.Assembly  = assembly;
     aRule.Assembly  = assemblyPath;
     aRule.Generic   = EnumPlus.ConvertString(typeof(GenericCollections), genericType);
     aRule.ValueRule = valueRule;
     aRule.KeyRule   = keyRule;
 }
Esempio n. 11
0
        private void mnuEditRule_Click(object sender, EventArgs e)
        {
            IDataRule oldRule = aRuleCtrl.Properties.Result;

            if (aRuleCtrl.ApplyDataToRuleSet())
            {
                tupleCtrl.EditARule(oldRule, aRuleCtrl.Properties.Result);
            }
        }
 private void btnSet_Click(object sender, EventArgs e)
 {
     if (fieldRuleCtrl.ApplyDataToRuleSet())
     {
         Result            = fieldRuleCtrl.Properties.Result;
         this.DialogResult = DialogResult.OK;
         this.Close();
     }
 }
Esempio n. 13
0
 public CollectionDialog(IDataRule editRule) : this()
 {
     collectionsCtrl.EditRule(editRule);
     descriptionCtrl.Description  = editRule.Description;
     descriptionCtrl.TypeDisplay  = editRule.FieldDataType;
     descriptionCtrl.FieldDisplay = editRule.FieldName;
     EditRules(editRule);
     SetCollectionType();
 }
 public virtual void EditRule(IDataRule aRule)
 {
     Properties.Result       = aRule;
     Properties.TypeDisplay  = aRule.FieldDataType;
     Properties.FieldDisplay = aRule.FieldName;
     Properties.Description  = aRule.Description;
     Properties.Random       = aRule.IsRandom;
     Properties.GeneralType  = aRule.RuleType;
 }
Esempio n. 15
0
        public override void EditRule(IDataRule aRule)
        {
            base.EditRule(aRule);
            TupleRule tRule = (TupleRule)aRule;

            foreach (IDataRule lstRule in tRule.Types)
            {
                AddRule(lstRule);
            }
        }
        private void AddRule(IDataRule aRule)
        {
            string[] info = new string[3];
            info[0] = aRule.FieldDataType;
            info[1] = Enum.GetName(typeof(FieldTypes), aRule.RuleType);
            info[2] = aRule.Description;
            ListViewItem aItem = new ListViewItem(info);

            lstDataSource.Items.Add(aItem).Tag = aRule;
        }
Esempio n. 17
0
        public DataFacadeImpl(IDataRule dataRule)
        {
            this.DataRule = dataRule;

            Crs = new CrsDataFacadeImpl(dataRule);
            Tch = new TchDataFacadeImpl(dataRule);
            Sqd = new SqdDataFacadeImpl(dataRule);

            Rule = new RuleDataFacadeImpl(dataRule);
        }
 public void SetRule(IDataRule collectionRule, bool key)
 {
     if (!key)
     {
         valueRule = collectionRule;
     }
     else
     {
         keyRule = collectionRule;
     }
 }
 private void editRuleToolStripMenuItem_Click(object sender, EventArgs e)
 {
     if (lstDataSource.SelectedItems.Count > 0)
     {
         IDataRule aRule = (IDataRule)lstDataSource.SelectedItems[0].Tag;
         if (aRule != null)
         {
             EditRule(aRule, lstDataSource.SelectedItems[0]);
         }
     }
 }
        public override void EditRule(IDataRule aRule)
        {
            base.EditRule(aRule);
            MultiFieldDataSourceRule iRule = (MultiFieldDataSourceRule)aRule;

            LoadFile(iRule.TypeofInternalSource);
            SourceType       = iRule.TypeofInternalSource;
            rangeCtrl.Random = iRule.IsRandom;
            selectionCtrl.EditRule(iRule.SearchFields, iRule.FieldColumnMap);
            txtMaxRecords.Text = iRule.MaxRecords.ToString();
        }
Esempio n. 21
0
        private string SetType(IDataRule aRule)
        {
            String result = aRule.RuleType.ToString();

            if (aRule.RuleType == FieldTypes.Number)
            {
                result = String.Format("Number:{0}", aRule.FieldDataType);
            }

            return(result);
        }
 private void ctxEditRule_Click(object sender, EventArgs e)
 {
     if (lstMappedPairs.SelectedItems.Count > 0)
     {
         IDataRule aRule = (IDataRule)lstMappedPairs.SelectedItems[0].Tag;
         if (aRule != null)
         {
             EditRule(aRule, lstMappedPairs.SelectedItems[0]);
         }
     }
 }
Esempio n. 23
0
 public void EditARule(IDataRule oldRule, IDataRule newRule)
 {
     foreach (ListViewItem aItem in lstTupleSet.Items)
     {
         if (((IDataRule)aItem.Tag).RuleId.Equals(oldRule.RuleId))
         {
             aItem.Tag = newRule;
             break;
         }
     }
 }
        private void LoadParameterMaps(List <ParameterMap> parameters, List <IDataRule> _rules)
        {
            foreach (ParameterMap aMap in parameters)
            {
                IDataRule aRule = _rules.Where(x => x.FieldName.Equals(aMap.ParameterName)).FirstOrDefault();
                AddToTargetObjectList(aMap.ParameterName, aMap.DataType);
                AddToDataSourceList(aMap);
                AddToMapList(aMap);
            }

            Totals(parameters.Count);
        }
Esempio n. 25
0
        private void mnuSet_Click(object sender, EventArgs e)
        {
            collectionsCtrl.Properties.TypeDisplay  = descriptionCtrl.TypeDisplay;
            collectionsCtrl.Properties.FieldDisplay = descriptionCtrl.FieldDisplay;

            if (collectionsCtrl.ApplyDataToRuleSet())
            {
                Result            = collectionsCtrl.Properties.Result;
                this.DialogResult = DialogResult.OK;
                this.Close();
            }
        }
        public override void EditRule(IDataRule aRule)
        {
            base.EditRule(aRule);
            NumberRule nRule = (NumberRule)aRule;

            chkConvertToString.Checked = nRule.ConvertToString;
            rbRandomNumber.Checked     = nRule.IsRandom;
            rbNumberIncrement.Checked  = !nRule.IsRandom;
            txtStart.Text        = nRule.Start.ToString();
            txtEnd.Text          = nRule.End.ToString();
            txtNumIncrement.Text = nRule.Increment.ToString();
        }
        private void EditRule(IDataRule oldRule)
        {
            int idx = lstSources.Items.IndexOf(((DataSourceRule)oldRule).TypeofInternalSource.ToString().Replace("_", " "));

            if (idx != -1)
            {
                Result   = oldRule;
                editMode = true;
                lstSources.SetSelected(idx, true);
                lastCtrl.EditRule(oldRule);
            }
        }
Esempio n. 28
0
        public override void EditRule(IDataRule aRule)
        {
            base.EditRule(aRule);
            int idx = enumeratorList.Items.IndexOf(((EnumeratorRule)aRule).Enumerator);

            if (idx != -1)
            {
                enumeratorList.SetItemChecked(idx, true);
                rbRandom.Checked     = aRule.IsRandom;
                rbIterate.Checked    = !aRule.IsRandom;
                lblAssemblyName.Text = "Assembly Name: " + ((EnumeratorRule)aRule).Assembly;
            }
        }
        public override void EditRule(IDataRule aRule)
        {
            base.EditRule(aRule);
            SingleFieldDataSourceRule iRule = (SingleFieldDataSourceRule)aRule;

            LoadFile(iRule.TypeofInternalSource);
            SourceType       = iRule.TypeofInternalSource;
            rangeCtrl.Start  = iRule.RangeStart;
            rangeCtrl.End    = iRule.RangeEnd;
            rangeCtrl.Random = iRule.IsRandom;
            regularExpressionCtrl.RegularExpression = iRule.RegularExpression;
            txtMaxRecords.Text = iRule.MaxRecords.ToString();
        }
        public override void EditRule(IDataRule aRule)
        {
            base.EditRule(aRule);
            CollectionRule cRule = (CollectionRule)aRule;

            keyRule   = cRule.KeyRule;
            valueRule = cRule.ValueRule;
            int idx = collectionTypes.Items.IndexOf(cRule.Generic.ToString());

            if (idx != -1)
            {
                collectionTypes.SelectedIndex = idx;
            }
        }