コード例 #1
0
ファイル: UserDeleter.cs プロジェクト: sb-baifeng-sb/GoNorth
        /// <summary>
        /// Deletes the modified data for the user
        /// </summary>
        /// <param name="user">User</param>
        /// <returns>Task</returns>
        private async Task DeleteModifiedData(GoNorthUser user)
        {
            List <AikaQuest> quests = await _questDbAccess.GetQuestsByModifiedUser(user.Id);

            foreach (AikaQuest curQuest in quests)
            {
                curQuest.ModifiedBy = Guid.Empty.ToString();
                curQuest.ModifiedOn = DateTimeOffset.UtcNow;
                await _questDbAccess.UpdateQuest(curQuest);
            }

            List <AikaChapterDetail> chapterDetail = await _chapterDetailDbAccess.GetChapterDetailsByModifiedUser(user.Id);

            foreach (AikaChapterDetail curChapterDetail in chapterDetail)
            {
                curChapterDetail.ModifiedBy = Guid.Empty.ToString();
                curChapterDetail.ModifiedOn = DateTimeOffset.UtcNow;
                await _chapterDetailDbAccess.UpdateChapterDetail(curChapterDetail);
            }

            List <AikaChapterOverview> chapterOverview = await _chapterOverviewDbAccess.GetChapterOverviewByModifiedUser(user.Id);

            foreach (AikaChapterOverview curOverview in chapterOverview)
            {
                curOverview.ModifiedBy = Guid.Empty.ToString();
                curOverview.ModifiedOn = DateTimeOffset.UtcNow;
                await _chapterOverviewDbAccess.UpdateChapterOverview(curOverview);
            }

            List <EvneSkill> skills = await _skillDbAccess.GetFlexFieldObjectsByModifiedUser(user.Id);

            foreach (EvneSkill curSkill in skills)
            {
                curSkill.ModifiedBy = Guid.Empty.ToString();
                curSkill.ModifiedOn = DateTimeOffset.UtcNow;
                await _skillDbAccess.UpdateFlexFieldObject(curSkill);
            }

            List <KortistoNpc> npcs = await _npcDbAccess.GetFlexFieldObjectsByModifiedUser(user.Id);

            foreach (KortistoNpc curNpc in npcs)
            {
                curNpc.ModifiedBy = Guid.Empty.ToString();
                curNpc.ModifiedOn = DateTimeOffset.UtcNow;
                await _npcDbAccess.UpdateFlexFieldObject(curNpc);
            }

            List <StyrItem> items = await _itemDbAccess.GetFlexFieldObjectsByModifiedUser(user.Id);

            foreach (StyrItem curItem in items)
            {
                curItem.ModifiedBy = Guid.Empty.ToString();
                curItem.ModifiedOn = DateTimeOffset.UtcNow;
                await _itemDbAccess.UpdateFlexFieldObject(curItem);
            }

            List <ExportTemplate> exportTemplates = await _exportTemplateDbAccess.GetExportTemplatesByModifiedUser(user.Id);

            foreach (ExportTemplate curTemplate in exportTemplates)
            {
                curTemplate.ModifiedBy = Guid.Empty.ToString();
                curTemplate.ModifiedOn = DateTimeOffset.UtcNow;
                await _exportTemplateDbAccess.UpdateTemplate(curTemplate);
            }

            List <KartaMap> maps = await _mapDbAccess.GetMapsByModifiedUser(user.Id);

            foreach (KartaMap curMap in maps)
            {
                curMap.ModifiedBy = Guid.Empty.ToString();
                curMap.ModifiedOn = DateTimeOffset.UtcNow;
                await _mapDbAccess.UpdateMap(curMap);
            }

            List <KirjaPage> pages = await _pageDbAccess.GetPagesByModifiedUser(user.Id);

            foreach (KirjaPage curPage in pages)
            {
                curPage.ModifiedBy = Guid.Empty.ToString();
                curPage.ModifiedOn = DateTimeOffset.UtcNow;
                await _pageDbAccess.UpdatePage(curPage);
            }

            List <KirjaPageVersion> pageVersions = await _pageVersionDbAccess.GetPageVersionsByModifiedUser(user.Id);

            foreach (KirjaPageVersion curVersion in pageVersions)
            {
                curVersion.ModifiedBy = Guid.Empty.ToString();
                curVersion.ModifiedOn = DateTimeOffset.UtcNow;
                await _pageVersionDbAccess.UpdatePageVersion(curVersion);
            }

            List <TaleDialog> dialogs = await _taleDbAccess.GetDialogsByModifiedUser(user.Id);

            foreach (TaleDialog curDialog in dialogs)
            {
                curDialog.ModifiedBy = Guid.Empty.ToString();
                curDialog.ModifiedOn = DateTimeOffset.UtcNow;
                await _taleDbAccess.UpdateDialog(curDialog);
            }

            List <JsonConfigEntry> jsonConfigEntries = await _projectConfigDbAccess.GetJsonConfigEntriesByModifiedUser(user.Id);

            foreach (JsonConfigEntry curConfig in jsonConfigEntries)
            {
                curConfig.ModifiedBy = Guid.Empty.ToString();
                curConfig.ModifiedOn = DateTimeOffset.UtcNow;
                await _projectConfigDbAccess.UpdateJsonConfig(curConfig);
            }

            List <MiscProjectConfig> miscConfigEntries = await _projectConfigDbAccess.GetMiscConfigEntriesByModifiedUser(user.Id);

            foreach (MiscProjectConfig curMiscConfig in miscConfigEntries)
            {
                curMiscConfig.ModifiedBy = Guid.Empty.ToString();
                curMiscConfig.ModifiedOn = DateTimeOffset.UtcNow;
                await _projectConfigDbAccess.UpdateMiscConfig(curMiscConfig);
            }

            List <TaskBoard> taskBoards = await _taskBoardDbAccess.GetTaskBoardsByModifiedUser(user.Id);

            foreach (TaskBoard curBoard in taskBoards)
            {
                if (curBoard.ModifiedBy == user.Id)
                {
                    curBoard.ModifiedBy = Guid.Empty.ToString();
                    curBoard.ModifiedOn = DateTimeOffset.UtcNow;
                }

                List <TaskGroup> modifiedGroups = curBoard.TaskGroups.Where(t => t.ModifiedBy == user.Id).ToList();
                foreach (TaskGroup curTaskGroup in modifiedGroups)
                {
                    curTaskGroup.ModifiedBy = Guid.Empty.ToString();
                    curTaskGroup.ModifiedOn = DateTimeOffset.UtcNow;
                }

                List <GoNorthTask> tasks = curBoard.TaskGroups.SelectMany(p => p.Tasks.Where(t => t.ModifiedBy == user.Id)).ToList();
                if (tasks.Count > 0)
                {
                    foreach (GoNorthTask curTask in tasks)
                    {
                        curTask.ModifiedBy = Guid.Empty.ToString();
                        curTask.ModifiedOn = DateTimeOffset.UtcNow;
                    }
                }

                await _taskBoardDbAccess.UpdateTaskBoard(curBoard);
            }

            List <GoNorthTaskType> taskGroupTypes = await _taskGroupTypeDbAccess.GetTaskTypesByModifiedUser(user.Id);

            foreach (GoNorthTaskType curType in taskGroupTypes)
            {
                curType.ModifiedBy = Guid.Empty.ToString();
                curType.ModifiedOn = DateTimeOffset.UtcNow;
                await _taskGroupTypeDbAccess.UpdateTaskType(curType);
            }

            List <GoNorthTaskType> taskTypes = await _taskTypeDbAccess.GetTaskTypesByModifiedUser(user.Id);

            foreach (GoNorthTaskType curType in taskTypes)
            {
                curType.ModifiedBy = Guid.Empty.ToString();
                curType.ModifiedOn = DateTimeOffset.UtcNow;
                await _taskTypeDbAccess.UpdateTaskType(curType);
            }
        }
