View | Details | Raw Unified | Return to bug 10190
Collapse All | Expand All

(-)a/koha-tmpl/intranet-tmpl/prog/js/vue/components/Admin/CirculationTriggers/TriggersTable.vue (-140 / +196 lines)
Lines 1-5 Link Here
1
<template>
1
<template>
2
    <div class="page-section">
2
    <div class="page-section">
3
        <div class="page-section bg-info">
4
            {{
5
                $__(
6
                    "Bolid italic values denote fallback values where an override has not been set for the context."
7
                )
8
            }}
9
        </div>
3
        <table>
10
        <table>
4
            <thead>
11
            <thead>
5
                <th v-if="!modal">
12
                <th v-if="!modal">
Lines 39-53 Link Here
39
                        triggerNumber
46
                        triggerNumber
40
                    )"
47
                    )"
41
                    v-bind:key="'rule' + i"
48
                    v-bind:key="'rule' + i"
49
                    :class="{
50
                        selected_rule:
51
                            modal && i + 1 === parseInt(ruleBeingEdited),
52
                    }"
42
                >
53
                >
43
                    <td
54
                    <td v-if="!modal">
44
                        v-if="!modal"
45
                        :class="
46
                            modal && i + 1 === parseInt(ruleBeingEdited)
47
                                ? 'selected_rule'
48
                                : ''
49
                        "
50
                    >
51
                        {{
55
                        {{
52
                            handleContext(
56
                            handleContext(
53
                                rule.context.patron_category_id,
57
                                rule.context.patron_category_id,
Lines 56-69 Link Here
56
                            )
60
                            )
57
                        }}
61
                        }}
58
                    </td>
62
                    </td>
59
                    <td
63
                    <td v-if="!modal">
60
                        v-if="!modal"
61
                        :class="
62
                            modal && i + 1 === parseInt(ruleBeingEdited)
63
                                ? 'selected_rule'
64
                                : ''
65
                        "
66
                    >
67
                        {{
64
                        {{
68
                            handleContext(
65
                            handleContext(
69
                                rule.context.item_type_id,
66
                                rule.context.item_type_id,
Lines 73-199 Link Here
73
                            )
70
                            )
74
                        }}
71
                        }}
75
                    </td>
72
                    </td>
76
                    <td
73
                    <td v-if="modal">{{ i + 1 }}</td>
77
                        v-if="modal"
74
78
                        :class="
75
                    <!-- Delay -->
79
                            modal && i + 1 === parseInt(ruleBeingEdited)
76
                    <td>
80
                                ? 'selected_rule'
77
                        <span
81
                                : ''
78
                            :class="{
82
                        "
79
                                fallback: findEffectiveRule(
83
                    >
80
                                    rule,
84
                        {{ i + 1 }}
81
                                    `overdue_${modal ? i + 1 : triggerNumber}_delay`
85
                    </td>
82
                                ).isFallback,
86
                    <td
83
                            }"
87
                        :class="
84
                        >
88
                            modal && i + 1 === parseInt(ruleBeingEdited)
85
                            {{
89
                                ? 'selected_rule'
86
                                findEffectiveRule(
90
                                : ''
87
                                    rule,
91
                        "
88
                                    `overdue_${modal ? i + 1 : triggerNumber}_delay`
92
                    >
89
                                ).value +
93
                        {{
90
                                " " +
94
                            rule[
91
                                $__("days")
95
                                "overdue_" +
92
                            }}
96
                                    (modal ? i + 1 : triggerNumber) +
93
                        </span>
97
                                    "_delay"
98
                            ]
99
                                ? rule[
100
                                      "overdue_" +
101
                                          (modal ? i + 1 : triggerNumber) +
102
                                          "_delay"
103
                                  ] +
104
                                  " " +
105
                                  $__("days")
106
                                : 0 + " " + $__("days")
107
                        }}
108
                    </td>
94
                    </td>
109
                    <td
95
110
                        :class="
96
                    <!-- Notice -->
111
                            modal && i + 1 === parseInt(ruleBeingEdited)
97
                    <td>
112
                                ? 'selected_rule'
98
                        <span
113
                                : ''
99
                            :class="{
114
                        "
