public static void AddDataVerifyPart(IDataListVerifyPart part, string nameOfPart, Dictionary <IDataListVerifyPart, string> unique)
{
if (!unique.ContainsValue(nameOfPart))
{
unique.Add(part, nameOfPart);
}
}
static void ProcessFoundRecordSets(IDataListVerifyPart part, IDataListItemModel recsetToRemove)
{
if (string.IsNullOrEmpty(part.Field))
{
if (recsetToRemove != null)
{
recsetToRemove.IsUsed = false;
}
}
else
{
if (recsetToRemove == null)
{
return;
}
var childrenToRemove = recsetToRemove.Children.Where(c => c.Name == part.Field && c.IsField);
childrenToRemove.ToList().ForEach(childToRemove =>
{
if (childToRemove != null)
{
childToRemove.IsUsed = false;
}
});
}
}
public void AddMissingScalarParts(IDataListVerifyPart part)
{
if (_vm.ScalarCollection.FirstOrDefault(c => c.DisplayName == part.Field) == null)
{
var scalar = DataListItemModelFactory.CreateScalarItemModel(part.Field, part.Description);
UpdateScalar(scalar);
}
}
public void SetComplexObjectSetPartIsUsed(IDataListVerifyPart part, bool isUsed)
{
var objects = _complexObjectItemModels.Flatten(model => model.Children).Where(model => model.DisplayName == part.DisplayValue.Trim('@'));
objects.ForEach(model =>
{
model.IsUsed = isUsed;
});
}
public void SetScalarPartIsUsed(IDataListVerifyPart part, bool isUsed)
{
var scalarsToRemove = _scalarCollection.Where(c => c.DisplayName == part.Field);
scalarsToRemove.ToList().ForEach(scalarToRemove =>
{
scalarToRemove.IsUsed = isUsed;
});
}
public void AddComplexObject(IDataListVerifyPart part)
{
var paths = part.DisplayValue.Split('.');
IComplexObjectItemModel itemModel = null;
for (var index = 0; index < paths.Length; index++)
{
var path = paths[index];
if (string.IsNullOrEmpty(path) || char.IsNumber(path[0]))
{
return;
}
path = DataListUtil.ReplaceRecordsetIndexWithBlank(path);
var pathToMatch = path.Replace("@", "");
if (string.IsNullOrEmpty(pathToMatch) || pathToMatch == "()")
{
return;
}
var isArray = DataListUtil.IsArray(ref path);
if (itemModel == null)
{
itemModel =
_vm.ComplexObjectCollection.FirstOrDefault(
model => model.DisplayName == pathToMatch && model.IsArray == isArray);
if (itemModel != null)
{
continue;
}
itemModel = new ComplexObjectItemModel(path)
{
IsArray = isArray
};
_vm.ComplexObjectCollection.Add(itemModel);
}
else
{
if (index == 0)
{
continue;
}
var item =
itemModel.Children.FirstOrDefault(
model => model.DisplayName == pathToMatch && model.IsArray == isArray);
if (item == null)
{
item = new ComplexObjectItemModel(path)
{
Parent = itemModel, IsArray = isArray
};
itemModel.Children.Add(item);
}
itemModel = item;
}
}
}
internal IntellisenseResult(int startIdx, int endIdx, IDataListVerifyPart option, string message, enIntellisenseResultType typeOf, enIntellisenseErrorCode errCode, bool isClosed)
{
StartIndex = startIdx;
EndIndex = endIdx;
Option = option;
Message = message;
Type = typeOf;
ErrorCode = errCode;
IsClosedRegion = isClosed;
}
void FindMissingForScalar(IDataListVerifyPart part, List <IDataListVerifyPart> missingDataParts)
{
if (part.IsScalar)
{
if (DataList.Count(c => c.Name == part.Field && !c.IsRecordset) == 0)
{
missingDataParts.Add(part);
}
}
}
internal IntellisenseResult(int startIdx, int endIdx, IDataListVerifyPart option, string message, enIntellisenseResultType typeOf, enIntellisenseErrorCode errCode, bool isClosed) {
StartIndex = startIdx;
EndIndex = endIdx;
Option = option;
Message = message;
Type = typeOf;
ErrorCode = errCode;
IsClosedRegion = isClosed;
}
public void AddMissingTempRecordSet(IDataListVerifyPart part, IRecordSetItemModel tmpRecset)
{
var child = DataListItemModelFactory.CreateRecordSetFieldItemModel(part.Field, part.Description, tmpRecset);
if (child != null)
{
child.DisplayName = part.Recordset + "()." + part.Field;
tmpRecset.Children.Add(child);
}
}
public void FindMissingForScalar(IDataListVerifyPart part, List <IDataListVerifyPart> missingDataParts)
{
if (!part.IsScalar)
{
return;
}
if (_vm.ScalarCollection.Count(c => c.DisplayName == part.Field) == 0)
{
missingDataParts.Add(part);
}
}
void ProcessScalarPart(IDataListVerifyPart part)
{
var scalarsToRemove = ScalarCollection.Where(c => c.Name == part.Field);
scalarsToRemove.ToList().ForEach(scalarToRemove =>
{
if (scalarToRemove != null)
{
scalarToRemove.IsUsed = false;
}
});
}
public void AddMissingRecordSetPart(IRecordSetItemModel recsetToAddTo, IDataListVerifyPart part)
{
if (recsetToAddTo.Children.FirstOrDefault(c => c.DisplayName == part.Field) == null)
{
var child = DataListItemModelFactory.CreateRecordSetFieldItemModel(part.Field, part.Description, recsetToAddTo);
if (recsetToAddTo.Children.Count > 0)
{
recsetToAddTo.Children.Insert(recsetToAddTo.Children.Count - 1, child);
}
else
{
recsetToAddTo.Children.Add(child);
}
}
}
public void AddMissingRecordSetPart(IRecordSetItemModel recsetToAddTo, IDataListVerifyPart part)
{
if (recsetToAddTo.Children.FirstOrDefault(c => c.DisplayName == part.Field) == null)
{
var child = DataListItemModelFactory.CreateRecordSetFieldItemModel(part.Field, part.Description, recsetToAddTo);
child.OnDeleted += (item) => _vm.RemoveDataListItem(item);
child.IsVisible = _vm.IsItemVisible(child.Name);
if (recsetToAddTo.Children.Count > 0)
{
recsetToAddTo.Children.Insert(recsetToAddTo.Children.Count - 1, child);
}
else
{
recsetToAddTo.Children.Add(child);
}
}
}
public bool AddRecordSetIndex(IParseTO payload, bool addCompleteParts, IList <IIntellisenseResult> result, string[] parts, IDev2DataLanguageIntellisensePart t1, bool emptyOk)
{
if (addCompleteParts)
{
string idx = DataListUtil.ExtractIndexRegionFromRecordset(parts[0]);
string recset = DataListUtil.ExtractRecordsetNameFromValue(parts[0]);
IDataListVerifyPart p = IntellisenseFactory.CreateDataListValidationRecordsetPart(recset, string.Empty, t1.Description, payload.Child != null ? payload.Child.Payload : idx);
result.Add(IntellisenseFactory.CreateSelectableResult(payload.StartIndex, payload.EndIndex, p, p.Description));
}
else
{
emptyOk = true;
}
return(emptyOk);
}
void FindMissingPartsForRecordset(IDataListVerifyPart part, List <IDataListVerifyPart> missingDataParts)
{
if (!(part.IsScalar))
{
var recset = DataList.Where(c => c.Name == part.Recordset && c.IsRecordset).ToList();
if (!recset.Any())
{
missingDataParts.Add(part);
}
else
{
if (!string.IsNullOrEmpty(part.Field) && recset[0].Children.Count(c => c.Name == part.Field) == 0)
{
missingDataParts.Add(part);
}
}
}
}
static void AddDataUniquePart(string dataPartFieldData, Dev2DataLanguageParser dataLanguageParser, Dictionary <IDataListVerifyPart, string> unique)
{
IDataListVerifyPart verifyPart = null;
var fieldList = dataPartFieldData.Split('.');
string fullyFormattedStringValue = "";
if (fieldList.Length > 1 && !String.IsNullOrEmpty(fieldList[0]))
{
AddRecsetContainingAField(dataLanguageParser, unique, ref verifyPart, fieldList, ref fullyFormattedStringValue);
}
else
{
if (fieldList.Length == 1 && !String.IsNullOrEmpty(fieldList[0]))
{
AddScalarOrRecset(dataPartFieldData, dataLanguageParser, unique, ref verifyPart, fieldList, ref fullyFormattedStringValue);
}
}
}
private static void ProcessFoundRecordSets(IDataListVerifyPart part, IRecordSetItemModel recsetToRemove, bool isUsed)
{
if (recsetToRemove == null)
{
return;
}
if (string.IsNullOrEmpty(part.Field))
{
recsetToRemove.IsUsed = isUsed;
}
else
{
var childrenToRemove = recsetToRemove.Children.Where(c => c.DisplayName == part.Field);
childrenToRemove.ToList().ForEach(childToRemove =>
{
childToRemove.IsUsed = isUsed;
});
}
}
public void FindMissingPartsForRecordset(IDataListVerifyPart part, List <IDataListVerifyPart> missingDataParts)
{
if (part.IsScalar)
{
return;
}
var recset = _vm.RecsetCollection.Where(c => c.DisplayName == part.Recordset).ToList();
if (!recset.Any())
{
missingDataParts.Add(part);
}
else
{
if (!string.IsNullOrEmpty(part.Field) && recset[0].Children.Count(c => c.DisplayName == part.Field) == 0)
{
missingDataParts.Add(part);
}
}
}
public void ProcessNonRecordsetFields(IParseTO payload, IList <IIntellisenseResult> result, IDev2DataLanguageIntellisensePart t1)
{
if (payload.Parent != null && payload.Parent.Payload.IndexOf(DataListUtil.RecordsetIndexOpeningBracket, StringComparison.Ordinal) >= 0)
{
IDataListVerifyPart part = IntellisenseFactory.CreateDataListValidationScalarPart(t1.Name, t1.Description + " / Use row at this index");
result.Add(IntellisenseFactory.CreateSelectableResult(payload.StartIndex, payload.EndIndex, part, part.Description));
}
else
{
IDataListVerifyPart part;
if (t1.Name.Contains('(') && t1.Name.Contains(')'))
{
part = IntellisenseFactory.CreateDataListValidationRecordsetPart(string.Empty, t1.Name, true);
}
else
{
part = IntellisenseFactory.CreateDataListValidationScalarPart(t1.Name, t1.Description);
}
result.Add(IntellisenseFactory.CreateSelectableResult(payload.StartIndex, payload.EndIndex, part, part.Description));
}
}
public void ProcessRecordSetMatch(IParseTO payload, IList <IIntellisenseResult> result, string rawSearch, string search, IDev2DataLanguageIntellisensePart t1)
{
// only process if it is an open region
// we need to add all children
string idx;
if (!payload.IsLeaf && !payload.Child.HangingOpen)
{
idx = DataListUtil.OpeningSquareBrackets + payload.Child.Payload + DataListUtil.ClosingSquareBrackets;
}
else
{
// we need to extract the index
idx = DataListUtil.ExtractIndexRegionFromRecordset(rawSearch);
}
// add general closed recordset
string rsName = search;
if (idx == string.Empty)
{
rsName = payload.Payload;
}
IDataListVerifyPart part = IntellisenseFactory.CreateDataListValidationRecordsetPart(rsName, "", t1.Description + " / Select a specific row", idx);
result.Add(IntellisenseFactory.CreateSelectableResult(payload.StartIndex, payload.EndIndex, part, part.Description));
IList <IDev2DataLanguageIntellisensePart> children = t1.Children;
if (children != null)
{
foreach (IDev2DataLanguageIntellisensePart t in children)
{
part = IntellisenseFactory.CreateDataListValidationRecordsetPart(rsName, t.Name, t.Description + " / Select a specific field at a specific row", idx);
result.Add(IntellisenseFactory.CreateSelectableResult(payload.StartIndex, payload.EndIndex, part, part.Description));
}
}
}
public void OpenRecordsetItem(IParseTO payload, IList <IIntellisenseResult> result, IDev2DataLanguageIntellisensePart t1)
{
if (payload.Child != null)
{
string indx = payload.Child.Payload;
int end = indx.IndexOf(DataListUtil.RecordsetIndexClosingBracket, StringComparison.Ordinal);
if (end > 0)
{
// malformed index -- correct it
indx = indx.Substring(0, end);
}
indx = DataListUtil.AddBracketsToValueIfNotExist(indx);
string rs = payload.Payload;
end = rs.IndexOf(DataListUtil.RecordsetIndexOpeningBracket, StringComparison.Ordinal);
if (end > 0)
{
rs = rs.Substring(0, end);
}
IDataListVerifyPart prt = IntellisenseFactory.CreateDataListValidationRecordsetPart(rs, "", " / Select a specific row", indx);
result.Add(IntellisenseFactory.CreateSelectableResult(payload.StartIndex, payload.EndIndex, prt, prt.Description));
// now add all fields to collection too ;)
if (t1.Children != null)
{
IList <IDev2DataLanguageIntellisensePart> cParts = t1.Children;
foreach (IDev2DataLanguageIntellisensePart t in cParts)
{
prt = IntellisenseFactory.CreateDataListValidationRecordsetPart(rs, t.Name, " / Select a specific row", indx);
result.Add(IntellisenseFactory.CreateSelectableResult(payload.StartIndex, payload.EndIndex, prt, prt.Description));
}
}
}
}
public bool ProcessFieldsForRecordSet(IParseTO payload, bool addCompleteParts, IList <IIntellisenseResult> result, string[] parts, out string search, out bool emptyOk, string display, IDev2DataLanguageIntellisensePart recordsetPart, string partName)
{
emptyOk = false;
search = "";
if (parts[0].IndexOf(DataListUtil.RecordsetIndexClosingBracket, StringComparison.Ordinal) <= 0)
{
// its an error ;)
IDataListVerifyPart part = IntellisenseFactory.CreateDataListValidationRecordsetPart(parts[0], "." + parts[1], true);
result.Add(IntellisenseFactory.CreateErrorResult(payload.StartIndex, payload.EndIndex, part, " [[" + display + "]] is a malformed recordset", enIntellisenseErrorCode.InvalidRecordsetNotation, !payload.HangingOpen));
}
else
{
search = parts[1].ToLower();
var intellisenseResult = ValidateName(search, "Recordset field");
if (intellisenseResult != null)
{
result.Add(intellisenseResult);
return(true);
}
foreach (IDev2DataLanguageIntellisensePart t in recordsetPart.Children)
{
string match = t.Name.ToLower();
if (match.Contains(search) && ((match != search) || (match == search && addCompleteParts)))
{
string index = payload.Child != null ? payload.Child.Payload : DataListUtil.ExtractIndexRegionFromRecordset(parts[0]);
IDataListVerifyPart part = IntellisenseFactory.CreateDataListValidationRecordsetPart(partName, t.Name, t.Description, index);
result.Add(IntellisenseFactory.CreateSelectableResult(parts[0].Length, payload.EndIndex, part, part.Description));
}
else if (match == search)
{
emptyOk = true;
}
}
}
return(false);
}
public static IIntellisenseResult CreateDateTimeResult(IDataListVerifyPart opt)
{
return new IntellisenseResult(0, 0, opt, "", enIntellisenseResultType.Selectable, enIntellisenseErrorCode.None, true);
}
public static IIntellisenseResult CreateErrorResult(int start, int end, IDataListVerifyPart opt, string msg, enIntellisenseErrorCode code, bool isClosed) {
return new IntellisenseResult(start, end, opt, msg, enIntellisenseResultType.Error, code, isClosed);
}
public static IIntellisenseResult CreateSelectableResult(int start, int end, IDataListVerifyPart opt, string msg) {
return new IntellisenseResult(start, end, opt, msg, enIntellisenseResultType.Selectable, enIntellisenseErrorCode.None, true);
}
static void AddRecsetContainingAField(Dev2DataLanguageParser dataLanguageParser, Dictionary <IDataListVerifyPart, string> unique, ref IDataListVerifyPart verifyPart, string[] fieldList, ref string fullyFormattedStringValue)
{
// If it's a RecordSet Containing a field
var recAdded = false;
foreach (var item in fieldList)
{
if (item.EndsWith(")") && item == fieldList[0])
{
AddField(dataLanguageParser, unique, ref verifyPart, ref fullyFormattedStringValue, ref recAdded, item);
}
else if (item == fieldList[1] && !(item.EndsWith(")") && item.Contains(")")))
{
verifyPart = AddField(dataLanguageParser, unique, verifyPart, fieldList, recAdded, item);
}
else
{
break;
}
}
}
public static void AddDataVerifyPart(IDataListVerifyPart part, string nameOfPart, Dictionary<IDataListVerifyPart, string> unique)
{
if (!unique.ContainsValue(nameOfPart))
{
unique.Add(part, nameOfPart);
}
}
void ProcessRecordSetPart(IDataListVerifyPart part)
{
var recsetsToRemove = RecsetCollection.Where(c => c.Name == part.Recordset && c.IsRecordset);
recsetsToRemove.ToList().ForEach(recsetToRemove => ProcessFoundRecordSets(part, recsetToRemove));
}
static IDataListVerifyPart AddField(Dev2DataLanguageParser dataLanguageParser, Dictionary <IDataListVerifyPart, string> unique, IDataListVerifyPart verifyPart, string[] fieldList, bool recAdded, string item)
{
// If it's a field to a record set
var intellisenseResult = dataLanguageParser.ValidateName(item, "");
if (intellisenseResult == null && recAdded)
{
verifyPart = IntellisenseFactory.CreateDataListValidationRecordsetPart(
RemoveRecordSetBrace(fieldList.ElementAt(0)), item);
AddDataVerifyPart(verifyPart, verifyPart.DisplayValue, unique);
}
return(verifyPart);
}
private static void AddScalarOrRecset(string dataPartFieldData, Dev2DataLanguageParser dataLanguageParser, Dictionary <IDataListVerifyPart, string> unique, ref IDataListVerifyPart verifyPart, string[] fieldList, ref string fullyFormattedStringValue)
{
// If the workflow field is simply a scalar or a record set without a child
if (dataPartFieldData.EndsWith(")") && dataPartFieldData == fieldList[0])
{
if (dataPartFieldData.Contains("("))
{
fullyFormattedStringValue = RemoveRecordSetBrace(fieldList[0]);
var intellisenseResult = dataLanguageParser.ValidateName(fullyFormattedStringValue, "");
if (intellisenseResult == null)
{
verifyPart = IntellisenseFactory.CreateDataListValidationRecordsetPart(fullyFormattedStringValue, String.Empty);
AddDataVerifyPart(verifyPart, verifyPart.DisplayValue, unique);
}
}
}
else
{
var intellisenseResult = dataLanguageParser.ValidateName(dataPartFieldData, "");
if (intellisenseResult == null)
{
verifyPart = IntellisenseFactory.CreateDataListValidationScalarPart(RemoveRecordSetBrace(dataPartFieldData));
AddDataVerifyPart(verifyPart, verifyPart.DisplayValue, unique);
}
}
}
static void AddField(Dev2DataLanguageParser dataLanguageParser, Dictionary <IDataListVerifyPart, string> unique, ref IDataListVerifyPart verifyPart, ref string fullyFormattedStringValue, ref bool recAdded, string item)
{
if (item.Contains("("))
{
fullyFormattedStringValue = RemoveRecordSetBrace(item);
var intellisenseResult = dataLanguageParser.ValidateName(fullyFormattedStringValue, "");
if (intellisenseResult == null)
{
recAdded = true;
verifyPart =
IntellisenseFactory.CreateDataListValidationRecordsetPart(fullyFormattedStringValue,
String.Empty);
AddDataVerifyPart(verifyPart, verifyPart.DisplayValue, unique);
}
}
}
void SetScalarPartIsUsed(IDataListVerifyPart part, bool isUsed)
{
var scalarsToRemove = ScalarCollection.Where(c => c.Name == part.Field);
scalarsToRemove.ToList().ForEach(scalarToRemove =>
{
if(scalarToRemove != null)
{
scalarToRemove.IsUsed = isUsed;
}
});
}
static void ProcessFoundRecordSets(IDataListVerifyPart part, IDataListItemModel recsetToRemove, bool isUsed)
{
if(string.IsNullOrEmpty(part.Field))
{
if(recsetToRemove != null)
{
recsetToRemove.IsUsed = isUsed;
}
}
else
{
if(recsetToRemove == null) return;
var childrenToRemove = recsetToRemove.Children.Where(c => c.Name == part.Field && c.IsField);
childrenToRemove.ToList().ForEach(childToRemove =>
{
if(childToRemove != null)
{
childToRemove.IsUsed = isUsed;
}
});
}
}
void SetRecordSetPartIsUsed(IDataListVerifyPart part, bool isUsed)
{
var recsetsToRemove = RecsetCollection.Where(c => c.Name == part.Recordset && c.IsRecordset);
recsetsToRemove.ToList().ForEach(recsetToRemove => ProcessFoundRecordSets(part, recsetToRemove, isUsed));
}
void FindMissingPartsForRecordset(IDataListVerifyPart part, List<IDataListVerifyPart> missingDataParts)
{
if(!(part.IsScalar))
{
var recset = DataList.Where(c => c.Name == part.Recordset && c.IsRecordset).ToList();
if(!recset.Any())
{
missingDataParts.Add(part);
}
else
{
if(!string.IsNullOrEmpty(part.Field) && recset[0].Children.Count(c => c.Name == part.Field) == 0)
{
missingDataParts.Add(part);
}
}
}
}
void FindMissingForScalar(IDataListVerifyPart part, List<IDataListVerifyPart> missingDataParts)
{
if(part.IsScalar)
{
if(DataList.Count(c => c.Name == part.Field && !c.IsRecordset) == 0)
{
missingDataParts.Add(part);
}
}
}
public static IIntellisenseResult CreateSelectableResult(int start, int end, IDataListVerifyPart opt, string msg) => new IntellisenseResult(start, end, opt, msg, enIntellisenseResultType.Selectable, enIntellisenseErrorCode.None, true);
public static IIntellisenseResult CreateDateTimeResult(IDataListVerifyPart opt) => new IntellisenseResult(0, 0, opt, "", enIntellisenseResultType.Selectable, enIntellisenseErrorCode.None, true);
void AddRecordSetItem(IDataListViewModel viewModel, IDataListVerifyPart part, List<IDataListItemModel> results)
{
IDataListItemModel item = DataListItemModelFactory.CreateDataListItemViewModel(viewModel, part.Recordset, part.Description, null, true);
results.Add(item);
}
public static IIntellisenseResult CreateErrorResult(int start, int end, IDataListVerifyPart opt, string msg, enIntellisenseErrorCode code, bool isClosed) => new IntellisenseResult(start, end, opt, msg, enIntellisenseResultType.Error, code, isClosed);
