864 lines
27 KiB
JavaScript
864 lines
27 KiB
JavaScript
class WTVAuthor {
|
|
|
|
fs = require('fs');
|
|
path = require('path');
|
|
uuid = require('uuid');
|
|
|
|
ssid = null;
|
|
minisrv_config = [];
|
|
wtvshared = null;
|
|
wtvclient = null;
|
|
pageFileExt = ".page";
|
|
pagestore_dir = null;
|
|
pageArr = [];
|
|
blockArr = [];
|
|
header = null;
|
|
previewheader = null;
|
|
titheader = null;
|
|
tabstart = null;
|
|
footerstart = null;
|
|
webtvfooter = null;
|
|
footerend = null;
|
|
link = "#0000EE";
|
|
vlink = "#551A8B";
|
|
text = "#000000";
|
|
headcol = this.text
|
|
listcol1 = null;
|
|
listcol2 = null;
|
|
stylemedia = [];
|
|
headerimgL = null;
|
|
headerimgLheight = null;
|
|
headerimgLwidth = null;
|
|
afterblock1 = null;
|
|
debug = require('debug')('WTVAuthor')
|
|
nunjucks = null;
|
|
|
|
constructor(minisrv_config, wtvclient) {
|
|
if (!minisrv_config) throw ("minisrv_config required");
|
|
if (!wtvclient) throw ("WTVClientSessionData required");
|
|
const WTVShared = require('./WTVShared.js')['WTVShared'];
|
|
const nunjucks = require('nunjucks');
|
|
this.nunjucks = nunjucks;
|
|
const WTVMime = require('./WTVMime.js');
|
|
this.minisrv_config = minisrv_config;
|
|
this.wtvshared = new WTVShared(minisrv_config);
|
|
this.wtvmime = new WTVMime(minisrv_config);
|
|
this.wtvclient = wtvclient;
|
|
this.ssid = wtvclient.ssid;
|
|
this.pageArr = this.pageArr;
|
|
this.blockArr = this.blockArr;
|
|
}
|
|
|
|
checkPageIntroSeen() {
|
|
return (this.wtvclient.getSessionData("subscriber_page_intro_seen")) ? this.wtvclient.getSessionData("subscriber_page_intro_seen") : false;
|
|
}
|
|
|
|
setPageIntroSeen(seen) {
|
|
this.wtvclient.setSessionData("subscriber_page_intro_seen", (seen) ? true : false);
|
|
}
|
|
|
|
pagestoreExists() {
|
|
if (this.pagestore_dir === null) {
|
|
// set pagestore directory local var so we don't call the function every time
|
|
const userstore_dir = this.wtvclient.getUserStoreDirectory();
|
|
// PageStore
|
|
const store_dir = "PageStore" + this.path.sep;
|
|
this.pagestore_dir = userstore_dir + store_dir;
|
|
}
|
|
return this.fs.existsSync(this.pagestore_dir);
|
|
}
|
|
|
|
createPagestore() {
|
|
if (this.pagestoreExists() === false) {
|
|
try {
|
|
if (!this.fs.existsSync(this.pagestore_dir)) this.fs.mkdirSync(this.pagestore_dir, { recursive: true });
|
|
return true;
|
|
} catch { }
|
|
}
|
|
return false;
|
|
}
|
|
|
|
createPage(style) {
|
|
this.pagestoreExists()
|
|
let pagenum = 0;
|
|
let pagefile = null;
|
|
const pagestorepath = this.pagestore_dir;
|
|
// All this shit is to work around the part where I don't use UUIDs to store pages, which is bad
|
|
const pages = this.fs.readdirSync(pagestorepath)
|
|
if (pages.length === 0) {
|
|
pagenum = 0;
|
|
} else {
|
|
let pagelen = pages.length;
|
|
if (pagelen < 0) pagelen = 0;
|
|
this.debug("createPage","pages",pages)
|
|
let pagenums = [];
|
|
for(let i = 0; i < pagelen; i++) {
|
|
const toarr = pages[i].slice(0, pages[i].indexOf('.'));
|
|
pagenums.push(parseInt(toarr));
|
|
}
|
|
pagenums = pagenums.sort()
|
|
this.debug("createPage", "pagenums", pagenums)
|
|
pagenum = parseInt(pagenums[pagelen - 1]);
|
|
this.debug("createPage", "pagenum", pagenum)
|
|
this.debug("createPage", "pagelen", pagelen)
|
|
}
|
|
if (pages.length === 0) {
|
|
pagenum = 0
|
|
pagefile = pagenum + this.pageFileExt;
|
|
} else {
|
|
pagefile = (pagenum + 1) + this.pageFileExt;
|
|
}
|
|
const pagefileout = this.pagestore_dir + pagefile;
|
|
// JSON data structure
|
|
const pagedata = {
|
|
"style": style,
|
|
"title": "(Untitled)",
|
|
"description": "(no description)",
|
|
"pagebreaks": [],
|
|
"showtitle": true,
|
|
"inlist": true,
|
|
"published": false,
|
|
"publishdate": null,
|
|
"publishname": null,
|
|
"blocks": []
|
|
}
|
|
if (this.fs.existsSync(pagefileout)) {
|
|
console.error(" * ERROR: Page already exists (should never happen). Page lost.");
|
|
return false;
|
|
}
|
|
|
|
// Encode page data into JSON
|
|
let returnval = pages.length
|
|
this.fs.writeFileSync(pagefileout, JSON.stringify(pagedata));
|
|
if (returnval !== 0) {
|
|
const npages = this.fs.readdirSync(pagestorepath)
|
|
returnval = npages.length - 1;
|
|
}
|
|
return returnval;
|
|
}
|
|
|
|
loadPage(pagenum) {
|
|
this.pagestoreExists()
|
|
const page_file = this.listPages();
|
|
const page_data_raw = page_file[pagenum];
|
|
|
|
if (page_data_raw) {
|
|
return page_data_raw;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
setStyle(style, title, desc, state, docName) {
|
|
// There's probably a better way to do this involving external files for each style, but no
|
|
this.debug("setStyle", "this.wtvshared.makeSafeStringPath(style) (before load)", this.wtvshared.makeSafeStringPath(style));
|
|
const template_data_file = this.wtvshared.getTemplate("wtv-author", "styles/" + this.wtvshared.makeSafeStringPath(style) + ".js", true);
|
|
if (template_data_file) {
|
|
this.debug("setStyle", "template_data_file", template_data_file);
|
|
const PBTemplate = require(template_data_file);
|
|
const pbtemplate = new PBTemplate(this, title, desc, state, docName);
|
|
const template_data = pbtemplate.get();
|
|
const self = this;
|
|
Object.keys(template_data).forEach((k) => {
|
|
self[k] = template_data[k];
|
|
})
|
|
this.debug("setStyle", "this.stylemedia", this.stylemedia);
|
|
}
|
|
}
|
|
|
|
generateBlock(number, page, state) {
|
|
const pagedata = this.loadPage(page);
|
|
const thisblock = pagedata.blocks[number];
|
|
const type = thisblock.type;
|
|
const numofblocks = pagedata.blocks.length;
|
|
|
|
// Configure nunjucks with custom filters
|
|
const env = this.nunjucks.configure({ autoescape: false });
|
|
env.addFilter('base64_decode', function(str) {
|
|
return Buffer.from(str, 'base64').toString();
|
|
});
|
|
|
|
const templateData = {
|
|
state: state,
|
|
page: page,
|
|
number: number,
|
|
thisblock: thisblock,
|
|
numofblocks: numofblocks,
|
|
headcol: this.headcol,
|
|
text_color: this.text,
|
|
headerimgL: this.headerimgL,
|
|
headerimgLwidth: this.headerimgLwidth,
|
|
headerimgLheight: this.headerimgLheight,
|
|
listcol1: this.listcol1,
|
|
listcol2: this.listcol2
|
|
};
|
|
|
|
let templatePath;
|
|
let block = "";
|
|
|
|
switch(type) {
|
|
case "text":
|
|
templatePath = this.wtvshared.getServiceDep('wtv-author/blocks/text_block.njk', true);
|
|
block = this.nunjucks.render(templatePath, templateData);
|
|
break;
|
|
|
|
case "snapshot":
|
|
case "scrapbook":
|
|
if (state === "publishing") {
|
|
block = this.generatePublishImageBlock(number, page);
|
|
} else {
|
|
templatePath = this.wtvshared.getServiceDep('wtv-author/blocks/snapshot_block.njk', true);
|
|
block = this.nunjucks.render(templatePath, templateData);
|
|
}
|
|
break;
|
|
|
|
case "clipart":
|
|
if (state === "publishing") {
|
|
block = this.generatePublishImageBlock(number, page);
|
|
} else {
|
|
templatePath = this.wtvshared.getServiceDep('wtv-author/blocks/clipart_block.njk', true);
|
|
block = this.nunjucks.render(templatePath, templateData);
|
|
}
|
|
break;
|
|
|
|
case "heading":
|
|
templatePath = this.wtvshared.getServiceDep('wtv-author/blocks/heading_block.njk', true);
|
|
block = this.nunjucks.render(templatePath, templateData);
|
|
break;
|
|
|
|
case "list":
|
|
templatePath = this.wtvshared.getServiceDep('wtv-author/blocks/list_block.njk', true);
|
|
block = this.nunjucks.render(templatePath, templateData);
|
|
break;
|
|
|
|
case "link":
|
|
templatePath = this.wtvshared.getServiceDep('wtv-author/blocks/link_block.njk', true);
|
|
block = this.nunjucks.render(templatePath, templateData);
|
|
break;
|
|
|
|
default:
|
|
block = "";
|
|
break;
|
|
}
|
|
|
|
return block;
|
|
}
|
|
// Separate function for generating image blocks when publishing because there is no possibly better way to do this
|
|
generatePublishImageBlock(number, page) {
|
|
const destDir = this.getPublishDir();
|
|
const pagedata = this.loadPage(page);
|
|
const thisblock = pagedata.blocks[number];
|
|
const type = thisblock.type;
|
|
|
|
// Configure nunjucks with custom filters
|
|
const env = this.nunjucks.configure({ autoescape: false });
|
|
env.addFilter('base64_decode', function(str) {
|
|
return Buffer.from(str, 'base64').toString();
|
|
});
|
|
|
|
const templateData = {
|
|
number: number,
|
|
thisblock: thisblock,
|
|
headcol: this.headcol
|
|
};
|
|
|
|
let block = "";
|
|
let templatePath;
|
|
|
|
switch(type) {
|
|
case "snapshot":
|
|
templatePath = this.wtvshared.getServiceDep('wtv-author/blocks/snapshot_publish_block.njk', true);
|
|
block = this.nunjucks.render(templatePath, templateData);
|
|
|
|
// Write the image file
|
|
this.fs.writeFile(destDir + this.wtvclient.session_store.subscriber_username + '/' + pagedata.publishname + '/media/captureA' + number + '.jpg', new Buffer.from(thisblock.photo, 'base64'), err => {
|
|
if (err) {
|
|
console.error(err);
|
|
}
|
|
// file written successfully
|
|
});
|
|
break;
|
|
|
|
case "clipart":
|
|
// Create directory and copy file
|
|
this.fs.mkdirSync(destDir + this.wtvclient.session_store.subscriber_username + '/' + pagedata.publishname + "/" + Buffer.from(thisblock.photo, 'base64').toString().slice(0, Buffer.from(thisblock.photo, 'base64').toString().lastIndexOf("/")), { recursive: true });
|
|
this.fs.copyFile('includes/ServiceVault/wtv-author/' + Buffer.from(thisblock.photo, 'base64').toString(), destDir + this.wtvclient.session_store.subscriber_username + '/' + pagedata.publishname + "/" + Buffer.from(thisblock.photo, 'base64').toString(), (err) => {
|
|
if (err) throw err;
|
|
});
|
|
|
|
templatePath = this.wtvshared.getServiceDep('wtv-author/blocks/clipart_publish_block.njk', true);
|
|
block = this.nunjucks.render(templatePath, templateData);
|
|
break;
|
|
}
|
|
return block;
|
|
}
|
|
|
|
generatePage(state, pagenum, page) {
|
|
const pagedata = this.loadPage(pagenum);
|
|
let title;
|
|
// Should probably have a better way to know if the page has no title
|
|
if (pagedata.title === "(Untitled)" && state === "editing")
|
|
title = "<i>Choose this to add a title to your document</i>"
|
|
else
|
|
title = pagedata.title
|
|
// Set the page style with too many paramaters
|
|
this.setStyle(pagedata.style, title, pagedata.description, state, pagenum);
|
|
let html = this.header
|
|
if (page === 1) {
|
|
if (pagedata.showtitle === true){
|
|
html += this.titheader
|
|
}
|
|
}
|
|
html += this.tabstart
|
|
// This generates blocks on separate pages in the most neat and optimized way possible (i think, i hate past jar)
|
|
if (page !== 1) {
|
|
for (let i = pagedata.pagebreaks[page - 2]; i < (pagedata.pagebreaks[page - 1] || pagedata.blocks.length); i++) {
|
|
html += this.generateBlock(i, pagenum, state)
|
|
}
|
|
} else if (pagedata.pagebreaks.length !== 0){
|
|
for (let i = 0; i < pagedata.pagebreaks[0]; i++) {
|
|
html += this.generateBlock(i, pagenum, state)
|
|
if (this.afterblock1 && i === 0) {
|
|
html += this.afterblock1
|
|
}
|
|
}
|
|
} else {
|
|
for (let i = 0; i < pagedata.blocks.length; i++) {
|
|
html += this.generateBlock(i, pagenum, state)
|
|
if (this.afterblock1 && i === 0) {
|
|
html += this.afterblock1
|
|
}
|
|
}
|
|
}
|
|
html += this.footerstart
|
|
// Add the footer if we're not in edit mode
|
|
html += this.getPaginationFooter(state, pagedata, page, pagenum)
|
|
html += this.footerend
|
|
return html;
|
|
}
|
|
|
|
editPage(pagedata, pagenum, callPublish = true) {
|
|
// just stolen from favorites lmao
|
|
const pageout = new Object();
|
|
const pagepath = this.pagestore_dir;
|
|
Object.assign(pageout, pagedata);
|
|
const pagestorepath = this.pagestore_dir;
|
|
const pages = this.fs.readdirSync(pagestorepath)
|
|
const page = pages[pagenum]
|
|
const result = this.fs.writeFileSync(pagepath + page, JSON.stringify(pageout));
|
|
if (pagedata.published === true && callPublish) {
|
|
this.publishPage(pagenum, pagedata.inlist, false)
|
|
}
|
|
if (!result) return false;
|
|
}
|
|
|
|
editMetadata(title, description, showtitle, pagenum) {
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
|
|
pagedata.title = title;
|
|
pagedata.description = description;
|
|
pagedata.showtitle = !showtitle;
|
|
this.editPage(pagedata, pagenum);
|
|
return true;
|
|
}
|
|
|
|
listPages() {
|
|
// i don't remember why, but i'm pretty sure this function sucks
|
|
const pagestore = this.pagestoreExists();
|
|
if (!pagestore) this.createPagestore();
|
|
const userstore_dir = this.wtvclient.getUserStoreDirectory();
|
|
|
|
// PageStore
|
|
const store_dir = "PageStore" + this.path.sep;
|
|
this.pagestore_dir = userstore_dir + store_dir;
|
|
const pagestorepath = this.pagestore_dir;
|
|
const self = this;
|
|
self.pageArr = [];
|
|
if (self.fs.existsSync(pagestorepath)) {
|
|
const files = this.fs.readdirSync(pagestorepath)
|
|
this.debug("listPages","files",files)
|
|
files.map(function (v) {
|
|
if (v.endsWith(self.pageFileExt)) {
|
|
// oh yeah it's because any non-JSON file in pagestore will throw an error and break everything
|
|
let page_data_raw = null;
|
|
const pagepath = pagestorepath + self.path.sep + v;
|
|
if (self.fs.existsSync(pagepath)) page_data_raw = self.fs.readFileSync(pagepath);
|
|
if (page_data_raw) {
|
|
const page_data = JSON.parse(page_data_raw);
|
|
self.pageArr.push(page_data);
|
|
}
|
|
}
|
|
})
|
|
}
|
|
return self.pageArr;
|
|
}
|
|
|
|
deleteBlock(pagenum, position) {
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
|
|
const block = pagedata.blocks[position];
|
|
|
|
const blocks = pagedata.blocks;
|
|
blocks.splice(position, 1);
|
|
this.editPage(pagedata, pagenum);
|
|
if (block.type === "break")
|
|
this.generateBreakList(pagenum)
|
|
return true;
|
|
}
|
|
|
|
getPublishDomain() {
|
|
if (this.minisrv_config.services['wtv-author'].public_domain) {
|
|
return this.minisrv_config.services['wtv-author'].public_domain;
|
|
} else {
|
|
if (this.minisrv_config.services['wtv-author'].publish_mode === "service") {
|
|
const target_service = this.minisrv_config.services[this.minisrv_config.services['wtv-author'].publish_dest];
|
|
if (target_service) {
|
|
return target_service.host + ":" + target_service.port;
|
|
}
|
|
} else {
|
|
return this.minisrv_config.services['wtv-author'].host + ":" + this.minisrv_config.services['wtv-author'].port;
|
|
}
|
|
}
|
|
}
|
|
|
|
getPoweredBy() {
|
|
if (this.minisrv_config.services['wtv-author'].powered_by_url) {
|
|
return this.minisrv_config.services['wtv-author'].powered_by_url;
|
|
} else {
|
|
return this.getPublishDomain();
|
|
}
|
|
}
|
|
|
|
getPublishDir() {
|
|
let destDir = false;
|
|
if (this.minisrv_config.services['wtv-author'].publish_mode === "service") {
|
|
const target_service = this.minisrv_config.services[this.minisrv_config.services['wtv-author'].publish_dest];
|
|
if (target_service) {
|
|
if (!target_service.pc_services) {
|
|
console.error("Invalid service configuration: publish_dest is not a pc service.");
|
|
return false;
|
|
}
|
|
if (!target_service.servicevault_dir) {
|
|
target_service.servicevault_dir = this.minisrv_config.services['wtv-author'].publish_dest;
|
|
}
|
|
if (target_service.service_vaults) {
|
|
destDir = target_service.service_vaults[0] + this.path.sep + target_service.servicevault_dir + this.path.sep;
|
|
} else {
|
|
destDir = this.minisrv_config.config.ServiceVaults[0] + this.path.sep + target_service.servicevault_dir + this.path.sep;
|
|
}
|
|
}
|
|
} else if (this.minisrv_config.services['wtv-author'].publish_mode === "directory") {
|
|
destDir = this.minisrv_config.services['wtv-author'].publish_dest;
|
|
} else {
|
|
console.error("Invalid service configuration: invalid publish_mode.");
|
|
return false;
|
|
}
|
|
return destDir;
|
|
}
|
|
|
|
|
|
unpublishPage(pagenum) {
|
|
const pagedata = this.loadPage(pagenum)
|
|
const destDir = this.getPublishDir();
|
|
if (pagedata.published !== true) {
|
|
return "This page is not published."
|
|
}
|
|
const publishname = pagedata.publishname;
|
|
if (this.fs.existsSync(destDir + this.wtvclient.session_store.subscriber_username + '/' + publishname)) {
|
|
try {
|
|
this.fs.rmSync(destDir + this.wtvclient.session_store.subscriber_username + '/' + publishname, { recursive: true })
|
|
pagedata.published = false;
|
|
this.editPage(pagedata, pagenum, false);
|
|
const pages = this.listPages()
|
|
const publishedPagesCount = pages.filter(page => page.published).length;
|
|
if (publishedPagesCount === 0) {
|
|
this.fs.rmSync(destDir + this.wtvclient.session_store.subscriber_username, { recursive: true });
|
|
}
|
|
this.generatePageList()
|
|
return true;
|
|
} catch { }
|
|
}
|
|
return false;
|
|
}
|
|
|
|
publishPage(pagenum, listpublicly) {
|
|
// this was done in a rush and probably also sucks
|
|
// remember to increment the "hours wasted here" comment at the top of the file
|
|
const pagedata = this.loadPage(pagenum)
|
|
const destDir = this.getPublishDir();
|
|
let publishname, fileout;
|
|
|
|
if (pagedata.published !== true) {
|
|
publishname = pagedata.title.slice(0, 50).replaceAll(" ", "").replace(/[^A-Za-z0-9]/g, "-");
|
|
pagedata.publishname = publishname;
|
|
this.editPage(pagedata, pagenum);
|
|
if (this.fs.existsSync(destDir + this.wtvclient.session_store.subscriber_username + '/' + publishname)) {
|
|
return "You already have a published page with a name similar to this one. Try changing the name of this page and try again.";
|
|
}
|
|
} else {
|
|
publishname = pagedata.publishname;
|
|
}
|
|
pagedata.publishname = publishname;
|
|
this.fs.mkdirSync(destDir + this.wtvclient.session_store.subscriber_username + '/' + publishname, { recursive: true })
|
|
this.fs.mkdirSync(destDir + this.wtvclient.session_store.subscriber_username + '/' + publishname + "/clipart/styleMedia/", { recursive: true })
|
|
this.fs.mkdirSync(destDir + this.wtvclient.session_store.subscriber_username + '/' + publishname + "/media/", { recursive: true })
|
|
for (let i = 1; i < pagedata.pagebreaks.length + 2; i++) {
|
|
const pagehtml = this.generatePage("publishing", pagenum, i)
|
|
if (i === 1)
|
|
fileout = "index.html"
|
|
else
|
|
fileout = "page" + i + ".html"
|
|
this.fs.writeFile(destDir + this.wtvclient.session_store.subscriber_username + '/' + publishname + '/' + fileout, pagehtml, err => {
|
|
if (err) {
|
|
console.error(err);
|
|
}
|
|
// file written successfully
|
|
});
|
|
}
|
|
for (let i = 0; i < this.stylemedia.length; i++) {
|
|
this.fs.mkdirSync(destDir + this.wtvclient.session_store.subscriber_username + '/' + publishname + this.stylemedia[i].slice(0, this.stylemedia[i].lastIndexOf("/")), { recursive: true })
|
|
this.fs.copyFile('includes/ServiceVault/wtv-author' + this.stylemedia[i], destDir + this.wtvclient.session_store.subscriber_username + '/' + publishname + this.stylemedia[i], (err) => {
|
|
if (err) throw err;
|
|
});
|
|
}
|
|
const strftime = require('strftime');
|
|
pagedata.publishdate = strftime("%a, %b %d, %Y, %I:%M%P", new Date(new Date().toUTCString()))
|
|
pagedata.published = true;
|
|
pagedata.inlist = listpublicly;
|
|
pagedata.publishname = publishname;
|
|
this.editPage(pagedata, pagenum, false);
|
|
this.generatePageList()
|
|
return true;
|
|
}
|
|
|
|
generatePageList() {
|
|
// this one's pretty ok i think, but it should have screenshots of each page
|
|
const pagelist = this.listPages();
|
|
|
|
// Filter published pages that should be listed
|
|
const publishedPages = pagelist.filter(page => page.published === true && page.inlist === true);
|
|
|
|
const templatePath = this.wtvshared.getServiceDep('wtv-author/page_list.njk', true);
|
|
this.nunjucks.configure({ autoescape: false });
|
|
|
|
const html = this.nunjucks.render(templatePath, {
|
|
subscriber_name: this.wtvclient.session_store.subscriber_name,
|
|
published_pages: publishedPages
|
|
});
|
|
|
|
this.fs.writeFile(this.getPublishDir() + this.wtvclient.session_store.subscriber_username + '/index.html', html, err => {
|
|
if (err) {
|
|
console.error(err);
|
|
}
|
|
// file written successfully
|
|
});
|
|
}
|
|
|
|
deletePage(pagenum) {
|
|
// i hate fs operations
|
|
const pagestore = this.pagestoreExists()
|
|
const userstore_dir = this.wtvclient.getUserStoreDirectory();
|
|
this.debug("deletePage","userstore_dir",userstore_dir)
|
|
|
|
// PageStore
|
|
const store_dir = "PageStore" + this.path.sep;
|
|
this.pagestore_dir = userstore_dir + store_dir;
|
|
const pagestorepath = this.pagestore_dir;
|
|
const page_file = this.fs.readdirSync(pagestorepath)
|
|
const page_file_out = page_file[pagenum]
|
|
|
|
this.unpublishPage(pagenum);
|
|
if (typeof page_file_out !== 'undefined') {
|
|
this.fs.unlinkSync(this.pagestore_dir + page_file_out, { recursive: true });
|
|
}
|
|
}
|
|
|
|
deleteUser(user_id) {;
|
|
this.wtvclient.switchUserID(user_id, false, false, false);
|
|
const pagelist = this.listPages();
|
|
for (let i = 0; i < pagelist.length; i++) {
|
|
this.deletePage(i);
|
|
}
|
|
const userstore_dir = this.wtvclient.getUserStoreDirectory();
|
|
const store_dir = "PageStore" + this.path.sep;
|
|
this.pagestore_dir = userstore_dir + store_dir;
|
|
this.wtvclient.switchUserID(0, false, false, false);
|
|
}
|
|
|
|
// these totally couldn't have been made into one function nah that's impossible
|
|
createTextBlock(pagenum, title, caption, size, style, position) {
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
|
|
const newblock = {
|
|
"type": "text",
|
|
"title": title,
|
|
"caption": caption,
|
|
"size": size,
|
|
"style": style
|
|
}
|
|
|
|
const blocks = pagedata.blocks
|
|
blocks.splice(position, 0, newblock);
|
|
this.editPage(pagedata, pagenum);
|
|
return true;
|
|
}
|
|
|
|
editTextBlock(pagenum, title, caption, size, style, position, oldposition) {
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
|
|
pagedata.blocks[oldposition].title = title
|
|
pagedata.blocks[oldposition].caption = caption
|
|
pagedata.blocks[oldposition].size = size
|
|
pagedata.blocks[oldposition].style = style
|
|
|
|
if (oldposition !== position)
|
|
this.wtvshared.moveObjectKey(pagedata.blocks,oldposition,position);
|
|
|
|
this.editPage(pagedata, pagenum);
|
|
return true;
|
|
}
|
|
|
|
createPhotoBlock(pagenum, photo, type) {
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
const base64photo = new Buffer.from(photo).toString('base64')
|
|
|
|
const newblock = {
|
|
"type": type,
|
|
"title": null,
|
|
"caption": null,
|
|
"photo": base64photo
|
|
}
|
|
|
|
const blocks = pagedata.blocks
|
|
blocks.push(newblock);
|
|
this.editPage(pagedata, pagenum);
|
|
return true;
|
|
}
|
|
|
|
editPhotoBlock(pagenum, oldposition, position, photo, type, title, caption) {
|
|
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
|
|
const blocks = pagedata.blocks
|
|
|
|
if (photo !== null) {
|
|
const base64photo = new Buffer.from(photo).toString('base64')
|
|
blocks[oldposition].photo = base64photo
|
|
}
|
|
|
|
if (type !== null) {
|
|
blocks[oldposition].type = type
|
|
}
|
|
|
|
if (title !== null)
|
|
blocks[oldposition].title = title
|
|
|
|
if (caption !== null)
|
|
blocks[oldposition].caption = caption
|
|
|
|
if (oldposition !== position) {
|
|
this.wtvshared.moveObjectKey(blocks, oldposition,position);
|
|
}
|
|
|
|
this.editPage(pagedata, pagenum);
|
|
return true;
|
|
}
|
|
|
|
createHeaderBlock(pagenum, text, size, dividerBefore, dividerAfter, position) {
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
|
|
const newblock = {
|
|
"type": "heading",
|
|
"text": text,
|
|
"size": size,
|
|
"dividerBefore": dividerBefore,
|
|
"dividerAfter": dividerAfter
|
|
}
|
|
|
|
const blocks = pagedata.blocks
|
|
blocks.splice(position, 0, newblock);
|
|
this.editPage(pagedata, pagenum);
|
|
return true;
|
|
}
|
|
|
|
editHeaderBlock(pagenum, text, size, dividerBefore, dividerAfter, position, oldposition) {
|
|
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
|
|
pagedata.blocks[oldposition].text = text
|
|
pagedata.blocks[oldposition].size = size
|
|
pagedata.blocks[oldposition].dividerBefore = dividerBefore
|
|
pagedata.blocks[oldposition].dividerAfter = dividerAfter
|
|
|
|
if (oldposition !== position)
|
|
this.wtvshared.moveObjectKey(pagedata.blocks, oldposition, position);
|
|
|
|
this.editPage(pagedata, pagenum);
|
|
return true;
|
|
}
|
|
|
|
createListBlock(pagenum, title, items, position) {
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
|
|
const newblock = {
|
|
"type": "list",
|
|
"title": title,
|
|
"items": items
|
|
}
|
|
|
|
const blocks = pagedata.blocks
|
|
blocks.splice(position, 0, newblock);
|
|
this.editPage(pagedata, pagenum);
|
|
return true;
|
|
}
|
|
|
|
editListBlock(pagenum, title, items, position, oldposition) {
|
|
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
|
|
pagedata.blocks[oldposition].title = title
|
|
pagedata.blocks[oldposition].items = items
|
|
|
|
if (oldposition !== position)
|
|
this.wtvshared.moveObjectKey(pagedata.blocks, oldposition, position);
|
|
|
|
this.editPage(pagedata, pagenum);
|
|
return true;
|
|
}
|
|
|
|
createLinkBlock(pagenum, title, listItems, linkItems, position) {
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
|
|
const items = [];
|
|
loop:
|
|
for (let i = 0; i < linkItems.length; i++) {
|
|
const url = linkItems[i]
|
|
const name = listItems[i]
|
|
|
|
if (url === "http://") {
|
|
continue loop;
|
|
} else {
|
|
const subblock = {
|
|
"name": name,
|
|
"url": url
|
|
}
|
|
items.push(subblock)
|
|
}
|
|
}
|
|
|
|
const newblock = {
|
|
"type": "link",
|
|
"title": title,
|
|
"items": items
|
|
}
|
|
|
|
const blocks = pagedata.blocks
|
|
blocks.splice(position, 0, newblock);
|
|
this.editPage(pagedata, pagenum);
|
|
return true;
|
|
}
|
|
|
|
editLinkBlock(pagenum, title, listItems, linkItems, position, oldposition) {
|
|
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
|
|
const items = [];
|
|
loop:
|
|
for (let i = 0; i < linkItems.length; i++) {
|
|
const url = linkItems[i]
|
|
const name = listItems[i]
|
|
|
|
if (url === "http://") {
|
|
continue loop;
|
|
} else {
|
|
const subblock = {
|
|
"name": name,
|
|
"url": url
|
|
}
|
|
items.push(subblock)
|
|
}
|
|
}
|
|
|
|
pagedata.blocks[oldposition].title = title
|
|
pagedata.blocks[oldposition].items = items
|
|
|
|
if (oldposition !== position)
|
|
this.wtvshared.moveObjectKey(pagedata.blocks, oldposition, position);
|
|
|
|
this.editPage(pagedata, pagenum);
|
|
return true;
|
|
}
|
|
|
|
createBreakBlock(pagenum, position) {
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
|
|
const newblock = {
|
|
"type": "break"
|
|
}
|
|
|
|
const blocks = pagedata.blocks
|
|
blocks.splice(position, 0, newblock);
|
|
this.editPage(pagedata, pagenum);
|
|
this.generateBreakList(pagenum);
|
|
return true;
|
|
}
|
|
|
|
editBreakBlock(pagenum, position, oldposition) {
|
|
const pagedata = this.loadPage(pagenum);
|
|
if (!pagedata) return false;
|
|
|
|
if (oldposition !== position)
|
|
this.wtvshared.moveObjectKey(pagedata.blocks, oldposition, position);
|
|
|
|
this.editPage(pagedata, pagenum);
|
|
this.generateBreakList(pagenum);
|
|
return true;
|
|
}
|
|
|
|
generateBreakList(pagenum) {
|
|
const pagedata = this.loadPage(pagenum)
|
|
const breaks = [];
|
|
for (let i = 0; i < pagedata.blocks.length; i++) {
|
|
const type = pagedata.blocks[i].type
|
|
if (type === "break")
|
|
breaks.push(i)
|
|
}
|
|
pagedata.pagebreaks = breaks;
|
|
this.editPage(pagedata, pagenum);
|
|
}
|
|
|
|
getCommonFooter() {
|
|
const template = this.wtvshared.getServiceDep('wtv-author/common_footer.njk', true);
|
|
this.nunjucks.configure({ autoescape: true });
|
|
return this.nunjucks.render(template, {
|
|
powered_by: this.getPoweredBy(),
|
|
service_name: this.minisrv_config.config.service_name
|
|
});
|
|
}
|
|
|
|
getPaginationFooter(state, pagedata, page, pagenum) {
|
|
const template = this.wtvshared.getServiceDep('wtv-author/pagination_footer.njk', true);
|
|
this.nunjucks.configure({ autoescape: false });
|
|
return this.nunjucks.render(template, {
|
|
state: state,
|
|
pagedata: pagedata,
|
|
page: parseInt(page),
|
|
pagenum: pagenum,
|
|
powered_by: this.getPoweredBy(),
|
|
service_name: this.minisrv_config.config.service_name
|
|
});
|
|
}
|
|
}
|
|
module.exports = WTVAuthor; |