mirror of
https://github.com/streetwriters/notesnook-sync-server.git
synced 2026-02-12 19:22:45 +00:00
376 lines
15 KiB
C#
376 lines
15 KiB
C#
/*
|
|
This file is part of the Notesnook Sync Server project (https://notesnook.com/)
|
|
|
|
Copyright (C) 2023 Streetwriters (Private) Limited
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the Affero GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
Affero GNU General Public License for more details.
|
|
|
|
You should have received a copy of the Affero GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Security.Claims;
|
|
using System.Text.Json;
|
|
using System.Threading.Tasks;
|
|
using AngleSharp;
|
|
using AngleSharp.Dom;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using MongoDB.Bson;
|
|
using MongoDB.Driver;
|
|
using Notesnook.API.Authorization;
|
|
using Notesnook.API.Models;
|
|
using Notesnook.API.Services;
|
|
using Streetwriters.Common;
|
|
using Streetwriters.Common.Interfaces;
|
|
using Streetwriters.Common.Messages;
|
|
using Streetwriters.Data.Interfaces;
|
|
using Streetwriters.Data.Repositories;
|
|
|
|
namespace Notesnook.API.Controllers
|
|
{
|
|
[ApiController]
|
|
[Route("monographs")]
|
|
[Authorize("Sync")]
|
|
public class MonographsController : ControllerBase
|
|
{
|
|
const string SVG_PIXEL = "<svg xmlns='http://www.w3.org/2000/svg' width='1' height='1'><circle r='9'/></svg>";
|
|
private Repository<Monograph> Monographs { get; set; }
|
|
private readonly IURLAnalyzer urlAnalyzer;
|
|
private readonly IUnitOfWork unit;
|
|
private const int MAX_DOC_SIZE = 15 * 1024 * 1024;
|
|
public MonographsController(Repository<Monograph> monographs, IUnitOfWork unitOfWork, IURLAnalyzer analyzer)
|
|
{
|
|
Monographs = monographs;
|
|
unit = unitOfWork;
|
|
urlAnalyzer = analyzer;
|
|
}
|
|
|
|
private static FilterDefinition<Monograph> CreateMonographFilter(string userId, Monograph monograph)
|
|
{
|
|
var userIdFilter = Builders<Monograph>.Filter.Eq("UserId", userId);
|
|
monograph.ItemId ??= monograph.Id;
|
|
return ObjectId.TryParse(monograph.ItemId, out ObjectId id)
|
|
? Builders<Monograph>.Filter
|
|
.And(userIdFilter,
|
|
Builders<Monograph>.Filter.Or(
|
|
Builders<Monograph>.Filter.Eq("_id", id), Builders<Monograph>.Filter.Eq("ItemId", monograph.ItemId)
|
|
)
|
|
)
|
|
: Builders<Monograph>.Filter
|
|
.And(userIdFilter,
|
|
Builders<Monograph>.Filter.Eq("ItemId", monograph.ItemId)
|
|
);
|
|
}
|
|
|
|
private static FilterDefinition<Monograph> CreateMonographFilter(string itemId)
|
|
{
|
|
return ObjectId.TryParse(itemId, out ObjectId id)
|
|
? Builders<Monograph>.Filter.Or(
|
|
Builders<Monograph>.Filter.Eq("_id", id),
|
|
Builders<Monograph>.Filter.Eq("ItemId", itemId))
|
|
: Builders<Monograph>.Filter.Eq("ItemId", itemId);
|
|
}
|
|
|
|
private async Task<Monograph> FindMonographAsync(string userId, Monograph monograph)
|
|
{
|
|
var result = await Monographs.Collection.FindAsync(CreateMonographFilter(userId, monograph), new FindOptions<Monograph>
|
|
{
|
|
Limit = 1
|
|
});
|
|
return await result.FirstOrDefaultAsync();
|
|
}
|
|
|
|
private async Task<Monograph> FindMonographAsync(string itemId)
|
|
{
|
|
var result = await Monographs.Collection.FindAsync(CreateMonographFilter(itemId), new FindOptions<Monograph>
|
|
{
|
|
Limit = 1
|
|
});
|
|
return await result.FirstOrDefaultAsync();
|
|
}
|
|
|
|
[HttpPost]
|
|
public async Task<IActionResult> PublishAsync([FromQuery] string? deviceId, [FromBody] Monograph monograph)
|
|
{
|
|
try
|
|
{
|
|
var userId = this.User.FindFirstValue("sub");
|
|
if (userId == null) return Unauthorized();
|
|
|
|
var existingMonograph = await FindMonographAsync(userId, monograph);
|
|
if (existingMonograph != null && !existingMonograph.Deleted)
|
|
{
|
|
return base.Conflict("This monograph is already published.");
|
|
}
|
|
|
|
if (monograph.EncryptedContent == null)
|
|
monograph.CompressedContent = (await CleanupContentAsync(monograph.Content)).CompressBrotli();
|
|
monograph.UserId = userId;
|
|
monograph.DatePublished = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
|
|
|
|
if (monograph.EncryptedContent?.Cipher.Length > MAX_DOC_SIZE || monograph.CompressedContent?.Length > MAX_DOC_SIZE)
|
|
return base.BadRequest("Monograph is too big. Max allowed size is 15mb.");
|
|
|
|
if (existingMonograph != null)
|
|
{
|
|
monograph.Id = existingMonograph?.Id;
|
|
}
|
|
monograph.Deleted = false;
|
|
await Monographs.Collection.ReplaceOneAsync(
|
|
CreateMonographFilter(userId, monograph),
|
|
monograph,
|
|
new ReplaceOptions { IsUpsert = true }
|
|
);
|
|
|
|
await MarkMonographForSyncAsync(monograph.ItemId ?? monograph.Id, deviceId);
|
|
|
|
return Ok(new
|
|
{
|
|
id = monograph.ItemId,
|
|
datePublished = monograph.DatePublished,
|
|
});
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
await Slogger<MonographsController>.Error(nameof(PublishAsync), e.ToString());
|
|
return BadRequest();
|
|
}
|
|
}
|
|
|
|
[HttpPatch]
|
|
public async Task<IActionResult> UpdateAsync([FromQuery] string? deviceId, [FromBody] Monograph monograph)
|
|
{
|
|
try
|
|
{
|
|
var userId = this.User.FindFirstValue("sub");
|
|
if (userId == null) return Unauthorized();
|
|
|
|
var existingMonograph = await FindMonographAsync(userId, monograph);
|
|
if (existingMonograph == null || existingMonograph.Deleted)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
if (monograph.EncryptedContent?.Cipher.Length > MAX_DOC_SIZE || monograph.CompressedContent?.Length > MAX_DOC_SIZE)
|
|
return base.BadRequest("Monograph is too big. Max allowed size is 15mb.");
|
|
|
|
if (monograph.EncryptedContent == null)
|
|
monograph.CompressedContent = (await CleanupContentAsync(monograph.Content)).CompressBrotli();
|
|
else
|
|
monograph.Content = null;
|
|
|
|
monograph.DatePublished = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
|
|
var result = await Monographs.Collection.UpdateOneAsync(
|
|
CreateMonographFilter(userId, monograph),
|
|
Builders<Monograph>.Update
|
|
.Set(m => m.DatePublished, monograph.DatePublished)
|
|
.Set(m => m.CompressedContent, monograph.CompressedContent)
|
|
.Set(m => m.EncryptedContent, monograph.EncryptedContent)
|
|
.Set(m => m.SelfDestruct, monograph.SelfDestruct)
|
|
.Set(m => m.Title, monograph.Title)
|
|
.Set(m => m.Password, monograph.Password)
|
|
);
|
|
if (!result.IsAcknowledged) return BadRequest();
|
|
|
|
await MarkMonographForSyncAsync(monograph.ItemId ?? monograph.Id, deviceId);
|
|
|
|
return Ok(new
|
|
{
|
|
id = monograph.ItemId,
|
|
datePublished = monograph.DatePublished,
|
|
});
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
await Slogger<MonographsController>.Error(nameof(UpdateAsync), e.ToString());
|
|
return BadRequest();
|
|
}
|
|
}
|
|
|
|
[HttpGet]
|
|
public async Task<IActionResult> GetUserMonographsAsync()
|
|
{
|
|
var userId = this.User.FindFirstValue("sub");
|
|
if (userId == null) return Unauthorized();
|
|
|
|
var monographs = (await Monographs.Collection.FindAsync(
|
|
Builders<Monograph>.Filter.And(
|
|
Builders<Monograph>.Filter.Eq("UserId", userId),
|
|
Builders<Monograph>.Filter.Ne("Deleted", true)
|
|
)
|
|
, new FindOptions<Monograph, ObjectWithId>
|
|
{
|
|
Projection = Builders<Monograph>.Projection.Include("_id").Include("ItemId"),
|
|
})).ToEnumerable();
|
|
return Ok(monographs.Select((m) => m.ItemId ?? m.Id));
|
|
}
|
|
|
|
[HttpGet("{id}")]
|
|
[AllowAnonymous]
|
|
public async Task<IActionResult> GetMonographAsync([FromRoute] string id)
|
|
{
|
|
var monograph = await FindMonographAsync(id);
|
|
if (monograph == null || monograph.Deleted)
|
|
{
|
|
return NotFound(new
|
|
{
|
|
error = "invalid_id",
|
|
error_description = $"No such monograph found."
|
|
});
|
|
}
|
|
|
|
if (monograph.EncryptedContent == null)
|
|
monograph.Content = monograph.CompressedContent.DecompressBrotli();
|
|
if (monograph.ItemId == null) monograph.ItemId = monograph.Id;
|
|
return Ok(monograph);
|
|
}
|
|
|
|
[HttpGet("{id}/view")]
|
|
[AllowAnonymous]
|
|
public async Task<IActionResult> TrackView([FromRoute] string id)
|
|
{
|
|
var monograph = await FindMonographAsync(id);
|
|
if (monograph == null || monograph.Deleted) return Content(SVG_PIXEL, "image/svg+xml");
|
|
|
|
if (monograph.SelfDestruct)
|
|
{
|
|
var userId = this.User.FindFirstValue("sub");
|
|
await Monographs.Collection.ReplaceOneAsync(
|
|
CreateMonographFilter(userId, monograph),
|
|
new Monograph
|
|
{
|
|
ItemId = id,
|
|
Id = monograph.Id,
|
|
Deleted = true,
|
|
UserId = monograph.UserId
|
|
}
|
|
);
|
|
|
|
await MarkMonographForSyncAsync(id);
|
|
}
|
|
|
|
return Content(SVG_PIXEL, "image/svg+xml");
|
|
}
|
|
|
|
[HttpDelete("{id}")]
|
|
public async Task<IActionResult> DeleteAsync([FromQuery] string? deviceId, [FromRoute] string id)
|
|
{
|
|
var monograph = await FindMonographAsync(id);
|
|
if (monograph == null || monograph.Deleted)
|
|
{
|
|
return NotFound(new
|
|
{
|
|
error = "invalid_id",
|
|
error_description = $"No such monograph found."
|
|
});
|
|
}
|
|
|
|
var userId = this.User.FindFirstValue("sub");
|
|
await Monographs.Collection.ReplaceOneAsync(
|
|
CreateMonographFilter(userId, monograph),
|
|
new Monograph
|
|
{
|
|
ItemId = id,
|
|
Id = monograph.Id,
|
|
Deleted = true,
|
|
UserId = monograph.UserId
|
|
}
|
|
);
|
|
|
|
await MarkMonographForSyncAsync(id, deviceId);
|
|
|
|
return Ok();
|
|
}
|
|
|
|
private async Task MarkMonographForSyncAsync(string monographId, string? deviceId)
|
|
{
|
|
if (deviceId == null) return;
|
|
var userId = this.User.FindFirstValue("sub");
|
|
|
|
new SyncDeviceService(new SyncDevice(userId, deviceId)).AddIdsToOtherDevices([$"{monographId}:monograph"]);
|
|
await SendTriggerSyncEventAsync();
|
|
}
|
|
|
|
private async Task MarkMonographForSyncAsync(string monographId)
|
|
{
|
|
var userId = this.User.FindFirstValue("sub");
|
|
|
|
new SyncDeviceService(new SyncDevice(userId, string.Empty)).AddIdsToAllDevices([$"{monographId}:monograph"]);
|
|
await SendTriggerSyncEventAsync(sendToAllDevices: true);
|
|
}
|
|
|
|
private async Task SendTriggerSyncEventAsync(bool sendToAllDevices = false)
|
|
{
|
|
var userId = this.User.FindFirstValue("sub");
|
|
var jti = this.User.FindFirstValue("jti");
|
|
|
|
await WampServers.MessengerServer.PublishMessageAsync(MessengerServerTopics.SendSSETopic, new SendSSEMessage
|
|
{
|
|
OriginTokenId = sendToAllDevices ? null : jti,
|
|
UserId = userId,
|
|
Message = new Message
|
|
{
|
|
Type = "triggerSync",
|
|
Data = JsonSerializer.Serialize(new { reason = "Monographs updated." })
|
|
}
|
|
});
|
|
}
|
|
|
|
private async Task<string> CleanupContentAsync(string content)
|
|
{
|
|
try
|
|
{
|
|
var json = JsonSerializer.Deserialize<MonographContent>(content);
|
|
var html = json.Data;
|
|
if (!Constants.IS_SELF_HOSTED && !User.IsUserSubscribed())
|
|
{
|
|
var config = Configuration.Default.WithDefaultLoader();
|
|
var context = BrowsingContext.New(config);
|
|
var document = await context.OpenAsync(r => r.Content(html));
|
|
foreach (var element in document.QuerySelectorAll("a,iframe,img,object,svg,button,link"))
|
|
{
|
|
element.Remove();
|
|
}
|
|
html = document.ToHtml();
|
|
}
|
|
|
|
if (User.IsUserSubscribed())
|
|
{
|
|
var config = Configuration.Default.WithDefaultLoader();
|
|
var context = BrowsingContext.New(config);
|
|
var document = await context.OpenAsync(r => r.Content(html));
|
|
foreach (var element in document.QuerySelectorAll("a"))
|
|
{
|
|
var href = element.GetAttribute("href");
|
|
if (string.IsNullOrEmpty(href)) continue;
|
|
if (!await urlAnalyzer.IsURLSafeAsync(href)) element.RemoveAttribute("href");
|
|
}
|
|
html = document.ToHtml();
|
|
}
|
|
|
|
return JsonSerializer.Serialize<MonographContent>(new MonographContent
|
|
{
|
|
Type = json.Type,
|
|
Data = html
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await Slogger<MonographsController>.Error("CleanupContentAsync", ex.ToString());
|
|
return content;
|
|
}
|
|
}
|
|
}
|
|
} |