[Share] Create Markdown file by template

[cs123951]

Description

Since mdnotes is unavailable in zotero 7, I write a simple script to create a markdown file using template.
template.md can be like:

year:: {{year}}
title:: {{title}}
doi:: {{DOI}}
localLink:: {{localLink}}
publication:: {{publicationTitle}} {{proceedingsTitle}}
authors::  {{author}}
tags::

• Need betterbibtex plugin.
• Only tested on macOS, zotero 7.
• Implemented functions: create markdown file in local system using template file.
• unimplemented functions: link markdown file with zotero item.

Event

None

Operation

Script

Data

/**
 * Creates Markdown file by template.
 * @author cs123951
 * @usage 
 * @link https://github.com/windingwind/zotero-actions-tags/discussions/
 * @see https://github.com/windingwind/zotero-actions-tags/discussions/
 */


var { FilePicker } = ChromeUtils.importESModule('chrome://zotero/content/modules/filePicker.mjs');
const window = require("window");

const typemap = {
  artwork: "Illustration",
  audioRecording: "Recording",
  bill: "Legislation",
  blogPost: "Blog post",
  book: "Book",
  bookSection: "Chapter",
  case: "Legal case",
  computerProgram: "Data",
  conferencePaper: "Conference paper",
  email: "Letter",
  encyclopediaArticle: "Encyclopaedia article",
  film: "Film",
  forumPost: "Forum post",
  hearing: "Hearing",
  instantMessage: "Instant message",
  interview: "Interview",
  journalArticle: "Article",
  letter: "Letter",
  magazineArticle: "Magazine article",
  manuscript: "Manuscript",
  map: "Image",
  newspaperArticle: "Newspaper article",
  patent: "Patent",
  podcast: "Podcast",
  presentation: "Presentation",
  radioBroadcast: "Radio broadcast",
  report: "Report",
  statute: "Legislation",
  thesis: "Thesis",
  tvBroadcast: "TV broadcast",
  videoRecording: "Recording",
  webpage: "Webpage",
};

function getCreatorArray(item, creatorType) {
  var creators = item.getCreators();
  var creatorTypeID = Zotero.CreatorTypes.getID(creatorType);
  var creatorArray = [];

  if (creators) {
    for (let creator of creators) {
      if (creator.creatorTypeID === creatorTypeID) {
        let firstName = creator.firstName.replace(/[^a-zA-Z]/g, "");
        let lastName = creator.lastName.replace(/[^a-zA-Z]/g, "");
        // Set author as tags so that we can conclude.
        let creatorName = ` #${firstName}_${lastName} `;
        creatorArray.push(creatorName);
      }
    }
  }
  return creatorArray;
}

function getPublication(item) {
  let publication = item.getField("publicationTitle");
  if (publication) {
      let pubTag = publication.replace(/[^a-zA-Z]/g, "_")
    return ` #${pubTag} `;
  } else {
    return publication;
  }
}

function getDOI(item) {
  let doi = item.getField("DOI");
  if (doi) {
    return `https://doi.org/${doi}`;
  } else {
    return doi;
  }
}

function getTitle(item) {
  let title = item.getField("title");
  return title;
}

function getYear(item){
	let date = item.getField("date");
	let year = ""
	if (date){
		if (date.includes('\/')){
			// 10/2012
			year = date.slice(3,7);
		} else if (date.includes('-')){
			// 2012-10-09
			year = date.slice(0,4);
		}
	}
	
	return year;
}

function getCiteKey(item) {
  if (typeof Zotero.BetterBibTeX === "object" && Zotero.BetterBibTeX !== null) {
    var bbtItem = Zotero.BetterBibTeX.KeyManager.get(item.getField("id"));
    return bbtItem.citationKey;  // Modified!
  }

  return "undefined";
}

function getCollectionNames(item) {
  const collectionArray = [];
  var collections = item.getCollections();

  for (let collectionID of collections) {
    var collection = Zotero.Collections.get(collectionID);
    collectionArray.push(collection.name);
  }

  return collectionArray;
}

