예제 #1
0
        /// <summary>
        /// Checks the references of a map if it can be deleted
        /// </summary>
        /// <param name="id">Id of the map</param>
        /// <returns>Error message if it can not be deleted, else null</returns>
        private async Task<string> CheckMapReferencesForDeletion(string id) 
        {
            List<KartaMap> kartaMaps = await _mapDbAccess.GetAllMapsMapIsMarkedIn(id);
            if(kartaMaps.Count > 0)
            {
                string markedInMaps = string.Join(", ", kartaMaps.Select(p => p.Name));
                return _localizer["CanNotDeleteMapMarkedInKartaMap", markedInMaps].Value;
            }

            List<TaleDialog> taleDialogs = await _taleDbAccess.GetDialogsObjectIsReferenced(id);
            if(taleDialogs.Count > 0)
            {
                List<KortistoNpc> npcs = await _kortistoNpcDbAccess.ResolveFlexFieldObjectNames(taleDialogs.Select(t => t.RelatedObjectId).ToList());
                string referencedInDialogs = string.Join(", ", npcs.Select(n => n.Name));
                return _localizer["CanNotDeleteMapReferencedInTaleDialog", referencedInDialogs].Value;
            }

            List<KortistoNpc> usedNpcs = await _kortistoNpcDbAccess.GetNpcsObjectIsReferencedInDailyRoutine(id);
            if(usedNpcs.Count > 0)
            {
                string referencedInNpcs = string.Join(", ", usedNpcs.Select(p => p.Name));
                return _localizer["CanNotDeleteMapReferencedInNpc", referencedInNpcs].Value;
            }

            List<AikaQuest> aikaQuests = await _questDbAccess.GetQuestsObjectIsReferenced(id);
            if(aikaQuests.Count > 0)
            {
                string referencedInQuests = string.Join(", ", aikaQuests.Select(p => p.Name));
                return _localizer["CanNotDeleteMapReferencedInAikaQuest", referencedInQuests].Value;
            }

            List<EvneSkill> referencedInSkills = await _skillDbAccess.GetSkillsObjectIsReferencedIn(id);
            if(referencedInSkills.Count > 0)
            {
                string usedInSkills = string.Join(", ", referencedInSkills.Select(m => m.Name));
                return _localizer["CanNotDeleteMapReferencedInSkill", usedInSkills].Value;
            }

            List<ObjectExportSnippet> referencedInSnippets = await _objectExportSnippetDbAccess.GetExportSnippetsObjectIsReferenced(id);
            if(referencedInSnippets.Count > 0)
            {
                List<ObjectExportSnippetReference> references = await _exportSnippetRelatedObjectNameResolver.ResolveExportSnippetReferences(referencedInSnippets, true, true, true);
                string usedInDailyRoutines = string.Join(", ", references.Select(m => string.Format("{0} ({1})", m.ObjectName, m.ExportSnippet)));
                return _localizer["CanNotDeleteMapReferencedInExportSnippet", usedInDailyRoutines].Value;
            }

            List<StateMachine> referencedInStateMachine = await _stateMachineDbAccess.GetStateMachinesObjectIsReferenced(id);
            if(referencedInStateMachine.Count > 0)
            {
                List<KortistoNpc> npcs = await _kortistoNpcDbAccess.ResolveFlexFieldObjectNames(referencedInStateMachine.Select(t => t.RelatedObjectId).ToList());
                List<KortistoNpc> npcTemplates = await _npcTemplateDbAccess.ResolveFlexFieldObjectNames(referencedInStateMachine.Select(t => t.RelatedObjectId).ToList());
                string usedInStateMachines = string.Join(", ", npcs.Union(npcTemplates).Select(n => n.Name));
                return _localizer["CanNotDeleteMapReferencedInStateMachines", usedInStateMachines].Value;
            }

            return null;
        }
        public async Task <IActionResult> GetStateMachineObjectIsReferenced(string objectId)
        {
            List <StateMachine> stateMachines = await _stateMachineDbAccess.GetStateMachinesObjectIsReferenced(objectId);

            List <KortistoNpc> npcs = await _npcDbAccess.ResolveFlexFieldObjectNames(stateMachines.Select(d => d.RelatedObjectId).ToList());

            List <KortistoNpc> npcTemplates = await _npcTemplateDbAccess.ResolveFlexFieldObjectNames(stateMachines.Select(d => d.RelatedObjectId).ToList());

            Dictionary <string, string>    npcNames         = npcs.ToDictionary(n => n.Id, n => n.Name);
            Dictionary <string, string>    npcTemplateNames = npcTemplates.ToDictionary(n => n.Id, n => n.Name);
            List <ObjectReferenceWithType> objectReferences = stateMachines.SelectMany(d => {
                ObjectReferenceType?referenceType = null;
                string objectName = string.Empty;
                if (npcNames.ContainsKey(d.RelatedObjectId))
                {
                    referenceType = ObjectReferenceType.Npc;
                    objectName    = npcNames[d.RelatedObjectId];
                }
                else if (npcTemplateNames.ContainsKey(d.RelatedObjectId))
                {
                    referenceType = ObjectReferenceType.NpcTemplate;
                    objectName    = npcTemplateNames[d.RelatedObjectId];
                }
                else
                {
                    return(new List <ObjectReferenceWithType>());
                }

                return(d.State.Where(s => s.ScriptNodeGraph != null).Select(s => {
                    ObjectReference objRef = _referenceAnalyzer.BuildObjectReferences(objectId, d.RelatedObjectId, objectName, s.ScriptNodeGraph.Action, s.ScriptNodeGraph.Condition, s.ScriptNodeGraph.Reference, null);
                    ObjectReferenceWithType refWithType = ObjectReferenceWithType.FromObjectReference(objRef, referenceType.Value);
                    return refWithType;
                }).Where(r => r.DetailedReferences.Any()).ToList());
            }).ToList();

            return(Ok(objectReferences));
        }
