220 lines
5.5 KiB
JavaScript
220 lines
5.5 KiB
JavaScript
const r2 = require('r2')
|
|
const path = require('path')
|
|
const fs = require('fs')
|
|
const getPost = require('mediumexporter').getPost
|
|
const { createClient } = require('webdav')
|
|
|
|
/**
|
|
* function [fetchFromMedium]
|
|
* @returns [string] status
|
|
*/
|
|
|
|
const fetchFromMedium = async (mediumUrl) => {
|
|
console.info(`Fetching: ${mediumUrl}`);
|
|
output = path.join(process.env.PWD, 'content')
|
|
|
|
// use mediumexporter's getPost function to fetch a Medium post
|
|
const post = await getPost(mediumUrl, {
|
|
returnObject: true,
|
|
output: output,
|
|
}).catch((err) => {
|
|
return {
|
|
error: err,
|
|
}
|
|
})
|
|
|
|
// set output folder path
|
|
// this is based on what mediumexporter chooses as the output folder
|
|
outputFolder = path.join(output, post.slug)
|
|
|
|
console.info(`Saving to: ${outputFolder}`)
|
|
|
|
if (!fs.existsSync(path.join(outputFolder, post.slug))) {
|
|
fs.mkdirSync(outputFolder, { recursive: true })
|
|
}
|
|
|
|
// mediumexporter writes a plain .md file if the post has no media
|
|
// if that is the case, we should create the subfolder manually
|
|
// and copy the data there.
|
|
if (fs.existsSync(path.join(output, post.slug + '.md'))) {
|
|
fs.renameSync(
|
|
path.join(output, post.slug + '.md'),
|
|
path.join(outputFolder, 'index.md')
|
|
)
|
|
}
|
|
|
|
// generate metadata
|
|
const metadata = JSON.stringify({
|
|
title: post.title,
|
|
subtitle: post.subtitle,
|
|
date: new Date(post.date),
|
|
tags: post.tags,
|
|
url: post.url,
|
|
slug: post.slug,
|
|
images: post.images,
|
|
featuredImage: post.featuredImage,
|
|
})
|
|
|
|
// write metadata to output folder
|
|
fs.writeFileSync(path.join(outputFolder, 'metadata.json'))
|
|
return post
|
|
};
|
|
|
|
/**
|
|
* function [pushToGhost]
|
|
* @returns [string] status
|
|
*/
|
|
const pushToGhost = (postSlug) => {
|
|
console.info('Pushing: ' + postSlug);
|
|
};
|
|
|
|
/**
|
|
* function [mediumToGhost]
|
|
* @returns [string] status
|
|
*/
|
|
const mediumToGhost = (mediumUrl) => {
|
|
console.info('Copying: ' + mediumUrl);
|
|
};
|
|
|
|
|
|
async function fetchMediumJSON(mediumUrl) {
|
|
console.debug(`Fetching: ${mediumUrl}`)
|
|
const response = await fetch(mediumUrl)
|
|
const text = await response.text()
|
|
const json = await JSON.parse(text.substr(text.indexOf('{')))
|
|
return json;
|
|
}
|
|
|
|
/**
|
|
* function [createUser]
|
|
* @returns [object] ghost data json
|
|
*/
|
|
const generateUserData = async (mediumUsername, email) => {
|
|
console.debug('Creating: @' + mediumUsername + '(email: ' + email + ')');
|
|
const mediumUrl = `https://medium.com/@${mediumUsername}/?format=json`;
|
|
const json = await fetchMediumJSON(mediumUrl);
|
|
|
|
if (!json.success) {
|
|
console.error(`Error: ${json.error}`)
|
|
return false
|
|
}
|
|
|
|
console.debug(`Name: ${json.payload.user.name}`)
|
|
console.debug(`Bio: ${json.payload.user.bio}`)
|
|
|
|
// Generate Ghost JSON
|
|
|
|
const ghostData = {
|
|
data: {
|
|
users: [
|
|
{
|
|
id: 1,
|
|
slug: json.payload.user.username,
|
|
bio: json.payload.user.bio,
|
|
email: email,
|
|
name: json.payload.user.name,
|
|
}
|
|
]
|
|
},
|
|
meta: {
|
|
exported_on: new Date,
|
|
version: '2.14.0'
|
|
}
|
|
}
|
|
|
|
|
|
return(JSON.stringify(ghostData))
|
|
};
|
|
|
|
const createDirIfNotExist = async (client, folder) => {
|
|
// recursively create subfolders if they don't exist.
|
|
|
|
//safety: don't touch directories outside WEBDAV_PATH_PREFIX
|
|
if (!folder.startsWith(process.env.WEBDAV_PATH_PREFIX)) {
|
|
throw new Error(`Cannot create directories outside ${process.env.WEBDAV_PATH_PREFIX}`)
|
|
}
|
|
|
|
// check the folder
|
|
await client.stat(folder)
|
|
.catch(async (err) => {
|
|
if (err.response.status == 404) {
|
|
|
|
// it's a 404, so we'll create the directory
|
|
console.debug(`Noting missing subdirectory: ${folder}`)
|
|
|
|
// first, create the parent directory (if required)
|
|
await createDirIfNotExist(client, path.dirname(folder))
|
|
|
|
console.debug(`Creating missing subdirectory: ${folder}`)
|
|
// then, create the current directory
|
|
await client.createDirectory(folder)
|
|
.catch(async (err) => {
|
|
if (err.response.status == 405) { // Method Not Allowed
|
|
// Maybe the directory's already been created in the meantime?
|
|
await client.stat(folder)
|
|
.catch((err2) => {
|
|
// Bad guess. Panic (and raise the original error)
|
|
console.debug(err.toJSON())
|
|
throw err
|
|
})
|
|
} else {
|
|
// what's this? Panic!
|
|
console.debug(err.toJSON())
|
|
throw err
|
|
}
|
|
})
|
|
} else {
|
|
|
|
// it's not a 404; we don't know how to handle this. Panic!
|
|
console.debug(err.toJSON())
|
|
throw err
|
|
}
|
|
})
|
|
}
|
|
|
|
/**
|
|
* function [createUser]
|
|
* @returns [string] status
|
|
*/
|
|
const webdavTest = async (filePath) => {
|
|
|
|
// connect to webdav
|
|
client = createClient(
|
|
process.env.WEBDAV_SERVER_URL,
|
|
{
|
|
username: process.env.WEBDAV_USERNAME,
|
|
password: process.env.WEBDAV_PASSWORD,
|
|
digest: process.env.WEBDAV_USE_DIGEST == 'true'
|
|
})
|
|
|
|
// decide path
|
|
current_date = new Date();
|
|
var dir_path = path.join(
|
|
process.env.WEBDAV_PATH_PREFIX,
|
|
current_date.getUTCFullYear().toString(),
|
|
current_date.getUTCMonth().toString(),
|
|
'test' // TODO: replace with article slug
|
|
)
|
|
|
|
// create directory if not exists
|
|
console.debug(`Loading ${dir_path}`)
|
|
await createDirIfNotExist(client, dir_path)
|
|
|
|
// upload a file
|
|
console.debug('Uploading file')
|
|
s = fs.createReadStream(filePath)
|
|
.pipe(client.createWriteStream(
|
|
path.join(dir_path, path.basename(filePath))
|
|
))
|
|
.on('finish', () => console.debug('Uploaded successfully.'))
|
|
|
|
return true
|
|
}
|
|
|
|
module.exports = {
|
|
fetchFromMedium,
|
|
pushToGhost,
|
|
mediumToGhost,
|
|
generateUserData,
|
|
webdavTest
|
|
}
|