/// <summary>
/// Parses a kirja page
/// </summary>
/// <param name="page">Page to parse</param>
public void ParsePage(KirjaPage page)
{
foreach (IKirjaParser curParser in _Parser)
{
curParser.ParsePage(page);
}
}
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(StatusCode((int)HttpStatusCode.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(StatusCode((int)HttpStatusCode.BadRequest, _localizer["CanNotDeletePageMarkedInKartaMap", markedInMaps].Value));
}
KirjaPage page = await _pageDbAccess.GetPageById(id);
await _pageDbAccess.DeletePage(page);
_logger.LogInformation("Page was deleted.");
if (page.UplodadedImages != null)
{
DeleteUnusedImages(page.UplodadedImages);
}
await _timelineService.AddTimelineEntry(TimelineEvent.KirjaPageDeleted, page.Name);
return(Ok(id));
}
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));
}
}
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));
}
public async Task <IActionResult> UpdatePage(string id, [FromBody] PageRequest page)
{
KirjaPage loadedPage = await _pageDbAccess.GetPageById(id);
List <string> oldImages = null;
if (loadedPage.UplodadedImages != null)
{
oldImages = new List <string>(loadedPage.UplodadedImages);
}
else
{
oldImages = new List <string>();
}
loadedPage.Name = page.Name;
loadedPage.Content = page.Content;
_pageParserService.ParsePage(loadedPage);
await this.SetModifiedData(_userManager, loadedPage);
await _pageDbAccess.UpdatePage(loadedPage);
_logger.LogInformation("Page was updated.");
DeleteUnusedImages(oldImages.Except(loadedPage.UplodadedImages, StringComparer.OrdinalIgnoreCase).ToList());
_logger.LogInformation("Unused Images were deleted.");
await _timelineService.AddTimelineEntry(TimelineEvent.KirjaPageUpdated, loadedPage.Name, loadedPage.Id);
return(Ok(loadedPage));
}
public async Task <IActionResult> KirjaAttachment(string pageId, string attachmentFile)
{
// Check Data
if (string.IsNullOrEmpty(pageId) || string.IsNullOrEmpty(attachmentFile))
{
return(StatusCode((int)HttpStatusCode.BadRequest));
}
KirjaPage page = await _pageDbAccess.GetPageById(pageId);
if (page == null || page.Attachments == null)
{
return(StatusCode((int)HttpStatusCode.NotFound));
}
// Get Attachment
KirjaPageAttachment attachment = FindAttachment(page, attachmentFile);
if (attachment == null)
{
return(StatusCode((int)HttpStatusCode.NotFound));
}
// Return File
Stream imageStream = _fileAccess.OpenFile(attachment.Filename);
return(File(imageStream, attachment.MimeType, attachment.OriginalFilename));
}
/// <summary>
/// Searches an attachment in the list of attachments of a page
/// </summary>
/// <param name="page">Page with attachments</param>
/// <param name="attachmentFile">Attachment file to search</param>
/// <returns>Attachment file, null if file was not found</returns>
private KirjaPageAttachment FindAttachment(KirjaPage page, string attachmentFile)
{
foreach (KirjaPageAttachment curAttachment in page.Attachments)
{
if (curAttachment.Filename == attachmentFile)
{
return(curAttachment);
}
}
return(null);
}
/// <summary>
/// Returns a wiki page by its id
/// </summary>
/// <param name="pageId">Page Id</param>
/// <returns>Wiki page</returns>
public async Task <KirjaPage> GetWikiPageById(string pageId)
{
if (string.IsNullOrEmpty(pageId))
{
return(null);
}
if (_cachedPages.ContainsKey(pageId))
{
return(_cachedPages[pageId]);
}
KirjaPage page = await _pageDbAccess.GetPageById(pageId);
_cachedPages.Add(pageId, page);
return(page);
}
public async Task <IActionResult> DeleteAttachment(string pageId, string attachmentFile)
{
// Check Data
if (string.IsNullOrEmpty(pageId) || string.IsNullOrEmpty(attachmentFile))
{
return(StatusCode((int)HttpStatusCode.BadRequest));
}
KirjaPage page = await _pageDbAccess.GetPageById(pageId);
if (page == null || page.Attachments == null)
{
return(StatusCode((int)HttpStatusCode.NotFound));
}
// Get Attachment
KirjaPageAttachment attachment = FindAttachment(page, attachmentFile);
if (attachment == null)
{
return(Ok(pageId));
}
// Delete Attachment
try
{
await this.SetModifiedData(_userManager, page);
page.Attachments.Remove(attachment);
await _pageDbAccess.UpdatePage(page);
_logger.LogInformation("Attachment deleted from page");
_fileAccess.DeleteFile(attachment.Filename);
_logger.LogInformation("Attachment file deleted");
}
catch (Exception ex)
{
_logger.LogError(ex, "Could not delete attachment");
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
await _timelineService.AddTimelineEntry(TimelineEvent.KirjaAttachmentDeleted, page.Name, page.Id, attachment.OriginalFilename);
return(Ok(pageId));
}
/// <summary>
/// Parses a kirja page
/// </summary>
/// <param name="page">Page to parse</param>
public void ParsePage(KirjaPage page)
{
Regex imageRegex = new Regex("KirjaImage\\?imageFile=([0-9A-F]{8}-([0-9A-F]{4}-){3}[0-9A-F]{12}\\..*?)\"", RegexOptions.IgnoreCase | RegexOptions.Multiline);
List <string> images = new List <string>();
MatchCollection imageMatches = imageRegex.Matches(page.Content);
foreach (Match curMatch in imageMatches)
{
if (!curMatch.Success)
{
continue;
}
images.Add(curMatch.Groups[1].Value);
}
page.UplodadedImages = images;
}
/// <summary>
/// Parses a kirja page
/// </summary>
/// <param name="page">Page to parse</param>
/// <param name="pageName">Name of the page in the link to search for</param>
/// <returns>Found ids</returns>
public List <string> ParseIds(KirjaPage page, string pageName)
{
Regex guidLinkRegex = new Regex("/" + pageName + "#id=([0-9A-F]{8}-([0-9A-F]{4}-){3}[0-9A-F]{12})", RegexOptions.IgnoreCase | RegexOptions.Multiline);
List <string> ids = new List <string>();
MatchCollection itemLinkMatches = guidLinkRegex.Matches(page.Content);
foreach (Match curMatch in itemLinkMatches)
{
if (!curMatch.Success)
{
continue;
}
ids.Add(curMatch.Groups[1].Value);
}
return(ids);
}
/// <summary>
/// Syncs kirja marker label
/// </summary>
/// <param name="map">Map To sync</param>
/// <returns>Task</returns>
private async Task SyncKirjaMarkerLabels(KartaMap map)
{
if (map.KirjaPageMarker == null)
{
return;
}
foreach (KirjaPageMapMarker curMarker in map.KirjaPageMarker)
{
KirjaPage curPage = await _kirjaPageDbAccess.GetPageById(curMarker.PageId);
if (curPage == null)
{
continue;
}
curMarker.PageName = curPage.Name;
}
}
/// <summary>
/// Parses a kirja page
/// </summary>
/// <param name="page">Page to parse</param>
/// <param name="pageName">Name of the page in the link to search for</param>
/// <returns>Found ids</returns>
public List <string> ParseIds(KirjaPage page, string pageName)
{
// Support both query and hash notation for backwards comaptibility of links
Regex guidLinkRegex = new Regex("/" + pageName + "[#|?]id=([0-9A-F]{8}-([0-9A-F]{4}-){3}[0-9A-F]{12})", RegexOptions.IgnoreCase | RegexOptions.Multiline);
List <string> ids = new List <string>();
MatchCollection itemLinkMatches = guidLinkRegex.Matches(page.Content);
foreach (Match curMatch in itemLinkMatches)
{
if (!curMatch.Success)
{
continue;
}
ids.Add(curMatch.Groups[1].Value);
}
return(ids);
}
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));
}
public async Task <IActionResult> UploadPageAttachment(string id)
{
// Validate Date
if (Request.Form.Files.Count != 1)
{
return(StatusCode((int)HttpStatusCode.BadRequest, _localizer["OnlyOneFileAllowed"]));
}
IFormFile uploadFile = Request.Form.Files[0];
string fileContentType = uploadFile.ContentType;
bool mimeTypeAllowed = false;
foreach (string curAllowedMimeType in _allowedAttachmentMimeTypes)
{
if (Regex.IsMatch(fileContentType, curAllowedMimeType))
{
mimeTypeAllowed = true;
break;
}
}
if (!mimeTypeAllowed)
{
return(StatusCode((int)HttpStatusCode.BadRequest, _localizer["FileTypeNotAllowed"]));
}
// Get Page
KirjaPage page = await _pageDbAccess.GetPageById(id);
if (page == null)
{
return(StatusCode((int)HttpStatusCode.NotFound));
}
// Save File
string fileName = string.Empty;
try
{
using (Stream fileStream = _fileAccess.CreateFile(uploadFile.FileName, out fileName))
{
uploadFile.CopyTo(fileStream);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Could not upload file");
return(StatusCode((int)HttpStatusCode.InternalServerError, _localizer["CouldNotUploadFile"]));
}
// Save File to page
if (page.Attachments == null)
{
page.Attachments = new List <KirjaPageAttachment>();
}
KirjaPageAttachment pageAttachment = new KirjaPageAttachment();
pageAttachment.OriginalFilename = uploadFile.FileName;
pageAttachment.Filename = fileName;
pageAttachment.MimeType = fileContentType;
page.Attachments.Add(pageAttachment);
page.Attachments = page.Attachments.OrderBy(pa => pa.OriginalFilename).ToList();
try
{
await this.SetModifiedData(_userManager, page);
await _pageDbAccess.UpdatePage(page);
}
catch (Exception ex)
{
_logger.LogError(ex, "Could not save page after file upload");
_fileAccess.DeleteFile(fileName);
return(StatusCode((int)HttpStatusCode.InternalServerError, _localizer["CouldNotUploadFile"]));
}
await _timelineService.AddTimelineEntry(TimelineEvent.KirjaAttachmentAdded, page.Name, page.Id, pageAttachment.OriginalFilename);
return(Ok(pageAttachment));
}
/// <summary>
/// Parses a kirja page
/// </summary>
/// <param name="page">Page to parse</param>
public void ParsePage(KirjaPage page)
{
page.MentionedItems = ParseIds(page, "Item");
}
/// <summary>
/// Parses a kirja page
/// </summary>
/// <param name="page">Page to parse</param>
public void ParsePage(KirjaPage page)
{
page.MentionedSkills = ParseIds(page, "Skill");
}
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(StatusCode((int)HttpStatusCode.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(StatusCode((int)HttpStatusCode.BadRequest, _localizer["CanNotDeletePageMarkedInKartaMap", markedInMaps].Value));
}
KirjaPage page = await _pageDbAccess.GetPageById(id);
if (page.IsDefault)
{
return(StatusCode((int)HttpStatusCode.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(TimelineEvent.KirjaPageDeleted, page.Name);
return(Ok(id));
}
/// <summary>
/// Saves a new version of a page
/// </summary>
/// <param name="page">Page</param>
/// <returns>Version Id</returns>
private async Task <string> SaveVersionOfPage(KirjaPage page)
{
if (_maxVersionCount == 0)
{
return(string.Empty);
}
// Check if the last modification to the page was made by the same user and is in the merge time span
bool isUpdate = false;
KirjaPageVersion version = new KirjaPageVersion();
if (_versionMergeTimeSpan > 0)
{
GoNorthUser currentUser = await _userManager.GetUserAsync(User);
KirjaPageVersion existingVersion = await _pageVersionDbAccess.GetLatestVersionOfPage(page.Id);
if (existingVersion != null && existingVersion.ModifiedBy == currentUser.Id && (float)(DateTimeOffset.UtcNow - existingVersion.ModifiedOn).TotalMinutes < _versionMergeTimeSpan)
{
version = existingVersion;
isUpdate = true;
}
}
if (!isUpdate)
{
int versionNumber = await _pageVersionDbAccess.GetMaxPageVersionNumber(page.Id);
++versionNumber;
version.VersionNumber = versionNumber;
}
version.OriginalPageId = page.Id;
version.ProjectId = page.ProjectId;
version.IsDefault = page.IsDefault;
version.Name = page.Name;
version.Content = page.Content;
version.MentionedKirjaPages = page.MentionedKirjaPages;
version.MentionedQuests = page.MentionedQuests;
version.MentionedNpcs = page.MentionedNpcs;
version.MentionedItems = page.MentionedItems;
version.MentionedSkills = page.MentionedSkills;
version.UplodadedImages = page.UplodadedImages;
version.Attachments = null;
version.ModifiedOn = page.ModifiedOn;
version.ModifiedBy = page.ModifiedBy;
if (isUpdate)
{
await _pageVersionDbAccess.UpdatePageVersion(version);
}
else
{
version = await _pageVersionDbAccess.CreatePageVersion(version);
}
// Delete old versions
if (_maxVersionCount > 0)
{
List <KirjaPageVersion> oldVersions = await _pageVersionDbAccess.GetVersionsOfPage(page.Id, 0, int.MaxValue);
List <string> imagesToDelete = new List <string>();
HashSet <string> stillUsedImages = page.UplodadedImages != null?page.UplodadedImages.ToHashSet() : new HashSet <string>();
for (int curVersion = 0; curVersion < oldVersions.Count; ++curVersion)
{
if (curVersion < _maxVersionCount)
{
if (oldVersions[curVersion].UplodadedImages != null)
{
foreach (string curImage in oldVersions[curVersion].UplodadedImages)
{
if (!stillUsedImages.Contains(curImage))
{
stillUsedImages.Add(curImage);
}
}
}
}
else
{
if (oldVersions[curVersion].Id != version.Id)
{
await _pageVersionDbAccess.DeletePageVersion(oldVersions[curVersion]);
if (oldVersions[curVersion].UplodadedImages != null)
{
imagesToDelete.AddRange(oldVersions[curVersion].UplodadedImages);
}
}
}
}
imagesToDelete = imagesToDelete.Distinct().ToList();
foreach (string curImage in imagesToDelete)
{
if (!stillUsedImages.Contains(curImage))
{
_fileAccess.DeleteFile(curImage);
}
}
}
return(version.Id);
}
/// <summary>
/// Parses a kirja page
/// </summary>
/// <param name="page">Page to parse</param>
public void ParsePage(KirjaPage page)
{
page.MentionedQuests = ParseIds(page, "Quest");
}
/// <summary>
/// Builds an export wiki page based on a kirja page
/// </summary>
/// <param name="page">Wiki page</param>
public ScribanExportWikiPage(KirjaPage page)
{
Name = page.Name;
Content = page.Content;
}
/// <summary>
/// Parses a kirja page
/// </summary>
/// <param name="page">Page to parse</param>
public void ParsePage(KirjaPage page)
{
page.MentionedNpcs = ParseIds(page, "Npc");
}
/// <summary>
/// Parses a kirja page
/// </summary>
/// <param name="page">Page to parse</param>
public void ParsePage(KirjaPage page)
{
page.MentionedKirjaPages = ParseIds(page, "Kirja");
}
/// <summary>
/// Checks if a project is empty
/// </summary>
/// <param name="project">Project to check</param>
/// <returns>True if the project is empty, else false</returns>
private async Task <bool> IsProjectEmpty(GoNorthProject project)
{
int rootKortistoFolderCount = await _kortistoFolderDbAccess.GetRootFolderCount(project.Id, CultureInfo.CurrentUICulture.TwoLetterISOLanguageName);
if (rootKortistoFolderCount > 0)
{
return(false);
}
int rootNpcCount = await _npcDbAccess.GetFlexFieldObjectsInRootFolderCount(project.Id, CultureInfo.CurrentUICulture.TwoLetterISOLanguageName);
if (rootNpcCount > 0)
{
return(false);
}
int rootStyrFolderCount = await _styrFolderDbAccess.GetRootFolderCount(project.Id, CultureInfo.CurrentUICulture.TwoLetterISOLanguageName);
if (rootStyrFolderCount > 0)
{
return(false);
}
int rootItemCount = await _itemDbAccess.GetFlexFieldObjectsInRootFolderCount(project.Id, CultureInfo.CurrentUICulture.TwoLetterISOLanguageName);
if (rootItemCount > 0)
{
return(false);
}
int rootEvneFolderCount = await _evneFolderDbAccess.GetRootFolderCount(project.Id, CultureInfo.CurrentUICulture.TwoLetterISOLanguageName);
if (rootEvneFolderCount > 0)
{
return(false);
}
int rootSkillCount = await _evneSkillDbAccess.GetFlexFieldObjectsInRootFolderCount(project.Id, CultureInfo.CurrentUICulture.TwoLetterISOLanguageName);
if (rootSkillCount > 0)
{
return(false);
}
int kirjaPageCount = await _kirjaPageDbAccess.SearchPagesCount(project.Id, string.Empty, string.Empty, CultureInfo.CurrentUICulture.TwoLetterISOLanguageName);
if (kirjaPageCount > 1)
{
return(false);
}
else if (kirjaPageCount == 1)
{
KirjaPage defaultPage = await _kirjaPageDbAccess.GetDefaultPageForProject(project.Id);
if (defaultPage == null)
{
return(false);
}
}
int chapterDetailCount = await _chapterDetailDbAccess.GetChapterDetailsByProjectIdCount(project.Id);
if (chapterDetailCount > 0)
{
return(false);
}
int questCount = await _questDbAccess.GetQuestsByProjectIdCount(project.Id, CultureInfo.CurrentUICulture.TwoLetterISOLanguageName);
if (questCount > 0)
{
return(false);
}
List <KartaMap> maps = await _mapDbAccess.GetAllProjectMaps(project.Id);
if (maps != null && maps.Count > 0)
{
return(false);
}
int taskBoardCount = await _taskBoardDbAccess.GetOpenTaskBoardCount(project.Id, CultureInfo.CurrentUICulture.TwoLetterISOLanguageName);
taskBoardCount += await _taskBoardDbAccess.GetClosedTaskBoardCount(project.Id, CultureInfo.CurrentUICulture.TwoLetterISOLanguageName);
if (taskBoardCount > 0)
{
return(false);
}
return(true);
}
public async Task <IActionResult> UpdatePage(string id, [FromBody] PageRequest page)
{
_xssChecker.CheckXss(page.Name);
_xssChecker.CheckXss(page.Content);
KirjaPage loadedPage = await _pageDbAccess.GetPageById(id);
if (loadedPage == null)
{
return(NotFound());
}
List <string> oldImages = null;
if (loadedPage.UplodadedImages != null)
{
oldImages = new List <string>(loadedPage.UplodadedImages);
}
else
{
oldImages = new List <string>();
}
bool nameChanged = loadedPage.Name != page.Name;
loadedPage.Name = page.Name;
loadedPage.Content = page.Content;
_pageParserService.ParsePage(loadedPage);
await this.SetModifiedData(_userManager, loadedPage);
await _pageDbAccess.UpdatePage(loadedPage);
_logger.LogInformation("Page was updated.");
if (nameChanged)
{
await SyncPageNameToMarkers(id, page.Name);
}
string versionId = await SaveVersionOfPage(loadedPage);
string oldVersionId = string.Empty;
if (!string.IsNullOrEmpty(versionId))
{
List <KirjaPageVersion> allVersions = await _pageVersionDbAccess.GetVersionsOfPage(loadedPage.Id, 0, 2);
if (allVersions.Count > 1)
{
oldVersionId = allVersions[1].Id;
}
}
_logger.LogInformation("Versions were updated.");
await DeleteUnusedImages(loadedPage.Id, oldImages.Except(loadedPage.UplodadedImages, StringComparer.OrdinalIgnoreCase).ToList());
_logger.LogInformation("Unused Images were deleted.");
await _timelineService.AddTimelineEntry(TimelineEvent.KirjaPageUpdated, loadedPage.Name, loadedPage.Id, versionId, oldVersionId);
return(Ok(loadedPage));
}