예제 #3
0
        /// <summary>
        /// Checks if a object is referenced before a delete
        /// </summary>
        /// <param name="id">Id</param>
        /// <returns>Empty string if no references exists, error string if references exists</returns>
        protected override async Task <string> CheckObjectReferences(string id)
        {
            List <AikaQuest> aikaQuests = await _aikaQuestDbAccess.GetQuestsObjectIsReferenced(id);

            if (aikaQuests.Count > 0)
            {
                string referencedInQuests = string.Join(", ", aikaQuests.Select(p => p.Name));
                return(_localizer["CanNotDeleteItemReferencedInAikaQuest", referencedInQuests].Value);
            }

            List <KirjaPage> kirjaPages = await _kirjaPageDbAccess.GetPagesByItem(id);

            if (kirjaPages.Count > 0)
            {
                string mentionedInPages = string.Join(", ", kirjaPages.Select(p => p.Name));
                return(_localizer["CanNotDeleteItemMentionedInKirjaPage", mentionedInPages].Value);
            }

            List <KartaMapMarkerQueryResult> kartaMaps = await _kartaMapDbAccess.GetAllMapsItemIsMarkedIn(id);

            if (kartaMaps.Count > 0)
            {
                string markedInMaps = string.Join(", ", kartaMaps.Select(m => m.Name));
                return(_localizer["CanNotDeleteItemMarkedInKartaMap", markedInMaps].Value);
            }

            List <TaleDialog> taleDialogs = await _taleDbAccess.GetDialogsObjectIsReferenced(id);

            taleDialogs = taleDialogs.Where(t => t.RelatedObjectId != id).ToList();
            if (taleDialogs.Count > 0)
            {
                List <KortistoNpc> npcs = await _kortistoNpcDbAccess.ResolveFlexFieldObjectNames(taleDialogs.Select(t => t.RelatedObjectId).ToList());

                string referencedInDialogs = string.Join(", ", npcs.Select(n => n.Name));
                return(_localizer["CanNotDeleteItemReferencedInTaleDialog", referencedInDialogs].Value);
            }

            List <KortistoNpc> inventoryNpcs = await _kortistoNpcDbAccess.GetNpcsByItemInInventory(id);

            if (inventoryNpcs.Count > 0)
            {
                string usedInInventories = string.Join(", ", inventoryNpcs.Select(n => n.Name));
                return(_localizer["CanNotDeleteItemUsedInInventory", usedInInventories].Value);
            }

            List <KortistoNpc> referencedInDailyRoutines = await _kortistoNpcDbAccess.GetNpcsObjectIsReferencedInDailyRoutine(id);

            if (referencedInDailyRoutines.Count > 0)
            {
                string usedInDailyRoutines = string.Join(", ", referencedInDailyRoutines.Select(m => m.Name));
                return(_localizer["CanNotDeleteItemUsedInDailyRoutine", usedInDailyRoutines].Value);
            }

            List <StateMachine> referencedInStateMachines = await _stateMachineDbAccess.GetStateMachinesObjectIsReferenced(id);

            if (referencedInStateMachines.Count > 0)
            {
                List <KortistoNpc> npcs = await _kortistoNpcDbAccess.ResolveFlexFieldObjectNames(referencedInStateMachines.Select(t => t.RelatedObjectId).ToList());

                List <KortistoNpc> npcTemplates = await _npcTemplateDbAccess.ResolveFlexFieldObjectNames(referencedInStateMachines.Select(t => t.RelatedObjectId).ToList());

                string usedInStateMachines = string.Join(", ", npcs.Union(npcTemplates).Select(n => n.Name));
                return(_localizer["CanNotDeleteItemUsedInStateMachines", usedInStateMachines].Value);
            }

            List <EvneSkill> referencedInSkills = await _skillDbAccess.GetSkillsObjectIsReferencedIn(id);

            if (referencedInSkills.Count > 0)
            {
                string referencedInSkillsString = string.Join(", ", referencedInSkills.Select(n => n.Name));
                return(_localizer["CanNotDeleteItemUsedInSkill", referencedInSkillsString].Value);
            }

            return(string.Empty);
        }
