mirror of
https://github.com/overleaf/overleaf.git
synced 2024-10-24 21:12:38 -04:00
2ff1cf43d6
Upgrade and configure ESLint GitOrigin-RevId: ad5aeaf85e72c847a125ff3a9db99a12855e38aa
172 lines
5.3 KiB
JavaScript
172 lines
5.3 KiB
JavaScript
/* eslint-disable
|
|
camelcase,
|
|
node/handle-callback-err,
|
|
max-len,
|
|
no-unused-vars,
|
|
*/
|
|
// TODO: This file was created by bulk-decaffeinate.
|
|
// Fix any style issues and re-enable lint.
|
|
/*
|
|
* decaffeinate suggestions:
|
|
* DS102: Remove unnecessary code created because of implicit returns
|
|
* DS103: Rewrite code to no longer use __guard__
|
|
* DS207: Consider shorter variations of null checks
|
|
* Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
|
|
*/
|
|
const { Project } = require('../../models/Project')
|
|
const ProjectDetailsHandler = require('./ProjectDetailsHandler')
|
|
const logger = require('logger-sharelatex')
|
|
const settings = require('settings-sharelatex')
|
|
const HistoryManager = require('../History/HistoryManager')
|
|
const ProjectEntityUpdateHandler = require('./ProjectEntityUpdateHandler')
|
|
const { promisifyAll } = require('../../util/promises')
|
|
|
|
const ProjectHistoryHandler = {
|
|
setHistoryId(project_id, history_id, callback) {
|
|
// reject invalid history ids
|
|
if (callback == null) {
|
|
callback = function(err) {}
|
|
}
|
|
if (!history_id || typeof history_id !== 'number') {
|
|
return callback(new Error('invalid history id'))
|
|
}
|
|
// use $exists:false to prevent overwriting any existing history id, atomically
|
|
return Project.updateOne(
|
|
{ _id: project_id, 'overleaf.history.id': { $exists: false } },
|
|
{ 'overleaf.history.id': history_id },
|
|
function(err, result) {
|
|
if (err != null) {
|
|
return callback(err)
|
|
}
|
|
if ((result != null ? result.n : undefined) === 0) {
|
|
return callback(new Error('history exists'))
|
|
}
|
|
return callback()
|
|
}
|
|
)
|
|
},
|
|
|
|
getHistoryId(project_id, callback) {
|
|
if (callback == null) {
|
|
callback = function(err, result) {}
|
|
}
|
|
return ProjectDetailsHandler.getDetails(project_id, function(err, project) {
|
|
if (err != null) {
|
|
return callback(err)
|
|
} // n.b. getDetails returns an error if the project doesn't exist
|
|
return callback(
|
|
null,
|
|
__guard__(
|
|
__guard__(
|
|
project != null ? project.overleaf : undefined,
|
|
x1 => x1.history
|
|
),
|
|
x => x.id
|
|
)
|
|
)
|
|
})
|
|
},
|
|
|
|
upgradeHistory(project_id, callback) {
|
|
// project must have an overleaf.history.id before allowing display of new history
|
|
if (callback == null) {
|
|
callback = function(err, result) {}
|
|
}
|
|
return Project.updateOne(
|
|
{ _id: project_id, 'overleaf.history.id': { $exists: true } },
|
|
{
|
|
'overleaf.history.display': true,
|
|
'overleaf.history.upgradedAt': new Date()
|
|
},
|
|
function(err, result) {
|
|
if (err != null) {
|
|
return callback(err)
|
|
}
|
|
// return an error if overleaf.history.id wasn't present
|
|
if ((result != null ? result.n : undefined) === 0) {
|
|
return callback(new Error('history not upgraded'))
|
|
}
|
|
return callback()
|
|
}
|
|
)
|
|
},
|
|
|
|
downgradeHistory(project_id, callback) {
|
|
if (callback == null) {
|
|
callback = function(err, result) {}
|
|
}
|
|
return Project.updateOne(
|
|
{ _id: project_id, 'overleaf.history.upgradedAt': { $exists: true } },
|
|
{
|
|
'overleaf.history.display': false,
|
|
$unset: { 'overleaf.history.upgradedAt': 1 }
|
|
},
|
|
function(err, result) {
|
|
if (err != null) {
|
|
return callback(err)
|
|
}
|
|
if ((result != null ? result.n : undefined) === 0) {
|
|
return callback(new Error('history not downgraded'))
|
|
}
|
|
return callback()
|
|
}
|
|
)
|
|
},
|
|
|
|
ensureHistoryExistsForProject(project_id, callback) {
|
|
// We can only set a history id for a project that doesn't have one. The
|
|
// history id is cached in the project history service, and changing an
|
|
// existing value corrupts the history, leaving it in an irrecoverable
|
|
// state. Setting a history id when one wasn't present before is ok,
|
|
// because undefined history ids aren't cached.
|
|
if (callback == null) {
|
|
callback = function(err) {}
|
|
}
|
|
return ProjectHistoryHandler.getHistoryId(project_id, function(
|
|
err,
|
|
history_id
|
|
) {
|
|
if (err != null) {
|
|
return callback(err)
|
|
}
|
|
if (history_id != null) {
|
|
return callback()
|
|
} // history already exists, success
|
|
return HistoryManager.initializeProject(function(err, history) {
|
|
if (err != null) {
|
|
return callback(err)
|
|
}
|
|
if (!(history != null ? history.overleaf_id : undefined)) {
|
|
return callback(new Error('failed to initialize history id'))
|
|
}
|
|
return ProjectHistoryHandler.setHistoryId(
|
|
project_id,
|
|
history.overleaf_id,
|
|
function(err) {
|
|
if (err != null) {
|
|
return callback(err)
|
|
}
|
|
return ProjectEntityUpdateHandler.resyncProjectHistory(
|
|
project_id,
|
|
function(err) {
|
|
if (err != null) {
|
|
return callback(err)
|
|
}
|
|
return HistoryManager.flushProject(project_id, callback)
|
|
}
|
|
)
|
|
}
|
|
)
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
function __guard__(value, transform) {
|
|
return typeof value !== 'undefined' && value !== null
|
|
? transform(value)
|
|
: undefined
|
|
}
|
|
|
|
ProjectHistoryHandler.promises = promisifyAll(ProjectHistoryHandler)
|
|
module.exports = ProjectHistoryHandler
|