npm - bloggerize - Versions diffs - 1.0.0 - Mend

bloggerize 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/htmls.js ADDED Viewed

@@ -0,0 +1,110 @@
+///////////////////////////////////////////////////////////
+globalThis.HTML_STYLE = '<style>img{max-width:100%;height:auto;}a{text-decoration:none;}a:link{color:#4287f5;}a:hover{color:red;}</style>';
+globalThis.HTML_FORM = `
+<!DOCTYPE html>
+<meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width,initial-scale=1.0"/>
+<html lang="en">
+<head>{{head}}</head>
+<body>
+{{body}}
+</body>
+</html>`
+///////////////////////////////////////////////////////////
+globalThis.COMMENT_FORM = `
+<comdiv class="comment-block" id="ds-{{count}}">
+<a name="cmt.{{count}}"/>
+<div class="sys-comment-block" id="b-{{id}}">
+ <div class="comment-header">
+  <p>
+   <span class="comment-author" id="c{{id}}">
+    <a class="comment-authorurl" href="{{profile}}" title="Meet her">{{avatar}}</a>
+    <b><a class="comment-authorname" href="{{link}}" timestamp="{{timestamp}}" id="is-post-{{id}}">{{author}}</a></b>
+    <span class="comment-count" style="color: #FF9966;" id="cs-post-{{id}}">({{count}})</span>
+    <span class="comment-authorinfo" id="as-post-{{id}}">{{info}}</span>
+   </span>
+  </p>
+ </div>
+ <div class="comment-body">
+  <p>
+   <span class="comment-text" id="ss-post-{{id}}">{{content}}</span>
+  </p>
+ </div>
+ <div class="comment-footer">
+  <p>
+   <a class="comment-mark" href="#page_top"><img border="0" width="12" height="12" src="https://cdn.jsdelivr.net/gh/asinerum/project/team/gui/mark.gif"/></a>
+   <span class="comment-timestamp" style="color: #AAAAAA" id="ds-post-{{id}}">{{dated}}</span>
+  </p>
+ </div>
+</div>
+</comdiv>`
+globalThis.COMMENT_DATA = {
+  count: 0,
+  id: '',
+  link: '',
+  author: '',
+  profile: '',
+  content: '',
+  timestamp: '',
+  dated: '',
+  avatar: '&#9673;',
+  info: '&#10003;',
+}
+///////////////////////////////////////////////////////////
+globalThis.POST_FORM = `
+<div class="post-entry" id="AhttBlogspotComments" style="text-align: justify; width: 100%; overflow-wrap: break-word;">
+ <p>
+ <a class="post-title" id="bloggerEntryURL" href="{{entry}}">
+  <h2 class="post-entry-title" style="color: blue;" id="bloggerEntryTitle">{{title}}</h2>
+ </a>
+ </p>
+ <p>
+ <h3 class="post-author" style="color: blue;" id="bloggerEntryAuthor">{{author}}</h3>
+ <h5 class="post-info" style="color: blue;">
+  <span class="post-label" id="bloggerEntryLabel">{{label}}</span>
+  <span class="post-stamp" id="bloggerEntryGMTDate">{{stamp}}</span>
+ </h5>
+ </p>
+ <p>
+ <span class="post-entry-content" id="bloggerEntryContent">
+  {{content}}
+ </span>
+ </p>
+ <p>
+ <a name="comments-show"></a>
+ <h2 class="post-comments-info" style="color: blue;">
+  <a class="post-comments-notice" id="bloggerCommentCountingNotice" href="{{compage}}"><span class="post-comments" id="bloggerEntryTotalComments">{{total}}</span>&nbsp;Comments</a>
+  <span class="post-comments-count">(Page <span class="post-comments-page" id="bloggerCommentPageNo">{{pageno}}</span>/<span class="post-comments-pages" id="bloggerTotalCommentPages">{{pages}}</span>)</span>
+  <span class="post-comments-link" id="bloggerEntryCommentsLink">{{comlink}}</span>
+ </h2>
+ </p>
+ <p>
+ <span class="post-comments-container" id="bloggerEntryComment">
+  {{comments}}
+ </span>
+ </p>
+</div>`
+globalThis.POST_DATA = {
+  entry: '',
+  title: '',
+  author: '',
+  label: '',
+  stamp: '',
+  total: 0,
+  pageno: 0,
+  pages: 0,
+  content: '',
+  comments: '',
+  compage: '',
+  comlink: '',
+}
+///////////////////////////////////////////////////////////