function getLocalZoteroLink(item) {
  let linksString = "zotero://select/items/";
  linksString += `${item.key}`;

  return linksString;
}

function getItemMetadata(item) {
    
  let metadata = {};
  let fields = Zotero.ItemFields.getItemTypeFields(item.getField("itemTypeID"));
  var zoteroType = Zotero.ItemTypes.getName(item.getField("itemTypeID"));
  let creatorTypes = Zotero.Utilities.getCreatorsForType(zoteroType);

  
  for (let creatorType of creatorTypes) {
    let creatorArray = getCreatorArray(item, creatorType);
    metadata[creatorType] = creatorArray;
  }
    
  for (let x of fields) {
    let field = Zotero.ItemFields.getName(x);
    let content = item.getField(field, false, true);
	
    if (field === "DOI") {
      content = getDOI(item);
    } else if(field == "title"){
		content = getTitle(item);
	}else if(field == "publicationTitle"){
		content = getPublication(item);
	}
    metadata[field] = content;
  }

  metadata.year = getYear(item);
  metadata.localLink = getLocalZoteroLink(item);
  metadata.itemType = typemap[zoteroType];
  metadata.citekey = getCiteKey(item);
  return metadata;
}

function replace_placeholders(str, args) {
  return str.replace(/{{(\w+)}}/g, (match, name) =>
    args[name] ? args[name] : ""
  );
}

async function getMDNoteFileContents(item, templatesPath) {
	let template;
	template = await Zotero.File.getContentsAsync(templatesPath);
	
	let itemMetadata = getItemMetadata(item);

	// Fill template.
	let formattedTemplate = replace_placeholders(template, itemMetadata);
	return formattedTemplate;
}

async function createNoteFileMenu(templatesPath, outputFileFolder){
	// Get selected items.
	var ZoteroPane = Zotero.getActiveZoteroPane();
	var items = ZoteroPane.getSelectedItems().filter(
          (item) =>
            Zotero.ItemTypes.getName(item.itemTypeID) !== "attachment" &&
            Zotero.ItemTypes.getName(item.itemTypeID) !== "note"
        );
    await Zotero.Schema.schemaUpdatePromise;
	
    const fp = new FilePicker();
    fp.displayDirectory = outputFileFolder;
    
	// items and item exist.
    for (const item of items) {
		// var itemID = item.id;
		// ZoteroPane.addAttachmentFromDialog(false, itemID);
		
    	fp.init(window, "Save markdown note...", fp.modeSave);
    	fp.appendFilter("Markdown", "*.md");
    
    	let citekey = getCiteKey(item);
    	fp.defaultString = `${citekey}.md`;
        
    	const rv = await fp.show();
        
    	if (rv == fp.returnOK || rv == fp.returnReplace){
    		let outputFile = fp.file;
    		if (outputFile.split(".").pop().toLowerCase() != "md") {
    				outputFile += ".md";
    			}

    		let contents = await getMDNoteFileContents(item, templatesPath);
    		
    		if ( rv == fp.returnReplace ){
    			const oldContents = await Zotero.File.getContentsAsync(outputFile);
    			contents = `${contents}${oldContents}`;

    		}
    		Zotero.File.putContentsAsync(outputFile, contents);
    	}
        
    }
	return `Markdown notes have been created for the selected item.`;

}

// =====Start======
// Read template.
var outputFileFolder = '/path_to_save_file/';
var templatesPath = '/path_to_read_template/template.md';

// When select a field, items and item are created. 

// This is to avoid duplicate operations
// When selecting multiple items in the library, the action will be triggered once for all items 
// (items=[...], item=undefined) and then one by one for each item (items=[], item=...). 
// You can use the items variable to get the selected items array and avoid duplicate executions.
// See https://github.com/windingwind/zotero-actions-tags/discussions/292
// we choose to use the first case: (items=[...], item=undefined).

if (items?.length > 0) {
	return createNoteFileMenu(templatesPath, outputFileFolder);
}

Anything else

Reference:
[1] https://github.com/argenos/zotero-mdnotes/blob/master/content/mdnotes.js