예제 #4
0
        /// <summary>
        /// Checks if a object is referenced before a delete
        /// </summary>
        /// <param name="id">Id</param>
        /// <returns>Empty string if no references exists, error string if references exists</returns>
        protected override async Task <string> CheckObjectReferences(string id)
        {
            List <AikaQuest> aikaQuests = await _aikaQuestDbAccess.GetQuestsObjectIsReferenced(id);

            if (aikaQuests.Count > 0)
            {
                string referencedInQuests = string.Join(", ", aikaQuests.Select(p => p.Name));
                return(_localizer["CanNotDeleteSkillReferencedInAikaQuest", referencedInQuests].Value);
            }

            List <KirjaPage> kirjaPages = await _kirjaPageDbAccess.GetPagesBySkill(id);

            if (kirjaPages.Count > 0)
            {
                string mentionedInPages = string.Join(", ", kirjaPages.Select(p => p.Name));
                return(_localizer["CanNotDeleteSkillMentionedInKirjaPage", mentionedInPages].Value);
            }

            List <TaleDialog> taleDialogs = await _taleDbAccess.GetDialogsObjectIsReferenced(id);

            if (taleDialogs.Count > 0)
            {
                List <KortistoNpc> npcs = await _kortistoNpcDbAccess.ResolveFlexFieldObjectNames(taleDialogs.Select(t => t.RelatedObjectId).ToList());

                string referencedInDialogs = string.Join(", ", npcs.Select(n => n.Name));
                return(_localizer["CanNotDeleteSkillReferencedInTaleDialog", referencedInDialogs].Value);
            }

            List <KortistoNpc> learnedNpcs = await _kortistoNpcDbAccess.GetNpcsByLearnedSkill(id);

            if (learnedNpcs.Count > 0)
            {
                string learnedByNpcsString = string.Join(", ", learnedNpcs.Select(n => n.Name));
                return(_localizer["CanNotDeleteSkillLearnedByNpc", learnedByNpcsString].Value);
            }

            List <KortistoNpc> referencedInDailyRoutines = await _kortistoNpcDbAccess.GetNpcsObjectIsReferencedInDailyRoutine(id);

            if (referencedInDailyRoutines.Count > 0)
            {
                string usedInDailyRoutines = string.Join(", ", referencedInDailyRoutines.Select(m => m.Name));
                return(_localizer["CanNotDeleteSkillUsedInDailyRoutine", usedInDailyRoutines].Value);
            }

            List <StateMachine> referencedInStateMachines = await _stateMachineDbAccess.GetStateMachinesObjectIsReferenced(id);

            if (referencedInStateMachines.Count > 0)
            {
                List <KortistoNpc> npcs = await _kortistoNpcDbAccess.ResolveFlexFieldObjectNames(referencedInStateMachines.Select(t => t.RelatedObjectId).ToList());

                List <KortistoNpc> npcTemplates = await _npcTemplateDbAccess.ResolveFlexFieldObjectNames(referencedInStateMachines.Select(t => t.RelatedObjectId).ToList());

                string usedInStateMachines = string.Join(", ", npcs.Union(npcTemplates).Select(n => n.Name));
                return(_localizer["CanNotDeleteSkillUsedInStateMachines", usedInStateMachines].Value);
            }

            List <EvneSkill> referencedInSkills = await((IEvneSkillDbAccess)_objectDbAccess).GetSkillsObjectIsReferencedIn(id);

            if (referencedInSkills.Count > 0)
            {
                string referencedInSkillsString = string.Join(", ", referencedInSkills.Select(n => n.Name));
                return(_localizer["CanNotDeleteSkillUsedInSkill", referencedInSkillsString].Value);
            }

            return(string.Empty);
        }
