/// <summary> /// Fills the placeholders of a code /// </summary> /// <param name="code">Code to fill</param> /// <param name="data">Export Data</param> /// <returns>Filled Code</returns> public async Task <string> FillPlaceholders(string code, ExportObjectData data) { // Check Data if (!data.ExportData.ContainsKey(ExportConstants.ExportDataObject)) { return(code); } KortistoNpc npc = data.ExportData[ExportConstants.ExportDataObject] as KortistoNpc; if (npc != null) { // Replace Dialog Placeholders return(await FillDialogPlaceholders(code, npc)); } ExportDialogFunctionCode dialogFunction = data.ExportData[ExportConstants.ExportDataObject] as ExportDialogFunctionCode; if (dialogFunction != null) { // Replace Dialog Function GoNorthProject project = await _cachedDbAccess.GetUserProject(); return(await RenderDialogFunction(project, dialogFunction)); } return(code); }
/// <summary> /// Fills the daily routine placeholders /// </summary> /// <param name="code">Code</param> /// <param name="npc">Npc</param> /// <param name="data">Export Data</param> /// <returns>Filled code</returns> private async Task <string> FillDailyRoutinePlaceholders(string code, KortistoNpc npc, ExportObjectData data) { GoNorthProject project = await _cachedDbAccess.GetUserProject(); ExportTemplate dailyRoutineFunctionTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectDailyRoutineFunction); code = await ExportUtil.BuildPlaceholderRegex(Placeholder_DailyRoutine_Events, ExportConstants.ListIndentPrefix).ReplaceAsync(code, async m => { string eventList = await ReplaceEventList(project, data); return(ExportUtil.IndentListTemplate(eventList, m.Groups[1].Value)); }); code = await ExportUtil.BuildPlaceholderRegex(Placeholder_DailyRoutine_Functions, ExportConstants.ListIndentPrefix).ReplaceAsync(code, async m => { string functionList = await ReplaceFunctionList(project, npc); return(ExportUtil.IndentListTemplate(functionList, m.Groups[1].Value)); }); code = ExportUtil.BuildPlaceholderRegex(Placeholder_DailyRoutine_Function, ExportConstants.ListIndentPrefix).Replace(code, m => { return(ExportUtil.IndentListTemplate(dailyRoutineFunctionTemplate.Code, m.Groups[1].Value)); }); code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_HasDailyRoutine_Start, Placeholder_HasDailyRoutine_End, npc.DailyRoutine != null && npc.DailyRoutine.Count > 0); code = ExportUtil.BuildRangePlaceholderRegex(Placeholder_DailyRoutine_Events_Start, Placeholder_DailyRoutine_Events_End).Replace(code, m => { return(ExportUtil.TrimEmptyLines(BuildEventList(m.Groups[1].Value, project, npc))); }); code = await ExportUtil.BuildRangePlaceholderRegex(Placeholder_DailyRoutine_Functions_Start, Placeholder_DailyRoutine_Functions_End).ReplaceAsync(code, async m => { string functionList = await BuildFunctionList(m.Groups[1].Value, project, npc); return(ExportUtil.TrimEmptyLines(functionList)); }); return(code); }
/// <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> /// Resolved the placeholders for a single daily routine event /// </summary> /// <param name="code">Code to resolve the placeholders in</param> /// <param name="npc">Npc to which the event belongs</param> /// <param name="dailyRoutineEvent">Daily routine to use for resolving the placeholders</param> /// <param name="errorCollection">Error collection</param> /// <returns>Code with resolved placeholders</returns> public async Task <string> ResolveDailyRoutineEventContentPlaceholders(string code, KortistoNpc npc, KortistoNpcDailyRoutineEvent dailyRoutineEvent, ExportPlaceholderErrorCollection errorCollection) { GoNorthProject project = await _cachedDbAccess.GetUserProject(); ExportTemplate dailyRoutineFunctionTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectDailyRoutineFunction); List <DailyRoutineFunction> functions = await this.RenderDailyRoutineFunctions(dailyRoutineEvent, npc, errorCollection); string finalCode = string.Empty; foreach (DailyRoutineFunction curFunction in functions) { if (!string.IsNullOrEmpty(finalCode)) { finalCode += Environment.NewLine; } string functionCode = code; if (dailyRoutineFunctionTemplate.RenderingEngine == ExportTemplateRenderingEngine.Scriban) { functionCode = await ReplaceEventFunction(functionCode, curFunction, errorCollection); } functionCode = FillFunctionCode(functionCode, curFunction); finalCode += functionCode; } return(finalCode); }
/// <summary> /// Loads the inventory /// </summary> /// <param name="parsedTemplate">Parsed scriban template</param> /// <param name="inputNpc">Input npc</param> /// <returns>List of items</returns> private async Task<List<ScribanExportInventoryItem>> LoadInventory(Template parsedTemplate, KortistoNpc inputNpc) { if(inputNpc.Inventory == null || !inputNpc.Inventory.Any()) { return new List<ScribanExportInventoryItem>(); } GoNorthProject project = await _exportCachedDbAccess.GetUserProject(); ExportSettings exportSettings = await _exportCachedDbAccess.GetExportSettings(project.Id); List<ScribanExportInventoryItem> inventoryItems = new List<ScribanExportInventoryItem>(); List<StyrItem> items = await _exportCachedDbAccess.GetItemsById(inputNpc.Inventory.Select(i => i.ItemId).ToList()); foreach(KortistoInventoryItem curItem in inputNpc.Inventory) { StyrItem loadedItem = items.FirstOrDefault(i => i.Id == curItem.ItemId); if(loadedItem == null) { continue; } ScribanExportInventoryItem exportItem = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject<ScribanExportInventoryItem>(null, parsedTemplate, loadedItem, exportSettings, _errorCollection); exportItem.Quantity = curItem.Quantity; exportItem.IsEquipped = curItem.IsEquipped; inventoryItems.Add(exportItem); } return inventoryItems; }
/// <summary> /// Returns the npc use /// </summary> /// <param name="flexFieldObject">Flex field object</param> /// <param name="parsedData">Parsed data</param> /// <param name="errorCollection">Error Collection</param> /// <returns>Value Object</returns> private async Task <IFlexFieldExportable> GetNpc(FlexFieldObject flexFieldObject, UseItemActionData parsedData, ExportPlaceholderErrorCollection errorCollection) { if (_isPickNpc) { KortistoNpc npc = await _cachedDbAccess.GetNpcById(parsedData.NpcId); if (npc == null) { errorCollection.AddDialogItemNotFoundError(); return(null); } return(npc); } else if (_isPlayer) { GoNorthProject curProject = await _cachedDbAccess.GetUserProject(); KortistoNpc npc = await _cachedDbAccess.GetPlayerNpc(curProject.Id); if (npc == null) { errorCollection.AddNoPlayerNpcExistsError(); return(null); } return(npc); } return(flexFieldObject); }
/// <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> /// 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> /// Loads a template /// </summary> /// <param name="templateName">Template name</param> /// <param name="callerSpan">Caller span</param> /// <returns>Code of the template</returns> private async Task <string> LoadTemplate(string templateName, SourceSpan callerSpan) { GoNorthProject project = await _cachedDbAccess.GetUserProject(); IncludeExportTemplate includeExportTemplate = await _cachedDbAccess.GetIncludeTemplateByName(project.Id, templateName); if (includeExportTemplate == null) { _errorCollection.AddIncludeTemplateNotFoundError(templateName, ScribanErrorUtil.FormatScribanSpan(callerSpan)); return("<<INCLUDE TEMPLATE NOT FOUND>>"); } return(includeExportTemplate.Code); }
/// <summary> /// Loads the skills /// </summary> /// <param name="parsedTemplate">Parsed scriban template</param> /// <param name="inputNpc">Input npc</param> /// <returns>List of skills</returns> private async Task <List <ScribanExportSkill> > LoadSkills(Template parsedTemplate, KortistoNpc inputNpc) { if (inputNpc.Skills == null || !inputNpc.Skills.Any()) { return(new List <ScribanExportSkill>()); } GoNorthProject project = await _exportCachedDbAccess.GetUserProject(); ExportSettings exportSettings = await _exportCachedDbAccess.GetExportSettings(project.Id); List <EvneSkill> skills = await _exportCachedDbAccess.GetSkillsById(inputNpc.Skills.Select(i => i.SkillId).ToList()); return(skills.Select(s => FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportSkill>(null, parsedTemplate, s, exportSettings, _errorCollection)).ToList()); }
/// <summary> /// Returns the currently valid npc for the action /// </summary> /// <param name="parsedData">Parsed data</param> /// <param name="flexFieldObject">Flex field object</param> /// <returns>Npc</returns> private async Task <KortistoNpc> GetNpc(MoveNpcActionData parsedData, FlexFieldObject flexFieldObject) { if (_isPickedNpc) { return(await _cachedDbAccess.GetNpcById(parsedData.ObjectId)); } if (_isPlayer) { GoNorthProject project = await _cachedDbAccess.GetUserProject(); return(await _cachedDbAccess.GetPlayerNpc(project.Id)); } return(flexFieldObject as KortistoNpc); }
/// <summary> /// Returns the npc to use /// </summary> /// <param name="flexFieldObject">Flex field object to which the dialog belongs</param> /// <param name="errorCollection">Error Collection</param> /// <returns>Value Object</returns> private async Task <IFlexFieldExportable> GetNpc(FlexFieldObject flexFieldObject, ExportPlaceholderErrorCollection errorCollection) { if (_isPlayer) { GoNorthProject curProject = await _cachedDbAccess.GetUserProject(); flexFieldObject = await _cachedDbAccess.GetPlayerNpc(curProject.Id); if (flexFieldObject == null) { errorCollection.AddNoPlayerNpcExistsError(); return(null); } } return(flexFieldObject); }
/// <summary> /// Collects the values for an export /// </summary> /// <param name="templateType">Template type</param> /// <param name="parsedTemplate">Parsed scriban template</param> /// <param name="scriptObject">Scriban script object to fill</param> /// <param name="data">Export Data</param> /// <returns>Task</returns> public override async Task CollectValues(TemplateType templateType, Template parsedTemplate, ScriptObject scriptObject, ExportObjectData data) { IFlexFieldExportable exportable = data.ExportData[ExportConstants.ExportDataObject] as IFlexFieldExportable; if (exportable == null) { return; } _languageKeyGenerator.SetErrorCollection(_errorCollection); GoNorthProject project = await _cachedDbAccess.GetUserProject(); ExportSettings exportSettings = await _cachedDbAccess.GetExportSettings(project.Id); scriptObject.AddOrUpdate(ObjectKey, FlexFieldValueCollectorUtil.ExtractScribanFields(exportable, exportSettings, _errorCollection)); scriptObject.AddOrUpdate(ExportConstants.ScribanLanguageKeyName, _languageKeyGenerator); }
/// <summary> /// Fills the language key Placeholders /// </summary> /// <param name="code">Code to fill</param> /// <param name="flexFieldObject">Flex Field Object</param> /// <param name="referencedLanguageKeys">Referenced language keys</param> /// <returns>Filled Code</returns> private async Task <string> FillLanguageKeyPlaceholders(string code, IFlexFieldExportable flexFieldObject, List <LanguageKey> referencedLanguageKeys) { GoNorthProject project = await _cachedDbAccess.GetUserProject(); List <LanguageKey> languageKeys = await _languageKeyDbAccess.GetLanguageKeysByGroupId(project.Id, flexFieldObject.Id); ExportSettings exportSettings = await _cachedDbAccess.GetExportSettings(project.Id); code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_Has_Referenced_LanguageKeys_Start, Placeholder_Has_Referenced_LanguageKeys_End, referencedLanguageKeys != null && referencedLanguageKeys.Any()); code = ExportUtil.BuildPlaceholderRegex(Placeholder_ObjectName).Replace(code, flexFieldObject.Name); code = ExportUtil.BuildRangePlaceholderRegex(Placeholder_LanguageKeys_Start, Placeholder_LanguageKeys_End).Replace(code, m => { return(BuildLanguageKeyList(m.Groups[1].Value, languageKeys, exportSettings)); }); code = ExportUtil.BuildRangePlaceholderRegex(Placeholder_Referenced_LanguageKeys_Start, Placeholder_Referenced_LanguageKeys_End).Replace(code, m => { return(BuildLanguageKeyList(m.Groups[1].Value, referencedLanguageKeys, exportSettings)); }); return(code); }
/// <summary> /// Collects the values for an export /// </summary> /// <param name="templateType">Template type</param> /// <param name="parsedTemplate">Parsed scriban template</param> /// <param name="scriptObject">Scriban script object to fill</param> /// <param name="data">Export Data</param> /// <returns>Task</returns> public override async Task CollectValues(TemplateType templateType, Template parsedTemplate, ScriptObject scriptObject, ExportObjectData data) { KortistoNpc inputNpc = data.ExportData[ExportConstants.ExportDataObject] as KortistoNpc; if (inputNpc == null) { return; } _languageKeyGenerator.SetErrorCollection(_errorCollection); GoNorthProject project = await _exportCachedDbAccess.GetUserProject(); TaleDialog dialog = await _taleDbAccess.GetDialogByRelatedObjectId(inputNpc.Id); ExportDialogData parsedDialog = await ParseDialog(inputNpc, project, dialog); ScribanExportDialog exportDialog = await BuildExportDialog(parsedDialog, inputNpc); scriptObject.AddOrUpdate(ExportConstants.ScribanDialogKey, exportDialog); scriptObject.AddOrUpdate(DialogFunctionRenderer.DialogFunctionName, new DialogFunctionRenderer(_templatePlaceholderResolver, _exportCachedDbAccess, _defaultTemplateProvider, _errorCollection, data)); }
/// <summary> /// Collects the values for an export /// </summary> /// <param name="templateType">Template type</param> /// <param name="parsedTemplate">Parsed scriban template</param> /// <param name="scriptObject">Scriban script object to fill</param> /// <param name="data">Export Data</param> /// <returns>Task</returns> public override async Task CollectValues(TemplateType templateType, Template parsedTemplate, ScriptObject scriptObject, ExportObjectData data) { InputObject inputObject = data.ExportData[ExportConstants.ExportDataObject] as InputObject; if (inputObject == null) { return; } _languageKeyGenerator.SetErrorCollection(_errorCollection); GoNorthProject project = await _exportCachedDbAccess.GetUserProject(); ExportSettings exportSettings = await _exportCachedDbAccess.GetExportSettings(project.Id); ExportClass exportObject = BuildExportObject(parsedTemplate, inputObject, exportSettings); scriptObject.Add(GetObjectKey(), exportObject); scriptObject.Add(ExportConstants.ScribanLanguageKeyName, _languageKeyGenerator); scriptObject.Add(FlexFieldAttributeListRenderer.AttributeListFunctionName, new FlexFieldAttributeListRenderer(_templatePlaceholderResolver, _exportCachedDbAccess, _defaultTemplateProvider, _errorCollection, data)); AddAdditionalScriptObjectValues(templateType, parsedTemplate, scriptObject, data); }
/// <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> /// Resolves the placeholders for a single daily routine event /// </summary> /// <param name="code">Code to resolve the placeholders in</param> /// <param name="npc">Npc to which the event belongs</param> /// <param name="dailyRoutineEvent">Daily routine to use for resolving the placeholders</param> /// <returns>Code with resolved placeholders</returns> public async Task <string> ResolveDailyRoutineEventPlaceholders(string code, KortistoNpc npc, KortistoNpcDailyRoutineEvent dailyRoutineEvent) { GoNorthProject defaultProject = await _cachedDbAccess.GetUserProject(); MiscProjectConfig projectConfig = await _cachedDbAccess.GetMiscProjectConfig(); code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_HasMovementTargetStart, Placeholder_HasMovementTargetEnd, dailyRoutineEvent.MovementTarget != null && !string.IsNullOrEmpty(dailyRoutineEvent.MovementTarget.Name)); code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_HasNoMovementTargetStart, Placeholder_HasNoMovementTargetEnd, dailyRoutineEvent.MovementTarget == null || string.IsNullOrEmpty(dailyRoutineEvent.MovementTarget.Name)); code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_HasMovementTargetExportNameStart, Placeholder_HasMovementTargetExportNameEnd, dailyRoutineEvent.MovementTarget != null && !string.IsNullOrEmpty(dailyRoutineEvent.MovementTarget.ExportName)); code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_HasNoMovementTargetExportNameStart, Placeholder_HasNoMovementTargetExportNameEnd, dailyRoutineEvent.MovementTarget == null || string.IsNullOrEmpty(dailyRoutineEvent.MovementTarget.ExportName)); code = ResolveDailyRoutineEventHasScript(code, dailyRoutineEvent.ScriptType != ExportConstants.ScriptType_None); code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_HasNodeGraphScriptStart, Placeholder_HasNodeGraphScriptEnd, dailyRoutineEvent.ScriptType == ExportConstants.ScriptType_NodeGraph); code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_HasCodeScriptStart, Placeholder_HasCodeScriptEnd, dailyRoutineEvent.ScriptType == ExportConstants.ScriptType_Code); code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_HasTargetStateStart, Placeholder_HasTargetStateEnd, !string.IsNullOrEmpty(dailyRoutineEvent.TargetState)); code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_HasNoTargetStateStart, Placeholder_HasNoTargetStateEnd, string.IsNullOrEmpty(dailyRoutineEvent.TargetState)); code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_IsEnabledByDefaultStart, Placeholder_IsEnabledByDefaultEnd, dailyRoutineEvent.EnabledByDefault); code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_IsDisabledByDefaultStart, Placeholder_IsDisabledByDefaultEnd, !dailyRoutineEvent.EnabledByDefault); code = ExportUtil.BuildPlaceholderRegex(Placeholder_EventId).Replace(code, dailyRoutineEvent.EventId); code = ExportUtil.BuildPlaceholderRegex(Placeholder_EarliestTime_Hours).Replace(code, dailyRoutineEvent.EarliestTime != null ? dailyRoutineEvent.EarliestTime.Hours.ToString() : string.Empty); code = ExportUtil.BuildPlaceholderRegex(Placeholder_EarliestTime_Minutes).Replace(code, dailyRoutineEvent.EarliestTime != null ? dailyRoutineEvent.EarliestTime.Minutes.ToString() : string.Empty); code = ExportUtil.BuildPlaceholderRegex(Placeholder_EarliestTime_TotalMinutes).Replace(code, dailyRoutineEvent.EarliestTime != null ? (dailyRoutineEvent.EarliestTime.Hours * projectConfig.MinutesPerHour + dailyRoutineEvent.EarliestTime.Minutes).ToString() : string.Empty); code = ExportUtil.BuildPlaceholderRegex(Placeholder_LatestTime_Hours).Replace(code, dailyRoutineEvent.LatestTime != null ? dailyRoutineEvent.LatestTime.Hours.ToString() : string.Empty); code = ExportUtil.BuildPlaceholderRegex(Placeholder_LatestTime_Minutes).Replace(code, dailyRoutineEvent.LatestTime != null ? dailyRoutineEvent.LatestTime.Minutes.ToString() : string.Empty); code = ExportUtil.BuildPlaceholderRegex(Placeholder_LatestTime_TotalMinutes).Replace(code, dailyRoutineEvent.LatestTime != null ? (dailyRoutineEvent.LatestTime.Hours * projectConfig.MinutesPerHour + dailyRoutineEvent.LatestTime.Minutes).ToString() : string.Empty); code = ExportUtil.BuildPlaceholderRegex(Placeholder_MovementTargetName).Replace(code, dailyRoutineEvent.MovementTarget != null && dailyRoutineEvent.MovementTarget.Name != null ? dailyRoutineEvent.MovementTarget.Name : string.Empty); code = ExportUtil.BuildPlaceholderRegex(Placeholder_MovementTargetExportName).Replace(code, dailyRoutineEvent.MovementTarget != null && dailyRoutineEvent.MovementTarget.ExportName != null ? dailyRoutineEvent.MovementTarget.ExportName : string.Empty); code = ExportUtil.BuildPlaceholderRegex(Placeholder_MovementTargetExportNameOrName).Replace(code, dailyRoutineEvent.MovementTarget != null && !string.IsNullOrEmpty(dailyRoutineEvent.MovementTarget.ExportName) ? dailyRoutineEvent.MovementTarget.ExportName : (dailyRoutineEvent.MovementTarget != null && dailyRoutineEvent.MovementTarget.Name != null ? dailyRoutineEvent.MovementTarget.Name : string.Empty)); code = await ExportUtil.BuildPlaceholderRegex(Placeholder_ScriptFunctionName).ReplaceAsync(code, async m => { return(await _dailyRoutineFunctionNameGenerator.GetNewDailyRoutineStepFunction(defaultProject.Id, npc.Id, dailyRoutineEvent.EventId)); }); code = ExportUtil.BuildPlaceholderRegex(Placeholder_ScriptName).Replace(code, dailyRoutineEvent.ScriptName != null ? dailyRoutineEvent.ScriptName : string.Empty); code = ExportUtil.BuildPlaceholderRegex(Placeholder_TargetState).Replace(code, dailyRoutineEvent.TargetState != null ? dailyRoutineEvent.TargetState : string.Empty); return(code); }
/// <summary> /// Collects the values for an export /// </summary> /// <param name="templateType">Template type</param> /// <param name="parsedTemplate">Parsed scriban template</param> /// <param name="scriptObject">Scriban script object to fill</param> /// <param name="data">Export Data</param> /// <returns>Task</returns> public override async Task CollectValues(TemplateType templateType, Template parsedTemplate, ScriptObject scriptObject, ExportObjectData data) { IFlexFieldExportable flexFieldObject = data.ExportData[ExportConstants.ExportDataObject] as IFlexFieldExportable; if (flexFieldObject == null) { return; } List <LanguageKey> referencedLanguageKeys = null; if (data.ExportData.ContainsKey(ExportConstants.ExportDataReferencedLanguageIds)) { referencedLanguageKeys = data.ExportData[ExportConstants.ExportDataReferencedLanguageIds] as List <LanguageKey>; } if (referencedLanguageKeys == null) { referencedLanguageKeys = new List <LanguageKey>(); } GoNorthProject project = await _exportCachedDbAccess.GetUserProject(); List <LanguageKey> languageKeys = await _languageKeyDbAccess.GetLanguageKeysByGroupId(project.Id, flexFieldObject.Id); ExportSettings exportSettings = await _exportCachedDbAccess.GetExportSettings(project.Id); languageKeys = languageKeys.OrderBy(l => GetLanguageKeySortOrder(l, flexFieldObject)).ToList(); ScribanExportLanguageFile languageFileData = new ScribanExportLanguageFile(); languageFileData.Object = FlexFieldValueCollectorUtil.ConvertScribanFlexFieldObject(flexFieldObject, exportSettings, _errorCollection); languageFileData.LanguageKeys = ConvertLanguageKeysToScriban(languageKeys, exportSettings); languageFileData.ReferencedLanguageKeys = ConvertLanguageKeysToScriban(referencedLanguageKeys, exportSettings); scriptObject.AddOrUpdate(LanguageObjectKey, languageFileData); }
/// <summary> /// Maps the daily routine data of an npc /// </summary> /// <param name="cachedDbAccess">Gecachter Datenzugriff</param> /// <param name="dailyRoutineFunctionNameGenerator">Daily routine function name generator</param> /// <param name="npc">Npc</param> /// <param name="dailyRoutine">Daily routine data</param> /// <returns>Mapped daily routine events</returns> public static async Task <List <ScribanExportDailyRoutineEvent> > MapNpcDailyRoutineEvents(IExportCachedDbAccess cachedDbAccess, IDailyRoutineFunctionNameGenerator dailyRoutineFunctionNameGenerator, KortistoNpc npc, List <KortistoNpcDailyRoutineEvent> dailyRoutine) { if (dailyRoutine == null || !dailyRoutine.Any()) { return(new List <ScribanExportDailyRoutineEvent>()); } GoNorthProject project = await cachedDbAccess.GetUserProject(); MiscProjectConfig projectConfig = await cachedDbAccess.GetMiscProjectConfig(); ExportSettings exportSettings = await cachedDbAccess.GetExportSettings(project.Id); List <ScribanExportDailyRoutineEvent> mappedEvents = new List <ScribanExportDailyRoutineEvent>(); foreach (KortistoNpcDailyRoutineEvent curEvent in dailyRoutine) { ScribanExportDailyRoutineEvent convertedEvent = await ConvertDailyRoutineEvent(dailyRoutineFunctionNameGenerator, npc, curEvent, project, projectConfig, exportSettings); mappedEvents.Add(convertedEvent); } return(mappedEvents); }
/// <summary> /// Exports the code snippet additional functions /// </summary> /// <param name="renderedFunctions">Rendered function cache</param> /// <param name="objectExportSnippet">Object export snippet to export</param> /// <param name="flexFieldObject">Flex field object</param> /// <param name="listIndent">Indent of the code</param> /// <returns>Result of the snippet render</returns> private async Task <string> ExportCodeSnippetAdditionalFunctions(Dictionary <string, List <ExportSnippetFunction> > renderedFunctions, ObjectExportSnippet objectExportSnippet, FlexFieldObject flexFieldObject, string listIndent) { if (objectExportSnippet == null) { return(string.Empty); } GoNorthProject project = await _cachedDbAccess.GetUserProject(); ExportTemplate functionContentTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectExportSnippetFunction); List <ExportSnippetFunction> functions = await RenderFunctions(renderedFunctions, objectExportSnippet, flexFieldObject); List <ExportSnippetFunction> additionalFunctions = functions.Skip(1).ToList(); string functionList = string.Empty; foreach (ExportSnippetFunction curFunction in additionalFunctions) { functionList += await RenderExportSnippetFunction(functionContentTemplate, curFunction); } return(ExportUtil.IndentListTemplate(functionList, listIndent)); }
/// <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)); }
/// <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); }