hedgedoc/old_src/lib/models/note.ts

import async from 'async'
import base64url from 'base64url'
import cheerio from 'cheerio'
// eslint-disable-next-line @typescript-eslint/camelcase
import { diff_match_patch, patch_obj } from 'diff-match-patch'
import fs from 'fs'
import LZString from 'lz-string'
import markdownIt from 'markdown-it'
import metaMarked from 'meta-marked'
import moment from 'moment'
import path from 'path'
import Sequelize from 'sequelize'
import {
  AfterCreate,
  AllowNull,
  BeforeCreate,
  BelongsTo,
  Column,
  DataType,
  Default,
  ForeignKey,
  HasMany,
  Model,
  PrimaryKey,
  Table,
  Unique
} from 'sequelize-typescript'

import { generate as shortIdGenerate, isValid as shortIdIsValid } from 'shortid'
import S from 'string'
import { config } from '../config'
import { logger } from '../logger'
import ot from '../ot/index'
import { processData, stripNullByte } from '../utils/functions'
import { Author, Revision, User } from './index'

const md = markdownIt()
// eslint-disable-next-line new-cap
const dmp = new diff_match_patch()

// permission types
enum PermissionEnum {
  freely = 'freely',
  editable = 'editable',
  limited = 'limited',
  locked = 'locked',
  protected = 'protected',
  private = 'private'
}

export class OpengraphMetadata {
  title: string | number
  description: string | number
  type: string
}

export class NoteMetadata {
  title: string
  description: string
  robots: string
  GA: string
  disqus: string
  slideOptions
  opengraph: OpengraphMetadata
}

export type NoteAuthorship = [string, number, number, number, number]

@Table({ paranoid: false })
export class Note extends Model<Note> {
  @PrimaryKey
  @Default(Sequelize.UUIDV4)
  @Column(DataType.UUID)
  id: string

  @AllowNull(false)
  @Default(shortIdGenerate)
  @Unique
  @Column(DataType.STRING)
  shortid: string

  @Unique
  @Column(DataType.STRING)
  alias: string

  @Column(DataType.ENUM({ values: Object.keys(PermissionEnum).map(k => PermissionEnum[k]) }))
  permission: PermissionEnum

  @AllowNull(false)
  @Default(0)
  @Column(DataType.INTEGER)
  viewcount: number

  // ToDo: use @UpdatedAt instead? (https://www.npmjs.com/package/sequelize-typescript#createdat--updatedat--deletedat)
  @Column(DataType.DATE)
  lastchangeAt: Date

  // ToDo: use @UpdatedAt instead? (https://www.npmjs.com/package/sequelize-typescript#createdat--updatedat--deletedat)
  @Column(DataType.DATE)
  savedAt: Date

  @ForeignKey(() => User)
  @Column
  ownerId: string

  @BelongsTo(() => User, { foreignKey: 'ownerId', constraints: false, onDelete: 'CASCADE', hooks: true })
  owner: User

  @ForeignKey(() => User)
  @Column
  lastchangeuserId: string

  @BelongsTo(() => User, { foreignKey: 'lastchangeuserId', constraints: false })
  lastchangeuser: User

  @HasMany(() => Revision, { foreignKey: 'noteId', constraints: false })
  revisions: Revision[]

  @HasMany(() => Author, { foreignKey: 'noteId', constraints: false })
  authors: Author[]

  @Column(DataType.TEXT)
  get title (): string {
    return this.getDataValue('title') ?? ''
  }

  set title (value: string) {
    this.setDataValue('title', stripNullByte(value))
  }

  @Column(DataType.TEXT({ length: 'long' }))
  get content (): string {
    return this.getDataValue('content') ?? ''
  }

  set content (value: string) {
    this.setDataValue('content', stripNullByte(value))
  }

  @Column(DataType.TEXT({ length: 'long' }))
  get authorship (): NoteAuthorship[] {
    return processData(this.getDataValue('authorship'), [], JSON.parse)
  }

  set authorship (value: NoteAuthorship[]) {
    // Evil hack for TypeScript to accept saving a string in a NoteAuthorship DB-field
    this.setDataValue('authorship', JSON.stringify(value) as unknown as NoteAuthorship[])
  }

