Example #1
0
        /// <summary>
        /// Fills the modified data for the response
        /// </summary>
        /// <param name="response">Response to send</param>
        /// <param name="currentUser">Current user</param>
        /// <returns>Task</returns>
        private async Task FillModifiedData(PersonalDataResponse response, GoNorthUser currentUser)
        {
            response.ModifiedData = new List <TrimmedModifiedData>();

            List <AikaQuest> quests = await _questDbAccess.GetQuestsByModifiedUser(currentUser.Id);

            response.ModifiedData.AddRange(quests.Select(p => new TrimmedModifiedData {
                ObjectType   = "Quest",
                Name         = p.Name,
                ModifiedDate = p.ModifiedOn
            }));

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

            response.ModifiedData.AddRange(chapterDetail.Select(p => new TrimmedModifiedData {
                ObjectType   = "ChapterDetail",
                Name         = p.Name,
                ModifiedDate = p.ModifiedOn
            }));

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

            response.ModifiedData.AddRange(chapterOverview.Select(p => new TrimmedModifiedData {
                ObjectType   = "ChapterOverview",
                Name         = "ChapterOverview",
                ModifiedDate = p.ModifiedOn
            }));

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

            response.ModifiedData.AddRange(skills.Select(p => new TrimmedModifiedData {
                ObjectType   = "Skill",
                Name         = p.Name,
                ModifiedDate = p.ModifiedOn
            }));

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

            response.ModifiedData.AddRange(npcs.Select(p => new TrimmedModifiedData {
                ObjectType   = "Npc",
                Name         = p.Name,
                ModifiedDate = p.ModifiedOn
            }));

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

            response.ModifiedData.AddRange(items.Select(p => new TrimmedModifiedData {
                ObjectType   = "Item",
                Name         = p.Name,
                ModifiedDate = p.ModifiedOn
            }));

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

            response.ModifiedData.AddRange(exportTemplates.Select(p => new TrimmedModifiedData {
                ObjectType   = "ExportTemplate",
                Name         = "Template " + p.TemplateType.ToString() + " " + p.Category.ToString(),
                ModifiedDate = p.ModifiedOn
            }));

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

            response.ModifiedData.AddRange(maps.Select(p => new TrimmedModifiedData {
                ObjectType   = "Map",
                Name         = p.Name,
                ModifiedDate = p.ModifiedOn
            }));

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

            response.ModifiedData.AddRange(pages.Select(p => new TrimmedModifiedData {
                ObjectType   = "WikiPage",
                Name         = p.Name,
                ModifiedDate = p.ModifiedOn
            }));

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

            response.ModifiedData.AddRange(pageVersions.Select(p => new TrimmedModifiedData {
                ObjectType   = "WikiPageVersion",
                Name         = string.Format("{0} #{1}", p.Name, p.VersionNumber),
                ModifiedDate = p.ModifiedOn
            }));

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

            Dictionary <string, KortistoNpc> dialogNpcs = (await _npcDbAccess.ResolveFlexFieldObjectNames(dialogs.Select(n => n.RelatedObjectId).ToList())).ToDictionary(n => n.Id);

            foreach (TaleDialog curDialog in dialogs)
            {
                string npcName = "DELETED";
                if (dialogNpcs.ContainsKey(curDialog.RelatedObjectId))
                {
                    npcName = dialogNpcs[curDialog.RelatedObjectId].Name;
                }
                response.ModifiedData.Add(new TrimmedModifiedData {
                    ObjectType   = "Dialog",
                    Name         = npcName,
                    ModifiedDate = curDialog.ModifiedOn
                });
            }

            List <TaleConfigEntry> taleConfigEntries = await _taleConfigDbAccess.GetConfigEntriesByModifiedUser(currentUser.Id);

            response.ModifiedData.AddRange(taleConfigEntries.Select(p => new TrimmedModifiedData {
                ObjectType   = "TaleConfig",
                Name         = p.Key,
                ModifiedDate = p.ModifiedOn
            }));

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

            foreach (TaskBoard curBoard in taskBoards)
            {
                if (curBoard.ModifiedBy == currentUser.Id)
                {
                    response.ModifiedData.Add(new TrimmedModifiedData {
                        ObjectType   = "TaskBoard",
                        Name         = curBoard.Name,
                        ModifiedDate = curBoard.ModifiedOn
                    });
                }

                List <TaskGroup> modifiedGroups = curBoard.TaskGroups.Where(t => t.ModifiedBy == currentUser.Id).ToList();
                if (modifiedGroups.Count > 0)
                {
                    response.ModifiedData.AddRange(modifiedGroups.Select(p => new TrimmedModifiedData {
                        ObjectType   = "TaskGroup",
                        Name         = p.Name,
                        ModifiedDate = p.ModifiedOn
                    }));
                }

                List <GoNorthTask> tasks = curBoard.TaskGroups.SelectMany(p => p.Tasks.Where(t => t.ModifiedBy == currentUser.Id)).ToList();
                if (tasks.Count > 0)
                {
                    response.ModifiedData.AddRange(tasks.Select(p => new TrimmedModifiedData {
                        ObjectType   = "Task",
                        Name         = p.Name,
                        ModifiedDate = p.ModifiedOn
                    }));
                }
            }

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

            response.ModifiedData.AddRange(taskGroupTypes.Select(p => new TrimmedModifiedData {
                ObjectType   = "TaskGroupType",
                Name         = p.Name,
                ModifiedDate = p.ModifiedOn
            }));

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

            response.ModifiedData.AddRange(taskTypes.Select(p => new TrimmedModifiedData {
                ObjectType   = "TaskType",
                Name         = p.Name,
                ModifiedDate = p.ModifiedOn
            }));
        }
Example #2
0
        /// <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 <TaleConfigEntry> taleConfigEntries = await _taleConfigDbAccess.GetConfigEntriesByModifiedUser(user.Id);

            foreach (TaleConfigEntry curConfig in taleConfigEntries)
            {
                curConfig.ModifiedBy = Guid.Empty.ToString();
                curConfig.ModifiedOn = DateTimeOffset.UtcNow;
                await _taleConfigDbAccess.UpdateConfig(curConfig);
            }

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