This repository has been archived on 2022-11-26. You can view files and clone it, but cannot push or open issues or pull requests.
IcyNet.eu/server/api/admin.js

235 lines
6.1 KiB
JavaScript
Raw Normal View History

2017-08-28 15:42:16 +00:00
import Users from './index'
import Models from './models'
const perPage = 6
2017-08-28 22:36:13 +00:00
function cleanUserObject (dbe, admin) {
2017-08-28 15:42:16 +00:00
return {
id: dbe.id,
username: dbe.username,
display_name: dbe.display_name,
email: dbe.email,
avatar_file: dbe.avatar_file,
activated: dbe.activated === 1,
locked: dbe.locked === 1,
2017-08-28 22:36:13 +00:00
ip_address: dbe.ip_address,
2017-08-28 15:42:16 +00:00
password: dbe.password !== null,
nw_privilege: dbe.nw_privilege,
2017-08-28 22:36:13 +00:00
created_at: dbe.created_at,
bannable: dbe.nw_privilege < admin.nw_privilege && dbe.id !== admin.id
2017-08-28 15:42:16 +00:00
}
}
async function cleanClientObject (dbe) {
let user = await Users.User.get(dbe.user_id)
return {
id: dbe.id,
title: dbe.title,
description: dbe.description,
url: dbe.url,
redirect_url: dbe.redirect_url,
grants: dbe.grants,
icon: dbe.icon,
user: {
id: user.id,
display_name: user.display_name
},
scope: dbe.scope,
secret: dbe.secret,
verified: dbe.verified === 1,
created_at: dbe.created_at
}
}
2017-08-28 22:36:13 +00:00
async function cleanBanObject (dbe) {
let user = await Users.User.get(dbe.user_id)
let admin = await Users.User.get(dbe.admin_id)
return {
id: dbe.id,
reason: dbe.reason,
user: {
id: user.id,
display_name: user.display_name
},
admin: {
id: admin.id,
display_name: admin.display_name
},
expires_at: dbe.expires_at,
created_at: dbe.created_at,
ip_address: dbe.associated_ip,
expired: dbe.expires_at && new Date(dbe.expires_at).getTime() < Date.now()
}
}
2017-08-28 15:42:16 +00:00
const API = {
2017-08-28 22:36:13 +00:00
getAllUsers: async function (page, adminId) {
2017-08-28 15:42:16 +00:00
let count = await Models.User.query().count('id as ids')
if (!count.length || !count[0]['ids'] || isNaN(page)) {
return {error: 'No users found'}
}
count = count[0].ids
let paginated = Users.Pagination(perPage, parseInt(count), page)
let raw = await Models.User.query().offset(paginated.offset).limit(perPage)
2017-08-28 22:36:13 +00:00
let admin = await Users.User.get(adminId)
2017-08-28 15:42:16 +00:00
let users = []
for (let i in raw) {
let entry = raw[i]
2017-08-28 22:36:13 +00:00
users.push(cleanUserObject(entry, admin))
2017-08-28 15:42:16 +00:00
}
return {
page: paginated,
users: users
}
},
getAllClients: async function (page) {
let count = await Models.OAuth2Client.query().count('id as ids')
if (!count.length || !count[0]['ids'] || isNaN(page)) {
return {error: 'No clients found'}
}
count = count[0].ids
let paginated = Users.Pagination(perPage, parseInt(count), page)
let raw = await Models.OAuth2Client.query().offset(paginated.offset).limit(perPage)
let clients = []
for (let i in raw) {
let entry = raw[i]
clients.push(await cleanClientObject(entry))
}
return {
page: paginated,
clients: clients
}
},
getClient: async function (id) {
let raw = await Models.OAuth2Client.query().where('id', id)
if (!raw.length) return null
return cleanClientObject(raw[0])
},
updateClient: async function (id, data) {
let fields = [
'title', 'description', 'url', 'redirect_url', 'scope'
]
for (let i in data) {
if (fields.indexOf(i) === -1) {
delete data[i]
}
}
for (let i in fields) {
if (!data[fields[i]] && fields[i] !== 'scope') return {error: 'Missing fields'}
}
try {
await Models.OAuth2Client.query().patchAndFetchById(id, data)
2017-08-28 22:36:13 +00:00
await Models.OAuth2AuthorizedClient.query().delete().where('client_id', id)
} catch (e) {
return {error: 'No such client'}
}
return {}
},
newSecret: async function (id) {
if (isNaN(id)) return {error: 'Invalid client ID'}
let secret = Users.Hash(16)
try {
await Models.OAuth2Client.query().patchAndFetchById(id, {secret: secret})
} catch (e) {
return {error: 'No such client'}
}
return {}
},
createClient: async function (data, user) {
let fields = [
'title', 'description', 'url', 'redirect_url', 'scope'
]
for (let i in data) {
if (fields.indexOf(i) === -1) {
delete data[i]
}
}
for (let i in fields) {
if (!data[fields[i]] && fields[i] !== 'scope') return {error: 'Missing fields'}
}
let obj = Object.assign({
secret: Users.Hash(16),
grants: 'authorization_code',
created_at: new Date(),
user_id: user.id
}, data)
return Models.OAuth2Client.query().insert(obj)
},
removeClient: async function (id) {
2017-09-01 12:02:20 +00:00
if (isNaN(id)) return {error: 'Invalid ID number'}
await Models.OAuth2Client.query().delete().where('id', id)
await Models.OAuth2AuthorizedClient.query().delete().where('client_id', id)
await Models.OAuth2AccessToken.query().delete().where('client_id', id)
await Models.OAuth2RefreshToken.query().delete().where('client_id', id)
return true
2017-08-28 22:36:13 +00:00
},
getAllBans: async function (page) {
let count = await Models.Ban.query().count('id as ids')
if (!count.length || !count[0]['ids'] || isNaN(page)) {
return {error: 'No bans on record'}
}
count = count[0].ids
let paginated = Users.Pagination(perPage, parseInt(count), page)
let raw = await Models.Ban.query().offset(paginated.offset).limit(perPage)
let bans = []
for (let i in raw) {
let entry = raw[i]
bans.push(await cleanBanObject(entry))
}
return {
page: paginated,
bans: bans
}
},
removeBan: async function (banId) {
return Models.Ban.query().delete().where('id', banId)
},
addBan: async function (data, adminId) {
let user = await Users.User.get(parseInt(data.user_id))
if (!user) return {error: 'No such user.'}
if (user.id === adminId) return {error: 'Cannot ban yourself!'}
let admin = await Users.User.get(adminId)
if (user.nw_privilege > admin.nw_privilege) return {error: 'Cannot ban user.'}
let banAdd = {
reason: data.reason || 'Unspecified ban',
admin_id: adminId,
user_id: user.id,
expires_at: data.expires_at != null ? new Date(data.expires_at) : null,
created_at: new Date(),
associated_ip: data.ip_address || user.ip_address || null
}
await Models.Ban.query().insert(banAdd)
return {}
2017-08-28 15:42:16 +00:00
}
}
module.exports = API