  @BeforeCreate
  static async defaultContentAndPermissions (note: Note): Promise<Note> {
    return await new Promise(function (resolve) {
      // if no content specified then use default note
      if (!note.content) {
        let filePath: string
        if (!note.alias) {
          filePath = config.defaultNotePath
        } else {
          filePath = path.join(config.docsPath, note.alias + '.md')
        }
        if (Note.checkFileExist(filePath)) {
          const fsCreatedTime = moment(fs.statSync(filePath).ctime)
          const body = fs.readFileSync(filePath, 'utf8')
          note.title = Note.parseNoteTitle(body)
          note.content = body
          if (filePath !== config.defaultNotePath) {
            note.createdAt = fsCreatedTime
          }
        }
      }
      // if no permission specified and have owner then give default permission in config, else default permission is freely
      if (!note.permission) {
        if (note.ownerId) {
          // TODO: Might explode if the user-defined permission does not exist
          note.permission = PermissionEnum[config.defaultPermission]
        } else {
          note.permission = PermissionEnum.freely
        }
      }
      return resolve(note)
    })
  }

  @AfterCreate
  static saveRevision (note): Promise<Note> {
    return new Promise(function (resolve, reject) {
      Revision.saveNoteRevision(note, function (err, _) {
        if (err) {
          return reject(err)
        }
        return resolve(note)
      })
    })
  }

  static checkFileExist (filePath): boolean {
    try {
      return fs.statSync(filePath).isFile()
    } catch (err) {
      return false
    }
  }

  static encodeNoteId (id): string {
    // remove dashes in UUID and encode in url-safe base64
    const str = id.replace(/-/g, '')
    const hexStr = Buffer.from(str, 'hex')
    return base64url.encode(hexStr)
  }

  static decodeNoteId (encodedId): string {
    // decode from url-safe base64
    const id: string = base64url.toBuffer(encodedId).toString('hex')
    // add dashes between the UUID string parts
    const idParts: string[] = []
    idParts.push(id.substr(0, 8))
    idParts.push(id.substr(8, 4))
    idParts.push(id.substr(12, 4))
    idParts.push(id.substr(16, 4))
    idParts.push(id.substr(20, 12))
    return idParts.join('-')
  }

  static checkNoteIdValid (id): boolean {
    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
    const result = id.match(uuidRegex)
    return !!(result && result.length === 1)
  }