package/index.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ exports.hf = require('./htmls.js');

package/loadlib.js ADDED Viewed

@@ -0,0 +1,154 @@
+console.log('Loading libs..');
+const fs = require('fs');
+const path = require('path');
+const hf = require('./htmls.js');
+const pubvar = require('./blogger.pubvar.gd3.js');
+const frmvar = require('./blogger.format.gd3.js');
+const memvar = require('./buasc.js');
+// Enable DOM global objects
+// This may be in conflict with GoogleAPIs
+const jd = require('jsdom-global')();
+// Enable <DOMParser> class
+const {JSDOM} = require('jsdom');
+const jsdom = new JSDOM(`<!DOCTYPE html>`);
+const {window} = jsdom;
+/////////////////////////////////////////////////////////////////////////////
+globalThis.DOMParser = window.DOMParser;
+globalThis.DEF_HIDE_STAMPS = false;
+globalThis.DEF_HIDE_COUNTS = false;
+/////////////////////////////////////////////////////////////////////////////
+globalThis.getArchivePostData = function (domdoc, timezone=7) {
+  let data = {};
+  data.entry = getAttribute(domdoc, {sel: 'id', sid: 'bloggerEntryURL', attr: 'href'});
+  data.title = getAttribute(domdoc, {sel: 'id', sid: 'bloggerEntryTitle'});
+  data.author = getAttribute(domdoc, {sel: 'id', sid: 'bloggerEntryAuthor'});
+  data.label = getAttribute(domdoc, {sel: 'id', sid: 'bloggerEntryLabel'});
+  data.stamp = getAttribute(domdoc, {sel: 'id', sid: 'bloggerEntryGMTDate'});
+  data.total = getAttribute(domdoc, {sel: 'id', sid: 'bloggerEntryTotalComments'}) || 0;
+  data.pages = getAttribute(domdoc, {sel: 'id', sid: 'bloggerTotalCommentPages'}) || 1;
+  data.pageno = getAttribute(domdoc, {sel: 'id', sid: 'bloggerCommentPageNo'}) || 1;
+  data.content = getAttribute(domdoc, {sel: 'id', sid: 'bloggerEntryContent', attr: 'innerHTML'});
+  data.compage = getAttribute(domdoc, {sel: 'id', sid: 'bloggerCommentCountingNotice', attr: 'href'});
+  data.comlink = getAttribute(domdoc, {sel: 'id', sid: 'bloggerEntryCommentsLink', attr: 'innerHTML'});
+  data.stamp = data.stamp || getAttribute(domdoc, {sel: 'id', sid: 'bloggerEntryHanoiDate'}) + `+${timezone}`;
+  data.label = data.label || '&#9730;'; // Umbrella web symbol
+  data.content = removeFontSize(data.content).cleanbrtags();
+  data.comments = ''; // Be filled later
+  return data
+}
+globalThis.getArchiveCommentsData = function (comdiv) {
+  let data = {};
+  data.count = getAttribute(comdiv, {sel: 'tag', sid: 'a', attr: 'name'}).split('.').pop();
+  const id1 = getAttribute(comdiv, {sid: 'comment-header', attr: 'id'});
+  const id2 = getAttribute(comdiv, {sid: 'comment-text', attr: 'id'});
+  data.id = (id1 || id2)?.split('-').pop();
+  data.author = getAttribute(comdiv, {sid: 'comment-authorname'});
+  data.profile = getAttribute(comdiv, {sid: 'comment-authorurl', attr: 'href'});
+  data.profile_id = data.profile ? data.profile.split('/').slice(-1).pop() : '';
+  data.avatar_url = getAttribute(comdiv, {sid: 'comment-avatar', attr: 'src'});
+  data.link = getAttribute(comdiv, {sid: 'comment-authorname', attr: 'href'});
+  data.dated = getAttribute(comdiv, {sid: 'comment-authorname', attr: 'alt'}); // VERY OLD STYLE
+  const stamp1 = getAttribute(comdiv, {sid: 'comment-header', attr: 'timestamp'}); // SINCE 2014
+  const stamp2 = getAttribute(comdiv, {sid: 'comment-authorname', attr: 'timestamp'}); // LATEST
+  data.timestamp = stamp1 || stamp2 || data.dated?.convertTime(); // PICK THIS BEFORE data.dated
+  if (!data.dated) data.dated = getAttribute(comdiv, {sid: 'comment-timestamp'}); // LATEST TIME
+  var reply = getAttribute(comdiv, {sid: 'reply-text', attr: 'innerHTML'});
+  reply = reply ? `\n\n<blockquote>${reply.cleanrepbrtags().cleanrepbrtags()}</blockquote>\n\n` : '';
+  data.content = getAttribute(comdiv, {sid: 'comment-text', attr: 'innerHTML'}).cleanbrtags() + reply;
+  data.content = removeFontSize(data.content).cleanrepptags();
+  data.info = ''; // Be filled later
+  return data
+}
+globalThis.getArchivePageData = function (domdoc, comdivs) {
+  let post = getArchivePostData(domdoc);
+  let coms = [];
+  for (const comdiv of comdivs) {
+    let com = getArchiveCommentsData(comdiv);
+    com.info = showVIP(com.profile, 1, 24, '&nbsp;', 1, com.count, com.id, post.entry);
+    com.content = getStyledComment(com.profile, com.author, com.timestamp, com.content, false);
+    // com.content = com.content.cmt2html();
+    coms.push(com);
+  }
+  post.comments = coms;
+  return post;
+}
+globalThis.convertComments = function (commentObject) {
+  commentObject.avatar = commentObject.avatar_url.convertAvatarUrl();
+  return commentObject.content.generateComment(cloneObject(commentObject));
+}
+String.prototype.convertArchiveData = function (sid='comment-block') {
+  const domdoc = this.domdoc();
+  const comdata = this.pickContent().domdoc();
+  const comdivs = comdata.getElementsByClassName(sid);
+  return getArchivePageData(domdoc, comdivs);
+}
+String.prototype.convertArchiveHtml = function (head=HTML_STYLE) {
+  let data = this.convertArchiveData();
+  if (!data.comlink) data.comlink = '';
+  data.comments = data.comments.map(item => convertComments(item)).join('')+'\n';
+  return data.content.generatePost(cloneObject(data)).generateHtml(head);
+}
+/////////////////////////////////////////////////////////////////////////////
+// Ref. String.prototype.domdoc();
+String.prototype.domdoc2 = function () {
+  return this.window().document;
+}
+// Reserved for old versions
+String.prototype.comdiv = function (profunc='cmt2html') {
+  return this.correctContent(profunc);
+}
+String.prototype.void = function () { return this; }
+String.prototype.jsdom = function () { return new JSDOM(this); }
+String.prototype.window = function () { return this.jsdom().window; }
+String.prototype.getdeid = function (deid) { return this.window().document.getElementById(deid).innerHTML; }
+String.prototype.getisel = function (tag, index=0) { return this.window().document.querySelector(tag)[index].innerHTML; }
+/////////////////////////////////////////////////////////////////////////////
+String.prototype.createFolder = function () {
+  // [this] can be a slash-separated string aka nested folder
+  const folderPath = path.join(process.cwd(), this.toString());
+  try {
+    fs.mkdirSync(folderPath, {recursive: true});
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+String.prototype.generateHtml = function (head=HTML_STYLE, form=HTML_FORM) {
+  return form.parse({head, body: this});
+}
+String.prototype.generateComment = function (objComment={}, form=COMMENT_FORM) {
+  objComment.content = this.toString();
+  return form.parse(objComment);
+}
+String.prototype.generatePost = function (objPost={}, form=POST_FORM) {
+  objPost.content = this.toString();
+  return form.parse(objPost);
+}
+// Global usage:
+// require('./loadlib.js');
+/////////////////////////////////////////////////////////////////////////////

package/package.json ADDED Viewed

@@ -0,0 +1,25 @@
+{
+  "name": "bloggerize",
+  "version": "1.0.0",
+  "description": "Tiny Blogger Archiving Toolkit",
+  "main": "index.js",
+  "dependencies": {
+    "cheerio": "^1.1.2",
+    "googleapis": "^169.0.0",
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "jsdom": "^27.4.0",
+    "jsdom-global": "^3.0.2"
+  },
+  "scripts": {
+    "test": "node test/script.js"
+  },
+  "keywords": [],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/asinerum/bloggerize.git"
+  },
+  "author": "Asinerum Project <https://github.com/asinerum>",
+  "license": "MIT"
+}

package/test/script.js ADDED Viewed

@@ -0,0 +1,23 @@
+/**
+This tiny script creates Google Access Token for you to launch Blogger API tasks.
+You have to do the following steps at Google Cloud Console:
+  1. Create new project, pick it when done, or pick another existing project;
+  2. Enable Blogger API V3 service for the project;
+  3. Go to IAM tab on Project Settings menu. Review all project's users;
+  4. Add new user for the project, pick it, or pick any existing user;
+  5. Create and download Credentials JSON file of the picked user;
+Then do these steps at your home machine:
+  1. Save the downloaded file "credentials.json" in your working folder;
+  2. Run this script. Follow its prompts;
+  3. Wait for the file named "token.json" being created;
+  4. Two files "credentials.json" and "token.json" must be kept safely.
+*/
+const blogger = require('bloggerize/upload');
+blogger.authorizeThru((res) => {
+  if (res) console.log('Done');
+  else { console.log('An error has occured'); }
+});

package/upload.js ADDED Viewed

@@ -0,0 +1,226 @@
+import {} from './blogger.format.gd3.js';
+import { default as fs } from 'fs';
+import * as cheerio from 'cheerio';
+// Google API >< JSDOM conflicts
+import { google } from 'googleapis';
+const TOKEN_PATH = './token.json';
+const APIKEY_PATH = './apikey.json';
+const CREDENTIALS_PATH = './credentials.json';
+const SCOPES = ['https://www.googleapis.com/auth/blogger'];
+export const BLOG_ID = '8254806400148362373';
+export const BLOG_URL = 'https://comment-archive.blogspot.com';
+export async function rlInterface () {
+  const readline = await import('readline');
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false,
+  });
+}
+export function getToken (oAuth2Client, code, {cbf=console.log, token_path=TOKEN_PATH}={}) {
+  oAuth2Client.getToken(code, (err, token) => {
+    if (err) return console.error('Error retrieving access token:', err.message);
+    oAuth2Client.setCredentials(token);
+    fs.writeFileSync(token_path, JSON.stringify(token));
+    console.log('Token stored to:', token_path);
+    cbf(oAuth2Client);
+  });
+}
+// Get new token if none exists
+// Just publish Google Cloud project of the credentials to prevent token expiration
+export async function getNewToken (oAuth2Client, cbf=console.log, {token_path=TOKEN_PATH, scopes=SCOPES}={}) {
+  const authUrl = oAuth2Client.generateAuthUrl({
+    access_type: 'offline',
+    prompt: 'consent',
+    scope: scopes,
+  });
+  console.log('Authorize this app by visiting this URL:\n\n', authUrl, '\n\n');
+  const rl = await rlInterface();
+  rl.question('Enter the code from that page here:\n', function (code) {
+    getToken(oAuth2Client, code.trim(), {cbf, token_path});
+    rl.close();
+  });
+}
+// Google Blogger API must be enabled in Google Cloud project
+// oAuth2 credentials got at https://console.cloud.google.com/apis/dashboard?project=XXX
+export function authorize (token_path=TOKEN_PATH, credentials_path=CREDENTIALS_PATH) {
+  let oAuth2Client;
+  try {
+    const credentials = JSON.parse(fs.readFileSync(credentials_path));
+    const { client_id, client_secret, redirect_uris } = credentials.installed;
+    oAuth2Client = new google.auth.OAuth2(client_id, client_secret, redirect_uris[0]);
+  } catch (err) {
+    console.error('Error loading credentials:', err.message);
+    return [null, null];
+  }
+  try {
+    oAuth2Client.setCredentials(JSON.parse(fs.readFileSync(token_path)));
+    return [oAuth2Client, true];
+  } catch (err) {
+    console.error('Error loading client token:', err.message);
+    return [oAuth2Client, false];
+  }
+}
+export async function authorizeThru (cbf=console.log, {token_path=TOKEN_PATH, credentials_path=CREDENTIALS_PATH}={}) {
+  const [oAuth2Client, tokenpass] = authorize(token_path, credentials_path);
+  if (!oAuth2Client) return cbf(null);
+  if (!tokenpass) return await getNewToken(oAuth2Client, cbf, {token_path});
+  cbf(oAuth2Client);
+}
+// Delete Blogger posts in a date range
+// start_date/end_date format: YYYY-MM-DD
+export async function deletePosts (start_date, end_date, {blog_id=BLOG_ID, maxResults=500}={}) {
+  const [auth, tokenpass] = authorize();
+  if (!auth || !tokenpass) {
+    return console.log('Failed to get client credentials');
+  }
+  const blogger = google.blogger({ version: 'v3', auth });
+  try {
+    const blogRes = await blogger.blogs.get({ blogId: blog_id });
+    const blogId = blogRes.data.id;
+    console.log('Blog ID resolved:', blogId);
+    const postsRes = await blogger.posts.list({
+      blogId,
+      maxResults,
+      startDate: start_date,
+      endDate: end_date,
+      orderBy: 'published',
+      fetchBodies: false
+    });
+    const posts = postsRes.data.items || [];
+    console.log(`Found ${posts.length} posts`);
+    const postsToDelete = posts; // May use filter()
+    console.log(`Deleting ${postsToDelete.length} posts..`);
+    for (const post of postsToDelete) {
+      await blogger.posts.delete({ blogId, postId: post.id });
+      console.log(`Deleted post: ${post.title} (${post.id})`);
+    }
+    console.log('Done');
+  } catch (err) {
+    console.error('Error:', err.message);
+  }
+}
+// Post HTML file content to Blogger
+export async function insertPosts (files, draft=false, blog_id=BLOG_ID, blog_url=BLOG_URL) {
+  const [auth, tokenpass] = authorize();
+  if (!auth || !tokenpass) {
+    return console.log('Failed to get client credentials');
+  }
+  const blogger = google.blogger({ version: 'v3', auth });
+  for (const file of files) {
+    let text, head;
+    try {
+      const content = fs.readFileSync(file, 'utf8');
+      [head, text] = await domGetArchivePostData(content);
+    } catch (err) {
+      console.error('File Error:', err.message);
+      continue;
+    }
+    const postData = text.bloggerPostData(
+      blog_id,
+      head.title,
+      { tid: ':P', page: head.pageno, labels: [head.label], dated: head.stamp.slice(0, 10) }
+    );
+    // (await postNotExist2(postData.published, postData.title, blog_url))
+    if (await postNotExist(postData.published, postData.title, blog_id)) {
+      blogger.posts.insert({
+        blogId: blog_id,
+        requestBody: postData,
+        isDraft: draft,
+      }, (err, res) => {
+        if (err) {
+          console.error('File:', file);
+          console.error('Post:', postData.title);
+          console.error('API Error:', err.message);
+          return;
+        }
+        console.log('Published:', res.data.url);
+      });
+    } else {
+      console.log('Ignored existing post:', postData.title);
+    }
+  }
+}
+export async function domGetArchivePostData (html, timezone=7, labicon='&#9730;') {
+  const text = html.pickContent('<body>', '</body>', false);
+  // const cheerio = await import('cheerio');
+  const $ = cheerio.load(text);
+  const head = {};
+  head.title = $('#bloggerEntryTitle').first().text().trim();
+  head.label = $('#bloggerEntryLabel').first().text().trim();
+  head.stamp = $('#bloggerEntryGMTDate').first().text().trim();
+  head.stampHn = $('#bloggerEntryHanoiDate').first().text().trim();
+  head.pageno = $('#bloggerCommentPageNo').first().text().trim();
+  head.stamp = head.stamp || head.stampHn + `+${timezone}`;
+  head.label = head.label || labicon;
+  return [head, text];
+}
+// Get posts between date range using GoogleAPIs with API Key
+// This is not the same function as the one at <download.getPosts>
+export async function getPosts (fromdate, {todate=null, url=BLOG_URL, blog=BLOG_ID, apikey_path=APIKEY_PATH}={}) {
+  todate = (todate||fromdate).convertDate() + 'T23:59:59Z';
+  fromdate = fromdate.convertDate() + 'T00:00:00Z';
+  const apikey = JSON.parse(fs.readFileSync(apikey_path)).key;
+  const feedUrl = `https://www.googleapis.com/blogger/v3/blogs/${blog}/posts?maxResults=500&startDate=${fromdate}&endDate=${todate}&key=${apikey}`;
+  const data = await loadJson(feedUrl);
+  const entries = data.items || [];
+  const posts = [];
+  for (const entry of entries) {
+    posts.push({
+      id: entry.id,
+      title: entry.title,
+      label: entry.labels?.at(0) || '',
+      entry: entry.url,
+      stamp: entry.published,
+      author: entry.author?.displayName,
+      summary: '', // Can be filled later
+      total: entry.replies?.totalItems,
+      pages: 0,
+      pageno: 0,
+      comments: [],
+      compage: '',
+      comlink: '',
+      content: entry.content,
+    });
+  }
+  return posts;
+}
+// Check posts title using GoogleAPIs with API Key
+export async function postNotExist (dated, title, blog=BLOG_ID, apikey_path=APIKEY_PATH) {
+  dated = dated.slice(0, 10);
+  const fromdate = dated + 'T00:00:00Z';
+  const todate = dated + 'T23:59:59Z';
+  const apikey = JSON.parse(fs.readFileSync(apikey_path)).key;
+  const feedUrl = `https://www.googleapis.com/blogger/v3/blogs/${blog}/posts?maxResults=50&startDate=${fromdate}&endDate=${todate}&key=${apikey}`;
+  const data = await loadJson(feedUrl);
+  const entries = data.items || [];
+  for (const entry of entries) if (entry.title == title) return false;
+  return true;
+}
+// Check posts title using Blogger Atom with no API Key
+export async function postNotExist2 (dated, title, url=BLOG_URL) {
+  dated = dated.slice(0, 10);
+  const fromdate = dated + 'T00:00:00Z';
+  const todate = dated + 'T23:59:59Z';
+  const feedUrl = `${url}/feeds/posts/summary?alt=json&redirect=false&max-results=200&published-min=${fromdate}&published-max=${todate}`;
+  const data = await loadJson(feedUrl);
+  const entries = data?.feed?.entry;
+  if (Array.isArray(entries)) for (const entry of entries) if (entry.title?.$t == title) return false;
+  return true;
+}