const system = require("../../../system");
const ServiceBase = require("../../sve.base")
const settings = require("../../../../config/settings")
class OrgService extends ServiceBase {
  constructor() {
    super("org", ServiceBase.getDaoName(OrgService));

    this.userDao = system.getObject("db.user.userDao");
  }
  /**
   *  添加 
   * @param {*} params 
   */
  async apiAddOrg(params) {
    try {
      return await this.addOrg(params);
    } catch (error) {
      return system.getResult(null, `系统错误 错误信息 ${error}`);
    }
  }

  /**
   * Org  更新
   * @param {*} params 
   */
  async apiUpdOrg(params) {
    try {
      return await this.updOrg(params);
    } catch (error) {
      return system.getResult(null, `系统错误 错误信息 ${error}`);
    }
  }

  /**
   * Org 删除 
   * @param {*} params 
   */
  async apiDelOrg(params) {
    try {
      return await this.delOrg(params);
    } catch (error) {
      return system.getResult(null, `系统错误 错误信息 ${error}`);
    }
  }
  /**
   * Org  查询列表 
   * @param {*} params 
   */
  async apiListOrg(params) {
    try {
      return await this.listOrg(params);
    } catch (error) {
      return system.getResult(null, `系统错误 错误信息 ${error}`);
    }
  }

  /**
   * 根据ID查询该组织机构下的所有用户
   */
  async apiFindUserByOrgId(params) {
    try {
      return this.findUserByOrgId(params.id);
    } catch (error) {
      return system.getResult(null, `系统错误 错误信息 ${error}`);
    }
  }

  /**
   * 根据ID查明细
   * @param {*} params 
   */
  async apiQueryById(params) {
    try {
      return await this.queryById(params)
    } catch (error) {
      return system.getResult(-1, `系统错误 错误信息 ${error}`);
    }
  }

  /**
   * 根据Ip查明细
   * @param {*} params 
   */
  async apiByPid(params) {
    try {
      return await this.byPid(params)
    } catch (error) {
      return system.getResult(-1, `系统错误 错误信息 ${error}`);
    }
  }

  /**
   * 根据ID查明细
   * @param {*} params 
   */
  async apiTree(params) {
    try {
      return await this.tree(params)
    } catch (error) {
      return system.getResult(-1, `系统错误 错误信息 ${error}`);
    }
  }

  /********************************************************************** */


  /**
   * 添加
   * @param {T} params 
   */
  async saveOrg(params) {
    try {
      var pid = Number(params.pid || 0);
      let id = this.trim(params.id);
      params.orgname = this.trim(params.orgname);
      params.saas_id = Number(params.saas_id || 0);
      params.main_ids = this.trim(params.main_ids);
      let mainIds = [];
      for (let mid of params.main_ids.split(",")) {
        if (mid) {
          mainIds.push(mid);
        }
      }

      if (!params.saas_id) {
        return system.getResult(-1, `saas_id不存在`);
      }

      if (!params.orgname) {
        return system.getResult(-1, `参数错误 组织名称不能为空`)
      }

      let path = "";
      if (pid === 0) {
        if(!id) {
          // 验证是否存在其他权限
          var exist = await this.findCount({
            where: {
              saas_id: saas_id
            }
          });
          if (exist) {
            return system.getResult(null, "菜单根目录已经存在");
          }
        }
        path = `/${params.orgname}`;
      } else {
        let _org = await this.findOne({
          id: pid
        });
        if (!_org) {
          return system.getResult(-1, `参数错误 父节点不存在`);
        }
        path = `${_org.path}/${params.orgname}`;
      }
      params.path = path;
      let org;
      if(id) {
        await this.dao.update(params);
        org = params;
      } else {
        org = await this.dao.create(params);
      }
      await this.userDao.updateOrg(org.id, path + "/");
      if (mainIds && mainIds.length > 0) {
        await this.userDao.updateOrgMain(org.id, path + "/", mainIds);
      }
      return system.getResultSuccess();
    } catch (error) {
      console.log(error);
      return system.getResult(-1, `系统错误 错误信息 ${error}`);
    }
  }

