w-web-perm 1.0.12 → 1.0.13

package/src/plugins/mShare.mjs

@@ -1,221 +1,511 @@
 //前後端共用函數區
 import JSON5 from 'json5'
-import get from 'lodash-es/get.js'
-import each from 'lodash-es/each.js'
-import map from 'lodash-es/map.js'
-import find from 'lodash-es/find.js'
-import join from 'lodash-es/join.js'
-import cloneDeep from 'lodash-es/cloneDeep.js'
-import takeRight from 'lodash-es/takeRight.js'
-import dropRight from 'lodash-es/dropRight.js'
-import sortBy from 'lodash-es/sortBy.js'
+import get from 'lodash-es/get.js'
+import each from 'lodash-es/each.js'
+import map from 'lodash-es/map.js'
+import join from 'lodash-es/join.js'
+import size from 'lodash-es/size.js'
+import find from 'lodash-es/find.js'
+import filter from 'lodash-es/filter.js'
+import cloneDeep from 'lodash-es/cloneDeep.js'
+import takeRight from 'lodash-es/takeRight.js'
+import dropRight from 'lodash-es/dropRight.js'
+import sortBy from 'lodash-es/sortBy.js'
 import sep from 'wsemi/src/sep.mjs'
 import iseobj from 'wsemi/src/iseobj.mjs'
+import isestr from 'wsemi/src/isestr.mjs'
 import haskey from 'wsemi/src/haskey.mjs'