  static parseNoteId (noteId, callback): void {
    async.series({
      parseNoteIdByAlias: function (_callback) {
        // try to parse note id by alias (e.g. doc)
        Note.findOne({
          where: {
            alias: noteId
          }
        }).then(function (note) {
          if (note) {
            const filePath = path.join(config.docsPath, noteId + '.md')
            if (Note.checkFileExist(filePath)) {
              // if doc in filesystem have newer modified time than last change time
              // then will update the doc in db
              const fsModifiedTime = moment(fs.statSync(filePath).mtime)
              const dbModifiedTime = moment(note.lastchangeAt || note.createdAt)
              const body = fs.readFileSync(filePath, 'utf8')
              const contentLength = body.length
              const title = Note.parseNoteTitle(body)
              if (fsModifiedTime.isAfter(dbModifiedTime) && note.content !== body) {
                note.update({
                  title: title,
                  content: body,
                  lastchangeAt: fsModifiedTime
                }).then(function (note) {
                  Revision.saveNoteRevision(note, function (err, revision) {
                    if (err) return _callback(err, null)
                    // update authorship on after making revision of docs
                    const patch = dmp.patch_fromText(revision.patch)
                    const operations = Note.transformPatchToOperations(patch, contentLength)
                    let authorship = note.authorship
                    for (let i = 0; i < operations.length; i++) {
                      authorship = Note.updateAuthorshipByOperation(operations[i], null, authorship)
                    }
                    note.update({
                      authorship: authorship
                    }).then(function (note) {
                      return callback(null, note.id)
                    }).catch(function (err) {
                      return _callback(err, null)
                    })
                  })
                }).catch(function (err) {
                  return _callback(err, null)
                })
              } else {
                return callback(null, note.id)
              }
            } else {
              return callback(null, note.id)
            }
          } else {
            const filePath = path.join(config.docsPath, noteId + '.md')
            if (Note.checkFileExist(filePath)) {
              Note.create({
                alias: noteId,
                owner: null,
                permission: 'locked'
              }).then(function (note) {
                return callback(null, note.id)
              }).catch(function (err) {
                return _callback(err, null)
              })
            } else {
              return _callback(null, null)
            }
          }
        }).catch(function (err) {
          return _callback(err, null)
        })
      },
      // parse note id by LZString is deprecated, here for compability
      parseNoteIdByLZString: function (_callback) {
        // Calculate minimal string length for an UUID that is encoded
        // base64 encoded and optimize comparsion by using -1
        // this should make a lot of LZ-String parsing errors obsolete
        // as we can assume that a nodeId that is 48 chars or longer is a
        // noteID.
        const base64UuidLength = ((4 * 36) / 3) - 1
        if (!(noteId.length > base64UuidLength)) {
          return _callback(null, null)
        }
        // try to parse note id by LZString Base64
        try {
          const id = LZString.decompressFromBase64(noteId)
          if (id && Note.checkNoteIdValid(id)) {
            return callback(null, id)
          } else {
            return _callback(null, null)
          }
        } catch (err) {
          if (err.message === 'Cannot read property \'charAt\' of undefined') {
            logger.warning('Looks like we can not decode "' + noteId + '" with LZString. Can be ignored.')
          } else {
            logger.error(err)
          }
          return _callback(null, null)
        }
      },
      parseNoteIdByBase64Url: function (_callback) {
        // try to parse note id by base64url
        try {
          const id = Note.decodeNoteId(noteId)
          if (id && Note.checkNoteIdValid(id)) {
            return callback(null, id)
          } else {
            return _callback(null, null)
          }
        } catch (err) {
          logger.error(err)
          return _callback(null, null)
        }
      },
      parseNoteIdByShortId: function (_callback) {
        // try to parse note id by shortId
        try {
          if (shortIdIsValid(noteId)) {
            Note.findOne({
              where: {
                shortid: noteId
              }
            }).then(function (note) {
              if (!note) return _callback(null, null)
              return callback(null, note.id)
            }).catch(function (err) {
              return _callback(err, null)
            })
          } else {
            return _callback(null, null)
          }
        } catch (err) {
          return _callback(err, null)
        }
      }
    }, function (err, _) {
      if (err) {
        logger.error(err)
        return callback(err, null)
      }
      return callback(null, null)
    })
  }

  static parseNoteTitle (body): string {
    const parsed = Note.extractMeta(body)
    const $ = cheerio.load(md.render(parsed.markdown))
    return Note.extractNoteTitle(parsed.meta, $)
  }

  static extractNoteTitle (meta, $): string {
    let title = ''
    if (meta.title && (typeof meta.title === 'string' || typeof meta.title === 'number')) {
      title = meta.title
    } else {
      const h1s = $('h1')
      if (h1s.length > 0 && h1s.first().text().split('\n').length === 1) {
        title = S(h1s.first().text()).stripTags().s
      }
    }
    if (!title) title = 'Untitled'
    return title
  }

  static generateDescription (markdown): string {
    return markdown.substr(0, 100).replace(/(?:\r\n|\r|\n)/g, ' ')
  }

  static decodeTitle (title): string {
    return title || 'Untitled'
  }

  static generateWebTitle (title): string {
    title = !title || title === 'Untitled' ? 'CodiMD - Collaborative markdown notes' : title + ' - CodiMD'
    return title
  }

  static extractNoteTags (meta, $): string[] {
    const tags: string[] = []
    const rawtags: string[] = []
    if (meta.tags && (typeof meta.tags === 'string' || typeof meta.tags === 'number')) {
      const metaTags = ('' + meta.tags).split(',')
      for (let i = 0; i < metaTags.length; i++) {
        const text: string = metaTags[i].trim()
        if (text) rawtags.push(text)
      }
    } else {
      const h6s = $('h6')
      h6s.each(function (key, value) {
        if (/^tags/gmi.test($(value).text())) {
          const codes = $(value).find('code')
          for (let i = 0; i < codes.length; i++) {
            const text = S($(codes[i]).text().trim()).stripTags().s
            if (text) rawtags.push(text)
          }
        }
      })
    }
    for (let i = 0; i < rawtags.length; i++) {
      let found = false
      for (let j = 0; j < tags.length; j++) {
        if (tags[j] === rawtags[i]) {
          found = true
          break
        }
      }
      if (!found) {
        tags.push(rawtags[i])
      }
    }
    return tags
  }

