/// <summary>
/// Fills a flex field template
/// </summary>
/// <param name="code">Code</param>
/// <param name="name">Name to use</param>
/// <param name="field">Field</param>
/// <param name="flexFieldObject">Flex Field object</param>
/// <param name="exportSettings">Export Settings</param>
/// <param name="objectType">Object Type</param>
/// <param name="isFirst">true if the field is the first field</param>
/// <param name="isLast">true if the field is the last field</param>
/// <returns>Filled template</returns>
private string FillFlexFieldTemplate(string code, string name, FlexField field, IFlexFieldExportable flexFieldObject, ExportSettings exportSettings, string objectType, bool isFirst, bool isLast)
{
code = ExportUtil.RenderPlaceholderIfTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_Field_IsBlank_Start), BuildFinalPlaceholder(Placeholder_FlexField_Field_IsBlank_End), string.IsNullOrEmpty(field.Value));
code = ExportUtil.RenderPlaceholderIfTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_Field_IsNotBlank_Start), BuildFinalPlaceholder(Placeholder_FlexField_Field_IsNotBlank_End), !string.IsNullOrEmpty(field.Value));
code = ExportUtil.RenderPlaceholderIfTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_Field_IsFirst_Start), BuildFinalPlaceholder(Placeholder_FlexField_Field_IsFirst_End), isFirst);
code = ExportUtil.RenderPlaceholderIfTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_Field_IsNotFirst_Start), BuildFinalPlaceholder(Placeholder_FlexField_Field_IsNotFirst_End), !isFirst);
code = ExportUtil.RenderPlaceholderIfTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_Field_IsLast_Start), BuildFinalPlaceholder(Placeholder_FlexField_Field_IsLast_End), isLast);
code = ExportUtil.RenderPlaceholderIfTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_Field_IsNotLast_Start), BuildFinalPlaceholder(Placeholder_FlexField_Field_IsNotLast_End), !isLast);
code = ExportUtil.RenderPlaceholderIfTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_Field_IsNumberField_Start), BuildFinalPlaceholder(Placeholder_FlexField_Field_IsNumberField_End), field.FieldType == ExportConstants.FlexFieldType_Number);
code = ExportUtil.RenderPlaceholderIfTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_Field_IsStringField_Start), BuildFinalPlaceholder(Placeholder_FlexField_Field_IsStringField_End), field.FieldType == ExportConstants.FlexFieldType_String || field.FieldType == ExportConstants.FlexFieldType_Option);
code = ExportUtil.RenderPlaceholderIfFuncTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_Field_Value_Equals_Start), BuildFinalPlaceholder(Placeholder_FlexField_Field_Value_Equals_End), m => {
return(m.Groups[1].Value == field.Value);
});
code = ExportUtil.RenderPlaceholderIfFuncTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_Field_Value_NotEquals_Start), BuildFinalPlaceholder(Placeholder_FlexField_Field_Value_NotEquals_End), m => {
return(m.Groups[1].Value != field.Value);
});
code = ExportUtil.BuildPlaceholderRegex(BuildFinalPlaceholder(Placeholder_FlexField_Field_Name)).Replace(code, name);
code = ExportUtil.BuildPlaceholderRegex(BuildFinalPlaceholder(Placeholder_FlexField_Field_Value)).Replace(code, EscapedFieldValue(field, exportSettings));
if (field.FieldType == ExportConstants.FlexFieldType_String || field.FieldType == ExportConstants.FlexFieldType_Option)
{
code = ExportUtil.BuildPlaceholderRegex(BuildFinalPlaceholder(Placeholder_FlexField_Field_LangKey)).Replace(code, m => {
// Run in function to only create needed language keys
return(BuildFlexFieldLangKey(flexFieldObject, field, objectType));
});
}
return(code);
}
/// <summary>
/// Builds a list of flex field values
/// </summary>
/// <param name="attributeTemplate">Attribute Template</param>
/// <param name="fields">List of fields</param>
/// <param name="flexFieldObject">Flex Field object</param>
/// <param name="exportSettings">Export Settings</param>
/// <param name="objectType">Object Type</param>
/// <returns>Flex Field list</returns>
private string BuildFlexFieldList(string attributeTemplate, List <FlexField> fields, IFlexFieldExportable flexFieldObject, ExportSettings exportSettings, string objectType)
{
string fieldContent = string.Empty;
List <FlexField> fieldsToExport = FilterInvalidFlexFields(fields);
for (int curFieldIndex = 0; curFieldIndex < fieldsToExport.Count; ++curFieldIndex)
{
FlexField curField = fieldsToExport[curFieldIndex];
string[] additionalScriptNames = null;
if (curField.ScriptSettings != null && !string.IsNullOrEmpty(curField.ScriptSettings.AdditionalScriptNames))
{
additionalScriptNames = curField.ScriptSettings.AdditionalScriptNames.Split(ExportConstants.FlexFieldAdditionalScriptNamesSeperator, StringSplitOptions.RemoveEmptyEntries);
}
string fieldCode = FillFlexFieldTemplate(attributeTemplate, curField.Name, curField, flexFieldObject, exportSettings, objectType, curFieldIndex == 0, curFieldIndex == fieldsToExport.Count - 1 && (additionalScriptNames == null || additionalScriptNames.Length == 0));
if (additionalScriptNames != null)
{
for (int curAdditionalNameIndex = 0; curAdditionalNameIndex < additionalScriptNames.Length; ++curAdditionalNameIndex)
{
string curAdditionalName = additionalScriptNames[curAdditionalNameIndex];
fieldCode += FillFlexFieldTemplate(attributeTemplate, curAdditionalName, curField, flexFieldObject, exportSettings, objectType, false, curFieldIndex == fieldsToExport.Count - 1 && curAdditionalNameIndex == additionalScriptNames.Length - 1);
}
}
fieldContent += fieldCode;
}
return(fieldContent);
}
/// <summary>
/// Returns true if a flex field is valid for exporting
/// </summary>
/// <param name="field">Field to check</param>
/// <param name="includeScriptExportIgnored">true if fields that should not be exported to script should be included, else false</param>
/// <returns>True if the field is valid</returns>
private static bool IsFlexFieldValidForExport(FlexField field, bool includeScriptExportIgnored)
{
if (!includeScriptExportIgnored && field.ScriptSettings != null && field.ScriptSettings.DontExportToScript)
{
return(false);
}
return(field.FieldType == ExportConstants.FlexFieldType_String || field.FieldType == ExportConstants.FlexFieldType_Number || field.FieldType == ExportConstants.FlexFieldType_Option);
}
/// <summary>
/// Returns the escaped field value
/// </summary>
/// <param name="field">Field</param>
/// <param name="exportSettings">Export settings</param>
/// <returns>Escaped Field Value</returns>
private string EscapedFieldValue(FlexField field, ExportSettings exportSettings)
{
if (field.FieldType == ExportConstants.FlexFieldType_Number)
{
return(field.Value);
}
return(ExportUtil.EscapeCharacters(field.Value, exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter));
}
/// <summary>
/// Finds a flex field
/// </summary>
/// <param name="flexFieldObject">Flex field object to search</param>
/// <param name="fieldName">Name of the field</param>
/// <returns>Found field, null if field does not exist</returns>
private FlexField FindFlexField(IFlexFieldExportable flexFieldObject, string fieldName)
{
fieldName = fieldName.ToLowerInvariant();
FlexField field = flexFieldObject.Fields.FirstOrDefault(f => f.Name.ToLowerInvariant() == fieldName ||
(f.ScriptSettings != null && !string.IsNullOrEmpty(f.ScriptSettings.AdditionalScriptNames) &&
f.ScriptSettings.AdditionalScriptNames.Split(ExportConstants.FlexFieldAdditionalScriptNamesSeperator).Any(name => name.ToLowerInvariant() == fieldName)));
return(field);
}
/// <summary>
/// Builds an action from parsed data
/// </summary>
/// <param name="parsedData">Parsed data</param>
/// <param name="data">Dialog data</param>
/// <param name="project">Project</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="npc">Npc to which the dialog belongs</param>
/// <param name="exportSettings">Export Settings</param>
/// <returns>Action string</returns>
public override async Task <string> BuildActionFromParsedData(ValueActionRenderBase.ValueFieldActionData parsedData, ExportDialogData data, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, KortistoNpc npc, ExportSettings exportSettings)
{
ExportTemplate actionTemplate = await GetExportTemplate(project);
IFlexFieldExportable valueObject = await GetValueObject(parsedData, npc, errorCollection);
if (valueObject == null)
{
return(string.Empty);
}
FlexField exportField = DialogFlexFieldUtil.GetFlexField(valueObject, parsedData.FieldId);
if (exportField == null)
{
errorCollection.AddErrorFlexField(parsedData.FieldName, valueObject.Name);
return(string.Empty);
}
string actionCode = actionTemplate.Code;
actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_ValueName).Replace(actionCode, m => {
return(DialogFlexFieldUtil.GetFieldName(exportField, parsedData.FieldName, errorCollection));
});
actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Operator).Replace(actionCode, GetOperatorFromTemplate(project, parsedData.Operator, errorCollection));
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_OperatorIsSetTo_Start, Placeholder_OperatorIsSetTo_End, parsedData.Operator == "=");
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_OperatorIsNotSetTo_Start, Placeholder_OperatorIsNotSetTo_End, parsedData.Operator != "=");
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_ValueIsString_Start, Placeholder_ValueIsString_End, exportField.FieldType != ExportConstants.FlexFieldType_Number);
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_ValueIsNumber_Start, Placeholder_ValueIsNumber_End, exportField.FieldType == ExportConstants.FlexFieldType_Number);
actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_ValueChange).Replace(actionCode, m => {
if (exportField.FieldType != ExportConstants.FlexFieldType_Number)
{
return(ExportUtil.EscapeCharacters(parsedData.ValueChange, exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter));
}
return(parsedData.ValueChange);
});
ExportObjectData flexFieldExportData = new ExportObjectData();
flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObject, valueObject);
flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObjectType, GetFlexFieldExportObjectType());
_flexFieldPlaceholderResolver.SetErrorMessageCollection(errorCollection);
actionCode = _flexFieldPlaceholderResolver.FillPlaceholders(actionCode, flexFieldExportData).Result;
return(actionCode);
}
/// <summary>
/// Builds a condition element from parsed data
/// </summary>
/// <param name="parsedData">Parsed data</param>
/// <param name="project">Project</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="npc">Npc to which the dialog belongs</param>
/// <param name="exportSettings">Export Settings</param>
/// <returns>Condition string</returns>
public override string BuildConditionElementFromParsedData(ValueConditionResolverBase.ValueFieldConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, KortistoNpc npc, ExportSettings exportSettings)
{
ExportTemplate conditionTemplate = GetExportTemplate(project);
IFlexFieldExportable valueObject = GetValueObject(parsedData, npc, errorCollection);
if (valueObject == null)
{
return(string.Empty);
}
FlexField exportField = DialogFlexFieldUtil.GetFlexField(valueObject, parsedData.FieldId);
if (exportField == null)
{
errorCollection.AddErrorFlexField(parsedData.FieldName, valueObject.Name);
return(string.Empty);
}
string conditionCode = conditionTemplate.Code;
conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_IsOperatorPrimitiveStart, Placeholder_IsOperatorPrimitiveEnd, IsOperatorPrimitiveOperator(parsedData.Operator));
conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_IsOperatorNonPrimitiveStart, Placeholder_IsOperatorNonPrimitiveEnd, !IsOperatorPrimitiveOperator(parsedData.Operator));
conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_ValueName).Replace(conditionCode, m => {
return(DialogFlexFieldUtil.GetFieldName(exportField, parsedData.FieldName, errorCollection));
});
conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Operator).Replace(conditionCode, GetOperatorFromTemplate(project, parsedData.Operator, errorCollection));
conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_ValueIsString_Start, Placeholder_ValueIsString_End, exportField.FieldType != ExportConstants.FlexFieldType_Number);
conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_ValueIsNumber_Start, Placeholder_ValueIsNumber_End, exportField.FieldType == ExportConstants.FlexFieldType_Number);
conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_CompareValue).Replace(conditionCode, m => {
if (exportField.FieldType != ExportConstants.FlexFieldType_Number)
{
return(ExportUtil.EscapeCharacters(parsedData.CompareValue, exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter));
}
return(parsedData.CompareValue);
});
ExportObjectData flexFieldExportData = new ExportObjectData();
flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObject, valueObject);
flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObjectType, GetFlexFieldExportObjectType());
_flexFieldPlaceholderResolver.SetErrorMessageCollection(errorCollection);
conditionCode = _flexFieldPlaceholderResolver.FillPlaceholders(conditionCode, flexFieldExportData).Result;
return(conditionCode);
}
/// <summary>
/// Returns the field name
/// </summary>
/// <param name="exportField">Field to export</param>
/// <param name="searchedFieldName">Searched field name</param>
/// <param name="errorCollection">Error Collection</param>
/// <returns>Field Name</returns>
public static string GetFieldName(FlexField exportField, string searchedFieldName, ExportPlaceholderErrorCollection errorCollection)
{
if (exportField.Name == searchedFieldName)
{
return(exportField.Name);
}
if (string.IsNullOrEmpty(exportField.ScriptSettings.AdditionalScriptNames))
{
string[] additionalFieldNames = exportField.ScriptSettings.AdditionalScriptNames.Split(ExportConstants.FlexFieldAdditionalScriptNamesSeperator, StringSplitOptions.RemoveEmptyEntries);
if (additionalFieldNames.Any(f => f.ToLowerInvariant() == searchedFieldName.ToLowerInvariant()))
{
return(searchedFieldName);
}
}
errorCollection.AddDialogFlexFieldErrorNotFoundDefaultWillBeUsed(searchedFieldName, exportField.Name);
return(exportField.Name);
}
/// <summary>
/// Distributes the fields of a template
/// </summary>
/// <param name="id">Template Id</param>
/// <returns>Task</returns>
protected async Task <IActionResult> BaseDistributeFlexFieldTemplateFields(string id)
{
T template = await _templateDbAccess.GetFlexFieldObjectById(id);
if (template == null)
{
return(StatusCode((int)HttpStatusCode.BadRequest));
}
List <T> flexFieldObjects = await _objectDbAccess.GetFlexFieldObjectsByTemplate(id);
foreach (T curObject in flexFieldObjects)
{
// Update Additional Configuration
foreach (FlexField curField in curObject.Fields)
{
FlexField templateField = template.Fields.FirstOrDefault(f => f.Name == curField.Name);
if (templateField != null && templateField.AdditionalConfiguration != curField.AdditionalConfiguration)
{
curField.AdditionalConfiguration = templateField.AdditionalConfiguration;
}
}
// Add new Fields
List <FlexField> newFields = template.Fields.Where(f => !curObject.Fields.Any(nf => nf.Name == f.Name)).ToList();
newFields.ForEach(f => f.CreatedFromTemplate = true);
if (newFields.Count > 0)
{
curObject.IsImplemented = false;
}
curObject.Fields.AddRange(newFields);
FlexFieldApiUtil.SetFieldIdsForNewFields(curObject.Fields);
FlexFieldApiUtil.SetFieldIdsForNewFieldsInFolders(curObject.Fields, template);
await _objectDbAccess.UpdateFlexFieldObject(curObject);
}
await _timelineService.AddTimelineEntry(TemplateFieldsDistributedEvent, template.Name, template.Id);
return(Ok(id));
}
/// <summary>
/// Builds a preview text from parsed data
/// </summary>
/// <param name="parsedData">Parsed data</param>
/// <param name="npc">Npc to which the dialog belongs</param>
/// <param name="errorCollection">Error Collection</param>
/// <returns>Preview text</returns>
public override async Task <string> BuildPreviewTextFromParsedData(ValueActionRenderBase.ValueFieldActionData parsedData, KortistoNpc npc, ExportPlaceholderErrorCollection errorCollection)
{
IFlexFieldExportable valueObject = await GetValueObject(parsedData, npc, errorCollection);
if (valueObject == null)
{
return(string.Empty);
}
FlexField exportField = DialogFlexFieldUtil.GetFlexField(valueObject, parsedData.FieldId);
if (exportField == null)
{
errorCollection.AddErrorFlexField(parsedData.FieldName, valueObject.Name);
return(string.Empty);
}
string fieldName = DialogFlexFieldUtil.GetFieldName(exportField, parsedData.FieldName, errorCollection);
return(GetPreviewPrefix() + " (" + fieldName + ")");
}
/// <summary>
/// Fills the placeholders
/// </summary>
/// <param name="template">Template to use</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="parsedData">Parsed config data</param>
/// <param name="valueObject">Value object to use</param>
/// <param name="actionOperator">Action operator to use</param>
/// <param name="flexFieldObject">Flex field object to which the dialog belongs</param>
/// <param name="curStep">Current step that is rendered</param>
/// <param name="nextStep">Next step that is being rendered</param>
/// <param name="exportSettings">Export Settings</param>
/// <param name="stepRenderer">Action Step renderer</param>
/// <returns>Filled placeholders</returns>
protected override async Task <string> FillPlaceholders(ExportTemplate template, ExportPlaceholderErrorCollection errorCollection, ValueFieldActionData parsedData, IFlexFieldExportable valueObject, string actionOperator,
FlexFieldObject flexFieldObject, ExportDialogData curStep, ExportDialogData nextStep, ExportSettings exportSettings, IActionStepRenderer stepRenderer)
{
FlexField exportField = DialogFlexFieldUtil.GetFlexField(valueObject, parsedData.FieldId);
if (exportField == null)
{
errorCollection.AddErrorFlexField(parsedData.FieldName, valueObject.Name);
return(string.Empty);
}
string actionCode = template.Code;
actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_ValueName).Replace(actionCode, m => {
return(DialogFlexFieldUtil.GetFieldName(exportField, parsedData.FieldName, errorCollection));
});
actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Operator).Replace(actionCode, actionOperator);
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_OperatorIsSetTo_Start, Placeholder_OperatorIsSetTo_End, parsedData.Operator == "=");
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_OperatorIsNotSetTo_Start, Placeholder_OperatorIsNotSetTo_End, parsedData.Operator != "=");
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_OperatorIsAdd_Start, Placeholder_OperatorIsAdd_End, parsedData.Operator == "+=");
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_OperatorIsNotAdd_Start, Placeholder_OperatorIsNotAdd_End, parsedData.Operator != "+=");
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_OperatorIsSubstract_Start, Placeholder_OperatorIsSubstract_End, parsedData.Operator == "-=");
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_OperatorIsNotSubstract_Start, Placeholder_OperatorIsNotSubstract_End, parsedData.Operator != "-=");
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_OperatorIsMultiply_Start, Placeholder_OperatorIsMultiply_End, parsedData.Operator == "*=");
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_OperatorIsNotMultiply_Start, Placeholder_OperatorIsNotMultiply_End, parsedData.Operator != "*=");
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_OperatorIsDivide_Start, Placeholder_OperatorIsDivide_End, parsedData.Operator == "/=");
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_OperatorIsNotDivide_Start, Placeholder_OperatorIsNotDivide_End, parsedData.Operator != "/=");
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_ValueIsString_Start, Placeholder_ValueIsString_End, exportField.FieldType != ExportConstants.FlexFieldType_Number);
actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_ValueIsNumber_Start, Placeholder_ValueIsNumber_End, exportField.FieldType == ExportConstants.FlexFieldType_Number);
actionCode = ExportUtil.RenderPlaceholderIfFuncTrue(actionCode, Placeholder_ValueNameEquals_Start, Placeholder_ValueNameEquals_End, m => {
string searchedFieldName = m.Groups[1].Value;
searchedFieldName = searchedFieldName.ToLowerInvariant();
string fieldName = string.Empty;
if (!string.IsNullOrEmpty(exportField.Name))
{
fieldName = exportField.Name.ToLowerInvariant();
}
return(fieldName == searchedFieldName);
});
actionCode = ExportUtil.RenderPlaceholderIfFuncTrue(actionCode, Placeholder_ValueNameNotEquals_Start, Placeholder_ValueNameNotEquals_End, m => {
string searchedFieldName = m.Groups[1].Value;
searchedFieldName = searchedFieldName.ToLowerInvariant();
string fieldName = string.Empty;
if (!string.IsNullOrEmpty(exportField.Name))
{
fieldName = exportField.Name.ToLowerInvariant();
}
return(fieldName != searchedFieldName);
});
actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_ValueChange).Replace(actionCode, m => {
if (exportField.FieldType != ExportConstants.FlexFieldType_Number)
{
return(ExportUtil.EscapeCharacters(parsedData.ValueChange, exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter));
}
return(parsedData.ValueChange);
});
ExportObjectData flexFieldExportData = new ExportObjectData();
flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObject, valueObject);
flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObjectType, GetFlexFieldExportObjectType());
_flexFieldPlaceholderResolver.SetErrorMessageCollection(errorCollection);
actionCode = await _flexFieldPlaceholderResolver.FillPlaceholders(actionCode, flexFieldExportData);
return(await stepRenderer.ReplaceBasePlaceholders(errorCollection, actionCode, curStep, nextStep, flexFieldObject));
}
/// <summary>
/// Returns the flex field by id
/// </summary>
/// <param name="valueObject">Value object to export</param>
/// <param name="fieldId">Field Id</param>
/// <returns>Flex Field</returns>
public static FlexField GetFlexField(IFlexFieldExportable valueObject, string fieldId)
{
FlexField field = valueObject.Fields.FirstOrDefault(f => f.Id == fieldId);
return(field);
}
/// <summary>
/// Sets the field ids for new fields in folders
/// </summary>
/// <param name="flexFields">Flex Fields</param>
/// <param name="templateObject">Template object from which fields are distributed at the moment, used to find the names of fields in folders</param>
public static void SetFieldIdsForNewFieldsInFolders(List <FlexField> flexFields, FlexFieldObject templateObject = null)
{
foreach (FlexField curField in flexFields)
{
if (curField.FieldType != FlexFieldTypeFolder || string.IsNullOrEmpty(curField.Value))
{
continue;
}
List <string> fieldIds = null;
try
{
fieldIds = JsonSerializer.Deserialize <List <string> >(curField.Value);
}
catch (Exception)
{
}
if (fieldIds == null)
{
continue;
}
// Fill ids for new fields
bool anyChange = false;
for (int curFieldIdIndex = 0; curFieldIdIndex < fieldIds.Count; ++curFieldIdIndex)
{
string curFieldId = fieldIds[curFieldIdIndex];
Guid tempGuid;
if (Guid.TryParse(curFieldId, out tempGuid))
{
continue;
}
int fieldIndex = -1;
if (!int.TryParse(curFieldId, out fieldIndex))
{
continue;
}
if (templateObject == null)
{
if (fieldIndex < 0 || fieldIndex >= flexFields.Count)
{
continue;
}
fieldIds[curFieldIdIndex] = flexFields[fieldIndex].Id;
}
else
{
if (fieldIndex < 0 || fieldIndex >= templateObject.Fields.Count)
{
continue;
}
string fieldName = templateObject.Fields[fieldIndex].Name;
FlexField targetField = flexFields.FirstOrDefault(f => f.Name == fieldName);
if (targetField == null)
{
continue;
}
fieldIds[curFieldIdIndex] = targetField.Id;
}
anyChange = true;
}
if (anyChange)
{
curField.Value = JsonSerializer.Serialize(fieldIds);
}
}
}
/// <summary>
/// Fills the Flex Field Placeholders
/// </summary>
/// <param name="code">Code to fill</param>
/// <param name="flexFieldObject">Flex Field Object</param>
/// <param name="objectType">Object Type</param>
/// <param name="data">Export Data</param>
/// <returns>Filled Code</returns>
private async Task <string> FillFlexFieldPlaceholders(string code, IFlexFieldExportable flexFieldObject, string objectType, ExportObjectData data)
{
GoNorthProject project = await _exportCachedDbAccess.GetUserProject();
ExportSettings exportSettings = await _exportCachedDbAccess.GetExportSettings(project.Id);
HashSet <string> usedFields = new HashSet <string>();
code = ExportUtil.BuildPlaceholderRegex(BuildFinalPlaceholder(Placeholder_Name)).Replace(code, flexFieldObject.Name);
code = ExportUtil.RenderPlaceholderIfFuncTrue(code, BuildFinalPlaceholder(Placeholder_Field_Value_Equals_Start), BuildFinalPlaceholder(Placeholder_Field_Value_Equals_End), m => {
string fieldName = m.Groups[1].Value;
FlexField field = FindFlexField(flexFieldObject, fieldName);
if (field == null)
{
return(false);
}
return(m.Groups[2].Value == field.Value);
});
code = ExportUtil.RenderPlaceholderIfFuncTrue(code, BuildFinalPlaceholder(Placeholder_Field_Value_NotEquals_Start), BuildFinalPlaceholder(Placeholder_Field_Value_NotEquals_End), m => {
string fieldName = m.Groups[1].Value;
FlexField field = FindFlexField(flexFieldObject, fieldName);
if (field == null)
{
return(true);
}
return(m.Groups[2].Value != field.Value);
});
code = ExportUtil.RenderPlaceholderIfFuncTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_HasField_Start), BuildFinalPlaceholder(Placeholder_FlexField_HasField_End), m => {
string fieldName = m.Groups[1].Value;
FlexField field = FindFlexField(flexFieldObject, fieldName);
return(field != null);
});
code = ExportUtil.RenderPlaceholderIfFuncTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_NotHasField_Start), BuildFinalPlaceholder(Placeholder_FlexField_NotHasField_End), m => {
string fieldName = m.Groups[1].Value;
FlexField field = FindFlexField(flexFieldObject, fieldName);
return(field == null);
});
code = ExportUtil.RenderPlaceholderIfFuncTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_FieldIsBlank_Start), BuildFinalPlaceholder(Placeholder_FlexField_FieldIsBlank_End), m => {
string fieldName = m.Groups[1].Value;
FlexField field = FindFlexField(flexFieldObject, fieldName);
if (field == null)
{
return(true);
}
return(string.IsNullOrEmpty(field.Value));
});
code = ExportUtil.RenderPlaceholderIfFuncTrue(code, BuildFinalPlaceholder(Placeholder_FlexField_FieldIsNotBlank_Start), BuildFinalPlaceholder(Placeholder_FlexField_FieldIsNotBlank_End), m => {
string fieldName = m.Groups[1].Value;
FlexField field = FindFlexField(flexFieldObject, fieldName);
if (field == null)
{
return(false);
}
return(!string.IsNullOrEmpty(field.Value));
});
code = await ExportUtil.BuildPlaceholderRegex(BuildFinalPlaceholder(Placeholder_Name_LangKey)).ReplaceAsync(code, async m => {
// Run in function to only create language key if required
string key = await _languageKeyGenerator.GetFlexFieldNameKey(flexFieldObject.Id, flexFieldObject.Name, objectType);
return(key);
});
code = ExportUtil.BuildPlaceholderRegex(BuildFinalPlaceholder(Placeholder_Field_Value)).Replace(code, m => {
string fieldName = m.Groups[1].Value;
FlexField field = FindFlexField(flexFieldObject, fieldName);
if (field != null)
{
usedFields.Add(field.Id);
return(EscapedFieldValue(field, exportSettings));
}
_errorCollection.AddErrorFlexField(fieldName, flexFieldObject.Name);
return("<<" + flexFieldObject.Name + "[" + fieldName + "] MISSING>>");
});
code = ExportUtil.BuildPlaceholderRegex(BuildFinalPlaceholder(Placeholder_Field_LangKey)).Replace(code, m => {
string fieldName = m.Groups[1].Value;
FlexField field = FindFlexField(flexFieldObject, fieldName);
if (field != null && (field.FieldType == ExportConstants.FlexFieldType_String || field.FieldType == ExportConstants.FlexFieldType_Option))
{
usedFields.Add(field.Id);
return(BuildFlexFieldLangKey(flexFieldObject, field, objectType));
}
_errorCollection.AddErrorFlexField(fieldName, flexFieldObject.Name);
return("<<" + flexFieldObject.Name + "[" + fieldName + "] MISSING>>");
});
code = ExportUtil.RenderPlaceholderIfFuncTrue(code, BuildFinalPlaceholder(Placeholder_HasUnusedFields_Start), BuildFinalPlaceholder(Placeholder_HasUnusedFields_End), m => {
return(flexFieldObject.Fields.Where(f => !usedFields.Contains(f.Id)).Any());
});
code = ExportUtil.BuildRangePlaceholderRegex(BuildFinalPlaceholder(Placeholder_UnusedFields_Start), BuildFinalPlaceholder(Placeholder_UnusedFields_End)).Replace(code, m => {
List <FlexField> fieldsToUse = flexFieldObject.Fields.Where(f => !usedFields.Contains(f.Id)).ToList();
return(BuildFlexFieldList(m.Groups[1].Value, fieldsToUse, flexFieldObject, exportSettings, objectType));
});
code = ExportUtil.BuildRangePlaceholderRegex(BuildFinalPlaceholder(Placeholder_AllFields_Start), BuildFinalPlaceholder(Placeholder_AllFields_End)).Replace(code, m => {
return(BuildFlexFieldList(m.Groups[1].Value, flexFieldObject.Fields, flexFieldObject, exportSettings, objectType));
});
code = ExportUtil.BuildRangePlaceholderRegex(Placeholder_FlexFieldList_Start, Placeholder_FlexFieldList_End).Replace(code, m => {
return(BuildFlexFieldList(m.Groups[1].Value, flexFieldObject.Fields, flexFieldObject, exportSettings, objectType));
});
code = await ExportUtil.BuildPlaceholderRegex(BuildFinalPlaceholder(Placeholder_UnusedFields), ExportConstants.ListIndentPrefix).ReplaceAsync(code, async m => {
return(await RenderAttributeList(project, FilterInvalidFlexFields(flexFieldObject.Fields.Where(f => !usedFields.Contains(f.Id)).ToList()), data, m.Groups[1].Value));
});
code = await ExportUtil.BuildPlaceholderRegex(BuildFinalPlaceholder(Placeholder_AllFields), ExportConstants.ListIndentPrefix).ReplaceAsync(code, async m => {
return(await RenderAttributeList(project, FilterInvalidFlexFields(flexFieldObject.Fields), data, m.Groups[1].Value));
});
return(code);
}
/// <summary>
/// Builds the flex field language key
/// </summary>
/// <param name="flexFieldObject">Flex Field Object</param>
/// <param name="field">Field</param>
/// <param name="objectType">Objcet type</param>
/// <returns>Language Key</returns>
private string BuildFlexFieldLangKey(IFlexFieldExportable flexFieldObject, FlexField field, string objectType)
{
return(_languageKeyGenerator.GetFlexFieldFieldKey(flexFieldObject.Id, flexFieldObject.Name, objectType, field.Id, field.Name, field.Value).Result);
}
/// <summary>
/// Converts a flexfield to an export field
/// </summary>
/// <param name="parentObject">Parent object</param>
/// <param name="field">Field to export</param>
/// <param name="exportSettings">Export settings</param>
/// <returns>Converted fields</returns>
private static IEnumerable <ScribanFlexFieldField> ConvertFieldToExportField(ScribanFlexFieldObject parentObject, FlexField field, ExportSettings exportSettings)
{
if (field.ScriptSettings != null && !string.IsNullOrEmpty(field.ScriptSettings.AdditionalScriptNames))
{
string[] additionalScriptNames = field.ScriptSettings.AdditionalScriptNames.Split(ExportConstants.FlexFieldAdditionalScriptNamesSeperator, StringSplitOptions.RemoveEmptyEntries);
foreach (string curAddtionalName in additionalScriptNames)
{
yield return(ConvertFieldWithName(parentObject, field, curAddtionalName, exportSettings));
}
}
yield return(ConvertFieldWithName(parentObject, field, field.Name, exportSettings));
}
/// <summary>
/// Converts a single field to an export field with a given anme
/// </summary>
/// <param name="parentObject">Parent object</param>
/// <param name="field">Field to convert</param>
/// <param name="fieldName">Field name to use</param>
/// <param name="exportSettings">Export settings</param>
/// <returns>Converted field</returns>
private static ScribanFlexFieldField ConvertFieldWithName(ScribanFlexFieldObject parentObject, FlexField field, string fieldName, ExportSettings exportSettings)
{
ScribanFlexFieldField convertedField = new ScribanFlexFieldField(parentObject);
convertedField.Id = field.Id;
convertedField.Name = fieldName;
convertedField.Type = ConvertFieldTypeToScribanFieldType(field.FieldType);
convertedField.UnescapedValue = ConvertFieldValue(field.FieldType, field.Value);
convertedField.Value = convertedField.UnescapedValue;
if (convertedField.Value is string)
{
convertedField.Value = ExportUtil.EscapeCharacters(convertedField.Value.ToString(), exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter);
}
convertedField.DontExportToScript = field.ScriptSettings != null && field.ScriptSettings.DontExportToScript ? true : false;
convertedField.Exists = true;
return(convertedField);
}
/// <summary>
/// Builds a condition element from parsed data
/// </summary>
/// <param name="template">Export template to use</param>
/// <param name="parsedData">Parsed data</param>
/// <param name="project">Project</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="flexFieldObject">Flex field object to which the dialog belongs</param>
/// <param name="exportSettings">Export Settings</param>
/// <returns>Condition string</returns>
public override async Task <string> BuildConditionElementFromParsedData(ExportTemplate template, ValueFieldConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
IFlexFieldExportable valueObject = await GetValueObject(parsedData, flexFieldObject, errorCollection);
if (valueObject == null)
{
return(string.Empty);
}
FlexField exportField = DialogFlexFieldUtil.GetFlexField(valueObject, parsedData.FieldId);
if (exportField == null)
{
errorCollection.AddErrorFlexField(parsedData.FieldName, valueObject.Name);
return(string.Empty);
}
string conditionCode = template.Code;
conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_IsOperatorPrimitiveStart, Placeholder_IsOperatorPrimitiveEnd, ConditionRenderingUtil.IsConditionOperatorPrimitiveOperator(parsedData.Operator));
conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_IsOperatorNonPrimitiveStart, Placeholder_IsOperatorNonPrimitiveEnd, !ConditionRenderingUtil.IsConditionOperatorPrimitiveOperator(parsedData.Operator));
conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_ValueName).Replace(conditionCode, m => {
return(DialogFlexFieldUtil.GetFieldName(exportField, parsedData.FieldName, errorCollection));
});
string operatorCode = await ConditionRenderingUtil.GetCompareOperatorFromTemplate(_defaultTemplateProvider, project, parsedData.Operator, errorCollection);
conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Operator).Replace(conditionCode, operatorCode);
conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_ValueIsString_Start, Placeholder_ValueIsString_End, exportField.FieldType != ExportConstants.FlexFieldType_Number);
conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_ValueIsNumber_Start, Placeholder_ValueIsNumber_End, exportField.FieldType == ExportConstants.FlexFieldType_Number);
conditionCode = ExportUtil.RenderPlaceholderIfFuncTrue(conditionCode, Placeholder_ValueNameEquals_Start, Placeholder_ValueNameEquals_End, m => {
string searchedFieldName = m.Groups[1].Value;
searchedFieldName = searchedFieldName.ToLowerInvariant();
string fieldName = string.Empty;
if (!string.IsNullOrEmpty(exportField.Name))
{
fieldName = exportField.Name.ToLowerInvariant();
}
return(fieldName == searchedFieldName);
});
conditionCode = ExportUtil.RenderPlaceholderIfFuncTrue(conditionCode, Placeholder_ValueNameNotEquals_Start, Placeholder_ValueNameNotEquals_End, m => {
string searchedFieldName = m.Groups[1].Value;
searchedFieldName = searchedFieldName.ToLowerInvariant();
string fieldName = string.Empty;
if (!string.IsNullOrEmpty(exportField.Name))
{
fieldName = exportField.Name.ToLowerInvariant();
}
return(fieldName != searchedFieldName);
});
conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_CompareValue).Replace(conditionCode, m => {
if (exportField.FieldType != ExportConstants.FlexFieldType_Number)
{
return(ExportUtil.EscapeCharacters(parsedData.CompareValue, exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter));
}
return(parsedData.CompareValue);
});
ExportObjectData flexFieldExportData = new ExportObjectData();
flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObject, valueObject);
flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObjectType, GetFlexFieldExportObjectType());
_flexFieldPlaceholderResolver.SetErrorMessageCollection(errorCollection);
conditionCode = await _flexFieldPlaceholderResolver.FillPlaceholders(conditionCode, flexFieldExportData);
return(conditionCode);
}
