mirror of
https://github.com/overleaf/overleaf.git
synced 2024-11-21 20:47:08 -05:00
a6f05109a3
[misc] fix eslint violations for `no-var` GitOrigin-RevId: c52e82f3a8a993b8662cc5aa56e7b95ca3c55832
922 lines
24 KiB
JavaScript
922 lines
24 KiB
JavaScript
import _ from 'lodash'
|
|
import App from '../../base'
|
|
import './services/project-list'
|
|
App.controller('ProjectPageController', function (
|
|
$scope,
|
|
$modal,
|
|
$window,
|
|
queuedHttp,
|
|
eventTracking, // eslint-disable-line camelcase
|
|
$timeout,
|
|
localStorage,
|
|
ProjectListService
|
|
) {
|
|
$scope.projects = window.data.projects
|
|
$scope.tags = window.data.tags
|
|
$scope.notifications = window.data.notifications
|
|
$scope.notificationsInstitution = window.data.notificationsInstitution
|
|
$scope.allSelected = false
|
|
$scope.selectedProjects = []
|
|
$scope.filter = 'all'
|
|
$scope.predicate = 'lastUpdated'
|
|
$scope.nUntagged = 0
|
|
$scope.reverse = true
|
|
$scope.searchText = { value: '' }
|
|
$scope.$watch('predicate', function (newValue) {
|
|
$scope.comparator =
|
|
newValue === 'ownerName' ? ownerNameComparator : defaultComparator
|
|
})
|
|
|
|
$timeout(() => recalculateProjectListHeight(), 10)
|
|
|
|
$scope.$watch(
|
|
() =>
|
|
$scope.projects.filter(
|
|
project =>
|
|
(project.tags == null || project.tags.length === 0) &&
|
|
!project.archived &&
|
|
!project.trashed
|
|
).length,
|
|
newVal => ($scope.nUntagged = newVal)
|
|
)
|
|
|
|
function recalculateProjectListHeight() {
|
|
const $projListCard = $('.project-list-card')
|
|
if (!$projListCard || !$projListCard.offset()) return
|
|
|
|
const topOffset = $projListCard.offset().top
|
|
const cardPadding = $projListCard.outerHeight() - $projListCard.height()
|
|
const bottomOffset = $('footer').outerHeight()
|
|
const height = $window.innerHeight - topOffset - bottomOffset - cardPadding
|
|
$scope.projectListHeight = height
|
|
}
|
|
|
|
function defaultComparator(v1, v2) {
|
|
let result = 0
|
|
const type1 = v1.type
|
|
const type2 = v2.type
|
|
|
|
if ($scope.predicate === 'ownerName') {
|
|
return
|
|
}
|
|
|
|
if (type1 === type2) {
|
|
let value1 = v1.value
|
|
let value2 = v2.value
|
|
|
|
if (type1 === 'string') {
|
|
// Compare strings case-insensitively
|
|
value1 = value1.toLowerCase()
|
|
value2 = value2.toLowerCase()
|
|
} else if (type1 === 'object') {
|
|
// For basic objects, use the position of the object
|
|
// in the collection instead of the value
|
|
if (angular.isObject(value1)) value1 = v1.index
|
|
if (angular.isObject(value2)) value2 = v2.index
|
|
}
|
|
|
|
if (value1 !== value2) {
|
|
result = value1 < value2 ? -1 : 1
|
|
}
|
|
} else {
|
|
result = type1 < type2 ? -1 : 1
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
function ownerNameComparator(v1, v2) {
|
|
if ($scope.predicate !== 'ownerName') {
|
|
return
|
|
}
|
|
if (v1.value === 'You') {
|
|
if (v2.value === 'You') {
|
|
return v1.index < v2.index ? -1 : 1
|
|
} else {
|
|
return 1
|
|
}
|
|
} else if (v1.value === 'An Overleaf v1 User' || v1.value === 'None') {
|
|
if (v2.value === 'An Overleaf v1 User' || v2.value === 'None') {
|
|
return v1.index < v2.index ? -1 : 1
|
|
} else {
|
|
return -1
|
|
}
|
|
} else {
|
|
if (v2.value === 'You') {
|
|
return -1
|
|
} else if (v2.value === 'An Overleaf v1 User' || v2.value === 'None') {
|
|
return 1
|
|
} else {
|
|
return v1.value > v2.value ? -1 : 1
|
|
}
|
|
}
|
|
}
|
|
|
|
angular.element($window).bind('resize', function () {
|
|
recalculateProjectListHeight()
|
|
$scope.$apply()
|
|
})
|
|
|
|
$scope.$on('project-list:notifications-received', () =>
|
|
$scope.$applyAsync(() => recalculateProjectListHeight())
|
|
)
|
|
|
|
// Allow tags to be accessed on projects as well
|
|
const projectsById = {}
|
|
for (const project of $scope.projects) {
|
|
projectsById[project.id] = project
|
|
}
|
|
|
|
$scope.getProjectById = id => projectsById[id]
|
|
|
|
for (const tag of $scope.tags) {
|
|
for (const projectId of tag.project_ids || []) {
|
|
const project = projectsById[projectId]
|
|
if (project) {
|
|
if (!project.tags) {
|
|
project.tags = []
|
|
}
|
|
project.tags.push(tag)
|
|
}
|
|
}
|
|
}
|
|
|
|
$scope.changePredicate = function (newPredicate) {
|
|
if ($scope.predicate === newPredicate) {
|
|
$scope.reverse = !$scope.reverse
|
|
}
|
|
$scope.predicate = newPredicate
|
|
}
|
|
|
|
$scope.getSortIconClass = function (column) {
|
|
if (column === $scope.predicate && $scope.reverse) {
|
|
return 'fa-caret-down'
|
|
} else if (column === $scope.predicate && !$scope.reverse) {
|
|
return 'fa-caret-up'
|
|
} else {
|
|
return ''
|
|
}
|
|
}
|
|
|
|
$scope.searchProjects = function () {
|
|
eventTracking.send(
|
|
'project-list-page-interaction',
|
|
'project-search',
|
|
'keydown'
|
|
)
|
|
$scope.updateVisibleProjects()
|
|
}
|
|
|
|
$scope.clearSearchText = function () {
|
|
$scope.searchText.value = ''
|
|
$scope.filter = 'all'
|
|
$scope.$emit('search:clear')
|
|
$scope.updateVisibleProjects()
|
|
}
|
|
|
|
$scope.setFilter = function (filter) {
|
|
$scope.filter = filter
|
|
$scope.updateVisibleProjects()
|
|
}
|
|
|
|
$scope.updateSelectedProjects = function () {
|
|
$scope.selectedProjects = $scope.projects.filter(
|
|
project => project.selected
|
|
)
|
|
}
|
|
|
|
$scope.getSelectedProjects = () => $scope.selectedProjects
|
|
|
|
$scope.getSelectedProjectIds = () =>
|
|
$scope.selectedProjects.map(project => project.id)
|
|
|
|
$scope.getFirstSelectedProject = () => $scope.selectedProjects[0]
|
|
|
|
$scope.hasLeavableProjectsSelected = () =>
|
|
_.some(
|
|
$scope.getSelectedProjects(),
|
|
project => project.accessLevel !== 'owner' && project.trashed
|
|
)
|
|
|
|
$scope.hasDeletableProjectsSelected = () =>
|
|
_.some(
|
|
$scope.getSelectedProjects(),
|
|
project => project.accessLevel === 'owner' && project.trashed
|
|
)
|
|
|
|
$scope.updateVisibleProjects = function () {
|
|
$scope.visibleProjects = []
|
|
const selectedTag = $scope.getSelectedTag()
|
|
for (const project of $scope.projects) {
|
|
let visible = true
|
|
// Only show if it matches any search text
|
|
if ($scope.searchText.value !== '') {
|
|
if (
|
|
project.name
|
|
.toLowerCase()
|
|
.indexOf($scope.searchText.value.toLowerCase()) === -1
|
|
) {
|
|
visible = false
|
|
}
|
|
}
|
|
// Only show if it matches the selected tag
|
|
if (
|
|
$scope.filter === 'tag' &&
|
|
selectedTag != null &&
|
|
!selectedTag.project_ids.includes(project.id)
|
|
) {
|
|
visible = false
|
|
}
|
|
|
|
// Hide tagged projects if we only want to see the uncategorized ones
|
|
if (
|
|
$scope.filter === 'untagged' &&
|
|
(project.tags != null ? project.tags.length : undefined) > 0
|
|
) {
|
|
visible = false
|
|
}
|
|
|
|
// Hide projects we own if we only want to see shared projects
|
|
if ($scope.filter === 'shared' && project.accessLevel === 'owner') {
|
|
visible = false
|
|
}
|
|
|
|
// Hide projects we don't own if we only want to see owned projects
|
|
if ($scope.filter === 'owned' && project.accessLevel !== 'owner') {
|
|
visible = false
|
|
}
|
|
|
|
if ($scope.filter === 'archived') {
|
|
// Only show archived projects
|
|
if (!project.archived) {
|
|
visible = false
|
|
}
|
|
} else {
|
|
// Only show non-archived projects
|
|
if (project.archived) {
|
|
visible = false
|
|
}
|
|
}
|
|
|
|
if ($scope.filter === 'trashed') {
|
|
// Only show trashed projects
|
|
if (!project.trashed) {
|
|
visible = false
|
|
}
|
|
} else {
|
|
// Only show non-trashed projects
|
|
if (project.trashed) {
|
|
visible = false
|
|
}
|
|
}
|
|
|
|
if (visible) {
|
|
$scope.visibleProjects.push(project)
|
|
} else {
|
|
// We don't want hidden selections
|
|
project.selected = false
|
|
}
|
|
}
|
|
|
|
localStorage(
|
|
'project_list',
|
|
JSON.stringify({
|
|
filter: $scope.filter,
|
|
selectedTagId: selectedTag != null ? selectedTag._id : undefined,
|
|
})
|
|
)
|
|
$scope.updateSelectedProjects()
|
|
}
|
|
|
|
$scope.getSelectedTag = function () {
|
|
for (const tag of $scope.tags) {
|
|
if (tag.selected) {
|
|
return tag
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
$scope._removeProjectIdsFromTagArray = function (tag, removeProjectIds) {
|
|
// Remove project_id from tag.project_ids
|
|
const remainingProjectIds = []
|
|
const removedProjectIds = []
|
|
for (const projectId of tag.project_ids) {
|
|
if (!removeProjectIds.includes(projectId)) {
|
|
remainingProjectIds.push(projectId)
|
|
} else {
|
|
removedProjectIds.push(projectId)
|
|
}
|
|
}
|
|
tag.project_ids = remainingProjectIds
|
|
return removedProjectIds
|
|
}
|
|
|
|
$scope._removeProjectFromList = function (project) {
|
|
const index = $scope.projects.indexOf(project)
|
|
if (index > -1) {
|
|
$scope.projects.splice(index, 1)
|
|
}
|
|
}
|
|
|
|
$scope.removeSelectedProjectsFromTag = function (tag) {
|
|
tag.showWhenEmpty = true
|
|
|
|
const selectedProjectIds = $scope.getSelectedProjectIds()
|
|
const selectedProjects = $scope.getSelectedProjects()
|
|
|
|
const removedProjectIds = $scope._removeProjectIdsFromTagArray(
|
|
tag,
|
|
selectedProjectIds
|
|
)
|
|
|
|
// Remove tag from project.tags
|
|
for (const project of selectedProjects) {
|
|
if (!project.tags) {
|
|
project.tags = []
|
|
}
|
|
const index = project.tags.indexOf(tag)
|
|
if (index > -1) {
|
|
project.tags.splice(index, 1)
|
|
}
|
|
}
|
|
|
|
for (const projectId of removedProjectIds) {
|
|
queuedHttp({
|
|
method: 'DELETE',
|
|
url: `/tag/${tag._id}/project/${projectId}`,
|
|
headers: {
|
|
'X-CSRF-Token': window.csrfToken,
|
|
},
|
|
})
|
|
}
|
|
|
|
// If we're filtering by this tag then we need to remove
|
|
// the projects from view
|
|
$scope.updateVisibleProjects()
|
|
}
|
|
|
|
$scope.removeProjectFromTag = function (project, tag) {
|
|
tag.showWhenEmpty = true
|
|
|
|
if (!project.tags) {
|
|
project.tags = []
|
|
}
|
|
const index = project.tags.indexOf(tag)
|
|
|
|
if (index > -1) {
|
|
$scope._removeProjectIdsFromTagArray(tag, [project.id])
|
|
project.tags.splice(index, 1)
|
|
queuedHttp({
|
|
method: 'DELETE',
|
|
url: `/tag/${tag._id}/project/${project.id}`,
|
|
headers: {
|
|
'X-CSRF-Token': window.csrfToken,
|
|
},
|
|
})
|
|
$scope.updateVisibleProjects()
|
|
}
|
|
}
|
|
|
|
$scope.addSelectedProjectsToTag = function (tag) {
|
|
const selectedProjects = $scope.getSelectedProjects()
|
|
eventTracking.send(
|
|
'project-list-page-interaction',
|
|
'project action',
|
|
'addSelectedProjectsToTag'
|
|
)
|
|
|
|
// Add project_ids into tag.project_ids
|
|
const addedProjectIds = []
|
|
for (const projectId of $scope.getSelectedProjectIds()) {
|
|
if (!tag.project_ids.includes(projectId)) {
|
|
tag.project_ids.push(projectId)
|
|
addedProjectIds.push(projectId)
|
|
}
|
|
}
|
|
|
|
// Add tag into each project.tags
|
|
for (const project of selectedProjects) {
|
|
if (!project.tags) {
|
|
project.tags = []
|
|
}
|
|
if (!project.tags.includes(tag)) {
|
|
project.tags.push(tag)
|
|
}
|
|
}
|
|
|
|
for (const projectId of addedProjectIds) {
|
|
queuedHttp.post(`/tag/${tag._id}/project/${projectId}`, {
|
|
_csrf: window.csrfToken,
|
|
})
|
|
}
|
|
}
|
|
|
|
$scope.openNewTagModal = function (e) {
|
|
const modalInstance = $modal.open({
|
|
templateUrl: 'newTagModalTemplate',
|
|
controller: 'NewTagModalController',
|
|
})
|
|
|
|
modalInstance.result.then(function (tag) {
|
|
const tagIsDuplicate = $scope.tags.find(function (existingTag) {
|
|
return tag.name === existingTag.name
|
|
})
|
|
|
|
if (!tagIsDuplicate) {
|
|
$scope.tags.push(tag)
|
|
$scope.addSelectedProjectsToTag(tag)
|
|
}
|
|
})
|
|
}
|
|
|
|
$scope.createProject = function (name, template) {
|
|
if (template == null) {
|
|
template = 'none'
|
|
}
|
|
return queuedHttp
|
|
.post('/project/new', {
|
|
_csrf: window.csrfToken,
|
|
projectName: name,
|
|
template,
|
|
})
|
|
.then(function (response) {
|
|
const { data } = response
|
|
$scope.projects.push({
|
|
name,
|
|
id: data.project_id,
|
|
accessLevel: 'owner',
|
|
owner: data.owner,
|
|
// TODO: Check access level if correct after adding it in
|
|
// to the rest of the app
|
|
})
|
|
$scope.updateVisibleProjects()
|
|
})
|
|
}
|
|
|
|
$scope.openCreateProjectModal = function (template) {
|
|
if (template == null) {
|
|
template = 'none'
|
|
}
|
|
eventTracking.send('project-list-page-interaction', 'new-project', template)
|
|
const modalInstance = $modal.open({
|
|
templateUrl: 'newProjectModalTemplate',
|
|
controller: 'NewProjectModalController',
|
|
resolve: {
|
|
template() {
|
|
return template
|
|
},
|
|
},
|
|
scope: $scope,
|
|
})
|
|
|
|
modalInstance.result.then(
|
|
projectId => (window.location = `/project/${projectId}`)
|
|
)
|
|
}
|
|
|
|
$scope.renameProject = (project, newName) =>
|
|
queuedHttp
|
|
.post(`/project/${project.id}/rename`, {
|
|
newProjectName: newName,
|
|
_csrf: window.csrfToken,
|
|
})
|
|
.then(() => (project.name = newName))
|
|
|
|
$scope.openRenameProjectModal = function () {
|
|
const project = $scope.getFirstSelectedProject()
|
|
if (!project || project.accessLevel !== 'owner') {
|
|
return
|
|
}
|
|
eventTracking.send(
|
|
'project-list-page-interaction',
|
|
'project action',
|
|
'Rename'
|
|
)
|
|
$modal.open({
|
|
templateUrl: 'renameProjectModalTemplate',
|
|
controller: 'RenameProjectModalController',
|
|
resolve: {
|
|
project() {
|
|
return project
|
|
},
|
|
},
|
|
scope: $scope,
|
|
})
|
|
}
|
|
|
|
$scope.cloneProject = function (project, cloneName) {
|
|
eventTracking.send(
|
|
'project-list-page-interaction',
|
|
'project action',
|
|
'Clone'
|
|
)
|
|
return queuedHttp
|
|
.post(`/project/${project.id}/clone`, {
|
|
_csrf: window.csrfToken,
|
|
projectName: cloneName,
|
|
})
|
|
.then(function (response) {
|
|
const { data } = response
|
|
$scope.projects.push({
|
|
name: data.name,
|
|
id: data.project_id,
|
|
accessLevel: 'owner',
|
|
owner: data.owner,
|
|
// TODO: Check access level if correct after adding it in
|
|
// to the rest of the app
|
|
})
|
|
$scope.updateVisibleProjects()
|
|
})
|
|
}
|
|
|
|
$scope.openCloneProjectModal = function (project) {
|
|
if (!project) {
|
|
return
|
|
}
|
|
|
|
$modal.open({
|
|
templateUrl: 'cloneProjectModalTemplate',
|
|
controller: 'CloneProjectModalController',
|
|
resolve: {
|
|
project() {
|
|
return project
|
|
},
|
|
},
|
|
scope: $scope,
|
|
})
|
|
}
|
|
|
|
// Methods to create modals for archiving, trashing, leaving and deleting projects
|
|
const _createArchiveTrashLeaveOrDeleteProjectsModal = function (
|
|
action,
|
|
projects
|
|
) {
|
|
eventTracking.send(
|
|
'project-list-page-interaction',
|
|
'project action',
|
|
action
|
|
)
|
|
return $modal.open({
|
|
templateUrl: 'archiveTrashLeaveOrDeleteProjectsModalTemplate',
|
|
controller: 'ArchiveTrashLeaveOrDeleteProjectsModalController',
|
|
resolve: {
|
|
projects() {
|
|
return projects
|
|
},
|
|
action() {
|
|
return action
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
$scope.createArchiveProjectsModal = function (projects) {
|
|
return _createArchiveTrashLeaveOrDeleteProjectsModal('archive', projects)
|
|
}
|
|
|
|
$scope.createTrashProjectsModal = function (projects) {
|
|
return _createArchiveTrashLeaveOrDeleteProjectsModal('trash', projects)
|
|
}
|
|
|
|
$scope.createLeaveProjectsModal = function (projects) {
|
|
return _createArchiveTrashLeaveOrDeleteProjectsModal('leave', projects)
|
|
}
|
|
|
|
$scope.createDeleteProjectsModal = function (projects) {
|
|
return _createArchiveTrashLeaveOrDeleteProjectsModal('delete', projects)
|
|
}
|
|
|
|
$scope.createLeaveOrDeleteProjectsModal = function (projects) {
|
|
return _createArchiveTrashLeaveOrDeleteProjectsModal(
|
|
'leaveOrDelete',
|
|
projects
|
|
)
|
|
}
|
|
|
|
//
|
|
$scope.openArchiveProjectsModal = function () {
|
|
const modalInstance = $scope.createArchiveProjectsModal(
|
|
$scope.getSelectedProjects()
|
|
)
|
|
modalInstance.result.then(() => $scope.archiveSelectedProjects())
|
|
}
|
|
|
|
$scope.openTrashProjectsModal = function () {
|
|
const modalInstance = $scope.createTrashProjectsModal(
|
|
$scope.getSelectedProjects()
|
|
)
|
|
|
|
modalInstance.result.then(() => $scope.trashSelectedProjects())
|
|
}
|
|
|
|
$scope.openLeaveProjectsModal = function () {
|
|
const modalInstance = $scope.createLeaveProjectsModal(
|
|
$scope.getSelectedProjects()
|
|
)
|
|
modalInstance.result.then(() => $scope.leaveSelectedProjects())
|
|
}
|
|
|
|
$scope.openDeleteProjectsModal = function () {
|
|
const modalInstance = $scope.createDeleteProjectsModal(
|
|
$scope.getSelectedProjects()
|
|
)
|
|
modalInstance.result.then(() => $scope.deleteSelectedProjects())
|
|
}
|
|
|
|
$scope.openLeaveOrDeleteProjectsModal = function () {
|
|
const modalInstance = $scope.createLeaveOrDeleteProjectsModal(
|
|
$scope.getSelectedProjects()
|
|
)
|
|
modalInstance.result.then(() => $scope.leaveOrDeleteSelectedProjects())
|
|
}
|
|
|
|
//
|
|
$scope.archiveSelectedProjects = () =>
|
|
$scope.archiveProjects($scope.getSelectedProjects())
|
|
|
|
$scope.unarchiveSelectedProjects = () =>
|
|
$scope.unarchiveProjects($scope.getSelectedProjects())
|
|
|
|
$scope.trashSelectedProjects = () =>
|
|
$scope.trashProjects($scope.getSelectedProjects())
|
|
|
|
$scope.untrashSelectedProjects = () =>
|
|
$scope.untrashProjects($scope.getSelectedProjects())
|
|
|
|
$scope.leaveSelectedProjects = () =>
|
|
$scope.leaveProjects($scope.getSelectedProjects())
|
|
|
|
$scope.deleteSelectedProjects = () =>
|
|
$scope.deleteProjects($scope.getSelectedProjects())
|
|
|
|
$scope.leaveOrDeleteSelectedProjects = () =>
|
|
$scope.leaveOrDeleteProjects($scope.getSelectedProjects())
|
|
|
|
//
|
|
$scope.archiveProjects = function (projects) {
|
|
for (const project of projects) {
|
|
project.archived = true
|
|
project.trashed = false
|
|
_archiveProject(project)
|
|
}
|
|
$scope.updateVisibleProjects()
|
|
}
|
|
|
|
$scope.unarchiveProjects = function (projects) {
|
|
for (const project of projects) {
|
|
project.archived = false
|
|
_unarchiveProject(project)
|
|
}
|
|
$scope.updateVisibleProjects()
|
|
}
|
|
|
|
$scope.trashProjects = function (projects) {
|
|
for (const project of projects) {
|
|
project.trashed = true
|
|
project.archived = false
|
|
_trashProject(project)
|
|
}
|
|
$scope.updateVisibleProjects()
|
|
}
|
|
|
|
$scope.untrashProjects = function (projects) {
|
|
for (const project of projects) {
|
|
project.trashed = false
|
|
_untrashProject(project)
|
|
}
|
|
$scope.updateVisibleProjects()
|
|
}
|
|
|
|
$scope.leaveProjects = function (projects) {
|
|
_deleteOrLeaveProjectsLocally(projects)
|
|
for (const project of projects) {
|
|
_leaveProject(project)
|
|
}
|
|
$scope.updateVisibleProjects()
|
|
}
|
|
|
|
$scope.deleteProjects = function (projects) {
|
|
_deleteOrLeaveProjectsLocally(projects)
|
|
for (const project of projects) {
|
|
_deleteProject(project)
|
|
}
|
|
$scope.updateVisibleProjects()
|
|
}
|
|
|
|
$scope.leaveOrDeleteProjects = function (projects) {
|
|
_deleteOrLeaveProjectsLocally(projects)
|
|
for (const project of projects) {
|
|
if (project.accessLevel === 'owner') {
|
|
_deleteProject(project)
|
|
} else {
|
|
_leaveProject(project)
|
|
}
|
|
}
|
|
$scope.updateVisibleProjects()
|
|
}
|
|
|
|
// Actual interaction with the backend---we could move this into a service
|
|
const _archiveProject = function (project) {
|
|
return queuedHttp({
|
|
method: 'POST',
|
|
url: `/project/${project.id}/archive`,
|
|
headers: {
|
|
'X-CSRF-Token': window.csrfToken,
|
|
},
|
|
})
|
|
}
|
|
|
|
const _unarchiveProject = function (project) {
|
|
return queuedHttp({
|
|
method: 'DELETE',
|
|
url: `/project/${project.id}/archive`,
|
|
headers: {
|
|
'X-CSRF-Token': window.csrfToken,
|
|
},
|
|
})
|
|
}
|
|
|
|
const _trashProject = function (project) {
|
|
return queuedHttp({
|
|
method: 'POST',
|
|
url: `/project/${project.id}/trash`,
|
|
headers: {
|
|
'X-CSRF-Token': window.csrfToken,
|
|
},
|
|
})
|
|
}
|
|
|
|
const _untrashProject = function (project) {
|
|
return queuedHttp({
|
|
method: 'DELETE',
|
|
url: `/project/${project.id}/trash`,
|
|
headers: {
|
|
'X-CSRF-Token': window.csrfToken,
|
|
},
|
|
})
|
|
}
|
|
|
|
const _leaveProject = function (project) {
|
|
return queuedHttp({
|
|
method: 'POST',
|
|
url: `/project/${project.id}/leave`,
|
|
headers: {
|
|
'X-CSRF-Token': window.csrfToken,
|
|
},
|
|
})
|
|
}
|
|
|
|
const _deleteProject = function (project) {
|
|
return queuedHttp({
|
|
method: 'DELETE',
|
|
url: `/project/${project.id}`,
|
|
headers: {
|
|
'X-CSRF-Token': window.csrfToken,
|
|
},
|
|
})
|
|
}
|
|
|
|
const _deleteOrLeaveProjectsLocally = function (projects) {
|
|
const projectIds = projects.map(p => p.id)
|
|
for (const tag of $scope.tags || []) {
|
|
$scope._removeProjectIdsFromTagArray(tag, projectIds)
|
|
}
|
|
for (const project of projects || []) {
|
|
$scope._removeProjectFromList(project)
|
|
}
|
|
}
|
|
|
|
$scope.getValueForCurrentPredicate = function (project) {
|
|
if ($scope.predicate === 'ownerName') {
|
|
return ProjectListService.getOwnerName(project)
|
|
} else {
|
|
return project[$scope.predicate]
|
|
}
|
|
}
|
|
|
|
$scope.openUploadProjectModal = function () {
|
|
$modal.open({
|
|
templateUrl: 'uploadProjectModalTemplate',
|
|
controller: 'UploadProjectModalController',
|
|
})
|
|
}
|
|
|
|
$scope.downloadSelectedProjects = () =>
|
|
$scope.downloadProjectsById($scope.getSelectedProjectIds())
|
|
|
|
$scope.downloadProjectsById = function (projectIds) {
|
|
let path
|
|
eventTracking.send(
|
|
'project-list-page-interaction',
|
|
'project action',
|
|
'Download Zip'
|
|
)
|
|
if (projectIds.length > 1) {
|
|
path = `/project/download/zip?project_ids=${projectIds.join(',')}`
|
|
} else {
|
|
path = `/project/${projectIds[0]}/download/zip`
|
|
}
|
|
return (window.location = path)
|
|
}
|
|
|
|
const markTagAsSelected = id => {
|
|
for (const tag of $scope.tags) {
|
|
if (tag._id === id) {
|
|
tag.selected = true
|
|
} else {
|
|
tag.selected = false
|
|
}
|
|
}
|
|
}
|
|
|
|
const storedUIOpts = JSON.parse(localStorage('project_list'))
|
|
|
|
if (storedUIOpts && storedUIOpts.filter) {
|
|
if (storedUIOpts.filter === 'tag' && storedUIOpts.selectedTagId) {
|
|
markTagAsSelected(storedUIOpts.selectedTagId)
|
|
}
|
|
$scope.setFilter(storedUIOpts.filter)
|
|
} else {
|
|
$scope.updateVisibleProjects()
|
|
}
|
|
})
|
|
|
|
App.controller(
|
|
'ProjectListItemController',
|
|
function ($scope, $modal, queuedHttp, ProjectListService) {
|
|
$scope.projectLink = function (project) {
|
|
return `/project/${project.id}`
|
|
}
|
|
|
|
$scope.isLinkSharingProject = project => project.source === 'token'
|
|
|
|
$scope.hasGenericOwnerName = () => {
|
|
/* eslint-disable camelcase */
|
|
const { first_name, last_name, email } = $scope.project.owner
|
|
return !first_name && !last_name && !email
|
|
/* eslint-enable camelcase */
|
|
}
|
|
|
|
$scope.getOwnerName = ProjectListService.getOwnerName
|
|
|
|
$scope.getUserName = ProjectListService.getUserName
|
|
|
|
$scope.isOwner = () =>
|
|
$scope.project.owner && window.user_id === $scope.project.owner._id
|
|
|
|
$scope.$watch('project.selected', function (value) {
|
|
if (value != null) {
|
|
$scope.updateSelectedProjects()
|
|
}
|
|
})
|
|
|
|
$scope.clone = function (e) {
|
|
e.stopPropagation()
|
|
$scope.openCloneProjectModal($scope.project)
|
|
}
|
|
|
|
$scope.download = function (e) {
|
|
e.stopPropagation()
|
|
$scope.downloadProjectsById([$scope.project.id])
|
|
}
|
|
|
|
$scope.archive = function (e) {
|
|
e.stopPropagation()
|
|
$scope.createArchiveProjectsModal([$scope.project]).result.then(() => {
|
|
$scope.archiveProjects([$scope.project])
|
|
})
|
|
}
|
|
|
|
$scope.unarchive = function (e) {
|
|
e.stopPropagation()
|
|
$scope.unarchiveProjects([$scope.project])
|
|
}
|
|
|
|
$scope.trash = function (e) {
|
|
e.stopPropagation()
|
|
$scope.createTrashProjectsModal([$scope.project]).result.then(() => {
|
|
$scope.trashProjects([$scope.project])
|
|
})
|
|
}
|
|
|
|
$scope.untrash = function (e) {
|
|
e.stopPropagation()
|
|
$scope.untrashProjects([$scope.project])
|
|
}
|
|
|
|
$scope.leave = function (e) {
|
|
e.stopPropagation()
|
|
$scope.createLeaveProjectsModal([$scope.project]).result.then(() => {
|
|
$scope.leaveProjects([$scope.project])
|
|
})
|
|
}
|
|
|
|
$scope.delete = function (e) {
|
|
e.stopPropagation()
|
|
$scope.createDeleteProjectsModal([$scope.project]).result.then(() => {
|
|
$scope.deleteProjects([$scope.project])
|
|
})
|
|
}
|
|
}
|
|
)
|