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

(-)a/koha-tmpl/intranet-tmpl/prog/js/vue/components/ERM/AgreementsList.vue (-1 / +1 lines)
Lines 42-48 Link Here
42
<script>
42
<script>
43
import flatPickr from "vue-flatpickr-component"
43
import flatPickr from "vue-flatpickr-component"
44
import Toolbar from "./AgreementsToolbar.vue"
44
import Toolbar from "./AgreementsToolbar.vue"
45
import { inject, createVNode, render, ref } from "vue"
45
import { inject, ref } from "vue"
46
import { APIClient } from "../../fetch/api-client.js"
46
import { APIClient } from "../../fetch/api-client.js"
47
import { storeToRefs } from "pinia"
47
import { storeToRefs } from "pinia"
48
import { build_url } from "../../composables/datatables"
48
import { build_url } from "../../composables/datatables"
(-)a/koha-tmpl/intranet-tmpl/prog/js/vue/components/ERM/LicensesList.vue (-235 / +115 lines)
Lines 3-9 Link Here
3
    <div v-else-if="licenses" id="licenses_list">
3
    <div v-else-if="licenses" id="licenses_list">
4
        <Toolbar />
4
        <Toolbar />
5
        <div v-if="licenses.length" class="page-section">
5
        <div v-if="licenses.length" class="page-section">
6
            <table :id="table_id"></table>
6
            <KohaTable
7
                ref="table"
8
                v-bind="tableOptions"
9
                @show="doShow"
10
                @edit="doEdit"
11
                @delete="doDelete"
12
            ></KohaTable>
7
        </div>
13
        </div>
8
        <div v-else-if="initialized" class="dialog message">
14
        <div v-else-if="initialized" class="dialog message">
9
            {{ $__("There are no licenses defined") }}
15
            {{ $__("There are no licenses defined") }}