コード例 #2
0
        public async Task <IActionResult> SaveChapterOverview([FromBody] AikaChapterOverview overview)
        {
            // Check Data
            if (overview.Chapter == null)
            {
                overview.Chapter = new List <AikaChapter>();
            }

            if (overview.Link == null)
            {
                overview.Link = new List <NodeLink>();
            }

            // Get Current Overview
            GoNorthProject defaultProject = await _projectDbAccess.GetDefaultProject();

            AikaChapterOverview chapterOverview = await _chapterOverviewDbAccess.GetChapterOverviewByProjectId(defaultProject.Id);

            bool overviewExisted = true;
            List <AikaChapterDetail> chapterDetailsToDelete = new List <AikaChapterDetail>();
            List <AikaChapterDetail> chapterDetailsToRename = new List <AikaChapterDetail>();
            List <int> deletedChapterNumbers = new List <int>();

            if (chapterOverview == null)
            {
                chapterOverview           = new AikaChapterOverview();
                chapterOverview.ProjectId = defaultProject.Id;
                overviewExisted           = false;
            }
            else
            {
                // Check deleted chapter numbers
                deletedChapterNumbers = chapterOverview.Chapter.Where(c => !overview.Chapter.Any(uc => uc.ChapterNumber == c.ChapterNumber)).Select(c => c.ChapterNumber).ToList();

                // Check deleted chapters
                List <AikaChapter> deletedChapters = chapterOverview.Chapter.Where(c => !overview.Chapter.Any(uc => uc.Id == c.Id)).ToList();
                foreach (AikaChapter curDeletedChapter in deletedChapters)
                {
                    if (string.IsNullOrEmpty(curDeletedChapter.DetailViewId))
                    {
                        continue;
                    }

                    AikaChapterDetail deletedChapterDetail = await _chapterDetailDbAccess.GetChapterDetailById(curDeletedChapter.DetailViewId);

                    if ((deletedChapterDetail.Detail != null && deletedChapterDetail.Detail.Count > 0) ||
                        (deletedChapterDetail.Quest != null && deletedChapterDetail.Quest.Count > 0) ||
                        (deletedChapterDetail.AllDone != null && deletedChapterDetail.AllDone.Count > 0) ||
                        (deletedChapterDetail.Finish != null && deletedChapterDetail.Finish.Count > 0))
                    {
                        _logger.LogInformation("Tried to delete non empty chapter");
                        return(StatusCode((int)HttpStatusCode.BadRequest, _localizer["CanNotDeleteNonEmptyChapter"].Value));
                    }

                    chapterDetailsToDelete.Add(deletedChapterDetail);
                }

                // Check renamed chapters
                List <AikaChapter> renamedChapters = overview.Chapter.Where(c => chapterOverview.Chapter.Any(uc => uc.Id == c.Id && uc.Name != c.Name)).ToList();
                foreach (AikaChapter curRenamedChapter in renamedChapters)
                {
                    if (string.IsNullOrEmpty(curRenamedChapter.DetailViewId))
                    {
                        continue;
                    }

                    AikaChapterDetail renamedChapterDetail = await _chapterDetailDbAccess.GetChapterDetailById(curRenamedChapter.DetailViewId);

                    renamedChapterDetail.Name = curRenamedChapter.Name;
                    chapterDetailsToRename.Add(renamedChapterDetail);
                }
            }

            // Update Data
            chapterOverview.Link    = overview.Link != null ? overview.Link : new List <NodeLink>();
            chapterOverview.Chapter = overview.Chapter != null ? overview.Chapter : new List <AikaChapter>();

            // Create Detail Views
            _logger.LogInformation("Creating chapter detail views");
            bool errorOccured = false;
            List <AikaChapterDetail> createdChapterDetails = new List <AikaChapterDetail>();

            foreach (AikaChapter curChapter in chapterOverview.Chapter)
            {
                if (string.IsNullOrEmpty(curChapter.DetailViewId))
                {
                    try
                    {
                        AikaChapterDetail newChapterDetail = await CreateNewChapterDetail(defaultProject.Id, curChapter.Id, curChapter.Name);

                        curChapter.DetailViewId = newChapterDetail.Id;
                        createdChapterDetails.Add(newChapterDetail);
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, "Could not create chapter detail view.");
                        errorOccured = true;
                        break;
                    }
                }
            }

            // Rollback on error
            if (errorOccured)
            {
                foreach (AikaChapterDetail curDetail in createdChapterDetails)
                {
                    await _chapterDetailDbAccess.DeleteChapterDetail(curDetail);
                }
                return(StatusCode((int)HttpStatusCode.InternalServerError));
            }

            // Save Chapter overview
            await this.SetModifiedData(_userManager, chapterOverview);

            if (overviewExisted)
            {
                await _chapterOverviewDbAccess.UpdateChapterOverview(chapterOverview);
            }
            else
            {
                chapterOverview = await _chapterOverviewDbAccess.CreateChapterOverview(chapterOverview);
            }

            // Rename Chapter details
            foreach (AikaChapterDetail curRenamedChapter in chapterDetailsToRename)
            {
                await _chapterDetailDbAccess.UpdateChapterDetail(curRenamedChapter);
            }

            // Remove Chapter Details for deleted chapters
            foreach (AikaChapterDetail curDeletedChapterDetail in chapterDetailsToDelete)
            {
                await _chapterDetailDbAccess.DeleteChapterDetail(curDeletedChapterDetail);
            }

            // Adjust Aika markers for deleted chapters
            int minChapterNumber = chapterOverview.Chapter.Min(c => c.ChapterNumber);
            int maxChapterNumber = chapterOverview.Chapter.Max(c => c.ChapterNumber);

            foreach (int curChapterNumber in deletedChapterNumbers)
            {
                await AdjustKartaMapMarkersForDeletedChapter(defaultProject.Id, curChapterNumber, minChapterNumber, maxChapterNumber, chapterOverview.Chapter);
            }

            // Timeline Entry
            await _timelineService.AddTimelineEntry(TimelineEvent.AikaChapterOverviewUpdated);

            return(Ok(chapterOverview));
        }