smsb-web-develop/src/api/user.js

import md5 from 'md5'
import store from '@/store'
import {
  Role,
  AlarmLevelInfo
} from '@/constant'
import request, {
  keycloakRequest,
  tenantRequest
} from '@/utils/request'
import {
  send,
  add,
  update,
  messageSend,
  addTenant as addTenantKey
} from './base'

export function getWechatQr (id) {
  return request({
    url: `keycloak/query/ticket/${id}`,
    method: 'GET'
  })
}

export function getAppletQr (data) {
  return request({
    url: 'wxapplet/qrcode',
    method: 'GET',
    params: data
  })
}

export function userinfo (silence) {
  const config = {
    url: `/users/${store.getters.userId}`,
    method: 'GET'
  }
  if (silence) {
    config.custom = true
    return keycloakRequest(config)
  }
  return send(config, keycloakRequest)
}

export function addUser (data) {
  return add({
    url: '/admin/users',
    method: 'POST',
    data: addTenantKey({
      ...data,
      credentials: [{ type: 'password', value: process.env.VUE_APP_USER_PASSWORD, temporary: true }]
    })
  })
}

export function updateUser (data, message) {
  return update({
    url: '/keycloak/users/attribute',
    method: 'PUT',
    data
  }, message)
}

export function toggleUser ({ userId, userName }, enabled) {
  return messageSend({
    url: '/admin/users/enabled',
    method: 'PUT',
    data: addTenantKey({
      userId,
      userName,
      enabled
    })
  }, enabled ? '启用' : '停用')
}

export function deleteUser ({ userId, userName }) {
  return messageSend({
    url: `/admin/users/${userId}?userName=${userName}`,
    method: 'DELETE'
  }, '注销')
}

export function getUserCredentials (userId) {
  return request({
    url: `/admin/users/${userId}/credentials`,
    method: 'GET'
  }).then(({ data }) => data)
}

export function deleteUserCredentials ({ userId, userName }, credentialId) {
  return messageSend({
    url: `/admin/users/${userId}/credentials/${credentialId}?userName=${userName}`,
    method: 'DELETE'
  }, '重置')
}

export function resetPassword ({ userId, userName }) {
  return messageSend({
    url: `/admin/users/${userId}/resetPassword`,
    method: 'PUT',
    data: {
      type: 'password',
      value: process.env.VUE_APP_USER_PASSWORD,
      temporary: true,
      userLabel: userName
    }
  }, '重置')
}

export function resetPasswordByUser (newPassword) {
  return messageSend({
    url: '/keycloak/changePassword',
    method: 'PUT',
    params: { newPassword: md5(`${newPassword}${process.env.VUE_APP_SALT}`) }
  }, '重置')
}

export function getTenantsByQuery (query, recursive) {
  const { pageSize: max, pageNum, name, ...params } = query
  return keycloakRequest({
    url: '/groups',
    method: 'GET',
    params: {
      briefRepresentation: false,
      max,
      first: pageNum ? (pageNum - 1) * max : void 0,
      search: name || void 0,
      ...params
    }
  }).then(data => {
    return { data: normalizeGroups(data, recursive) }
  })
}

function normalizeGroups (groups, recursive, parentGroup) {
  return groups.map(({ id, name, path, attributes, subGroups }) => {
    const remark = attributes.remark?.[0] || ''
    const group = {
      parentGroup,
      id,
      path,
      name,
      remark,
      label: remark || name
    }
    if (!recursive) {
      return group
    }
    group.subGroups = normalizeGroups(subGroups.sort((a, b) => a.name <= b.name ? -1 : 1), recursive, group)
    return group
  })
}

export function getTenantCount (name) {
  return keycloakRequest({
    url: '/groups/count',
    method: 'GET',
    params: {
      top: true,
      search: name || void 0
    }
  })
}

export async function getTenants (query) {
  const { count } = await getTenantCount(query.name)
  const { data } = await getTenantsByQuery(query, false)
  return {
    data,
    totalCount: count
  }
}

export async function getPlatformTenants () {
  const { count } = await getTenantCount()
  return getTenantsByQuery({ max: count }, false)
}

export function addTenant ({ name, remark }) {
  return add({
    url: '/super/admin/tenant',
    method: 'POST',
    data: {
      name,
      attributes: {
        remark: [remark]
      }
    }
  })
}

export function deleteTenant ({ id }) {
  return messageSend({
    url: `/super/admin/tenant/${id}`,
    method: 'DELETE'
  }, '删除')
}

export function updateTenant ({ id, name, remark }) {
  return update({
    url: `/admin/group/${id}`,
    method: 'PUT',
    data: {
      name,
      attributes: {
        remark: [remark]
      }
    }
  })
}

export function getUsersByGroup (query) {
  const { id, pageSize: max, pageNum, ...params } = query
  return keycloakRequest({
    url: `/groups/${id}/members`,
    method: 'GET',
    params: {
      briefRepresentation: true,
      max: max + 1,
      first: pageNum ? (pageNum - 1) * max : void 0,
      ...params
    }
  }).then(data => {
    const totalCount = data.length
    if (totalCount > max) {
      data = data.slice(0, -1)
    }
    return {
      data,
      totalCount
    }
  })
}