-import composeToTree from 'wsemi/src/composeToTree.mjs'
 
 
-//dlm
-let dlm = '/'
+// //dlm
+// let dlm = '/'
 
 
-function getAllBlocks(targets) {
+function getNameNew(rows, key = 'name', nameBase = '', nameExt = '') {
 
-    //rs
-    let rs = map(targets, (v) => {
-
-        //text, parentId
-        let s = sep(v.id, dlm) //[tag:dlm]
-        let text = get(takeRight(s), 0) //取最後節點
-        s = dropRight(s, 1)
-        let parentId = join(s, dlm) //[tag:dlm] 取父節點
+    //hasName
+    let hasName = (name) => {
+        let b = false
+        each(rows, (r) => {
+            let _name = get(r, key, '')
+            if (_name === name) {
+                b = true
+                return false //跳出
+            }
+        })
+        return b
+    }
 
-        return {
-            ...v,
-            idTemp: v.id,
-            parentId,
-            text,
+    //nameNew
+    let nameNew = ''
+    let b = true
+    let i = 0
+    while (b) {
+        i++
+        let pre = ''
+        if (isestr(nameBase)) {
+            pre = `${nameBase} - `
         }
-    })
-    // console.log('rs', rs)
-
-    //sortBy
-    rs = sortBy(rs, 'order')
-    // console.log('rs sortBy', rs)
+        nameNew = `${pre}${nameExt}(${i})` //vo.$t('pemiAddNameNew') vo.$t('pemiCopyNameNew')
+        b = hasName(nameNew)
+    }
 
-    return rs
+    return nameNew
 }
 
 
-function getTreeBlocks(targets) {
+// function getAllBlocks(targets) {
 
-    //getAllBlocks
-    let blocks = getAllBlocks(targets)
-    // console.log('blocks', blocks)
+//     //rs
+//     let rs = map(targets, (v) => {
 
-    //opt
-    let opt = {
-        bindKey: 'id',
-        bindParent: 'parentId',
-        bindChildren: 'children',
-        saveExtProps: true,
-    }
+//         //text, parentId
+//         let s = sep(v.id, dlm) //[tag:dlm]
+//         let text = get(takeRight(s), 0) //取最後節點
+//         s = dropRight(s, 1)
+//         let parentId = join(s, dlm) //[tag:dlm] 取父節點
 
-    //composeToTree
-    let r
-    try {
-        r = composeToTree(blocks, opt)
-    }
-    catch (err) {
-        console.log(err)
-    }
-    // console.log('treeBlocks', cloneDeep(r))
+//         return {
+//             ...v,
+//             idTemp: v.id,
+//             parentId,
+//             text,
+//         }
+//     })
+//     // console.log('rs', rs)
 
-    return r
-}
+//     //sortBy
+//     rs = sortBy(rs, 'order')
+//     // console.log('rs sortBy', rs)
 
+//     return rs
+// }
 
-function getUserGroups(user, ruleGroups) {
 
-    //userGroups
-    let ruleGroupsIds = get(user, 'ruleGroupsIds', '')
+// function getTreeBlocks(targets) {
 
-    //sep
-    let s = sep(ruleGroupsIds, ';')
+//     //getAllBlocks
+//     let blocks = getAllBlocks(targets)
+//     // console.log('blocks', blocks)
 
-    //gs
-    let gs = []
-    each(s, (id) => {
-        let g = find(ruleGroups, { id })
-        if (iseobj(g)) {
-            gs.push(g)
-        }
-    })
+//     //opt
+//     let opt = {
+//         bindKey: 'id',
+//         bindParent: 'parentId',
+//         bindChildren: 'children',
+//         saveExtProps: true,
+//     }
 
-    //add rules
-    gs = map(gs, (g) => {
-        let rules = JSON5.parse(g.crules)
-        g.rules = rules
-        return g
-    })
+//     //composeToTree
+//     let r
+//     try {
+//         r = composeToTree(blocks, opt)
+//     }
+//     catch (err) {
+//         console.log(err)
+//     }
+//     // console.log('treeBlocks', cloneDeep(r))
 
-    return gs
-}
+//     return r
+// }
 
 
-function getTargetsByGroup(targets, group) {
+// function getUserGroups(user, pemis) {
 
-    //cloneDeep
-    targets = cloneDeep(targets)
+//     //userGroups
+//     let ruleGroupsIds = get(user, 'ruleGroupsIds', '')
 
-    //sortBy
-    targets = sortBy(targets, 'order')
+//     //sep
+//     let s = sep(ruleGroupsIds, ';')
 
-    //cloneDeep
-    group = cloneDeep(group)
+//     //gs
+//     let gs = []
+//     each(s, (id) => {
+//         let g = find(pemis, { id })
+//         if (iseobj(g)) {
+//             gs.push(g)
+//         }
+//     })
 
-    //rules
-    let rules = JSON5.parse(group.crules)
+//     //add pemis
+//     gs = map(gs, (g) => {
+//         let pemis = JSON5.parse(g.crules)
+//         g.pemis = pemis
+//         return g
+//     })
 
-    //rulesDisplay
-    let rulesDisplay = {}
-    let ks = ['show', 'active']
-    each(ks, (k) => {
+//     return gs
+// }
 
-        //___all___
-        let def = get(rules, `___all___.${k}`)
-        def = (def === 'y') ? 'y' : 'n'
 
-        //other props
-        each(targets, (v) => {
+// function getTargetsByGroup(targets, group) {
 
-            //krule
-            let krule = v.id
+//     //cloneDeep
+//     targets = cloneDeep(targets)
 
-            //check
-            if (!rulesDisplay[krule]) {
-                rulesDisplay[krule] = {}
-            }
+//     //sortBy
+//     targets = sortBy(targets, 'order')
+
+//     //cloneDeep
+//     group = cloneDeep(group)
+
+//     //pemis
+//     let pemis = JSON5.parse(group.crules)
+
+//     //rulesDisplay
+//     let rulesDisplay = {}
+//     let ks = ['show', 'active']
+//     each(ks, (k) => {
+
+//         //___all___
+//         let def = get(pemis, `___all___.${k}`)
+//         def = (def === 'y') ? 'y' : 'n'
+
+//         //other props
+//         each(targets, (v) => {
+
+//             //krule
+//             let krule = v.id
+
+//             //check
+//             if (!rulesDisplay[krule]) {
+//                 rulesDisplay[krule] = {}
+//             }
+
+//             //rule
+//             let rule = pemis[krule]
+
+//             //r
+//             let r = null
 
-            //rule
-            let rule = rules[krule]
+//             //b
+//             let b = get(rule, `${k}`)
+//             if (b === 'y' || b === 'n') {
+//                 r = b
+//             }
+//             else {
+//                 r = def
+//             }
 
-            //r
-            let r = null
+//             //save
+//             rulesDisplay[krule][k] = r //因krule內含有「.」故不能用set
 
-            //b
-            let b = get(rule, `${k}`)
-            if (b === 'y' || b === 'n') {
-                r = b
+//         })
+
+//     })
+//     // console.log('rulesDisplay', rulesDisplay)
+
+//     return rulesDisplay
+// }
+
+
+function getUserRules(user, grups, pemis, targets) {
+
+    let cvKpToArr = (kp) => {
+        let rs = []
+        each(kp, (v, k) => {
+            // console.log(k, v)
+            let r = {
+                name: k,
+            }
+            if (iseobj(v)) {
+                r = {
+                    ...r,
+                    ...v,
+                }
             }
             else {
-                r = def
+                r = {
+                    ...r,
+                    isActive: v,
+                }
             }
-
-            //save
-            rulesDisplay[krule][k] = r //因krule內含有「.」故不能用set
-
+            rs.push(r)
         })
+        return rs
+    }
 
-    })
-    // console.log('rulesDisplay', rulesDisplay)
+    let cvStrToArr = (c) => {
 
-    return rulesDisplay
-}
+        //kp
+        let kp = {}
+        try {
+            kp = JSON5.parse(c)
+            // console.log('kp', kp)
+        }
+        catch (err) {
+            console.log('c', c)
+            console.log(err)
+        }
 
+        //arr
+        let arr = []
+        try {
+            arr = cvKpToArr(kp)
+            // console.log('arr', arr)
+        }
+        catch (err) {
+            console.log('c', c)
+            console.log('kp', kp)
+            console.log(err)
+        }
 
-function getUserRules(user, ruleGroups, targets) {
-    //依照使用者所允許之ruleGroups轉出對全部targets權限
+        return arr
+    }
 
-    //ruleGroupsIds
-    let ruleGroupsIds = get(user, 'ruleGroupsIds', '')
+    let arrFinder = (arrSrc, arrPks, key) => {
+        let rs = []
+        each(arrSrc, (v) => {
+            let tSrc = get(v, key, '')
+            each(arrPks, (vv) => {
+                let tPks = get(vv, key, '')
+                if (tSrc === tPks) {
+                    rs.push({
+                        ...v,
+                        data: vv,
+                    })
+                    return false //跳出
+                }
+            })
+        })
+        return rs
+    }
 
-    //getUserGroups
-    let gs = getUserGroups(user, ruleGroups)
-    // console.log('gs', gs)
+    let mergeRules = (rs) => {
 
-    //ruleGroupsNames
-    let ruleGroupsNames = map(gs, 'name')
-    ruleGroupsNames = join(ruleGroupsNames, ';')
+        //ts
+        let ts = []
+        each(rs, (v) => {
 
-    //getTargetsByGroup
-    let rulesDisplay = {}
-    each(gs, (g) => {
-        let r = getTargetsByGroup(targets, g)
-        each(r, (v, k) => {
+            //mode
+            let mode = get(v, 'mode', '')
 
             //check
-            if (!haskey(rulesDisplay, k)) {
-                rulesDisplay[k] = {}
+            if (mode !== 'OR' && mode !== 'AND') {
+                return true //跳出換下一個
             }
 
-            //merge
-            let ks = ['show', 'active']
-            each(ks, (kk) => {
-                let bOld = rulesDisplay[k][kk]
-                let bNew = r[k][kk]
-                if (bOld === 'y') {
-                    //不用覆寫
-                }
-                else {
-                    //需覆寫
-                    if (bNew === 'y') {
-                        rulesDisplay[k][kk] = 'y'
+            //kpRule
+            let rules = get(v, 'rules', [])
+            let kpRule = {}
+            each(rules, (vv) => {
+                kpRule[vv.name] = vv.isActive
+            })
+
+            //push
+            ts.push({
+                mode,
+                kpRule,
+            })
+
+        })
+
+        //check
+        if (size(ts) === 0) {
+            return []
+        }
+
+        let objOR = (obj1, obj2) => {
+            let kp = {}
+            let objs = [obj1, obj2]
+            each(objs, (obj) => {
+                each(obj, (v, k) => {
+                    if (!haskey(kp, k)) {
+                        kp[k] = 'n'
+                    }
+                    if (kp[k] === 'y' || v === 'y') {
+                        kp[k] = 'y'
                     }
                     else {
-                        rulesDisplay[k][kk] = 'n'
+                        kp[k] = 'n'
                     }
-                }
+                })
+            })
+            return kp
+        }
+
+        let objAND = (obj1, obj2) => {
+            let kp = cloneDeep(obj1)
+            let objs = [obj2]
+            each(objs, (obj) => {
+                each(obj, (v, k) => {
+                    if (!haskey(kp, k)) {
+                        kp[k] = 'n'
+                    }
+                    if (kp[k] === 'y' && v === 'y') {
+                        kp[k] = 'y'
+                    }
+                    else {
+                        kp[k] = 'n'
+                    }
+                })
             })
+            return kp
+        }
+
+        let tsOR = filter(ts, { mode: 'OR' })
+        let tsAND = filter(ts, { mode: 'AND' })
+        // console.log('tsOR', tsOR)
+        // console.log('tsAND', tsAND)
+
+        //kpRuleFin
+        let kpRuleFin = null
+        if (size(tsOR) > 0) {
+            kpRuleFin = get(tsOR, `0.kpRule`)
+        }
+        else if (size(tsAND) > 0) {
+            kpRuleFin = get(tsAND, `0.kpRule`)
+        }
+        // console.log('kpRuleFin(0)', kpRuleFin)
 
+        //or
+        each(tsOR, (t) => {
+            let kpRule = get(t, 'kpRule', {})
+            kpRuleFin = objOR(kpRuleFin, kpRule)
         })
+        // console.log('kpRuleFin(or)', kpRuleFin)
+
+        //and
+        each(tsAND, (t, kt) => {
+            let kpRule = get(t, 'kpRule', {})
+            // console.log(kt, '(and)(in) kpRule', kpRule)
+            // console.log(kt, '(and)(in) kpRuleFin', kpRuleFin)
+            kpRuleFin = objAND(kpRuleFin, kpRule)
+            // console.log(kt, '(and)(out) kpRuleFin', kpRuleFin)
+        })
+        // console.log('kpRuleFin(and)', kpRuleFin)
+
+        //rulesFin
+        let rulesFin = []
+        each(kpRuleFin, (v, k) => {
+            rulesFin.push({
+                name: k,
+                isActive: v,
+            })
+        })
+        // console.log('rulesFin', rulesFin)
+
+        return rulesFin
+    }
+
+    //cgrups
+    let cgrups = get(user, 'cgrups', '')
+    // console.log('cgrups', cgrups)
+
+    //cvStrToArr
+    let _grups = cvStrToArr(cgrups)
+    // console.log('cvStrToArr _grups', _grups)
+
+    //_grups
+    _grups = arrFinder(_grups, grups, 'name')
+    // console.log('arrFinder _grups', cloneDeep(_grups))
+
+    //filter
+    _grups = filter(_grups, { isActive: 'y' })
+    // console.log('filter _grups', cloneDeep(_grups))
+
+    //proc _pemis
+    _grups = map(_grups, (v) => {
+        let cpemis = get(v, 'data.cpemis', '')
+        let _pemis = cvStrToArr(cpemis)
+        _pemis = filter(_pemis, { isActive: 'y' })
+        _pemis = arrFinder(_pemis, pemis, 'name')
+        v.data._pemis = _pemis
+        return v
     })
-    // console.log('rulesDisplay', rulesDisplay)
+    // console.log('proc _pemis _grups', cloneDeep(_grups))
+
+    //proc _rules
+    _grups = map(_grups, (v) => {
+        let _pemis = get(v, 'data._pemis', [])
+        _pemis = map(_pemis, (vv) => {
+            let crules = get(vv, 'data.crules', '')
+            let _rules = cvStrToArr(crules)
+            vv.data._rules = _rules
+            return vv
+        })
+        v.data._pemis = _pemis
+        return v
+    })
+    // console.log('proc _rules _grups', cloneDeep(_grups))
+
+    //merge _rules
+    let _rules = []
+    if (true) {
+
+        //rrs
+        let rrs = []
+        each(_grups, (v) => {
+
+            let modeG = v.mode
+            let _pemis = v.data._pemis
+
+            //rs
+            let rs = []
+            each(_pemis, (vv) => {
+                let modeP = vv.mode
+                let _rules = vv.data._rules
+                rs.push({
+                    mode: modeP,
+                    rules: _rules,
+                })
+
+            })
+            // console.log('rs', rs)
+
+            //mergeRules
+            let rulesP = mergeRules(rs)
+            // console.log('rulesP', rulesP)
+
+            //t
+            let t = {
+                mode: modeG,
+                rules: rulesP,
+            }
+
+            //push
+            rrs.push(t)
+
+        })
+        // console.log('rrs', rrs)
+
+        //mergeRules
+        let rulesG = mergeRules(rrs)
+        // console.log('rulesG', rulesG)
+
+        //save
+        _rules = rulesG
+
+    }
+    // console.log('merge _rules', cloneDeep(_rules))
+
+    //expand _rules
+    if (true) {
+        let kp = {}
+        each(_rules, (v) => {
+            kp[v.name] = v.isActive
+        })
+        each(targets, (t) => {
+            // console.log('t', t)
+            if (!haskey(kp, t.id)) {
+                kp[t.id] = 'n'
+            }
+        })
+        let rs = []
+        each(kp, (v, k) => {
+            let r = {
+                name: k,
+                isActive: v,
+            }
+            rs.push(r)
+        })
+        _rules = rs
+    }
+    // console.log('expand _rules', cloneDeep(_rules))
 
     return {
-        ruleGroupsIds,
-        ruleGroupsNames,
-        rules: rulesDisplay,
+        grups: _grups,
+        rules: _rules,
     }
 }
 
@@ -226,8 +516,9 @@ export {
     // atParse,
     // atMerge,
     // atRemove,
+    getNameNew,
     // getAllBlocks,
-    getTreeBlocks,
+    // getTreeBlocks,
     // getUserGroups,
     // getTargetsByGroup,
     getUserRules