github/overleaf
1
0
Fork 0
mirror of https://github.com/overleaf/overleaf.git synced 2024-11-21 20:47:08 -05:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #12219 from overleaf/em-camel-case-web

Browse source 
Camel case variables in web

GitOrigin-RevId: 28e61b759b27f71265f33ab64f588374dba610e0
This commit is contained in:
Eric Mc Sween 2023-03-21 09:21:57 -04:00 committed by Copybot
parent e4efe121da
commit 21971956b7
56 changed files with 685 additions and 742 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
services/web/app/src/Features/Authentication/AuthenticationController.js
View file

@ -624,7 +624,7 @@ function _loginAsyncHandlers(req, user, anonymousAnalyticsId, isNewUser) {
Analytics.identifyUser(user._id, anonymousAnalyticsId, isNewUser)
logger.debug(
{ email: user.email, user_id: user._id.toString() },
{ email: user.email, userId: user._id.toString() },
'successful log in'
)

5
services/web/app/src/Features/BetaProgram/BetaProgramController.js
View file

@ -36,10 +36,7 @@ const BetaProgramController = {
optInPage(req, res, next) {
const userId = SessionManager.getLoggedInUserId(req.session)
logger.debug(
{ user_id: userId },
'showing beta participation page for user'
)
logger.debug({ userId }, 'showing beta participation page for user')
UserGetter.getUser(userId, function (err, user) {
if (err) {
OError.tag(err, 'error fetching user', {

47
services/web/app/src/Features/Chat/ChatApiHandler.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
*/
@ -17,13 +16,13 @@ const request = require('request')
const settings = require('@overleaf/settings')
const { promisify } = require('util')
function getThreads(project_id, callback) {
function getThreads(projectId, callback) {
if (callback == null) {
callback = function () {}
}
return ChatApiHandler._apiRequest(
{
url: `${settings.apis.chat.internal_url}/project/${project_id}/threads`,
url: `${settings.apis.chat.internal_url}/project/${projectId}/threads`,
method: 'GET',
json: true,
},
@ -31,13 +30,13 @@ function getThreads(project_id, callback) {
)
}
function destroyProject(project_id, callback) {
function destroyProject(projectId, callback) {
if (callback == null) {
callback = function () {}
}
return ChatApiHandler._apiRequest(
{
url: `${settings.apis.chat.internal_url}/project/${project_id}`,
url: `${settings.apis.chat.internal_url}/project/${projectId}`,
method: 'DELETE',
},
callback
@ -66,18 +65,18 @@ module.exports = ChatApiHandler = {
})
},
sendGlobalMessage(project_id, user_id, content, callback) {
sendGlobalMessage(projectId, userId, content, callback) {
return ChatApiHandler._apiRequest(
{
url: `${settings.apis.chat.internal_url}/project/${project_id}/messages`,
url: `${settings.apis.chat.internal_url}/project/${projectId}/messages`,
method: 'POST',
json: { user_id, content },
json: { user_id: userId, content },
},
callback
)
},
getGlobalMessages(project_id, limit, before, callback) {
getGlobalMessages(projectId, limit, before, callback) {
const qs = {}
if (limit != null) {
qs.limit = limit
@ -88,7 +87,7 @@ module.exports = ChatApiHandler = {
return ChatApiHandler._apiRequest(
{
url: `${settings.apis.chat.internal_url}/project/${project_id}/messages`,
url: `${settings.apis.chat.internal_url}/project/${projectId}/messages`,
method: 'GET',
qs,
json: true,
@ -97,67 +96,67 @@ module.exports = ChatApiHandler = {
)
},
sendComment(project_id, thread_id, user_id, content, callback) {
sendComment(projectId, threadId, userId, content, callback) {
if (callback == null) {
callback = function () {}
}
return ChatApiHandler._apiRequest(
{
url: `${settings.apis.chat.internal_url}/project/${project_id}/thread/${thread_id}/messages`,
url: `${settings.apis.chat.internal_url}/project/${projectId}/thread/${threadId}/messages`,
method: 'POST',
json: { user_id, content },
json: { user_id: userId, content },
},
callback
)
},
resolveThread(project_id, thread_id, user_id, callback) {
resolveThread(projectId, threadId, userId, callback) {
if (callback == null) {
callback = function () {}
}
return ChatApiHandler._apiRequest(
{
url: `${settings.apis.chat.internal_url}/project/${project_id}/thread/${thread_id}/resolve`,
url: `${settings.apis.chat.internal_url}/project/${projectId}/thread/${threadId}/resolve`,
method: 'POST',
json: { user_id },
json: { user_id: userId },
},
callback
)
},
reopenThread(project_id, thread_id, callback) {
reopenThread(projectId, threadId, callback) {
if (callback == null) {
callback = function () {}
}
return ChatApiHandler._apiRequest(
{
url: `${settings.apis.chat.internal_url}/project/${project_id}/thread/${thread_id}/reopen`,
url: `${settings.apis.chat.internal_url}/project/${projectId}/thread/${threadId}/reopen`,
method: 'POST',
},
callback
)
},
deleteThread(project_id, thread_id, callback) {
deleteThread(projectId, threadId, callback) {
if (callback == null) {
callback = function () {}
}
return ChatApiHandler._apiRequest(
{
url: `${settings.apis.chat.internal_url}/project/${project_id}/thread/${thread_id}`,
url: `${settings.apis.chat.internal_url}/project/${projectId}/thread/${threadId}`,
method: 'DELETE',
},
callback
)
},
editMessage(project_id, thread_id, message_id, userId, content, callback) {
editMessage(projectId, threadId, messageId, userId, content, callback) {
if (callback == null) {
callback = function () {}
}
return ChatApiHandler._apiRequest(
{
url: `${settings.apis.chat.internal_url}/project/${project_id}/thread/${thread_id}/messages/${message_id}/edit`,
url: `${settings.apis.chat.internal_url}/project/${projectId}/thread/${threadId}/messages/${messageId}/edit`,
method: 'POST',
json: {
content,
@ -168,13 +167,13 @@ module.exports = ChatApiHandler = {
)
},
deleteMessage(project_id, thread_id, message_id, callback) {
deleteMessage(projectId, threadId, messageId, callback) {
if (callback == null) {
callback = function () {}
}
return ChatApiHandler._apiRequest(
{
url: `${settings.apis.chat.internal_url}/project/${project_id}/thread/${thread_id}/messages/${message_id}`,
url: `${settings.apis.chat.internal_url}/project/${projectId}/thread/${threadId}/messages/${messageId}`,
method: 'DELETE',
},
callback

49
services/web/app/src/Features/Chat/ChatController.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
no-unused-vars,
@ -23,16 +22,16 @@ const async = require('async')
module.exports = ChatController = {
sendMessage(req, res, next) {
const { project_id } = req.params
const { content, client_id } = req.body
const user_id = SessionManager.getLoggedInUserId(req.session)
if (user_id == null) {
const { project_id: projectId } = req.params
const { content, client_id: clientId } = req.body
const userId = SessionManager.getLoggedInUserId(req.session)
if (userId == null) {
const err = new Error('no logged-in user')
return next(err)
}
return ChatApiHandler.sendGlobalMessage(
project_id,
user_id,
projectId,
userId,
content,
function (err, message) {
if (err != null) {
@ -45,9 +44,9 @@ module.exports = ChatController = {
return next(err)
}
message.user = UserInfoController.formatPersonalInfo(user)
message.clientId = client_id
message.clientId = clientId
EditorRealTimeController.emitToRoom(
project_id,
projectId,
'new-chat-message',
message
)
@ -59,10 +58,10 @@ module.exports = ChatController = {
},
getMessages(req, res, next) {
const { project_id } = req.params
const { project_id: projectId } = req.params
const { query } = req
return ChatApiHandler.getGlobalMessages(
project_id,
projectId,
query.limit,
query.before,
function (err, messages) {
@ -86,42 +85,42 @@ module.exports = ChatController = {
// There will be a lot of repitition of user_ids, so first build a list
// of unique ones to perform db look ups on, then use these to populate the
// user fields
let message, thread, thread_id, user_id
let message, thread, threadId, userId
if (callback == null) {
callback = function () {}
}
const user_ids = {}
for (thread_id in threads) {
thread = threads[thread_id]
const userIds = {}
for (threadId in threads) {
thread = threads[threadId]
if (thread.resolved) {
user_ids[thread.resolved_by_user_id] = true
userIds[thread.resolved_by_user_id] = true
}
for (message of Array.from(thread.messages)) {
user_ids[message.user_id] = true
userIds[message.user_id] = true
}
}
const jobs = []
const users = {}
for (user_id in user_ids) {
const _ = user_ids[user_id]
;(user_id =>
for (userId in userIds) {
const _ = userIds[userId]
;(userId =>
jobs.push(cb =>
UserInfoManager.getPersonalInfo(user_id, function (error, user) {
UserInfoManager.getPersonalInfo(userId, function (error, user) {
if (error != null) return cb(error)
user = UserInfoController.formatPersonalInfo(user)
users[user_id] = user
users[userId] = user
cb()
})
))(user_id)
))(userId)
}
return async.series(jobs, function (error) {
if (error != null) {
return callback(error)
}
for (thread_id in threads) {
thread = threads[thread_id]
for (threadId in threads) {
thread = threads[threadId]
if (thread.resolved) {
thread.resolved_by_user = users[thread.resolved_by_user_id]
}

5
services/web/app/src/Features/Collaborators/CollaboratorsEmailHandler.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
*/
@ -19,8 +18,8 @@ module.exports = CollaboratorsEmailHandler = {
)
},
notifyUserOfProjectInvite(project_id, email, invite, sendingUser, callback) {
Project.findOne({ _id: project_id })
notifyUserOfProjectInvite(projectId, email, invite, sendingUser, callback) {
Project.findOne({ _id: projectId })
.select('name owner_ref')
.populate('owner_ref')
.exec(function (err, project) {

76
services/web/app/src/Features/Compile/ClsiCookieManager.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
*/
@ -11,7 +10,7 @@
* DS207: Consider shorter variations of null checks
* Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
*/
let rclient_secondary
let rclientSecondary
const { URL, URLSearchParams } = require('url')
const OError = require('@overleaf/o-error')
const Settings = require('@overleaf/settings')
@ -19,7 +18,7 @@ const request = require('request').defaults({ timeout: 30 * 1000 })
const RedisWrapper = require('../../infrastructure/RedisWrapper')
const rclient = RedisWrapper.client('clsi_cookie')
if (Settings.redis.clsi_cookie_secondary != null) {
rclient_secondary = RedisWrapper.client('clsi_cookie_secondary')
rclientSecondary = RedisWrapper.client('clsi_cookie_secondary')
}
const Cookie = require('cookie')
const logger = require('@overleaf/logger')
@ -31,17 +30,17 @@ const clsiCookiesEnabled =
module.exports = function (backendGroup) {
return {
buildKey(project_id, user_id) {
buildKey(projectId, userId) {
if (backendGroup != null) {
return `clsiserver:${backendGroup}:${project_id}:${user_id}`
return `clsiserver:${backendGroup}:${projectId}:${userId}`
} else {
return `clsiserver:${project_id}:${user_id}`
return `clsiserver:${projectId}:${userId}`
}
},
_getServerId(
project_id,
user_id,
projectId,
userId,
compileGroup,
compileBackendClass,
callback
@ -49,16 +48,14 @@ module.exports = function (backendGroup) {
if (callback == null) {
callback = function () {}
}
return rclient.get(
this.buildKey(project_id, user_id),
(err, serverId) => {
return rclient.get(this.buildKey(projectId, userId), (err, serverId) => {
if (err != null) {
return callback(err)
}
if (serverId == null || serverId === '') {
return this._populateServerIdViaRequest(
project_id,
user_id,
projectId,
userId,
compileGroup,
compileBackendClass,
callback
@ -66,13 +63,12 @@ module.exports = function (backendGroup) {
} else {
return callback(null, serverId)
}
}
)
})
},
_populateServerIdViaRequest(
project_id,
user_id,
projectId,
userId,
compileGroup,
compileBackendClass,
callback
@ -80,9 +76,7 @@ module.exports = function (backendGroup) {
if (callback == null) {
callback = function () {}
}
const u = new URL(
`${Settings.apis.clsi.url}/project/${project_id}/status`
)
const u = new URL(`${Settings.apis.clsi.url}/project/${projectId}/status`)
u.search = new URLSearchParams({
compileGroup,
compileBackendClass,
@ -90,13 +84,13 @@ module.exports = function (backendGroup) {
request.post(u.href, (err, res, body) => {
if (err != null) {
OError.tag(err, 'error getting initial server id for project', {
project_id,
project_id: projectId,
})
return callback(err)
}
this.setServerId(
project_id,
user_id,
projectId,
userId,
compileGroup,
compileBackendClass,
res,
@ -104,7 +98,7 @@ module.exports = function (backendGroup) {
function (err, serverId) {
if (err != null) {
logger.warn(
{ err, project_id },
{ err, projectId },
'error setting server id via populate request'
)
}
@ -153,8 +147,8 @@ module.exports = function (backendGroup) {
},
setServerId(
project_id,
user_id,
projectId,
userId,
compileGroup,
compileBackendClass,
response,
@ -171,7 +165,7 @@ module.exports = function (backendGroup) {
if (serverId == null) {
// We don't get a cookie back if it hasn't changed
return rclient.expire(
this.buildKey(project_id, user_id),
this.buildKey(projectId, userId),
this._getTTLInSeconds(previous),
err => callback(err, undefined)
)
@ -186,45 +180,45 @@ module.exports = function (backendGroup) {
compileBackendClass
)
}
if (rclient_secondary != null) {
if (rclientSecondary != null) {
this._setServerIdInRedis(
rclient_secondary,
project_id,
user_id,
rclientSecondary,
projectId,
userId,
serverId,
() => {}
)
}
this._setServerIdInRedis(rclient, project_id, user_id, serverId, err =>
this._setServerIdInRedis(rclient, projectId, userId, serverId, err =>
callback(err, serverId)
)
},
_setServerIdInRedis(rclient, project_id, user_id, serverId, callback) {
_setServerIdInRedis(rclient, projectId, userId, serverId, callback) {
if (callback == null) {
callback = function () {}
}
rclient.setex(
this.buildKey(project_id, user_id),
this.buildKey(projectId, userId),
this._getTTLInSeconds(serverId),
serverId,
callback
)
},
clearServerId(project_id, user_id, callback) {
clearServerId(projectId, userId, callback) {
if (callback == null) {
callback = function () {}
}
if (!clsiCookiesEnabled) {
return callback()
}
return rclient.del(this.buildKey(project_id, user_id), callback)
return rclient.del(this.buildKey(projectId, userId), callback)
},
getCookieJar(
project_id,
user_id,
projectId,
userId,
compileGroup,
compileBackendClass,
callback
@ -236,14 +230,14 @@ module.exports = function (backendGroup) {
return callback(null, request.jar(), undefined)
}
return this._getServerId(
project_id,
user_id,
projectId,
userId,
compileGroup,
compileBackendClass,
(err, serverId) => {
if (err != null) {
OError.tag(err, 'error getting server id', {
project_id,
project_id: projectId,
})
return callback(err)
}

21
services/web/app/src/Features/Contacts/ContactController.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-unused-vars,
*/
@ -21,16 +20,16 @@ const Modules = require('../../infrastructure/Modules')
module.exports = ContactsController = {
getContacts(req, res, next) {
const user_id = SessionManager.getLoggedInUserId(req.session)
const userId = SessionManager.getLoggedInUserId(req.session)
return ContactManager.getContactIds(
user_id,
userId,
{ limit: 50 },
function (error, contact_ids) {
function (error, contactIds) {
if (error != null) {
return next(error)
}
return UserGetter.getUsers(
contact_ids,
contactIds,
{
email: 1,
first_name: 1,
@ -44,9 +43,9 @@ module.exports = ContactsController = {
// UserGetter.getUsers may not preserve order so put them back in order
const positions = {}
for (let i = 0; i < contact_ids.length; i++) {
const contact_id = contact_ids[i]
positions[contact_id] = i
for (let i = 0; i < contactIds.length; i++) {
const contactId = contactIds[i]
positions[contactId] = i
}
contacts.sort(
(a, b) =>
@ -61,14 +60,14 @@ module.exports = ContactsController = {
return Modules.hooks.fire(
'getContacts',
user_id,
userId,
contacts,
function (error, additional_contacts) {
function (error, additionalContacts) {
if (error != null) {
return next(error)
}
contacts = contacts.concat(
...Array.from(additional_contacts || [])
...Array.from(additionalContacts || [])
)
return res.json({
contacts,

17
services/web/app/src/Features/Contacts/ContactManager.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
no-unused-vars,
@ -18,14 +17,14 @@ const request = require('request')
const settings = require('@overleaf/settings')
module.exports = ContactManager = {
getContactIds(user_id, options, callback) {
getContactIds(userId, options, callback) {
if (options == null) {
options = { limits: 50 }
}
if (callback == null) {
callback = function () {}
}
const url = `${settings.apis.contacts.url}/user/${user_id}/contacts`
const url = `${settings.apis.contacts.url}/user/${userId}/contacts`
return request.get(
{
url,
@ -45,7 +44,7 @@ module.exports = ContactManager = {
} else {
error = new OError(
`contacts api responded with non-success code: ${res.statusCode}`,
{ user_id }
{ user_id: userId }
)
return callback(error)
}
@ -53,16 +52,16 @@ module.exports = ContactManager = {
)
},
addContact(user_id, contact_id, callback) {
addContact(userId, contactId, callback) {
if (callback == null) {
callback = function () {}
}
const url = `${settings.apis.contacts.url}/user/${user_id}/contacts`
const url = `${settings.apis.contacts.url}/user/${userId}/contacts`
return request.post(
{
url,
json: {
contact_id,
contact_id: contactId,
},
jar: false,
},
@ -79,8 +78,8 @@ module.exports = ContactManager = {
error = new OError(
`contacts api responded with non-success code: ${res.statusCode}`,
{
user_id,
contact_id,
user_id: userId,
contact_id: contactId,
}
)
return callback(error)

17
services/web/app/src/Features/Downloads/ProjectDownloadsController.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-unused-vars,
*/
@ -21,23 +20,23 @@ const { prepareZipAttachment } = require('../../infrastructure/Response')
module.exports = ProjectDownloadsController = {
downloadProject(req, res, next) {
const project_id = req.params.Project_id
const projectId = req.params.Project_id
Metrics.inc('zip-downloads')
return DocumentUpdaterHandler.flushProjectToMongo(
project_id,
projectId,
function (error) {
if (error != null) {
return next(error)
}
return ProjectGetter.getProject(
project_id,
projectId,
{ name: true },
function (error, project) {
if (error != null) {
return next(error)
}
return ProjectZipStreamManager.createZipStreamForProject(
project_id,
projectId,
function (error, stream) {
if (error != null) {
return next(error)
@ -53,23 +52,23 @@ module.exports = ProjectDownloadsController = {
},
downloadMultipleProjects(req, res, next) {
const project_ids = req.query.project_ids.split(',')
const projectIds = req.query.project_ids.split(',')
Metrics.inc('zip-downloads-multiple')
return DocumentUpdaterHandler.flushMultipleProjectsToMongo(
project_ids,
projectIds,
function (error) {
if (error != null) {
return next(error)
}
return ProjectZipStreamManager.createZipStreamForMultipleProjects(
project_ids,
projectIds,
function (error, stream) {
if (error != null) {
return next(error)
}
prepareZipAttachment(
res,
`Overleaf Projects (${project_ids.length} items).zip`
`Overleaf Projects (${projectIds.length} items).zip`
)
return stream.pipe(res)
}

2
services/web/app/src/Features/Downloads/ProjectZipStreamManager.js
View file

@ -121,7 +121,7 @@ module.exports = ProjectZipStreamManager = {
(error, stream) => {
if (error) {
logger.warn(
{ err: error, projectId, file_id: file._id },
{ err: error, projectId, fileId: file._id },
'something went wrong adding file to zip archive'
)
return cb(error)

13
services/web/app/src/Features/Editor/EditorRealTimeController.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-unused-vars,
*/
@ -24,20 +23,20 @@ const RND = crypto.randomBytes(4).toString('hex') // generate a random key for t
let COUNT = 0
module.exports = EditorRealTimeController = {
emitToRoom(room_id, message, ...payload) {
emitToRoom(roomId, message, ...payload) {
// create a unique message id using a counter
const message_id = `web:${HOST}:${RND}-${COUNT++}`
const messageId = `web:${HOST}:${RND}-${COUNT++}`
let channel
if (room_id === 'all' || !Settings.publishOnIndividualChannels) {
if (roomId === 'all' || !Settings.publishOnIndividualChannels) {
channel = 'editor-events'
} else {
channel = `editor-events:${room_id}`
channel = `editor-events:${roomId}`
}
const blob = JSON.stringify({
room_id,
room_id: roomId,
message,
payload,
_id: message_id,
_id: messageId,
})
Metrics.summary('redis.publish.editor-events', blob.length, {
status: message,

2
services/web/app/src/Features/Email/EmailSender.js
View file

@ -78,7 +78,7 @@ async function sendEmail(options) {
if (!canContinue) {
logger.debug(
{
sendingUser_id: options.sendingUser_id,
sendingUserId: options.sendingUser_id,
to: options.to,
subject: options.subject,
canContinue,

74
services/web/app/src/Features/Exports/ExportsController.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
*/
// TODO: This file was created by bulk-decaffeinate.
@ -16,42 +15,43 @@ const logger = require('@overleaf/logger')
module.exports = {
exportProject(req, res, next) {
const { project_id, brand_variation_id } = req.params
const user_id = SessionManager.getLoggedInUserId(req.session)
const export_params = {
project_id,
brand_variation_id,
user_id,
const { project_id: projectId, brand_variation_id: brandVariationId } =
req.params
const userId = SessionManager.getLoggedInUserId(req.session)
const exportParams = {
project_id: projectId,
brand_variation_id: brandVariationId,
user_id: userId,
}
if (req.body) {
if (req.body.firstName) {
export_params.first_name = req.body.firstName.trim()
exportParams.first_name = req.body.firstName.trim()
}
if (req.body.lastName) {
export_params.last_name = req.body.lastName.trim()
exportParams.last_name = req.body.lastName.trim()
}
// additional parameters for gallery exports
if (req.body.title) {
export_params.title = req.body.title.trim()
exportParams.title = req.body.title.trim()
}
if (req.body.description) {
export_params.description = req.body.description.trim()
exportParams.description = req.body.description.trim()
}
if (req.body.author) {
export_params.author = req.body.author.trim()
exportParams.author = req.body.author.trim()
}
if (req.body.license) {
export_params.license = req.body.license.trim()
exportParams.license = req.body.license.trim()
}
if (req.body.showSource != null) {
export_params.show_source = req.body.showSource
exportParams.show_source = req.body.showSource
}
}
return ExportsHandler.exportProject(
export_params,
function (err, export_data) {
exportParams,
function (err, exportData) {
if (err != null) {
if (err.forwardResponse != null) {
logger.debug(
@ -66,24 +66,24 @@ module.exports = {
}
logger.debug(
{
user_id,
project_id,
brand_variation_id,
export_v1_id: export_data.v1_id,
userId,
projectId,
brandVariationId,
exportV1Id: exportData.v1_id,
},
'exported project'
)
return res.json({
export_v1_id: export_data.v1_id,
message: export_data.message,
export_v1_id: exportData.v1_id,
message: exportData.message,
})
}
)
},
exportStatus(req, res) {
const { export_id } = req.params
return ExportsHandler.fetchExport(export_id, function (err, export_json) {
const { export_id: exportId } = req.params
return ExportsHandler.fetchExport(exportId, function (err, exportJson) {
let json
if (err != null) {
json = {
@ -93,34 +93,34 @@ module.exports = {
res.json({ export_json: json })
return err
}
const parsed_export = JSON.parse(export_json)
const parsedExport = JSON.parse(exportJson)
json = {
status_summary: parsed_export.status_summary,
status_detail: parsed_export.status_detail,
partner_submission_id: parsed_export.partner_submission_id,
v2_user_email: parsed_export.v2_user_email,
v2_user_first_name: parsed_export.v2_user_first_name,
v2_user_last_name: parsed_export.v2_user_last_name,
title: parsed_export.title,
token: parsed_export.token,
status_summary: parsedExport.status_summary,
status_detail: parsedExport.status_detail,
partner_submission_id: parsedExport.partner_submission_id,
v2_user_email: parsedExport.v2_user_email,
v2_user_first_name: parsedExport.v2_user_first_name,
v2_user_last_name: parsedExport.v2_user_last_name,
title: parsedExport.title,
token: parsedExport.token,
}
return res.json({ export_json: json })
})
},
exportDownload(req, res, next) {
const { type, export_id } = req.params
const { type, export_id: exportId } = req.params
SessionManager.getLoggedInUserId(req.session)
return ExportsHandler.fetchDownload(
export_id,
exportId,
type,
function (err, export_file_url) {
function (err, exportFileUrl) {
if (err != null) {
return next(err)
}
return res.redirect(export_file_url)
return res.redirect(exportFileUrl)
}
)
},

97
services/web/app/src/Features/Exports/ExportsHandler.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
no-unused-vars,
@ -27,59 +26,59 @@ request = request.defaults()
settings = require('@overleaf/settings')
module.exports = ExportsHandler = {
exportProject(export_params, callback) {
exportProject(exportParams, callback) {
if (callback == null) {
callback = function () {}
}
return ExportsHandler._buildExport(
export_params,
function (err, export_data) {
exportParams,
function (err, exportData) {
if (err != null) {
return callback(err)
}
return ExportsHandler._requestExport(export_data, function (err, body) {
return ExportsHandler._requestExport(exportData, function (err, body) {
if (err != null) {
return callback(err)
}
export_data.v1_id = body.exportId
export_data.message = body.message
exportData.v1_id = body.exportId
exportData.message = body.message
// TODO: possibly store the export data in Mongo
return callback(null, export_data)
return callback(null, exportData)
})
}
)
},
_buildExport(export_params, callback) {
_buildExport(exportParams, callback) {
if (callback == null) {
callback = function () {}
}
const {
project_id,
user_id,
brand_variation_id,
project_id: projectId,
user_id: userId,
brand_variation_id: brandVariationId,
title,
description,
author,
license,
show_source,
} = export_params
show_source: showSource,
} = exportParams
const jobs = {
project(cb) {
return ProjectGetter.getProject(project_id, cb)
return ProjectGetter.getProject(projectId, cb)
},
// TODO: when we update async, signature will change from (cb, results) to (results, cb)
rootDoc: [
'project',
(results, cb) =>
ProjectRootDocManager.ensureRootDocumentIsValid(
project_id,
projectId,
function (error) {
if (error != null) {
return callback(error)
}
return ProjectLocator.findRootDoc(
{ project: results.project, project_id },
{ project: results.project, project_id: projectId },
cb
)
}
@ -87,19 +86,19 @@ module.exports = ExportsHandler = {
],
user(cb) {
return UserGetter.getUser(
user_id,
userId,
{ first_name: 1, last_name: 1, email: 1, overleaf: 1 },
cb
)
},
historyVersion(cb) {
return ProjectHistoryHandler.ensureHistoryExistsForProject(
project_id,
projectId,
function (error) {
if (error != null) {
return callback(error)
}
return ExportsHandler._requestVersion(project_id, cb)
return ExportsHandler._requestVersion(projectId, cb)
}
)
},
@ -108,9 +107,9 @@ module.exports = ExportsHandler = {
return async.auto(jobs, function (err, results) {
if (err != null) {
OError.tag(err, 'error building project export', {
project_id,
user_id,
brand_variation_id,
project_id: projectId,
user_id: userId,
brand_variation_id: brandVariationId,
})
return callback(err)
}
@ -118,19 +117,19 @@ module.exports = ExportsHandler = {
const { project, rootDoc, user, historyVersion } = results
if (!rootDoc || rootDoc[1] == null) {
err = new OError('cannot export project without root doc', {
project_id,
project_id: projectId,
})
return callback(err)
}
if (export_params.first_name && export_params.last_name) {
user.first_name = export_params.first_name
user.last_name = export_params.last_name
if (exportParams.first_name && exportParams.last_name) {
user.first_name = exportParams.first_name
user.last_name = exportParams.last_name
}
const export_data = {
const exportData = {
project: {
id: project_id,
id: projectId,
rootDocPath: rootDoc[1] != null ? rootDoc[1].fileSystem : undefined,
historyId: project.overleaf?.history?.id,
historyVersion,
@ -143,11 +142,11 @@ module.exports = ExportsHandler = {
description,
author,
license,
showSource: show_source,
showSource,
},
},
user: {
id: user_id,
id: userId,
firstName: user.first_name,
lastName: user.last_name,
email: user.email,
@ -155,17 +154,17 @@ module.exports = ExportsHandler = {
v1UserId: user.overleaf != null ? user.overleaf.id : undefined,
},
destination: {
brandVariationId: brand_variation_id,
brandVariationId,
},
options: {
callbackUrl: null,
}, // for now, until we want v1 to call us back
}
return callback(null, export_data)
return callback(null, exportData)
})
},
_requestExport(export_data, callback) {
_requestExport(exportData, callback) {
if (callback == null) {
callback = function () {}
}
@ -173,20 +172,20 @@ module.exports = ExportsHandler = {
{
url: `${settings.apis.v1.url}/api/v1/sharelatex/exports`,
auth: { user: settings.apis.v1.user, pass: settings.apis.v1.pass },
json: export_data,
json: exportData,
timeout: settings.apis.v1.timeout,
},
function (err, res, body) {
if (err != null) {
OError.tag(err, 'error making request to v1 export', {
export: export_data,
export: exportData,
})
return callback(err)
} else if (res.statusCode >= 200 && res.statusCode < 300) {
return callback(null, body)
} else {
logger.warn(
{ export: export_data },
{ export: exportData },
`v1 export returned failure; forwarding: ${body}`
)
// pass the v1 error along for the publish modal to handle
@ -197,19 +196,19 @@ module.exports = ExportsHandler = {
)
},
_requestVersion(project_id, callback) {
_requestVersion(projectId, callback) {
if (callback == null) {
callback = function () {}
}
return request.get(
{
url: `${settings.apis.project_history.url}/project/${project_id}/version`,
url: `${settings.apis.project_history.url}/project/${projectId}/version`,
json: true,
},
function (err, res, body) {
if (err != null) {
OError.tag(err, 'error making request to project history', {
project_id,
project_id: projectId,
})
return callback(err)
} else if (res.statusCode >= 200 && res.statusCode < 300) {
@ -217,7 +216,7 @@ module.exports = ExportsHandler = {
} else {
err = new OError(
`project history version returned a failure status code: ${res.statusCode}`,
{ project_id }
{ project_id: projectId }
)
return callback(err)
}
@ -225,20 +224,20 @@ module.exports = ExportsHandler = {
)
},
fetchExport(export_id, callback) {
fetchExport(exportId, callback) {
if (callback == null) {
callback = function () {}
}
return request.get(
{
url: `${settings.apis.v1.url}/api/v1/sharelatex/exports/${export_id}`,
url: `${settings.apis.v1.url}/api/v1/sharelatex/exports/${exportId}`,
auth: { user: settings.apis.v1.user, pass: settings.apis.v1.pass },
timeout: settings.apis.v1.timeout,
},
function (err, res, body) {
if (err != null) {
OError.tag(err, 'error making request to v1 export', {
export: export_id,
export: exportId,
})
return callback(err)
} else if (res.statusCode >= 200 && res.statusCode < 300) {
@ -246,7 +245,7 @@ module.exports = ExportsHandler = {
} else {
err = new OError(
`v1 export returned a failure status code: ${res.statusCode}`,
{ export: export_id }
{ export: exportId }
)
return callback(err)
}
@ -254,20 +253,20 @@ module.exports = ExportsHandler = {
)
},
fetchDownload(export_id, type, callback) {
fetchDownload(exportId, type, callback) {
if (callback == null) {
callback = function () {}
}
return request.get(
{
url: `${settings.apis.v1.url}/api/v1/sharelatex/exports/${export_id}/${type}_url`,
url: `${settings.apis.v1.url}/api/v1/sharelatex/exports/${exportId}/${type}_url`,
auth: { user: settings.apis.v1.user, pass: settings.apis.v1.pass },
timeout: settings.apis.v1.timeout,
},
function (err, res, body) {
if (err != null) {
OError.tag(err, 'error making request to v1 export', {
export: export_id,
export: exportId,
})
return callback(err)
} else if (res.statusCode >= 200 && res.statusCode < 300) {
@ -275,7 +274,7 @@ module.exports = ExportsHandler = {
} else {
err = new OError(
`v1 export returned a failure status code: ${res.statusCode}`,
{ export: export_id }
{ export: exportId }
)
return callback(err)
}

35
services/web/app/src/Features/History/RestoreManager.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
no-unused-vars,
@ -23,7 +22,7 @@ const Errors = require('../Errors/Errors')
const moment = require('moment')
module.exports = RestoreManager = {
restoreDocFromDeletedDoc(user_id, project_id, doc_id, name, callback) {
restoreDocFromDeletedDoc(userId, projectId, docId, name, callback) {
// This is the legacy method for restoring a doc from the SL track-changes/deletedDocs system.
// It looks up the deleted doc's contents, and then creates a new doc with the same content.
// We don't actually remove the deleted doc entry, just create a new one from its lines.
@ -31,8 +30,8 @@ module.exports = RestoreManager = {
callback = function () {}
}
return ProjectEntityHandler.getDoc(
project_id,
doc_id,
projectId,
docId,
{ include_deleted: true },
function (error, lines) {
if (error != null) {
@ -40,12 +39,12 @@ module.exports = RestoreManager = {
}
const addDocWithName = (name, callback) =>
EditorController.addDoc(
project_id,
projectId,
null,
name,
lines,
'restore',
user_id,
userId,
callback
)
return RestoreManager._addEntityWithUniqueName(
@ -57,12 +56,12 @@ module.exports = RestoreManager = {
)
},
restoreFileFromV2(user_id, project_id, version, pathname, callback) {
restoreFileFromV2(userId, projectId, version, pathname, callback) {
if (callback == null) {
callback = function () {}
}
return RestoreManager._writeFileVersionToDisk(
project_id,
projectId,
version,
pathname,
function (error, fsPath) {
@ -76,17 +75,17 @@ module.exports = RestoreManager = {
dirname = ''
}
return RestoreManager._findOrCreateFolder(
project_id,
projectId,
dirname,
function (error, parent_folder_id) {
function (error, parentFolderId) {
if (error != null) {
return callback(error)
}
const addEntityWithName = (name, callback) =>
FileSystemImportManager.addEntity(
user_id,
project_id,
parent_folder_id,
userId,
projectId,
parentFolderId,
name,
fsPath,
false,
@ -103,12 +102,12 @@ module.exports = RestoreManager = {
)
},
_findOrCreateFolder(project_id, dirname, callback) {
_findOrCreateFolder(projectId, dirname, callback) {
if (callback == null) {
callback = function () {}
}
return EditorController.mkdirp(
project_id,
projectId,
dirname,
function (error, newFolders, lastFolder) {
if (error != null) {
@ -145,13 +144,13 @@ module.exports = RestoreManager = {
})
},
_writeFileVersionToDisk(project_id, version, pathname, callback) {
_writeFileVersionToDisk(projectId, version, pathname, callback) {
if (callback == null) {
callback = function () {}
}
const url = `${
Settings.apis.project_history.url
}/project/${project_id}/version/${version}/${encodeURIComponent(pathname)}`
return FileWriter.writeUrlToDisk(project_id, url, callback)
}/project/${projectId}/version/${version}/${encodeURIComponent(pathname)}`
return FileWriter.writeUrlToDisk(projectId, url, callback)
},
}

5
services/web/app/src/Features/InactiveData/InactiveProjectController.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
*/
// TODO: This file was created by bulk-decaffeinate.
@ -33,8 +32,8 @@ module.exports = {
},
deactivateProject(req, res) {
const { project_id } = req.params
return InactiveProjectManager.deactivateProject(project_id, function (err) {
const { project_id: projectId } = req.params
return InactiveProjectManager.deactivateProject(projectId, function (err) {
if (err != null) {
return res.sendStatus(500)
} else {

27
services/web/app/src/Features/InactiveData/InactiveProjectManager.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
*/
// TODO: This file was created by bulk-decaffeinate.
@ -22,19 +21,19 @@ const { ObjectId } = require('mongodb')
const MILISECONDS_IN_DAY = 86400000
module.exports = InactiveProjectManager = {
reactivateProjectIfRequired(project_id, callback) {
reactivateProjectIfRequired(projectId, callback) {
ProjectGetter.getProject(
project_id,
projectId,
{ active: true },
function (err, project) {
if (err != null) {
OError.tag(err, 'error getting project', {
project_id,
project_id: projectId,
})
return callback(err)
}
logger.debug(
{ project_id, active: project.active },
{ projectId, active: project.active },
'seeing if need to reactivate project'
)
@ -42,14 +41,14 @@ module.exports = InactiveProjectManager = {
return callback()
}
DocstoreManager.unarchiveProject(project_id, function (err) {
DocstoreManager.unarchiveProject(projectId, function (err) {
if (err != null) {
OError.tag(err, 'error reactivating project in docstore', {
project_id,
project_id: projectId,
})
return callback(err)
}
ProjectUpdateHandler.markAsActive(project_id, callback)
ProjectUpdateHandler.markAsActive(projectId, callback)
})
}
)
@ -85,7 +84,7 @@ module.exports = InactiveProjectManager = {
function (err) {
if (err) {
logger.err(
{ project_id: project._id, err },
{ projectId: project._id, err },
'unable to deactivate project'
)
}
@ -106,15 +105,15 @@ module.exports = InactiveProjectManager = {
})
},
deactivateProject(project_id, callback) {
logger.debug({ project_id }, 'deactivating inactive project')
deactivateProject(projectId, callback) {
logger.debug({ projectId }, 'deactivating inactive project')
const jobs = [
cb => DocstoreManager.archiveProject(project_id, cb),
cb => ProjectUpdateHandler.markAsInactive(project_id, cb),
cb => DocstoreManager.archiveProject(projectId, cb),
cb => ProjectUpdateHandler.markAsInactive(projectId, cb),
]
async.series(jobs, function (err) {
if (err != null) {
logger.warn({ err, project_id }, 'error deactivating project')
logger.warn({ err, projectId }, 'error deactivating project')
}
callback(err)
})

29
services/web/app/src/Features/LinkedFiles/LinkedFilesController.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-unused-vars,
*/
@ -65,9 +64,9 @@ module.exports = LinkedFilesController = {
},
createLinkedFile(req, res, next) {
const { project_id } = req.params
const { name, provider, data, parent_folder_id } = req.body
const user_id = SessionManager.getLoggedInUserId(req.session)
const { project_id: projectId } = req.params
const { name, provider, data, parent_folder_id: parentFolderId } = req.body
const userId = SessionManager.getLoggedInUserId(req.session)
const Agent = LinkedFilesController._getAgent(provider)
if (Agent == null) {
@ -77,11 +76,11 @@ module.exports = LinkedFilesController = {
data.provider = provider
return Agent.createLinkedFile(
project_id,
projectId,
data,
name,
parent_folder_id,
user_id,
parentFolderId,
userId,
function (err, newFileId) {
if (err != null) {
return LinkedFilesController.handleError(err, req, res, next)
@ -92,12 +91,12 @@ module.exports = LinkedFilesController = {
},
refreshLinkedFile(req, res, next) {
const { project_id, file_id } = req.params
const user_id = SessionManager.getLoggedInUserId(req.session)
const { project_id: projectId, file_id: fileId } = req.params
const userId = SessionManager.getLoggedInUserId(req.session)
return LinkedFilesHandler.getFileById(
project_id,
file_id,
projectId,
fileId,
function (err, file, path, parentFolder) {
if (err != null) {
return next(err)
@ -114,18 +113,18 @@ module.exports = LinkedFilesController = {
return res.sendStatus(409)
}
const { provider } = linkedFileData
const parent_folder_id = parentFolder._id
const parentFolderId = parentFolder._id
const Agent = LinkedFilesController._getAgent(provider)
if (Agent == null) {
return res.sendStatus(400)
}
return Agent.refreshLinkedFile(
project_id,
projectId,
linkedFileData,
name,
parent_folder_id,
user_id,
parentFolderId,
userId,
function (err, newFileId) {
if (err != null) {
return LinkedFilesController.handleError(err, req, res, next)

41
services/web/app/src/Features/LinkedFiles/LinkedFilesHandler.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
no-unused-vars,
@ -25,14 +24,14 @@ const {
} = require('./LinkedFilesErrors')
module.exports = LinkedFilesHandler = {
getFileById(project_id, file_id, callback) {
getFileById(projectId, fileId, callback) {
if (callback == null) {
callback = function () {}
}
ProjectLocator.findElement(
{
project_id,
element_id: file_id,
project_id: projectId,
element_id: fileId,
type: 'file',
},
function (err, file, path, parentFolder) {
@ -83,33 +82,30 @@ module.exports = LinkedFilesHandler = {
},
importFromStream(
project_id,
projectId,
readStream,
linkedFileData,
name,
parent_folder_id,
user_id,
parentFolderId,
userId,
callback
) {
if (callback == null) {
callback = function () {}
}
callback = _.once(callback)
FileWriter.writeStreamToDisk(
project_id,
readStream,
function (err, fsPath) {
FileWriter.writeStreamToDisk(projectId, readStream, function (err, fsPath) {
if (err != null) {
return callback(err)
}
EditorController.upsertFile(
project_id,
parent_folder_id,
projectId,
parentFolderId,
name,
fsPath,
linkedFileData,
'upload',
user_id,
userId,
(err, file) => {
if (err != null) {
return callback(err)
@ -117,35 +113,34 @@ module.exports = LinkedFilesHandler = {
callback(null, file)
}
)
}
)
})
},
importContent(
project_id,
projectId,
content,
linkedFileData,
name,
parent_folder_id,
user_id,
parentFolderId,
userId,
callback
) {
if (callback == null) {
callback = function () {}
}
callback = _.once(callback)
FileWriter.writeContentToDisk(project_id, content, function (err, fsPath) {
FileWriter.writeContentToDisk(projectId, content, function (err, fsPath) {
if (err != null) {
return callback(err)
}
EditorController.upsertFile(
project_id,
parent_folder_id,
projectId,
parentFolderId,
name,
fsPath,
linkedFileData,
'upload',
user_id,
userId,
(err, file) => {
if (err != null) {
return callback(err)

73
services/web/app/src/Features/LinkedFiles/ProjectFileAgent.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
no-unused-vars,
@ -33,52 +32,52 @@ const {
module.exports = ProjectFileAgent = {
createLinkedFile(
project_id,
projectId,
linkedFileData,
name,
parent_folder_id,
user_id,
parentFolderId,
userId,
callback
) {
if (!this._canCreate(linkedFileData)) {
return callback(new AccessDeniedError())
}
return this._go(
project_id,
projectId,
linkedFileData,
name,
parent_folder_id,
user_id,
parentFolderId,
userId,
callback
)
},
refreshLinkedFile(
project_id,
projectId,
linkedFileData,
name,
parent_folder_id,
user_id,
parentFolderId,
userId,
callback
) {
return this._go(
project_id,
projectId,
linkedFileData,
name,
parent_folder_id,
user_id,
parentFolderId,
userId,
callback
)
},
_prepare(project_id, linkedFileData, user_id, callback) {
_prepare(projectId, linkedFileData, userId, callback) {
if (callback == null) {
callback = function () {}
}
return this._checkAuth(
project_id,
projectId,
linkedFileData,
user_id,
userId,
(err, allowed) => {
if (err != null) {
return callback(err)
@ -94,12 +93,12 @@ module.exports = ProjectFileAgent = {
)
},
_go(project_id, linkedFileData, name, parent_folder_id, user_id, callback) {
_go(projectId, linkedFileData, name, parentFolderId, userId, callback) {
linkedFileData = this._sanitizeData(linkedFileData)
return this._prepare(
project_id,
projectId,
linkedFileData,
user_id,
userId,
(err, linkedFileData) => {
if (err != null) {
return callback(err)
@ -109,26 +108,26 @@ module.exports = ProjectFileAgent = {
}
return this._getEntity(
linkedFileData,
user_id,
(err, source_project, entity, type) => {
userId,
(err, sourceProject, entity, type) => {
if (err != null) {
return callback(err)
}
if (type === 'doc') {
return DocstoreManager.getDoc(
source_project._id,
sourceProject._id,
entity._id,
function (err, lines) {
if (err != null) {
return callback(err)
}
return LinkedFilesHandler.importContent(
project_id,
projectId,
lines.join('\n'),
linkedFileData,
name,
parent_folder_id,
user_id,
parentFolderId,
userId,
function (err, file) {
if (err != null) {
return callback(err)
@ -140,7 +139,7 @@ module.exports = ProjectFileAgent = {
) // Created
} else if (type === 'file') {
return FileStoreHandler.getFileStream(
source_project._id,
sourceProject._id,
entity._id,
null,
function (err, fileStream) {
@ -148,12 +147,12 @@ module.exports = ProjectFileAgent = {
return callback(err)
}
return LinkedFilesHandler.importFromStream(
project_id,
projectId,
fileStream,
linkedFileData,
name,
parent_folder_id,
user_id,
parentFolderId,
userId,
function (err, file) {
if (err != null) {
return callback(err)
@ -172,27 +171,27 @@ module.exports = ProjectFileAgent = {
)
},
_getEntity(linkedFileData, current_user_id, callback) {
_getEntity(linkedFileData, currentUserId, callback) {
if (callback == null) {
callback = function () {}
}
callback = _.once(callback)
const { source_entity_path } = linkedFileData
const { source_entity_path: sourceEntityPath } = linkedFileData
return this._getSourceProject(linkedFileData, function (err, project) {
if (err != null) {
return callback(err)
}
const source_project_id = project._id
const sourceProjectId = project._id
return DocumentUpdaterHandler.flushProjectToMongo(
source_project_id,
sourceProjectId,
function (err) {
if (err != null) {
return callback(err)
}
return ProjectLocator.findElementByPath(
{
project_id: source_project_id,
path: source_entity_path,
project_id: sourceProjectId,
path: sourceEntityPath,
exactCaseMatch: true,
},
function (err, entity, type) {
@ -234,7 +233,7 @@ module.exports = ProjectFileAgent = {
_getSourceProject: LinkedFilesHandler.getSourceProject,
_checkAuth(project_id, data, current_user_id, callback) {
_checkAuth(projectId, data, currentUserId, callback) {
if (callback == null) {
callback = function () {}
}
@ -247,7 +246,7 @@ module.exports = ProjectFileAgent = {
return callback(err)
}
return AuthorizationManager.canUserReadProject(
current_user_id,
currentUserId,
project._id,
null,
function (err, canRead) {

35
services/web/app/src/Features/Metadata/MetaController.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-unused-vars,
*/
@ -19,53 +18,49 @@ const logger = require('@overleaf/logger')
module.exports = MetaController = {
getMetadata(req, res, next) {
const { project_id } = req.params
logger.debug({ project_id }, 'getting all labels for project')
const { project_id: projectId } = req.params
logger.debug({ projectId }, 'getting all labels for project')
return MetaHandler.getAllMetaForProject(
project_id,
projectId,
function (err, projectMeta) {
if (err != null) {
OError.tag(
err,
'[MetaController] error getting all labels from project',
{
project_id,
project_id: projectId,
}
)
return next(err)
}
return res.json({ projectId: project_id, projectMeta })
return res.json({ projectId, projectMeta })
}
)
},
broadcastMetadataForDoc(req, res, next) {
const { project_id } = req.params
const { doc_id } = req.params
const { project_id: projectId } = req.params
const { doc_id: docId } = req.params
const { broadcast } = req.body
logger.debug({ project_id, doc_id, broadcast }, 'getting labels for doc')
return MetaHandler.getMetaForDoc(
project_id,
doc_id,
function (err, docMeta) {
logger.debug({ projectId, docId, broadcast }, 'getting labels for doc')
return MetaHandler.getMetaForDoc(projectId, docId, function (err, docMeta) {
if (err != null) {
OError.tag(err, '[MetaController] error getting labels from doc', {
project_id,
doc_id,
project_id: projectId,
doc_id: docId,
})
return next(err)
}
// default to broadcasting, unless explicitly disabled (for backwards compatibility)
if (broadcast !== false) {
EditorRealTimeController.emitToRoom(project_id, 'broadcastDocMeta', {
docId: doc_id,
EditorRealTimeController.emitToRoom(projectId, 'broadcastDocMeta', {
docId,
meta: docMeta,
})
return res.sendStatus(200)
} else {
return res.json({ docId: doc_id, meta: docMeta })
return res.json({ docId, meta: docMeta })
}
}
)
})
},
}

13
services/web/app/src/Features/Metadata/MetaHandler.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
no-cond-assign,
@ -82,19 +81,19 @@ module.exports = MetaHandler = {
let pkg
const docMeta = { labels: [], packages: {} }
const packages = []
const label_re = MetaHandler.labelRegex()
const package_re = MetaHandler.usepackageRegex()
const req_package_re = MetaHandler.ReqPackageRegex()
const labelRe = MetaHandler.labelRegex()
const packageRe = MetaHandler.usepackageRegex()
const reqPackageRe = MetaHandler.ReqPackageRegex()
for (const line of Array.from(lines)) {
let labelMatch
let clean, messy, packageMatch
while ((labelMatch = label_re.exec(line))) {
while ((labelMatch = labelRe.exec(line))) {
let label
if ((label = labelMatch[1])) {
docMeta.labels.push(label)
}
}
while ((packageMatch = package_re.exec(line))) {
while ((packageMatch = packageRe.exec(line))) {
if ((messy = packageMatch[1])) {
for (pkg of Array.from(messy.split(','))) {
if ((clean = pkg.trim())) {
@ -103,7 +102,7 @@ module.exports = MetaHandler = {
}
}
}
while ((packageMatch = req_package_re.exec(line))) {
while ((packageMatch = reqPackageRe.exec(line))) {
if ((messy = packageMatch[1])) {
for (pkg of Array.from(messy.split(','))) {
if ((clean = pkg.trim())) {

5
services/web/app/src/Features/Project/ProjectApiController.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-unused-vars,
*/
@ -16,9 +15,9 @@ const logger = require('@overleaf/logger')
module.exports = {
getProjectDetails(req, res, next) {
const { project_id } = req.params
const { project_id: projectId } = req.params
return ProjectDetailsHandler.getDetails(
project_id,
projectId,
function (err, projDetails) {
if (err != null) {
return next(err)

83
services/web/app/src/Features/Project/ProjectCollabratecDetailsHandler.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
*/
@ -17,38 +16,44 @@ const { Project } = require('../../models/Project')
module.exports = ProjectCollabratecDetailsHandler = {
initializeCollabratecProject(
project_id,
user_id,
collabratec_document_id,
collabratec_privategroup_id,
projectId,
userId,
collabratecDocumentId,
collabratecPrivategroupId,
callback
) {
if (callback == null) {
callback = function () {}
}
ProjectCollabratecDetailsHandler.setCollabratecUsers(
project_id,
[{ user_id, collabratec_document_id, collabratec_privategroup_id }],
projectId,
[
{
user_id: userId,
collabratec_document_id: collabratecDocumentId,
collabratec_privategroup_id: collabratecPrivategroupId,
},
],
callback
)
},
isLinkedCollabratecUserProject(project_id, user_id, callback) {
isLinkedCollabratecUserProject(projectId, userId, callback) {
if (callback == null) {
callback = function () {}
}
try {
project_id = ObjectId(project_id)
user_id = ObjectId(user_id)
projectId = ObjectId(projectId)
userId = ObjectId(userId)
} catch (error) {
const err = error
return callback(err)
}
const query = {
_id: project_id,
_id: projectId,
collabratecUsers: {
$elemMatch: {
user_id,
user_id: userId,
},
},
}
@ -61,28 +66,28 @@ module.exports = ProjectCollabratecDetailsHandler = {
},
linkCollabratecUserProject(
project_id,
user_id,
collabratec_document_id,
projectId,
userId,
collabratecDocumentId,
callback
) {
if (callback == null) {
callback = function () {}
}
try {
project_id = ObjectId(project_id)
user_id = ObjectId(user_id)
projectId = ObjectId(projectId)
userId = ObjectId(userId)
} catch (error) {
const err = error
return callback(err)
}
const query = {
_id: project_id,
_id: projectId,
collabratecUsers: {
$not: {
$elemMatch: {
collabratec_document_id,
user_id,
collabratec_document_id: collabratecDocumentId,
user_id: userId,
},
},
},
@ -90,75 +95,75 @@ module.exports = ProjectCollabratecDetailsHandler = {
const update = {
$push: {
collabratecUsers: {
collabratec_document_id,
user_id,
collabratec_document_id: collabratecDocumentId,
user_id: userId,
},
},
}
Project.updateOne(query, update, callback)
},
setCollabratecUsers(project_id, collabratec_users, callback) {
setCollabratecUsers(projectId, collabratecUsers, callback) {
let err
if (callback == null) {
callback = function () {}
}
try {
project_id = ObjectId(project_id)
projectId = ObjectId(projectId)
} catch (error) {
err = error
return callback(err)
}
if (!Array.isArray(collabratec_users)) {
if (!Array.isArray(collabratecUsers)) {
callback(new Error('collabratec_users must be array'))
}
for (const collabratec_user of Array.from(collabratec_users)) {
for (const collabratecUser of Array.from(collabratecUsers)) {
try {
collabratec_user.user_id = ObjectId(collabratec_user.user_id)
collabratecUser.user_id = ObjectId(collabratecUser.user_id)
} catch (error1) {
err = error1
return callback(err)
}
}
const update = { $set: { collabratecUsers: collabratec_users } }
Project.updateOne({ _id: project_id }, update, callback)
const update = { $set: { collabratecUsers } }
Project.updateOne({ _id: projectId }, update, callback)
},
unlinkCollabratecUserProject(project_id, user_id, callback) {
unlinkCollabratecUserProject(projectId, userId, callback) {
if (callback == null) {
callback = function () {}
}
try {
project_id = ObjectId(project_id)
user_id = ObjectId(user_id)
projectId = ObjectId(projectId)
userId = ObjectId(userId)
} catch (error) {
const err = error
return callback(err)
}
const query = { _id: project_id }
const query = { _id: projectId }
const update = {
$pull: {
collabratecUsers: {
user_id,
user_id: userId,
},
},
}
Project.updateOne(query, update, callback)
},
updateCollabratecUserIds(old_user_id, new_user_id, callback) {
updateCollabratecUserIds(oldUserId, newUserId, callback) {
if (callback == null) {
callback = function () {}
}
try {
old_user_id = ObjectId(old_user_id)
new_user_id = ObjectId(new_user_id)
oldUserId = ObjectId(oldUserId)
newUserId = ObjectId(newUserId)
} catch (error) {
const err = error
return callback(err)
}
const query = { 'collabratecUsers.user_id': old_user_id }
const update = { $set: { 'collabratecUsers.$.user_id': new_user_id } }
const query = { 'collabratecUsers.user_id': oldUserId }
const update = { $set: { 'collabratecUsers.$.user_id': newUserId } }
Project.updateMany(query, update, callback)
},
}

4
services/web/app/src/Features/Project/ProjectDeleter.js
View file

@ -57,7 +57,7 @@ module.exports = {
async function markAsDeletedByExternalSource(projectId) {
logger.debug(
{ project_id: projectId },
{ projectId },
'marking project as deleted by external data source'
)
await Project.updateOne(
@ -274,7 +274,7 @@ async function deleteProject(projectId, options = {}) {
throw err
}
logger.debug({ project_id: projectId }, 'successfully deleted project')
logger.debug({ projectId }, 'successfully deleted project')
}
async function undeleteProject(projectId, options = {}) {

57
services/web/app/src/Features/Project/ProjectRootDocManager.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
no-unused-vars,
@ -27,11 +26,11 @@ const _ = require('underscore')
const { promisifyAll } = require('../../util/promises')
module.exports = ProjectRootDocManager = {
setRootDocAutomatically(project_id, callback) {
setRootDocAutomatically(projectId, callback) {
if (callback == null) {
callback = function () {}
}
return ProjectEntityHandler.getAllDocs(project_id, function (error, docs) {
return ProjectEntityHandler.getAllDocs(projectId, function (error, docs) {
if (error != null) {
return callback(error)
}
@ -55,11 +54,11 @@ module.exports = ProjectRootDocManager = {
}
)
return async.series(jobs, function (root_doc_id) {
if (root_doc_id != null) {
return async.series(jobs, function (rootDocId) {
if (rootDocId != null) {
return ProjectEntityUpdateHandler.setRootDoc(
project_id,
root_doc_id,
projectId,
rootDocId,
callback
)
} else {
@ -130,14 +129,14 @@ module.exports = ProjectRootDocManager = {
return null
},
setRootDocFromName(project_id, rootDocName, callback) {
setRootDocFromName(projectId, rootDocName, callback) {
if (callback == null) {
callback = function () {}
}
return ProjectEntityHandler.getAllDocPathsFromProjectById(
project_id,
projectId,
function (error, docPaths) {
let doc_id, path
let docId, path
if (error != null) {
return callback(error)
}
@ -148,28 +147,28 @@ module.exports = ProjectRootDocManager = {
rootDocName = `/${rootDocName}`
}
// find the root doc from the filename
let root_doc_id = null
for (doc_id in docPaths) {
let rootDocId = null
for (docId in docPaths) {
// docpaths have a leading / so allow matching "folder/filename" and "/folder/filename"
path = docPaths[doc_id]
path = docPaths[docId]
if (path === rootDocName) {
root_doc_id = doc_id
rootDocId = docId
}
}
// try a basename match if there was no match
if (!root_doc_id) {
for (doc_id in docPaths) {
path = docPaths[doc_id]
if (!rootDocId) {
for (docId in docPaths) {
path = docPaths[docId]
if (Path.basename(path) === Path.basename(rootDocName)) {
root_doc_id = doc_id
rootDocId = docId
}
}
}
// set the root doc id if we found a match
if (root_doc_id != null) {
if (rootDocId != null) {
return ProjectEntityUpdateHandler.setRootDoc(
project_id,
root_doc_id,
projectId,
rootDocId,
callback
)
} else {
@ -179,12 +178,12 @@ module.exports = ProjectRootDocManager = {
)
},
ensureRootDocumentIsSet(project_id, callback) {
ensureRootDocumentIsSet(projectId, callback) {
if (callback == null) {
callback = function () {}
}
return ProjectGetter.getProject(
project_id,
projectId,
{ rootDoc_id: 1 },
function (error, project) {
if (error != null) {
@ -198,7 +197,7 @@ module.exports = ProjectRootDocManager = {
return callback()
} else {
return ProjectRootDocManager.setRootDocAutomatically(
project_id,
projectId,
callback
)
}
@ -210,9 +209,9 @@ module.exports = ProjectRootDocManager = {
* @param {ObjectId | string} project_id
* @param {Function} callback
*/
ensureRootDocumentIsValid(project_id, callback) {
ensureRootDocumentIsValid(projectId, callback) {
ProjectGetter.getProjectWithoutDocLines(
project_id,
projectId,
function (error, project) {
if (error != null) {
return callback(error)
@ -227,9 +226,9 @@ module.exports = ProjectRootDocManager = {
project.rootDoc_id,
(err, docPath) => {
if (docPath) return callback()
ProjectEntityUpdateHandler.unsetRootDoc(project_id, () =>
ProjectEntityUpdateHandler.unsetRootDoc(projectId, () =>
ProjectRootDocManager.setRootDocAutomatically(
project_id,
projectId,
callback
)
)
@ -237,7 +236,7 @@ module.exports = ProjectRootDocManager = {
)
} else {
return ProjectRootDocManager.setRootDocAutomatically(
project_id,
projectId,
callback
)
}

13
services/web/app/src/Features/Project/ProjectUpdateHandler.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
no-unused-vars,
*/
@ -55,8 +54,8 @@ const ProjectUpdateHandler = {
Project.updateOne(conditions, update, {}, callback)
},
markAsOpened(project_id, callback) {
const conditions = { _id: project_id }
markAsOpened(projectId, callback) {
const conditions = { _id: projectId }
const update = { lastOpened: Date.now() }
Project.updateOne(conditions, update, {}, function (err) {
if (callback != null) {
@ -65,8 +64,8 @@ const ProjectUpdateHandler = {
})
},
markAsInactive(project_id, callback) {
const conditions = { _id: project_id }
markAsInactive(projectId, callback) {
const conditions = { _id: projectId }
const update = { active: false }
Project.updateOne(conditions, update, {}, function (err) {
if (callback != null) {
@ -75,8 +74,8 @@ const ProjectUpdateHandler = {
})
},
markAsActive(project_id, callback) {
const conditions = { _id: project_id }
markAsActive(projectId, callback) {
const conditions = { _id: projectId }
const update = { active: true }
Project.updateOne(conditions, update, {}, function (err) {
if (callback != null) {

5
services/web/app/src/Features/ServerAdmin/AdminController.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len
*/
@ -144,8 +143,8 @@ const AdminController = {
},
pollDropboxForUser(req, res) {
const { user_id } = req.body
return TpdsUpdateSender.pollDropboxForUser(user_id, () =>
const { user_id: userId } = req.body
return TpdsUpdateSender.pollDropboxForUser(userId, () =>
res.sendStatus(200)
)
},

21
services/web/app/src/Features/Subscription/RecurlyWrapper.js
View file

@ -43,7 +43,7 @@ const RecurlyWrapper = {
checkAccountExists(cache, next) {
const { user } = cache
logger.debug(
{ user_id: user._id },
{ userId: user._id },
'checking if recurly account exists for user'
)
RecurlyWrapper.apiRequest(
@ -66,16 +66,13 @@ const RecurlyWrapper = {
if (response.statusCode === 404) {
// actually not an error in this case, just no existing account
logger.debug(
{ user_id: user._id },
{ userId: user._id },
'user does not currently exist in recurly, proceed'
)
cache.userExists = false
return next(null, cache)
}
logger.debug(
{ user_id: user._id },
'user appears to exist in recurly'
)
logger.debug({ userId: user._id }, 'user appears to exist in recurly')
RecurlyWrapper._parseAccountXml(
responseBody,
function (err, account) {
@ -158,7 +155,7 @@ const RecurlyWrapper = {
createBillingInfo(cache, next) {
const { user } = cache
const { recurlyTokenIds } = cache
logger.debug({ user_id: user._id }, 'creating billing info in recurly')
logger.debug({ userId: user._id }, 'creating billing info in recurly')
const accountCode = cache?.account?.account_code
if (!accountCode) {
return next(new Error('no account code at createBillingInfo stage'))
@ -211,7 +208,7 @@ const RecurlyWrapper = {
const { user } = cache
const { subscriptionDetails } = cache
logger.debug(
{ user_id: user._id },
{ userId: user._id },
'setting billing address and company info in recurly'
)
const accountCode = cache?.account?.account_code
@ -279,7 +276,7 @@ const RecurlyWrapper = {
createSubscription(cache, next) {
const { user } = cache
const { subscriptionDetails } = cache
logger.debug({ user_id: user._id }, 'creating subscription in recurly')
logger.debug({ userId: user._id }, 'creating subscription in recurly')
const data = {
plan_code: subscriptionDetails.plan_code,
currency: subscriptionDetails.currencyCode,
@ -344,7 +341,7 @@ const RecurlyWrapper = {
callback
) {
logger.debug(
{ user_id: user._id },
{ userId: user._id },
'starting process of creating paypal subscription'
)
// We use `async.waterfall` to run each of these actions in sequence
@ -374,7 +371,7 @@ const RecurlyWrapper = {
return callback(err)
}
logger.debug(
{ user_id: user._id },
{ userId: user._id },
'done creating paypal subscription for user'
)
callback(null, result.subscription)
@ -444,7 +441,7 @@ const RecurlyWrapper = {
createSubscription(user, subscriptionDetails, recurlyTokenIds, callback) {
const { isPaypal } = subscriptionDetails
logger.debug(
{ user_id: user._id, isPaypal },
{ userId: user._id, isPaypal },
'setting up subscription in recurly'
)
const fn = isPaypal

16
services/web/app/src/Features/Subscription/SubscriptionController.js
View file

@ -451,7 +451,7 @@ async function createSubscription(req, res) {
await LimitationsManager.promises.userHasV1OrV2Subscription(user)
if (hasSubscription) {
logger.warn({ user_id: user._id }, 'user already has subscription')
logger.warn({ userId: user._id }, 'user already has subscription')
return res.sendStatus(409) // conflict
}
@ -477,7 +477,7 @@ async function createSubscription(req, res) {
)
} else {
logger.warn(
{ err, user_id: user._id },
{ err, userId: user._id },
'something went wrong creating subscription'
)
throw err
@ -553,7 +553,7 @@ async function _successfulSubscriptionAngular(req, res) {
function cancelSubscription(req, res, next) {
const user = SessionManager.getSessionUser(req.session)
logger.debug({ user_id: user._id }, 'canceling subscription')
logger.debug({ userId: user._id }, 'canceling subscription')
SubscriptionHandler.cancelSubscription(user, function (err) {
if (err) {
OError.tag(err, 'something went wrong canceling subscription', {
@ -627,12 +627,12 @@ function updateSubscription(req, res, next) {
if (planCode == null) {
const err = new Error('plan_code is not defined')
logger.warn(
{ user_id: user._id, err, planCode, origin, body: req.body },
{ userId: user._id, err, planCode, origin, body: req.body },
'[Subscription] error in updateSubscription form'
)
return next(err)
}
logger.debug({ planCode, user_id: user._id }, 'updating subscription')
logger.debug({ planCode, userId: user._id }, 'updating subscription')
SubscriptionHandler.updateSubscription(user, planCode, null, function (err) {
if (err) {
OError.tag(err, 'something went wrong updating subscription', {
@ -646,7 +646,7 @@ function updateSubscription(req, res, next) {
function cancelPendingSubscriptionChange(req, res, next) {
const user = SessionManager.getSessionUser(req.session)
logger.debug({ user_id: user._id }, 'canceling pending subscription change')
logger.debug({ userId: user._id }, 'canceling pending subscription change')
SubscriptionHandler.cancelPendingSubscriptionChange(user, function (err) {
if (err) {
OError.tag(
@ -678,7 +678,7 @@ function updateAccountEmailAddress(req, res, next) {
function reactivateSubscription(req, res, next) {
const user = SessionManager.getSessionUser(req.session)
logger.debug({ user_id: user._id }, 'reactivating subscription')
logger.debug({ userId: user._id }, 'reactivating subscription')
SubscriptionHandler.reactivateSubscription(user, function (err) {
if (err) {
OError.tag(err, 'something went wrong reactivating subscription', {
@ -775,7 +775,7 @@ function processUpgradeToAnnualPlan(req, res, next) {
const couponCode = Settings.coupon_codes.upgradeToAnnualPromo[planName]
const annualPlanName = `${planName}-annual`
logger.debug(
{ user_id: user._id, planName: annualPlanName },
{ userId: user._id, planName: annualPlanName },
'user is upgrading to annual billing with discount'
)
return SubscriptionHandler.updateSubscription(

4
services/web/app/src/Features/Subscription/SubscriptionGroupController.js
View file

@ -8,7 +8,7 @@ function removeUserFromGroup(req, res, next) {
const subscription = req.entity
const userToRemoveId = req.params.user_id
logger.debug(
{ subscriptionId: subscription._id, userToRemove_id: userToRemoveId },
{ subscriptionId: subscription._id, userToRemoveId },
'removing user from group subscription'
)
SubscriptionGroupHandler.removeUserFromGroup(
@ -44,7 +44,7 @@ function removeSelfFromGroup(req, res, next) {
function (error) {
if (error) {
logger.err(
{ err: error, userToRemove_id: userToRemoveId, subscriptionId },
{ err: error, userToRemoveId, subscriptionId },
'error removing self from group'
)
return res.sendStatus(500)

6
services/web/app/src/Features/Subscription/SubscriptionHandler.js
View file

@ -80,7 +80,7 @@ function updateSubscription(user, planCode, couponCode, callback) {
function (err, hasSubscription, subscription) {
if (err) {
logger.warn(
{ err, user_id: user._id, hasSubscription },
{ err, userId: user._id, hasSubscription },
'there was an error checking user v2 subscription'
)
}
@ -183,7 +183,7 @@ function cancelSubscription(user, callback) {
function (err, hasSubscription, subscription) {
if (err) {
logger.warn(
{ err, user_id: user._id, hasSubscription },
{ err, userId: user._id, hasSubscription },
'there was an error checking user v2 subscription'
)
}
@ -220,7 +220,7 @@ function reactivateSubscription(user, callback) {
function (err, hasSubscription, subscription) {
if (err) {
logger.warn(
{ err, user_id: user._id, hasSubscription },
{ err, userId: user._id, hasSubscription },
'there was an error checking user v2 subscription'
)
}

5
services/web/app/src/Features/Templates/TemplatesController.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-unused-vars,
*/
@ -47,7 +46,7 @@ module.exports = TemplatesController = {
},
createProjectFromV1Template(req, res, next) {
const user_id = SessionManager.getLoggedInUserId(req.session)
const userId = SessionManager.getLoggedInUserId(req.session)
return TemplatesManager.createProjectFromV1Template(
req.body.brandVariationId,
req.body.compiler,
@ -55,7 +54,7 @@ module.exports = TemplatesController = {
req.body.templateId,
req.body.templateName,
req.body.templateVersionId,
user_id,
userId,
req.body.imageName,
function (err, project) {
if (err != null) {

21
services/web/app/src/Features/Templates/TemplatesManager.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
*/
// TODO: This file was created by bulk-decaffeinate.
@ -35,7 +34,7 @@ const TemplatesManager = {
templateId,
templateName,
templateVersionId,
user_id,
userId,
imageName,
_callback
) {
@ -73,7 +72,7 @@ const TemplatesManager = {
return callback(new Error('get zip failed'))
}
ProjectUploadManager.createProjectFromZipArchiveWithName(
user_id,
userId,
projectName,
dumpPath,
attributes,
@ -129,33 +128,33 @@ const TemplatesManager = {
})
},
_setCompiler(project_id, compiler, callback) {
_setCompiler(projectId, compiler, callback) {
if (compiler == null) {
return callback()
}
ProjectOptionsHandler.setCompiler(project_id, compiler, callback)
ProjectOptionsHandler.setCompiler(projectId, compiler, callback)
},
_setImage(project_id, imageName, callback) {
_setImage(projectId, imageName, callback) {
if (!imageName) {
imageName = 'wl_texlive:2018.1'
}
ProjectOptionsHandler.setImageName(project_id, imageName, callback)
ProjectOptionsHandler.setImageName(projectId, imageName, callback)
},
_setMainFile(project_id, mainFile, callback) {
_setMainFile(projectId, mainFile, callback) {
if (mainFile == null) {
return callback()
}
ProjectRootDocManager.setRootDocFromName(project_id, mainFile, callback)
ProjectRootDocManager.setRootDocFromName(projectId, mainFile, callback)
},
_setBrandVariationId(project_id, brandVariationId, callback) {
_setBrandVariationId(projectId, brandVariationId, callback) {
if (brandVariationId == null) {
return callback()
}
ProjectOptionsHandler.setBrandVariationId(
project_id,
projectId,
brandVariationId,
callback
)

2
services/web/app/src/Features/ThirdPartyDataStore/TpdsUpdateHandler.js
View file

@ -89,7 +89,7 @@ async function deleteUpdate(userId, projectId, projectName, path, source) {
const project = activeProjects[0]
if (path === '/') {
logger.debug(
{ userId, filePath: path, projectName, project_id: project._id },
{ userId, filePath: path, projectName, projectId: project._id },
'project found for delete update, path is root so marking project as deleted'
)
await ProjectDeleter.promises.markAsDeletedByExternalSource(project._id)

2
services/web/app/src/Features/ThirdPartyDataStore/TpdsUpdateSender.js
View file

@ -190,7 +190,7 @@ async function deleteProject(params) {
)
if (!response.ok) {
logger.error(
{ statusCode: response.status, project_id: projectId },
{ statusCode: response.status, projectId },
'error deleting project in third party datastore (project_archiver)'
)
return false

23
services/web/app/src/Features/Uploads/ProjectUploadController.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-unused-vars,
*/
@ -39,11 +38,11 @@ const upload = multer(
module.exports = ProjectUploadController = {
uploadProject(req, res, next) {
const timer = new metrics.Timer('project-upload')
const user_id = SessionManager.getLoggedInUserId(req.session)
const userId = SessionManager.getLoggedInUserId(req.session)
const { originalname, path } = req.file
const name = Path.basename(originalname, '.zip')
return ProjectUploadManager.createProjectFromZipArchive(
user_id,
userId,
name,
path,
function (error, project) {
@ -76,11 +75,11 @@ module.exports = ProjectUploadController = {
const timer = new metrics.Timer('file-upload')
const name = req.file != null ? req.file.originalname : undefined
const path = req.file != null ? req.file.path : undefined
const project_id = req.params.Project_id
const { folder_id } = req.query
const projectId = req.params.Project_id
const { folder_id: folderId } = req.query
if (name == null || name.length === 0 || name.length > 150) {
logger.err(
{ projectId: project_id, fileName: name },
{ projectId, fileName: name },
'bad name when trying to upload file'
)
return res.status(422).json({
@ -88,12 +87,12 @@ module.exports = ProjectUploadController = {
error: 'invalid_filename',
})
}
const user_id = SessionManager.getLoggedInUserId(req.session)
const userId = SessionManager.getLoggedInUserId(req.session)
return FileSystemImportManager.addEntity(
user_id,
project_id,
folder_id,
userId,
projectId,
folderId,
name,
path,
true,
@ -104,10 +103,10 @@ module.exports = ProjectUploadController = {
logger.error(
{
err: error,
projectId: project_id,
projectId,
filePath: path,
fileName: name,
folderId: folder_id,
folderId,
},
'error uploading file'
)

9
services/web/app/src/Features/User/UserSessionsManager.js
View file

@ -88,10 +88,7 @@ const UserSessionsManager = {
}
sessionKeys = _.filter(sessionKeys, k => !_.contains(exclude, k))
if (sessionKeys.length === 0) {
logger.debug(
{ user_id: user._id },
'no other sessions found, returning'
)
logger.debug({ userId: user._id }, 'no other sessions found, returning')
return callback(null, [])
}
@ -152,13 +149,13 @@ const UserSessionsManager = {
)
if (keysToDelete.length === 0) {
logger.debug(
{ user_id: user._id },
{ userId: user._id },
'no sessions in UserSessions set to delete, returning'
)
return callback(null)
}
logger.debug(
{ user_id: user._id, count: keysToDelete.length },
{ userId: user._id, count: keysToDelete.length },
'deleting sessions for user'
)

9
services/web/app/src/Features/V1/V1Handler.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-unused-vars,
*/
@ -55,13 +54,13 @@ module.exports = V1Handler = {
)
},
doPasswordReset(v1_user_id, password, callback) {
doPasswordReset(v1UserId, password, callback) {
return V1Api.request(
{
method: 'POST',
url: '/api/v1/sharelatex/reset_password',
json: {
user_id: v1_user_id,
user_id: v1UserId,
password,
},
expectedStatusCodes: [200],
@ -69,13 +68,13 @@ module.exports = V1Handler = {
function (err, response, body) {
if (err != null) {
OError.tag(err, 'error while talking to v1 password reset api', {
v1_user_id,
v1_user_id: v1UserId,
})
return callback(err, false)
}
if ([200].includes(response.statusCode)) {
logger.debug(
{ v1_user_id, changed: true },
{ v1UserId, changed: true },
'got success response from v1 password reset api'
)
return callback(null, true)

2
services/web/app/src/infrastructure/ExpressLocals.js
View file

@ -126,7 +126,7 @@ module.exports = function (webRouter, privateApiRouter, publicApiRouter) {
const userId = SessionManager.getLoggedInUserId(req.session)
if (cdnBlocked && req.session.cdnBlocked == null) {
logger.debug(
{ user_id: userId, ip: req != null ? req.ip : undefined },
{ userId, ip: req != null ? req.ip : undefined },
'cdnBlocked for user, not using it and turning it off for future requets'
)
Metrics.inc('no_cdn', 1, {

2
services/web/app/src/util/bib2json.js
View file

@ -49,7 +49,7 @@ function BibtexParser(arg0, allowedKeys) {
let parser = new BibtexParser(accumulator, allowedKeys)
parser.parse(arg0)
return {
entries: entries,
entries,
errors: parser.getErrors(),
}
}

6
services/web/modules/launchpad/app/src/LaunchpadController.js
View file

@ -185,7 +185,7 @@ module.exports = LaunchpadController = {
AuthenticationController.setRedirectInSession(req, '/launchpad')
logger.debug(
{ email, user_id: user._id, authMethod },
{ email, userId: user._id, authMethod },
'created first admin account'
)
@ -244,7 +244,7 @@ module.exports = LaunchpadController = {
return next(err)
}
logger.debug({ user_id: user._id }, 'making user an admin')
logger.debug({ userId: user._id }, 'making user an admin')
User.updateOne(
{ _id: user._id },
{
@ -262,7 +262,7 @@ module.exports = LaunchpadController = {
}
logger.debug(
{ email, user_id: user._id },
{ email, userId: user._id },
'created first admin account'
)
res.json({ redir: '/launchpad' })

6
services/web/scripts/history/debug_history.js
View file

@ -170,14 +170,14 @@ function rewindOp(content, op, log) {
// is the case with this op, and shift p back appropriately to match
// ShareJS if so.
let { p } = op
const max_p = content.length - op.i.length
if (p > max_p) {
const maxP = content.length - op.i.length
if (p > maxP) {
log.opError(
'invalid offset rewinding insert, truncating to content length',
content,
op
)
p = max_p
p = maxP
}
const textToBeRemoved = content.slice(p, p + op.i.length)
if (op.i !== textToBeRemoved) {

9
services/web/test/acceptance/src/ApiClsiTests.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-unused-vars,
n/no-deprecated-api,
@ -17,7 +16,7 @@ const request = require('./helpers/request')
const Settings = require('@overleaf/settings')
const auth = Buffer.from('sharelatex:password').toString('base64')
const authed_request = request.defaults({
const authedRequest = request.defaults({
headers: {
Authorization: `Basic ${auth}`,
},
@ -52,7 +51,7 @@ describe('ApiClsiTests', function () {
describe('valid request', function () {
it('returns success and a list of output files', function (done) {
return authed_request.post(
return authedRequest.post(
{
uri: '/api/clsi/compile/abcd',
json: this.compileSpec,
@ -108,7 +107,7 @@ describe('ApiClsiTests', function () {
describe('get output', function () {
describe('valid file', function () {
it('returns the file', function (done) {
return authed_request.get(
return authedRequest.get(
'/api/clsi/compile/abcd/build/1234/output/project.pdf',
(error, response, body) => {
if (error != null) {
@ -124,7 +123,7 @@ describe('ApiClsiTests', function () {
describe('invalid file', function () {
it('returns 404', function (done) {
return authed_request.get(
return authedRequest.get(
'/api/clsi/compile/abcd/build/1234/output/project.aux',
(error, response, body) => {
if (error != null) {

16
services/web/test/acceptance/src/ProjectFeaturesTests.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
*/
@ -17,11 +16,11 @@ const User = require('./helpers/User')
const request = require('./helpers/request')
const settings = require('@overleaf/settings')
const joinProject = (user_id, project_id, callback) =>
const joinProject = (userId, projectId, callback) =>
request.post(
{
url: `/project/${project_id}/join`,
qs: { user_id },
url: `/project/${projectId}/join`,
qs: { user_id: userId },
auth: {
user: settings.apis.web.user,
pass: settings.apis.web.pass,
@ -42,16 +41,13 @@ describe('ProjectFeatures', function () {
describe('with private project', function () {
beforeEach(function (done) {
return this.owner.createProject(
'private-project',
(error, project_id) => {
return this.owner.createProject('private-project', (error, projectId) => {
if (error != null) {
return done(error)
}
this.project_id = project_id
this.project_id = projectId
return done()
}
)
})
})
describe('with an upgraded account', function () {

9
services/web/test/acceptance/src/RestoringFilesTest.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-unused-vars,
*/
@ -35,8 +34,8 @@ describe('RestoringFiles', function () {
return this.owner.createProject(
'example-project',
{ template: 'example' },
(error, project_id) => {
this.project_id = project_id
(error, projectId) => {
this.project_id = projectId
if (error != null) {
throw error
}
@ -94,11 +93,11 @@ describe('RestoringFiles', function () {
if (error != null) {
throw error
}
const restored_doc = _.find(
const restoredDoc = _.find(
project.rootFolder[0].docs,
doc => doc.name === 'main.tex'
)
expect(restored_doc._id.toString()).to.equal(this.restored_doc_id)
expect(restoredDoc._id.toString()).to.equal(this.restored_doc_id)
expect(this.doc._id).to.not.equal(this.restored_doc_id)
expect(
MockDocstoreApi.docs[this.project_id][this.restored_doc_id].lines

27
services/web/test/acceptance/src/SecurityHeadersTests.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
no-return-assign,
@ -17,7 +16,7 @@ const async = require('async')
const User = require('./helpers/User')
const request = require('./helpers/request')
const assert_has_common_headers = function (response) {
const assertHasCommonHeaders = function (response) {
const { headers } = response
assert.include(headers, {
'x-download-options': 'noopen',
@ -31,7 +30,7 @@ const assert_has_common_headers = function (response) {
assert.isUndefined(headers['cross-origin-embedder-policy'])
}
const assert_has_cache_headers = function (response) {
const assertHasCacheHeaders = function (response) {
assert.include(response.headers, {
'surrogate-control': 'no-store',
'cache-control': 'no-store, no-cache, must-revalidate, proxy-revalidate',
@ -40,7 +39,7 @@ const assert_has_cache_headers = function (response) {
})
}
const assert_has_no_cache_headers = function (response) {
const assertHasNoCacheHeaders = function (response) {
assert.doesNotHaveAnyKeys(response.headers, [
'surrogate-control',
'cache-control',
@ -49,7 +48,7 @@ const assert_has_no_cache_headers = function (response) {
])
}
const assert_has_asset_caching_headers = function (response) {
const assertHasAssetCachingHeaders = function (response) {
assert.equal(response.headers['cache-control'], 'public, max-age=31536000')
}
@ -67,21 +66,21 @@ describe('SecurityHeaders', function () {
it('should have all common headers', function (done) {
return request.get('/', (err, res, body) => {
assert_has_common_headers(res)
assertHasCommonHeaders(res)
return done()
})
})
it('should not have cache headers on public pages', function (done) {
return request.get('/', (err, res, body) => {
assert_has_no_cache_headers(res)
assertHasNoCacheHeaders(res)
return done()
})
})
it('should have caching headers on static assets', function (done) {
request.get('/favicon.ico', (err, res) => {
assert_has_asset_caching_headers(res)
assertHasAssetCachingHeaders(res)
done(err)
})
})
@ -94,8 +93,8 @@ describe('SecurityHeaders', function () {
cb => this.user.logout(cb),
],
(err, results) => {
const main_response = results[1][0]
assert_has_cache_headers(main_response)
const mainResponse = results[1][0]
assertHasCacheHeaders(mainResponse)
return done()
}
)
@ -108,11 +107,11 @@ describe('SecurityHeaders', function () {
cb => {
return this.user.createProject(
'public-project',
(error, project_id) => {
(error, projectId) => {
if (error != null) {
return done(error)
}
this.project_id = project_id
this.project_id = projectId
return this.user.makePublic(this.project_id, 'readAndWrite', cb)
}
)
@ -121,7 +120,7 @@ describe('SecurityHeaders', function () {
],
(err, results) => {
return request.get(`/project/${this.project_id}`, (err, res, body) => {
assert_has_cache_headers(res)
assertHasCacheHeaders(res)
return done()
})
}
@ -137,7 +136,7 @@ describe('SecurityHeaders', function () {
],
(err, results) => {
const res = results[1][0]
assert_has_asset_caching_headers(res)
assertHasAssetCachingHeaders(res)
done()
}
)

2
services/web/test/unit/src/Authentication/AuthenticationControllerTests.js
View file

@ -1419,7 +1419,7 @@ describe('AuthenticationController', function () {
it('should log the successful login', function () {
this.logger.debug
.calledWith(
{ email: this.user.email, user_id: this.user._id.toString() },
{ email: this.user.email, userId: this.user._id.toString() },
'successful log in'
)
.should.equal(true)

5
services/web/test/unit/src/Chat/ChatControllerTests.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
no-return-assign,
@ -135,8 +134,8 @@ describe('ChatController', function () {
mock: 'user_2',
},
}
this.UserInfoManager.getPersonalInfo = (user_id, callback) => {
return callback(null, this.users[user_id])
this.UserInfoManager.getPersonalInfo = (userId, callback) => {
return callback(null, this.users[userId])
}
sinon.spy(this.UserInfoManager, 'getPersonalInfo')
return (this.UserInfoController.formatPersonalInfo = user => ({

43
services/web/test/unit/src/Downloads/ProjectZipStreamManagerTests.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-return-assign,
no-unused-vars,
@ -55,19 +54,19 @@ describe('ProjectZipStreamManager', function () {
}
this.ProjectZipStreamManager.createZipStreamForProject = (
project_id,
projectId,
callback
) => {
callback(null, this.zip_streams[project_id])
callback(null, this.zip_streams[projectId])
setTimeout(() => {
return this.zip_streams[project_id].emit('end')
return this.zip_streams[projectId].emit('end')
})
return 0
}
sinon.spy(this.ProjectZipStreamManager, 'createZipStreamForProject')
this.ProjectGetter.getProject = (project_id, fields, callback) => {
return callback(null, { name: this.project_names[project_id] })
this.ProjectGetter.getProject = (projectId, fields, callback) => {
return callback(null, { name: this.project_names[projectId] })
}
sinon.spy(this.ProjectGetter, 'getProject')
@ -95,26 +94,26 @@ describe('ProjectZipStreamManager', function () {
})
it('should get a zip stream for all of the projects', function () {
return Array.from(this.project_ids).map(project_id =>
return Array.from(this.project_ids).map(projectId =>
this.ProjectZipStreamManager.createZipStreamForProject
.calledWith(project_id)
.calledWith(projectId)
.should.equal(true)
)
})
it('should get the names of each project', function () {
return Array.from(this.project_ids).map(project_id =>
return Array.from(this.project_ids).map(projectId =>
this.ProjectGetter.getProject
.calledWith(project_id, { name: true })
.calledWith(projectId, { name: true })
.should.equal(true)
)
})
it('should add all of the projects to the zip', function () {
return Array.from(this.project_ids).map(project_id =>
return Array.from(this.project_ids).map(projectId =>
this.archive.append
.calledWith(this.zip_streams[project_id], {
name: this.project_names[project_id] + '.zip',
.calledWith(this.zip_streams[projectId], {
name: this.project_names[projectId] + '.zip',
})
.should.equal(true)
)
@ -132,18 +131,18 @@ describe('ProjectZipStreamManager', function () {
}
this.ProjectZipStreamManager.createZipStreamForProject = (
project_id,
projectId,
callback
) => {
callback(null, this.zip_streams[project_id])
callback(null, this.zip_streams[projectId])
setTimeout(() => {
this.zip_streams[project_id].emit('end')
this.zip_streams[projectId].emit('end')
})
}
sinon.spy(this.ProjectZipStreamManager, 'createZipStreamForProject')
this.ProjectGetter.getProject = (project_id, fields, callback) => {
const name = this.project_names[project_id]
this.ProjectGetter.getProject = (projectId, fields, callback) => {
const name = this.project_names[projectId]
callback(null, name ? { name } : undefined)
}
sinon.spy(this.ProjectGetter, 'getProject')
@ -170,9 +169,9 @@ describe('ProjectZipStreamManager', function () {
})
it('should get the names of each project', function () {
this.project_ids.map(project_id =>
this.project_ids.map(projectId =>
this.ProjectGetter.getProject
.calledWith(project_id, { name: true })
.calledWith(projectId, { name: true })
.should.equal(true)
)
})
@ -379,10 +378,10 @@ describe('ProjectZipStreamManager', function () {
this.ProjectEntityHandler.getAllFiles = sinon
.stub()
.callsArgWith(1, null, this.files)
this.FileStoreHandler.getFileStream = (project_id, file_id, ...rest) => {
this.FileStoreHandler.getFileStream = (projectId, fileId, ...rest) => {
const obj = rest[0],
callback = rest[1]
return callback(null, this.streams[file_id])
return callback(null, this.streams[fileId])
}
sinon.spy(this.FileStoreHandler, 'getFileStream')
this.ProjectZipStreamManager.addAllFilesToArchive(

37
services/web/test/unit/src/Exports/ExportsControllerTests.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-return-assign,
no-unused-vars,
@ -22,23 +21,23 @@ const modulePath = require('path').join(
)
describe('ExportsController', function () {
const project_id = '123njdskj9jlk'
const user_id = '123nd3ijdks'
const brand_variation_id = 22
const projectId = '123njdskj9jlk'
const userId = '123nd3ijdks'
const brandVariationId = 22
const firstName = 'first'
const lastName = 'last'
const title = 'title'
const description = 'description'
const author = 'author'
const license = 'other'
const show_source = true
const showSource = true
beforeEach(function () {
this.handler = { getUserNotifications: sinon.stub().callsArgWith(1) }
this.req = {
params: {
project_id,
brand_variation_id,
project_id: projectId,
brand_variation_id: brandVariationId,
},
body: {
firstName,
@ -46,7 +45,7 @@ describe('ExportsController', function () {
},
session: {
user: {
_id: user_id,
_id: userId,
},
},
i18n: {
@ -77,9 +76,9 @@ describe('ExportsController', function () {
.stub()
.yields(null, { iAmAnExport: true, v1_id: 897 })
const expected = {
project_id,
user_id,
brand_variation_id,
project_id: projectId,
user_id: userId,
brand_variation_id: brandVariationId,
first_name: firstName,
last_name: lastName,
}
@ -101,9 +100,9 @@ describe('ExportsController', function () {
message: 'RESUBMISSION',
})
const expected = {
project_id,
user_id,
brand_variation_id,
project_id: projectId,
user_id: userId,
brand_variation_id: brandVariationId,
first_name: firstName,
last_name: lastName,
}
@ -134,16 +133,16 @@ describe('ExportsController', function () {
.stub()
.yields(null, { iAmAnExport: true, v1_id: 897 })
const expected = {
project_id,
user_id,
brand_variation_id,
project_id: projectId,
user_id: userId,
brand_variation_id: brandVariationId,
first_name: firstName,
last_name: lastName,
title,
description,
author,
license,
show_source,
show_source: showSource,
}
return this.controller.exportProject(this.req, {
json: body => {
@ -184,7 +183,7 @@ describe('ExportsController', function () {
}`
)
this.req.params = { project_id, export_id: 897 }
this.req.params = { project_id: projectId, export_id: 897 }
return this.controller.exportStatus(this.req, {
json: body => {
expect(body).to.deep.equal({

73
services/web/test/unit/src/Exports/ExportsHandlerTests.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-return-assign,
no-unused-vars,
@ -73,8 +72,8 @@ describe('ExportsHandler', function () {
beforeEach(function (done) {
return this.ExportsHandler.exportProject(
this.export_params,
(error, export_data) => {
this.callback(error, export_data)
(error, exportData) => {
this.callback(error, exportData)
return done()
}
)
@ -106,8 +105,8 @@ describe('ExportsHandler', function () {
.yields(new Error('cannot export project without root doc'))
return this.ExportsHandler.exportProject(
this.export_params,
(error, export_data) => {
this.callback(error, export_data)
(error, exportData) => {
this.callback(error, exportData)
return done()
}
)
@ -126,8 +125,8 @@ describe('ExportsHandler', function () {
.yields(null, { forwardResponse: this.error_json })
return this.ExportsHandler.exportProject(
this.export_params,
(error, export_data) => {
this.callback(error, export_data)
(error, exportData) => {
this.callback(error, exportData)
return done()
}
)
@ -188,8 +187,8 @@ describe('ExportsHandler', function () {
beforeEach(function (done) {
return this.ExportsHandler._buildExport(
this.export_params,
(error, export_data) => {
this.callback(error, export_data)
(error, exportData) => {
this.callback(error, exportData)
return done()
}
)
@ -206,7 +205,7 @@ describe('ExportsHandler', function () {
})
it('should return export data', function () {
const expected_export_data = {
const expectedExportData = {
project: {
id: this.project_id,
rootDocPath: this.rootDocPath,
@ -239,7 +238,7 @@ describe('ExportsHandler', function () {
},
}
return this.callback
.calledWith(null, expected_export_data)
.calledWith(null, expectedExportData)
.should.equal(true)
})
})
@ -252,15 +251,15 @@ describe('ExportsHandler', function () {
this.export_params.last_name = this.custom_last_name
return this.ExportsHandler._buildExport(
this.export_params,
(error, export_data) => {
this.callback(error, export_data)
(error, exportData) => {
this.callback(error, exportData)
return done()
}
)
})
it('should send the data from the user input', function () {
const expected_export_data = {
const expectedExportData = {
project: {
id: this.project_id,
rootDocPath: this.rootDocPath,
@ -293,7 +292,7 @@ describe('ExportsHandler', function () {
},
}
return this.callback
.calledWith(null, expected_export_data)
.calledWith(null, expectedExportData)
.should.equal(true)
})
})
@ -305,8 +304,8 @@ describe('ExportsHandler', function () {
.yields(new Error('project not found'))
return this.ExportsHandler._buildExport(
this.export_params,
(error, export_data) => {
this.callback(error, export_data)
(error, exportData) => {
this.callback(error, exportData)
return done()
}
)
@ -326,8 +325,8 @@ describe('ExportsHandler', function () {
.yields(null, [null, { fileSystem: 'other.tex' }])
return this.ExportsHandler._buildExport(
this.export_params,
(error, export_data) => {
this.callback(error, export_data)
(error, exportData) => {
this.callback(error, exportData)
return done()
}
)
@ -340,7 +339,7 @@ describe('ExportsHandler', function () {
})
it('should return export data', function () {
const expected_export_data = {
const expectedExportData = {
project: {
id: this.project_id,
rootDocPath: 'other.tex',
@ -373,7 +372,7 @@ describe('ExportsHandler', function () {
},
}
return this.callback
.calledWith(null, expected_export_data)
.calledWith(null, expectedExportData)
.should.equal(true)
})
})
@ -389,8 +388,8 @@ describe('ExportsHandler', function () {
.yields(null, [null, { fileSystem: 'other.tex' }])
return this.ExportsHandler._buildExport(
this.export_params,
(error, export_data) => {
this.callback(error, export_data)
(error, exportData) => {
this.callback(error, exportData)
return done()
}
)
@ -403,7 +402,7 @@ describe('ExportsHandler', function () {
})
it('should return export data', function () {
const expected_export_data = {
const expectedExportData = {
project: {
id: this.project_id,
rootDocPath: 'other.tex',
@ -436,7 +435,7 @@ describe('ExportsHandler', function () {
},
}
return this.callback
.calledWith(null, expected_export_data)
.calledWith(null, expectedExportData)
.should.equal(true)
})
})
@ -448,8 +447,8 @@ describe('ExportsHandler', function () {
.yields(null, [null, null])
return this.ExportsHandler._buildExport(
this.export_params,
(error, export_data) => {
this.callback(error, export_data)
(error, exportData) => {
this.callback(error, exportData)
return done()
}
)
@ -468,8 +467,8 @@ describe('ExportsHandler', function () {
.yields(new Error('user not found'))
return this.ExportsHandler._buildExport(
this.export_params,
(error, export_data) => {
this.callback(error, export_data)
(error, exportData) => {
this.callback(error, exportData)
return done()
}
)
@ -487,8 +486,8 @@ describe('ExportsHandler', function () {
.yields(new Error('project history call failed'))
return this.ExportsHandler._buildExport(
this.export_params,
(error, export_data) => {
this.callback(error, export_data)
(error, exportData) => {
this.callback(error, exportData)
return done()
}
)
@ -523,8 +522,8 @@ describe('ExportsHandler', function () {
this.stubRequest.post = this.stubPost
return this.ExportsHandler._requestExport(
this.export_data,
(error, export_v1_id) => {
this.callback(error, export_v1_id)
(error, exportV1Id) => {
this.callback(error, exportV1Id)
return done()
}
)
@ -556,8 +555,8 @@ describe('ExportsHandler', function () {
.yields(new Error('export request failed'))
return this.ExportsHandler._requestExport(
this.export_data,
(error, export_v1_id) => {
this.callback(error, export_v1_id)
(error, exportV1Id) => {
this.callback(error, exportV1Id)
return done()
}
)
@ -577,8 +576,8 @@ describe('ExportsHandler', function () {
.yields(null, { statusCode: this.error_code }, this.error_json)
return this.ExportsHandler._requestExport(
this.export_data,
(error, export_v1_id) => {
this.callback(error, export_v1_id)
(error, exportV1Id) => {
this.callback(error, exportV1Id)
return done()
}
)

25
services/web/test/unit/src/Notifications/NotificationsHandlerTests.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
no-return-assign,
@ -22,8 +21,8 @@ const modulePath = require('path').join(
const _ = require('underscore')
describe('NotificationsHandler', function () {
const user_id = '123nd3ijdks'
const notification_id = '123njdskj9jlk'
const userId = '123nd3ijdks'
const notificationId = '123njdskj9jlk'
const notificationUrl = 'notification.sharelatex.testing'
beforeEach(function () {
@ -40,7 +39,7 @@ describe('NotificationsHandler', function () {
describe('getUserNotifications', function () {
it('should get unread notifications', function (done) {
const stubbedNotifications = [{ _id: notification_id, user_id }]
const stubbedNotifications = [{ _id: notificationId, user_id: userId }]
this.request.callsArgWith(
1,
null,
@ -48,11 +47,11 @@ describe('NotificationsHandler', function () {
stubbedNotifications
)
return this.handler.getUserNotifications(
user_id,
userId,
(err, unreadNotifications) => {
stubbedNotifications.should.deep.equal(unreadNotifications)
const getOpts = {
uri: `${notificationUrl}/user/${user_id}`,
uri: `${notificationUrl}/user/${userId}`,
json: true,
timeout: 1000,
method: 'GET',
@ -66,7 +65,7 @@ describe('NotificationsHandler', function () {
it('should return empty arrays if there are no notifications', function () {
this.request.callsArgWith(1, null, { statusCode: 200 }, null)
return this.handler.getUserNotifications(
user_id,
userId,
(err, unreadNotifications) => {
return unreadNotifications.length.should.equal(0)
}
@ -80,9 +79,9 @@ describe('NotificationsHandler', function () {
})
it('should send a delete request when a delete has been received to mark a notification', function (done) {
return this.handler.markAsReadWithKey(user_id, this.key, () => {
return this.handler.markAsReadWithKey(userId, this.key, () => {
const opts = {
uri: `${notificationUrl}/user/${user_id}`,
uri: `${notificationUrl}/user/${userId}`,
json: {
key: this.key,
},
@ -105,14 +104,14 @@ describe('NotificationsHandler', function () {
it('should post the message over', function (done) {
return this.handler.createNotification(
user_id,
userId,
this.key,
this.templateKey,
this.messageOpts,
this.expiry,
() => {
const args = this.request.args[0][0]
args.uri.should.equal(`${notificationUrl}/user/${user_id}`)
args.uri.should.equal(`${notificationUrl}/user/${userId}`)
args.timeout.should.equal(1000)
const expectedJson = {
key: this.key,
@ -136,14 +135,14 @@ describe('NotificationsHandler', function () {
it('should post the message over with expiry field', function (done) {
return this.handler.createNotification(
user_id,
userId,
this.key,
this.templateKey,
this.messageOpts,
this.expiry,
() => {
const args = this.request.args[0][0]
args.uri.should.equal(`${notificationUrl}/user/${user_id}`)
args.uri.should.equal(`${notificationUrl}/user/${userId}`)
args.timeout.should.equal(1000)
const expectedJson = {
key: this.key,

23
services/web/test/unit/src/Project/ProjectHistoryHandlerTests.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
max-len,
no-return-assign,
no-unused-vars,
@ -18,7 +17,7 @@ const modulePath = '../../../../app/src/Features/Project/ProjectHistoryHandler'
const SandboxedModule = require('sandboxed-module')
describe('ProjectHistoryHandler', function () {
const project_id = '4eecb1c1bffa66588e0000a1'
const projectId = '4eecb1c1bffa66588e0000a1'
const userId = 1234
beforeEach(function () {
@ -30,7 +29,7 @@ describe('ProjectHistoryHandler', function () {
}
constructor(options) {
this._id = project_id
this._id = projectId
this.name = 'project_name_here'
this.rev = 0
}
@ -71,20 +70,20 @@ describe('ProjectHistoryHandler', function () {
beforeEach(function () {
this.ProjectDetailsHandler.getDetails = sinon
.stub()
.withArgs(project_id)
.withArgs(projectId)
.callsArgWith(1, null, this.project)
this.ProjectModel.updateOne = sinon
.stub()
.callsArgWith(2, null, { matchedCount: 1 })
return this.ProjectHistoryHandler.ensureHistoryExistsForProject(
project_id,
projectId,
this.callback
)
})
it('should get any existing history id for the project', function () {
return this.ProjectDetailsHandler.getDetails
.calledWith(project_id)
.calledWith(projectId)
.should.equal(true)
})
@ -95,7 +94,7 @@ describe('ProjectHistoryHandler', function () {
it('should set the new history id on the project', function () {
return this.ProjectModel.updateOne
.calledWith(
{ _id: project_id, 'overleaf.history.id': { $exists: false } },
{ _id: projectId, 'overleaf.history.id': { $exists: false } },
{ 'overleaf.history.id': this.historyId }
)
.should.equal(true)
@ -103,13 +102,13 @@ describe('ProjectHistoryHandler', function () {
it('should resync the project history', function () {
return this.ProjectEntityUpdateHandler.resyncProjectHistory
.calledWith(project_id)
.calledWith(projectId)
.should.equal(true)
})
it('should flush the project history', function () {
return this.HistoryManager.flushProject
.calledWith(project_id)
.calledWith(projectId)
.should.equal(true)
})
@ -123,18 +122,18 @@ describe('ProjectHistoryHandler', function () {
this.project.overleaf = { history: { id: 1234 } }
this.ProjectDetailsHandler.getDetails = sinon
.stub()
.withArgs(project_id)
.withArgs(projectId)
.callsArgWith(1, null, this.project)
this.ProjectModel.updateOne = sinon.stub()
return this.ProjectHistoryHandler.ensureHistoryExistsForProject(
project_id,
projectId,
this.callback
)
})
it('should get any existing history id for the project', function () {
return this.ProjectDetailsHandler.getDetails
.calledWith(project_id)
.calledWith(projectId)
.should.equal(true)
})

49
services/web/test/unit/src/Project/ProjectOptionsHandlerTests.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
no-return-assign,
@ -20,7 +19,7 @@ const modulePath =
const SandboxedModule = require('sandboxed-module')
describe('ProjectOptionsHandler', function () {
const project_id = '4eecaffcbffa66588e000008'
const projectId = '4eecaffcbffa66588e000008'
beforeEach(function () {
let Project
@ -49,16 +48,16 @@ describe('ProjectOptionsHandler', function () {
describe('Setting the compiler', function () {
it('should perform and update on mongo', function (done) {
this.handler.setCompiler(project_id, 'xeLaTeX', err => {
this.handler.setCompiler(projectId, 'xeLaTeX', err => {
const args = this.projectModel.updateOne.args[0]
args[0]._id.should.equal(project_id)
args[0]._id.should.equal(projectId)
args[1].compiler.should.equal('xelatex')
done()
})
})
it('should not perform and update on mongo if it is not a recognised compiler', function (done) {
this.handler.setCompiler(project_id, 'something', err => {
this.handler.setCompiler(projectId, 'something', err => {
this.projectModel.updateOne.called.should.equal(false)
done()
})
@ -66,7 +65,7 @@ describe('ProjectOptionsHandler', function () {
describe('when called without arg', function () {
it('should callback with null', function (done) {
this.handler.setCompiler(project_id, null, err => {
this.handler.setCompiler(projectId, null, err => {
expect(err).to.be.undefined
this.projectModel.updateOne.callCount.should.equal(0)
done()
@ -80,7 +79,7 @@ describe('ProjectOptionsHandler', function () {
})
it('should callback with error', function (done) {
this.handler.setCompiler(project_id, 'xeLaTeX', err => {
this.handler.setCompiler(projectId, 'xeLaTeX', err => {
err.should.equal('error')
done()
})
@ -90,16 +89,16 @@ describe('ProjectOptionsHandler', function () {
describe('Setting the imageName', function () {
it('should perform and update on mongo', function (done) {
this.handler.setImageName(project_id, 'texlive-1234.5', err => {
this.handler.setImageName(projectId, 'texlive-1234.5', err => {
const args = this.projectModel.updateOne.args[0]
args[0]._id.should.equal(project_id)
args[0]._id.should.equal(projectId)
args[1].imageName.should.equal('docker-repo/subdir/texlive-1234.5')
done()
})
})
it('should not perform and update on mongo if it is not a reconised compiler', function (done) {
this.handler.setImageName(project_id, 'something', err => {
this.handler.setImageName(projectId, 'something', err => {
this.projectModel.updateOne.called.should.equal(false)
done()
})
@ -107,7 +106,7 @@ describe('ProjectOptionsHandler', function () {
describe('when called without arg', function () {
it('should callback with null', function (done) {
this.handler.setImageName(project_id, null, err => {
this.handler.setImageName(projectId, null, err => {
expect(err).to.be.undefined
this.projectModel.updateOne.callCount.should.equal(0)
done()
@ -121,7 +120,7 @@ describe('ProjectOptionsHandler', function () {
})
it('should callback with error', function (done) {
this.handler.setImageName(project_id, 'texlive-1234.5', err => {
this.handler.setImageName(projectId, 'texlive-1234.5', err => {
err.should.equal('error')
done()
})
@ -131,23 +130,23 @@ describe('ProjectOptionsHandler', function () {
describe('setting the spellCheckLanguage', function () {
it('should perform and update on mongo', function (done) {
this.handler.setSpellCheckLanguage(project_id, 'fr', err => {
this.handler.setSpellCheckLanguage(projectId, 'fr', err => {
const args = this.projectModel.updateOne.args[0]
args[0]._id.should.equal(project_id)
args[0]._id.should.equal(projectId)
args[1].spellCheckLanguage.should.equal('fr')
done()
})
})
it('should not perform and update on mongo if it is not a reconised compiler', function (done) {
this.handler.setSpellCheckLanguage(project_id, 'no a lang', err => {
this.handler.setSpellCheckLanguage(projectId, 'no a lang', err => {
this.projectModel.updateOne.called.should.equal(false)
done()
})
})
it('should perform and update on mongo if the language is blank (means turn it off)', function (done) {
this.handler.setSpellCheckLanguage(project_id, '', err => {
this.handler.setSpellCheckLanguage(projectId, '', err => {
this.projectModel.updateOne.called.should.equal(true)
done()
})
@ -159,7 +158,7 @@ describe('ProjectOptionsHandler', function () {
})
it('should callback with error', function (done) {
this.handler.setSpellCheckLanguage(project_id, 'fr', err => {
this.handler.setSpellCheckLanguage(projectId, 'fr', err => {
err.should.equal('error')
done()
})
@ -169,23 +168,23 @@ describe('ProjectOptionsHandler', function () {
describe('setting the brandVariationId', function () {
it('should perform and update on mongo', function (done) {
this.handler.setBrandVariationId(project_id, '123', err => {
this.handler.setBrandVariationId(projectId, '123', err => {
const args = this.projectModel.updateOne.args[0]
args[0]._id.should.equal(project_id)
args[0]._id.should.equal(projectId)
args[1].brandVariationId.should.equal('123')
done()
})
})
it('should not perform and update on mongo if there is no brand variation', function (done) {
this.handler.setBrandVariationId(project_id, null, err => {
this.handler.setBrandVariationId(projectId, null, err => {
this.projectModel.updateOne.called.should.equal(false)
done()
})
})
it('should not perform and update on mongo if brand variation is an empty string', function (done) {
this.handler.setBrandVariationId(project_id, '', err => {
this.handler.setBrandVariationId(projectId, '', err => {
this.projectModel.updateOne.called.should.equal(false)
done()
})
@ -197,7 +196,7 @@ describe('ProjectOptionsHandler', function () {
})
it('should callback with error', function (done) {
this.handler.setBrandVariationId(project_id, '123', err => {
this.handler.setBrandVariationId(projectId, '123', err => {
err.should.equal('error')
done()
})
@ -207,9 +206,9 @@ describe('ProjectOptionsHandler', function () {
describe('unsetting the brandVariationId', function () {
it('should perform and update on mongo', function (done) {
this.handler.unsetBrandVariationId(project_id, err => {
this.handler.unsetBrandVariationId(projectId, err => {
const args = this.projectModel.updateOne.args[0]
args[0]._id.should.equal(project_id)
args[0]._id.should.equal(projectId)
expect(args[1]).to.deep.equal({ $unset: { brandVariationId: 1 } })
done()
})
@ -221,7 +220,7 @@ describe('ProjectOptionsHandler', function () {
})
it('should callback with error', function (done) {
this.handler.unsetBrandVariationId(project_id, err => {
this.handler.unsetBrandVariationId(projectId, err => {
err.should.equal('error')
done()
})

19
services/web/test/unit/src/Project/ProjectUpdateHandlerTests.js
View file

@ -1,5 +1,4 @@
/* eslint-disable
camelcase,
n/handle-callback-err,
max-len,
no-return-assign,
@ -83,10 +82,10 @@ describe('ProjectUpdateHandler', function () {
describe('markAsOpened', function () {
it('should send an update to mongo', function (done) {
const project_id = 'project_id'
return this.handler.markAsOpened(project_id, err => {
const projectId = 'project_id'
return this.handler.markAsOpened(projectId, err => {
const args = this.ProjectModel.updateOne.args[0]
args[0]._id.should.equal(project_id)
args[0]._id.should.equal(projectId)
const date = args[1].lastOpened + ''
const now = Date.now() + ''
date.substring(0, 5).should.equal(now.substring(0, 5))
@ -97,10 +96,10 @@ describe('ProjectUpdateHandler', function () {
describe('markAsInactive', function () {
it('should send an update to mongo', function (done) {
const project_id = 'project_id'
return this.handler.markAsInactive(project_id, err => {
const projectId = 'project_id'
return this.handler.markAsInactive(projectId, err => {
const args = this.ProjectModel.updateOne.args[0]
args[0]._id.should.equal(project_id)
args[0]._id.should.equal(projectId)
args[1].active.should.equal(false)
return done()
})
@ -109,10 +108,10 @@ describe('ProjectUpdateHandler', function () {
describe('markAsActive', function () {
it('should send an update to mongo', function (done) {
const project_id = 'project_id'
return this.handler.markAsActive(project_id, err => {
const projectId = 'project_id'
return this.handler.markAsActive(projectId, err => {
const args = this.ProjectModel.updateOne.args[0]
args[0]._id.should.equal(project_id)
args[0]._id.should.equal(projectId)
args[1].active.should.equal(true)
return done()
})