  static extractMeta (content): { markdown: string; meta: {} } {
    try {
      const obj = metaMarked(content)
      if (!obj.markdown) obj.markdown = ''
      if (!obj.meta) obj.meta = {}
      return obj
    } catch (err) {
      return {
        markdown: content,
        meta: {}
      }
    }
  }

  static parseMeta (meta): NoteMetadata {
    const _meta = new NoteMetadata()
    if (meta) {
      if (meta.title && (typeof meta.title === 'string' || typeof meta.title === 'number')) {
        _meta.title = meta.title
      }
      if (meta.description && (typeof meta.description === 'string' || typeof meta.description === 'number')) {
        _meta.description = meta.description
      }
      if (meta.robots && (typeof meta.robots === 'string' || typeof meta.robots === 'number')) {
        _meta.robots = meta.robots
      }
      if (meta.GA && (typeof meta.GA === 'string' || typeof meta.GA === 'number')) {
        _meta.GA = meta.GA
      }
      if (meta.disqus && (typeof meta.disqus === 'string' || typeof meta.disqus === 'number')) {
        _meta.disqus = meta.disqus
      }
      if (meta.slideOptions && (typeof meta.slideOptions === 'object')) {
        _meta.slideOptions = meta.slideOptions
      }
      if (meta.opengraph && (typeof meta.opengraph === 'object')) {
        _meta.opengraph = meta.opengraph
      }
    }
    return _meta
  }

  static parseOpengraph (meta, title: string): OpengraphMetadata {
    let _ogdata = new OpengraphMetadata()
    if (meta.opengraph) {
      _ogdata = meta.opengraph
    }
    if (!(_ogdata.title && (typeof _ogdata.title === 'string' || typeof _ogdata.title === 'number'))) {
      _ogdata.title = title
    }
    if (!(_ogdata.description && (typeof _ogdata.description === 'string' || typeof _ogdata.description === 'number'))) {
      _ogdata.description = meta.description || ''
    }
    if (!(_ogdata.type && (typeof _ogdata.type === 'string'))) {
      _ogdata.type = 'website'
    }
    return _ogdata
  }

