392 lines
13 KiB
JavaScript
392 lines
13 KiB
JavaScript
const VersionedModel = require('../VersionedModel')
|
|
const { ObjectId } = require('mongodb')
|
|
const uuid = require('uuid/v4')
|
|
|
|
const ActiveScope = require('../scopes/Active.scope')
|
|
const { PageType } = require('../../enum');
|
|
|
|
/*
|
|
* Page Model
|
|
* -------------------------------------------------------------
|
|
* Put some description here!
|
|
*/
|
|
class Page extends VersionedModel {
|
|
static get services() {
|
|
return [...super.services, 'models'];
|
|
}
|
|
static get schema() {
|
|
// Return a flitter-orm schema here.
|
|
return {
|
|
...super.schema,
|
|
UUID: {type: String, default: () => uuid()},
|
|
Name: String,
|
|
OrgUserId: ObjectId,
|
|
IsPublic: {type: Boolean, default: true},
|
|
IsVisibleInMenu: {type: Boolean, default: true},
|
|
ParentId: String,
|
|
NodeIds: [String],
|
|
CreatedAt: {type: Date, default: () => new Date},
|
|
UpdatedAt: {type: Date, default: () => new Date},
|
|
DeletedAt: Date,
|
|
Active: {type: Boolean, default: true},
|
|
CreatedUserId: {type: String},
|
|
UpdateUserId: {type: String},
|
|
ChildPageIds: [String],
|
|
PageType: {type: String, default: PageType.Note}, // PageType
|
|
AdditionalData: Object,
|
|
|
|
// Menu flags
|
|
noDelete: { type: Boolean, default: false },
|
|
virtual: { type: Boolean, default: false },
|
|
|
|
// Sharing properties
|
|
shared_users_view: [ObjectId],
|
|
shared_users_update: [ObjectId],
|
|
shared_users_manage: [ObjectId],
|
|
};
|
|
}
|
|
|
|
static scopes = [new ActiveScope]
|
|
|
|
static async visible_by_user(user) {
|
|
const user_root = await user.get_root_page()
|
|
const user_root_children = await user_root.visible_flat_children(user)
|
|
|
|
const view_only_trees = await this.find({ shared_users_view: user._id })
|
|
let view_only_children = []
|
|
for ( const tree of view_only_trees ) {
|
|
if ( await tree.is_accessible_by(user) ) {
|
|
view_only_children.push(tree)
|
|
view_only_children = [...view_only_children, await tree.visible_flat_children(user)]
|
|
}
|
|
}
|
|
|
|
const update_trees = await this.find({ shared_users_update: user._id })
|
|
let update_children = []
|
|
for ( const tree of update_trees ) {
|
|
if ( await tree.is_accessible_by(user) ) {
|
|
update_children.push(tree)
|
|
update_children = [...update_children, await tree.visible_flat_children(user)]
|
|
}
|
|
}
|
|
|
|
const manage_trees = await this.find({ shared_users_manage: user._id })
|
|
let manage_children = []
|
|
for ( const tree of manage_trees ) {
|
|
if ( await tree.is_accessible_by(user) ) {
|
|
manage_children.push(tree)
|
|
manage_children = [...manage_children, await tree.visible_flat_children(user)]
|
|
}
|
|
}
|
|
|
|
const all_children = [...user_root_children, ...view_only_children, ...update_children, ...manage_children]
|
|
const unique_children = []
|
|
const seen_UUIDs = []
|
|
all_children.forEach(child => {
|
|
if ( !seen_UUIDs.includes(child.UUID) ) {
|
|
unique_children.push(child)
|
|
seen_UUIDs.push(child.UUID)
|
|
}
|
|
})
|
|
|
|
return unique_children
|
|
}
|
|
|
|
async visible_flat_children(user) {
|
|
const children = await this.childPages
|
|
let visible = []
|
|
if ( children ) {
|
|
for ( const child of children ) {
|
|
if ( !(await child.is_accessible_by(user)) ) continue
|
|
visible.push(child)
|
|
visible = [...visible, ...(await child.visible_flat_children(user))]
|
|
}
|
|
}
|
|
|
|
return visible
|
|
}
|
|
|
|
is_shared() { // TODO: public user sharing...
|
|
return this.shared_users_view.length > 0 || this.shared_users_update.length > 0 || this.shared_users_manage.length > 0
|
|
}
|
|
|
|
// ================= RELATIONSHIPS =================
|
|
get user() {
|
|
const User = this.models.get("auth:User")
|
|
return this.belongs_to_one(User, "OrgUserId", "_id")
|
|
}
|
|
|
|
get nodes() {
|
|
const Node = this.models.get("api:Node")
|
|
const node_promise = this.has_many(Node, "NodeIds", "UUID")
|
|
if ( this.is_a_version() ) {
|
|
// return the nodes for this version!
|
|
return (async () => {
|
|
const nodes = await node_promise
|
|
const version_data = this.raw_version_data()
|
|
const return_nodes = []
|
|
if ( version_data?.node_version_nums ) {
|
|
const node_x_version_num = {}
|
|
for ( const item of version_data.node_version_nums ) {
|
|
node_x_version_num[item.NodeId] = item.version_num
|
|
}
|
|
|
|
for ( const node of nodes ) {
|
|
if ( node_x_version_num[node.UUID] ) {
|
|
return_nodes.push(await node.as_version(node_x_version_num[node.UUID]))
|
|
} else {
|
|
return_nodes.push(node)
|
|
}
|
|
}
|
|
}
|
|
|
|
return return_nodes
|
|
})()
|
|
} else {
|
|
return node_promise
|
|
}
|
|
}
|
|
|
|
get childPages() {
|
|
const Page = this.models.get("api:Page")
|
|
return this.has_many(Page, "ChildPageIds", "UUID")
|
|
}
|
|
|
|
get parent() {
|
|
const Parent = this.models.get("api:Page")
|
|
return this.belongs_to_one(Parent, "ParentId", "UUID")
|
|
}
|
|
|
|
get view_users() {
|
|
const User = this.models.get('auth:User')
|
|
return this.has_many(User, 'shared_users_view', '_id')
|
|
}
|
|
|
|
get update_users() {
|
|
const User = this.models.get('auth:User')
|
|
return this.has_many(User, 'shared_users_update', '_id')
|
|
}
|
|
|
|
get manage_users() {
|
|
const User = this.models.get('auth:User')
|
|
return this.has_many(User, 'shared_users_manage', '_id')
|
|
}
|
|
|
|
// ================= SECURITY =================
|
|
|
|
async is_accessible_by(user, mode = 'view') {
|
|
const can_manage = await user.can(`page:${this.UUID}:manage`)
|
|
const can_update = await user.can(`page:${this.UUID}:update`)
|
|
const can_view = await user.can(`page:${this.UUID}:view`)
|
|
const can_all = await user.can(`page:${this.UUID}`)
|
|
|
|
// Allow universal access
|
|
if ( can_all ) return true
|
|
// deny if blocked
|
|
else if ( await user.can(`page:${this.UUID}:block`) ) return false
|
|
// manage, update, view can view
|
|
else if ( mode === 'view' && (can_manage || can_update || can_view) ) return true
|
|
// manage, update can update
|
|
else if ( mode === 'update' ) {
|
|
if ( can_manage || can_update ) return true
|
|
// If other permissions are explicitly set for this page, use those
|
|
else if ( can_view ) return false
|
|
}
|
|
// manage can manage
|
|
else if ( mode === 'manage' ) {
|
|
if ( can_manage ) return true
|
|
// If other permissions are explicitly set for this page, use those
|
|
else if ( can_update || can_view ) return false
|
|
}
|
|
|
|
// allow universal access
|
|
// deny blocked users
|
|
|
|
// If there are no explicit permissions set for this node, check the parent
|
|
const parent = await this.parent
|
|
if ( parent ) return (await this.parent).is_accessible_by(user, mode)
|
|
else return false
|
|
}
|
|
|
|
async access_level_for(user) {
|
|
if ( await this.is_accessible_by(user, 'manage') ) return 'manage'
|
|
else if ( await this.is_accessible_by(user, 'update') ) return 'update'
|
|
else if ( await this.is_accessible_by(user, 'view') ) return 'view'
|
|
else return false
|
|
}
|
|
|
|
async share_public(current_user, level = 'view') {
|
|
const PublicUserPermission = this.models.get('auth:PublicUserPermission')
|
|
|
|
if ( !['view', 'update', 'manage'].includes(level) ) {
|
|
throw new Error(`Invalid share level: ${level}`)
|
|
}
|
|
|
|
const possible_grants = [':view', ':manage', ':update', ''].map(x => `page:${this.UUID}${x}`)
|
|
|
|
// Remove existing sharing info
|
|
await PublicUserPermission.deleteMany({
|
|
permission: {
|
|
$in: possible_grants,
|
|
},
|
|
})
|
|
|
|
// Create the new sharing level
|
|
const share = new PublicUserPermission({
|
|
associated_user_id: this.OrgUserId,
|
|
permission: `page:${this.UUID}:${level}`,
|
|
})
|
|
|
|
await this.version_save(`Shared publicly (${level} access)`, current_user.id)
|
|
await share.save()
|
|
}
|
|
|
|
async unshare_public(current_user) {
|
|
const PublicUserPermission = this.models.get('auth:PublicUserPermission')
|
|
const possible_grants = [':view', ':manage', ':update', ''].map(x => `page:${this.UUID}${x}`)
|
|
|
|
// Remove existing sharing info
|
|
await PublicUserPermission.deleteMany({
|
|
permission: {
|
|
$in: possible_grants,
|
|
},
|
|
})
|
|
|
|
await this.version_save(`Un-shared public access)`, current_user.id)
|
|
}
|
|
|
|
async share_with(user, level = 'view') {
|
|
if ( !['view', 'update', 'manage'].includes(level) ) {
|
|
throw new Error(`Invalid share level: ${level}`)
|
|
}
|
|
|
|
// Remove existing sharing info
|
|
await this.unshare_with(user)
|
|
|
|
// Add the page to the user's permissions:
|
|
user.allow(`page:${this.UUID}:${level}`)
|
|
|
|
// Add the user to the appropriate access list
|
|
this[`shared_users_${level}`].push(user._id)
|
|
|
|
// TODO replace user.uid with name of user when we support that
|
|
await this.version_save(`Shared with ${user.uid} (${level} access)`, user.id)
|
|
await user.save()
|
|
}
|
|
|
|
async unshare_with(user) {
|
|
// Remove this page from the user's permissions
|
|
if ( await user.can(`page:${this.UUID}`) ) user.disallow(`page:${this.UUID}`)
|
|
for ( const level of ['view', 'update', 'manage'] ) {
|
|
if ( await user.can(`page:${this.UUID}:${level}`) ) user.disallow(`page:${this.UUID}:${level}`)
|
|
}
|
|
|
|
// Remove the user from this page's access lists
|
|
this.shared_users_view = this.shared_users_view.filter(x => String(x) !== user.id)
|
|
this.shared_users_update = this.shared_users_update.filter(x => String(x) !== user.id)
|
|
this.shared_users_manage = this.shared_users_manage.filter(x => String(x) !== user.id)
|
|
|
|
await this.version_save(`Unshared with ${user.uid}`, user.id)
|
|
await user.save()
|
|
}
|
|
|
|
async get_menu_items(page_only) {
|
|
if ( page_only ) return [];
|
|
|
|
// {
|
|
// id: child.UUID,
|
|
// name: child.is_shared() ? child.Name + ' ⁽ˢʰᵃʳᵉᵈ⁾' : child.Name,
|
|
// shared: child.is_shared(),
|
|
// children: await this._build_menu_object(child),
|
|
// type: 'page',
|
|
// }
|
|
|
|
// Databases & Code Snips
|
|
const children = []
|
|
|
|
const Database = this.models.get('api:db:Database')
|
|
const dbs = await Database.find({
|
|
Active: true,
|
|
PageId: this.UUID,
|
|
})
|
|
|
|
for ( const db of dbs ) {
|
|
children.push({
|
|
id: db.PageId,
|
|
node_id: db.NodeId,
|
|
children: [],
|
|
type: 'db',
|
|
name: db.Name,
|
|
})
|
|
}
|
|
|
|
const FileBox = this.models.get('api:files:FileBox')
|
|
const boxes = await FileBox.find({
|
|
active: true,
|
|
pageId: this.UUID,
|
|
})
|
|
|
|
for ( const box of boxes ) {
|
|
if ( box.parentUUID ) continue; // only show top-level
|
|
|
|
children.push({
|
|
id: box.pageId,
|
|
node_id: box.nodeId,
|
|
children: [],
|
|
type: 'file_box',
|
|
name: box.name,
|
|
})
|
|
}
|
|
|
|
const Codium = this.models.get('api:Codium')
|
|
const codiums = await Codium.find({
|
|
PageId: this.UUID,
|
|
})
|
|
|
|
for ( const codium of codiums ) {
|
|
children.push({
|
|
id: codium.PageId,
|
|
node_id: codium.NodeId,
|
|
children: [],
|
|
type: 'code',
|
|
name: codium.code.slice(0, 25) + (codium.code.length > 25 ? '...' : ''),
|
|
})
|
|
}
|
|
|
|
return children
|
|
}
|
|
|
|
async cast_to_version_data() {
|
|
const data = await super.cast_to_version_data()
|
|
const node_version_nums = []
|
|
const nodes = await this.nodes
|
|
|
|
for ( const node of nodes ) {
|
|
node_version_nums.push({ NodeId: node.UUID, version_num: node.version_num })
|
|
}
|
|
|
|
data.node_version_nums = node_version_nums
|
|
return data
|
|
}
|
|
|
|
async revert_to_version(version_num, user_id = undefined) {
|
|
const Node = this.models.get('api:Node')
|
|
const reverted = await super.revert_to_version(version_num, user_id)
|
|
const data = await this.get_version_data(version_num)
|
|
|
|
// Revert the nodes to the given versions
|
|
for ( const node_data of data.node_version_nums ) {
|
|
const node = await Node.findOne({ UUID: node_data.NodeId })
|
|
if ( node ) {
|
|
const reverted_node = await node.revert_to_version(node_data.version_num)
|
|
await reverted_node.save()
|
|
}
|
|
}
|
|
|
|
await reverted.save()
|
|
return reverted
|
|
}
|
|
}
|
|
|
|
module.exports = exports = Page;
|