예제 #5
0
        public async Task <IActionResult> DeletePage(string id)
        {
            List <KirjaPage> kirjaPages = await _pageDbAccess.GetPagesByPage(id);

            if (kirjaPages.Count > 0)
            {
                string mentionedInPages = string.Join(", ", kirjaPages.Select(p => p.Name));
                return(BadRequest(_localizer["CanNotDeletePageMentionedInOtherPages", mentionedInPages].Value));
            }

            List <KartaMapMarkerQueryResult> kartaMaps = await _kartaMapDbAccess.GetAllMapsKirjaPageIsMarkedIn(id);

            if (kartaMaps.Count > 0)
            {
                string markedInMaps = string.Join(", ", kartaMaps.Select(p => p.Name));
                return(BadRequest(_localizer["CanNotDeletePageMarkedInKartaMap", markedInMaps].Value));
            }

            List <TaleDialog> taleDialogs = await _dialogDbAccess.GetDialogsObjectIsReferenced(id);

            if (taleDialogs.Count > 0)
            {
                List <KortistoNpc> npcs = await _npcDbAccess.ResolveFlexFieldObjectNames(taleDialogs.Select(t => t.RelatedObjectId).ToList());

                string referencedInDialogs = string.Join(", ", npcs.Select(n => n.Name));
                return(BadRequest(_localizer["CanNotDeletePageReferencedInDialog", referencedInDialogs].Value));
            }

            List <KortistoNpc> usedNpcs = await _npcDbAccess.GetNpcsObjectIsReferencedInDailyRoutine(id);

            if (usedNpcs.Count > 0)
            {
                string referencedInNpcs = string.Join(", ", usedNpcs.Select(p => p.Name));
                return(BadRequest(_localizer["CanNotDeletePageReferencedInNpc", referencedInNpcs].Value));
            }

            List <AikaQuest> aikaQuests = await _questDbAccess.GetQuestsObjectIsReferenced(id);

            if (aikaQuests.Count > 0)
            {
                string referencedInQuests = string.Join(", ", aikaQuests.Select(p => p.Name));
                return(BadRequest(_localizer["CanNotDeletePageReferencedInQuest", referencedInQuests].Value));
            }

            List <EvneSkill> referencedInSkills = await _skillDbAccess.GetSkillsObjectIsReferencedIn(id);

            if (referencedInSkills.Count > 0)
            {
                string usedInSkills = string.Join(", ", referencedInSkills.Select(m => m.Name));
                return(BadRequest(_localizer["CanNotDeletePageReferencedInSkill", usedInSkills].Value));
            }

            List <ObjectExportSnippet> referencedInSnippets = await _objectExportSnippetDbAccess.GetExportSnippetsObjectIsReferenced(id);

            if (referencedInSnippets.Count > 0)
            {
                List <ObjectExportSnippetReference> references = await _exportSnippetRelatedObjectNameResolver.ResolveExportSnippetReferences(referencedInSnippets, true, true, true);

                string usedInDailyRoutines = string.Join(", ", references.Select(m => string.Format("{0} ({1})", m.ObjectName, m.ExportSnippet)));
                return(BadRequest(_localizer["CanNotDeletePageReferencedInExportSnippet", usedInDailyRoutines].Value));
            }

            List <StateMachine> referencedInStateMachines = await _stateMachineDbAccess.GetStateMachinesObjectIsReferenced(id);

            if (referencedInStateMachines.Count > 0)
            {
                List <KortistoNpc> npcs = await _npcDbAccess.ResolveFlexFieldObjectNames(referencedInStateMachines.Select(t => t.RelatedObjectId).ToList());

                List <KortistoNpc> npcTemplates = await _npcTemplateDbAccess.ResolveFlexFieldObjectNames(referencedInStateMachines.Select(t => t.RelatedObjectId).ToList());

                string usedInStateMachines = string.Join(", ", npcs.Union(npcTemplates).Select(n => n.Name));
                return(BadRequest(_localizer["CanNotDeletePageUsedInStateMachines", usedInStateMachines].Value));
            }

            KirjaPage page = await _pageDbAccess.GetPageById(id);

            if (page.IsDefault)
            {
                return(BadRequest(_localizer["CanNotDeleteRootPage"].Value));
            }

            await _pageDbAccess.DeletePage(page);

            _logger.LogInformation("Page was deleted.");

            // Delete Images
            List <string> allImages = new List <string>();

            if (page.UplodadedImages != null)
            {
                allImages.AddRange(page.UplodadedImages);
            }

            List <KirjaPageVersion> oldVersions = await _pageVersionDbAccess.GetVersionsOfPage(page.Id, 0, int.MaxValue);

            foreach (KirjaPageVersion curVersion in oldVersions)
            {
                if (curVersion.UplodadedImages != null)
                {
                    allImages.AddRange(curVersion.UplodadedImages);
                }
            }

            allImages = allImages.Distinct().ToList();
            foreach (string curImage in allImages)
            {
                _fileAccess.DeleteFile(curImage);
            }

            // Delete Attachments
            if (page.Attachments != null)
            {
                foreach (KirjaPageAttachment curAttachment in page.Attachments)
                {
                    _fileAccess.DeleteFile(curAttachment.Filename);
                }
            }

            await _pageVersionDbAccess.DeletePageVersionsByPage(page.Id);

            await _timelineService.AddTimelineEntry(page.ProjectId, TimelineEvent.KirjaPageDeleted, page.Name);

            return(Ok(id));
        }