diff --git a/Other/account-options-template.js b/Other/account-options-template.js new file mode 100644 index 0000000..37e9e4c --- /dev/null +++ b/Other/account-options-template.js @@ -0,0 +1,84 @@ +"use strict"; +class AccountOptions extends HTMLElement { + constructor() { + super() + this.attachShadow({ mode: "open" }) + } + + connectedCallback() { + this.shadowRoot.innerHTML = html` + + + ` + const style = document.createElement("style") + style.innerHTML = css` + .account-options { + display: flex; + } + + .login-button { + height: 100%; + } + + .account-image { + height: 48px; + aspect-ratio: 1/1; + object-fit: cover; + border-radius: 4px; + } + + .account-link { + display: flex; + height: 100%; + justify-content: center; + width: 100px; + column-gap: 8px; + align-items: center; + }` + this.shadowRoot.appendChild(style) + defineAndInject(this, this.shadowRoot) + + this.loginButton.addEventListener("click", () => { + let loginSignup = document.querySelector("login-signup"); + if (loginSignup) { + loginSignup.remove() + } + loginSignup = createFromData("login-signup"); + document.body.appendChild(loginSignup) + loginSignup.addEventListener("finished", (d, e) => { + this.loginCallback() + }) + loginSignup.open() + }) + + isLoggedIn().then((loggedIn) => { + if (loggedIn) { + this.loginCallback() + } + }) + } + + trySignout() { + if (typeof signout === "undefined") { + signout() + } + } + + async loginCallback() { + this.loginButton.style.display = "none" + this.accountOptions.style.display = "flex" + + const accountData = await getAccountData() + if (accountData) { + + } + } +} + +customElements.define("account-options", AccountOptions) diff --git a/Other/component-registrar.js b/Other/component-registrar.js index c75c44b..8376523 100644 --- a/Other/component-registrar.js +++ b/Other/component-registrar.js @@ -1,3 +1,4 @@ +"use strict"; /** * Will instance the given element, returning it so that it can be inserted into the DOM. * @param {HTMLElement} name Element to be instanced @@ -8,7 +9,9 @@ function createFromData(name, data = null) { let element = document.createElement(name) if (data) { for (const [key, value] of Object.entries(data)) { - element.setAttribute(key, value.toString()) + if (value !== undefined) { + element.setAttribute("data-" + key, value.toString()) + } } } // TODO: This causes issues with some nodes wanting to be IN the dom before methods can be used on them diff --git a/Other/content-warning-template.js b/Other/content-warning-template.js index ac63a8a..36376f8 100644 --- a/Other/content-warning-template.js +++ b/Other/content-warning-template.js @@ -1,3 +1,5 @@ +"use strict"; + class ContentWarning extends HTMLElement { constructor() { super() diff --git a/Other/header-template.js b/Other/header-template.js index 65b59d0..3ffdd3c 100644 --- a/Other/header-template.js +++ b/Other/header-template.js @@ -1,3 +1,4 @@ +"use strict"; class SubliminalHeader extends HTMLElement { constructor() { super() @@ -8,7 +9,9 @@ class SubliminalHeader extends HTMLElement { this.shadowRoot.innerHTML = html`
- Dog + + +

Subliminal

` @@ -64,8 +58,8 @@ class SubliminalHeader extends HTMLElement { line-height: 64px; white-space: nowrap; } - - a { + + nav > a { align-self: center; white-space: nowrap; /*Click hitboxes*/ @@ -73,6 +67,11 @@ class SubliminalHeader extends HTMLElement { padding-bottom: 24px; } + nav > a[current] { + background-color: #0074d90d; + border-bottom: 4px solid var(--input-hilight); + } + span, div { font-family: Arial, Helvetica, sans-serif; } @@ -80,24 +79,23 @@ class SubliminalHeader extends HTMLElement { p, a { font-family: Arial, Helvetica, sans-serif; font-size: 110%; - } + } - a[current] { - background-color: #0074d90d; - border-bottom: 4px solid var(--input-hilight); + .logo-button { + display: flex; + cursor: pointer; } - img { + .logo { align-self: center; - cursor: pointer; transition: .2s transform; } - - img:hover { + + .logo:hover { transform: rotate(10deg) scale(1.5); } - - img:active { + + .logo:active { transform: rotate(8deg) scale(1.1); } @@ -113,7 +111,7 @@ class SubliminalHeader extends HTMLElement { column-gap: 8px; padding: 8px; } - + hr { border: none; border-top: 1px solid gray; @@ -129,12 +127,12 @@ class SubliminalHeader extends HTMLElement { display: none; } - img { + .logo { width: 48px; height: 48px; } - a { + nav > a { font-size: 3.4vw; flex: 1 1 auto; white-space: nowrap; @@ -163,7 +161,7 @@ class SubliminalHeader extends HTMLElement { } @media(prefers-color-scheme: dark) { - img { + .logo { filter: invert(1); } @@ -181,19 +179,12 @@ class SubliminalHeader extends HTMLElement { } } - ;(async function(_this){ - if (_this.getAttribute("nologin") || typeof isLoggedIn === "undefined" || typeof isLoggedIn !== "function") { - // TODO: Potentially change right to just display 'The coolest crowdsourced anthology on the web' (delete buttons) - _this.right.style.display = 'none' - console.warn("WARNING: Page has not imported account.js or is requesting nologin. Login UI disabled") - return - } - - if (await isLoggedIn()) { - _this.loginButton.style.display = "none" - _this.logoutButton.style.display = "block" - } - })(this) + if (this.getAttribute("nologin") || typeof isLoggedIn === "undefined" || typeof isLoggedIn !== "function") { + // TODO: Potentially change right to just display 'The coolest crowdsourced anthology on the web' (delete buttons) + this.right.style.display = 'none' + console.warn("WARNING: Page has not imported account.js or is requesting nologin. Login UI disabled") + return + } } } diff --git a/Other/login-template.js b/Other/login-template.js index d39825a..134a60a 100644 --- a/Other/login-template.js +++ b/Other/login-template.js @@ -1,3 +1,4 @@ +"use strict"; class LoginSignup extends HTMLElement { #nocancel = false @@ -203,13 +204,13 @@ class LoginSignup extends HTMLElement { } } - //Impossible to log in without code, GUID can be retrieved though async signin(username, email) { + let signinData = null try { const signinResponse = await fetch(serverBaseAddress + "/auth/signin", { method: "POST", headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify({ Username: username, Email: email }) + body: JSON.stringify({ username, email }) }) if (!signinResponse.ok) { @@ -217,19 +218,16 @@ class LoginSignup extends HTMLElement { return } - const signinData = await signinResponse.json() - - localStorage.accountUsername = username - localStorage.accountEmail = email - //localStorage.accountGuid = signinData.guid - - showMyAccount() + signinData = await signinResponse.json() + //sessionStorage.accountId = signinData.id + //sessionStorage.accountToken = signinData.token + this.login.close() } catch (error) { this.confirmFail(error) } - const finishEvent = new CustomEvent("finished", { type: "signin" }) + const finishEvent = new CustomEvent("finished", { type: "signin", data: signinData }) this.dispatchEvent(finishEvent) } diff --git a/Other/notification-template.js b/Other/notification-template.js index 13ce307..5e269db 100644 --- a/Other/notification-template.js +++ b/Other/notification-template.js @@ -1,3 +1,4 @@ +"use strict"; class SubliminalNotification extends HTMLElement { constructor() { super() diff --git a/Other/poem-canvas-editor-template.js b/Other/poem-canvas-editor-template.js new file mode 100644 index 0000000..02e107c --- /dev/null +++ b/Other/poem-canvas-editor-template.js @@ -0,0 +1,359 @@ +"use strict"; +class PoemCanvasEditor extends HTMLElement { + document = null + canvasScale = 1.5 + cursor = true + + constructor() { + super() + this.attachShadow({ mode: "open" }) + } + + connectedCallback() { + this.shadowRoot.innerHTML = html` + + + + + + +
+ + + + + + + +
` + const style = document.createElement("style") + style.innerHTML = css` + #editorCanvas { + display: block; + width: 100%; + height: 100%; + cursor: text; + } + #editorCanvas:focus { + outline: none; + } + #editorInput { + position: absolute; + opacity: 0; + pointer-events: none; + } + #editorContext { + display: flex; + visibility: hidden; + transition: left 0.1s ease 0s; + position: fixed; + width: 200px; + background-color: var(--button-transparent); + backdrop-filter: blur(5px); + border-radius: 4px; + box-shadow: 0px 0px 10px #656565; + border: 1px solid darkgray; + flex-direction: column; + padding: 4px; + row-gap: 4px; + } + #editorContext > button { + height: 32px; + background-color: transparent; + border: 1px solid var(--button-opaque); + display: flex; + align-items: center; + column-gap: 8px; + transition: .05 transform; + user-select: none; + } + #editorContext > button:hover { + background-color: var(--button-opaque-hover); + } + #editorContext > button:active { + transform: scale(0.98); + } + #editorContext > button > svg { + opacity: 0.6; + fill: var(--text-colour); + } + #editorContext > button > span { + font-weight: bold; + opacity: 0.4; + flex-grow: 1; + text-align: end; + } + .suggestions { + width: 192px; + position: absolute; + background: #bdbdbd; + z-index: 3; + border-radius: 4px; + top: 0px; + display: flex; + background-color: var(--button-transparent); + flex-direction: column; + border: 1px solid gray; + overflow: clip; + overflow-y: scroll; + } + .suggestions-item { + padding: 8px; + display: flex; + } + .suggestions-item > span:nth-child(1) { + flex-grow: 1; + } + .suggestions-item > span:nth-child(2) { + font-size: 10px; + opacity: 0.6; + }` + this.shadowRoot.appendChild(style) + defineAndInject(this, this.shadowRoot) + + // Apply attributes + this.document = new EditorDocument(1.0, 18) + this.canvasScale = Number(this.getAttribute("scale") || 1.5) + this.cursor = !!this.getAttribute("cursor") + this.tabIndex = "0" + + // Event listeners + this.editorInput.addEventListener("keydown", (event) => { + if (!(event.ctrlKey && event.key.toLowerCase() === 'v')) { + this.editorCanvas.dispatchEvent(new event.constructor(event.type, event)) + } + // Uses clipboard API if possible + else if (navigator.clipboard.readText) { + navigator.clipboard.readText() + .then((paste) => { + this.document.insertText(paste) + this.document.renderCanvasData(this.editorCanvas) + }) + .catch((error) => { + alert('Could not paste text. Please give the site access to the clipboard') + }) + } + }) + this.editorInput.addEventListener("paste", (event) => { + // WORKAROUND: For browsers not supporting the navigator clipboard readText API + // we let the paste (usually handled from) keydown event trickle through to an onpaste + // event, catch the text, and then pass it to the editor + if (navigator.clipboard.readText) return + const paste = (event.clipboardData || window.clipboardData).getData('text') + this.document.insertText(paste) + this.document.renderCanvasData(this.editorCanvas) + }) + this.editorCanvas.addEventListener("contextmenu", (event) => { + this.editorContext.style.left = (event.clientX) + 'px' + this.editorContext.style.top = (event.clientY) + 'px' + this.editorContext.style.visibility = 'visible' + return event.preventDefault() + }) + this.editorCanvas.addEventListener("mousedown", (event) => { + if (event.button === 2) return + event.preventDefault() + // TODO: handle virtkeyboard geometry in scrolldown + this.editorInput.focus() + navigator.virtualKeyboard?.show() + this.editorCanvas['pressed'] = true + this.document.clearSelection() + this.document.position = this.document.realToTextPosition(event.offsetX, event.offsetY, this.editorCanvas) + this.document.renderCanvasData(this.editorCanvas, this.cursor) + this.editorContext.style.visibility = 'hidden' + }) + this.editorCanvas.addEventListener("mouseup", (event) => { + this.editorCanvas['pressed'] = false + }) + this.editorCanvas.addEventListener("mousemove", (event) => { + if (this.editorCanvas['pressed']) { + let endPosition = this.document.realToTextPosition(event.offsetX, event.offsetY, this.editorCanvas) + this.document.selection.start = this.document.position > endPosition ? endPosition : this.document.position + this.document.selection.end = this.document.position > endPosition ? this.document.position : endPosition + this.document.renderCanvasData(this.editorCanvas, this.cursor) + } + }) + this.editorCanvas.addEventListener("dblclick", (event) => { + // TODO: Select word on mobile handles + }) + this.editorCanvas.addEventListener("keydown", (event) => { + if (event.key === 'Backspace') { + this.document.deleteText() + } + else if (event.key === 'Delete') { + this.document.deleteText(-1) + } + else if (event.key === 'Enter') { + this.document.addNewLine() + // TODO: only scroll down if cursor becomes off the screen + setTimeout(() => window.scrollTo(0, 1e5), 10) + } + else if (event.key === 'ArrowLeft' || event.key === 'ArrowRight' || event.key === 'ArrowUp' || event.key === 'ArrowDown') { + this.document.movePosition( + event.key == 'ArrowLeft' + ? positionMovements.left + : event.key == 'ArrowRight' + ? positionMovements.right + : event.key == 'ArrowUp' + ? positionMovements.up + : positionMovements.down, event.shiftKey) + } + else if (event.key == 'Home') { + throw new Error('\'Home\' control key is not implemented') + } + else if (event.key == 'End') { + throw new Error('\'End\' control key is not implemented') + } + else if (event.key == 'Tab') { + this.document.insertText('\t') + } + else if (event.key === 'Shift' || event.key.length > 1) { + return + } + else if (event.ctrlKey) { + switch (event.key.toLowerCase()) { + case 'a': { + this.document.selectAll() + break + } + case 'x': { + navigator.clipboard.writeText(this.document.getSelectionText()) + this.document.deleteSelection() + break + } + case 'c': { + navigator.clipboard.writeText(this.document.getSelectionText()) + break + } + case 'v': { + if (navigator.clipboard.readText) { // HACK: See handler in input catcher + navigator.clipboard.readText().then((clipText) => this.document.insertText(clipText)) + } + break + } + } + } + else { + this.document.insertText(event.key) + } + this.document.renderCanvasData(this.editorCanvas,this.cursor) + }) + this.editorCanvas.addEventListener("blur", (event) => { + this.document.renderCanvasData(this.editorCanvas, false) + }) + this.editorCanvas.addEventListener("focus", (event) => { + this.document.renderCanvasData(this.editorCanvas, this.cursor) + }) + + // External handlers + this.addEventListener("blur", () => { + this.editorContext.style.visibility = 'hidden' + }) + window.addEventListener("resize", () => { + this.updateCanvas() + }) + this.updateCanvas() + this.syncInputCatcher() + } + + useDocument(document) { + this.document = document + this.updateCanvas() + this.syncInputCatcher() + } + + syncInputCatcher() { + // Ideally input catcher is a 100% plaintext synced version of the canvas render + // output, manual intervention is required for slight discrepancies between how + // the real input catcher and emulated canvas text editor work + this.editorInput.textContent = this.document.getText() + this.editorInput.style.width = this.editorCanvas.offsetWidth + "px" + this.editorInput.style.height = this.editorCanvas.offsetHeight + "px" + } + + updateCanvas() { + this.editorCanvas.width = this.editorCanvas.offsetWidth * this.canvasScale + this.editorCanvas.height = this.editorCanvas.offsetHeight * this.canvasScale + this.document.renderCanvasData(this.editorCanvas, this.cursor) + } +} + +customElements.define("poem-canvas-editor", PoemCanvasEditor) \ No newline at end of file diff --git a/Other/poem-ghost-template.js b/Other/poem-ghost-template.js index eaa383f..1e8c91a 100644 --- a/Other/poem-ghost-template.js +++ b/Other/poem-ghost-template.js @@ -1,3 +1,4 @@ +"use strict"; class PoemGhost extends HTMLElement { constructor() { super() diff --git a/Other/poem-load-cover-template.js b/Other/poem-load-cover-template.js index 17bdfae..1668587 100644 --- a/Other/poem-load-cover-template.js +++ b/Other/poem-load-cover-template.js @@ -1,3 +1,4 @@ +"use strict"; class PoemLoadCover extends HTMLElement { constructor() { super() diff --git a/Other/purgatory-entry-template.js b/Other/purgatory-entry-template.js index 7610518..eba1190 100644 --- a/Other/purgatory-entry-template.js +++ b/Other/purgatory-entry-template.js @@ -1,3 +1,4 @@ +"use strict"; class PurgatoryEntry extends HTMLElement { constructor() { super() @@ -8,23 +9,23 @@ class PurgatoryEntry extends HTMLElement { // TODO: Clear up slightly XSS prone string interpolations this.shadowRoot.innerHTML = html`
- ${this.getAttribute('notification') + ${this.getAttribute('data-notification') ? html`

- ${this.getAttribute('notification')} + ${this.getAttribute('data-notification')}

` : ''} - ${this.getAttribute('tooltip') + ${this.getAttribute('data-tooltip') ? html`

` : ''}

- By ${this.getAttribute('author')} -
+ By ${this.getAttribute('data-author')} +
-
+
@@ -86,6 +87,12 @@ class PurgatoryEntry extends HTMLElement { flex-direction: row; margin-left: 8px; margin-right: 8px; + column-gap: 8px; + } + + .vote-container { + display: flex; + flex: 1; } svg { @@ -106,14 +113,14 @@ class PurgatoryEntry extends HTMLElement { defineAndInject(this, this.shadowRoot) this.setAttribute("tabindex", "0") - if (this.getAttribute("tooltip")) { + if (this.getAttribute("data-tooltip")) { } - this.poemPreview.textContent = this.getAttribute("preview") - this.poemName.textContent = this.getAttribute("name") - this.approves.textContent = this.getAttribute("approves") - this.vetoes.textContent = this.getAttribute("vetoes") + this.poemPreview.textContent = this.getAttribute("data-preview") + this.poemName.textContent = this.getAttribute("data-name") + this.approves.textContent = this.getAttribute("data-approves") + this.vetoes.textContent = this.getAttribute("data-vetoes") if (this.getAttribute("new")) { setTimeout(() => { @@ -132,12 +139,11 @@ class PurgatoryEntry extends HTMLElement { this.classList.remove("entry-new") }, 1600) } - this.onclick = function() { - const guid = this.getAttribute("guid") - if (guid) { - window.location.href = "./purgatory-poem?guid=" + guid + this.addEventListener("click", function() { + if (this.dataset.id) { + window.location.href = "./purgatory-poem?id=" + this.dataset.id } - } + }) } } diff --git a/Other/report-template.js b/Other/report-template.js index 0b0790f..3cfb34a 100644 --- a/Other/report-template.js +++ b/Other/report-template.js @@ -1,3 +1,4 @@ +"use strict"; class ReportPopup extends HTMLElement { constructor() { super() diff --git a/Other/select-template.js b/Other/select-template.js index 550367a..abaef8d 100644 --- a/Other/select-template.js +++ b/Other/select-template.js @@ -1,3 +1,4 @@ +"use strict"; class SubliminalSelect extends HTMLElement { constructor() { super() diff --git a/Resources/AbbstraktDog.ico b/Resources/AbbstraktDog.ico new file mode 100644 index 0000000..e337369 Binary files /dev/null and b/Resources/AbbstraktDog.ico differ diff --git a/Resources/AbbstrakDog.png b/Resources/AbbstraktDog.png similarity index 100% rename from Resources/AbbstrakDog.png rename to Resources/AbbstraktDog.png diff --git a/SubliminalServer/.config/dotnet-tools.json b/SubliminalServer/.config/dotnet-tools.json index d9d129c..071b4ee 100644 --- a/SubliminalServer/.config/dotnet-tools.json +++ b/SubliminalServer/.config/dotnet-tools.json @@ -3,7 +3,7 @@ "isRoot": true, "tools": { "dotnet-ef": { - "version": "8.0.3", + "version": "8.0.8", "commands": [ "dotnet-ef" ] diff --git a/SubliminalServer/ApiModel/AvatarRequest.cs b/SubliminalServer/ApiModel/AvatarRequest.cs new file mode 100644 index 0000000..0c4bb2c --- /dev/null +++ b/SubliminalServer/ApiModel/AvatarRequest.cs @@ -0,0 +1,3 @@ +namespace SubliminalServer.ApiModel; + +public record AvatarRequest(string MimeType, string Data); \ No newline at end of file diff --git a/SubliminalServer/AuthorizationMiddleware.cs b/SubliminalServer/AuthorizationMiddleware.cs deleted file mode 100644 index d2e99a3..0000000 --- a/SubliminalServer/AuthorizationMiddleware.cs +++ /dev/null @@ -1,29 +0,0 @@ -using Microsoft.EntityFrameworkCore; - -namespace SubliminalServer; - -public class AuthorizationMiddleware -{ - private readonly RequestDelegate nextRequest; - private readonly DatabaseContext databaseContext; - - public AuthorizationMiddleware(RequestDelegate nextReq, DatabaseContext db) - { - nextRequest = nextReq; - databaseContext = db; - } - - public async Task Invoke(HttpContext context) - { - var accountToken = context.Request.Cookies["Token"]; - - if (accountToken != null) - { - var account = await databaseContext.Accounts - .SingleOrDefaultAsync(account => account.Token == accountToken); - context.Items["Account"] = account; - } - - await nextRequest(context); - } -} \ No newline at end of file diff --git a/SubliminalServer/DataModel/Account/AccountAddress.cs b/SubliminalServer/DataModel/Account/AccountClient.cs similarity index 53% rename from SubliminalServer/DataModel/Account/AccountAddress.cs rename to SubliminalServer/DataModel/Account/AccountClient.cs index c94172d..24d6e45 100644 --- a/SubliminalServer/DataModel/Account/AccountAddress.cs +++ b/SubliminalServer/DataModel/Account/AccountClient.cs @@ -5,18 +5,28 @@ namespace SubliminalServer.DataModel.Account; [PrimaryKey(nameof(Id))] -public class AccountAddress +public class AccountClient { - // Unique, Primary key [Required] [DatabaseGenerated(DatabaseGeneratedOption.Identity)] public int Id { get; set; } + public string IpAddress { get; set; } + public string UserAgent { get; set; } public DateTime LastUsed { get; set; } - // Foreign key AccountData - public int AccountKey { get; set; } - + public int AccountId { get; set; } // Navigation property to the parent AccounData public AccountData Account { get; set; } + + // EFCore constructor - Don't use + public AccountClient() { } + + public AccountClient(string ipAddress, string userAgent, int accountId, DateTime? lastUsed = null) + { + IpAddress = ipAddress; + UserAgent = userAgent; + AccountId = accountId; + LastUsed = lastUsed ?? DateTime.Now; + } } \ No newline at end of file diff --git a/SubliminalServer/DataModel/Account/AccountData.cs b/SubliminalServer/DataModel/Account/AccountData.cs index b22caf0..601229c 100644 --- a/SubliminalServer/DataModel/Account/AccountData.cs +++ b/SubliminalServer/DataModel/Account/AccountData.cs @@ -20,7 +20,7 @@ public class AccountData : AccountProfile // Navigation property [JsonIgnore] - public List KnownIPs { get; set; } + public List KnownIPs { get; set; } // Navigation property [JsonIgnore] public List Drafts { get; set; } @@ -35,7 +35,7 @@ public AccountData(string username, string email, DateTime joinDate, string toke { Token = token; Email = email; - KnownIPs = new List(); + KnownIPs = new List(); Drafts = new List(); Blocked = new List(); LikedPoems = new List(); diff --git a/SubliminalServer/DataModel/Configurations/AccountAddressConfiguration.cs b/SubliminalServer/DataModel/Configurations/AccountAddressConfiguration.cs deleted file mode 100644 index f061dc5..0000000 --- a/SubliminalServer/DataModel/Configurations/AccountAddressConfiguration.cs +++ /dev/null @@ -1,20 +0,0 @@ -using Microsoft.EntityFrameworkCore; -using Microsoft.EntityFrameworkCore.Metadata.Builders; -using SubliminalServer.DataModel.Account; - -namespace SubliminalServer.DataModel.Configurations; - -public class AccountAddressConfiguration : IEntityTypeConfiguration -{ - public void Configure(EntityTypeBuilder builder) - { - builder.HasKey(address => address.Id); - builder.Property(address => address.Id) - .ValueGeneratedOnAdd(); - - // One to many (AccountData) - builder.HasOne(address => address.Account) - .WithMany(account => account.KnownIPs) - .HasForeignKey(address => address.Id); - } -} diff --git a/SubliminalServer/DataModel/Configurations/AccountClientConfiguration.cs b/SubliminalServer/DataModel/Configurations/AccountClientConfiguration.cs new file mode 100644 index 0000000..4912a5a --- /dev/null +++ b/SubliminalServer/DataModel/Configurations/AccountClientConfiguration.cs @@ -0,0 +1,16 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Metadata.Builders; +using SubliminalServer.DataModel.Account; + +namespace SubliminalServer.DataModel.Configurations; + +public class AccountClientConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + // One to many (AccountData) + builder.HasOne(client => client.Account) + .WithMany(account => account.KnownIPs) + .HasForeignKey(client => client.AccountId); + } +} diff --git a/SubliminalServer/DataModel/Configurations/AccountDataConfiguration.cs b/SubliminalServer/DataModel/Configurations/AccountDataConfiguration.cs index 579f347..bd5cc21 100644 --- a/SubliminalServer/DataModel/Configurations/AccountDataConfiguration.cs +++ b/SubliminalServer/DataModel/Configurations/AccountDataConfiguration.cs @@ -34,7 +34,7 @@ public void Configure(EntityTypeBuilder builder) // One to many IPs (AccountBadge) builder.HasMany(mainEntity => mainEntity.KnownIPs) .WithOne(address => address.Account) - .HasForeignKey(address => address.AccountKey); + .HasForeignKey(address => address.AccountId); // Many to many AccountData (Blocked), AccountData (BlockedBy) builder.HasMany(account => account.Blocked) diff --git a/SubliminalServer/DataModel/Purgatory/PurgatoryEntry.cs b/SubliminalServer/DataModel/Purgatory/PurgatoryEntry.cs index fedd3cc..4eaeb93 100644 --- a/SubliminalServer/DataModel/Purgatory/PurgatoryEntry.cs +++ b/SubliminalServer/DataModel/Purgatory/PurgatoryEntry.cs @@ -56,5 +56,6 @@ public class PurgatoryEntry : IDatabasePoem public int Approves { get; set; } public int Vetoes { get; set; } public DateTime DateCreated { get; set; } + // TODO: Make pick object instead to track who assigned what pick public bool Pick { get; set; } } \ No newline at end of file diff --git a/SubliminalServer/DataModel/Report/AccountReport.cs b/SubliminalServer/DataModel/Report/AccountReport.cs index c52ecf4..b78678a 100644 --- a/SubliminalServer/DataModel/Report/AccountReport.cs +++ b/SubliminalServer/DataModel/Report/AccountReport.cs @@ -9,6 +9,7 @@ public class AccountReport : Report [Required] [ForeignKey(nameof(Account))] public int AccountId { get; set; } + // Navigation property to reported account public AccountData Account { get; set; } } \ No newline at end of file diff --git a/SubliminalServer/DataModel/Report/PurgatoryReport.cs b/SubliminalServer/DataModel/Report/PurgatoryReport.cs index 916b65e..d9cf2be 100644 --- a/SubliminalServer/DataModel/Report/PurgatoryReport.cs +++ b/SubliminalServer/DataModel/Report/PurgatoryReport.cs @@ -9,5 +9,6 @@ public class PurgatoryReport : Report [Required] [ForeignKey(nameof(Poem))] public int PoemId { get; set; } + // Navigation property to reporteed poem public PurgatoryEntry Poem { get; set; } } \ No newline at end of file diff --git a/SubliminalServer/DataModel/Report/Report.cs b/SubliminalServer/DataModel/Report/Report.cs index 141cb05..3bf93fb 100644 --- a/SubliminalServer/DataModel/Report/Report.cs +++ b/SubliminalServer/DataModel/Report/Report.cs @@ -16,7 +16,7 @@ public class Report // Foreign key Account Data [Required] [ForeignKey(nameof(Reporter))] - public int ReporterKey { get; set; } + public int ReporterId { get; set; } public AccountData Reporter { get; set; } [MaxLength(300)] diff --git a/SubliminalServer/DatabaseContext.cs b/SubliminalServer/DatabaseContext.cs index 7e6160b..56a2a41 100644 --- a/SubliminalServer/DatabaseContext.cs +++ b/SubliminalServer/DatabaseContext.cs @@ -11,7 +11,7 @@ public class DatabaseContext : DbContext { public DbSet Accounts { get; set; } public DbSet AccountBadges { get; set; } - public DbSet AccountAddressInfos { get; set; } + public DbSet AccountClients { get; set; } public DbSet PurgatoryDrafts { get; set; } public DbSet PurgatoryEntries { get; set; } @@ -32,7 +32,7 @@ public DatabaseContext(DbContextOptions options) : base(options protected override void OnModelCreating(ModelBuilder modelBuilder) { modelBuilder.ApplyConfiguration(new AccountDataConfiguration()); - modelBuilder.ApplyConfiguration(new AccountAddressConfiguration()); + modelBuilder.ApplyConfiguration(new AccountClientConfiguration()); modelBuilder.ApplyConfiguration(new AccountBadgeConfiguration()); modelBuilder.ApplyConfiguration(new PurgatoryEntryConfiguration()); modelBuilder.ApplyConfiguration(new PurgatoryTagConfiguration()); diff --git a/SubliminalServer/EnsureAuthorizationMiddleware.cs b/SubliminalServer/EnsureAuthorizationMiddleware.cs deleted file mode 100644 index b613820..0000000 --- a/SubliminalServer/EnsureAuthorizationMiddleware.cs +++ /dev/null @@ -1,25 +0,0 @@ -using SubliminalServer.DataModel.Account; - -namespace SubliminalServer; - -public class EnsureAuthorizationMiddleware -{ - private readonly RequestDelegate nextRequest; - - public EnsureAuthorizationMiddleware(RequestDelegate nextReq) - { - nextRequest = nextReq; - } - - public async Task Invoke(HttpContext context) - { - var account = context.Items["Account"]; - if (account is not AccountData) - { - context.Response.StatusCode = StatusCodes.Status401Unauthorized; - await context.Response.WriteAsync("This endpoint requires account authorisation."); - } - - await nextRequest(context); - } -} \ No newline at end of file diff --git a/SubliminalServer/EnsuredAuthorizationMiddleware.cs b/SubliminalServer/EnsuredAuthorizationMiddleware.cs new file mode 100644 index 0000000..ff0b82f --- /dev/null +++ b/SubliminalServer/EnsuredAuthorizationMiddleware.cs @@ -0,0 +1,41 @@ +using Microsoft.EntityFrameworkCore; +using SubliminalServer.DataModel.Account; + +namespace SubliminalServer; + +public class EnsuredAuthorizationMiddleware +{ + private readonly RequestDelegate nextRequest; + + public EnsuredAuthorizationMiddleware(RequestDelegate nextRequest) + { + this.nextRequest = nextRequest; + } + + public async Task InvokeAsync(HttpContext context, DatabaseContext database) + { + var token = GetRequestToken(context); + if (token is null || await GetTokenAccount(token, database) is not { } account) + { + context.Response.StatusCode = StatusCodes.Status401Unauthorized; + await context.Response.WriteAsJsonAsync(new { Message = "Invalid token provided in auth header" }); + return; + } + + context.Items["Account"] = account; + await nextRequest(context); + } + + private static async Task GetTokenAccount(string token, DatabaseContext database) + { + var account = await database.Accounts.FirstOrDefaultAsync(account => account.Token == token); + return account; + } + + private static string? GetRequestToken(HttpContext context) + { + var token = context.Request.Headers.Authorization.FirstOrDefault() + ?? context.Request.Cookies["Token"] ?? context.Request.Query["token"].FirstOrDefault(); + return token; + } +} \ No newline at end of file diff --git a/SubliminalServer/Extensions.cs b/SubliminalServer/Extensions.cs new file mode 100644 index 0000000..e500cd2 --- /dev/null +++ b/SubliminalServer/Extensions.cs @@ -0,0 +1,17 @@ +namespace SubliminalServer; + +using System.Text.RegularExpressions; + +public static class Extensions +{ + public delegate Regex PathMatchRegex(); + public static RouteHandlerBuilder UseMiddleware(this RouteHandlerBuilder builder, WebApplication app, PathMatchRegex predicate, params object?[] args) + { + app.UseWhen + ( + context => predicate().IsMatch(context.Request.Path), + appBuilder => appBuilder.UseMiddleware(args) + ); + return builder; + } +} \ No newline at end of file diff --git a/SubliminalServer/Program.Accounts.cs b/SubliminalServer/Program.Accounts.cs index 8685100..c5ea658 100644 --- a/SubliminalServer/Program.Accounts.cs +++ b/SubliminalServer/Program.Accounts.cs @@ -1,3 +1,4 @@ +using System.Text.RegularExpressions; using Microsoft.AspNetCore.Mvc; using SubliminalServer.ApiModel; using SubliminalServer.DataModel.Account; @@ -6,8 +7,12 @@ namespace SubliminalServer; -public static partial class Program +internal static partial class Program { + // /accounts/{id:int} + [GeneratedRegex(@"^\/accounts\/\d+\/report\/*$")] + private static partial Regex AccountReportEndpointRegex(); + private static void AddAccountEndpoints() { // Account action endpoints @@ -26,7 +31,7 @@ private static void AddAccountEndpoints() throw new NotImplementedException(); }); - httpServer.MapPost("/accounts/{accountId}/report", (int accountId, [FromBody] UploadableReport reportUpload, [FromServices] DatabaseContext database, HttpContext context) => + var reportEndpoint = httpServer.MapPost("/accounts/{accountId}/report", (int accountId, [FromBody] UploadableReport reportUpload, [FromServices] DatabaseContext database, HttpContext context) => { var validationIssues = new Dictionary(); if (reportUpload.Reason.Length > 300) @@ -53,60 +58,118 @@ private static void AddAccountEndpoints() } var account = (AccountData) context.Items["Account"]!; - /*var report = new Report() + var report = new AccountReport() { - ReporterKey = account.Id, - TargetKey = reportUpload.TargetKey, + ReporterId = account.Id, + AccountId = reportUpload.TargetKey, Reason = reportUpload.Reason, ReportType = reportUpload.ReportType, ReportTargetType = reportUpload.TargetType, DateCreated = DateTime.UtcNow }; - database.Reports.Add(report); - database.SaveChanges();*/ + database.AccountReports.Add(report); + database.SaveChanges(); return Results.Ok(); - }); - // TODO: Reimplement this - //rateLimitEndpoints.Add("/accounts/{accountId}/report", (1, TimeSpan.FromSeconds(60))); - //authRequiredEndpoints.Add("/accounts/{accountId}/report"); + }).UseMiddleware(httpServer, AccountReportEndpointRegex); + if (!httpServer.Environment.IsDevelopment()) + { + httpServer.UseWhen + ( + context => AccountReportEndpointRegex().IsMatch(context.Request.Path), + appBuilder => appBuilder.UseMiddleware(1, TimeSpan.FromSeconds(60)) + ); + } httpServer.MapPost("/accounts/{accountId}/unfollow", ([FromBody] string userId, HttpContext context) => { throw new NotImplementedException(); }); - // Personal account endpoints - httpServer.MapPost("/accounts/me/email", ([FromBody] string email, HttpContext context) => + httpServer.MapGet("/accounts/me", (HttpContext context, DatabaseContext dbContext) => { - throw new NotImplementedException(); + var account = context.Items["Account"] as AccountData; + return Results.Ok(account); }); - httpServer.MapPost("/accounts/me/pen-name", ([FromBody] string penName, HttpContext context) => + httpServer.MapPost("/accounts/me/email", async ([FromBody] string email, HttpContext context, DatabaseContext dbContext) => { - throw new NotImplementedException(); + var account = context.Items["Account"] as AccountData; + account!.Email = email; + await dbContext.SaveChangesAsync(); + return Results.Ok(); }); - httpServer.MapPost("/accounts/me/biography", ([FromBody] string biography, HttpContext context) => + httpServer.MapPost("/accounts/me/pen-name", async ([FromBody] string penName, HttpContext context, DatabaseContext dbContext) => { - - throw new NotImplementedException(); + var account = context.Items["Account"] as AccountData; + account!.PenName = penName; + await dbContext.SaveChangesAsync(); + return Results.Ok(); }); - httpServer.MapPost("/accounts/me/location", ([FromBody] string location, HttpContext context) => + httpServer.MapPost("/accounts/me/biography", async ([FromBody] string biography, HttpContext context, DatabaseContext dbContext) => { - throw new NotImplementedException(); + var account = context.Items["Account"] as AccountData; + account!.Biography = biography; + await dbContext.SaveChangesAsync(); + return Results.Ok(); }); - httpServer.MapPost("/accounts/me/role", ([FromBody] string role, HttpContext context) => + httpServer.MapPost("/accounts/me/location", async ([FromBody] string location, HttpContext context, DatabaseContext dbContext) => { - throw new NotImplementedException(); + var account = context.Items["Account"] as AccountData; + account!.Location = location; + await dbContext.SaveChangesAsync(); + return Results.Ok(); }); - httpServer.MapPost("/accounts/me/avatar", ([FromBody] string avatarUrl, HttpContext context) => + httpServer.MapPost("/accounts/me/role", async ([FromBody] string role, HttpContext context, DatabaseContext dbContext) => { - throw new NotImplementedException(); + var account = context.Items["Account"] as AccountData; + account!.Role = role; + await dbContext.SaveChangesAsync(); + return Results.Ok(); }); + + var allowedAvatarMimes = new Dictionary + { + { "image/png", ".png" }, + { "image/jpeg", ".jpg" }, + { "image/webp", ".webp" }, + { "image/gif", ".gif" } + }; + httpServer.MapPost("/accounts/me/avatar", async ([FromBody] AvatarRequest pictureRequest, HttpContext context, DatabaseContext dbContext) => + { + // Only allow user to access their own account + var account = (AccountData)context.Items["Account"]!; + + if (!allowedAvatarMimes.TryGetValue(pictureRequest.MimeType, out var fileExtension)) + { + return Results.BadRequest(new { Message = "Supplied image was not of a valid format" }); + } + var fileName = account.Id + fileExtension; + var savePath = Path.Combine(profileImagesDir.FullName, fileName); + var fileData = Convert.FromBase64String(pictureRequest.Data); + if (fileData.Length > 25e5) + { + return Results.BadRequest(new { Message = "Supplied image can not be more than 2.5MB" }); + } + + if (account.AvatarUrl is not null) + { + var previousFile = Path.Combine(profileImagesDir.FullName, account.AvatarUrl.Split("/").Last()); + File.Delete(previousFile); + } + + await File.WriteAllBytesAsync(savePath, fileData); + account.AvatarUrl = $"/profiles/avatars/{fileName}"; + await dbContext.SaveChangesAsync(); + return Results.Ok(); + }); + + // Protect personal endpoints with the auth required middleware to ensure they can not be called otherwise + authRequiredEndpoints.Add("/accounts/me"); } } \ No newline at end of file diff --git a/SubliminalServer/Program.Auth.cs b/SubliminalServer/Program.Auth.cs index 14db4d3..4d66d37 100644 --- a/SubliminalServer/Program.Auth.cs +++ b/SubliminalServer/Program.Auth.cs @@ -1,16 +1,17 @@ using Microsoft.AspNetCore.Mvc; using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Storage; using SubliminalServer.ApiModel; using SubliminalServer.DataModel.Account; namespace SubliminalServer; -public static partial class Program +internal static partial class Program { private static void AddAuthEndpoints() { //Creates a new account with a provided pen name, and then gives the client the credentials for their created account - httpServer.MapPost("/auth/signup", static ([FromBody] LoginDetails details, [FromServices] DatabaseContext database, HttpContext context) => + httpServer.MapPost("/auth/signup", async ([FromBody] LoginDetails details, [FromServices] DatabaseContext database, HttpContext context) => { if (!PermissibleUsernameRegex().IsMatch(details.Username)) { @@ -28,29 +29,25 @@ private static void AddAuthEndpoints() // TODO: Email validation, this will all be moved elsewhere var tokenString = GenerateToken(); var account = new AccountData(details.Username, details.Email, DateTime.UtcNow, tokenString); + database.Accounts.Add(account); + await database.SaveChangesAsync(); // Rate limit middleware should have passed us a nicely sanitised IP. Otherwise we will just fallback - var requestIp = context.Items["RealIp"] as string ?? context.Connection.RemoteIpAddress?.ToString(); + var requestIp = GetRequestIp(context); + var userAgent = context.Request.Headers.UserAgent.ToString(); if (requestIp is null) { return Results.Forbid(); } - account.KnownIPs.Add(new AccountAddress() - { - IpAddress = requestIp - }); - database.Accounts.Add(account); - database.SaveChanges(); + await UpdateAccountClients(requestIp, userAgent, account, database); - context.Response.Cookies.Append("Token", tokenString, new CookieOptions() - { - HttpOnly = true, - SameSite = SameSiteMode.Strict, - Expires = DateTimeOffset.UtcNow.AddMonths(1) - }); + + // Add auth cookie for subsequent requests + AppendTokenCookie(account.Token, httpServer, context); + // If for some reason they can not persist the cookie, we also send them the token so that they may save it somwehere // secure on certain platforms, such as a third party non-web client. - return Results.Ok(account.Token); + return Results.Ok(new { account.Token, account.Id}); }); if (!httpServer.Environment.IsDevelopment()) { @@ -58,8 +55,8 @@ private static void AddAuthEndpoints() sizeLimitEndpoints.Add("/auth/signup", PayloadSize.FromKilobytes(5)); } - // Allows a user to signin and receive account data - httpServer.MapPost("/auth/signin/token", ([FromBody] string? token, [FromServices] DatabaseContext database, HttpContext context) => + // Allows a user to signin and receive account data + httpServer.MapPost("/auth/signin/token", async ([FromBody] string? token, [FromServices] DatabaseContext database, HttpContext context) => { if (string.IsNullOrEmpty(token)) { @@ -73,7 +70,7 @@ private static void AddAuthEndpoints() } // Completely invalid token - Reject - var expiryString = token.Split(";").Last(); + var expiryString = token.Split("_").Last(); if (!long.TryParse(expiryString, out var expiry)) { return Results.Unauthorized(); @@ -93,18 +90,18 @@ private static void AddAuthEndpoints() } // Rate limit middleware should have passed us a nicely sanitised IP. Otherwise we will just fallback - var requestIp = context.Items["RealIp"] as string ?? context.Connection.RemoteIpAddress?.ToString(); + var requestIp = GetRequestIp(context); + var userAgent = context.Request.Headers.UserAgent.ToString(); if (requestIp is null) { return Results.Forbid(); } - account.KnownIPs.Add(new AccountAddress() - { - IpAddress = requestIp - }); - database.SaveChanges(); + await UpdateAccountClients(requestIp, userAgent, account, database); + + // Add auth cookie for subsequent requests + AppendTokenCookie(account.Token, httpServer, context); - return Results.Json(account); + return Results.Ok(new { account.Token, account.Id}); }); if (!httpServer.Environment.IsDevelopment()) { @@ -123,46 +120,84 @@ private static void AddAuthEndpoints() // If the current account token is expired, we will generate a new one, // we will also give them the token cookie regardless - var expiryString = account.Token.Split(";").Last(); + var expiryString = account.Token.Split("_").Last(); if (long.Parse(expiryString) < DateTimeOffset.UtcNow.ToUnixTimeSeconds()) { var tokenString = GenerateToken(); account.Token = tokenString; - database.SaveChanges(); + await database.SaveChangesAsync(); } // Rate limit middleware should have passed us a nicely sanitised IP. Otherwise we will just fallback - var requestIp = context.Items["RealIp"] as string ?? context.Connection.RemoteIpAddress?.ToString(); + var requestIp = GetRequestIp(context); + var userAgent = context.Request.Headers.UserAgent.ToString(); if (requestIp is null) { return Results.Forbid(); } - var addressInfo = await database.AccountAddressInfos - .SingleOrDefaultAsync(info => info.IpAddress == requestIp); - if (addressInfo is null) + await UpdateAccountClients(requestIp, userAgent, account, database); + + // Add auth cookie for subsequent requests + AppendTokenCookie(account.Token, httpServer, context); + + return Results.Ok(new { account.Token, account.Id}); + }); + if (!httpServer.Environment.IsDevelopment()) + { + rateLimitEndpoints.Add("/auth/signin", (1, TimeSpan.FromSeconds(1))); + sizeLimitEndpoints.Add("/auth/signin", PayloadSize.FromKilobytes(5)); + } + + httpServer.MapPost("/auth/signout", (HttpContext context) => + { + if (context.Request.Cookies["Token"] != null) { - account.KnownIPs.Add(new AccountAddress() + context.Response.Cookies.Delete("Token", new CookieOptions() { - IpAddress = requestIp, - LastUsed = DateTime.Now + HttpOnly = true }); } - else - { - addressInfo.LastUsed = DateTime.Now; - } - await database.SaveChangesAsync(); - context.Response.Cookies.Append("Token", account.Token, new CookieOptions() - { - HttpOnly = true, - SameSite = SameSiteMode.Strict, - Expires = DateTimeOffset.UtcNow.AddMonths(1) - }); - - return Results.Json(account); + return Results.Ok(); }); - rateLimitEndpoints.Add("/auth/signin", (1, TimeSpan.FromSeconds(1))); - sizeLimitEndpoints.Add("/auth/signin", PayloadSize.FromKilobytes(5)); + } + + private static string? GetRequestIp(HttpContext context) + { + return context.Items["RealIp"] as string ?? context.Connection.RemoteIpAddress?.ToString(); + } + + private static async Task UpdateAccountClients(string requestIp, string userAgent, AccountData account, DatabaseContext database) + { + var accountClient = await database.AccountClients + .SingleOrDefaultAsync(info => + info.IpAddress == requestIp + && info.AccountId == account.Id + && info.UserAgent == userAgent); + if (accountClient is null) + { + var newClient = new AccountClient(requestIp, userAgent, account.Id); + database.AccountClients.Add(newClient); + } + else + { + accountClient.LastUsed = DateTime.Now; + } + await database.SaveChangesAsync(); + } + + private static void AppendTokenCookie(string token, WebApplication app, HttpContext context) + { + var cookieOptions = new CookieOptions + { + HttpOnly = true, + Secure = true, + SameSite = config!.CorsCookie ? SameSiteMode.Lax : SameSiteMode.None, + Expires = DateTimeOffset.UtcNow.AddMonths(1), + Domain = context.Request.Host.Host, + Path = "/" + }; + + context.Response.Cookies.Append("Token", token, cookieOptions); } } \ No newline at end of file diff --git a/SubliminalServer/Program.Profiles.cs b/SubliminalServer/Program.Profiles.cs index c2d0da5..59a4b47 100644 --- a/SubliminalServer/Program.Profiles.cs +++ b/SubliminalServer/Program.Profiles.cs @@ -3,7 +3,7 @@ namespace SubliminalServer; -public static partial class Program +internal static partial class Program { private static void AddProfileEndpoints() { @@ -19,8 +19,7 @@ private static void AddProfileEndpoints() } var profile = new UploadableProfile(account); - return Results.Json(profile); + return Results.Ok(profile); }); - rateLimitEndpoints.Add("/Profiles", (1, TimeSpan.FromMilliseconds(500))); } } \ No newline at end of file diff --git a/SubliminalServer/Program.Purgatory.cs b/SubliminalServer/Program.Purgatory.cs index c67dcec..76700b8 100644 --- a/SubliminalServer/Program.Purgatory.cs +++ b/SubliminalServer/Program.Purgatory.cs @@ -1,65 +1,37 @@ +using System.Text.RegularExpressions; using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; using SubliminalServer.ApiModel; using SubliminalServer.DataModel.Account; using SubliminalServer.DataModel.Purgatory; +using SubliminalServer.DataModel.Report; namespace SubliminalServer; -public static partial class Program +internal static partial class Program { + // /accounts/{id:int} + [GeneratedRegex(@"^\/purgatory\/\d+\/report\/*$")] + private static partial Regex PurgatoryReportEndpointRegex(); + [GeneratedRegex(@"^\/purgatory\/\d+\/report\/*$")] + private static partial Regex PurgatoryEndpointRegex(); + + private static void AddPurgatoryEndpoints() { - httpServer.MapGet("/purgatory/{poemId}/report", (string poemId) => - { - Console.ForegroundColor = ConsoleColor.Yellow; - Console.WriteLine($"WIP: Report function - Poem {poemId} has been reported, please investigate!"); - Console.ResetColor(); - return Results.Ok(); - }); - // TODO: Reimplement this - //authRequiredEndpoints.Add("/purgatory/{poemId}/report"); - //rateLimitEndpoints.Add("/purgatory/{poemId}/report", (1, TimeSpan.FromSeconds(5))); - //sizeLimitEndpoints.Add("/purgatory/{poemId}/report", PayloadSize.FromKilobytes(100)); - - httpServer.MapGet("/purgatory/picks", ([FromServices] DatabaseContext database) => + httpServer.MapGet("/purgatory/{poemId:int}", async (int poemId, DatabaseContext dbContext) => { - var entries = database.PurgatoryEntries - .Where(entry => entry.Pick == true) - .Select(entry => entry.Id); - return Results.Json(entries); - }); - rateLimitEndpoints.Add("/purgatory/picks", (1, TimeSpan.FromSeconds(2))); - - httpServer.MapGet("/purgatory/after", ([FromQuery(Name = "date")] DateTime date, [FromQuery(Name = "count")] int count, [FromServices] DatabaseContext database) => - { - var poemIds = database.PurgatoryEntries - .Where(entry => entry.DateCreated > date) - .Take(Math.Clamp(count, 1, 50)) - .Select(poem => poem.Id); - return Results.Json(poemIds); - }); - rateLimitEndpoints.Add("/purgatory/after", (1, TimeSpan.FromSeconds(2))); - + var poem = await dbContext.PurgatoryEntries.FindAsync(poemId); + if (poem is null) + { + return Results.NotFound(); + } - httpServer.MapGet("/purgatory/before", ([FromQuery(Name = "date")] DateTime date, [FromQuery(Name = "count")] int count, [FromServices] DatabaseContext database) => - { - var poemIds = database.PurgatoryEntries - .Where(entry => entry.DateCreated < date) - .Take(Math.Clamp(count, 1, 50)) - .Select(poem => poem.Id); - return Results.Json(poemIds); + return Results.Ok(poem); }); - rateLimitEndpoints.Add("/purgatory/before", (1, TimeSpan.FromSeconds(2))); - // Take into account genres that they have liked, accounts they have blocked, new poems and interactions when reccomending - httpServer.MapGet("/purgatory/recommended", () => - { - return Results.Problem(); - }); - authRequiredEndpoints.Add("/purgatory/recommended"); - rateLimitEndpoints.Add("/purgatory/recommended", (1, TimeSpan.FromSeconds(5))); - httpServer.MapPost("/purgatory", ([FromBody] UploadableEntry entryUpload, [FromServices] DatabaseContext database, HttpContext context) => + httpServer.MapPost("/purgatory/upload", ([FromBody] UploadableEntry entryUpload, [FromServices] DatabaseContext database, HttpContext context) => { var validationIssues = new Dictionary(); var tags = new List(); @@ -129,36 +101,162 @@ private static void AddPurgatoryEndpoints() return Results.Ok(entry.Id); }); - authRequiredEndpoints.Add("/purgatory"); + authRequiredEndpoints.Add("/purgatory/upload"); if (!httpServer.Environment.IsDevelopment()) { rateLimitEndpoints.Add("/purgatory", (1, TimeSpan.FromSeconds(60))); sizeLimitEndpoints.Add("/purgatory", PayloadSize.FromMegabytes(5)); } - - httpServer.MapPost("/purgatory/{id}/like", ([FromBody] int poemId, HttpContext context) => + + httpServer.MapGet("/purgatory/picks", async ([FromServices] DatabaseContext database) => { - throw new NotImplementedException(); + var entriesQuery = database.PurgatoryEntries + .Where(entry => entry.Pick == true) + .Select(entry => entry.Id); + var entries = await entriesQuery.ToListAsync(); + return Results.Ok(entries); }); + rateLimitEndpoints.Add("/purgatory/picks", (1, TimeSpan.FromSeconds(2))); - httpServer.MapPost("/purgatory/{id}/unlike", ([FromBody] int poemId, HttpContext context) => + httpServer.MapGet("/purgatory/after", ([FromQuery(Name = "date")] DateTime date, [FromQuery(Name = "count")] int count, [FromServices] DatabaseContext database) => { - throw new NotImplementedException(); + var poemIds = database.PurgatoryEntries + .Where(entry => entry.DateCreated > date) + .Take(Math.Clamp(count, 1, 50)) + .Select(poem => poem.Id); + return Results.Ok(poemIds); }); + rateLimitEndpoints.Add("/purgatory/after", (1, TimeSpan.FromSeconds(2))); - httpServer.MapPost("/purgatory/{id}/pin", ([FromBody] int poemId, HttpContext context) => + + httpServer.MapGet("/purgatory/before", ([FromQuery(Name = "date")] DateTime date, [FromQuery(Name = "count")] int count, [FromServices] DatabaseContext database) => { - throw new NotImplementedException(); + var poemIds = database.PurgatoryEntries + .Where(entry => entry.DateCreated < date) + .Take(Math.Clamp(count, 1, 50)) + .Select(poem => poem.Id); + return Results.Ok(poemIds); }); + rateLimitEndpoints.Add("/purgatory/before", (1, TimeSpan.FromSeconds(2))); - httpServer.MapPost("/purgatory/{id}/unpin", ([FromBody] int poemId, HttpContext context) => + // Take into account genres that they have liked, accounts they have blocked, new poems and interactions when reccomending + httpServer.MapGet("/purgatory/recommended", () => { - throw new NotImplementedException(); + return Results.Problem(); + }); + authRequiredEndpoints.Add("/purgatory/recommended"); + rateLimitEndpoints.Add("/purgatory/recommended", (1, TimeSpan.FromSeconds(5))); + + httpServer.MapPost("/purgatory/{poemId:int}/like", async (int poemId, HttpContext context, DatabaseContext dbContext) => + { + var account = (AccountData)context.Items["Account"]!; + + var poem = await dbContext.PurgatoryEntries.FindAsync(poemId); + if (poem is null) + { + return Results.NotFound(); + } + + if (!account.LikedPoems.Contains(poem)) + { + account.LikedPoems.Add(poem); + await dbContext.SaveChangesAsync(); + } + + return Results.Ok(); + }); + + httpServer.MapPost("/purgatory/{poemId:int}/unlike", async (int poemId, HttpContext context, DatabaseContext dbContext) => + { + var account = (AccountData)context.Items["Account"]!; + + var poem = await dbContext.PurgatoryEntries.FindAsync(poemId); + if (poem is null) + { + return Results.NotFound(); + } + + if (account.LikedPoems.Contains(poem)) + { + account.LikedPoems.Remove(poem); + await dbContext.SaveChangesAsync(); + } + + return Results.Ok(); + }); + + httpServer.MapPost("/purgatory/{poemId:int}/pin", async (int poemId, HttpContext context, DatabaseContext dbContext) => + { + var account = (AccountData)context.Items["Account"]!; + + var poem = await dbContext.PurgatoryEntries.FindAsync(poemId); + if (poem is null) + { + return Results.NotFound(); + } + + if (!account.PinnedPoems.Contains(poem)) + { + account.PinnedPoems.Add(poem); + await dbContext.SaveChangesAsync(); + } + + return Results.Ok(); + }); + + httpServer.MapPost("/purgatory/{poemId:int}/unpin", async (int poemId, HttpContext context, DatabaseContext dbContext) => + { + var account = (AccountData)context.Items["Account"]!; + + var poem = await dbContext.PurgatoryEntries.FindAsync(poemId); + if (poem is null) + { + return Results.NotFound(); + } + + if (account.PinnedPoems.Contains(poem)) + { + account.PinnedPoems.Remove(poem); + await dbContext.SaveChangesAsync(); + } + + return Results.Ok(); }); - httpServer.MapPost("/purgatory/{id}/rate", ([FromBody] UploadableRating ratingUpload, HttpContext context) => + httpServer.MapPost("/purgatory/{poemId:int}/rate", async (int poemId, [FromBody] UploadableRating ratingUpload, HttpContext context, DatabaseContext dbContext) => { throw new NotImplementedException(); }); + + httpServer.MapPost("/purgatory/{poemId:int}/report", async (int poemId, DatabaseContext dbContext) => + { + throw new NotImplementedException(); + + var poem = await dbContext.PurgatoryEntries.FindAsync(poemId); + if (poem is null) + { + return Results.NotFound(); + } + + var report = new PurgatoryReport + { + PoemId = poemId, + Poem = poem, + // Add any other necessary report details + }; + + dbContext.PurgatoryReports.Add(report); + await dbContext.SaveChangesAsync(); + + return Results.Ok(); + }).UseMiddleware(httpServer, PurgatoryReportEndpointRegex); + if (!httpServer.Environment.IsDevelopment()) + { + httpServer.UseWhen + ( + context => PurgatoryReportEndpointRegex().IsMatch(context.Request.Path), + appBuilder => appBuilder.UseMiddleware(1, TimeSpan.FromSeconds(5)) + ); + } } } \ No newline at end of file diff --git a/SubliminalServer/Program.cs b/SubliminalServer/Program.cs index 3b98df4..c31dd16 100644 --- a/SubliminalServer/Program.cs +++ b/SubliminalServer/Program.cs @@ -17,13 +17,16 @@ namespace SubliminalServer; // Prerelease .NET 9 may require "dotnet tool install --global dotnet-ef --prerelease" // to update from a non-prerelease, do "dotnet tool update --global dotnet-ef --prerelease" -public static partial class Program +internal static partial class Program { private static WebApplication httpServer; private static List authRequiredEndpoints; private static Dictionary rateLimitEndpoints; // Should only really be needed on POST endpoint private static Dictionary sizeLimitEndpoints; + + private static DirectoryInfo profileImagesDir; + private static ServerConfig? config; [GeneratedRegex("^[a-z][a-z0-9_-]{0,23}$")] private static partial Regex PermissibleTagRegex(); @@ -33,19 +36,29 @@ public static partial class Program public static async Task Main(string[] args) { var dataDir = new DirectoryInfo("Data"); - var profileImageDir = new DirectoryInfo(Path.Join(dataDir.FullName, "ProfileImages")); + var profilesDir = new DirectoryInfo(Path.Combine(dataDir.FullName, "Profiles", "Avatars")); + profileImagesDir = new DirectoryInfo(Path.Combine(dataDir.FullName, "Profiles", "Avatars")); var soundsDir = new DirectoryInfo(Path.Join(dataDir.FullName, "Sounds")); var configFile = new FileInfo("config.json"); var dbPath = Path.Join(dataDir.FullName, "subliminal.db"); - - ServerConfig? config = null; if (File.Exists(configFile.Name)) { - var configText = File.ReadAllText(configFile.Name); + var configText = await File.ReadAllTextAsync(configFile.Name); config = JsonSerializer.Deserialize(configText); } + if (config?.Version < ServerConfig.LatestVersion) + { + var configMoveLocation = configFile.FullName.Replace(".json", $".version{config.Version}.old.json"); + Console.ForegroundColor = ConsoleColor.Yellow; + Console.WriteLine("[WARN]: Current config of version {0} older than current version {1}." + + "Outdated config file will be moved to {2}.", + config.Version, ServerConfig.LatestVersion, configMoveLocation); + Console.ResetColor(); + File.Move(configFile.FullName, configMoveLocation); + config = null; + } if (config is null) { await using var stream = File.OpenWrite(configFile.Name); @@ -55,13 +68,13 @@ public static async Task Main(string[] args) }); await stream.FlushAsync(); Console.ForegroundColor = ConsoleColor.Green; - Console.WriteLine("[LOG]: Config created! Please edit {0} and run this program again!", configFile); + Console.WriteLine("[LOG]: New config created! Please edit {0} and run this program again!", configFile); Console.ResetColor(); Environment.Exit(0); } Console.ForegroundColor = ConsoleColor.Yellow; - foreach (var dirPath in new[] { dataDir, profileImageDir }) + foreach (var dirPath in new[] { dataDir, profilesDir, profileImagesDir, soundsDir }) { if (!Directory.Exists(dirPath.FullName)) { @@ -81,11 +94,13 @@ public static async Task Main(string[] args) { options.AddDefaultPolicy(policy => { - policy.WithOrigins("https://poemanthology.org", "*") - .WithOrigins("https://zekiah-a.github.io/", "*"); + policy.WithOrigins("http://localhost:80", "http://localhost:1234", "https://poemanthology.org") + .AllowAnyHeader() + .AllowAnyMethod() + .AllowCredentials(); }); }); - + builder.Services.Configure(options => { options.SerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase; @@ -113,21 +128,16 @@ public static async Task Main(string[] args) httpServer.UseStaticFiles(new StaticFileOptions { - FileProvider = new PhysicalFileProvider(profileImageDir.FullName), - RequestPath = "/ProfileImage" + FileProvider = new PhysicalFileProvider(profileImagesDir.FullName), + RequestPath = "/profiles/avatars" }); - + if (httpServer.Environment.IsDevelopment()) { httpServer.UseSwagger(); httpServer.UseSwaggerUI(); } - // This is some straightup weirdness to force inject the DB, it seems to work for out current use though - var scope = httpServer.Services.CreateScope(); - var serviceProvider = scope.ServiceProvider; - httpServer.UseMiddleware(serviceProvider.GetRequiredService()); - authRequiredEndpoints = new List(); rateLimitEndpoints = new Dictionary(); sizeLimitEndpoints = new Dictionary(); // Should only really be needed on POST endpoints @@ -170,7 +180,7 @@ public static async Task Main(string[] args) context => context.Request.Path.StartsWithSegments(endpoint), appBuilder => { - appBuilder.UseMiddleware(); + appBuilder.UseMiddleware(); } ); } @@ -182,7 +192,7 @@ private static string GenerateToken() { var tokenBytes = RandomNumberGenerator.GetBytes(32); var tokenString = Convert.ToBase64String(tokenBytes) - + ";" + DateTimeOffset.UtcNow.AddMonths(1).ToUnixTimeSeconds(); + + "_" + DateTimeOffset.UtcNow.AddMonths(1).ToUnixTimeSeconds(); return tokenString; } } \ No newline at end of file diff --git a/SubliminalServer/ServerConfig.cs b/SubliminalServer/ServerConfig.cs index d7f54c2..e81b100 100644 --- a/SubliminalServer/ServerConfig.cs +++ b/SubliminalServer/ServerConfig.cs @@ -2,10 +2,11 @@ namespace SubliminalServer; public class ServerConfig { - public const int LatestVersion = 0; - public int Version = 0; + public const int LatestVersion = 1; + public int Version = 1; public string? Certificate = null; public string? Key = null; public int Port = 1234; public bool UseHttps = false; + public bool CorsCookie = false; } \ No newline at end of file diff --git a/SubliminalServer/SubliminalServer.csproj b/SubliminalServer/SubliminalServer.csproj index 715a2e9..3d9a37a 100644 --- a/SubliminalServer/SubliminalServer.csproj +++ b/SubliminalServer/SubliminalServer.csproj @@ -1,11 +1,9 @@  - net8.0 + net9.0 enable enable - false - false @@ -14,7 +12,7 @@ all - + diff --git a/SubliminalServer/config.json b/SubliminalServer/config.json index 884b47a..21b5420 100644 --- a/SubliminalServer/config.json +++ b/SubliminalServer/config.json @@ -3,5 +3,6 @@ "Certificate": null, "Key": null, "Port": 1234, - "UseHttps": false + "UseHttps": false, + "CorsCookie": false } \ No newline at end of file diff --git a/Volume-2/Idiots/modern-day-brockelhurst.json b/Volume-2/Idiots/modern-day-brockelhurst.json index 875869c..d0df413 100644 --- a/Volume-2/Idiots/modern-day-brockelhurst.json +++ b/Volume-2/Idiots/modern-day-brockelhurst.json @@ -1 +1 @@ -{"summary":"","tags":"","cWarning":false,"cWarningAdditions":"","poemName":"Modern Day Brockelhurst","poemAuthor":"Zekiah","poemContent":{"type":"fragment","styles":[],"children":[{"type":"text","content":"So this Sunday, treat all others with love kindness and compassion. "},{"type":"newline","count":1},{"type":"text","content":"You SLIMY SINNERS, you freaking scum, "},{"type":"newline","count":1},{"type":"text","content":"Can't you see my godly duty's done? "},{"type":"newline","count":1},{"type":"text","content":" \"I'm sorry priest, I must confess\" "},{"type":"newline","count":1},{"type":"text","content":"I couldn't give a fuck if you're damned or blessed! "},{"type":"newline","count":2},{"type":"text","content":"My sheep are starving, my basement's dark, "},{"type":"newline","count":1},{"type":"text","content":"screw this family business. Hark! "},{"type":"newline","count":1},{"type":"text","content":"the herald angel screams and sings, "},{"type":"newline","count":1},{"type":"text","content":"I'm mad with power, god made me king. "},{"type":"newline","count":2},{"type":"text","content":"So now with this service, we gently proceed, "},{"type":"newline","count":1},{"type":"text","content":"open the bibles, turn to page 3, and then piss on it "},{"type":"newline","count":1},{"type":"text","content":"'til you make a hole, this stupid book won't "},{"type":"newline","count":1},{"type":"text","content":"save your soul! "},{"type":"newline","count":2},{"type":"text","content":"My way is the ONLY way to be religious, "},{"type":"newline","count":1},{"type":"text","content":"that old man's work is just sacrilegious "},{"type":"newline","count":1},{"type":"text","content":"Punish the body to spare the soul "},{"type":"newline","count":1},{"type":"text","content":"even if you have to end your life. "},{"type":"newline","count":1},{"type":"text","content":"Punish the soul to save the body "},{"type":"newline","count":1},{"type":"text","content":"And spare those trees and foxes lives. "},{"type":"newline","count":2},{"type":"text","content":"You may have priority on the road, "},{"type":"newline","count":1},{"type":"text","content":"but you're breaching heaven's code "},{"type":"newline","count":1},{"type":"text","content":"Fuck your wellbeing, screw your health "},{"type":"newline","count":1},{"type":"text","content":"build a cross and kill yourself! "},{"type":"newline","count":2},{"type":"text","content":"Deny thy doctors, deny thy teachers. "},{"type":"newline","count":1},{"type":"text","content":"All the little french boys know, "},{"type":"newline","count":1},{"type":"text","content":"to accept, "},{"type":"newline","count":1},{"type":"text","content":"thy, "},{"type":"newline","count":1},{"type":"text","content":"PREACHER! "},{"type":"newline","count":2},{"type":"text","content":"(I'll be posting some pron tomorrow "},{"type":"newline","count":1},{"type":"text","content":"so keep in touch kids! I mean, it is "},{"type":"newline","count":1},{"type":"text","content":"the grand Methodist church afterall) "},{"type":"newline","count":3}]},"pageStyle":"centre","pageBackground":""} \ No newline at end of file +{"summary":"","tags":"","cWarning":false,"cWarningAdditions":"","poemName":"Modern Day Brockelhurst","poemAuthor":"Zekiah","poemContent":{"type":"fragment","styles":[],"children":[{"type":"text","content":"So this Sunday, treat all others with love kindness and compassion. "},{"type":"newline","count":1},{"type":"text","content":"You SLIMY SINNERS, you freaking scum, "},{"type":"newline","count":1},{"type":"text","content":"Can't you see my godly duty's done? "},{"type":"newline","count":1},{"type":"fragment","styles":[{"type":"italic"}],"children":[{"type":"text","content":"\"I'm sorry priest, I must confess\""}]},{"type":"newline","count":1},{"type":"text","content":"I couldn't give a fuck if you're damned or blessed! "},{"type":"newline","count":2},{"type":"text","content":"My sheep are starving, my basement's dark, "},{"type":"newline","count":1},{"type":"text","content":"screw this family business. Hark! "},{"type":"newline","count":1},{"type":"text","content":"the herald angel screams and sings, "},{"type":"newline","count":1},{"type":"text","content":"I'm mad with power, god made "},{"type":"fragment","styles":[{"type":"bold"},{"type":"underline"}],"children":[{"type":"text","content":"me"}]},{"type":"text","content":" king."},{"type":"newline","count":2},{"type":"text","content":"So now with this service, we gently proceed, "},{"type":"newline","count":1},{"type":"text","content":"open the bibles, turn to page 3, and then piss on it "},{"type":"newline","count":1},{"type":"text","content":"'til you make a hole, this stupid book won't "},{"type":"newline","count":1},{"type":"text","content":"save your soul! "},{"type":"newline","count":2},{"type":"text","content":"My way is the "},{"type":"fragment","styles":[{"type":"bold"},{"type":"italic"}],"children":[{"type":"text","content":"ONLY"}]},{"type":"text","content":" way to be religious, "},{"type":"newline","count":1},{"type":"text","content":"that old man's work is just sacrilegious "},{"type":"newline","count":1},{"type":"text","content":"Punish the body to spare the soul "},{"type":"newline","count":1},{"type":"text","content":"even if you have to end your life. "},{"type":"newline","count":1},{"type":"text","content":"Punish the soul to save the body "},{"type":"newline","count":1},{"type":"text","content":"And spare those trees and foxes lives. "},{"type":"newline","count":2},{"type":"text","content":"You may have priority on the road, "},{"type":"newline","count":1},{"type":"text","content":"but you're breaching heaven's code "},{"type":"newline","count":1},{"type":"text","content":"Fuck your wellbeing, screw your health "},{"type":"newline","count":1},{"type":"text","content":"build a cross and kill yourself!"},{"type":"newline","count":2},{"type":"text","content":"Deny thy doctors, deny thy teachers."},{"type":"newline","count":1},{"type":"text","content":"All the little french boys know, "},{"type":"newline","count":1},{"type":"text","content":"to accept, "},{"type":"newline","count":1},{"type":"text","content":"thy, "},{"type":"newline","count":1},{"type":"text","content":"PREACHER! "},{"type":"newline","count":2},{"type":"fragment","styles":[{"type": "subscript"}],"children":[{"type":"text","content":"(I'll be posting some pron tomorrow "},{"type":"newline","count":1},{"type":"text","content":"so keep in touch kids! I mean, it "},{"type":"fragment","styles":[{"type":"italic"}],"children":[{"type":"text","content":"is"}]},{"type":"newline","count":1},{"type":"text","content":"the grand Methodist church afterall)"}]}]},"pageStyle":"centre","pageBackground":""} \ No newline at end of file diff --git a/Volume-2/Tales-And-Tomes/bull-and-bush.json b/Volume-2/Tales-And-Tomes/bull-and-bush.json index 7046b8c..9af9a0c 100644 --- a/Volume-2/Tales-And-Tomes/bull-and-bush.json +++ b/Volume-2/Tales-And-Tomes/bull-and-bush.json @@ -1 +1 @@ -{"summary":"","tags":"","cWarning":false,"cWarningAdditions":"","poemName":"Bull and Bush","poemAuthor":"Angelos","poemContent":{"type":"fragment","styles":[],"children":[{"type":"text","content":"Oben den Hügel, liegt es den alten Bull & Bush"},{"type":"newline","count":1},{"type":"text","content":"A Bush and a Bull, can’t see them around,"},{"type":"newline","count":1},{"type":"text","content":"Just in gothic writing, on the north facing pub."},{"type":"newline","count":2},{"type":"text","content":"So where are they hidden - "},{"type":"newline","count":1},{"type":"text","content":"The Bush and the Bull? "},{"type":"newline","count":1},{"type":"text","content":"The toilets, the kitchen, or under the Müll? "},{"type":"newline","count":1},{"type":"text","content":"The white building? Unlikely"},{"type":"newline","count":1},{"type":"text","content":"For beasts that mighty. "},{"type":"newline","count":1},{"type":"text","content":"But maybe I’m wrong. "},{"type":"newline","count":2},{"type":"text","content":"The bull was me, for it climbed the bush, "},{"type":"newline","count":1},{"type":"text","content":"In an electrical substation; eternal damnation, "},{"type":"newline","count":1},{"type":"text","content":"Danger of death! 415 volts. "},{"type":"newline","count":1},{"type":"text","content":"But you won’t die; it's between screws and bolts. "},{"type":"newline","count":2},{"type":"text","content":"For it seems like a tube station"},{"type":"newline","count":1},{"type":"text","content":"Rather than a substation,"},{"type":"newline","count":1},{"type":"text","content":"Clickety clack, knew t’was that! "},{"type":"newline","count":1},{"type":"text","content":"Artificial crescendo; where are they off to? "},{"type":"newline","count":1},{"type":"text","content":"Air turbulence shows, it blows to the north. "},{"type":"newline","count":2},{"type":"text","content":"This dust has a familiar smell; "},{"type":"newline","count":1},{"type":"text","content":"The smell of decay, the stench of rocks. "},{"type":"newline","count":1},{"type":"text","content":"It’s appeared on the headlines countless times "},{"type":"newline","count":1},{"type":"text","content":"For its particulates are known for scarring lungs. "},{"type":"newline","count":1},{"type":"text","content":"Yet who can resist this landmark of London? "},{"type":"newline","count":2},{"type":"text","content":"Turning right towards the circular shaft, "},{"type":"newline","count":1},{"type":"text","content":"Hier liegt ein Sign der sagt: "},{"type":"newline","count":1},{"type":"text","content":"Depth of shaft: 38 metres "},{"type":"newline","count":1},{"type":"text","content":"My wheel touches the first stair of the shaft. "},{"type":"newline","count":1},{"type":"text","content":"Spiralling down in a spiral of decay, "},{"type":"newline","count":1},{"type":"text","content":"Like Mr Statin’s might; I picture its plight. "},{"type":"newline","count":2},{"type":"text","content":"Slamming the breaks, bike "},{"type":"newline","count":1},{"type":"text","content":"Crashed on the landing, "},{"type":"newline","count":1},{"type":"text","content":"Just like the empire of OzyAndy. "},{"type":"newline","count":2},{"type":"text","content":"Rushing down to platform level, "},{"type":"newline","count":1},{"type":"text","content":"A train whizzed south from north; a furious rebel."},{"type":"newline","count":1},{"type":"text","content":"Its destination read ‘‘express to history’’ "},{"type":"newline","count":1},{"type":"text","content":"of the Hill’s largest port. "},{"type":"newline","count":1},{"type":"text","content":"Once a trading spot; largest depot, "},{"type":"newline","count":1},{"type":"text","content":"At the world’s poshest school, "},{"type":"newline","count":1},{"type":"text","content":"now among the level sands. "},{"type":"newline","count":2},{"type":"text","content":"Like a dead old bull decaying in a bush, "},{"type":"newline","count":1},{"type":"text","content":"OzyAndy’s statue crumbles, "},{"type":"newline","count":1},{"type":"text","content":"On what once was a platform. "},{"type":"newline","count":1},{"type":"text","content":"Reduced to rubbles."},{"type":"newline","count":3}]},"pageStyle":"poem-centre","pageBackground":"url(\"data:image/png;base64,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\")"} \ No newline at end of file +{"summary":"","tags":"","cWarning":false,"cWarningAdditions":"","poemName":"Bull and Bush","poemAuthor":"Angelos","poemContent":{"type":"fragment","styles":[],"children":[{"type":"text","content":"Oben den Hügel, liegt es den alten Bull & Bush"},{"type":"newline","count":1},{"type":"text","content":"A Bush and a Bull, can’t see them around,"},{"type":"newline","count":1},{"type":"text","content":"Just in gothic writing, on the north facing pub."},{"type":"newline","count":2},{"type":"text","content":"So where are they hidden -"},{"type":"newline","count":1},{"type":"text","content":"The Bush and the Bull?"},{"type":"newline","count":1},{"type":"text","content":"The toilets, the kitchen, or under the Müll?"},{"type":"newline","count":1},{"type":"text","content":"The white building? Unlikely"},{"type":"newline","count":1},{"type":"text","content":"For beasts that mighty."},{"type":"newline","count":1},{"type":"text","content":"But maybe I’m wrong."},{"type":"newline","count":2},{"type":"text","content":"The bull was me, for it climbed the bush,"},{"type":"newline","count":1},{"type":"text","content":"In an electrical substation; eternal damnation,"},{"type":"newline","count":1},{"type":"text","content":"Danger of death! 415 volts."},{"type":"newline","count":1},{"type":"text","content":"But you won’t die; it's between screws and bolts."},{"type":"newline","count":2},{"type":"text","content":"For it seems like a tube station"},{"type":"newline","count":1},{"type":"text","content":"Rather than a substation,"},{"type":"newline","count":1},{"type":"text","content":"Clickety clack, knew t’was that!"},{"type":"newline","count":1},{"type":"text","content":"Artificial crescendo; where are they off to?"},{"type":"newline","count":1},{"type":"text","content":"Air turbulence shows, it blows to the north."},{"type":"newline","count":2},{"type":"text","content":"This dust has a familiar smell;"},{"type":"newline","count":1},{"type":"text","content":"The smell of decay, the stench of rocks."},{"type":"newline","count":1},{"type":"text","content":"It’s appeared on the headlines countless times"},{"type":"newline","count":1},{"type":"text","content":"For its particulates are known for scarring lungs."},{"type":"newline","count":1},{"type":"text","content":"Yet who can resist this landmark of London?"},{"type":"newline","count":2},{"type":"text","content":"Turning right towards the circular shaft,"},{"type":"newline","count":1},{"type":"text","content":"Hier liegt ein Sign der sagt:"},{"type":"newline","count":1},{"type":"text","content":"Depth of shaft: 38 metres "},{"type":"newline","count":1},{"type":"text","content":"My wheel touches the first stair of the shaft."},{"type":"newline","count":1},{"type":"text","content":"Spiralling down in a spiral of decay,"},{"type":"newline","count":1},{"type":"text","content":"Like Mr Statin’s might; I picture its plight."},{"type":"newline","count":2},{"type":"text","content":"Slamming the breaks, bike"},{"type":"newline","count":1},{"type":"text","content":"Crashed on the landing, "},{"type":"newline","count":1},{"type":"text","content":"Just like the empire of OzyAndy."},{"type":"newline","count":2},{"type":"text","content":"Rushing down to platform level,"},{"type":"newline","count":1},{"type":"text","content":"A train whizzed south from north; a furious rebel."},{"type":"newline","count":1},{"type":"text","content":"Its destination read ‘‘express to history’’"},{"type":"newline","count":1},{"type":"text","content":"of the Hill’s largest port."},{"type":"newline","count":1},{"type":"text","content":"Once a trading spot; largest depot,"},{"type":"newline","count":1},{"type":"text","content":"At the world’s poshest school,"},{"type":"newline","count":1},{"type":"text","content":"now among the level sands."},{"type":"newline","count":2},{"type":"text","content":"Like a dead old bull decaying in a bush,"},{"type":"newline","count":1},{"type":"text","content":"OzyAndy’s statue crumbles,"},{"type":"newline","count":1},{"type":"text","content":"On what once was a platform."},{"type":"newline","count":1},{"type":"text","content":"Reduced to rubbles."},{"type":"newline","count":3}]},"pageStyle":"poem-centre","pageBackground":""} \ No newline at end of file diff --git a/account.html b/account.html index 70536b2..aa86db8 100644 --- a/account.html +++ b/account.html @@ -1,483 +1,563 @@ - - - - Subliminal - - - - - - - - - - - - - - -

Your profile role:

-
- - - - - - - - - - - - -
-
- -
- -

These are for vanity purposes only, setting a certain role won't limit you from doing certain actions!

- - -

Enter your email:

- -
- - -
-
-
- - - -
-
-
-

I'm

- -

,

-

a writer

-
- @username - -
-
🌍 
-
📌 Poem1, Poem2, Poem3, Poem4, Poem5
-
-
-
-
-

- -

Recent works:

-
- -

Following:

-
- -

Private account info:

-
-

This stuff won't appear on your profile, it is for your eyes only!

- - -

-

Draft poems:

-
-
-

London

-

I walk through each chartered street, near where the chartered thames do flow. And marks on every face I meet, marks of weakness, marks of woe.

-
-
- -

-
-

Account agreement +

- -
- <- Back - - - + + + + Subliminal + + + + + + + + + + + + + + + + +

Your profile role:

+
+ + + + + + + + + + + + +
+
+ +
+ +

These are for vanity purposes only, setting a certain role won't limit you from doing certain actions!

+ + +

Enter your email:

+ +
+ + +
+
+
+ + + +
+
+
+

I'm

+ +

,

+

a writer

+
+ @username + +
+
🌍 
+
📌 Poem1, Poem2, Poem3, Poem4, Poem5
+
+
+
+
+

+ +

Recent works:

+
+ +

Following:

+
+ +

Private account info:

+
+

This stuff won't appear on your profile, it is for your eyes only!

+ + +

+

Draft poems:

+
+
+

London

+

I walk through each chartered street, near where the chartered thames do flow. And marks on every face I meet, marks of weakness, marks of woe.

+
+
+ +

+
+

Account agreement +

+ +
+ <- Back + + + diff --git a/account.js b/account.js index 26010e6..71f3d02 100644 --- a/account.js +++ b/account.js @@ -1,31 +1,4 @@ -const actionType = { - // General account actions - BlockUser: 0, - UnblockUser: 1, - FollowUser: 2, - UnfollowUser: 3, - LikePoem: 4, - UnlikePoem: 5, - RatePoem: 6, - UploadDraft: 7, - DeleteDraft: 8, - GetDraft: 9, - Report: 10, - - // Location - Account data - UpdateEmail: 11, - UpdateNumber: 12, - - //Location - Account profile - UpdatePenName: 13, - UpdateBiography: 14, - UpdateLocation: 15, - UpdateRole: 16, - UpdateAvatar: 17, - PinPoem: 18, - UnpinPoem: 19 -} - +"use strict"; const badgeType = { Admin: 0, Based: 1, @@ -59,17 +32,15 @@ function getBadgeInfo(badge) { } async function getAccountData() { - let data = null - - await fetch(serverBaseAddress + "/auth/signin", { + const res = await fetch(serverBaseAddress + "/accounts/me", { method: "POST", - headers: { 'Content-Type': 'application/json' }, - body: '"' + localStorage.accountCode + '"' + headers: { 'Content-Type': 'application/json' } }) - .then((res) => res.json()) - .then((dataObject) => data = dataObject) - - return data + if (!res.ok) { + return null + } + const accountData = await res.json() + return accountData } async function getPublicProfile(accountId) { @@ -86,14 +57,20 @@ async function getPublicProfile(accountId) { } async function isLoggedIn() { - if (!localStorage.accountCode) return false + if (sessionStorage.accountToken) { + return true + } let response = await fetch(serverBaseAddress + "/auth/signin/token", { method: "POST", - headers: { 'Content-Type': 'application/json' }, body: '"' + localStorage.accountCode + '"'} - ) + headers: {'Content-Type': 'application/json'} + }) return response.ok } -console.log("%cPrivate account data may be held in browser local storage, a thing that can be acessed by putting code in this browser console! If someone tells you to put something here, there is a high chance that you may get hacked!", "background: red; color: yellow; font-size: large") +async function signout() { + window.location.reload(true) +} + +console.log("%cAccount credentials may be held in browser storage, a thing that can be acessed by putting code in this console! If someone tells you to put something here, there is a high chance that you may get hacked!", "background: red; color: yellow; font-size: large") console.log("%cTL;DR: Never put anything you do not understand here. Uncool things may happen.", "color: blue; font-size: x-large") \ No newline at end of file diff --git a/contents.css b/contents.css new file mode 100644 index 0000000..6f6de23 --- /dev/null +++ b/contents.css @@ -0,0 +1,324 @@ +.section-span { + cursor: pointer; + max-width: 20%; + width: 20%; + margin: 20px; + transition: .2s font-weight, .2s margin, .2s max-width; +} + +.section-body { + /*border-radius: 10px; + border-left: 2px solid grey; + padding-left: 5px;*/ + transition: transform .5s, opacity .5s; +} + +.section-collapsed { + position: absolute; + top: 34px; + transform: translate(-50%, -50%); + right: 16px; + transform-origin: center; + transition: .2s transform; + border: 1px solid lightgray; + border-radius: 100%; + width: 36px; + height: 36px; + background-color: var(--button-opaque); + z-index: 2; + cursor: pointer; +} + +.section-collapsed > svg { + fill: var(--text-colour); + padding: 8px; + box-sizing: border-box; +} + +.grid-container { + display: grid; + grid-template-columns: auto auto; + padding: 10px; + grid-gap: 10px; +} + +.grid-sub-container { + display: flex; + flex-direction: row; + border-radius: 8px; + margin: 8px; + padding: 8px; + background-color: var(--panel-transparent); + position: relative; + transition: max-height .2s; + max-height: 1000px; + overflow: hidden; +} + +.grid-sub-container[collapsed] { + height: 64px; + max-height: 64px; + cursor: pointer; +} + +.grid-sub-container[collapsed] > .section-span { + max-width: 100%; + width: 100%; + font-weight: bold; + position: absolute; + margin: 14px; + overflow: clip; +} + +.grid-sub-container[collapsed] > .section-body { + transform: translateX(110%); + opacity: 0; +} + +.grid-sub-container[collapsed] > .section-collapsed { + transform: translate(-50%, -50%) rotate(-90deg); +} + +.seminars-centre { + border-radius: 8px; + height: 400px; + background-color: var(--button-opaque); + display: flex; + flex-direction: column; + padding: 16px; + background: linear-gradient(-90deg, #ee6352, #d16e8d); + flex-grow: 1; + flex-shrink: 0; + transition: .2s box-shadow; + margin: 0px; +} + +.seminars-centre:hover { + box-shadow: 0px 0px 6px 2px lightgrey; +} + +.seminars-parent { + margin-top: 16px; + width: 100%; + display: flex; + column-gap: 16px; +} + +.seminars-side { + border-radius: 8px; + height: 400px; + background-color: var(--button-opaque); + display: flex; + flex-direction: column; + padding: 16px; + flex-shrink: 2; + flex-basis: 20%; + margin: 0px; +} + +.seminars-parent-mobile { + margin-top: 16px; + width: 100%; + display: none; + column-gap: 16px; + flex-direction: column; + box-sizing: border-box; +} + +.seminars-side-parent-mobile { + display: flex; + column-gap: 8px; + padding-top: 8px; + box-sizing: border-box; +} + +.seminars-side-mobile { + border-radius: 8px; + height: 280px; + background-color: var(--button-opaque); + display: flex; + flex-direction: column; + padding: 16px; + flex: 50%; +} + +.poem-preview { + display: none; + position: fixed; + left: 20px; + top: 200px; + width: 250px; + height: 400px; + border: 2px solid grey; + border-radius: 2px; + background: white; +} + +.poem-preview > iframe { + width: 100%; + height: 100%; + border: none; +} + +/*Purgatory flex CSS*/ +#purgatoryFlex { + display: flex; + max-width: 100%; + padding: 8px; + flex-direction: row; + column-gap: 16px; + overflow-x: auto; + user-select: none; + overflow-y: hidden; + height: min-content; + max-height: 80vh; + box-sizing: border-box; +} + +#purgatoryGrid { + display: grid; + grid-template-columns: auto auto auto auto auto; + grid-gap: 16px; + overflow: hidden; + overflow-y: auto; + position: relative; + height: min-content; + max-height: 80vh; + box-sizing: border-box; +} + +.purgatory-warning { + width: 100%; + display: flex; + justify-content: center; + margin-top: 16px; + margin-bottom: 16px; +} + +.purgatory-warning > span { + align-self: center; + background: var(--button-transparent); + padding: 8px; + border-radius: 8px; + border: 1px solid lightgray; +} + +.purgatory-actions-bottom { + display: flex; +} + +#filtersBar { + display: flex; + justify-content: center; + column-gap: 4px; + margin: 8px; +} + +#filtersBar > button { + border-radius: 32px; + padding: 1px; + position: relative; +} + +#filtersBar > button > div { + padding-left: 12px; + padding-right: 12px; + padding-top: 4px; + padding-bottom: 4px; + background-color: var(--button-transparent); + border-radius: 32px; + user-select: none; + pointer-events: none; +} + +.signup-code-hidden { + background: gray; + border-radius: 4px; + color: gray; + cursor: pointer; + transition: .2s all; +} + +.searchbar { + color: var(--text-colour); + background-color: #ffffff33; + backdrop-filter: blur(10px); + z-index: 1; + border: 1px solid gray; + border-radius: 4px; + padding-left: 8px; +} + +.classics-header { + top: 78px; + display: flex; + column-gap: 8px; + position: sticky; + line-height: 40px; + z-index: 3; + margin: 0; + padding: 0px; + transition: .2s background-color, .2s margin, .2s padding, .2s border; +} + +.classics-header.stuck { + border: 1px solid gray; + padding: 8px; + margin: -8px; + border-radius: 8px; + backdrop-filter: blur(10px); +} + +.classics-header.stuck > .searchbar { + border-radius: 8px 0 0 8px; +} + +@media screen and (orientation:portrait) { + .grid-container { + grid-template-columns: auto; + } + + .searchbar { + height: 48px; + flex-grow: 1; + } + + .classics-header { + top: 64px; + } + + .grid-sub-container { + flex-direction: column; + } + + .section-span { + max-width: 100%; + width: 100%; + } + + #purgatoryGrid { + grid-template-columns: auto auto; + } + + .purgatory-actions-bottom { + justify-content: end; + } + + .seminars-parent-mobile { + display: flex; + } + + .seminars-parent { + display: none; + } +} + +@media screen and (orientation:landscape) { + .searchbar { + width: 50%; + line-height: 300%; + top: 2px; + z-index: 1; + flex-grow: 1; + } +} diff --git a/contents.html b/contents.html index f893457..c2669bb 100644 --- a/contents.html +++ b/contents.html @@ -1,347 +1,24 @@ - + Subliminal + - + + - - + + + -
@@ -672,6 +349,7 @@

Other stuff:

<- Back - - - + Subliminal + + + + + + + + + -
diff --git a/editor-document.js b/editor-document.js index acd25af..abc0a9a 100644 --- a/editor-document.js +++ b/editor-document.js @@ -1,5 +1,5 @@ -// Code that handles logic for complex poem editor interactions "use strict"; +// Code that handles logic for complex poem editor interactions const positionMovements = { up: 0, down: 1, diff --git a/for-teachers.html b/for-teachers.html index 7159d8a..f26df31 100644 --- a/for-teachers.html +++ b/for-teachers.html @@ -4,8 +4,10 @@ Subliminal + - + + diff --git a/index.css b/index.css new file mode 100644 index 0000000..df3956d --- /dev/null +++ b/index.css @@ -0,0 +1,243 @@ +body { + overflow-x: clip; + overflow-y: scroll; +} + +.fixed { + vertical-align: middle; + text-align: center; + height: calc(100% - 40px); + width: 100%; + overflow: scroll; + margin-bottom: 5px; + scroll-behavior: smooth; + -ms-overflow-style: none; + scrollbar-width: none; + border-radius: 2px; + transition: width .5s; +} + +.fixed:has(a > #advert3:target) { + width: 128%; +} + +.fixed::-webkit-scrollbar { + display: none; +} + +.fixed-container { + position: fixed; + top: 30%; + left: 65%; + height: 46vh; + width: 18vh; +} + +.slide-link { + text-decoration: none; + padding: 2px 6px 2px 6px; + color: rgb(50, 50, 50); + background-color: #eeeeee; + border: 1px solid rgb(50, 50, 50); + border-radius: 2px; +} + +.scroll-in { + opacity: 1 !important; + transform: unset !important; +} + +.scroll-unseen { + opacity: 0; + transform: translateY(64px) scale(1.1); + transition: .5s opacity, .5s transform; +} + +.main-logo { + min-width: 70%; + min-height: 70%; + aspect-ratio: 1/1; +} + +/* Sections, below main style */ +.section { + display: flex; + flex-direction: row; + border-radius: 8px; + background-color: var(--button-transparent); + padding: 8px; + margin-left: 5%; + margin-right: 5%; + align-self: center; + column-gap: 16px; +} + +/*Special bottom section code*/ +.section-double { + flex-direction: row; + background: transparent; +} + +.section-double > div { + /*max-height: 256px; + height: 256px;*/ + margin-left: 0px; + margin-right: 0px; +} + +.section-double img, .section-double video { + width: 180px; + height: 320px; + object-fit: cover; + border-radius: 4px; +} + +/* Relatable-s messages */ +.section-info { + margin-left: 5%; + margin-right: 5%; + margin-top: 32px; + margin-bottom: 128px; +} + +.presenter-container { + display: flex; + flex-direction: column; + width: 60%; + margin: 0px; +} + +.presenter { + position: relative; + width: 100%; + border-radius: 4px; + overflow: hidden; + user-select: none; + flex-grow: 1; +} + +.presenter img { + width: 100%; + height: 100%; +} + +.presenter p { + position: absolute; + top: 0px; + left: 50%; + transform: rotateX(42deg) rotateY(-12deg) rotateZ(24deg) translate(-50%); + white-space: nowrap; + color: white; + opacity: 0.6; + font-family: 'Comic Sans MS', 'Comic Sans', cursive; + line-height: 1; + font-weight: bolder; + font-size: 1.8vw; +} + +.presenter-caption { + opacity: 0.6; + margin-top: 8px; + font-style: italic; +} + +#aboutInfo.scroll-unseen { + transform: translateX(-90%); +} + +.info-list { + padding-left: 32px; +} + +.info-list > li { + margin: 18px 18px 18px 12px; + list-style-type: none; +} + +#poemProcessSubInfo { + display: flex; + column-gap: 64px; + transition: .5s column-gap, .2s background-color; + overflow-x: auto; + -ms-overflow-style: none; + scrollbar-width: none; + transition: .5s column-gap, .2s background-color; +} + +#poemProcessSubInfo > li { + background-color: var(--panel-transparent); + padding: 8px; + border-radius: 8px; + min-width: 156px; + user-select: none; + list-style-type: none; +} + +#poemProcessSubInfo > li > p { + opacity: 0.6; + transition: .2s opacity; +} + +#poemProcessSubInfo > li:hover { + background-color: var(--button-opaque-hover); +} + +#poemProcessSubInfo > li:hover > p { + opacity: 1; +} + +#poemProcessSubInfo.scroll-in { + column-gap: 4px; +} + +#topBackground { + position: absolute; + z-index: -1; + left: 0px; + top: 0px; +} + +#topBackground > img { + width: 100%; +} + +#topBackground::after { + position: absolute; + left: 0px; + top: 0px; + width: 100%; + height: 100%; + background: linear-gradient(to bottom, transparent, var(--background-opaque) 90%); + content: ""; +} + +@media(prefers-color-scheme: dark) { + .index-image { + filter: invert(1); + } +} + +@media screen and (orientation:portrait) { + .fixed-container { + left: auto; + right: 32px; + } + + .section { + flex-direction: column-reverse; + } + + .section-double { + row-gap: 16px; + } + + .presenter p { + font-size: 4.9vw; + } + + .presenter-container { + display: flex; + flex-direction: column; + width: 100%; + } +} diff --git a/index.html b/index.html index 60abae8..d4ac463 100644 --- a/index.html +++ b/index.html @@ -1,264 +1,36 @@ - + Subliminal - + - + + + + - - -
+
Subliminal scenery background

Subliminal

“The methallyne blue analogy of stuff.

Probably the weirdest poetry anthology to ever exist.”

- Dog +

Beware: C o o l s t u f f a h e a d .

About Subliminal

-
+

Subliminal is an open source project to create the largest repository of poems in one place, where anyone can contribute their own work, no matter how chaotic, critical, or hilarious it may be!

Here we value fairness and freedom of expression, because everyone should have the right to be creative.

@@ -278,26 +50,26 @@ A vulture, flew overhead,
then dropped down dead! Beating
my back like a brick of lead. Yet I
+ Shouted 'horay', meat for days!
+ On my way to Al'mogus.
...

A long road to Al'mogus, a poem about human desire, by Zekiah.
-
- -
+ +
Did you know?
-
-

-> We have over 100 hand crafted curated originals to read and take inspiration from!

-

-> There is a full rich-text poem editor, to make your works come to light both literally and visually.

-

-> Free cloud saving, and accounts allow you to acess, read and write poems anywhere, across your devices!

-
+
    +
  • -> We have over 100 hand crafted curated originals to read and take inspiration from!
    • +
  • -> There is a full rich-text poem editor, to make your works come to light both literally and visually.
    • +
  • -> Free cloud saving, and accounts allow you to acess, read and write poems anywhere, across your devices!
    • +

If you aren't on subliminal, what are you even doing with your life?

-
- +

Get started

-
+
@@ -310,52 +82,49 @@

Simply navigate to the "poems" page to see all of the contents of the anthology. Here you can also set up an account, or start writing your own poem with the "+add a poem" button whenever you like!

If you ever have any questions, check the dictionary and disclaimer pages for more info on what you may find here...

-
- -
+ +
Relatable?

For most of us, process of writing a poem often looks like this:

-
-

💡 Burst of inspiration at the most unexpected moment.

-

✍️ Spontaneous writing, tiring yourself out as you refine your work.

-

😨 Writer's block.

-

✨ A second hope, reading back on some previous works, you are motivated to finish what you started.

-

🎉 Finally completed poem! Sigh a breath of relief.

-

🗣️ Tell everyone! Have your teacher, friends, family, read and review your poem!

-
-
-

-> From writers block, to that banger rhyme you were thinking of just slipping out of your mind, writing a creative piece can be brutal.

-

-> That's why subliminal provides a community where people can share and grow, so we can all can write the poems that future generations will be tortured with in class one day.

-
+ " style="margin: 0px; padding: 0px;"> +

  • 💡 Burst of inspiration at the most unexpected moment.

    • +

  • ✍️Spontaneous writing, tiring yourself out as you refine your work.

    • +

  • 😨 Writer's block.

    • +

  • ✨ A second hope, reading back on some previous works, you are motivated to finish what you started.

    • +

  • 🎉 Finally completed poem! Sigh a breath of relief.

    • +

  • 🗣️ Tell everyone! Have your teacher, friends, family, read and review your poem!

    • + +
      +
    • -> From writers block, to that banger rhyme you were thinking of just slipping out of your mind, writing a creative piece can be brutal.
      • +
    • -> That's why subliminal provides a community where people can share and grow, so we can all can write the poems that future generations will be tortured with in class one day.
      • +

    Poetry may not solve your crippling internet addiction, but it's a step in the right direction!

    -
    - +

    Other stuff

    -
    -
    +
    +
    A fun game to play in your free time -
    +

    Rplace.live: a spinoff of the reddit place event!

    A game by Zekiah-A and BlobKat, featuring a massive multiplayer canvas, place pixels, collaborate or start pixel wars, to create the most epic canvas arts possible.

    -
    -
    - -
    + + +
    -
    +

    The best waste of money since buying an NFT!

    Help fund development of subliminal, and support me with my other projects by donating, and getting an absolute monstrosity of literature in return, it's almost a good deal!

    -
    -
    -
    + + +
    @@ -363,6 +132,7 @@
    + diff --git a/poem-editor.css b/poem-editor.css index 71c49ce..3314a57 100644 --- a/poem-editor.css +++ b/poem-editor.css @@ -4,56 +4,6 @@ border-radius: 4px; background-color: var(--background-opaque); } -#editorCanvas { - display: block; - width: 100%; - height: 100%; - cursor: text; -} -#editorCanvas:focus { - outline: none; -} -#editorContext { - display: flex; - visibility: hidden; - transition: left 0.1s ease 0s; - position: fixed; - width: 200px; - background-color: var(--button-transparent); - backdrop-filter: blur(5px); - border-radius: 4px; - box-shadow: 0px 0px 10px #656565; - border: 1px solid darkgray; - flex-direction: column; - padding: 4px; - row-gap: 4px; -} -#editorContext > button { - height: 32px; - background-color: transparent; - border: 1px solid var(--button-opaque); - display: flex; - align-items: center; - column-gap: 8px; - transition: .05 transform; - user-select: none; -} -#editorContext > button:hover { - background-color: var(--button-opaque-hover); -} -#editorContext > button:active { - transform: scale(0.98); -} -#editorContext > button > svg { - opacity: 0.6; - fill: var(--text-colour); -} -#editorContext > button > span { - font-weight: bold; - opacity: 0.4; - flex-grow: 1; - text-align: end; -} .tool { margin: 1px; height: 24px; @@ -281,7 +231,6 @@ display: none; #tagContainer > button { border-radius: 4px; height: 64px; - background: lightgrey; padding: 4px; text-align: center; position: relative; @@ -351,31 +300,6 @@ color: white; padding: 8px; overflow-y: auto; } -.suggestions { - width: 192px; - position: absolute; - background: #bdbdbd; - z-index: 3; - border-radius: 4px; - top: 0px; - display: flex; - background-color: var(--button-transparent); - flex-direction: column; - border: 1px solid gray; - overflow: clip; - overflow-y: scroll; -} -.suggestions-item { - padding: 8px; - display: flex; -} -.suggestions-item > span:nth-child(1) { - flex-grow: 1; -} -.suggestions-item > span:nth-child(2) { - font-size: 10px; - opacity: 0.6; -} .online-editors { position: fixed; left: 16px; diff --git a/poem-editor.html b/poem-editor.html index 694d3fa..9bf4b36 100644 --- a/poem-editor.html +++ b/poem-editor.html @@ -1,1030 +1,820 @@ - - - Subliminal - - - - - - - - - - - - - -

    You're almost there!

    - + + + Subliminal + + + + + + + + + + + + + + + +

    You're almost there!

    + +

    + When you click submit, your poem will be uploaded publicly to the poem + purgatory. For more information, see the license agreement below. +

    +
    +

    + License agreement + +

    +     - -

    Built-in backgrounds:

    - These backgrounds are free for you to use to jazz up your poem's look! - Drawn and shot by members of the subliminal team. + By uploading your work to this site, you give consent for your poem to + be licensed under Creative Commons + Attribution-NonCommercial-ShareAlike 4.0.

    -
    -
    - -
    Taken somewhere in the Chilterns, UK.
    -
    +

    + You also agree to allow us permission to store and process your work. + We can also accept no responsibility, if you write something that gets + you in trouble with people you know, an institution, or local + government, you agree that you WILLINGLY chose to upload it here. We + accept no responsibility how your work is interpreted, and what + consequences may or may not come as a result of it. +

    +

    + You will always be the lone copyright owner of your work, we will + never take ownership of what you made from you, and we will always + comply if you ask for your poem to be modified, and or taken down from + this site. +

    +
    + +     + +

    Built-in backgrounds:

    +

    + These backgrounds are free for you to use to jazz up your poem's look! + Drawn and shot by members of the subliminal team. +

    +
    +
    + +
    Taken somewhere in the Chilterns, UK.
    +
    +
    +
    - -
    - Taken at an intersection somewhere between Uusikaupunki and - Helsinki, Finland. -
    + Taken at an intersection somewhere between Uusikaupunki and + Helsinki, Finland.
    +
    +
    +
    - -
    - A fish that mysteriously disappeared the next day, Island near - Uusikaupunki, Finland. -
    + A fish that mysteriously disappeared the next day, Island near + Uusikaupunki, Finland.
    +
    +
    + +
    A bridge to the Tate, London, UK.
    +
    +
    + +
    A day in the city, near Farringdon, London, UK.
    +
    +
    +
    - -
    A bridge to the Tate, London, UK.
    + It took standing on a rock in the middle of the sea to get this, + Portheleven, UK.
    +
    +
    +
    - -
    A day in the city, near Farringdon, London, UK.
    + A really old shell cave, in Gyllyngdune Gardens, Falmouth, UK.
    +
    +
    + +
    A long path to mount Snowdon (maybe), Wales, UK.
    +
    +
    +
    - -
    - It took standing on a rock in the middle of the sea to get this, - Portheleven, UK. -
    + A spooky snap of quarry taken from a moving vehicle, Snowdonia, + Wales, UK.
    +
    +
    + +
    A sunnier view of the massive quarry, Snowdonia, Wales, UK.
    +
    +
    +
    - -
    - A really old shell cave, in Gyllyngdune Gardens, Falmouth, UK. -
    + An atmospheric pee(a)k (punny) of a quarry, Snowdonia, Wales, UK.
    +
    +
    +
    - -
    A long path to mount Snowdon (maybe), Wales, UK.
    + This boat certainly has more than 5 horsepower, Island near + Uusikaupunki, Finland.
    +
    +
    + +
    A long, long road, past field and moor, Yorkshire, UK.
    +
    +
    +
    - -
    - A spooky snap of quarry taken from a moving vehicle, Snowdonia, - Wales, UK. -
    + Chaos, for those who want to have a bit of zazz around their stuff.
    +
    +
    +
    - -
    A sunnier view of the massive quarry, Snowdonia, Wales, UK.
    + Is it a bird? Dog? A secret message of text? All we know is that + this mascot is iconic.
    -
    - -
    - An atmospheric pee(a)k (punny) of a quarry, Snowdonia, Wales, UK. +
    +
    +
    + +

    Load poem:

    + +
    + + +     +
    +
    +

    + Click On Me to Start Editing +

    +

     - By 

    +

    + Click On Me to Start Editing +

    +
    +
    +
    +
    - -

    Load poem:

    - -
    -
    +
    - - -
    -
    -

    - Click On Me to Start Editing -

    -

     - By 

    -

    - Click On Me to Start Editing -

    -
    -
    -
    - - - - - - - - - - -
    - + + + + + + + +
    + + - - - -
    -
    -
    - -

    Find someone to invite

    - -
    -     -
    - Online editors: -
    - -
    - You
    -
    - + + +
    -
    - - - - -
    - - - - - - - + You
    -
    -
    -
    -
    -

    Poem summary:

    -
    - + +
    +
    + +
    +
    +
    +
    +
    +

    Poem summary:

    -
    -
    -

    Poem tags:

    -
    -
    - -
    + +
    +
    +
    +

    Poem tags:

    -
    -
    -

    Content Warning:

    -
    -
    - - - -
    +
    +
    -
    -
    -

    Poem Rhyme finder:

    - -

    - Use * to match any word ending, or ?? to match anything within a word, - for example pai* (paint, pain), p???t (paint, print) -

    - - - - - - - - - - - - - -
    - +
    +
    +

    Content Warning:

    -

    - Credits to datamuse for their fantastic API. https://www.datamuse.com/ -

    -
    -
    -

    Poem AI coauthor:

    - Use the subliminal poem writing AI to help cowrite your work! - - - - - -
    -
    -
    - - - + + +
    +
    - <- Back - - + } + + function appendRhyme(event) { + // TODO: Rhyme + console.log(event) + } + + async function editMode() { + loadPoemPopup.close() + let currentJson = await fetchPathJson(edit) + currentJson.edits = edit + load(currentJson) + } + + if (amend) + amendMode(); //enter poem amendment mode + else if (edit) editMode(); + else fetchStorage(); //Load saved poems from local storage + + formattingToolbar.addEventListener("mousemove", (event) => { + for (let button of formattingToolbar.children) { + if (button.className == "separator") continue; + button.style.background = + "radial-gradient(at left " + + (event.screenX - button.offsetLeft) + + "px top " + + (event.screenY - button.offsetTop) + + "px, darkgray, var(--background-opaque)" + } + }); + + formattingToolbar.addEventListener("mouseleave", (event) => { + for (let button of formattingToolbar.children) { + if (button.className == "separator") continue + button.style.background = "none" + } + }); + + + \ No newline at end of file diff --git a/poem.html b/poem.html index 2f90db9..0eedede 100644 --- a/poem.html +++ b/poem.html @@ -3,6 +3,7 @@ Subliminal + @@ -24,7 +25,7 @@

    Poem - By Author

    - + + <- Back -
    +
    @@ -58,24 +59,24 @@

    Edit poem:

    } try { const poemData = await response.json() - //Set up title and url bar for vanity + // Set up title and url bar for vanity window.history.replaceState(null, "Title", path) document.title = "Subliminal - " + poemData.poemName - //Display content warning with additions if needed + // Display content warning with additions if needed if (poemData.cWarning === true) { document.body.insertBefore( createFromData("content-warning", { addition: poemData.cWarningAdditions }), back) } - //Place poem data into the DOM + // Place poem data into the DOM poemTitle.innerText = poemData.poemName + " - By " + poemData.poemAuthor const poemDocument = new EditorDocument(poemData.poemContent) poemDocument.renderHtmlData(poemContent) poemMain.classList.add(poemData.pageStyle) document.body.style.background = poemData.pageBackground - //Probably useless since pages are procedurally generated... + // Probably useless since pages are procedurally generated... document.querySelector('meta[name="description"]').setAttribute("content", poemData.summary) document.querySelector('meta[name="keywords"]').setAttribute("content", poemData.tags) } diff --git a/polyfill.js b/polyfill.js index 194ced5..43ad70e 100644 --- a/polyfill.js +++ b/polyfill.js @@ -7,7 +7,6 @@ */ (() => { "use strict" - Path2D.prototype.roundRect ??= roundRect; if (globalThis.CanvasRenderingContext2D) { globalThis.CanvasRenderingContext2D.prototype.roundRect ??= roundRect diff --git a/purgatory-poem.html b/purgatory-poem.html index af90e1e..29c718b 100644 --- a/purgatory-poem.html +++ b/purgatory-poem.html @@ -2,17 +2,19 @@ - Subliminal - Loading... + Subliminal + - + +