  static updateAuthorshipByOperation (operation, userId: string | null, authorships): NoteAuthorship[] {
    let index = 0
    const timestamp = Date.now()
    for (let i = 0; i < operation.length; i++) {
      const op = operation[i]
      if (ot.TextOperation.isRetain(op)) {
        index += op
      } else if (ot.TextOperation.isInsert(op)) {
        const opStart = index
        const opEnd = index + op.length
        let inserted = false
        // authorship format: [userId, startPos, endPos, createdAt, updatedAt]
        if (authorships.length <= 0) authorships.push([userId, opStart, opEnd, timestamp, timestamp])
        else {
          for (let j = 0; j < authorships.length; j++) {
            const authorship = authorships[j]
            if (!inserted) {
              const nextAuthorship = authorships[j + 1] || -1
              if ((nextAuthorship !== -1 && nextAuthorship[1] >= opEnd) || j >= authorships.length - 1) {
                if (authorship[1] < opStart && authorship[2] > opStart) {
                  // divide
                  const postLength = authorship[2] - opStart
                  authorship[2] = opStart
                  authorship[4] = timestamp
                  authorships.splice(j + 1, 0, [userId, opStart, opEnd, timestamp, timestamp])
                  authorships.splice(j + 2, 0, [authorship[0], opEnd, opEnd + postLength, authorship[3], timestamp])
                  j += 2
                  inserted = true
                } else if (authorship[1] >= opStart) {
                  authorships.splice(j, 0, [userId, opStart, opEnd, timestamp, timestamp])
                  j += 1
                  inserted = true
                } else if (authorship[2] <= opStart) {
                  authorships.splice(j + 1, 0, [userId, opStart, opEnd, timestamp, timestamp])
                  j += 1
                  inserted = true
                }
              }
            }
            if (authorship[1] >= opStart) {
              authorship[1] += op.length
              authorship[2] += op.length
            }
          }
        }
        index += op.length
      } else if (ot.TextOperation.isDelete(op)) {
        const opStart = index
        const opEnd = index - op
        if (operation.length === 1) {
          authorships = []
        } else if (authorships.length > 0) {
          for (let j = 0; j < authorships.length; j++) {
            const authorship = authorships[j]
            if (authorship[1] >= opStart && authorship[1] <= opEnd && authorship[2] >= opStart && authorship[2] <= opEnd) {
              authorships.splice(j, 1)
              j -= 1
            } else if (authorship[1] < opStart && authorship[1] < opEnd && authorship[2] > opStart && authorship[2] > opEnd) {
              authorship[2] += op
              authorship[4] = timestamp
            } else if (authorship[2] >= opStart && authorship[2] <= opEnd) {
              authorship[2] = opStart
              authorship[4] = timestamp
            } else if (authorship[1] >= opStart && authorship[1] <= opEnd) {
              authorship[1] = opEnd
              authorship[4] = timestamp
            }
            if (authorship[1] >= opEnd) {
              authorship[1] += op
              authorship[2] += op
            }
          }
        }
        index += op
      }
    }
    // merge
    for (let j = 0; j < authorships.length; j++) {
      const authorship = authorships[j]
      for (let k = j + 1; k < authorships.length; k++) {
        const nextAuthorship = authorships[k]
        if (nextAuthorship && authorship[0] === nextAuthorship[0] && authorship[2] === nextAuthorship[1]) {
          const minTimestamp = Math.min(authorship[3], nextAuthorship[3])
          const maxTimestamp = Math.max(authorship[3], nextAuthorship[3])
          authorships.splice(j, 1, [authorship[0], authorship[1], nextAuthorship[2], minTimestamp, maxTimestamp])
          authorships.splice(k, 1)
          j -= 1
          break
        }
      }
    }
    // clear
    for (let j = 0; j < authorships.length; j++) {
      const authorship = authorships[j]
      if (!authorship[0]) {
        authorships.splice(j, 1)
        j -= 1
      }
    }
    return authorships
  }

  // eslint-disable-next-line @typescript-eslint/camelcase
  static transformPatchToOperations (patch: patch_obj[], contentLength): number[][] {
    const operations: number[][] = []
    if (patch.length > 0) {
      // calculate original content length
      for (let j = patch.length - 1; j >= 0; j--) {
        const p = patch[j]
        for (let i = 0; i < p.diffs.length; i++) {
          const diff = p.diffs[i]
          switch (diff[0]) {
            case 1: // insert
              contentLength -= diff[1].length
              break
            case -1: // delete
              contentLength += diff[1].length
              break
          }
        }
      }
      // generate operations
      let bias = 0
      let lengthBias = 0
      for (let j = 0; j < patch.length; j++) {
        const operation: number[] = []
        const p = patch[j]
        let currIndex = p.start1 || 0
        const currLength = contentLength - bias
        for (let i = 0; i < p.diffs.length; i++) {
          const diff = p.diffs[i]
          switch (diff[0]) {
            case 0: // retain
              if (i === 0) {
                // first
                operation.push(currIndex + diff[1].length)
              } else if (i !== p.diffs.length - 1) {
                // mid
                operation.push(diff[1].length)
              } else {
                // last
                operation.push(currLength + lengthBias - currIndex)
              }
              currIndex += diff[1].length
              break
            case 1: // insert
              operation.push(diff[1].length)
              lengthBias += diff[1].length
              currIndex += diff[1].length
              break
            case -1: // delete
              operation.push(-diff[1].length)
              bias += diff[1].length
              currIndex += diff[1].length
              break
          }
        }
        operations.push(operation)
      }
    }
    return operations
  }

  static parseNoteInfo (body): { title: string; tags: string[] } {
    const parsed = Note.extractMeta(body)
    const $ = cheerio.load(md.render(parsed.markdown))
    return {
      title: Note.extractNoteTitle(parsed.meta, $),
      tags: Note.extractNoteTags(parsed.meta, $)
    }
  }
}