@steedos/service-core-objects 3.0.0-beta.8

package/main/default/services/company.service.js

@@ -0,0 +1,276 @@
+/*
+ * @Author: sunhaolin@hotoa.com
+ * @Date: 2022-12-08 15:38:09
+ * @LastEditors: baozhoutao@steedos.com
+ * @LastEditTime: 2025-03-03 11:59:13
+ * @Description: 
+ */
+"use strict";
+const { getObject } = require("@steedos/objectql")
+const _ = require('underscore')
+/**
+ * @typedef {import('moleculer').Context} Context Moleculer's Context
+ */
+module.exports = {
+    name: 'company',
+    namespace: "steedos",
+    mixins: [],
+    /**
+     * Settings
+     */
+    settings: {
+
+    },
+
+    /**
+     * Dependencies
+     */
+    dependencies: [],
+
+    /**
+     * Actions
+     */
+    actions: {
+        /**
+         * @api {post} /service/api/company/updateOrgs 更新组织
+         * @apiName updateOrgs
+         * @apiGroup company.service.js
+         * @apiParam {String} companyId 分部ID
+         * @apiSuccess {Number} updatedOrgs   更新的组织数。
+         * @apiSuccess {Number} updatedSus   更新成功数。
+         */
+        updateOrgs: {
+            params: {
+                companyId: { type: "string" },
+            },
+            async handler(ctx) {
+                console.log('[service][company]===>', '/service/api/company/updateOrgs', ctx.params)
+                return await this.updateOrgs(ctx.params.companyId, ctx.meta.user)
+            }
+        },
+    },
+
+    /**
+     * Events
+     */
+    events: {
+
+    },
+
+    /**
+     * Methods
+     */
+    methods: {
+        /**
+         * 更新组织
+         * @param {*} companyId 
+         * @param {*} userSession 
+         */
+        async updateOrgs(companyId, userSession) {
+
+            let callThis = {
+                userSession: userSession
+            }
+
+            let company = await getObject("company").findOne(companyId, {
+                fields: ["organization", "space"]
+            });
+
+            if (!company.organization) {
+                throw new Error("该分部的关联组织未设置");
+            }
+
+            // 在使用cachedCompanys过程中一定要注意内部程序是否会变更cachedCompanys中的值，
+            // 如果会则不能使用cachedCompanys而应该用getObject...find的方式即时更新到最新数据
+            const cachedCompanys = await getObject("company").find({
+                filters: [["space", "=", company.space]],
+                fields: ["_id", "organization"]
+            });
+
+            await this.update_all_company_org.call(callThis, company.space, cachedCompanys);
+
+            let updatedOrgs = { count: 0 };
+            await this.update_org_company_id.call(callThis, company.organization, companyId, company.space, cachedCompanys, updatedOrgs);
+
+            const sus = await getObject("space_users").find({
+                filters: [["organizations_parents", "=", company.organization]],
+                fields: ["organizations", "organization", "company_id", "space"]
+            });
+
+            // 在使用cachedOrganizations过程中一定要注意内部程序是否会变更cachedOrganizations中的值，
+            // 如果会则不能使用cachedOrganizations而应该用getObject...find的方式即时更新到最新数据
+            const cachedOrganizations = await getObject("organizations").find({
+                filters: [["space", "=", company.space]],
+                fields: ["_id", "company_id", "sort_no"]
+            });
+
+            for (let su of sus) {
+                await this.update_su_company_ids.call(callThis, su._id, su, cachedOrganizations);
+            }
+
+            // 分部没有上下层级关系，只能每次都更新所有分部的排序号
+            await this.update_all_company_sort_no.call(callThis, cachedCompanys, cachedOrganizations);
+
+            return {
+                updatedOrgs: updatedOrgs.count,
+                updatedSus: sus.length
+            }
+        },
+        /**
+         * 根据当前space_users的organizations/organization值，计算其company_ids及company_id值
+         * @param {*} _id 
+         * @param {*} su 
+         * @param {*} cachedOrganizations 
+         * @returns 
+         */
+        async update_su_company_ids(_id, su, cachedOrganizations) {
+            var company_ids, orgs, org;
+            if (!su) {
+                su = await getObject("space_users").findOne(_id, {
+                    fields: ["organizations", "organization", "company_id", "space"]
+                });
+            }
+            if (!su) {
+                console.error("db.space_users.update_company_ids,can't find space_users by _id of:", _id);
+                return;
+            }
+            orgs = cachedOrganizations.filter(function (item) {
+                return su.organizations.indexOf(item._id) > -1;
+            });
+            company_ids = _.pluck(orgs, 'company_id');
+            // company_ids中的空值就空着，不需要转换成根组织ID值
+            company_ids = _.uniq(_.compact(company_ids));
+
+            org = cachedOrganizations.find(function (item) {
+                return su.organization === item._id;
+            });
+
+            let updateDoc = {
+                company_ids: company_ids
+            };
+            if (org && org.company_id) {
+                updateDoc.company_id = org.company_id;
+            }
+            await getObject("space_users").directUpdate(_id, updateDoc);
+        },
+        /**
+         * 循环执行当前组织及其子组织children的company_id值计算
+         * @param {*} _id 
+         * @param {*} company_id 
+         * @param {*} space_id 
+         * @param {*} cachedCompanys 
+         * @param {*} updated 
+         * @returns 
+         */
+        async update_org_company_id(_id, company_id, space_id, cachedCompanys, updated = { count: 0 }) {
+            const org = await getObject("organizations").findOne(_id, {
+                fields: ["children", "is_company"]
+            });
+
+            if (!org) {
+                return;
+            }
+
+            if (org.is_company) {
+                const orgCompany = cachedCompanys.find(function (company) {
+                    return company.organization === _id;
+                });
+                if (orgCompany) {
+                    company_id = orgCompany._id;
+                }
+            }
+            await getObject("organizations").directUpdate(_id, {
+                company_id: company_id
+            });
+            updated.count += 1;
+
+            const children = org.children;
+            if (children && children.length) {
+                for (let child of children) {
+                    await this.update_org_company_id.call(this, child, company_id, space_id, cachedCompanys, updated);
+                }
+            }
+        },
+        /**
+         * 执行更新组织前先把所有company的直属关联组织is_company及is_company设置对，
+         * 即把直属关联组织is_company设置为true，company_id设置为关联分部_id
+         * 只需要处理organization值不等于其_id值的company记录，这些记录不是新建出来的，而是其他方式同步过来的数据
+         * @param {*} space_id 
+         * @param {*} cachedCompanys 
+         */
+        async update_all_company_org(space_id, cachedCompanys) {
+            if (!cachedCompanys) {
+                cachedCompanys = await getObject("company").find({
+                    filters: [["space", "=", space_id]],
+                    fields: ["organization"]
+                });
+            }
+
+            for (let company of cachedCompanys) {
+                if (company.organization) {
+                    await getObject("organizations").directUpdate(company.organization, {
+                        is_company: true,
+                        company_id: company._id
+                    });
+                }
+            }
+
+            let orgs = await getObject("organizations").find({
+                filters: [["space", "=", space_id], ["is_company", "=", true]],
+                fields: ["company_id", "is_company"]
+            });
+            // 清除未被company引用的organizations记录的is_company值为false
+            for (let org of orgs) {
+                const orgCompany = cachedCompanys.find(function (company) {
+                    return company.organization === org._id;
+                });
+                if (!orgCompany) {
+                    await getObject("organizations").directUpdate(org._id, {
+                        is_company: false
+                    });
+                }
+            }
+        },
+        /**
+         * 
+         * @param {*} cachedCompanys 
+         * @param {*} cachedOrganizations 
+         */
+        async update_all_company_sort_no(cachedCompanys, cachedOrganizations) {
+            let org = null;
+            for (let company of cachedCompanys) {
+                if (company.organization) {
+                    org = cachedOrganizations.find(function (item) {
+                        return company.organization === item._id;
+                    });
+                    if (org && _.isNumber(org.sort_no)) {
+                        await getObject("company").directUpdate(company._id, {
+                            sort_no: org.sort_no
+                        });
+                    }
+                }
+            }
+        }
+    },
+
+    /**
+     * Service created lifecycle event handler
+     */
+    created() {
+
+    },
+
+    /**
+     * Service started lifecycle event handler
+     */
+    async started() {
+        this.broker.logger.info('[service][company]===>', 'started')
+    },
+
+    /**
+     * Service stopped lifecycle event handler
+     */
+    async stopped() {
+
+    }
+};

