public TflField GetField(string expression = null) { var field = new TflField().GetDefaultOf<TflField>(f => { f.Name = "Test"; }); if (expression != null) { field.T = expression; } return field; }
public TflField GetField(string expression = null) { var field = new TflField{ Name = "Test" }.WithDefaults(); if (expression != null) { field.T = expression; } return field; }
public ShortHandFactory GetFactory(TflField field = null) { var process = new TflRoot().GetDefaultOf<TflProcess>(p => { p.Name = "Test"; p.Entities = new List<TflEntity>{ new TflEntity().GetDefaultOf<TflEntity>(e => { e.Name = "Test"; }) }; }); if (field != null) { process.Entities.First().Fields.Add(field); } return new ShortHandFactory(process); }
public ShortHandFactory GetFactory(TflField field = null) { var process = new TflProcess { Name = "Test", Entities = new List<TflEntity>{ new TflEntity { Name = "Test" }.WithDefaults() } }.WithDefaults(); if (field != null) { process.Entities.First().Fields.Add(field); } return new ShortHandFactory(process); }
private void FieldSearchTypesLoader(Field field, TflField element) { var searchTypes = element.SearchTypes; if (searchTypes.Count > 0) { foreach (var st in searchTypes.Where(st => _process.SearchTypes.ContainsKey(st.Name))) { field.SearchTypes.Add(InheritType(_process.SearchTypes[st.Name], field)); } return; } var searchType = element.SearchType.ToLower(); if (_process.SearchTypes.Any()) { if (_process.SearchTypes.ContainsKey(searchType)) { field.SearchTypes.Add(InheritType(_process.SearchTypes[searchType], field)); } } }
public Field Read(TflField element, FieldType fieldType = FieldType.NonKey) { var alias = Common.GetAlias(element, _usePrefix, _entity.Prefix); var field = new Field(element.Type, element.Length, fieldType, element.Output, element.Default) { Process = _process.Name, Entity = _entity.Alias, EntityIndex = _entity.Index, EntityOutputName = _entity.OutputName(), Index = element.Index, Schema = _entity.Schema, Name = element.Name, Alias = alias, Precision = element.Precision, Scale = element.Scale, Input = element.Input, NodeType = element.NodeType, ReadInnerXml = element.ReadInnerXml, Unicode = element.Unicode.Equals("[default]") ? _entity.Unicode : Convert.ToBoolean(element.Unicode), VariableLength = element.VariableLength.Equals("[default]") ? _entity.VariableLength : Convert.ToBoolean(element.VariableLength), Aggregate = element.Aggregate, Sort = element.Sort, Label = element.Label, DefaultBlank = element.DefaultBlank, DefaultWhiteSpace = element.DefaultWhiteSpace, QuotedWith = element.QuotedWith, Optional = element.Optional, Raw = element.Raw, Delimiter = element.Delimiter, Distinct = element.Distinct }; FieldSearchTypesLoader(field, element); foreach (var keyField in new[] { "TflKey", "TflUpdate", "TflBatchId", "TflFileName", "TflDeleted", "TflAction" }) { if (field.Alias.Equals(keyField, IC) && field.Input) { _process.Logger.EntityWarn(_entity.Name, "{0}, defined in {1}, is a reserved field name. Please alias this field.", field.Alias, field.Entity); } } return field; }
public TflTransform Interpret(string expression, TflField field, TflTransform lastTransform = null) { string method; var arg = string.Empty; if (Guard.Against(_problems, expression == null, "You may not pass a null expression.")) { return _guard; } // ReSharper disable once PossibleNullReferenceException if (expression.Contains("(")) { var index = expression.IndexOf('('); method = expression.Left(index).ToLower(); arg = expression.Remove(0, index + 1).TrimEnd(new[] { ')' }); } else { method = expression; } if (Guard.Against(_problems, !_methods.ContainsKey(method), "Sorry. Your expression '{0}' references an undefined method: '{1}'.", expression, method)) { return _guard; } return _functions[_methods[method]](arg, field, lastTransform); }
private TflTransform Concat(string arg, TflField field, TflTransform lastTransform) { return Parameterless("concat", "concatenated", arg, field, lastTransform); }
private TflTransform Pad(string method, string arg, TflField field, TflTransform lastTransform) { if (Guard.Against(_problems, arg.Equals(string.Empty), "The {0} method requires two pararmeters: the total width, and the padding character(s).", method)) { return _guard; } var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 2, "The {0} method requires two pararmeters: the total width, and the padding character(s). You've provided {1} parameter{2}.", method, split.Length, split.Length.Plural())) { return _guard; } var element = new TflTransform { Method = method, IsShortHand = true }.WithDefaults(); int totalWidth; if (int.TryParse(split[0], out totalWidth)) { element.TotalWidth = totalWidth; } else { _problems.Add(string.Format("The {0} method requires the first parameter to be total width; an integer. {1} is not an integer", method, split[0])); return _guard; } element.PaddingChar = split[1][0]; if (Guard.Against(_problems, element.PaddingChar == default(char), "The {0} second parameter, the padding character, must be a character. You can't pad something with nothing.", method)) { return _guard; } if (split.Length > 2) { element.Parameter = split[2]; } return element; }
private TflTransform ToInt(string arg, TflField field, TflTransform lastTransform) { var element = Convert(arg, field, lastTransform); element.Method = "convert"; element.To = "int"; return element; }
private TflTransform Right(string arg, TflField field, TflTransform lastTransform) { int length; if (Guard.Against(_problems, !int.TryParse(arg, out length), "The right method requires a single integer representing the length, or how many right-most characters you want. You passed in '{0}'.", arg)) { return _guard; } return new TflTransform { Method = "right", Length = length, IsShortHand = true }.WithDefaults(); }
private TflTransform Slug(string arg, TflField field, TflTransform lastTransform) { var element = new TflTransform { Method = "slug", IsShortHand = true }.WithDefaults(); var split = SplitComma(arg); if (Guard.Against(_problems, split.Length > 1, "The slug method takes 1 argument; an integer representing the maximum length of the slug. You passed in '{0}' arguments.", split.Length)) { return _guard; } int length; if (split.Length > 0 && int.TryParse(split[0], out length)) { element.Length = length; } else { element.Length = 128; } return element; }
private TflTransform Convert(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); var element = new TflTransform { Method = "convert", IsShortHand = true }.WithDefaults(); if (split.Length == 0) return element; foreach (var p in split) { if (System.Text.Encoding.GetEncodings().Any(e => e.Name.Equals(p, StringComparison.OrdinalIgnoreCase))) { element.Encoding = p; } else if (Common.TypeMap.ContainsKey(Common.ToSimpleType(p))) { element.To = Common.ToSimpleType(p); } else { element.Format = p; } } return element; }
private TflTransform Substring(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 1, "The substring method requires a start index.")) { return _guard; } int length; int startIndex; if (int.TryParse(split[0], out startIndex)) { return new TflTransform { Method = "substring", StartIndex = startIndex, Length = split.Length > 1 && int.TryParse(split[1], out length) ? length : 0, IsShortHand = true }.WithDefaults(); } _problems.Add($"The substring method requires two integers indicating start index and length. '{arg}' doesn't represent two integers."); return _guard; }
private TflTransform Remove(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 2, "The remove method requires start index and length. You have {0} parameter{1}.", split.Length, split.Length.Plural())) { return _guard; } int startIndex; int length; if (int.TryParse(split[0], out startIndex) && int.TryParse(split[1], out length)) { return new TflTransform { Method = "remove", StartIndex = startIndex, Length = length, IsShortHand = true }.WithDefaults(); } _problems.Add( $"The remove method requires two integer parameters indicating start index and length. '{arg}' doesn't represent two integers."); return _guard; }
private TflTransform TrimStartAppend(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 1, "The trimstartappend method requires at least one parameter indicating the trim characters.")) { return _guard; } var element = new TflTransform { Method = "trimstartappend", TrimChars = split[0], IsShortHand = true }.WithDefaults(); if (split.Length > 1) { element.Separator = split[1]; } if (split.Length > 2) { element.Parameter = split[2]; } return element; }
private TflTransform Map(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length == 0, "The map method requires a map name (e.g. 'map'), or a set of parameters that represent an inline map (e.g. 'a=1,b=2,c=3').")) { return _guard; } var element = new TflTransform { Method = "map", IsShortHand = true }.WithDefaults(); if (_maps.ContainsKey(split[0])) { element.Map = split[0]; Guard.Against(_problems, split.Length > 1, "If you reference a map name in a map method, that's the only parameter you can have. It will map what is in the current field."); return element; } element.Map = string.Join(",", split); return element; }
private TflTransform Web(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length > 2, "The web method takes two optional parameters: a parameter referencing a field, and an integer representing sleep ms in between web requests. You have {0} parameter{1} in '{2}'.", split.Length, split.Length.Plural(), arg)) { return _guard; } var element = new TflTransform { Method = "web", IsShortHand = true }.WithDefaults(); foreach (var p in split) { int sleep; if (int.TryParse(p, out sleep)) { element.Sleep = sleep; } else { element.Parameter = p; } } return element; }
private TflTransform RegexReplace(string arg, TflField field, TflTransform lastTransform) { if (Guard.Against(_problems, arg.Equals(string.Empty), "The regexreplace requires two parameters: a regular expression pattern, and replacement text. You didn't pass in any parameters.")) { return _guard; }; var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 2, "The regexreplace method requires at least two parameters: the pattern, and the replacement text. A third parameter, count (how many to replace) is optional. The argument '{0}' has {1} parameter{2}.", arg, split.Length, split.Length.Plural())) { return _guard; } var element = new TflTransform { Method = "regexreplace", Pattern = split[0], Replacement = split[1], IsShortHand = true }.WithDefaults(); if (split.Length <= 2) return element; int count; if (Guard.Against(_problems, !int.TryParse(split[2], out count), "The regexreplace's third parameter; count, must be an integer. The argument '{0}' contains '{1}'.", arg, split[2])) { return _guard; } element.Count = count; return element; }
private TflTransform InsertInterval(string arg, TflField field, TflTransform lastTransform) { //interval, value var split = SplitComma(arg); if (Guard.Against(_problems, split.Length != 2, "The insertinterval method requires two parameters: the interval (e.g. every certain number of characters), and the value to insert. '{0}' has {1} parameter{2}.", arg, split.Length, split.Length.Plural())) { return _guard; } var element = new TflTransform { Method = "insertinterval", IsShortHand = true }.WithDefaults(); int interval; if (int.TryParse(split[0], out interval)) { element.Interval = interval; } else { _problems.Add(string.Format("The insertinterval method's first parameter must be an integer. {0} is not an integer.", split[0])); return _guard; } element.Value = split[1]; return element; }
private TflTransform Replace(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 2, "The replace method requires two parameters: an old value, and a new value. Your arguments '{0}' resolve {1} parameter{2}.", arg, split.Length, split.Length.Plural())) { return _guard; } var oldValue = split[0]; var newValue = split[1]; return new TflTransform { Method = "replace", OldValue = oldValue, NewValue = newValue, IsShortHand = true }.WithDefaults(); }
private TflTransform Insert(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length != 2, "The insert method requires two parameters; the start index, and the value (or field reference) you'd like to insert. '{0}' has {1} parameter{2}.", arg, split.Length, split.Length.Plural())) { return _guard; } var element = new TflTransform { Method = "insert", IsShortHand = true }.WithDefaults(); int startIndex; if (int.TryParse(split[0], out startIndex)) { element.StartIndex = startIndex; } else { _problems.Add($"The insert method's first parameter must be an integer. {split[0]} is not an integer."); return _guard; } element.Parameter = split[1]; return element; }
private TflTransform ToString(string arg, TflField field, TflTransform lastTransform) { var element = Convert(arg, field, lastTransform); element.Method = "tostring"; element.To = "string"; return element; }
private TflTransform PadLeft(string arg, TflField field, TflTransform lastTransform) { return Pad("padleft", arg, field, lastTransform); }
private TflTransform If(string arg, TflField field, TflTransform lastTransform) { var linked = new LinkedList<string>(SplitComma(arg)); if (Guard.Against(_problems, linked.Count < 2, "The if method requires at least 2 arguments. Your argument '{0}' has {1}.", arg, linked.Count)) { return _guard; } // left is required first, assign and remove var element = new TflTransform { Method = "if", Left = linked.First.Value, IsShortHand = true }.WithDefaults(); linked.RemoveFirst(); // operator is second, but optional, assign and remove if present ComparisonOperator op; if (Enum.TryParse(linked.First.Value, true, out op)) { element.Operator = op.ToString(); linked.RemoveFirst(); } // right, then, and else in that order var split = linked.ToList(); for (var i = 0; i < split.Count; i++) { switch (i) { case 0: element.Right = split[i]; break; case 1: element.Then = split[i]; break; case 2: element.Else = split[i]; break; } } return element; }
private TflTransform Add(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length == 0, "The add method requires a * parameter, or a comma delimited list of parameters that reference numeric fields.")) { return _guard; } var element = new TflTransform { Method = "add", IsShortHand = true }.WithDefaults(); if (split.Length == 1) { element.Parameter = split[0]; } else { for (var i = 0; i < split.Length; i++) { var p = split[i]; element.Parameters.Add( p.IsNumeric() ? new TflParameter { Name = p, Value = p }.WithDefaults() : new TflParameter { Field = p }.WithDefaults()); } } return element; }
private static FieldType GetFieldType(TflField element, bool isMaster) { FieldType fieldType; if (element.PrimaryKey) { fieldType = isMaster ? FieldType.MasterKey : FieldType.PrimaryKey; } else { fieldType = FieldType.NonKey; } return fieldType; }
private TflTransform Parameters(string method, string arg, int skip, TflField f, TflTransform lastTransform) { var split = SplitComma(arg, skip); if (Guard.Against(_problems, split.Length == 0, "The {0} method requires parameters.", method)) { return _guard; } var element = new TflTransform { Method = method, IsShortHand = true }.WithDefaults(); if (split.Length == 1) { element.Parameter = split[0]; } else { for (var i = 0; i < split.Length; i++) { var p = split[i]; element.Parameters.Add(new TflParameter { Field = p }.WithDefaults()); } } // handle single parameter that is named parameter if (element.Parameter.Contains(":")) { var pair = Common.Split(element.Parameter, ":"); element.Parameters.Insert(0, new TflParameter { Field = string.Empty, Name = pair[0], Value = pair[1] }.WithDefaults()); element.Parameter = string.Empty; } // handle regular parameters foreach (var p in element.Parameters) { if (!p.Field.Contains(":")) continue; var pair = Common.Split(p.Field, ":"); p.Field = string.Empty; p.Name = pair[0]; p.Value = pair[1]; } return element; }
private TflTransform Join(string arg, TflField field, TflTransform lastTransform) { if (string.IsNullOrEmpty(arg)) { return new TflTransform { Method = "concat", IsShortHand = true }.WithDefaults(); } var split = SplitComma(arg); if (Guard.Against(_problems, split.Length != 1, "The join method requires one parameter; the separator. To get fields for join, use the copy() method.")) { return _guard; } return new TflTransform { Method = "join", Separator = split[0], IsShortHand = true }.WithDefaults(); }
private TflTransform PadRight(string arg, TflField field, TflTransform lastTransform) { return Pad("padright", arg, field, lastTransform); }