100
                                fallback: findEffectiveRule(
115
                    >
101
                                    rule,
116
                        {{
102
                                    `overdue_${modal ? i + 1 : triggerNumber}_notice`
117
                            handleNotice(
103
                                ).isFallback,
118
                                rule[
104
                            }"
119
                                    "overdue_" +
105
                        >
120
                                        (modal ? i + 1 : triggerNumber) +
106
                            {{
121
                                        "_notice"
107
                                handleNotice(
122
                                ]
108
                                    findEffectiveRule(
123
                            )
109
                                        rule,
124
                        }}
110
                                        `overdue_${modal ? i + 1 : triggerNumber}_notice`
111
                                    ).value
112
                                )
113
                            }}
114
                        </span>
125
                    </td>
115
                    </td>
126
                    <td
116
127
                        :class="
117
                    <!-- Email -->
128
                            modal && i + 1 === parseInt(ruleBeingEdited)
118
                    <td>
129
                                ? 'selected_rule'
119
                        <span
130
                                : ''
120
                            :class="{
131
                        "
121
                                fallback: findEffectiveRule(
132
                    >
122
                                    rule,
133
                        {{
123
                                    `overdue_${modal ? i + 1 : triggerNumber}_mtt`
134
                            handleTransport(
124
                                ).isFallback,
135
                                rule[
125
                            }"
136
                                    "overdue_" +
126
                        >
137
                                        (modal ? i + 1 : triggerNumber) +
127
                            {{
138
                                        "_mtt"
128
                                handleTransport(
139
                                ],
129
                                    findEffectiveRule(
140
                                "email"
130
                                        rule,
141
                            )
131
                                        `overdue_${modal ? i + 1 : triggerNumber}_mtt`
142
                        }}
132
                                    ).value,
133
                                    "email"
134
                                )
135
                            }}
136
                        </span>
143
                    </td>
137
                    </td>
144
                    <td
138
145
                        :class="
139
                    <!-- Print -->
146
                            modal && i + 1 === parseInt(ruleBeingEdited)
140
                    <td>
147
                                ? 'selected_rule'
141
                        <span
148
                                : ''
142
                            :class="{
149
                        "
143
                                fallback: findEffectiveRule(
150
                    >
144
                                    rule,
151
                        {{
145
                                    `overdue_${modal ? i + 1 : triggerNumber}_mtt`
152
                            handleTransport(
146
                                ).isFallback,
153
                                rule[
147
                            }"
154
                                    "overdue_" +
148
                        >
155
                                        (modal ? i + 1 : triggerNumber) +
149
                            {{
156
                                        "_mtt"
150
                                handleTransport(
157
                                ],
151
                                    findEffectiveRule(
158
                                "print"
152
                                        rule,
159
                            )
153
                                        `overdue_${modal ? i + 1 : triggerNumber}_mtt`
160
                        }}
154
                                    ).value,
155
                                    "print"
156
                                )
157
                            }}
158
                        </span>
161
                    </td>
159
                    </td>
162
                    <td
160
163
                        :class="
161
                    <!-- SMS -->
164
                            modal && i + 1 === parseInt(ruleBeingEdited)
162
                    <td>
165
                                ? 'selected_rule'
163
                        <span
166
                                : ''
164
                            :class="{
167
                        "
165
                                fallback: findEffectiveRule(
168
                    >
166
                                    rule,
169
                        {{
167
                                    `overdue_${modal ? i + 1 : triggerNumber}_mtt`
170
                            handleTransport(
168
                                ).isFallback,
171
                                rule[
169
                            }"
172
                                    "overdue_" +
170
                        >
173
                                        (modal ? i + 1 : triggerNumber) +
171
                            {{
174
                                        "_mtt"
172
                                handleTransport(
175
                                ],
173
                                    findEffectiveRule(
176
                                "sms"
174
                                        rule,
177
                            )
175
                                        `overdue_${modal ? i + 1 : triggerNumber}_mtt`
178
                        }}
176
                                    ).value,
177
                                    "sms"
178
                                )
179
                            }}
180
                        </span>
179
                    </td>
181
                    </td>
180
                    <td
182
181
                        :class="
183
                    <!-- Restricts Checkouts -->
182
                            modal && i + 1 === parseInt(ruleBeingEdited)
184
                    <td>
183
                                ? 'selected_rule'
185
                        <span
184
                                : ''
186
                            :class="{