package/main/default/services/organizations.service.js

@@ -0,0 +1,370 @@
+/*
+ * @Author: sunhaolin@hotoa.com
+ * @Date: 2022-12-02 16:53:23
+ * @LastEditors: baozhoutao@steedos.com
+ * @LastEditTime: 2025-02-28 11:51:23
+ * @Description: 
+ */
+"use strict";
+const { getObject } = require("@steedos/objectql")
+const _ = require('underscore')
+const lodash = require('lodash');
+
+function getTreeRootIds(rows) {
+    const valueField = "_id";
+    const ids = [];
+    for (var i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        if (!!row["parent"]) {
+            if (!lodash.some(rows, row2 => row["parent"] == row2[valueField])){
+                ids.push(row._id);
+            }
+        } else {
+            ids.push(row._id);
+        };
+    }
+    return ids;
+}
+
+
+/**
+ * @typedef {import('moleculer').Context} Context Moleculer's Context
+ */
+module.exports = {
+    name: 'organizations',
+    namespace: "steedos",
+    mixins: [],
+    /**
+     * Settings
+     */
+    settings: {
+
+    },
+
+    /**
+     * Dependencies
+     */
+    dependencies: [],
+
+    /**
+     * Actions
+     */
+    actions: {
+        /**
+         * @api {post} calculateFullname 计算组织的全名
+         * @apiName calculateFullname
+         * @apiGroup organizations.service.js
+         * @apiParam {String} orgId  组织ID
+         * @apiSuccess {String} 返回组织的全名
+         */
+        calculateFullname: {
+            params: {
+                orgId: { type: "string" },
+            },
+            async handler(ctx) {
+                this.broker.logger.info('[service][organizations]===>', 'calculateFullname', ctx.params.orgId)
+                return this.calculateFullname(ctx.params.orgId)
+            }
+        },
+        /**
+         * @api {post} calculateParents 计算组织的父节点
+         * @apiName calculateParents
+         * @apiGroup organizations.service.js
+         * @apiParam {String} orgId  组织ID
+         * @apiSuccess {String[]} 返回组织的父节点
+         */
+        calculateParents: {
+            params: {
+                orgId: { type: "string" },
+            },
+            async handler(ctx) {
+                this.broker.logger.info('[service][organizations]===>', 'calculateParents', ctx.params.orgId)
+                return this.calculateParents(ctx.params.orgId)
+            }
+        },
+        /**
+         * @api {post} calculateChildren 计算组织的子节点
+         * @apiName calculateChildren
+         * @apiGroup organizations.service.js
+         * @apiParam {String} orgId  组织ID
+         * @apiSuccess {String[]} 返回组织的子节点
+         */
+        calculateChildren: {
+            params: {
+                orgId: { type: "string" },
+            },
+            async handler(ctx) {
+                this.broker.logger.info('[service][organizations]===>', 'calculateChildren', ctx.params.orgId)
+                return this.calculateChildren(ctx.params.orgId)
+            }
+        },
+        /**
+         * @api {post} updateUsers 更新组织成员
+         * @apiName updateUsers
+         * @apiGroup organizations.service.js
+         * @apiParam {String} orgId  组织ID
+         */
+        updateUsers: {
+            params: {
+                orgId: { type: "string" },
+            },
+            async handler(ctx) {
+                this.broker.logger.info('[service][organizations]===>', 'updateUsers', ctx.params.orgId)
+                return this.updateUsers(ctx.params.orgId)
+            }
+        },
+        /**
+         * @api {post} calculateUsers 计算组织成员
+         * @apiName calculateUsers
+         * @apiGroup organizations.service.js
+         * @apiParam {String} orgId  组织ID
+         * @apiParam {Boolean} isIncludeParents 是否计算父组织
+         * @apiSuccess {String[]} 成员IDs
+         */
+        calculateUsers: {
+            params: {
+                orgId: { type: "string" },
+                isIncludeParents: { type: "boolean", optional: true },
+            },
+            async handler(ctx) {
+                this.broker.logger.info('[service][organizations]===>', 'calculateUsers', ctx.params)
+                return this.calculateUsers(ctx.params.orgId, ctx.params.isIncludeParents)
+            }
+        },
+        getOrganizationsRootNode: {
+            params: {
+                fields: { type: 'string', optional: true },
+                filters: { type: 'string', optional: true },
+            },
+            // 访问地址： GET /service/api/organizations/root
+            rest: { method: 'GET', path: '/root' },
+            async handler(ctx) {
+                return this.getOrganizationsRootNode(ctx)
+            }
+        }
+    },
+
+    /**
+     * Events
+     */
+    events: {
+
+    },
+
+    /**
+     * Methods
+     */
+    methods: {
+        /**
+         * 计算组织的全名
+         * @param {String} orgId 
+         * @returns 组织的全名
+         */
+        async calculateFullname(orgId) {
+            const orgObj = getObject('organizations')
+            const orgDoc = await orgObj.findOne(orgId)
+            let fullname = orgDoc.name;
+            if (!orgDoc.parent) {
+                return fullname;
+            }
+            let parentId = orgDoc.parent;
+            while (parentId) {
+                const parentOrg = await orgObj.findOne(parentId, { fields: ['parent', 'name'] });
+                if (parentOrg) {
+                    parentId = parentOrg.parent;
+                } else {
+                    parentId = null;
+                }
+                if (parentId) {
+                    fullname = (parentOrg != null ? parentOrg.name : void 0) + "/" + fullname;
+                }
+            }
+            return fullname;
+        },
+
+        /**
+         * 计算组织父节点
+         * @param {*} orgId 
+         */
+        async calculateParents(orgId) {
+            const orgObj = getObject('organizations')
+            const orgDoc = await orgObj.findOne(orgId)
+            var parentId, parentOrg, parents;
+            parents = [];
+            if (!orgDoc.parent) {
+                return parents;
+            }
+            parentId = orgDoc.parent;
+            while (parentId) {
+                parents.push(parentId);
+                parentOrg = await orgObj.findOne(parentId, { fields: ['parent', 'name'] });
+                if (parentOrg) {
+                    parentId = parentOrg.parent;
+                } else {
+                    parentId = null;
+                }
+            }
+            return parents;
+        },
+        /**
+         * 计算组织的子节点
+         * @param {*} orgId 
+         */
+        async calculateChildren(orgId) {
+            const orgObj = getObject('organizations')
+            var children, childrenObjs;
+            children = [];
+            childrenObjs = await orgObj.find({
+                filters: [
+                    ['parent', '=', orgId]
+                ],
+                fields: ['_id']
+            });
+            childrenObjs.forEach(function (child) {
+                return children.push(child._id);
+            });
+            return children;
+        },
+        /**
+         * 更新组织成员
+         * @param {*} orgId 
+         */
+        async updateUsers(orgId) {
+            const orgObj = getObject('organizations')
+            const suObj = getObject('space_users')
+            var spaceUsers, users;
+            users = [];
+            spaceUsers = await suObj.find({
+                filters: [
+                    ['organizations', '=', orgId]
+                ],
+                fields: ['user']
+            });
+            spaceUsers.forEach(function (su) {
+                return users.push(su.user);
+            });
+            await orgObj.directUpdate(orgId, { users: users });
+        },
+        /**
+         * 计算组织所有子节点
+         * @param {*} orgId 
+         * @returns 
+         */
+        async calculateAllChildren(orgId) {
+            const orgObj = getObject('organizations')
+            var children, childrenObjs;
+            children = [];
+            childrenObjs = await orgObj.find({
+                filters: [
+                    ['parents', '=', orgId]
+                ],
+                fields: ['_id']
+            });
+            childrenObjs.forEach(function (child) {
+                return children.push(child._id);
+            });
+            return _.uniq(children);
+        },
+        /**
+         * 计算组织成员
+         * @param {*} orgId 
+         * @param {*} isIncludeParents 
+         */
+        async calculateUsers(orgId, isIncludeParents) {
+            const orgObj = getObject('organizations')
+            var orgs, userOrgs, users;
+            orgs = isIncludeParents ? (await this.calculateAllChildren(orgId)) : (await this.calculateChildren(orgId));
+            orgs.push(orgId);
+            users = [];
+            userOrgs = await orgObj.find({
+                filters: [
+                    ['_id', 'in', orgs]
+                ],
+                fields: ['users']
+            });
+            userOrgs.forEach(function (org) {
+                var ref;
+                if (org != null ? (ref = org.users) != null ? ref.length : void 0 : void 0) {
+                    return users = users.concat(org.users);
+                }
+            });
+            return _.uniq(users);
+        },
+
+        /**
+         * 从所有组织数据中算出当前用户有权限访问的根组织节点
+         * @param {*} orgId 
+         * @returns 
+         */
+        async getOrganizationsRootNode(ctx) {
+            const orgObj = getObject('organizations');
+
+            let userFilters = null;
+
+            if(ctx.params?.filters && lodash.isString(ctx.params.filters)){
+                userFilters = JSON.parse(ctx.params.filters)
+            }
+            const orgs = await orgObj.find({filters: userFilters, fields: ['_id','parent', 'children']})
+            const rootIds = getTreeRootIds(orgs)
+            let queryFields = ctx.params?.fields || `
+                _id,
+                name,
+                fullname,
+                sort_no,
+                hidden,
+                _display:_ui{sort_no,hidden},
+                parent,
+                children
+            `;
+            const filters = ["_id", "in", rootIds];
+            let graphqlResult = await this.broker.call('api.graphql', {
+              query: `
+                query {
+                  rows: organizations(filters: ${JSON.stringify(filters)},sort: \"sort_no desc\") {
+                    ${queryFields}
+                  }
+                }
+              `},
+              {
+                meta: {
+                  user: ctx.meta.user
+                }
+              }
+            )
+            let rootOrgs = graphqlResult.data.rows;
+            return {
+                data: {
+                    rows: _.map(rootOrgs, (item)=>{
+                        return {
+                            ...item,
+                            defer: !!(item.children && item.children.length),
+                            __reloadTag: new Date().getTime()
+                        }
+                    }),
+                    count: orgs.length
+                }
+            };
+        }
+    },
+
+    /**
+     * Service created lifecycle event handler
+     */
+    created() {
+
+    },
+
+    /**
+     * Service started lifecycle event handler
+     */
+    async started() {
+        this.broker.logger.info('[service][organizations]===>', 'started')
+    },
+
+    /**
+     * Service stopped lifecycle event handler
+     */
+    async stopped() {
+
+    }
+};