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