export function getUserRoleMapping (userId) {
  return keycloakRequest({
    url: `/users/${userId}/role-mappings/realm`,
    method: 'GET'
  }).then(
    roles => getRoles().then(
      available => {
        return {
          available,
          roles
        }
      }
    )
  )
}

let roles = null
function getRoles () {
  if (roles) {
    return Promise.resolve(roles)
  }
  return keycloakRequest({
    url: `/roles`,
    method: 'GET'
  }).then(data => {
    const isSuperAdmin = store.getters.isSuperAdmin
    return (roles = data.filter(({ name }) => name !== Role.SUPER_ADMIN && (isSuperAdmin || name !== Role.ADMIN) && name.startsWith('ROLE_')))
  })
}

export function updateUserRoles (userId, available, fromKeys, toKeys) {
  const delRoles = []
  const toSet = new Set(toKeys)
  fromKeys.forEach(id => {
    if (!toSet.has(id)) {
      delRoles.push(available.find(role => role.id === id))
    }
  })
  const addRoles = []
  const fromSet = new Set(fromKeys)
  toKeys.forEach(id => {
    if (!fromSet.has(id)) {
      addRoles.push(available.find(role => role.id === id))
    }
  })
  return request({
    url: '/admin/users/role/configure',
    method: 'PUT',
    data: {
      userId,
      addRoleList: addRoles,
      removeRoleList: delRoles
    }
  })
}

export function sendVerificationCode (data) {
  return request({
    url: '/authcode/send',
    method: 'POST',
    data
  })
}

export function checkVerificationCode (data) {
  return request({
    url: '/authcode/check',
    method: 'POST',
    data
  })
}

export function getDepartments () {
  return tenantRequest({
    url: '/admin/department/list',
    method: 'POST',
    data: addTenantKey()
  })
}

export function getDepartmentTree () {
  if (store.getters.isTenantAdmin) {
    return getDepartments().then(({ data }) => {
      return {
        data: [{
          path: store.getters.tenant,
          name: '我的部门',
          children: data
        }]
      }
    })
  }
  return request({
    url: '/keycloak/oneself/tree',
    method: 'GET'
  }).then(({ data }) => {
    return {
      data: [{
        path: store.getters.org,
        name: '我的部门',
        children: data || []
      }]
    }
  })
}

export function addDepartment (data) {
  return add({
    url: '/admin/department',
    method: 'POST',
    data: addTenantKey(data)
  }, tenantRequest)
}

export function updateDepartmentName (data) {
  return update({
    url: '/admin/department',
    method: 'PUT',
    data
  })
}

export function deleteDepartment ({ id }) {
  return messageSend({
    url: `/admin/department/${id}`,
    method: 'DELETE'
  }, '删除')
}

export function getUsersByDepartment (query) {
  const { pageNum: pageIndex, pageSize, ...params } = query
  return tenantRequest({
    url: '/admin/department/user/list',
    method: 'POST',
    data: addTenantKey({
      pageIndex, pageSize,
      ...params
    })
  })
}

export function updateUserDepartment ({ userId, userName }, { id, name }) {
  return tenantRequest({
    url: '/admin/users/regrouping',
    method: 'PUT',
    data: addTenantKey({
      userId,
      userName,
      ...(id ? { departmentId: id, departmentName: name } : { departmentName: '顶层部门' })
    })
  })
}

export function updateUserName (userId, name) {
  return update({
    url: '/admin/users/update',
    method: 'PUT',
    data: addTenantKey({
      userId,
      name
    })
  }, null, tenantRequest)
}

export function updateUserInformLevel ({ userId, userName }, informLevel, informType = []) {
  let informName = '未知'
  switch (true) {
    case informLevel === 9999:
      informName = '自定义'
      break
    case informLevel >= 0:
      informName = AlarmLevelInfo[informLevel]
      break
    case informLevel === -1:
      informName = '不预警'
      break
    default:
      break
  }
  return update({
    url: '/admin/users/update/deviceExceptionLevel',
    method: 'PUT',
    data: addTenantKey({
      userId,
      userName,
      informLevel,
      informName,
      informType
    })
  }, null, tenantRequest)
}

export function getUserInforms ({ userId }) {
  return send({
    url: '/admin/user/custom',
    method: 'GET',
    params: { userId }
  })
}

export function migrateUser (data) {
  return tenantRequest({
    url: '/admin/users/temporary/migration',
    method: 'POST',
    data: addTenantKey(data)
  })
}

export function getTenantTree () {
  return getGroups().then(data => {
    const groups = normalizeGroups([data], true)
    groups[0].label = '根部门'
    return { data: groups }
  })
}

async function getGroups () {
  if (!store.getters.tenantId) {
    const groups = await getUserGroups(store.getters.userId)
    store.commit('user/SET_TENANT_ID', groups[0].id)
  }
  return keycloakRequest({
    url: `/groups/${store.getters.tenantId}`,
    method: 'GET'
  })
}

export function getUserGroups (id) {
  return keycloakRequest({
    url: `/users/${id}/groups`,
    method: 'GET',
    params: { briefRepresentation: true }
  }).then(data => data.sort((a, b) => a.path.length - b.path.length))
}