/// <summary>
/// Runs additional updates on a flex field object
/// </summary>
/// <param name="flexFieldObject">Flex Field Object</param>
/// <param name="loadedFlexFieldObject">Loaded Flex Field Object</param>
/// <returns>Updated flex field object</returns>
protected override async Task <KortistoNpc> RunAdditionalUpdates(KortistoNpc flexFieldObject, KortistoNpc loadedFlexFieldObject)
{
if (User.IsInRole(RoleNames.KortistoPlayerManager))
{
if (flexFieldObject.IsPlayerNpc && loadedFlexFieldObject.IsPlayerNpc != flexFieldObject.IsPlayerNpc)
{
GoNorthProject project = await _projectDbAccess.GetDefaultProject();
await((IKortistoNpcDbAccess)_objectDbAccess).ResetPlayerFlagForAllNpcs(project.Id);
}
loadedFlexFieldObject.IsPlayerNpc = flexFieldObject.IsPlayerNpc;
}
loadedFlexFieldObject.NameGenTemplate = flexFieldObject.NameGenTemplate;
if (User.IsInRole(RoleNames.Styr))
{
loadedFlexFieldObject.Inventory = flexFieldObject.Inventory;
}
if (User.IsInRole(RoleNames.Evne))
{
loadedFlexFieldObject.Skills = flexFieldObject.Skills;
}
return(loadedFlexFieldObject);
}
/// <summary>
/// Returns the operator from the template of the condition
/// </summary>
/// <param name="project">Project</param>
/// <param name="conditionOperator">Condition Operator</param>
/// <param name="errorCollection">Error Collection</param>
/// <returns>Condition Operator</returns>
private string GetOperatorFromTemplate(GoNorthProject project, string conditionOperator, ExportPlaceholderErrorCollection errorCollection)
{
switch (conditionOperator.ToLowerInvariant())
{
case "=":
return(_defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralCompareOperatorEqual).Result.Code);
case "!=":
return(_defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralCompareOperatorNotEqual).Result.Code);
case "<":
return(_defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralCompareOperatorLess).Result.Code);
case "<=":
return(_defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralCompareOperatorLessOrEqual).Result.Code);
case ">":
return(_defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralCompareOperatorBigger).Result.Code);
case ">=":
return(_defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralCompareOperatorBiggerOrEqual).Result.Code);
case "contains":
return(_defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralCompareOperatorContains).Result.Code);
case "startswith":
return(_defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralCompareOperatorStartsWith).Result.Code);
case "endswith":
return(_defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralCompareOperatorEndsWith).Result.Code);
}
errorCollection.AddDialogUnknownConditionOperator(conditionOperator);
return(string.Empty);
}
/// <summary>
/// Fills the dialog placeholders
/// </summary>
/// <param name="code">Code</param>
/// <param name="npc">Npc</param>
/// <returns>Filled code</returns>
private async Task <string> FillDialogPlaceholders(string code, KortistoNpc npc)
{
GoNorthProject project = await _cachedDbAccess.GetDefaultProject();
TaleDialog dialog = await _taleDbAccess.GetDialogByRelatedObjectId(npc.Id);
try
{
_errorCollection.CurrentErrorContext = _localizer["DialogErrorContext"].Value;
_dialogParser.SetErrorCollection(_errorCollection);
_dialogRenderer.SetErrorCollection(_errorCollection);
ExportDialogData exportDialog = null;
bool hasValidDialog = HasValidDialog(dialog);
if (hasValidDialog)
{
exportDialog = _dialogParser.ParseDialog(dialog);
if (exportDialog == null)
{
return(string.Empty);
}
exportDialog = await _dialogFunctionGenerator.GenerateFunctions(project.Id, npc.Id, exportDialog, _errorCollection);
}
code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_HasDialog_Start, Placeholder_HasDialog_End, hasValidDialog);
code = await RenderDialog(project, code, exportDialog, dialog, npc);
}
finally
{
_errorCollection.CurrentErrorContext = "";
}
return(code);
}
public async Task <IActionResult> FlexFieldObjects(string parentId, int start, int pageSize)
{
Task <List <T> > queryTask;
Task <int> countTask;
if (string.IsNullOrEmpty(parentId))
{
GoNorthProject project = await _projectDbAccess.GetDefaultProject();
queryTask = _objectDbAccess.GetFlexFieldObjectsInRootFolderForProject(project.Id, start, pageSize);
countTask = _objectDbAccess.GetFlexFieldObjectsInRootFolderCount(project.Id);
}
else
{
queryTask = _objectDbAccess.GetFlexFieldObjectsInFolder(parentId, start, pageSize);
countTask = _objectDbAccess.GetFlexFieldObjectsInFolderCount(parentId);
}
Task.WaitAll(queryTask, countTask);
FlexFieldObjectQueryResult queryResult = new FlexFieldObjectQueryResult();
queryResult.FlexFieldObjects = queryTask.Result;
queryResult.HasMore = start + queryResult.FlexFieldObjects.Count < countTask.Result;
return(Ok(queryResult));
}
/// <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>
/// 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);
}
public async Task <IActionResult> Folders(string parentId, int start, int pageSize)
{
string folderName = string.Empty;
string parentFolderId = string.Empty;
Task <List <FlexFieldFolder> > queryTask;
Task <int> countTask;
if (string.IsNullOrEmpty(parentId))
{
GoNorthProject project = await _projectDbAccess.GetDefaultProject();
queryTask = _folderDbAccess.GetRootFoldersForProject(project.Id, start, pageSize);
countTask = _folderDbAccess.GetRootFolderCount(project.Id);
}
else
{
FlexFieldFolder folder = await _folderDbAccess.GetFolderById(parentId);
parentFolderId = folder.ParentFolderId;
folderName = folder.Name;
queryTask = _folderDbAccess.GetChildFolders(parentId, start, pageSize);
countTask = _folderDbAccess.GetChildFolderCount(parentId);
}
Task.WaitAll(queryTask, countTask);
FolderQueryResult queryResult = new FolderQueryResult();
queryResult.FolderName = folderName;
queryResult.ParentId = parentFolderId;
queryResult.Folders = queryTask.Result;
queryResult.HasMore = start + queryResult.Folders.Count < countTask.Result;
return(Ok(queryResult));
}
/// <summary>
/// Fills the placeholders of a code
/// </summary>
/// <param name="code">Code to fill</param>
/// <param name="data">Export Data</param>
/// <returns>Filled Code</returns>
public async Task <string> FillPlaceholders(string code, ExportObjectData data)
{
// Check Data
if (!data.ExportData.ContainsKey(ExportConstants.ExportDataObject))
{
return(code);
}
KortistoNpc npc = data.ExportData[ExportConstants.ExportDataObject] as KortistoNpc;
if (npc != null)
{
// Replace Dialog Placeholders
return(await FillDialogPlaceholders(code, npc));
}
ExportDialogFunctionCode dialogFunction = data.ExportData[ExportConstants.ExportDataObject] as ExportDialogFunctionCode;
if (dialogFunction != null)
{
// Replace Dialog Function
GoNorthProject project = await _cachedDbAccess.GetUserProject();
return(await RenderDialogFunction(project, dialogFunction));
}
return(code);
}
/// <summary>
/// Renders the dialog
/// </summary>
/// <param name="project">Current Project</param>
/// <param name="code">Template code</param>
/// <param name="exportDialog">Export dialog data</param>
/// <param name="dialog">Dialog</param>
/// <param name="npc">Npc to which the dialog belongs</param>
/// <returns>Filled code</returns>
private async Task <string> RenderDialog(GoNorthProject project, string code, ExportDialogData exportDialog, TaleDialog dialog, KortistoNpc npc)
{
if (exportDialog == null)
{
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Start).Replace(code, string.Empty);
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Additional_Functions).Replace(code, string.Empty);
return(code);
}
List <ExportDialogFunctionCode> dialogRenderResult = await _dialogRenderer.RenderDialogSteps(exportDialog, npc);
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Start, ExportConstants.ListIndentPrefix).Replace(code, m => {
if (dialogRenderResult.Any())
{
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(dialogRenderResult[0].Code, m.Groups[1].Value)));
}
return(string.Empty);
});
code = await ExportUtil.BuildPlaceholderRegex(Placeholder_Additional_Functions, ExportConstants.ListIndentPrefix).ReplaceAsync(code, async m => {
string finalCode = string.Empty;
foreach (ExportDialogFunctionCode curFunction in dialogRenderResult.Skip(1))
{
finalCode += await RenderFunctionForList(project, curFunction);
}
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(finalCode, m.Groups[1].Value)));
});
return(code);
}
/// <summary>
/// Ensures that the project is loaded
/// </summary>
/// <returns>Task</returns>
private async Task EnsureProject()
{
if (_project == null)
{
_project = await _projectDbAccess.GetDefaultProject();
}
}
/// <summary>
/// Builds the function list
/// </summary>
/// <param name="functionCode">Code for the functions to repeat</param>
/// <param name="project">Project to export for</param>
/// <param name="npc">Npc</param>
/// <returns>Daily Routine function list of the npc</returns>
private string BuildFunctionList(string functionCode, GoNorthProject project, KortistoNpc npc)
{
if (npc.DailyRoutine == null)
{
return(string.Empty);
}
SortDailyRoutine(npc.DailyRoutine);
int eventIndex = 0;
string eventListCode = string.Empty;
foreach (KortistoNpcDailyRoutineEvent curEvent in npc.DailyRoutine)
{
string curEventCode = ExportUtil.BuildPlaceholderRegex(Placeholder_CurEvent_Index).Replace(functionCode, eventIndex.ToString());
try
{
_errorCollection.CurrentErrorContext = _localizer["DailyRoutineErrorContext", curEvent.EarliestTime.Hours.ToString().PadLeft(2, '0'), curEvent.EarliestTime.Minutes.ToString().PadLeft(2, '0')].Value;
curEventCode = _eventContentPlaceholderResolver.ResolveDailyRoutineEventContentPlaceholders(curEventCode, npc, curEvent, _errorCollection);
curEventCode = _eventPlaceholderResolver.ResolveDailyRoutineEventPlaceholders(curEventCode, npc, curEvent).Result;
}
finally
{
_errorCollection.CurrentErrorContext = string.Empty;
}
eventListCode += curEventCode;
++eventIndex;
}
return(eventListCode);
}
/// <summary>
/// Returns the operator from the template of the action
/// </summary>
/// <param name="project">Project</param>
/// <param name="actionOperator">Action Operator</param>
/// <param name="errorCollection">Error Collection</param>
/// <returns>Action Operator</returns>
private async Task <string> GetOperatorFromTemplate(GoNorthProject project, string actionOperator, ExportPlaceholderErrorCollection errorCollection)
{
if (actionOperator == null)
{
actionOperator = string.Empty;
}
switch (actionOperator.ToLowerInvariant())
{
case "=":
return((await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralChangeOperatorAssign)).Code);
case "+=":
return((await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralChangeOperatorAddTo)).Code);
case "-=":
return((await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralChangeOperatorSubstractFrom)).Code);
case "*=":
return((await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralChangeOperatorMultiply)).Code);
case "/=":
return((await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.GeneralChangeOperatorDivide)).Code);
}
errorCollection.AddDialogUnknownActionOperator(actionOperator);
return(string.Empty);
}
/// <summary>
/// Parses a dialog
/// </summary>
/// <param name="inputNpc">Input npc</param>
/// <param name="project">Project</param>
/// <param name="dialog">Dialog</param>
/// <returns>Export dialog data</returns>
private async Task <ExportDialogData> ParseDialog(KortistoNpc inputNpc, GoNorthProject project, TaleDialog dialog)
{
ExportDialogData parsedDialog = null;
IStringLocalizer localizer = _localizerFactory.Create(typeof(DialogValueCollector));
try
{
_errorCollection.CurrentErrorContext = localizer["DialogErrorContext"].Value;
_dialogParser.SetErrorCollection(_errorCollection);
_dialogRenderer.SetErrorCollection(_errorCollection);
bool hasValidDialog = SharedDialogExportUtil.HasValidDialog(dialog);
if (hasValidDialog)
{
parsedDialog = _dialogParser.ParseDialog(dialog);
if (parsedDialog != null)
{
parsedDialog = await _dialogFunctionGenerator.GenerateFunctions(project.Id, inputNpc.Id, parsedDialog, _errorCollection);
}
}
}
finally
{
_errorCollection.CurrentErrorContext = "";
}
return(parsedDialog);
}
/// <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));
}
public async Task <IActionResult> Page(string id)
{
KirjaPage page = null;
if (!string.IsNullOrEmpty(id))
{
page = await _pageDbAccess.GetPageById(id);
}
else
{
GoNorthProject project = await _projectDbAccess.GetDefaultProject();
page = await _pageDbAccess.GetDefaultPageForProject(project.Id);
if (page == null)
{
page = new KirjaPage();
page.IsDefault = true;
page.ProjectId = project.Id;
page.Name = _localizer["DefaultPageName"];
page.Content = _localizer["DefaultPageContent"];
_pageParserService.ParsePage(page);
page = await _pageDbAccess.CreatePage(page);
}
}
return(Ok(page));
}
/// <summary>
/// Returns the npc use
/// </summary>
/// <param name="flexFieldObject">Flex field object</param>
/// <param name="parsedData">Parsed data</param>
/// <param name="errorCollection">Error Collection</param>
/// <returns>Value Object</returns>
private async Task <IFlexFieldExportable> GetNpc(FlexFieldObject flexFieldObject, UseItemActionRenderer.UseItemActionData parsedData, ExportPlaceholderErrorCollection errorCollection)
{
if (_isPickNpc)
{
KortistoNpc npc = await _cachedDbAccess.GetNpcById(parsedData.NpcId);
if (npc == null)
{
errorCollection.AddDialogItemNotFoundError();
return(null);
}
return(npc);
}
else if (_isPlayer)
{
GoNorthProject curProject = await _cachedDbAccess.GetDefaultProject();
KortistoNpc npc = await _cachedDbAccess.GetPlayerNpc(curProject.Id);
if (npc == null)
{
errorCollection.AddNoPlayerNpcExistsError();
return(null);
}
return(npc);
}
return(flexFieldObject);
}
public async Task <IActionResult> CreatePage([FromBody] PageRequest page)
{
if (string.IsNullOrEmpty(page.Name))
{
return(StatusCode((int)HttpStatusCode.BadRequest));
}
try
{
GoNorthProject project = await _projectDbAccess.GetDefaultProject();
KirjaPage newPage = new KirjaPage();
newPage.ProjectId = project.Id;
newPage.Name = page.Name;
newPage.Content = page.Content;
newPage.Attachments = new List <KirjaPageAttachment>();
_pageParserService.ParsePage(newPage);
await this.SetModifiedData(_userManager, newPage);
newPage = await _pageDbAccess.CreatePage(newPage);
await _timelineService.AddTimelineEntry(TimelineEvent.KirjaPageCreated, newPage.Name, newPage.Id);
return(Ok(newPage));
}
catch (Exception ex)
{
_logger.LogError(ex, "Could not create page {0}", page.Name);
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
/// <summary>
/// Builds a single condition element
/// </summary>
/// <param name="project">Project</param>
/// <param name="condition">Current Condition</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="flexFieldObject">FlexField to which the dialog belongs</param>
/// <param name="exportSettings">Export Settings</param>
/// <returns>Condition Build Result</returns>
private async Task <string> BuildSingleConditionElement(GoNorthProject project, ParsedConditionData condition, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
ConditionType conditionType = (ConditionType)condition.ConditionType;
if (!_elementRenderes.ContainsKey(conditionType))
{
errorCollection.AddDialogUnknownConditionTypeError(condition.ConditionType);
return(string.Empty);
}
string oldContext = errorCollection.CurrentErrorContext;
errorCollection.CurrentErrorContext = _localizer["ErrorContextCondition", _conditionTranslator.TranslateConditionType(conditionType)];
try
{
return(await _elementRenderes[conditionType].BuildSingleConditionElement(condition, project, errorCollection, flexFieldObject, exportSettings));
}
catch (Exception ex)
{
errorCollection.AddException(ex);
return("<<ERROR_RENDERING_CONDITION>>");
}
finally
{
errorCollection.CurrentErrorContext = oldContext;
}
}
public async Task <IActionResult> SaveExportSettings([FromBody] ExportSettings exportSettings)
{
GoNorthProject project = await _projectDbAccess.GetDefaultProject();
ExportSettings loadedExportSettings = await _exportSettingsDbAccess.GetExportSettings(project.Id);
loadedExportSettings.ScriptExtension = exportSettings.ScriptExtension;
loadedExportSettings.ScriptLanguage = exportSettings.ScriptLanguage;
loadedExportSettings.EscapeCharacter = exportSettings.EscapeCharacter;
loadedExportSettings.CharactersNeedingEscaping = exportSettings.CharactersNeedingEscaping;
loadedExportSettings.NewlineCharacter = exportSettings.NewlineCharacter;
loadedExportSettings.LanguageFileExtension = exportSettings.LanguageFileExtension;
loadedExportSettings.LanguageFileLanguage = exportSettings.LanguageFileLanguage;
loadedExportSettings.LanguageEscapeCharacter = exportSettings.LanguageEscapeCharacter;
loadedExportSettings.LanguageCharactersNeedingEscaping = exportSettings.LanguageCharactersNeedingEscaping;
loadedExportSettings.LanguageNewlineCharacter = exportSettings.LanguageNewlineCharacter;
await this.SetModifiedData(_userManager, loadedExportSettings);
await _exportSettingsDbAccess.SaveExportSettings(project.Id, loadedExportSettings);
await _timelineService.AddTimelineEntry(TimelineEvent.ExportSettingsUpdated);
return(Ok());
}
public async Task <IActionResult> CreateChapterDetail([FromBody] AikaChapterDetail chapterDetail)
{
GoNorthProject defaultProject = await _projectDbAccess.GetDefaultProject();
AikaChapterDetail newChapterDetail = new AikaChapterDetail();
newChapterDetail.ProjectId = defaultProject.Id;
newChapterDetail.ChapterId = string.Empty;
newChapterDetail.Name = chapterDetail.Name;
CopyValidChapterDetailProperties(newChapterDetail, chapterDetail);
await this.SetModifiedData(_userManager, newChapterDetail);
bool detailSuccess = await CreateDetailsForDetail(defaultProject, newChapterDetail);
if (!detailSuccess)
{
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
newChapterDetail = await _chapterDetailDbAccess.CreateChapterDetail(newChapterDetail);
// Timeline Entry
await _timelineService.AddTimelineEntry(TimelineEvent.AikaChapterDetailCreated, newChapterDetail.Id);
return(Ok(newChapterDetail));
}
public async Task <IActionResult> CreateFolder([FromBody] FolderRequest folder)
{
if (string.IsNullOrEmpty(folder.Name))
{
return(StatusCode((int)HttpStatusCode.BadRequest));
}
try
{
GoNorthProject project = await _projectDbAccess.GetDefaultProject();
FlexFieldFolder newFolder = new FlexFieldFolder {
ProjectId = project.Id,
ParentFolderId = folder.ParentId,
Name = folder.Name,
Description = folder.Description
};
newFolder = await _folderDbAccess.CreateFolder(newFolder);
await _timelineService.AddTimelineEntry(FolderCreatedEvent, folder.Name);
return(Ok(newFolder.Id));
}
catch (Exception ex)
{
_logger.LogError(ex, "Could not create folder {0}", folder.Name);
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
public async Task <IActionResult> GetQuests(string searchPattern, int start, int pageSize)
{
GoNorthProject project = await _projectDbAccess.GetDefaultProject();
Task <List <AikaQuest> > queryTask;
Task <int> countTask;
if (string.IsNullOrEmpty(searchPattern))
{
queryTask = _questDbAccess.GetQuestsByProjectId(project.Id, start, pageSize);
countTask = _questDbAccess.GetQuestsByProjectIdCount(project.Id);
}
else
{
queryTask = _questDbAccess.SearchQuests(project.Id, searchPattern, start, pageSize);
countTask = _questDbAccess.SearchQuestsCount(project.Id, searchPattern);
}
Task.WaitAll(queryTask, countTask);
QuestQueryResult queryResult = new QuestQueryResult();
queryResult.Quests = queryTask.Result;
queryResult.HasMore = start + queryResult.Quests.Count < countTask.Result;
return(Ok(queryResult));
}
/// <summary>
/// Fills the task board history
/// </summary>
/// <param name="response">Response to send</param>
/// <param name="currentUser">Current user</param>
/// <returns>Task</returns>
private async Task FillTaskBoardHistory(PersonalDataResponse response, GoNorthUser currentUser)
{
response.TaskBoardHistory = new List <TrimmedTaskBoardHistory>();
List <UserTaskBoardHistory> taskBoardHistory = await _userTaskBoardHistoryDbAccess.GetAllOpenedBoardsOfUser(currentUser.Id);
foreach (UserTaskBoardHistory curTaskBoard in taskBoardHistory)
{
TrimmedTaskBoardHistory curTaskBoardHistory = new TrimmedTaskBoardHistory();
curTaskBoardHistory.BoardName = "DELETED";
curTaskBoardHistory.Project = "DELETED";
TaskBoard taskBoard = await _taskBoardDbAccess.GetTaskBoardById(curTaskBoard.LastOpenBoardId);
if (taskBoard != null)
{
curTaskBoardHistory.BoardName = taskBoard.Name;
}
GoNorthProject project = await _projectDbAccess.GetProjectById(curTaskBoard.ProjectId);
if (project != null)
{
curTaskBoardHistory.Project = project.Name;
}
response.TaskBoardHistory.Add(curTaskBoardHistory);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="exportCachedDbAccess">Export cached Db access</param>
/// <param name="exportSettings">Export Settings</param>
/// <param name="conditionRenderer">Condition Renderer</param>
/// <param name="localizerFactory">Localizer Factory</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="project">Project</param>
public ScribanConditionStepRenderer(IExportCachedDbAccess exportCachedDbAccess, ExportSettings exportSettings, ExportPlaceholderErrorCollection errorCollection, IConditionRenderer conditionRenderer, IStringLocalizerFactory localizerFactory, GoNorthProject project) :
base(errorCollection, exportSettings, localizerFactory)
{
_exportCachedDbAccess = exportCachedDbAccess;
_conditionRenderer = conditionRenderer;
_project = project;
}
/// <summary>
/// Configures the project
/// </summary>
/// <returns>Task</returns>
private static async Task ConfigureProject()
{
ServiceProvider serviceProvider = ServiceProviderBuilder.BuildServiceProvider();
IProjectDbAccess projectDbAccess = serviceProvider.GetService <IProjectDbAccess>();
GoNorthProject defaultProject = await projectDbAccess.GetDefaultProject();
if (defaultProject != null)
{
MessageService.PrintDefaultProjectExistMessage();
return;
}
try
{
string displayName = MessageService.GetDefaultProjectName();
GoNorthProject projectToCreate = new GoNorthProject
{
Name = displayName,
IsDefault = true
};
await projectDbAccess.CreateProject(projectToCreate);
MessageService.PrintSuccessCreatingDefaultProject();
}
catch (Exception ex)
{
MessageService.PrintErrorCreatingDefaultProject(ex);
}
}
public async Task <IActionResult> SaveJsonConfigByKey(string configKey)
{
string configData = string.Empty;
using (StreamReader reader = new StreamReader(Request.Body))
{
configData = reader.ReadToEnd();
}
GoNorthProject project = await _projectDbAccess.GetDefaultProject();
JsonConfigEntry configEntry = await _projectConfigDbAccess.GetJsonConfigByKey(project.Id, configKey);
if (configEntry != null)
{
await this.SetModifiedData(_userManager, configEntry);
configEntry.ConfigData = configData;
await _projectConfigDbAccess.UpdateJsonConfig(configEntry);
}
else
{
configEntry = new JsonConfigEntry();
configEntry.ProjectId = project.Id;
configEntry.Key = configKey;
configEntry.ConfigData = configData;
await this.SetModifiedData(_userManager, configEntry);
await _projectConfigDbAccess.CreateJsonConfig(configEntry);
}
return(Ok(configKey));
}
public async Task <IActionResult> DeleteProject(string id)
{
GoNorthProject project = await _projectDbAccess.GetProjectById(id);
if (project.IsDefault)
{
return(BadRequest(_localizer["ProjectIsDefaultProject"].Value));
}
bool isProjectEmpty = await IsProjectEmpty(project);
if (!isProjectEmpty)
{
_logger.LogInformation("Attempted to delete non empty project {0}.", project.Name);
return(BadRequest(_localizer["ProjectNotEmpty"].Value));
}
await _projectDbAccess.DeleteProject(project);
_logger.LogInformation("Project was deleted.");
await CleanUpAdditionalProjectData(project);
_logger.LogInformation("Additional project data was deleted.");
await _timelineService.AddTimelineEntry(null, TimelineEvent.ProjectDeleted, project.Name);
return(Ok(id));
}
public async Task <IActionResult> SaveMiscConfig([FromBody] TrimmedMiscConfig configData)
{
if (configData.HoursPerDay <= 0 || configData.MinutesPerHour <= 0)
{
return(BadRequest());
}
GoNorthProject project = await _projectDbAccess.GetDefaultProject();
MiscProjectConfig configEntry = await _projectConfigDbAccess.GetMiscConfig(project.Id);
if (configEntry != null)
{
await this.SetModifiedData(_userManager, configEntry);
configEntry.HoursPerDay = configData.HoursPerDay;
configEntry.MinutesPerHour = configData.MinutesPerHour;
await _projectConfigDbAccess.UpdateMiscConfig(configEntry);
}
else
{
configEntry = new MiscProjectConfig();
configEntry.ProjectId = project.Id;
configEntry.HoursPerDay = configData.HoursPerDay;
configEntry.MinutesPerHour = configData.MinutesPerHour;
await this.SetModifiedData(_userManager, configEntry);
await _projectConfigDbAccess.CreateMiscConfig(configEntry);
}
return(Ok(configData));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="errorCollection">Error Collection</param>
/// <param name="defaultTemplateProvider">Default Template Provider</param>
/// <param name="cachedDbAccess">Cached Db Access</param>
/// <param name="languageKeyGenerator">Language Key Generator</param>
/// <param name="localizerFactory">Localizer Factory</param>
/// <param name="exportSettings">Export Settings</param>
/// <param name="project">Project</param>
public ExportDialogActionRenderer(ExportPlaceholderErrorCollection errorCollection, ICachedExportDefaultTemplateProvider defaultTemplateProvider, IExportCachedDbAccess cachedDbAccess,
ILanguageKeyGenerator languageKeyGenerator, IStringLocalizerFactory localizerFactory, ExportSettings exportSettings, GoNorthProject project) :
base(errorCollection, localizerFactory)
{
_defaultTemplateProvider = defaultTemplateProvider;
_languageKeyGenerator = languageKeyGenerator;
_localizer = localizerFactory.Create(typeof(ExportDialogActionRenderer));
_exportSettings = exportSettings;
_project = project;
_actionRenderes = new Dictionary <ActionType, IActionRenderer>();
_actionRenderes.Add(ActionType.ChangePlayerValue, new NpcValueChangeRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, true));
_actionRenderes.Add(ActionType.ChangeNpcValue, new NpcValueChangeRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, false));
_actionRenderes.Add(ActionType.SpawnItemInPlayerInventory, new InventoryActionRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, true, false));
_actionRenderes.Add(ActionType.TransferItemToPlayerInventory, new InventoryActionRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, true, true));
_actionRenderes.Add(ActionType.SpawnItemInNpcInventory, new InventoryActionRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, false, false));
_actionRenderes.Add(ActionType.TransferItemToNpcInventory, new InventoryActionRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, false, true));
_actionRenderes.Add(ActionType.ChangeQuestValue, new QuestValueChangeRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory));
_actionRenderes.Add(ActionType.ChangeQuestState, new SetQuestStateActionRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory));
_actionRenderes.Add(ActionType.AddQuestText, new AddQuestTextRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory));
_actionRenderes.Add(ActionType.Wait, new WaitActionRenderer(defaultTemplateProvider, localizerFactory));
_actionRenderes.Add(ActionType.ChangePlayerState, new ChangeNpcStateActionRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, true));
_actionRenderes.Add(ActionType.ChangeNpcState, new ChangeNpcStateActionRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, false));
_actionRenderes.Add(ActionType.PlayerLearnSkill, new LearnForgetSkillActionRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, true, true));
_actionRenderes.Add(ActionType.PlayerForgetSkill, new LearnForgetSkillActionRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, true, false));
_actionRenderes.Add(ActionType.NpcLearnSkill, new LearnForgetSkillActionRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, false, true));
_actionRenderes.Add(ActionType.NpcForgetSkill, new LearnForgetSkillActionRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, false, false));
_actionRenderes.Add(ActionType.ChangePlayerSkillValue, new SkillValueChangeRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, true));
_actionRenderes.Add(ActionType.ChangeNpcSkillValue, new SkillValueChangeRenderer(defaultTemplateProvider, cachedDbAccess, languageKeyGenerator, localizerFactory, false));
_actionRenderes.Add(ActionType.PersistDialogState, new PersistDialogStateActionRenderer(defaultTemplateProvider));
_actionRenderes.Add(ActionType.OpenShop, new OpenShopActionRenderer(defaultTemplateProvider));
}
/// <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));
}
