351d9ca3b8aa21a8042d79b412010bd19d466d92
[Evergreen.git] / Open-ILS / src / sql / Pg / 090.schema.action.sql
1 /*
2  * Copyright (C) 2004-2008  Georgia Public Library Service
3  * Copyright (C) 2007-2008  Equinox Software, Inc.
4  * Mike Rylander <miker@esilibrary.com> 
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  */
17
18 DROP SCHEMA IF EXISTS action CASCADE;
19
20 BEGIN;
21
22 CREATE SCHEMA action;
23
24 CREATE TABLE action.in_house_use (
25         id              SERIAL                          PRIMARY KEY,
26         item            BIGINT                          NOT NULL, -- REFERENCES asset.copy (id) DEFERRABLE INITIALLY DEFERRED, -- XXX could be an serial.issuance
27         staff           INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
28         org_unit        INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
29         use_time        TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW()
30 );
31 CREATE INDEX action_in_house_use_staff_idx      ON action.in_house_use ( staff );
32
33 CREATE TABLE action.non_cataloged_circulation (
34         id              SERIAL                          PRIMARY KEY,
35         patron          INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
36         staff           INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
37         circ_lib        INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
38         item_type       INT                             NOT NULL REFERENCES config.non_cataloged_type (id) DEFERRABLE INITIALLY DEFERRED,
39         circ_time       TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW()
40 );
41 CREATE INDEX action_non_cat_circ_patron_idx ON action.non_cataloged_circulation ( patron );
42 CREATE INDEX action_non_cat_circ_staff_idx  ON action.non_cataloged_circulation ( staff );
43
44 CREATE TABLE action.non_cat_in_house_use (
45         id              SERIAL                          PRIMARY KEY,
46         item_type       BIGINT                          NOT NULL REFERENCES config.non_cataloged_type(id) DEFERRABLE INITIALLY DEFERRED,
47         staff           INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
48         org_unit        INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
49         use_time        TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW()
50 );
51 CREATE INDEX non_cat_in_house_use_staff_idx ON action.non_cat_in_house_use ( staff );
52
53 CREATE TABLE action.survey (
54         id              SERIAL                          PRIMARY KEY,
55         owner           INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
56         start_date      TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
57         end_date        TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW() + '10 years'::INTERVAL,
58         usr_summary     BOOL                            NOT NULL DEFAULT FALSE,
59         opac            BOOL                            NOT NULL DEFAULT FALSE,
60         poll            BOOL                            NOT NULL DEFAULT FALSE,
61         required        BOOL                            NOT NULL DEFAULT FALSE,
62         name            TEXT                            NOT NULL,
63         description     TEXT                            NOT NULL
64 );
65 CREATE UNIQUE INDEX asv_once_per_owner_idx ON action.survey (owner,name);
66
67 CREATE TABLE action.survey_question (
68         id              SERIAL  PRIMARY KEY,
69         survey          INT     NOT NULL REFERENCES action.survey DEFERRABLE INITIALLY DEFERRED,
70         question        TEXT    NOT NULL
71 );
72
73 CREATE TABLE action.survey_answer (
74         id              SERIAL  PRIMARY KEY,
75         question        INT     NOT NULL REFERENCES action.survey_question DEFERRABLE INITIALLY DEFERRED,
76         answer          TEXT    NOT NULL
77 );
78
79 CREATE SEQUENCE action.survey_response_group_id_seq;
80
81 CREATE TABLE action.survey_response (
82         id                      BIGSERIAL                       PRIMARY KEY,
83         response_group_id       INT,
84         usr                     INT, -- REFERENCES actor.usr
85         survey                  INT                             NOT NULL REFERENCES action.survey DEFERRABLE INITIALLY DEFERRED,
86         question                INT                             NOT NULL REFERENCES action.survey_question DEFERRABLE INITIALLY DEFERRED,
87         answer                  INT                             NOT NULL REFERENCES action.survey_answer DEFERRABLE INITIALLY DEFERRED,
88         answer_date             TIMESTAMP WITH TIME ZONE,
89         effective_date          TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW()
90 );
91 CREATE INDEX action_survey_response_usr_idx ON action.survey_response ( usr );
92
93 CREATE OR REPLACE FUNCTION action.survey_response_answer_date_fixup () RETURNS TRIGGER AS '
94 BEGIN
95         NEW.answer_date := NOW();
96         RETURN NEW;
97 END;
98 ' LANGUAGE 'plpgsql';
99 CREATE TRIGGER action_survey_response_answer_date_fixup_tgr
100         BEFORE INSERT ON action.survey_response
101         FOR EACH ROW
102         EXECUTE PROCEDURE action.survey_response_answer_date_fixup ();
103
104 CREATE TABLE action.archive_actor_stat_cat (
105     id          BIGSERIAL   PRIMARY KEY,
106     xact        BIGINT      NOT NULL, -- action.circulation (+aged/all)
107     stat_cat    INT         NOT NULL,
108     value       TEXT        NOT NULL
109 );
110
111 CREATE TABLE action.archive_asset_stat_cat (
112     id          BIGSERIAL   PRIMARY KEY,
113     xact        BIGINT      NOT NULL, -- action.circulation (+aged/all)
114     stat_cat    INT         NOT NULL,
115     value       TEXT        NOT NULL
116 );
117
118
119 CREATE TABLE action.circulation (
120         target_copy             BIGINT                          NOT NULL, -- asset.copy.id
121         circ_lib                INT                             NOT NULL, -- actor.org_unit.id
122         circ_staff              INT                             NOT NULL, -- actor.usr.id
123         checkin_staff           INT,                                      -- actor.usr.id
124         checkin_lib             INT,                                      -- actor.org_unit.id
125         renewal_remaining       INT                             NOT NULL, -- derived from "circ duration" rule
126     grace_period           INTERVAL             NOT NULL, -- derived from "circ fine" rule
127         due_date                TIMESTAMP WITH TIME ZONE,
128         stop_fines_time         TIMESTAMP WITH TIME ZONE,
129         checkin_time            TIMESTAMP WITH TIME ZONE,
130         create_time             TIMESTAMP WITH TIME ZONE    NOT NULL DEFAULT NOW(),
131         duration                INTERVAL,                                 -- derived from "circ duration" rule
132         fine_interval           INTERVAL                        NOT NULL DEFAULT '1 day'::INTERVAL, -- derived from "circ fine" rule
133         recurring_fine          NUMERIC(6,2),                             -- derived from "circ fine" rule
134         max_fine                NUMERIC(6,2),                             -- derived from "max fine" rule
135         phone_renewal           BOOL                            NOT NULL DEFAULT FALSE,
136         desk_renewal            BOOL                            NOT NULL DEFAULT FALSE,
137         opac_renewal            BOOL                            NOT NULL DEFAULT FALSE,
138         duration_rule           TEXT                            NOT NULL, -- name of "circ duration" rule
139         recurring_fine_rule     TEXT                            NOT NULL, -- name of "circ fine" rule
140         max_fine_rule           TEXT                            NOT NULL, -- name of "max fine" rule
141         stop_fines              TEXT                            CHECK (stop_fines IN (
142                                                'CHECKIN','CLAIMSRETURNED','LOST','MAXFINES','RENEW','LONGOVERDUE','CLAIMSNEVERCHECKEDOUT')),
143         workstation         INT        REFERENCES actor.workstation(id)
144                                        ON DELETE SET NULL
145                                                                    DEFERRABLE INITIALLY DEFERRED,
146         checkin_workstation INT        REFERENCES actor.workstation(id)
147                                        ON DELETE SET NULL
148                                                                    DEFERRABLE INITIALLY DEFERRED,
149         copy_location   INT                             NOT NULL DEFAULT 1 REFERENCES asset.copy_location (id) DEFERRABLE INITIALLY DEFERRED,
150         checkin_scan_time   TIMESTAMP WITH TIME ZONE
151 ) INHERITS (money.billable_xact);
152 ALTER TABLE action.circulation ADD PRIMARY KEY (id);
153 ALTER TABLE action.circulation
154         ADD COLUMN parent_circ BIGINT
155         REFERENCES action.circulation( id )
156         DEFERRABLE INITIALLY DEFERRED;
157 CREATE INDEX circ_open_xacts_idx ON action.circulation (usr) WHERE xact_finish IS NULL;
158 CREATE INDEX circ_outstanding_idx ON action.circulation (usr) WHERE checkin_time IS NULL;
159 CREATE INDEX circ_checkin_time ON "action".circulation (checkin_time) WHERE checkin_time IS NOT NULL;
160 CREATE INDEX circ_circ_lib_idx ON "action".circulation (circ_lib);
161 CREATE INDEX circ_open_date_idx ON "action".circulation (xact_start) WHERE xact_finish IS NULL;
162 CREATE INDEX circ_all_usr_idx       ON action.circulation ( usr );
163 CREATE INDEX circ_circ_staff_idx    ON action.circulation ( circ_staff );
164 CREATE INDEX circ_checkin_staff_idx ON action.circulation ( checkin_staff );
165 CREATE INDEX action_circulation_target_copy_idx ON action.circulation (target_copy);
166 CREATE UNIQUE INDEX circ_parent_idx ON action.circulation ( parent_circ ) WHERE parent_circ IS NOT NULL;
167 CREATE UNIQUE INDEX only_one_concurrent_checkout_per_copy ON action.circulation(target_copy) WHERE checkin_time IS NULL;
168
169 CREATE TRIGGER action_circulation_target_copy_trig AFTER INSERT OR UPDATE ON action.circulation FOR EACH ROW EXECUTE PROCEDURE evergreen.fake_fkey_tgr('target_copy');
170
171 CREATE TRIGGER mat_summary_create_tgr AFTER INSERT ON action.circulation FOR EACH ROW EXECUTE PROCEDURE money.mat_summary_create ('circulation');
172 CREATE TRIGGER mat_summary_change_tgr AFTER UPDATE ON action.circulation FOR EACH ROW EXECUTE PROCEDURE money.mat_summary_update ();
173 CREATE TRIGGER mat_summary_remove_tgr AFTER DELETE ON action.circulation FOR EACH ROW EXECUTE PROCEDURE money.mat_summary_delete ();
174
175 CREATE OR REPLACE FUNCTION action.push_circ_due_time () RETURNS TRIGGER AS $$
176 BEGIN
177     IF (EXTRACT(EPOCH FROM NEW.duration)::INT % EXTRACT(EPOCH FROM '1 day'::INTERVAL)::INT) = 0 THEN
178         NEW.due_date = (NEW.due_date::DATE + '1 day'::INTERVAL - '1 second'::INTERVAL)::TIMESTAMPTZ;
179     END IF;
180
181     RETURN NEW;
182 END;
183 $$ LANGUAGE PLPGSQL;
184
185 CREATE TRIGGER push_due_date_tgr BEFORE INSERT OR UPDATE ON action.circulation FOR EACH ROW EXECUTE PROCEDURE action.push_circ_due_time();
186
187 CREATE OR REPLACE FUNCTION action.fill_circ_copy_location () RETURNS TRIGGER AS $$
188 BEGIN
189     SELECT INTO NEW.copy_location location FROM asset.copy WHERE id = NEW.target_copy;
190     RETURN NEW;
191 END;
192 $$ LANGUAGE PLPGSQL;
193
194 CREATE TRIGGER fill_circ_copy_location_tgr BEFORE INSERT ON action.circulation FOR EACH ROW EXECUTE PROCEDURE action.fill_circ_copy_location();
195
196 CREATE OR REPLACE FUNCTION action.archive_stat_cats () RETURNS TRIGGER AS $$
197 BEGIN
198     INSERT INTO action.archive_actor_stat_cat(xact, stat_cat, value)
199         SELECT NEW.id, asceum.stat_cat, asceum.stat_cat_entry
200         FROM actor.stat_cat_entry_usr_map asceum
201              JOIN actor.stat_cat sc ON asceum.stat_cat = sc.id
202         WHERE NEW.usr = asceum.target_usr AND sc.checkout_archive;
203     INSERT INTO action.archive_asset_stat_cat(xact, stat_cat, value)
204         SELECT NEW.id, ascecm.stat_cat, asce.value
205         FROM asset.stat_cat_entry_copy_map ascecm
206              JOIN asset.stat_cat sc ON ascecm.stat_cat = sc.id
207              JOIN asset.stat_cat_entry asce ON ascecm.stat_cat_entry = asce.id
208         WHERE NEW.target_copy = ascecm.owning_copy AND sc.checkout_archive;
209     RETURN NULL;
210 END;
211 $$ LANGUAGE PLPGSQL;
212
213 CREATE TRIGGER archive_stat_cats_tgr AFTER INSERT ON action.circulation FOR EACH ROW EXECUTE PROCEDURE action.archive_stat_cats();
214
215 CREATE TABLE action.aged_circulation (
216         usr_post_code           TEXT,
217         usr_home_ou             INT     NOT NULL,
218         usr_profile             INT     NOT NULL,
219         usr_birth_year          INT,
220         copy_call_number        INT     NOT NULL,
221         copy_owning_lib         INT     NOT NULL,
222         copy_circ_lib           INT     NOT NULL,
223         copy_bib_record         BIGINT  NOT NULL,
224         LIKE action.circulation
225
226 );
227 ALTER TABLE action.aged_circulation ADD PRIMARY KEY (id);
228 ALTER TABLE action.aged_circulation DROP COLUMN usr;
229 CREATE INDEX aged_circ_circ_lib_idx ON "action".aged_circulation (circ_lib);
230 CREATE INDEX aged_circ_start_idx ON "action".aged_circulation (xact_start);
231 CREATE INDEX aged_circ_copy_circ_lib_idx ON "action".aged_circulation (copy_circ_lib);
232 CREATE INDEX aged_circ_copy_owning_lib_idx ON "action".aged_circulation (copy_owning_lib);
233 CREATE INDEX aged_circ_copy_location_idx ON "action".aged_circulation (copy_location);
234 CREATE INDEX action_aged_circulation_target_copy_idx ON action.aged_circulation (target_copy);
235
236 CREATE OR REPLACE VIEW action.all_circulation AS
237     SELECT  id,usr_post_code, usr_home_ou, usr_profile, usr_birth_year, copy_call_number, copy_location,
238         copy_owning_lib, copy_circ_lib, copy_bib_record, xact_start, xact_finish, target_copy,
239         circ_lib, circ_staff, checkin_staff, checkin_lib, renewal_remaining, grace_period, due_date,
240         stop_fines_time, checkin_time, create_time, duration, fine_interval, recurring_fine,
241         max_fine, phone_renewal, desk_renewal, opac_renewal, duration_rule, recurring_fine_rule,
242         max_fine_rule, stop_fines, workstation, checkin_workstation, checkin_scan_time, parent_circ
243       FROM  action.aged_circulation
244             UNION ALL
245     SELECT  DISTINCT circ.id,COALESCE(a.post_code,b.post_code) AS usr_post_code, p.home_ou AS usr_home_ou, p.profile AS usr_profile, EXTRACT(YEAR FROM p.dob)::INT AS usr_birth_year,
246         cp.call_number AS copy_call_number, circ.copy_location, cn.owning_lib AS copy_owning_lib, cp.circ_lib AS copy_circ_lib,
247         cn.record AS copy_bib_record, circ.xact_start, circ.xact_finish, circ.target_copy, circ.circ_lib, circ.circ_staff, circ.checkin_staff,
248         circ.checkin_lib, circ.renewal_remaining, circ.grace_period, circ.due_date, circ.stop_fines_time, circ.checkin_time, circ.create_time, circ.duration,
249         circ.fine_interval, circ.recurring_fine, circ.max_fine, circ.phone_renewal, circ.desk_renewal, circ.opac_renewal, circ.duration_rule,
250         circ.recurring_fine_rule, circ.max_fine_rule, circ.stop_fines, circ.workstation, circ.checkin_workstation, circ.checkin_scan_time,
251         circ.parent_circ
252       FROM  action.circulation circ
253         JOIN asset.copy cp ON (circ.target_copy = cp.id)
254         JOIN asset.call_number cn ON (cp.call_number = cn.id)
255         JOIN actor.usr p ON (circ.usr = p.id)
256         LEFT JOIN actor.usr_address a ON (p.mailing_address = a.id)
257         LEFT JOIN actor.usr_address b ON (p.billing_address = b.id);
258
259 CREATE OR REPLACE FUNCTION action.age_circ_on_delete () RETURNS TRIGGER AS $$
260 DECLARE
261 found char := 'N';
262 BEGIN
263
264     -- If there are any renewals for this circulation, don't archive or delete
265     -- it yet.   We'll do so later, when we archive and delete the renewals.
266
267     SELECT 'Y' INTO found
268     FROM action.circulation
269     WHERE parent_circ = OLD.id
270     LIMIT 1;
271
272     IF found = 'Y' THEN
273         RETURN NULL;  -- don't delete
274         END IF;
275
276     -- Archive a copy of the old row to action.aged_circulation
277
278     INSERT INTO action.aged_circulation
279         (id,usr_post_code, usr_home_ou, usr_profile, usr_birth_year, copy_call_number, copy_location,
280         copy_owning_lib, copy_circ_lib, copy_bib_record, xact_start, xact_finish, target_copy,
281         circ_lib, circ_staff, checkin_staff, checkin_lib, renewal_remaining, grace_period, due_date,
282         stop_fines_time, checkin_time, create_time, duration, fine_interval, recurring_fine,
283         max_fine, phone_renewal, desk_renewal, opac_renewal, duration_rule, recurring_fine_rule,
284         max_fine_rule, stop_fines, workstation, checkin_workstation, checkin_scan_time, parent_circ)
285       SELECT
286         id,usr_post_code, usr_home_ou, usr_profile, usr_birth_year, copy_call_number, copy_location,
287         copy_owning_lib, copy_circ_lib, copy_bib_record, xact_start, xact_finish, target_copy,
288         circ_lib, circ_staff, checkin_staff, checkin_lib, renewal_remaining, grace_period, due_date,
289         stop_fines_time, checkin_time, create_time, duration, fine_interval, recurring_fine,
290         max_fine, phone_renewal, desk_renewal, opac_renewal, duration_rule, recurring_fine_rule,
291         max_fine_rule, stop_fines, workstation, checkin_workstation, checkin_scan_time, parent_circ
292         FROM action.all_circulation WHERE id = OLD.id;
293
294     RETURN OLD;
295 END;
296 $$ LANGUAGE 'plpgsql';
297
298 CREATE TRIGGER action_circulation_aging_tgr
299         BEFORE DELETE ON action.circulation
300         FOR EACH ROW
301         EXECUTE PROCEDURE action.age_circ_on_delete ();
302
303
304 CREATE OR REPLACE FUNCTION action.age_parent_circ_on_delete () RETURNS TRIGGER AS $$
305 BEGIN
306
307     -- Having deleted a renewal, we can delete the original circulation (or a previous
308     -- renewal, if that's what parent_circ is pointing to).  That deletion will trigger
309     -- deletion of any prior parents, etc. recursively.
310
311     IF OLD.parent_circ IS NOT NULL THEN
312         DELETE FROM action.circulation
313         WHERE id = OLD.parent_circ;
314     END IF;
315
316     RETURN OLD;
317 END;
318 $$ LANGUAGE 'plpgsql';
319
320 CREATE TRIGGER age_parent_circ
321         AFTER DELETE ON action.circulation
322         FOR EACH ROW
323         EXECUTE PROCEDURE action.age_parent_circ_on_delete ();
324
325
326 CREATE OR REPLACE VIEW action.open_circulation AS
327         SELECT  *
328           FROM  action.circulation
329           WHERE checkin_time IS NULL
330           ORDER BY due_date;
331                 
332
333 CREATE OR REPLACE VIEW action.billable_circulations AS
334         SELECT  *
335           FROM  action.circulation
336           WHERE xact_finish IS NULL;
337
338 CREATE OR REPLACE FUNCTION action.circulation_claims_returned () RETURNS TRIGGER AS $$
339 BEGIN
340         IF OLD.stop_fines IS NULL OR OLD.stop_fines <> NEW.stop_fines THEN
341                 IF NEW.stop_fines = 'CLAIMSRETURNED' THEN
342                         UPDATE actor.usr SET claims_returned_count = claims_returned_count + 1 WHERE id = NEW.usr;
343                 END IF;
344                 IF NEW.stop_fines = 'CLAIMSNEVERCHECKEDOUT' THEN
345                         UPDATE actor.usr SET claims_never_checked_out_count = claims_never_checked_out_count + 1 WHERE id = NEW.usr;
346                 END IF;
347                 IF NEW.stop_fines = 'LOST' THEN
348                         UPDATE asset.copy SET status = 3 WHERE id = NEW.target_copy;
349                 END IF;
350         END IF;
351         RETURN NEW;
352 END;
353 $$ LANGUAGE 'plpgsql';
354 CREATE TRIGGER action_circulation_stop_fines_tgr
355         BEFORE UPDATE ON action.circulation
356         FOR EACH ROW
357         EXECUTE PROCEDURE action.circulation_claims_returned ();
358
359 CREATE TABLE action.hold_request_cancel_cause (
360     id      SERIAL  PRIMARY KEY,
361     label   TEXT    UNIQUE
362 );
363
364 CREATE TABLE action.hold_request (
365         id                      SERIAL                          PRIMARY KEY,
366         request_time            TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
367         capture_time            TIMESTAMP WITH TIME ZONE,
368         fulfillment_time        TIMESTAMP WITH TIME ZONE,
369         checkin_time            TIMESTAMP WITH TIME ZONE,
370         return_time             TIMESTAMP WITH TIME ZONE,
371         prev_check_time         TIMESTAMP WITH TIME ZONE,
372         expire_time             TIMESTAMP WITH TIME ZONE,
373         cancel_time             TIMESTAMP WITH TIME ZONE,
374         cancel_cause    INT REFERENCES action.hold_request_cancel_cause (id) ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED,
375         cancel_note             TEXT,
376         target                  BIGINT                          NOT NULL, -- see hold_type
377         current_copy            BIGINT,                         -- REFERENCES asset.copy (id) ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED,  -- XXX could be an serial.unit now...
378         fulfillment_staff       INT                             REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
379         fulfillment_lib         INT                             REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
380         request_lib             INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
381         requestor               INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
382         usr                     INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
383         selection_ou            INT                             NOT NULL,
384         selection_depth         INT                             NOT NULL DEFAULT 0,
385         pickup_lib              INT                             NOT NULL REFERENCES actor.org_unit DEFERRABLE INITIALLY DEFERRED,
386         hold_type               TEXT                            NOT NULL, -- CHECK (hold_type IN ('M','T','V','C')),  -- XXX constraint too constraining...
387         holdable_formats        TEXT,
388         phone_notify            TEXT,
389         email_notify            BOOL                            NOT NULL DEFAULT FALSE,
390         sms_notify              TEXT,
391         sms_carrier             INT REFERENCES config.sms_carrier (id),
392         frozen                  BOOL                            NOT NULL DEFAULT FALSE,
393         thaw_date               TIMESTAMP WITH TIME ZONE,
394         shelf_time              TIMESTAMP WITH TIME ZONE,
395     cut_in_line     BOOL,
396         mint_condition  BOOL NOT NULL DEFAULT TRUE,
397         shelf_expire_time TIMESTAMPTZ,
398         current_shelf_lib INT REFERENCES actor.org_unit DEFERRABLE INITIALLY DEFERRED
399 );
400 ALTER TABLE action.hold_request ADD CONSTRAINT sms_check CHECK (
401     sms_notify IS NULL
402     OR sms_carrier IS NOT NULL -- and implied sms_notify IS NOT NULL
403 );
404
405
406 CREATE INDEX hold_request_target_idx ON action.hold_request (target);
407 CREATE INDEX hold_request_usr_idx ON action.hold_request (usr);
408 CREATE INDEX hold_request_pickup_lib_idx ON action.hold_request (pickup_lib);
409 CREATE INDEX hold_request_current_copy_idx ON action.hold_request (current_copy);
410 CREATE INDEX hold_request_prev_check_time_idx ON action.hold_request (prev_check_time);
411 CREATE INDEX hold_request_fulfillment_staff_idx ON action.hold_request ( fulfillment_staff );
412 CREATE INDEX hold_request_requestor_idx         ON action.hold_request ( requestor );
413 CREATE INDEX hold_request_open_idx ON action.hold_request (id) WHERE cancel_time IS NULL AND fulfillment_time IS NULL;
414 CREATE INDEX hold_request_current_copy_before_cap_idx ON action.hold_request (current_copy) WHERE capture_time IS NULL AND cancel_time IS NULL;
415
416
417 CREATE TABLE action.hold_request_note (
418
419     id     BIGSERIAL PRIMARY KEY,
420     hold   BIGINT    NOT NULL REFERENCES action.hold_request (id)
421                               ON DELETE CASCADE
422                               DEFERRABLE INITIALLY DEFERRED,
423     title  TEXT      NOT NULL,
424     body   TEXT      NOT NULL,
425     slip   BOOL      NOT NULL DEFAULT FALSE,
426     pub    BOOL      NOT NULL DEFAULT FALSE,
427     staff  BOOL      NOT NULL DEFAULT FALSE  -- created by staff
428
429 );
430 CREATE INDEX ahrn_hold_idx ON action.hold_request_note (hold);
431
432
433 CREATE TABLE action.hold_notification (
434         id              SERIAL                          PRIMARY KEY,
435         hold            INT                             NOT NULL REFERENCES action.hold_request (id)
436                                                                         ON DELETE CASCADE
437                                                                         DEFERRABLE INITIALLY DEFERRED,
438         notify_staff    INT                     REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
439         notify_time     TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
440         method          TEXT                            NOT NULL, -- email address or phone number
441         note            TEXT
442 );
443 CREATE INDEX ahn_hold_idx ON action.hold_notification (hold);
444 CREATE INDEX ahn_notify_staff_idx ON action.hold_notification ( notify_staff );
445
446 CREATE TABLE action.hold_copy_map (
447         id              BIGSERIAL       PRIMARY KEY,
448         hold            INT     NOT NULL REFERENCES action.hold_request (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
449         target_copy     BIGINT  NOT NULL, -- REFERENCES asset.copy (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, -- XXX could be an serial.issuance
450         proximity       NUMERIC,
451         CONSTRAINT copy_once_per_hold UNIQUE (hold,target_copy)
452 );
453 -- CREATE INDEX acm_hold_idx ON action.hold_copy_map (hold);
454 CREATE INDEX acm_copy_idx ON action.hold_copy_map (target_copy);
455
456 CREATE TABLE action.transit_copy (
457         id                      SERIAL                          PRIMARY KEY,
458         source_send_time        TIMESTAMP WITH TIME ZONE,
459         dest_recv_time          TIMESTAMP WITH TIME ZONE,
460         target_copy             BIGINT                          NOT NULL, -- REFERENCES asset.copy (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, -- XXX could be an serial.issuance
461         source                  INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
462         dest                    INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
463         prev_hop                INT                             REFERENCES action.transit_copy (id) DEFERRABLE INITIALLY DEFERRED,
464         copy_status             INT                             NOT NULL REFERENCES config.copy_status (id) DEFERRABLE INITIALLY DEFERRED,
465         persistant_transfer     BOOL                            NOT NULL DEFAULT FALSE,
466         prev_dest       INT                             REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED
467 );
468 CREATE INDEX active_transit_dest_idx ON "action".transit_copy (dest); 
469 CREATE INDEX active_transit_source_idx ON "action".transit_copy (source);
470 CREATE INDEX active_transit_cp_idx ON "action".transit_copy (target_copy);
471
472
473 CREATE TABLE action.hold_transit_copy (
474         hold    INT     REFERENCES action.hold_request (id) ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED
475 ) INHERITS (action.transit_copy);
476 ALTER TABLE action.hold_transit_copy ADD PRIMARY KEY (id);
477 -- ALTER TABLE action.hold_transit_copy ADD CONSTRAINT ahtc_tc_fkey FOREIGN KEY (target_copy) REFERENCES asset.copy (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED; -- XXX could be an serial.issuance
478 CREATE INDEX active_hold_transit_dest_idx ON "action".hold_transit_copy (dest);
479 CREATE INDEX active_hold_transit_source_idx ON "action".hold_transit_copy (source);
480 CREATE INDEX active_hold_transit_cp_idx ON "action".hold_transit_copy (target_copy);
481 CREATE INDEX hold_transit_copy_hold_idx on action.hold_transit_copy (hold);
482
483
484 CREATE TABLE action.unfulfilled_hold_list (
485         id              BIGSERIAL                       PRIMARY KEY,
486         current_copy    BIGINT                          NOT NULL,
487         hold            INT                             NOT NULL,
488         circ_lib        INT                             NOT NULL,
489         fail_time       TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW()
490 );
491 CREATE INDEX uhr_hold_idx ON action.unfulfilled_hold_list (hold);
492
493 CREATE OR REPLACE VIEW action.unfulfilled_hold_loops AS
494     SELECT  u.hold,
495             c.circ_lib,
496             count(*)
497       FROM  action.unfulfilled_hold_list u
498             JOIN asset.copy c ON (c.id = u.current_copy)
499       GROUP BY 1,2;
500
501 CREATE OR REPLACE VIEW action.unfulfilled_hold_min_loop AS
502     SELECT  hold,
503             min(count)
504       FROM  action.unfulfilled_hold_loops
505       GROUP BY 1;
506
507 CREATE OR REPLACE VIEW action.unfulfilled_hold_innermost_loop AS
508     SELECT  DISTINCT l.*
509       FROM  action.unfulfilled_hold_loops l
510             JOIN action.unfulfilled_hold_min_loop m USING (hold)
511       WHERE l.count = m.min;
512
513 CREATE VIEW action.unfulfilled_hold_max_loop AS
514     SELECT  hold,
515             max(count) AS max
516       FROM  action.unfulfilled_hold_loops
517       GROUP BY 1;
518
519
520 CREATE TABLE action.aged_hold_request (
521     usr_post_code               TEXT,
522     usr_home_ou         INT     NOT NULL,
523     usr_profile         INT     NOT NULL,
524     usr_birth_year              INT,
525     staff_placed        BOOLEAN NOT NULL,
526     LIKE action.hold_request
527 );
528 ALTER TABLE action.aged_hold_request
529       ADD PRIMARY KEY (id),
530       DROP COLUMN usr,
531       DROP COLUMN requestor,
532       DROP COLUMN sms_carrier,
533       ALTER COLUMN phone_notify TYPE BOOLEAN
534             USING CASE WHEN phone_notify IS NULL OR phone_notify = '' THEN FALSE ELSE TRUE END,
535       ALTER COLUMN sms_notify TYPE BOOLEAN
536             USING CASE WHEN sms_notify IS NULL OR sms_notify = '' THEN FALSE ELSE TRUE END,
537       ALTER COLUMN phone_notify SET NOT NULL,
538       ALTER COLUMN sms_notify SET NOT NULL;
539 CREATE INDEX aged_hold_request_target_idx ON action.aged_hold_request (target);
540 CREATE INDEX aged_hold_request_pickup_lib_idx ON action.aged_hold_request (pickup_lib);
541 CREATE INDEX aged_hold_request_current_copy_idx ON action.aged_hold_request (current_copy);
542 CREATE INDEX aged_hold_request_fulfillment_staff_idx ON action.aged_hold_request ( fulfillment_staff );
543
544 CREATE OR REPLACE VIEW action.all_hold_request AS
545     SELECT DISTINCT
546            COALESCE(a.post_code, b.post_code) AS usr_post_code,
547            p.home_ou AS usr_home_ou,
548            p.profile AS usr_profile,
549            EXTRACT(YEAR FROM p.dob)::INT AS usr_birth_year,
550            CAST(ahr.requestor <> ahr.usr AS BOOLEAN) AS staff_placed,
551            ahr.id,
552            ahr.request_time,
553            ahr.capture_time,
554            ahr.fulfillment_time,
555            ahr.checkin_time,
556            ahr.return_time,
557            ahr.prev_check_time,
558            ahr.expire_time,
559            ahr.cancel_time,
560            ahr.cancel_cause,
561            ahr.cancel_note,
562            ahr.target,
563            ahr.current_copy,
564            ahr.fulfillment_staff,
565            ahr.fulfillment_lib,
566            ahr.request_lib,
567            ahr.selection_ou,
568            ahr.selection_depth,
569            ahr.pickup_lib,
570            ahr.hold_type,
571            ahr.holdable_formats,
572            CASE
573            WHEN ahr.phone_notify IS NULL THEN FALSE
574            WHEN ahr.phone_notify = '' THEN FALSE
575            ELSE TRUE
576            END AS phone_notify,
577            ahr.email_notify,
578            CASE
579            WHEN ahr.sms_notify IS NULL THEN FALSE
580            WHEN ahr.sms_notify = '' THEN FALSE
581            ELSE TRUE
582            END AS sms_notify,
583            ahr.frozen,
584            ahr.thaw_date,
585            ahr.shelf_time,
586            ahr.cut_in_line,
587            ahr.mint_condition,
588            ahr.shelf_expire_time,
589            ahr.current_shelf_lib
590     FROM action.hold_request ahr
591          JOIN actor.usr p ON (ahr.usr = p.id)
592          LEFT JOIN actor.usr_address a ON (p.mailing_address = a.id)
593          LEFT JOIN actor.usr_address b ON (p.billing_address = b.id)
594     UNION ALL
595     SELECT 
596            usr_post_code,
597            usr_home_ou,
598            usr_profile,
599            usr_birth_year,
600            staff_placed,
601            id,
602            request_time,
603            capture_time,
604            fulfillment_time,
605            checkin_time,
606            return_time,
607            prev_check_time,
608            expire_time,
609            cancel_time,
610            cancel_cause,
611            cancel_note,
612            target,
613            current_copy,
614            fulfillment_staff,
615            fulfillment_lib,
616            request_lib,
617            selection_ou,
618            selection_depth,
619            pickup_lib,
620            hold_type,
621            holdable_formats,
622            phone_notify,
623            email_notify,
624            sms_notify,
625            frozen,
626            thaw_date,
627            shelf_time,
628            cut_in_line,
629            mint_condition,
630            shelf_expire_time,
631            current_shelf_lib
632     FROM action.aged_hold_request;
633
634 CREATE OR REPLACE FUNCTION action.age_hold_on_delete () RETURNS TRIGGER AS $$
635 DECLARE
636 BEGIN
637     -- Archive a copy of the old row to action.aged_hold_request
638
639     INSERT INTO action.aged_hold_request
640            (usr_post_code,
641             usr_home_ou,
642             usr_profile,
643             usr_birth_year,
644             staff_placed,
645             id,
646             request_time,
647             capture_time,
648             fulfillment_time,
649             checkin_time,
650             return_time,
651             prev_check_time,
652             expire_time,
653             cancel_time,
654             cancel_cause,
655             cancel_note,
656             target,
657             current_copy,
658             fulfillment_staff,
659             fulfillment_lib,
660             request_lib,
661             selection_ou,
662             selection_depth,
663             pickup_lib,
664             hold_type,
665             holdable_formats,
666             phone_notify,
667             email_notify,
668             sms_notify,
669             frozen,
670             thaw_date,
671             shelf_time,
672             cut_in_line,
673             mint_condition,
674             shelf_expire_time,
675             current_shelf_lib)
676       SELECT 
677            usr_post_code,
678            usr_home_ou,
679            usr_profile,
680            usr_birth_year,
681            staff_placed,
682            id,
683            request_time,
684            capture_time,
685            fulfillment_time,
686            checkin_time,
687            return_time,
688            prev_check_time,
689            expire_time,
690            cancel_time,
691            cancel_cause,
692            cancel_note,
693            target,
694            current_copy,
695            fulfillment_staff,
696            fulfillment_lib,
697            request_lib,
698            selection_ou,
699            selection_depth,
700            pickup_lib,
701            hold_type,
702            holdable_formats,
703            phone_notify,
704            email_notify,
705            sms_notify,
706            frozen,
707            thaw_date,
708            shelf_time,
709            cut_in_line,
710            mint_condition,
711            shelf_expire_time,
712            current_shelf_lib
713         FROM action.all_hold_request WHERE id = OLD.id;
714
715     RETURN OLD;
716 END;
717 $$ LANGUAGE 'plpgsql';
718
719 CREATE TRIGGER action_hold_request_aging_tgr
720         BEFORE DELETE ON action.hold_request
721         FOR EACH ROW
722         EXECUTE PROCEDURE action.age_hold_on_delete ();
723
724 CREATE TABLE action.fieldset (
725     id              SERIAL          PRIMARY KEY,
726     owner           INT             NOT NULL REFERENCES actor.usr (id)
727                                     DEFERRABLE INITIALLY DEFERRED,
728         owning_lib      INT             NOT NULL REFERENCES actor.org_unit (id)
729                                     DEFERRABLE INITIALLY DEFERRED,
730         status          TEXT            NOT NULL
731                                         CONSTRAINT valid_status CHECK ( status in
732                                                                         ( 'PENDING', 'APPLIED', 'ERROR' )),
733     creation_time   TIMESTAMPTZ     NOT NULL DEFAULT NOW(),
734     scheduled_time  TIMESTAMPTZ,
735     applied_time    TIMESTAMPTZ,
736     classname       TEXT            NOT NULL, -- an IDL class name
737     name            TEXT            NOT NULL,
738     stored_query    INT             REFERENCES query.stored_query (id)
739                                     DEFERRABLE INITIALLY DEFERRED,
740     pkey_value      TEXT,
741         CONSTRAINT lib_name_unique UNIQUE (owning_lib, name),
742     CONSTRAINT fieldset_one_or_the_other CHECK (
743         (stored_query IS NOT NULL AND pkey_value IS NULL) OR
744         (pkey_value IS NOT NULL AND stored_query IS NULL)
745     )
746         -- the CHECK constraint means we can update the fields for a single
747         -- row without all the extra overhead involved in a query
748 );
749
750 CREATE INDEX action_fieldset_sched_time_idx ON action.fieldset( scheduled_time );
751 CREATE INDEX action_owner_idx               ON action.fieldset( owner );
752
753
754 CREATE TABLE action.fieldset_col_val (
755     id              SERIAL  PRIMARY KEY,
756     fieldset        INT     NOT NULL REFERENCES action.fieldset
757                                          ON DELETE CASCADE
758                                          DEFERRABLE INITIALLY DEFERRED,
759     col             TEXT    NOT NULL,  -- "field" from the idl ... the column on the table
760     val             TEXT,              -- value for the column ... NULL means, well, NULL
761     CONSTRAINT fieldset_col_once_per_set UNIQUE (fieldset, col)
762 );
763
764
765 -- represents a circ chain summary
766 CREATE TYPE action.circ_chain_summary AS (
767     num_circs INTEGER,
768     start_time TIMESTAMP WITH TIME ZONE,
769     checkout_workstation TEXT,
770     last_renewal_time TIMESTAMP WITH TIME ZONE, -- NULL if no renewals
771     last_stop_fines TEXT,
772     last_stop_fines_time TIMESTAMP WITH TIME ZONE,
773     last_renewal_workstation TEXT, -- NULL if no renewals
774     last_checkin_workstation TEXT,
775     last_checkin_time TIMESTAMP WITH TIME ZONE,
776     last_checkin_scan_time TIMESTAMP WITH TIME ZONE
777 );
778
779
780 CREATE OR REPLACE FUNCTION action.circ_chain ( ctx_circ_id BIGINT ) RETURNS SETOF action.circulation AS $$
781 DECLARE
782     tmp_circ action.circulation%ROWTYPE;
783     circ_0 action.circulation%ROWTYPE;
784 BEGIN
785
786     SELECT INTO tmp_circ * FROM action.circulation WHERE id = ctx_circ_id;
787
788     IF tmp_circ IS NULL THEN
789         RETURN NEXT tmp_circ;
790     END IF;
791     circ_0 := tmp_circ;
792
793     -- find the front of the chain
794     WHILE TRUE LOOP
795         SELECT INTO tmp_circ * FROM action.circulation WHERE id = tmp_circ.parent_circ;
796         IF tmp_circ IS NULL THEN
797             EXIT;
798         END IF;
799         circ_0 := tmp_circ;
800     END LOOP;
801
802     -- now send the circs to the caller, oldest to newest
803     tmp_circ := circ_0;
804     WHILE TRUE LOOP
805         IF tmp_circ IS NULL THEN
806             EXIT;
807         END IF;
808         RETURN NEXT tmp_circ;
809         SELECT INTO tmp_circ * FROM action.circulation WHERE parent_circ = tmp_circ.id;
810     END LOOP;
811
812 END;
813 $$ LANGUAGE 'plpgsql';
814
815 CREATE OR REPLACE FUNCTION action.summarize_circ_chain ( ctx_circ_id BIGINT ) RETURNS action.circ_chain_summary AS $$
816
817 DECLARE
818
819     -- first circ in the chain
820     circ_0 action.circulation%ROWTYPE;
821
822     -- last circ in the chain
823     circ_n action.circulation%ROWTYPE;
824
825     -- circ chain under construction
826     chain action.circ_chain_summary;
827     tmp_circ action.circulation%ROWTYPE;
828
829 BEGIN
830     
831     chain.num_circs := 0;
832     FOR tmp_circ IN SELECT * FROM action.circ_chain(ctx_circ_id) LOOP
833
834         IF chain.num_circs = 0 THEN
835             circ_0 := tmp_circ;
836         END IF;
837
838         chain.num_circs := chain.num_circs + 1;
839         circ_n := tmp_circ;
840     END LOOP;
841
842     chain.start_time := circ_0.xact_start;
843     chain.last_stop_fines := circ_n.stop_fines;
844     chain.last_stop_fines_time := circ_n.stop_fines_time;
845     chain.last_checkin_time := circ_n.checkin_time;
846     chain.last_checkin_scan_time := circ_n.checkin_scan_time;
847     SELECT INTO chain.checkout_workstation name FROM actor.workstation WHERE id = circ_0.workstation;
848     SELECT INTO chain.last_checkin_workstation name FROM actor.workstation WHERE id = circ_n.checkin_workstation;
849
850     IF chain.num_circs > 1 THEN
851         chain.last_renewal_time := circ_n.xact_start;
852         SELECT INTO chain.last_renewal_workstation name FROM actor.workstation WHERE id = circ_n.workstation;
853     END IF;
854
855     RETURN chain;
856
857 END;
858 $$ LANGUAGE 'plpgsql';
859
860 -- Return the list of circ chain heads in xact_start order that the user has chosen to "retain"
861 CREATE OR REPLACE FUNCTION action.usr_visible_circs (usr_id INT) RETURNS SETOF action.circulation AS $func$
862 DECLARE
863     c               action.circulation%ROWTYPE;
864     view_age        INTERVAL;
865     usr_view_age    actor.usr_setting%ROWTYPE;
866     usr_view_start  actor.usr_setting%ROWTYPE;
867 BEGIN
868     SELECT * INTO usr_view_age FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.circ.retention_age';
869     SELECT * INTO usr_view_start FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.circ.retention_start';
870
871     IF usr_view_age.value IS NOT NULL AND usr_view_start.value IS NOT NULL THEN
872         -- User opted in and supplied a retention age
873         IF oils_json_to_text(usr_view_age.value)::INTERVAL > AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ) THEN
874             view_age := AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ);
875         ELSE
876             view_age := oils_json_to_text(usr_view_age.value)::INTERVAL;
877         END IF;
878     ELSIF usr_view_start.value IS NOT NULL THEN
879         -- User opted in
880         view_age := AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ);
881     ELSE
882         -- User did not opt in
883         RETURN;
884     END IF;
885
886     FOR c IN
887         SELECT  *
888           FROM  action.circulation
889           WHERE usr = usr_id
890                 AND parent_circ IS NULL
891                 AND xact_start > NOW() - view_age
892           ORDER BY xact_start DESC
893     LOOP
894         RETURN NEXT c;
895     END LOOP;
896
897     RETURN;
898 END;
899 $func$ LANGUAGE PLPGSQL;
900
901 CREATE OR REPLACE FUNCTION action.usr_visible_circ_copies( INTEGER ) RETURNS SETOF BIGINT AS $$
902     SELECT DISTINCT(target_copy) FROM action.usr_visible_circs($1)
903 $$ LANGUAGE SQL ROWS 10;
904
905 CREATE OR REPLACE FUNCTION action.usr_visible_holds (usr_id INT) RETURNS SETOF action.hold_request AS $func$
906 DECLARE
907     h               action.hold_request%ROWTYPE;
908     view_age        INTERVAL;
909     view_count      INT;
910     usr_view_count  actor.usr_setting%ROWTYPE;
911     usr_view_age    actor.usr_setting%ROWTYPE;
912     usr_view_start  actor.usr_setting%ROWTYPE;
913 BEGIN
914     SELECT * INTO usr_view_count FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.hold.retention_count';
915     SELECT * INTO usr_view_age FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.hold.retention_age';
916     SELECT * INTO usr_view_start FROM actor.usr_setting WHERE usr = usr_id AND name = 'history.hold.retention_start';
917
918     FOR h IN
919         SELECT  *
920           FROM  action.hold_request
921           WHERE usr = usr_id
922                 AND fulfillment_time IS NULL
923                 AND cancel_time IS NULL
924           ORDER BY request_time DESC
925     LOOP
926         RETURN NEXT h;
927     END LOOP;
928
929     IF usr_view_start.value IS NULL THEN
930         RETURN;
931     END IF;
932
933     IF usr_view_age.value IS NOT NULL THEN
934         -- User opted in and supplied a retention age
935         IF oils_json_to_text(usr_view_age.value)::INTERVAL > AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ) THEN
936             view_age := AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ);
937         ELSE
938             view_age := oils_json_to_text(usr_view_age.value)::INTERVAL;
939         END IF;
940     ELSE
941         -- User opted in
942         view_age := AGE(NOW(), oils_json_to_text(usr_view_start.value)::TIMESTAMPTZ);
943     END IF;
944
945     IF usr_view_count.value IS NOT NULL THEN
946         view_count := oils_json_to_text(usr_view_count.value)::INT;
947     ELSE
948         view_count := 1000;
949     END IF;
950
951     -- show some fulfilled/canceled holds
952     FOR h IN
953         SELECT  *
954           FROM  action.hold_request
955           WHERE usr = usr_id
956                 AND ( fulfillment_time IS NOT NULL OR cancel_time IS NOT NULL )
957                 AND COALESCE(fulfillment_time, cancel_time) > NOW() - view_age
958           ORDER BY COALESCE(fulfillment_time, cancel_time) DESC
959           LIMIT view_count
960     LOOP
961         RETURN NEXT h;
962     END LOOP;
963
964     RETURN;
965 END;
966 $func$ LANGUAGE PLPGSQL;
967
968 CREATE OR REPLACE FUNCTION action.purge_circulations () RETURNS INT AS $func$
969 DECLARE
970     usr_keep_age    actor.usr_setting%ROWTYPE;
971     usr_keep_start  actor.usr_setting%ROWTYPE;
972     org_keep_age    INTERVAL;
973     org_use_last    BOOL = false;
974     org_age_is_min  BOOL = false;
975     org_keep_count  INT;
976
977     keep_age        INTERVAL;
978
979     target_acp      RECORD;
980     circ_chain_head action.circulation%ROWTYPE;
981     circ_chain_tail action.circulation%ROWTYPE;
982
983     count_purged    INT;
984     num_incomplete  INT;
985
986     last_finished   TIMESTAMP WITH TIME ZONE;
987 BEGIN
988
989     count_purged := 0;
990
991     SELECT value::INTERVAL INTO org_keep_age FROM config.global_flag WHERE name = 'history.circ.retention_age' AND enabled;
992
993     SELECT value::INT INTO org_keep_count FROM config.global_flag WHERE name = 'history.circ.retention_count' AND enabled;
994     IF org_keep_count IS NULL THEN
995         RETURN count_purged; -- Gimme a count to keep, or I keep them all, forever
996     END IF;
997
998     SELECT enabled INTO org_use_last FROM config.global_flag WHERE name = 'history.circ.retention_uses_last_finished';
999     SELECT enabled INTO org_age_is_min FROM config.global_flag WHERE name = 'history.circ.retention_age_is_min';
1000
1001     -- First, find copies with more than keep_count non-renewal circs
1002     FOR target_acp IN
1003         SELECT  target_copy,
1004                 COUNT(*) AS total_real_circs
1005           FROM  action.circulation
1006           WHERE parent_circ IS NULL
1007                 AND xact_finish IS NOT NULL
1008           GROUP BY target_copy
1009           HAVING COUNT(*) > org_keep_count
1010     LOOP
1011         -- And, for those, select circs that are finished and older than keep_age
1012         FOR circ_chain_head IN
1013             -- For reference, the subquery uses a window function to order the circs newest to oldest and number them
1014             -- The outer query then uses that information to skip the most recent set the library wants to keep
1015             -- End result is we don't care what order they come out in, as they are all potentials for deletion.
1016             SELECT ac.* FROM action.circulation ac JOIN (
1017               SELECT  rank() OVER (ORDER BY xact_start DESC), ac.id
1018                 FROM  action.circulation ac
1019                 WHERE ac.target_copy = target_acp.target_copy
1020                   AND ac.parent_circ IS NULL
1021                 ORDER BY ac.xact_start ) ranked USING (id)
1022                 WHERE ranked.rank > org_keep_count
1023         LOOP
1024
1025             SELECT * INTO circ_chain_tail FROM action.circ_chain(circ_chain_head.id) ORDER BY xact_start DESC LIMIT 1;
1026             SELECT COUNT(CASE WHEN xact_finish IS NULL THEN 1 ELSE NULL END), MAX(xact_finish) INTO num_incomplete, last_finished FROM action.circ_chain(circ_chain_head.id);
1027             CONTINUE WHEN circ_chain_tail.xact_finish IS NULL OR num_incomplete > 0;
1028
1029             IF NOT org_use_last THEN
1030                 last_finished := circ_chain_tail.xact_finish;
1031             END IF;
1032
1033             -- Now get the user settings, if any, to block purging if the user wants to keep more circs
1034             usr_keep_age.value := NULL;
1035             SELECT * INTO usr_keep_age FROM actor.usr_setting WHERE usr = circ_chain_head.usr AND name = 'history.circ.retention_age';
1036
1037             usr_keep_start.value := NULL;
1038             SELECT * INTO usr_keep_start FROM actor.usr_setting WHERE usr = circ_chain_head.usr AND name = 'history.circ.retention_start';
1039
1040             IF usr_keep_age.value IS NOT NULL AND usr_keep_start.value IS NOT NULL THEN
1041                 IF oils_json_to_text(usr_keep_age.value)::INTERVAL > AGE(NOW(), oils_json_to_text(usr_keep_start.value)::TIMESTAMPTZ) THEN
1042                     keep_age := AGE(NOW(), oils_json_to_text(usr_keep_start.value)::TIMESTAMPTZ);
1043                 ELSE
1044                     keep_age := oils_json_to_text(usr_keep_age.value)::INTERVAL;
1045                 END IF;
1046             ELSIF usr_keep_start.value IS NOT NULL THEN
1047                 keep_age := AGE(NOW(), oils_json_to_text(usr_keep_start.value)::TIMESTAMPTZ);
1048             ELSE
1049                 keep_age := COALESCE( org_keep_age, '2000 years'::INTERVAL );
1050             END IF;
1051
1052             IF org_age_is_min THEN
1053                 keep_age := GREATEST( keep_age, org_keep_age );
1054             END IF;
1055
1056             CONTINUE WHEN AGE(NOW(), last_finished) < keep_age;
1057
1058             -- We've passed the purging tests, purge the circ chain starting at the end
1059             -- A trigger should auto-purge the rest of the chain.
1060             DELETE FROM action.circulation WHERE id = circ_chain_tail.id;
1061
1062             count_purged := count_purged + 1;
1063
1064         END LOOP;
1065     END LOOP;
1066
1067     return count_purged;
1068 END;
1069 $func$ LANGUAGE PLPGSQL;
1070
1071 CREATE OR REPLACE FUNCTION action.purge_holds() RETURNS INT AS $func$
1072 DECLARE
1073   current_hold RECORD;
1074   purged_holds INT;
1075   cgf_d INTERVAL;
1076   cgf_f INTERVAL;
1077   cgf_c INTERVAL;
1078   prev_usr INT;
1079   user_start TIMESTAMPTZ;
1080   user_age INTERVAL;
1081   user_count INT;
1082 BEGIN
1083   purged_holds := 0;
1084   SELECT INTO cgf_d value::INTERVAL FROM config.global_flag WHERE name = 'history.hold.retention_age' AND enabled;
1085   SELECT INTO cgf_f value::INTERVAL FROM config.global_flag WHERE name = 'history.hold.retention_age_fulfilled' AND enabled;
1086   SELECT INTO cgf_c value::INTERVAL FROM config.global_flag WHERE name = 'history.hold.retention_age_canceled' AND enabled;
1087   FOR current_hold IN
1088     SELECT
1089       rank() OVER (PARTITION BY usr ORDER BY COALESCE(fulfillment_time, cancel_time) DESC),
1090       cgf_cs.value::INTERVAL as cgf_cs,
1091       ahr.*
1092     FROM
1093       action.hold_request ahr
1094       LEFT JOIN config.global_flag cgf_cs ON (ahr.cancel_cause IS NOT NULL AND cgf_cs.name = 'history.hold.retention_age_canceled_' || ahr.cancel_cause AND cgf_cs.enabled)
1095     WHERE
1096       (fulfillment_time IS NOT NULL OR cancel_time IS NOT NULL)
1097   LOOP
1098     IF prev_usr IS NULL OR prev_usr != current_hold.usr THEN
1099       prev_usr := current_hold.usr;
1100       SELECT INTO user_start oils_json_to_text(value)::TIMESTAMPTZ FROM actor.usr_setting WHERE usr = prev_usr AND name = 'history.hold.retention_start';
1101       SELECT INTO user_age oils_json_to_text(value)::INTERVAL FROM actor.usr_setting WHERE usr = prev_usr AND name = 'history.hold.retention_age';
1102       SELECT INTO user_count oils_json_to_text(value)::INT FROM actor.usr_setting WHERE usr = prev_usr AND name = 'history.hold.retention_count';
1103       IF user_start IS NOT NULL THEN
1104         user_age := LEAST(user_age, AGE(NOW(), user_start));
1105       END IF;
1106       IF user_count IS NULL THEN
1107         user_count := 1000; -- Assumption based on the user visible holds routine
1108       END IF;
1109     END IF;
1110     -- Library keep age trumps user keep anything, for purposes of being able to hold on to things when staff canceled and such.
1111     IF current_hold.fulfillment_time IS NOT NULL AND current_hold.fulfillment_time > NOW() - COALESCE(cgf_f, cgf_d) THEN
1112       CONTINUE;
1113     END IF;
1114     IF current_hold.cancel_time IS NOT NULL AND current_hold.cancel_time > NOW() - COALESCE(current_hold.cgf_cs, cgf_c, cgf_d) THEN
1115       CONTINUE;
1116     END IF;
1117
1118     -- User keep age needs combining with count. If too old AND within the count, keep!
1119     IF user_start IS NOT NULL AND COALESCE(current_hold.fulfillment_time, current_hold.cancel_time) > NOW() - user_age AND current_hold.rank <= user_count THEN
1120       CONTINUE;
1121     END IF;
1122
1123     -- All checks should have passed, delete!
1124     DELETE FROM action.hold_request WHERE id = current_hold.id;
1125     purged_holds := purged_holds + 1;
1126   END LOOP;
1127   RETURN purged_holds;
1128 END;
1129 $func$ LANGUAGE plpgsql;
1130
1131 CREATE OR REPLACE FUNCTION action.apply_fieldset(
1132         fieldset_id IN INT,        -- id from action.fieldset
1133         table_name  IN TEXT,       -- table to be updated
1134         pkey_name   IN TEXT,       -- name of primary key column in that table
1135         query       IN TEXT        -- query constructed by qstore (for query-based
1136                                    --    fieldsets only; otherwise null
1137 )
1138 RETURNS TEXT AS $$
1139 DECLARE
1140         statement TEXT;
1141         fs_status TEXT;
1142         fs_pkey_value TEXT;
1143         fs_query TEXT;
1144         sep CHAR;
1145         status_code TEXT;
1146         msg TEXT;
1147         update_count INT;
1148         cv RECORD;
1149 BEGIN
1150         -- Sanity checks
1151         IF fieldset_id IS NULL THEN
1152                 RETURN 'Fieldset ID parameter is NULL';
1153         END IF;
1154         IF table_name IS NULL THEN
1155                 RETURN 'Table name parameter is NULL';
1156         END IF;
1157         IF pkey_name IS NULL THEN
1158                 RETURN 'Primary key name parameter is NULL';
1159         END IF;
1160         --
1161         statement := 'UPDATE ' || table_name || ' SET';
1162         --
1163         SELECT
1164                 status,
1165                 quote_literal( pkey_value )
1166         INTO
1167                 fs_status,
1168                 fs_pkey_value
1169         FROM
1170                 action.fieldset
1171         WHERE
1172                 id = fieldset_id;
1173         --
1174         IF fs_status IS NULL THEN
1175                 RETURN 'No fieldset found for id = ' || fieldset_id;
1176         ELSIF fs_status = 'APPLIED' THEN
1177                 RETURN 'Fieldset ' || fieldset_id || ' has already been applied';
1178         END IF;
1179         --
1180         sep := '';
1181         FOR cv IN
1182                 SELECT  col,
1183                                 val
1184                 FROM    action.fieldset_col_val
1185                 WHERE   fieldset = fieldset_id
1186         LOOP
1187                 statement := statement || sep || ' ' || cv.col
1188                                          || ' = ' || coalesce( quote_literal( cv.val ), 'NULL' );
1189                 sep := ',';
1190         END LOOP;
1191         --
1192         IF sep = '' THEN
1193                 RETURN 'Fieldset ' || fieldset_id || ' has no column values defined';
1194         END IF;
1195         --
1196         -- Add the WHERE clause.  This differs according to whether it's a
1197         -- single-row fieldset or a query-based fieldset.
1198         --
1199         IF query IS NULL        AND fs_pkey_value IS NULL THEN
1200                 RETURN 'Incomplete fieldset: neither a primary key nor a query available';
1201         ELSIF query IS NOT NULL AND fs_pkey_value IS NULL THEN
1202             fs_query := rtrim( query, ';' );
1203             statement := statement || ' WHERE ' || pkey_name || ' IN ( '
1204                          || fs_query || ' );';
1205         ELSIF query IS NULL     AND fs_pkey_value IS NOT NULL THEN
1206                 statement := statement || ' WHERE ' || pkey_name || ' = '
1207                                      || fs_pkey_value || ';';
1208         ELSE  -- both are not null
1209                 RETURN 'Ambiguous fieldset: both a primary key and a query provided';
1210         END IF;
1211         --
1212         -- Execute the update
1213         --
1214         BEGIN
1215                 EXECUTE statement;
1216                 GET DIAGNOSTICS update_count = ROW_COUNT;
1217                 --
1218                 IF UPDATE_COUNT > 0 THEN
1219                         status_code := 'APPLIED';
1220                         msg := NULL;
1221                 ELSE
1222                         status_code := 'ERROR';
1223                         msg := 'No eligible rows found for fieldset ' || fieldset_id;
1224         END IF;
1225         EXCEPTION WHEN OTHERS THEN
1226                 status_code := 'ERROR';
1227                 msg := 'Unable to apply fieldset ' || fieldset_id
1228                            || ': ' || sqlerrm;
1229         END;
1230         --
1231         -- Update fieldset status
1232         --
1233         UPDATE action.fieldset
1234         SET status       = status_code,
1235             applied_time = now()
1236         WHERE id = fieldset_id;
1237         --
1238         RETURN msg;
1239 END;
1240 $$ LANGUAGE plpgsql;
1241
1242 COMMENT ON FUNCTION action.apply_fieldset( INT, TEXT, TEXT, TEXT ) IS $$
1243 Applies a specified fieldset, using a supplied table name and primary
1244 key name.  The query parameter should be non-null only for
1245 query-based fieldsets.
1246
1247 Returns NULL if successful, or an error message if not.
1248 $$;
1249
1250 CREATE OR REPLACE FUNCTION action.hold_copy_calculated_proximity(
1251     ahr_id INT,
1252     acp_id BIGINT,
1253     copy_context_ou INT DEFAULT NULL
1254     -- TODO maybe? hold_context_ou INT DEFAULT NULL.  This would optionally
1255     -- support an "ahprox" measurement: adjust prox between copy circ lib and
1256     -- hold request lib, but I'm unsure whether to use this theoretical
1257     -- argument only in the baseline calculation or later in the other
1258     -- queries in this function.
1259 ) RETURNS NUMERIC AS $f$
1260 DECLARE
1261     aoupa           actor.org_unit_proximity_adjustment%ROWTYPE;
1262     ahr             action.hold_request%ROWTYPE;
1263     acp             asset.copy%ROWTYPE;
1264     acn             asset.call_number%ROWTYPE;
1265     acl             asset.copy_location%ROWTYPE;
1266     baseline_prox   NUMERIC;
1267
1268     icl_list        INT[];
1269     iol_list        INT[];
1270     isl_list        INT[];
1271     hpl_list        INT[];
1272     hrl_list        INT[];
1273
1274 BEGIN
1275
1276     SELECT * INTO ahr FROM action.hold_request WHERE id = ahr_id;
1277     SELECT * INTO acp FROM asset.copy WHERE id = acp_id;
1278     SELECT * INTO acn FROM asset.call_number WHERE id = acp.call_number;
1279     SELECT * INTO acl FROM asset.copy_location WHERE id = acp.location;
1280
1281     IF copy_context_ou IS NULL THEN
1282         copy_context_ou := acp.circ_lib;
1283     END IF;
1284
1285     -- First, gather the baseline proximity of "here" to pickup lib
1286     SELECT prox INTO baseline_prox FROM actor.org_unit_proximity WHERE from_org = copy_context_ou AND to_org = ahr.pickup_lib;
1287
1288     -- Find any absolute adjustments, and set the baseline prox to that
1289     SELECT  adj.* INTO aoupa
1290       FROM  actor.org_unit_proximity_adjustment adj
1291             LEFT JOIN actor.org_unit_ancestors_distance(copy_context_ou) acp_cl ON (acp_cl.id = adj.item_circ_lib)
1292             LEFT JOIN actor.org_unit_ancestors_distance(acn.owning_lib) acn_ol ON (acn_ol.id = adj.item_owning_lib)
1293             LEFT JOIN actor.org_unit_ancestors_distance(acl.owning_lib) acl_ol ON (acn_ol.id = adj.copy_location)
1294             LEFT JOIN actor.org_unit_ancestors_distance(ahr.pickup_lib) ahr_pl ON (ahr_pl.id = adj.hold_pickup_lib)
1295             LEFT JOIN actor.org_unit_ancestors_distance(ahr.request_lib) ahr_rl ON (ahr_rl.id = adj.hold_request_lib)
1296       WHERE (adj.circ_mod IS NULL OR adj.circ_mod = acp.circ_modifier) AND
1297         absolute_adjustment AND
1298         COALESCE(acp_cl.id, acn_ol.id, acl_ol.id, ahr_pl.id, ahr_rl.id) IS NOT NULL
1299       ORDER BY
1300             COALESCE(acp_cl.distance,999)
1301                 + COALESCE(acn_ol.distance,999)
1302                 + COALESCE(acl_ol.distance,999)
1303                 + COALESCE(ahr_pl.distance,999)
1304                 + COALESCE(ahr_rl.distance,999),
1305             adj.pos
1306       LIMIT 1;
1307
1308     IF FOUND THEN
1309         baseline_prox := aoupa.prox_adjustment;
1310     END IF;
1311
1312     -- Now find any relative adjustments, and change the baseline prox based on them
1313     FOR aoupa IN
1314         SELECT  adj.* 
1315           FROM  actor.org_unit_proximity_adjustment adj
1316                 LEFT JOIN actor.org_unit_ancestors_distance(copy_context_ou) acp_cl ON (acp_cl.id = adj.item_circ_lib)
1317                 LEFT JOIN actor.org_unit_ancestors_distance(acn.owning_lib) acn_ol ON (acn_ol.id = adj.item_owning_lib)
1318                 LEFT JOIN actor.org_unit_ancestors_distance(acl.owning_lib) acl_ol ON (acn_ol.id = adj.copy_location)
1319                 LEFT JOIN actor.org_unit_ancestors_distance(ahr.pickup_lib) ahr_pl ON (ahr_pl.id = adj.hold_pickup_lib)
1320                 LEFT JOIN actor.org_unit_ancestors_distance(ahr.request_lib) ahr_rl ON (ahr_rl.id = adj.hold_request_lib)
1321           WHERE (adj.circ_mod IS NULL OR adj.circ_mod = acp.circ_modifier) AND
1322             NOT absolute_adjustment AND
1323             COALESCE(acp_cl.id, acn_ol.id, acl_ol.id, ahr_pl.id, ahr_rl.id) IS NOT NULL
1324     LOOP
1325         baseline_prox := baseline_prox + aoupa.prox_adjustment;
1326     END LOOP;
1327
1328     RETURN baseline_prox;
1329 END;
1330 $f$ LANGUAGE PLPGSQL;
1331
1332 COMMIT;