/// <summary>
/// Renders an daily routine event list
/// </summary>
/// <param name="context">Template context</param>
/// <param name="callerContext">Caller context</param>
/// <param name="arguments">Arguments to render the list with</param>
/// <returns>Rendered daily routine event list</returns>
private async ValueTask <object> RenderDailyRoutineEventList(TemplateContext context, ScriptNode callerContext, ScriptArray arguments)
{
List <ScribanExportDailyRoutineEvent> eventList = ScribanParsingUtil.GetArrayFromScribanArgument <ScribanExportDailyRoutineEvent>(arguments, 0);
if (eventList == null)
{
_errorCollection.AddInvalidParameter(ScribanErrorUtil.FormatScribanSpan(callerContext.Span));
return("<<DID NOT PROVIDE VALID EVENT LIST>>");
}
GoNorthProject curProject = await _exportCachedDbAccess.GetUserProject();
ExportTemplate eventListTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(curProject.Id, TemplateType.ObjectDailyRoutineEventList);
ExportObjectData objectData = _exportObjectData.Clone();
if (objectData.ExportData.ContainsKey(ExportConstants.ExportDataObject) && objectData.ExportData[ExportConstants.ExportDataObject] is KortistoNpc)
{
((KortistoNpc)objectData.ExportData[ExportConstants.ExportDataObject]).DailyRoutine = eventList.Select(e => e.OriginalEvent).ToList();
}
ExportPlaceholderFillResult fillResult = await _templatePlaceholderResolver.FillPlaceholders(TemplateType.ObjectDailyRoutineEventList, eventListTemplate.Code, objectData, eventListTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(ScribanOutputUtil.IndentMultilineCode(context, fillResult.Code));
}
/// <summary>
/// Fills the placeholders of a code
/// </summary>
/// <param name="templateType">Template Type</param>
/// <param name="code">Code to fill</param>
/// <param name="data">Export Data</param>
/// <returns>Filled Code</returns>
public async Task <ExportPlaceholderFillResult> FillPlaceholders(TemplateType templateType, string code, ExportObjectData data)
{
ExportPlaceholderErrorCollection errorCollection = new ExportPlaceholderErrorCollection(_localizerFactory);
Template parsedTemplate = ScribanParsingUtil.ParseTemplate(code, errorCollection);
if (parsedTemplate != null)
{
ScriptObject exportObject = await BuildScriptObject(templateType, parsedTemplate, data, errorCollection);
TemplateContext context = BuildTemplateContext(exportObject, errorCollection);
try
{
code = await parsedTemplate.RenderAsync(context);
}
catch (Exception ex)
{
errorCollection.AddException(ex);
}
}
ExportPlaceholderFillResult result = new ExportPlaceholderFillResult();
result.Code = code;
result.Errors = errorCollection;
return(result);
}
/// <summary>
/// Renders an skill List
/// </summary>
/// <param name="context">Template context</param>
/// <param name="callerContext">Caller context</param>
/// <param name="arguments">Arguments to render the list with</param>
/// <returns>Rendered skill list</returns>
private async ValueTask <object> RenderSkillList(TemplateContext context, ScriptNode callerContext, ScriptArray arguments)
{
if (!_exportObjectData.ExportData.ContainsKey(ExportConstants.ExportDataObject) || !(_exportObjectData.ExportData[ExportConstants.ExportDataObject] is KortistoNpc))
{
_errorCollection.AddInvalidParameter(ScribanErrorUtil.FormatScribanSpan(callerContext.Span));
return("<<NO VALID NPC CONTEXT>>");
}
List <ScribanExportSkill> skillList = ScribanParsingUtil.GetArrayFromScribanArgument <ScribanExportSkill>(arguments, 0);
if (skillList == null)
{
_errorCollection.AddInvalidParameter(ScribanErrorUtil.FormatScribanSpan(callerContext.Span));
return("<<DID NOT PROVIDE VALID SKILL LIST>>");
}
GoNorthProject curProject = await _exportCachedDbAccess.GetUserProject();
ExportTemplate skillListTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(curProject.Id, TemplateType.ObjectSkillList);
ExportObjectData objectData = _exportObjectData.Clone();
((KortistoNpc)objectData.ExportData[ExportConstants.ExportDataObject]).Skills = ConvertSkillsToKortistoNpcSkill(skillList);
ExportPlaceholderFillResult fillResult = await _templatePlaceholderResolver.FillPlaceholders(TemplateType.ObjectSkillList, skillListTemplate.Code, objectData, skillListTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(ScribanOutputUtil.IndentMultilineCode(context, fillResult.Code));
}
/// <summary>
/// Renders an attribute List
/// </summary>
/// <param name="context">Template context</param>
/// <param name="callerContext">Caller context</param>
/// <param name="arguments">Arguments to render the list with</param>
/// <returns>Rendered attribute list</returns>
private async ValueTask <object> RenderAttributeList(TemplateContext context, ScriptNode callerContext, ScriptArray arguments)
{
List <ScribanFlexFieldField> fieldList = ScribanParsingUtil.GetArrayFromScribanArgument <ScribanFlexFieldField>(arguments, 0);
if (fieldList == null)
{
_errorCollection.AddInvalidParameter(ScribanErrorUtil.FormatScribanSpan(callerContext.Span));
return("<<DID NOT PROVIDE VALID ATTRIBUTE LIST>>");
}
GoNorthProject curProject = await _exportCachedDbAccess.GetUserProject();
ExportTemplate attributeListTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(curProject.Id, TemplateType.ObjectAttributeList);
ExportObjectData objectData = _exportObjectData.Clone();
if (objectData.ExportData.ContainsKey(ExportConstants.ExportDataObject) && objectData.ExportData[ExportConstants.ExportDataObject] is IFlexFieldExportable)
{
((IFlexFieldExportable)objectData.ExportData[ExportConstants.ExportDataObject]).Fields = ConvertListToFlexFieldList(fieldList);
}
ExportPlaceholderFillResult fillResult = await _templatePlaceholderResolver.FillPlaceholders(TemplateType.ObjectAttributeList, attributeListTemplate.Code, objectData, attributeListTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(ScribanOutputUtil.IndentMultilineCode(context, fillResult.Code));
}
/// <summary>
/// Replaces the event list
/// </summary>
/// <param name="project">Current project</param>
/// <param name="data">Export data</param>
/// <returns>Rendered event list</returns>
private async Task <string> ReplaceEventList(GoNorthProject project, ExportObjectData data)
{
ExportTemplate dailyRoutineEventTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectDailyRoutineEventList);
ExportPlaceholderFillResult fillResult = await _placeholderResolver.FillPlaceholders(TemplateType.ObjectDailyRoutineEventList, dailyRoutineEventTemplate.Code, data, dailyRoutineEventTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(fillResult.Code);
}
/// <summary>
/// Renders an export snippet function
/// </summary>
/// <param name="functionTemplate">Function template</param>
/// <param name="function"></param>
/// <returns></returns>
private async Task <string> RenderExportSnippetFunction(ExportTemplate functionTemplate, ExportSnippetFunction function)
{
ExportObjectData objectData = new ExportObjectData();
objectData.ExportData.Add(ExportConstants.ExportDataObject, function);
ExportPlaceholderFillResult fillResult = await _templatePlaceholderResolver.FillPlaceholders(TemplateType.ObjectExportSnippetFunction, functionTemplate.Code, objectData, functionTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(fillResult.Code);
}
/// <summary>
/// Replaces the event function
/// </summary>
/// <param name="code">Function code</param>
/// <param name="function">Function to render</param>
/// <param name="errorCollection">Error collection</param>
/// <returns>Rendered event function</returns>
public async Task <string> ReplaceEventFunction(string code, DailyRoutineFunction function, ExportPlaceholderErrorCollection errorCollection)
{
ExportObjectData objectData = new ExportObjectData();
objectData.ExportData.Add(ExportConstants.ExportDataObject, function);
ExportPlaceholderFillResult fillResult = await _templatePlaceholderResolver.FillPlaceholders(TemplateType.ObjectDailyRoutineFunction, code, objectData, ExportTemplateRenderingEngine.Scriban);
errorCollection.Merge(fillResult.Errors);
return(fillResult.Code);
}
/// <summary>
/// Renders the inventory based on the shared template
/// </summary>
/// <param name="data">Export Data</param>
/// <param name="indent">Indentation</param>
/// <returns>Item List</returns>
private async Task <string> RenderInventory(ExportObjectData data, string indent)
{
GoNorthProject project = await _cachedDbAccess.GetUserProject();
ExportTemplate inventoryTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectInventory);
ExportPlaceholderFillResult fillResult = await _placeholderResolver.FillPlaceholders(TemplateType.ObjectInventory, inventoryTemplate.Code, data, inventoryTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(ExportUtil.IndentListTemplate(fillResult.Code, indent));
}
/// <summary>
/// Renders a function for a list
/// </summary>
/// <param name="project">Current Project</param>
/// <param name="functionCode">Function code to use</param>
/// <returns>Function</returns>
public async Task <string> RenderFunctionForList(GoNorthProject project, ExportDialogFunctionCode functionCode)
{
ExportTemplate functionTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.TaleDialogFunction);
ExportObjectData objectData = new ExportObjectData();
objectData.ExportData.Add(ExportConstants.ExportDataObject, functionCode);
ExportPlaceholderFillResult fillResult = await _templatePlaceholderResolver.FillPlaceholders(TemplateType.TaleDialogFunction, functionTemplate.Code, objectData, functionTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(fillResult.Code);
}
/// <summary>
/// Renders an attribute list
/// </summary>
/// <param name="project">Current project</param>
/// <param name="fields">Fields to render</param>
/// <param name="data">Export data</param>
/// <param name="indent">Indentation</param>
/// <returns>Rendered attribute list</returns>
private async Task <string> RenderAttributeList(GoNorthProject project, List <FlexField> fields, ExportObjectData data, string indent)
{
ExportTemplate attributeListTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectAttributeList);
ExportObjectData objectData = data.Clone();
if (objectData.ExportData.ContainsKey(ExportConstants.ExportDataObject) && objectData.ExportData[ExportConstants.ExportDataObject] is IFlexFieldExportable)
{
((IFlexFieldExportable)objectData.ExportData[ExportConstants.ExportDataObject]).Fields = fields;
}
ExportPlaceholderFillResult fillResult = await _placeholderResolver.FillPlaceholders(TemplateType.ObjectAttributeList, attributeListTemplate.Code, objectData, attributeListTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(ExportUtil.IndentListTemplate(fillResult.Code, indent));
}
/// <summary>
/// Exports an object
/// </summary>
/// <param name="template">Template to use</param>
/// <param name="objectData">Object data</param>
/// <returns>Export Result</returns>
public async Task <ExportObjectResult> ExportObject(ExportTemplate template, ExportObjectData objectData)
{
GoNorthProject project = await _projectDbAccess.GetDefaultProject();
ExportSettings exportSettings = await _exportSettingsDbAccess.GetExportSettings(project.Id);
ExportObjectResult result = new ExportObjectResult();
result.FileExtension = exportSettings.ScriptExtension;
ExportPlaceholderFillResult filledResult = await _placeholderResolver.FillPlaceholders(template.TemplateType, template.Code, objectData);
result.Code = filledResult.Code;
result.Errors = filledResult.Errors.ToErrorList();
return(result);
}
/// <summary>
/// Fills the placeholders of a code
/// </summary>
/// <param name="templateType">Template Type</param>
/// <param name="code">Code to fill</param>
/// <param name="data">Export Data</param>
/// <returns>Filled Code</returns>
public async Task <ExportPlaceholderFillResult> FillPlaceholders(TemplateType templateType, string code, ExportObjectData data)
{
ExportPlaceholderErrorCollection errorCollection = new ExportPlaceholderErrorCollection(_localizerFactory);
foreach (IExportTemplateTopicPlaceholderResolver curResolver in _exportTemplatePlaceholderResolvers)
{
if (curResolver.IsValidForTemplateType(templateType))
{
curResolver.SetErrorMessageCollection(errorCollection);
code = await curResolver.FillPlaceholders(code, data);
}
}
ExportPlaceholderFillResult result = new ExportPlaceholderFillResult();
result.Code = code;
result.Errors = errorCollection;
return(result);
}
/// <summary>
/// Exports an object
/// </summary>
/// <param name="template">Template to use</param>
/// <param name="objectData">Object data</param>
/// <returns>Export Result</returns>
public async Task <ExportObjectResult> ExportObject(ExportTemplate template, ExportObjectData objectData)
{
// Run script export to refresh language keys
IFlexFieldExportable flexFieldObject = null;
if (objectData.ExportData.ContainsKey(ExportConstants.ExportDataObject))
{
flexFieldObject = objectData.ExportData[ExportConstants.ExportDataObject] as IFlexFieldExportable;
}
if (flexFieldObject != null)
{
_languageKeyReferenceCollector.PrepareCollectionForGroup(flexFieldObject.Id);
}
else
{
_languageKeyReferenceCollector.PrepareCollectionForGroup(null);
}
await _scriptExporter.ExportObject(template, objectData);
objectData.ExportData[ExportConstants.ExportDataReferencedLanguageIds] = _languageKeyReferenceCollector.GetReferencedLanguageKeys();
// Export language keys
GoNorthProject project = await _userProjectAccess.GetUserProject();
ExportSettings exportSettings = await _exportSettingsDbAccess.GetExportSettings(project.Id);
ExportTemplate exportTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.LanguageFile);
ExportObjectResult result = new ExportObjectResult();
result.FileExtension = exportSettings.LanguageFileExtension;
ExportPlaceholderFillResult filledResult = await _placeholderResolver.FillPlaceholders(TemplateType.LanguageFile, exportTemplate.Code, objectData, exportTemplate.RenderingEngine);
result.Code = filledResult.Code;
result.Errors = filledResult.Errors.ToErrorList();
return(result);
}
/// <summary>
/// Renders an state machine function
/// </summary>
/// <param name="context">Template context</param>
/// <param name="callerContext">Caller context</param>
/// <param name="arguments">Arguments to render the function with</param>
/// <returns>Rendered state machine function</returns>
private async ValueTask <object> RenderStateMachineFunction(TemplateContext context, ScriptNode callerContext, ScriptArray arguments)
{
if (arguments.Count != 1 || !(arguments[0] is ScribanExportStateFunction))
{
_errorCollection.AddInvalidParameter(ScribanErrorUtil.FormatScribanSpan(callerContext.Span));
return("<<DID NOT PROVIDE VALID STATE MACHINE FUNCTION>>");
}
ScribanExportStateFunction exportFunction = (ScribanExportStateFunction)arguments[0];
GoNorthProject curProject = await _exportCachedDbAccess.GetUserProject();
ExportTemplate eventFunctionTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(curProject.Id, TemplateType.ObjectStateFunction);
ExportObjectData objectData = new ExportObjectData();
objectData.ExportData.Add(ExportConstants.ExportDataObject, exportFunction.ToStateFunction());
ExportPlaceholderFillResult fillResult = await _templatePlaceholderResolver.FillPlaceholders(TemplateType.ObjectStateFunction, eventFunctionTemplate.Code, objectData, eventFunctionTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(ScribanOutputUtil.IndentMultilineCode(context, fillResult.Code));
}
/// <summary>
/// Replaces the function list
/// </summary>
/// <param name="project">Current project</param>
/// <param name="npc">Npc for which the daily routine functions must be rendered</param>
/// <returns>Rendered function list</returns>
private async Task <string> ReplaceFunctionList(GoNorthProject project, KortistoNpc npc)
{
ExportTemplate dailyRoutineFunctionListTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectDailyRoutineFunctionList);
if (dailyRoutineFunctionListTemplate.RenderingEngine == ExportTemplateRenderingEngine.Scriban)
{
_dailyRoutineFunctionRenderer.SetErrorCollection(_errorCollection);
List <DailyRoutineFunction> functions = await _dailyRoutineFunctionRenderer.RenderDailyRoutineFunctions(npc.DailyRoutine, npc);
ExportObjectData objectData = new ExportObjectData();
objectData.ExportData.Add(ExportConstants.ExportDataObject, functions);
ExportPlaceholderFillResult fillResult = await _placeholderResolver.FillPlaceholders(TemplateType.ObjectDailyRoutineFunctionList, dailyRoutineFunctionListTemplate.Code, objectData, dailyRoutineFunctionListTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(fillResult.Code);
}
else
{
return(dailyRoutineFunctionListTemplate.Code);
}
}
/// <summary>
/// Exports an object
/// </summary>
/// <param name="template">Template to use</param>
/// <param name="objectData">Object data</param>
/// <returns>Export Result</returns>
public async Task <ExportObjectResult> ExportObject(ExportTemplate template, ExportObjectData objectData)
{
// Run script export to refresh language keys
await _scriptExporter.ExportObject(template, objectData);
// Export language keys
GoNorthProject project = await _projectDbAccess.GetDefaultProject();
ExportSettings exportSettings = await _exportSettingsDbAccess.GetExportSettings(project.Id);
ExportTemplate exportTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.LanguageFile);
ExportObjectResult result = new ExportObjectResult();
result.FileExtension = exportSettings.LanguageFileExtension;
ExportPlaceholderFillResult filledResult = await _placeholderResolver.FillPlaceholders(TemplateType.LanguageFile, exportTemplate.Code, objectData);
result.Code = filledResult.Code;
result.Errors = filledResult.Errors.ToErrorList();
return(result);
}
/// <summary>
/// Renders an daily routine function list
/// </summary>
/// <param name="context">Template context</param>
/// <param name="callerContext">Caller context</param>
/// <param name="arguments">Arguments to render the list with</param>
/// <returns>Rendered daily routine function list</returns>
private async ValueTask <object> RenderDailyRoutineFunctionList(TemplateContext context, ScriptNode callerContext, ScriptArray arguments)
{
List <ScribanExportDailyRoutineFunction> functionList = ScribanParsingUtil.GetArrayFromScribanArgument <ScribanExportDailyRoutineFunction>(arguments, 0);
if (functionList == null)
{
_errorCollection.AddInvalidParameter(ScribanErrorUtil.FormatScribanSpan(callerContext.Span));
return("<<DID NOT PROVIDE VALID FUNCTION LIST>>");
}
GoNorthProject curProject = await _exportCachedDbAccess.GetUserProject();
ExportTemplate functionListTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(curProject.Id, TemplateType.ObjectDailyRoutineFunctionList);
ExportObjectData objectData = new ExportObjectData();
objectData.ExportData.Add(ExportConstants.ExportDataObject, functionList.Select(f => f.ToDailyRoutineFunction()).ToList());
ExportPlaceholderFillResult fillResult = await _templatePlaceholderResolver.FillPlaceholders(TemplateType.ObjectDailyRoutineFunctionList, functionListTemplate.Code, objectData, functionListTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(ScribanOutputUtil.IndentMultilineCode(context, fillResult.Code));
}