  /**
   * 更新
   * @param {T} params 
   */
  async updOrg(params) {
    if (!params.id) {
      return system.getResult(-1, `参数错误 ID不能为空`);
    }
    let _org = await this.findById(params.id);
    if (!_org) {
      return system.getResult(-1, `信息不存在 请核对 ID`);
    }
    try {
      if(params.orgname){
        _org.orgname = this.trim(params.orgname);
      }
      let res = await _org.save();
      console.log(`saas 更新成功 ： ${JSON.stringify(res)}`);
      return system.getResult(res);
    } catch (error) {
      return system.getResult(-1, `系统错误 错误信息 ${error}`);
    }
    // return system.getResult(`此方法不对外提供服务`);
  }
  /**
   * 删除
   * @param {T} params 
   */
  async delOrg(params) {
    try {
      //检查是否存在此组织机构
      let _org = await this.findById(params.id);
      if (!_org) {
        return system.getResult(-1, `信息不存在 请核对 ID`);
      }
      //检查组织机构下是否有用户
      let _usersRes = await this.findUserByOrgId(params.id);
      if (_usersRes.status === -1) {
        return _usersRes;
      }
      if (_usersRes.data.length != 0) {
        return system.getResult(-1, `该组织机构不能删除`);
      }
      //检查父节点 下是否有子节点
      let _orgChildren = await this.dao.model.findAll({
        where: {
          pid: this.trim(params.id)
        }
      });
      if (_orgChildren.length != 0) {
        return system.getResult(-1, `该组织机构不能删除`);
      }
      if(_org.pid==0){
        return system.getResult(-1,`该组织为根结点 不能删除`);
      }
      //删除
      let res = await _org.destroy();
      return system.getResult(res);
    } catch (error) {
      return system.getResult(-1, `系统错误 错误信息 ${error}`);
    }
  }

  /**
   * 查询列表
   * @param {T} params 
   */
  async listOrg(params) {
    let where = {};
    let pageIndex = Number(params.pageIndex || 1);
    let pageSize = Number(params.pageSize || 10);
    if (params.orgname) {
      where.orgname = this.trim(params.orgname);
    }
    if (params.path) {
      where.path = this.trim(params.path);
    }
    if (params.pid) {
      where.pid = this.trim(params.pid);
    }
    if (params.saas_id) {
      where.saas_id = Number(params.saas_id);
    }
    if (params.hasOwnProperty("is_leaf")) {
      where.is_leaf = Number(params.is_leaf);
    }
    try {
      let orgList = await this.getPageList(pageIndex, pageSize, where);
      for (let item  of orgList.rows) {
        this.handleDate(item,['created_at'],null,-8);
        this.handleDate(item,['updated_at'],null,-8);
      }
      return system.getResult(orgList);
    } catch (error) {
      return system.getResult(-1, `系统错误 错误信息 ${error}`);
    }
  }

  async queryById(params) {
    if (!params.id) {
      return system.getResult(-1, `参数错误 ID不能为空`);
    }
    try {
      let _org = await this.dao.getById(this.trim(params.id));
      this.handleDate(_org,['created_at'],null,-8);
      this.handleDate(_org,['updated_at'],null,-8);
      return system.getResult(_org);
    } catch (error) {
      return system.getResult(-1, `系统错误 错误信息 ${error}`);
    }
  }

  /**
   * 根据ID查询该组织机构下的所有用户
   */
  async findUserByOrgId(id) {
    if (!Number(id)) {
      return system.getResult(-1, `参数错误 组织机构不能为空`);
    }
    try {
      let res = await this.dao.findUserByOrgId(id);
      return system.getResult(res);
    } catch (error) {
      return system.getResult(-1, `系统错误 错误信息 ${error}`);
    }
  }

  async byPid(obj) {
    try {
      var list = await this.dao.findAll({
        pid: obj.pid || 0,
      });
      return system.getResult(list);
    } catch (error) {
      return system.getResult(-1, `系统错误 错误信息 ${error}`);
    }
  }

  /**
   * 结构树
   */
  async tree(params) {
    try {
      var all = await this.dao.all(params.saas_id);
      var pmap = {};
      for (var item of all) {
        item.label =  item.orgname;
        var list = pmap[item.pid];
        if (!list) {
          list = [];
        }
        list.push(item);
        pmap[item.pid] = list;
      }
      for(var item of all) {
        item.children = pmap[item.id] || [];
      }
      return system.getResult(pmap[0]);
    } catch (error) {
      return system.getResult(-1, `系统错误 错误信息 ${error}`);
    }

  }
}
module.exports = OrgService;