/// <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;
}
