/// <summary> /// Builds an action from parsed data /// </summary> /// <param name="template">Template to export</param> /// <param name="parsedData">Parsed data</param> /// <param name="data">Dialog data</param> /// <param name="nextStep">Next step in the dialog</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> /// <param name="stepRenderer">Action Step renderer</param> /// <returns>Action string</returns> public override async Task <string> BuildActionFromParsedData(ExportTemplate template, SetGameTimeActionData parsedData, ExportDialogData data, ExportDialogData nextStep, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings, IActionStepRenderer stepRenderer) { MiscProjectConfig projectConfig = await _cachedDbAccess.GetMiscProjectConfig(); return(await FillPlaceholders(template, errorCollection, parsedData, projectConfig, flexFieldObject, data, nextStep, exportSettings, stepRenderer)); }
/// <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(InventoryConditionResolver.InventoryConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, KortistoNpc npc, ExportSettings exportSettings) { ExportTemplate conditionTemplate = _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, _isPlayer ? TemplateType.TaleConditionPlayerInventory : TemplateType.TaleConditionNpcInventory).Result; StyrItem item = _cachedDbAccess.GetItemById(parsedData.ItemId).Result; if (item == null) { errorCollection.AddDialogItemNotFoundError(); return(string.Empty); } ExportObjectData itemExportData = new ExportObjectData(); itemExportData.ExportData.Add(ExportConstants.ExportDataObject, item); itemExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeItem); string conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Operator).Replace(conditionTemplate.Code, GetOperatorFromTemplate(project, parsedData.Operator, errorCollection)); conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Quantity).Replace(conditionCode, parsedData.Quantity.ToString()); conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_Operator_IsAtLeast_Start, Placeholder_Operator_IsAtLeast_End, parsedData.Operator == CompareOperator_AtLeast); conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_Operator_IsAtMaximum_Start, Placeholder_Operator_IsAtMaximum_End, parsedData.Operator == CompareOperator_AtMaximum); _itemPlaceholderResolver.SetErrorMessageCollection(errorCollection); conditionCode = _itemPlaceholderResolver.FillPlaceholders(conditionCode, itemExportData).Result; return(conditionCode); }
/// <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="flexFieldObject">Flex field object to which the dialog belongs</param> /// <param name="exportSettings">Export Settings</param> /// <returns>Action string</returns> public override async Task <string> BuildActionFromParsedData(SpawnObjectAtMarkerRendererBase.SpawnObjectActionData parsedData, ExportDialogData data, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings) { ExportTemplate actionTemplate = await GetExportTemplate(project); IFlexFieldExportable valueObject = await GetValueObject(parsedData, flexFieldObject, errorCollection); if (valueObject == null) { return(string.Empty); } KartaMapNamedMarkerQueryResult markerResult = await GetMarker(parsedData); if (markerResult == null) { errorCollection.AddDialogMarkerNotFoundError(); return(string.Empty); } string actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_TargetMarker_Name).Replace(actionTemplate.Code, markerResult.MarkerName); actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Rotation_Pitch).Replace(actionCode, parsedData.Pitch.ToString()); actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Rotation_Yaw).Replace(actionCode, parsedData.Yaw.ToString()); actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Rotation_Roll).Replace(actionCode, parsedData.Roll.ToString()); 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> /// Renders a condition step /// </summary> /// <param name="template">Export template</param> /// <param name="data">Dialog Step Data</param> /// <param name="flexFieldObject">Flex field object to which the dialog belongs</param> /// <param name="conditionNode">Condition node to render</param> /// <returns>Dialog Step Render Result</returns> public async Task <ExportDialogStepRenderResult> RenderDialogStep(ExportTemplate template, ExportDialogData data, FlexFieldObject flexFieldObject, ConditionNode conditionNode) { ExportDialogStepRenderResult renderResult = new ExportDialogStepRenderResult(); Template parsedTemplate = ScribanParsingUtil.ParseTemplate(template.Code, _errorCollection); if (parsedTemplate == null) { return(renderResult); } ScribanCondition conditionData = new ScribanCondition(); SetRenderObjectBaseDataFromFlexFieldObject(conditionData, data, flexFieldObject); conditionData.AllConditions = await BuildAllConditions(data, flexFieldObject, conditionNode); conditionData.Conditions = conditionData.AllConditions.Where(c => c.ChildNode != null).ToList(); conditionData.Else = BuildElsePart(data, flexFieldObject); TemplateContext context = BuildTemplateContext(conditionData); renderResult.StepCode = await parsedTemplate.RenderAsync(context); return(renderResult); }
/// <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(AddQuestTextRenderer.AddQuestTextData parsedData, ExportDialogData data, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, KortistoNpc npc, ExportSettings exportSettings) { ExportTemplate actionTemplate = await GetExportTemplate(project); IFlexFieldExportable valueObject = await GetQuest(parsedData, errorCollection); if (valueObject == null) { return(string.Empty); } string actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_QuestText).Replace(actionTemplate.Code, ExportUtil.EscapeCharacters(parsedData.QuestText, exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter)); actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_QuestText_Preview).Replace(actionCode, ExportUtil.BuildTextPreview(parsedData.QuestText)); actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_QuestText_LangKey).Replace(actionCode, m => { return(_languageKeyGenerator.GetDialogTextLineKey(npc.Id, valueObject.Name, ExportConstants.LanguageKeyTypeQuest, data.Id, parsedData.QuestText).Result); }); ExportObjectData flexFieldExportData = new ExportObjectData(); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObject, valueObject); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeQuest); _flexFieldPlaceholderResolver.SetErrorMessageCollection(errorCollection); actionCode = _flexFieldPlaceholderResolver.FillPlaceholders(actionCode, flexFieldExportData).Result; return(actionCode); }
protected override IWorkbook CreateExcelWorkBook(string locale, ExportTemplate exportTemplate, SearchArgs <Material> searchArgs) { IWorkbook workbook = new XSSFWorkbook(); //导出当前页 if (searchArgs.Pagination && searchArgs.Model != null && searchArgs.Model.CategoryId.HasValue) { var result = SearchDic(searchArgs); var category = MaterialCategoryService.GetById(searchArgs.Model.CategoryId); CreateSingleSheet(workbook, category, locale, "Sheet1", exportTemplate, result); return(workbook); } //导出所有 else { //先获取类别 每个类别创建一个Sheet var categories = MaterialCategoryService.Search(new SearchArgs <MaterialCategory> { Pagination = false }).Items; foreach (var category in categories) { var result = SearchDic(new SearchArgs <Material>() { Model = new Material() { CategoryId = category.Id } }); CreateSingleSheet(workbook, category, locale, "en-us".EqualsIgnoreCase(locale) ? category.Code : category.Name, exportTemplate, result); } } return(workbook); }
/// <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> /// 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="flexFieldObject">Flex field object to which the dialog belongs</param> /// <param name="exportSettings">Export Settings</param> /// <returns>Condition string</returns> public override string BuildConditionElementFromParsedData(NpcAliveStateConditionResolver.NpvAliveStateConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings) { ExportTemplate conditionTemplate = _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.TaleConditionNpcAliveState).Result; KortistoNpc selectedNpc = _cachedDbAccess.GetNpcById(parsedData.NpcId).Result; if (selectedNpc == null) { errorCollection.AddDialogItemNotFoundError(); return(string.Empty); } ExportObjectData npcExportData = new ExportObjectData(); npcExportData.ExportData.Add(ExportConstants.ExportDataObject, selectedNpc); npcExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeNpc); string conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionTemplate.Code, Placeholder_State_Alive_Start, Placeholder_State_Alive_End, parsedData.State == State_Alive); conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_State_Dead_Start, Placeholder_State_Dead_End, parsedData.State == State_Dead); _npcPlaceholderResolver.SetErrorMessageCollection(errorCollection); conditionCode = _npcPlaceholderResolver.FillPlaceholders(conditionCode, npcExportData).Result; return(conditionCode); }
/// <summary> /// Fills the daily routine placeholders /// </summary> /// <param name="code">Code</param> /// <param name="npc">Npc</param> /// <returns>Filled code</returns> private async Task <string> FillDailyRoutinePlaceholders(string code, KortistoNpc npc) { GoNorthProject project = await _cachedDbAccess.GetDefaultProject(); ExportTemplate dailyRoutineEventTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectDailyRoutineEventList); ExportTemplate dailyRoutineFunctionListTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectDailyRoutineFunctionList); ExportTemplate dailyRoutineFunctionTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectDailyRoutineFunction); code = ExportUtil.BuildPlaceholderRegex(Placeholder_DailyRoutine_Events, ExportConstants.ListIndentPrefix).Replace(code, m => { return(ExportUtil.IndentListTemplate(dailyRoutineEventTemplate.Code, m.Groups[1].Value)); }); code = ExportUtil.BuildPlaceholderRegex(Placeholder_DailyRoutine_Functions, ExportConstants.ListIndentPrefix).Replace(code, m => { return(ExportUtil.IndentListTemplate(dailyRoutineFunctionListTemplate.Code, 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 = ExportUtil.BuildRangePlaceholderRegex(Placeholder_DailyRoutine_Functions_Start, Placeholder_DailyRoutine_Functions_End).Replace(code, m => { return(ExportUtil.TrimEmptyLines(BuildFunctionList(m.Groups[1].Value, project, npc))); }); return(code); }
/// <summary> /// Renders a dialog step /// </summary> /// <param name="data">Dialog Step Data</param> /// <param name="npc">Npc to which the dialog belongs</param> /// <returns>Dialog Step Render Result</returns> public async Task <ExportDialogStepRenderResult> RenderDialogStep(ExportDialogData data, KortistoNpc npc) { ConditionNode conditionNode = data.Condition; if (conditionNode == null) { return(null); } ExportTemplate template = await _defaultTemplateProvider.GetDefaultTemplateByType(_project.Id, TemplateType.TaleCondition); ExportDialogStepRenderResult renderResult = new ExportDialogStepRenderResult(); renderResult.StepCode = ReplaceNodeId(template.Code, data); renderResult.StepCode = ExportUtil.BuildRangePlaceholderRegex(Placeholder_ConditionsStart, Placeholder_ConditionsEnd).Replace(renderResult.StepCode, m => { return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(BuildConditions(m.Groups[1].Value, data, conditionNode, npc, false), m.Groups[2].Value))); }); renderResult.StepCode = ExportUtil.BuildRangePlaceholderRegex(Placeholder_AllConditionsStart, Placeholder_AllConditionsEnd).Replace(renderResult.StepCode, m => { return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(BuildConditions(m.Groups[1].Value, data, conditionNode, npc, true), m.Groups[2].Value))); }); renderResult.StepCode = ExportUtil.BuildRangePlaceholderRegex(Placeholder_ElseStart, Placeholder_ElseEnd).Replace(renderResult.StepCode, m => { return(ExportUtil.IndentListTemplate(BuildElsePart(m.Groups[1].Value, data), m.Groups[2].Value)); }); return(renderResult); }
/// <summary> /// Builds an action from parsed data /// </summary> /// <param name="template">Template to export</param> /// <param name="parsedData">Parsed data</param> /// <param name="data">Dialog data</param> /// <param name="nextStep">Next step in the dialog</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> /// <param name="stepRenderer">Action Step renderer</param> /// <returns>Action string</returns> public override async Task <string> BuildActionFromParsedData(ExportTemplate template, MoveNpcToNpcActionData parsedData, ExportDialogData data, ExportDialogData nextStep, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings, IActionStepRenderer stepRenderer) { KortistoNpc foundNpc = await GetNpc(parsedData, flexFieldObject); if (foundNpc == null) { errorCollection.AddDialogNpcNotFoundError(); return(string.Empty); } KortistoNpc targetResult = await GetTargetNpc(parsedData); if (targetResult == null) { errorCollection.AddDialogNpcNotFoundError(); return(string.Empty); } string directContinueFunction = string.Empty; if (data.Children != null) { ExportDialogDataChild directStep = data.Children.FirstOrDefault(c => c.NodeChildId == DirectContinueFunctionNodeId); directContinueFunction = directStep != null ? directStep.Child.DialogStepFunctionName : string.Empty; } return(await FillPlaceholders(template, errorCollection, parsedData, foundNpc, targetResult, directContinueFunction, flexFieldObject, data, nextStep, exportSettings, stepRenderer)); }
/// <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, ConfigClass parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings) { Template parsedTemplate = ScribanParsingUtil.ParseTemplate(template.Code, errorCollection); if (parsedTemplate == null) { return(string.Empty); } if (_languageKeyGenerator != null) { _languageKeyGenerator.SetErrorCollection(errorCollection); } ScribanRenderingClass renderingObject = await GetExportObject(parsedData, project, errorCollection, flexFieldObject, exportSettings); if (renderingObject == null) { return(string.Empty); } TemplateContext context = BuildTemplateContext(renderingObject, errorCollection); string conditionCode = await parsedTemplate.RenderAsync(context); return(conditionCode); }
/// <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(MoveNpcActionRenderer.MoveNpcActionData parsedData, ExportDialogData data, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, KortistoNpc npc, ExportSettings exportSettings) { ExportTemplate actionTemplate = await GetExportTemplate(project); KortistoNpc foundNpc = await GetNpc(parsedData, npc); if (foundNpc == null) { errorCollection.AddDialogNpcNotFoundError(); return(string.Empty); } KartaMapNamedMarkerQueryResult markerResult = await GetMarker(parsedData); if (markerResult == null) { errorCollection.AddDialogMarkerNotFoundError(); return(string.Empty); } string actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_TargetMarker_Name).Replace(actionTemplate.Code, markerResult.MarkerName); ExportObjectData flexFieldExportData = new ExportObjectData(); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObject, foundNpc); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeNpc); _flexFieldPlaceholderResolver.SetErrorMessageCollection(errorCollection); actionCode = _flexFieldPlaceholderResolver.FillPlaceholders(actionCode, flexFieldExportData).Result; return(actionCode); }
/// <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 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> /// Builds an action from parsed data /// </summary> /// <param name="template">Export template</param> /// <param name="parsedData">Parsed data</param> /// <param name="data">Dialog data</param> /// <param name="nextStep">Next step in the dialog</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> /// <param name="stepRenderer">Action Step renderer</param> /// <returns>Action string</returns> public override async Task <string> BuildActionFromParsedData(ExportTemplate template, FloatingTextActionData parsedData, ExportDialogData data, ExportDialogData nextStep, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings, IActionStepRenderer stepRenderer) { IFlexFieldExportable valueObject = await GetValueObject(project, parsedData, flexFieldObject, errorCollection); if (valueObject == null) { return(string.Empty); } string actionCode = template.Code; actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_FloatingText).Replace(actionCode, parsedData.FloatingText); actionCode = await ExportUtil.BuildPlaceholderRegex(Placeholder_FloatingText_LangKey).ReplaceAsync(actionCode, async m => { return(await _languageKeyGenerator.GetDialogTextLineKey(flexFieldObject.Id, valueObject.Name, GetLanguageKeyType(), data.Id, parsedData.FloatingText)); }); 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(actionCode); }
/// <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(SetQuestStateActionRenderer.SetQuestStateActionData parsedData, ExportDialogData data, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, KortistoNpc npc, ExportSettings exportSettings) { ExportTemplate actionTemplate = await GetExportTemplate(project); IFlexFieldExportable valueObject = await GetQuest(parsedData, errorCollection); if (valueObject == null) { return(string.Empty); } string actionCode = ExportUtil.RenderPlaceholderIfTrue(actionTemplate.Code, Placeholder_QuestState_NotStarted_Start, Placeholder_QuestState_NotStarted_End, parsedData.QuestState == QuestState_NotStarted); actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_QuestState_InProgress_Start, Placeholder_QuestState_InProgress_End, parsedData.QuestState == QuestState_InProgress); actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_QuestState_Success_Start, Placeholder_QuestState_Success_End, parsedData.QuestState == QuestState_Success); actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_QuestState_Failed_Start, Placeholder_QuestState_Failed_End, parsedData.QuestState == QuestState_Failed); ExportObjectData flexFieldExportData = new ExportObjectData(); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObject, valueObject); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeQuest); _flexFieldPlaceholderResolver.SetErrorMessageCollection(errorCollection); actionCode = _flexFieldPlaceholderResolver.FillPlaceholders(actionCode, flexFieldExportData).Result; return(actionCode); }
/// <summary> /// Parses the snippets of a template /// </summary> /// <param name="template">Template to parse</param> /// <returns>List of found snippets</returns> private List <ExportTemplateSnippet> ParseSnippets(ExportTemplate template) { string snippetRegexFormat = string.Format("(\\s|^){0}\\.{1}\\.(.*?)\\.({2}|{3}|{4})", ExportConstants.ScribanExportSnippetsObjectKey, StandardMemberRenamer.Rename(nameof(ScribanExportSnippetsData.Snippets)), StandardMemberRenamer.Rename(nameof(ScribanExportSnippet.InitialFunction)), StandardMemberRenamer.Rename(nameof(ScribanExportSnippet.AdditionalFunctions)), StandardMemberRenamer.Rename(nameof(ScribanExportSnippet.AllFunctions))); Regex exportSnippetRegex = new Regex(snippetRegexFormat, RegexOptions.Multiline); Template parsedTemplate = Template.Parse(template.Code); List <ExportTemplateSnippet> snippets = new List <ExportTemplateSnippet>(); List <ScriptStatement> statementsToCheck = ScribanStatementExtractor.ExtractPlainNonTextStatements(parsedTemplate); foreach (ScriptStatement curStatement in statementsToCheck) { if (curStatement is ScriptRawStatement) { continue; } string statement = curStatement.ToString(); MatchCollection snippetMatches = exportSnippetRegex.Matches(statement); if (!snippetMatches.Any()) { continue; } AddNewSnippets(snippets, snippetMatches); } return(snippets); }
/// <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="npc">Npc to move</param> /// <param name="targetNpc">Target npc</param> /// <param name="directContinueFunction">Direct continue function</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, MoveNpcToNpcActionData parsedData, KortistoNpc npc, KortistoNpc targetNpc, string directContinueFunction, FlexFieldObject flexFieldObject, ExportDialogData curStep, ExportDialogData nextStep, ExportSettings exportSettings, IActionStepRenderer stepRenderer) { ExportObjectData flexFieldExportData = new ExportObjectData(); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObject, npc); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeNpc); _flexFieldPlaceholderResolver.SetErrorMessageCollection(errorCollection); string actionCode = _flexFieldPlaceholderResolver.FillPlaceholders(template.Code, flexFieldExportData).Result; if (!_isTeleport) { actionCode = BuildDirectContinueFunction(directContinueFunction, actionCode); actionCode = BuildMovementState(parsedData, actionCode); } ExportObjectData flexFieldTargetExportData = new ExportObjectData(); flexFieldTargetExportData.ExportData.Add(ExportConstants.ExportDataObject, targetNpc); flexFieldTargetExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeNpc); _flexFieldTargetPlaceholderResolver.SetErrorMessageCollection(errorCollection); actionCode = _flexFieldTargetPlaceholderResolver.FillPlaceholders(actionCode, flexFieldTargetExportData).Result; return(await stepRenderer.ReplaceBasePlaceholders(errorCollection, actionCode, curStep, nextStep, flexFieldObject)); }
/// <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="npc">Npc to move</param> /// <param name="targetNpc">Target npc</param> /// <param name="directContinueFunction">Direct continue function</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, MoveNpcToNpcActionData parsedData, KortistoNpc npc, KortistoNpc targetNpc, string directContinueFunction, FlexFieldObject flexFieldObject, ExportDialogData curStep, ExportDialogData nextStep, ExportSettings exportSettings, IActionStepRenderer stepRenderer) { ScribanMoveNpcToNpcActionBaseData actionData; if (_isTeleport) { actionData = new ScribanMoveNpcToNpcActionBaseData(); } else { ScribanMoveNpcToNpcActionData walkData = new ScribanMoveNpcToNpcActionData(); walkData.MovementState = !string.IsNullOrEmpty(parsedData.MovementState) ? ExportUtil.EscapeCharacters(parsedData.MovementState, exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter) : null; walkData.UnescapedMovementState = parsedData.MovementState; walkData.DirectContinueFunction = !string.IsNullOrEmpty(directContinueFunction) ? directContinueFunction : null; actionData = walkData; } actionData.Npc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, npc, exportSettings, errorCollection); actionData.Npc.IsPlayer = npc.IsPlayerNpc; actionData.TargetNpc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, targetNpc, exportSettings, errorCollection); actionData.TargetNpc.IsPlayer = targetNpc.IsPlayerNpc; return(await ScribanActionRenderingUtil.FillPlaceholders(_cachedDbAccess, errorCollection, template.Code, actionData, flexFieldObject, curStep, nextStep, _scribanLanguageKeyGenerator, stepRenderer)); }
/// <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="flexFieldObject">Flex field object to which the dialog belongs</param> /// <param name="exportSettings">Export Settings</param> /// <returns>Action string</returns> public override async Task <string> BuildActionFromParsedData(UseItemActionRenderer.UseItemActionData parsedData, ExportDialogData data, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings) { ExportTemplate actionTemplate = await GetExportTemplate(project); IFlexFieldExportable valueItem = await GetItem(parsedData, errorCollection); IFlexFieldExportable valueNpc = await GetNpc(flexFieldObject, parsedData, errorCollection); if (valueItem == null || valueNpc == null) { return(string.Empty); } string actionCode = actionTemplate.Code; ExportObjectData flexFieldExportDataItem = new ExportObjectData(); flexFieldExportDataItem.ExportData.Add(ExportConstants.ExportDataObject, valueItem); flexFieldExportDataItem.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeItem); _flexFieldPlaceholderResolverItem.SetErrorMessageCollection(errorCollection); actionCode = await _flexFieldPlaceholderResolverItem.FillPlaceholders(actionCode, flexFieldExportDataItem); ExportObjectData flexFieldExportDataNpc = new ExportObjectData(); flexFieldExportDataNpc.ExportData.Add(ExportConstants.ExportDataObject, valueNpc); flexFieldExportDataNpc.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeNpc); _flexFieldPlaceholderResolverNpc.SetErrorMessageCollection(errorCollection); actionCode = await _flexFieldPlaceholderResolverNpc.FillPlaceholders(actionCode, flexFieldExportDataNpc); return(actionCode); }
/// <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, InventoryConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings) { StyrItem item = await _cachedDbAccess.GetItemById(parsedData.ItemId); if (item == null) { errorCollection.AddDialogItemNotFoundError(); return(string.Empty); } ExportObjectData itemExportData = new ExportObjectData(); itemExportData.ExportData.Add(ExportConstants.ExportDataObject, item); itemExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeItem); string conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Operator).Replace(template.Code, await ConditionRenderingUtil.GetItemCompareOperatorFromTemplate(_defaultTemplateProvider, project, parsedData.Operator, errorCollection)); conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Quantity).Replace(conditionCode, parsedData.Quantity.ToString()); conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_Operator_IsAtLeast_Start, Placeholder_Operator_IsAtLeast_End, parsedData.Operator == InventoryConditionData.CompareOperator_AtLeast); conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_Operator_IsAtMaximum_Start, Placeholder_Operator_IsAtMaximum_End, parsedData.Operator == InventoryConditionData.CompareOperator_AtMaximum); _itemPlaceholderResolver.SetErrorMessageCollection(errorCollection); conditionCode = await _itemPlaceholderResolver.FillPlaceholders(conditionCode, itemExportData); return(conditionCode); }
/// <summary> /// Renders a dialog step /// </summary> /// <param name="template">Export template</param> /// <param name="data">Dialog Step Data</param> /// <param name="npc">Npc object to which the dialog belongs</param> /// <param name="textNode">Text node to render</param> /// <returns>Dialog Step Render Result</returns> public async Task <ExportDialogStepRenderResult> RenderDialogStep(ExportTemplate template, ExportDialogData data, KortistoNpc npc, TextNode textNode) { ExportDialogStepRenderResult renderResult = new ExportDialogStepRenderResult(); Template parsedTemplate = ScribanParsingUtil.ParseTemplate(template.Code, _errorCollection); if (parsedTemplate == null) { return(renderResult); } _languageKeyGenerator.SetErrorCollection(_errorCollection); ScribanTextLine textLineData = BuildDialogRenderObject <ScribanTextLine>(data, data.Children.FirstOrDefault() != null ? data.Children.FirstOrDefault().Child : null, npc); textLineData.TextLine = ExportUtil.EscapeCharacters(textNode.Text, _exportSettings.EscapeCharacter, _exportSettings.CharactersNeedingEscaping, _exportSettings.NewlineCharacter); textLineData.UnescapedTextLine = textNode.Text; textLineData.TextLinePreview = ExportUtil.BuildTextPreview(textNode.Text); textLineData.IsPlayerLine = _isPlayerLine; TemplateContext context = BuildTemplateContext(textLineData); renderResult.StepCode = await parsedTemplate.RenderAsync(context); return(renderResult); }
/// <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="flexFieldObject">Flex field object to which the dialog belongs</param> /// <param name="exportSettings">Export Settings</param> /// <returns>Action string</returns> public override async Task <string> BuildActionFromParsedData(WaitActionRenderer.WaitActionData parsedData, ExportDialogData data, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings) { if (data.Children != null && data.Children.Count == 1 && data.Children[0].NodeChildId == DirectContinueFunctionNodeId) { errorCollection.AddWaitActionHasOnlyDirectContinueFunction(); } ExportTemplate actionTemplate = await GetExportTemplate(project); string actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Wait_Amount).Replace(actionTemplate.Code, parsedData.WaitAmount.ToString()); actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_WaitTypeIsRealTime_Start, Placeholder_WaitTypeIsRealTime_End, parsedData.WaitType == WaitTypeRealTime); actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_WaitTypeIsGameTime_Start, Placeholder_WaitTypeIsGameTime_End, parsedData.WaitType == WaitTypeGameTime); actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_WaitUnitIsMilliseconds_Start, Placeholder_WaitUnitIsMilliseconds_End, parsedData.WaitUnit == WaitUnitMilliseconds); actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_WaitUnitIsSeconds_Start, Placeholder_WaitUnitIsSeconds_End, parsedData.WaitUnit == WaitUnitSeconds); actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_WaitUnitIsMinutes_Start, Placeholder_WaitUnitIsMinutes_End, parsedData.WaitUnit == WaitUnitMinutes); actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_WaitUnitIsHours_Start, Placeholder_WaitUnitIsHours_End, parsedData.WaitUnit == WaitUnitHours); actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_WaitUnitIsDays_Start, Placeholder_WaitUnitIsDays_End, parsedData.WaitUnit == WaitUnitDays); string directContinueFunction = string.Empty; if (data.Children != null) { ExportDialogDataChild directStep = data.Children.FirstOrDefault(c => c.NodeChildId == DirectContinueFunctionNodeId); directContinueFunction = directStep != null ? directStep.Child.DialogStepFunctionName : string.Empty; } actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_HasDirectContinueFunction_Start, Placeholder_HasDirectContinueFunction_End, !string.IsNullOrEmpty(directContinueFunction)); actionCode = ExportUtil.RenderPlaceholderIfTrue(actionCode, Placeholder_HasNoDirectContinueFunction_Start, Placeholder_HasNoDirectContinueFunction_End, string.IsNullOrEmpty(directContinueFunction)); actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_DirectContinueFunction).Replace(actionCode, directContinueFunction); return(actionCode); }
/// <summary> /// Renders a dialog step /// </summary> /// <param name="data">Dialog Step Data</param> /// <param name="flexFieldObject">Flex field object to which the dialog belongs</param> /// <returns>Dialog Step Render Result</returns> public async Task <ExportDialogStepRenderResult> RenderDialogStep(ExportDialogData data, FlexFieldObject flexFieldObject) { ConditionNode conditionNode = data.Condition; if (conditionNode == null) { return(null); } ExportTemplate template = await _defaultTemplateProvider.GetDefaultTemplateByType(_project.Id, TemplateType.TaleCondition); if (!_renderers.ContainsKey(template.RenderingEngine)) { throw new KeyNotFoundException(string.Format("Unknown rendering engine {0} for ConditionNode", template.RenderingEngine.ToString())); } string oldContext = _errorCollection.CurrentErrorContext; _errorCollection.CurrentErrorContext = _localizer["ErrorContextCondition"]; try { return(await _renderers[template.RenderingEngine].RenderDialogStep(template, data, flexFieldObject, conditionNode)); } catch (Exception ex) { _errorCollection.AddException(ex); return(new ExportDialogStepRenderResult { StepCode = "<<ERROR_RENDERING_CONDITION>>" }); } finally { _errorCollection.CurrentErrorContext = oldContext; } }
/// <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="flexFieldObject">Flex field object to which the dialog belongs</param> /// <param name="exportSettings">Export Settings</param> /// <returns>Condition string</returns> public override string BuildConditionElementFromParsedData(QuestStateConditionResolver.QuestStateConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings) { ExportTemplate conditionTemplate = _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.TaleConditionQuestState).Result; IFlexFieldExportable quest = _cachedDbAccess.GetQuestById(parsedData.QuestId).Result; if (quest == null) { errorCollection.AddDialogQuestNotFoundError(); return(string.Empty); } string conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionTemplate.Code, Placeholder_QuestState_NotStarted_Start, Placeholder_QuestState_NotStarted_End, parsedData.State == QuestState_NotStarted); conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_QuestState_InProgress_Start, Placeholder_QuestState_InProgress_End, parsedData.State == QuestState_InProgress); conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_QuestState_Success_Start, Placeholder_QuestState_Success_End, parsedData.State == QuestState_Success); conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_QuestState_Failed_Start, Placeholder_QuestState_Failed_End, parsedData.State == QuestState_Failed); ExportObjectData flexFieldExportData = new ExportObjectData(); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObject, quest); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeQuest); _flexFieldPlaceholderResolver.SetErrorMessageCollection(errorCollection); conditionCode = _flexFieldPlaceholderResolver.FillPlaceholders(conditionCode, flexFieldExportData).Result; return(conditionCode); }
/// <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(ShowFloatingTextAboveObjectActionRenderer.FloatingTextActionData parsedData, ExportDialogData data, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, KortistoNpc npc, ExportSettings exportSettings) { ExportTemplate actionTemplate = await GetExportTemplate(project); IFlexFieldExportable valueObject = await GetValueObject(project, parsedData, npc, errorCollection); if (valueObject == null) { return(string.Empty); } string actionCode = actionTemplate.Code; actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_FloatingText).Replace(actionCode, parsedData.FloatingText); actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_FloatingText_LangKey).Replace(actionCode, m => { return(_languageKeyGenerator.GetDialogTextLineKey(npc.Id, valueObject.Name, GetLanguageKeyType(), data.Id, parsedData.FloatingText).Result); }); 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 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="flexFieldObject">Flex field object to which the dialog belongs</param> /// <param name="exportSettings">Export Settings</param> /// <returns>Action string</returns> public override async Task <string> BuildActionFromParsedData(SetDailyRoutineEventState.SetDailyRoutineEventStateData parsedData, ExportDialogData data, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings) { ExportTemplate actionTemplate = await GetExportTemplate(project); KortistoNpc eventNpc = await _cachedDbAccess.GetNpcById(parsedData.NpcId); if (eventNpc == null) { return(string.Empty); } KortistoNpcDailyRoutineEvent exportEvent = null; if (eventNpc.DailyRoutine != null) { exportEvent = eventNpc.DailyRoutine.FirstOrDefault(e => e.EventId == parsedData.EventId); } if (exportEvent == null) { errorCollection.AddDialogDailyRoutineEventNotFoundError(eventNpc.Name); return(string.Empty); } string actionCode = await _dailyRoutineEventPlaceholderResolver.ResolveDailyRoutineEventPlaceholders(actionTemplate.Code, eventNpc, exportEvent); ExportObjectData flexFieldExportData = new ExportObjectData(); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObject, eventNpc); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeNpc); _flexFieldPlaceholderResolver.SetErrorMessageCollection(errorCollection); actionCode = _flexFieldPlaceholderResolver.FillPlaceholders(actionCode, flexFieldExportData).Result; return(actionCode); }
/// <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="flexFieldObject">Flex field object to which the dialog belongs</param> /// <param name="exportSettings">Export Settings</param> /// <returns>Action string</returns> public override async Task <string> BuildActionFromParsedData(InventoryActionRenderer.InventoryActionData parsedData, ExportDialogData data, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings) { ExportTemplate actionTemplate = await GetExportTemplate(project); IFlexFieldExportable valueObject = await GetItem(parsedData, errorCollection); if (valueObject == null) { return(string.Empty); } string actionCode = actionTemplate.Code; actionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Quantity).Replace(actionCode, parsedData.Quantity.HasValue ? parsedData.Quantity.Value.ToString() : "1"); ExportObjectData flexFieldExportData = new ExportObjectData(); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObject, valueObject); flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeItem); _flexFieldPlaceholderResolver.SetErrorMessageCollection(errorCollection); actionCode = await _flexFieldPlaceholderResolver.FillPlaceholders(actionCode, flexFieldExportData); return(actionCode); }
/// <summary> /// Exports an object /// </summary> /// <param name="template">Template to use</param> /// <param name="objectData">Object data</param> /// <returns>Export Result</returns> public Task <ExportObjectResult> ExportObject(ExportTemplate template, ExportObjectData objectData) { ExportObjectResult result = new ExportObjectResult(); result.FileExtension = "json"; object exportResult = null; if (template.TemplateType == TemplateType.ObjectNpc) { NpcJsonExportObject exportObject = new NpcJsonExportObject((KortistoNpc)objectData.ExportData[ExportConstants.ExportDataObject]); exportObject.Dialog = objectData.ExportData[ExportConstants.ExportDataDialog] as TaleDialog; exportResult = exportObject; } else { exportResult = objectData.ExportData[ExportConstants.ExportDataObject]; } JsonSerializerSettings serializerSettings = new JsonSerializerSettings(); serializerSettings.ContractResolver = new JsonExportContractResolver(); serializerSettings.Formatting = Formatting.Indented; result.Code = JsonConvert.SerializeObject(exportResult, serializerSettings); return(Task.FromResult(result)); }
public string Export(Guid importTemplateID, IList listInvalidData, string outputPath) { string result = string.Empty; using (var context = new VnrHrmDataContext()) { var unitOfWork = (IUnitOfWork)(new UnitOfWork(context)); if (importTemplateID != Guid.Empty) { var importTemplate = unitOfWork.CreateQueryable<Cat_Import>(Guid.Empty, d => d.ID == importTemplateID).Select(d => new { d.StartColumnIndex, d.StartRowIndex, d.SheetIndex, d.ObjectName, d.TemplateFile }).FirstOrDefault(); var listImportItem = unitOfWork.CreateQueryable<Cat_ImportItem>(Guid.Empty, d => d.ImportID == ImportTemplateID && d.ExcelField != null && d.IsDelete == null).Select(d => new { d.ChildFieldLevel1, d.ChildFieldLevel2, d.ExcelField, d.AllowNull, d.AllowDuplicate, d.DuplicateGroup }).OrderBy(d => d.ExcelField).ToList(); ExcelExporter exporter = new ExcelExporter(); ExportTemplate template = new ExportTemplate(); template.TemplateID = importTemplateID; template.DataSource = listInvalidData; template.SheetIndex = (int)importTemplate.SheetIndex.GetLong(); template.StartRowIndex = (int)importTemplate.StartRowIndex.GetLong(); template.StartColumnIndex = (int)importTemplate.StartColumnIndex.GetLong(); Type objectType = GetAssembly(importTemplate.ObjectName); string templatepath = Common.GetPath(Common.TemplateURL).Replace("/", "\\"); template.TemplateFile = templatepath + "\\" + importTemplate.TemplateFile; string fileSuffix = DateTime.Now.ToString("yyyyMMddHHmmss"); string fileExt = Path.GetExtension(importTemplate.TemplateFile); fileExt = string.IsNullOrWhiteSpace(fileExt) ? "xls" : fileExt; fileExt = fileExt.StartsWith(".") ? fileExt : "." + fileExt; string filename = Path.GetFileNameWithoutExtension(importTemplate.TemplateFile); template.FileName = outputPath.Replace("/", "\\") + filename + fileSuffix + fileExt; foreach (var importItem in listImportItem) { string childFieldLevel1 = importItem.ChildFieldLevel1.TrimAll(); string childFieldLevel2 = importItem.ChildFieldLevel2.TrimAll(); PropertyInfo propertyType = objectType.GetProperty(childFieldLevel1); if (propertyType != null) { if (string.IsNullOrWhiteSpace(childFieldLevel2)) { template.MappingFields.Add(childFieldLevel1, importItem.ExcelField); } else { if (unitOfWork.IsMetadataType(propertyType.PropertyType)) { propertyType = propertyType.PropertyType.GetProperty(childFieldLevel2); string importFieldName = unitOfWork.GetFieldConstraint(objectType, childFieldLevel1); template.MappingFields.Add(importFieldName + "_" + childFieldLevel2, importItem.ExcelField); } } } } exporter.ExportByTemplate(template); result = template.FileName; } } return result; }