185
                        "
187
                                fallback: findEffectiveRule(
186
                    >
188
                                    rule,
187
                        {{
189
                                    `overdue_${modal ? i + 1 : triggerNumber}_restrict`
188
                            handleRestrictions(
190
                                ).isFallback,
189
                                rule[
191
                            }"
190
                                    "overdue_" +
192
                        >
191
                                        (modal ? i + 1 : triggerNumber) +
193
                            {{
192
                                        "_restrict"
194
                                handleRestrictions(
193
                                ]
195
                                    findEffectiveRule(
194
                            )
196
                                        rule,
195
                        }}
197
                                        `overdue_${modal ? i + 1 : triggerNumber}_restrict`
198
                                    ).value
199
                                )
200
                            }}
201
                        </span>
196
                    </td>
202
                    </td>
203
197
                    <td v-if="!modal" class="actions">
204
                    <td v-if="!modal" class="actions">
198
                        <router-link
205
                        <router-link
199
                            :to="{
206
                            :to="{
Lines 238-244 export default { Link Here
238
                ? value.includes(type)
245
                ? value.includes(type)
239
                    ? this.$__("Yes")
246
                    ? this.$__("Yes")
240
                    : this.$__("No")
247
                    : this.$__("No")
241
                : this.$__("Default");
248
                : "";
242
        },
249
        },
243
        handleRestrictions(value) {
250
        handleRestrictions(value) {
244
            return value === "1" ? this.$__("Yes") : this.$__("No");
251
            return value === "1" ? this.$__("Yes") : this.$__("No");
Lines 256-276 export default { Link Here
256
        },
263
        },
257
        handleNotice(notice) {
264
        handleNotice(notice) {
258
            const letter = this.letters.find(letter => letter.code === notice);
265
            const letter = this.letters.find(letter => letter.code === notice);
259
            return letter
266
            return letter ? letter.name : notice;
260
                ? letter.name
267
        },
261
                    ? letter.name
268
        findEffectiveRule(ruleSet, key) {
262
                    : notice
269
            // Check if the current rule's value for the key is null
263
                : this.$__("Default");
270
            if (ruleSet[key] === null) {
271
                // Filter rules to only those with non-null values for the specified key
272
                const relevantRules = this.circRules.filter(
273
                    rule => rule[key] !== null
274
                );
275
276
                // Function to calculate specificity score
277
                const getSpecificityScore = ruleContext => {
278
                    let score = 0;
279
                    if (
280
                        ruleContext.library_id !== "*" &&
281
                        ruleContext.library_id === ruleSet.library_id
282
                    )
283
                        score += 4;
284
                    if (
285
                        ruleContext.patron_category_id !== "*" &&
286
                        ruleContext.patron_category_id ===
287
                            ruleSet.patron_category_id
288
                    )
289
                        score += 2;
290
                    if (
291
                        ruleContext.item_type_id !== "*" &&
292
                        ruleContext.item_type_id === ruleSet.item_type_id
293
                    )
294
                        score += 1;
295
                    return score;
296
                };
297
298
                // Sort the rules based on specificity score, descending
299
                const sortedRules = relevantRules.sort((a, b) => {
300
                    return (
301
                        getSpecificityScore(b.context) -
302
                        getSpecificityScore(a.context)
303
                    );
304
                });
305
306
                // If no rule found, return null
307
                if (sortedRules.length === 0) {
308
                    return { value: null, isFallback: true };
309
                }
310
311
                // Get the value from the most specific rule
312
                const bestRule = sortedRules[0];
313
                return { value: bestRule[key], isFallback: true };
314
            } else {
315
                // If the current rule's value is not null, use it directly
316
                return { value: ruleSet[key], isFallback: false };
317
            }
264
        },
318
        },
265
    },
319
    },
266
};
320
};
267
</script>
321
</script>
268
322
269
<style scoped>
323
<style scoped>
270
.selected_rule {
324
.selected_rule > td {
271
    background-color: yellow !important;
325
    background-color: yellow !important;
272
}
326
}
273
327
.fallback {
328
    font-style: italic;
329
    font-weight: bold;
330
}
274
.actions a {
331
.actions a {
275
    margin-right: 5px;
332
    margin-right: 5px;
276
}
333
}
277
- 

Return to bug 10190