Lines 13-22 Link Here
13
19
14
<script>
20
<script>
15
import Toolbar from "./LicensesToolbar.vue"
21
import Toolbar from "./LicensesToolbar.vue"
16
import { inject, createVNode, render } from "vue"
22
import { inject, ref } from "vue"
17
import { storeToRefs } from "pinia"
23
import { storeToRefs } from "pinia"
18
import { APIClient } from "../../fetch/api-client.js"
24
import { APIClient } from "../../fetch/api-client.js"
19
import { useDataTable } from "../../composables/datatables"
25
import KohaTable from "../KohaTable.vue"
20
26
21
export default {
27
export default {
22
    setup() {
28
    setup() {
Lines 28-54 export default { Link Here
28
34
29
        const { setConfirmationDialog, setMessage } = inject("mainStore")
35
        const { setConfirmationDialog, setMessage } = inject("mainStore")
30
36
31
        const table_id = "license_list"
37
        const table = ref()
32
        useDataTable(table_id)
33
38
34
        return {
39
        return {
35
            vendors,
40
            vendors,
36
            get_lib_from_av,
41
            get_lib_from_av,
37
            map_av_dt_filter,
42
            map_av_dt_filter,
38
            table_id,
43
            table,
39
            setConfirmationDialog,
44
            setConfirmationDialog,
40
            setMessage,
45
            setMessage,
46
            license_table_settings,
41
        }
47
        }
42
    },
48
    },
43
    data: function () {
49
    data: function () {
44
        return {
50
        return {
45
            licenses: [],
51
            licenses: [],
46
            initialized: false,
52
            initialized: false,
53
            tableOptions: {
54
                columns: this.getTableColumns(),
55
                url: "/api/v1/erm/licenses",
56
                options: { embed: "vendor" },
57
                table_settings: this.license_table_settings,
58
                add_filters: true,
59
                filters_options: {
60
                    1: () =>
61
                        this.vendors.map(e => {
62
                            e["_id"] = e["id"]
63
                            e["_str"] = e["name"]
64
                            return e
65
                        }),
66
                    3: () => this.map_av_dt_filter("av_license_types"),
67
                    4: () => this.map_av_dt_filter("av_license_statuses"),
68
                },
69
                actions: {
70
                    0: ["show"],
71
                    "-1": ["edit", "delete"],
72
                },
73
            },
47
        }
74
        }
48
    },
75
    },
49
    beforeRouteEnter(to, from, next) {
76
    beforeRouteEnter(to, from, next) {
50
        next(vm => {
77
        next(vm => {
51
            vm.getLicenses().then(() => vm.build_datatable())
78
            vm.getLicenses().then(() => (vm.initialized = true))
52
        })
79
        })
53
    },
80
    },
54
    methods: {
81
    methods: {
Lines 57-333 export default { Link Here
57
            await client.licenses.getAll().then(
84
            await client.licenses.getAll().then(
58
                licenses => {
85
                licenses => {
59
                    this.licenses = licenses
86
                    this.licenses = licenses
60
                    this.initialized = true
61
                },
87
                },
62
                error => {}
88
                error => {}
63
            )
89
            )
64
        },
90
        },
65
        show_license: function (license_id) {
91
        doShow: function (license, dt, event) {
66
            this.$router.push("/cgi-bin/koha/erm/licenses/" + license_id)
92
            event.preventDefault()
93
            this.$router.push(
94
                "/cgi-bin/koha/erm/licenses/" + license.license_id
95
            )
67
        },
96
        },
68
        edit_license: function (license_id) {
97
        doEdit: function (license, dt, event) {
69
            this.$router.push("/cgi-bin/koha/erm/licenses/edit/" + license_id)
98
            this.$router.push(
99
                "/cgi-bin/koha/erm/licenses/edit/" + license.license_id
100
            )
70
        },
101
        },
71
        delete_license: function (license_id, license_name) {
102
        doDelete: function (license, dt, event) {
72
            this.setConfirmationDialog(
103
            this.setConfirmationDialog(
73
                {
104
                {
74
                    title: this.$__(
105
                    title: this.$__(
75
                        "Are you sure you want to remove this license?"
106
                        "Are you sure you want to remove this license?"
76
                    ),
107
                    ),
77
                    message: license_name,
108
                    message: license.name,
78
                    accept_label: this.$__("Yes, delete"),
109
                    accept_label: this.$__("Yes, delete"),
79
                    cancel_label: this.$__("No, do not delete"),
110
                    cancel_label: this.$__("No, do not delete"),
80
                },
111
                },
81
                () => {
112
                () => {
82
                    const client = APIClient.erm
113
                    const client = APIClient.erm
83
                    client.licenses.delete(license_id).then(
114
                    client.licenses.delete(license.license_id).then(
84
                        success => {
115
                        success => {
85
                            this.setMessage(
116
                            this.setMessage(
86
                                this.$__("License %s deleted").format(
117
                                this.$__("License %s deleted").format(
87
                                    license_name
118
                                    license.name
88
                                ),
119
                                ),
89
                                true
120
                                true
90
                            )
121
                            )
91
                            $("#" + this.table_id)
122
                            dt.draw()
92
                                .DataTable()
93
                                .ajax.url("/api/v1/erm/licenses")
94
                                .draw()
95
                        },
123
                        },
96
                        error => {}
124
                        error => {}
97
                    )
125
                    )
98
                }
126
                }
99
            )
127
            )
100
        },
128
        },
101
        build_datatable: function () {
129
        getTableColumns: function () {
102
            let show_license = this.show_license
103
            let edit_license = this.edit_license
104
            let delete_license = this.delete_license
105
            let get_lib_from_av = this.get_lib_from_av
130
            let get_lib_from_av = this.get_lib_from_av
106
            let map_av_dt_filter = this.map_av_dt_filter
107
            let default_search = this.$route.query.q
108
            let table_id = this.table_id
109
110
            window["vendors"] = this.vendors.map(e => {
111
                e["_id"] = e["id"]
112
                e["_str"] = e["name"]
113
                return e
114
            })
115
            let vendors_map = this.vendors.reduce((map, e) => {
116
                map[e.id] = e
117
                return map
118
            }, {})
119
            let avs = ["av_license_types", "av_license_statuses"]
120
            avs.forEach(function (av_cat) {
121
                window[av_cat] = map_av_dt_filter(av_cat)
122
            })
123
131
124
            $("#" + table_id).kohaTable(
132
            return [
125
                {
133
                {
126
                    ajax: {
134
                    title: __("Name"),
127
                        url: "/api/v1/erm/licenses",
135
                    data: "me.license_id:me.name",
136
                    searchable: true,
137
                    orderable: true,
138
                    render: function (data, type, row, meta) {
139
                        return (
140
                            '<a href="/cgi-bin/koha/erm/licenses/' +
141
                            row.license_id +
142
                            '" class="show">' +
143
                            row.name +
144
                            "</a>"
145
                        )
128
                    },
146
                    },
129
                    order: [[0, "asc"]],
147
                },
130
                    search: { search: default_search },
148
                {
131
                    columnDefs: [
149
                    title: __("Vendor"),
132
                        {
150
                    data: "vendor_id",
133
                            targets: [0, 1],
151
                    searchable: true,
134
                            render: function (data, type, row, meta) {
152
                    orderable: true,
135
                                if (type == "display") {
153
                    render: function (data, type, row, meta) {
136
                                    return escape_str(data)
154
                        return row.vendor_id != undefined ? row.vendor.name : ""
137
                                }
155
                    },
138
                                return data
156
                },
139
                            },
140
                        },
141
                    ],
142
                    columns: [
143
                        {
144
                            title: __("Name"),
145
                            data: "me.license_id:me.name",
146
                            searchable: true,
147
                            orderable: true,
148
                            render: function (data, type, row, meta) {
149
                                // Rendering done in drawCallback
150
                                return ""
151
                            },
152
                        },
153
                        {
154
                            title: __("Vendor"),
155
                            data: "vendor_id",
156
                            searchable: true,
157
                            orderable: true,
158
                            render: function (data, type, row, meta) {
159
                                return row.vendor_id != undefined
160
                                    ? escape_str(
161
                                          vendors_map[row.vendor_id].name
162
                                      )
163
                                    : ""
164
                            },
165
                        },
166
167
                        {
168
                            title: __("Description"),
169
                            data: "description",
170
                            searchable: true,
171
                            orderable: true,
172
                        },
173
                        {
174
                            title: __("Type"),
175
                            data: "type",
176
                            searchable: true,
177
                            orderable: true,
178
                            render: function (data, type, row, meta) {
179
                                return escape_str(
180
                                    get_lib_from_av(
181
                                        "av_license_types",
182
                                        row.type
183
                                    )
184
                                )
185
                            },
186
                        },
187
                        {
188
                            title: __("Status"),
189
                            data: "status",
190
                            searchable: true,
191
                            orderable: true,
192
                            render: function (data, type, row, meta) {
193
                                return escape_str(
194
                                    get_lib_from_av(
195
                                        "av_license_statuses",
196
                                        row.status
197
                                    )
198
                                )
199
                            },
200
                        },
201
                        {
202
                            title: __("Started on"),
203
                            data: "started_on",
204
                            searchable: true,
205
                            orderable: true,
206
                            render: function (data, type, row, meta) {
207
                                return $date(row.started_on)
208
                            },
209
                        },
210
                        {
211
                            title: __("Ended on"),
212
                            data: "ended_on",
213
                            searchable: true,
214
                            orderable: true,
215
                            render: function (data, type, row, meta) {
216
                                return $date(row.ended_on)
217
                            },
218
                        },
219
                        {
220
                            title: __("Actions"),
221
                            data: function (row, type, val, meta) {
222
                                return '<div class="actions"></div>'
223
                            },
224
                            className: "actions noExport",
225
                            searchable: false,
226
                            orderable: false,
227
                        },
228
                    ],
229
                    drawCallback: function (settings) {
230
                        var api = new $.fn.dataTable.Api(settings)
231
232
                        $.each(
233
                            $(this).find("td .actions"),
234
                            function (index, e) {
235
                                let tr = $(this).parent().parent()
236
                                let license_id = api.row(tr).data().license_id
237
                                let license_name = api.row(tr).data().name
238
                                let editButton = createVNode(
239
                                    "a",
240
                                    {
241
                                        class: "btn btn-default btn-xs",
242
                                        role: "button",
243
                                        onClick: () => {
244
                                            edit_license(license_id)
245
                                        },
246
                                    },
247
                                    [
248
                                        createVNode("i", {
249
                                            class: "fa fa-pencil",
250
                                            "aria-hidden": "true",
251
                                        }),
252
                                        __("Edit"),
253
                                    ]
254
                                )
255
256
                                let deleteButton = createVNode(
257
                                    "a",
258
                                    {
259
                                        class: "btn btn-default btn-xs",
260
                                        role: "button",
261
                                        onClick: () => {
262
                                            delete_license(
263
                                                license_id,
264
                                                license_name
265
                                            )
266
                                        },
267
                                    },
268
                                    [
269
                                        createVNode("i", {
270
                                            class: "fa fa-trash",
271
                                            "aria-hidden": "true",
272
                                        }),
273
                                        __("Delete"),
274
                                    ]
275
                                )
276
157
277
                                let n = createVNode("span", {}, [
158
                {
278
                                    editButton,
159
                    title: __("Description"),
279
                                    " ",
160
                    data: "description",
280
                                    deleteButton,
161
                    searchable: true,
281
                                ])
162
                    orderable: true,
282
                                render(n, e)
163
                },
283
                            }
164
                {
165
                    title: __("Type"),
166
                    data: "type",
167
                    searchable: true,
168
                    orderable: true,
169
                    render: function (data, type, row, meta) {
170
                        return escape_str(
171
                            get_lib_from_av("av_license_types", row.type)
284
                        )
172
                        )
285
173
                    },
286
                        $.each(
174
                },
287
                            $(this).find("tbody tr td:first-child"),
175
                {
288
                            function (index, e) {
176
                    title: __("Status"),
289
                                let tr = $(this).parent()
177
                    data: "status",
290
                                let row = api.row(tr).data()
178
                    searchable: true,
291
                                if (!row) return // Happen if the table is empty
179
                    orderable: true,
292
                                let n = createVNode(
180
                    render: function (data, type, row, meta) {
293
                                    "a",
181
                        return escape_str(
294
                                    {
182
                            get_lib_from_av("av_license_statuses", row.status)
295
                                        role: "button",
296
                                        onClick: () => {
297
                                            show_license(row.license_id)
298
                                        },
299
                                    },
300
                                    `${row.name} (#${row.license_id})`
301
                                )
302
                                render(n, e)
303
                            }
304
                        )
183
                        )
305
                    },
184
                    },
306
                    preDrawCallback: function (settings) {
185
                },
307
                        $("#" + table_id)
186
                {
308
                            .find("thead th")
187
                    title: __("Started on"),
309
                            .eq(1)
188
                    data: "started_on",
310
                            .attr("data-filter", "vendors")
189
                    searchable: true,
311
                        $("#" + table_id)
190
                    orderable: true,
312
                            .find("thead th")
191
                    render: function (data, type, row, meta) {
313
                            .eq(3)
192
                        return $date(row.started_on)
314
                            .attr("data-filter", "av_license_types")
193
                    },
315
                        $("#" + table_id)
194
                },
316
                            .find("thead th")
195
                {
317
                            .eq(4)
196
                    title: __("Ended on"),
318
                            .attr("data-filter", "av_license_statuses")
197
                    data: "ended_on",
198
                    searchable: true,
199
                    orderable: true,
200
                    render: function (data, type, row, meta) {
201
                        return $date(row.ended_on)
319
                    },
202
                    },
320
                },
203
                },
321
                license_table_settings,
204
            ]
322
                1
323
            )
324
        },
205
        },
325
    },
206
    },
326
    props: {
207
    props: {
327
        av_license_types: Array,
208
        av_license_types: Array,
328
        av_license_statuses: Array,
209
        av_license_statuses: Array,
329
    },
210
    },
330
    components: { Toolbar },
211
    components: { Toolbar, KohaTable },
331
    name: "LicensesList",
212
    name: "LicensesList",
332
}
213
}
333
</script>
214
</script>
334
- 

Return to bug 33066