7fa60e32e873049a8dc66ace424a284aa7d64436
[working/Evergreen.git] / Open-ILS / src / sql / Pg / 200.schema.acq.sql
1 /*
2  * Copyright (C) 2009  Georgia Public Library Service
3  * Scott McKellar <scott@esilibrary.com>
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  */
15
16 DROP SCHEMA IF EXISTS acq CASCADE;
17
18 BEGIN;
19
20 CREATE SCHEMA acq;
21
22
23 -- Tables
24
25
26 CREATE TABLE acq.currency_type (
27         code    TEXT PRIMARY KEY,
28         label   TEXT
29 );
30
31 CREATE TABLE acq.exchange_rate (
32     id              SERIAL  PRIMARY KEY,
33     from_currency   TEXT    NOT NULL REFERENCES acq.currency_type (code) DEFERRABLE INITIALLY DEFERRED,
34     to_currency     TEXT    NOT NULL REFERENCES acq.currency_type (code) DEFERRABLE INITIALLY DEFERRED,
35     ratio           NUMERIC NOT NULL,
36     CONSTRAINT exchange_rate_from_to_once UNIQUE (from_currency,to_currency)
37 );
38
39 CREATE TABLE acq.claim_policy (
40         id              SERIAL       PRIMARY KEY,
41         org_unit        INT          NOT NULL REFERENCES actor.org_unit
42                                      DEFERRABLE INITIALLY DEFERRED,
43         name            TEXT         NOT NULL,
44         description     TEXT         NOT NULL,
45         CONSTRAINT name_once_per_org UNIQUE (org_unit, name)
46 );
47
48 CREATE TABLE acq.claim_event_type (
49         id             SERIAL           PRIMARY KEY,
50         org_unit       INT              NOT NULL REFERENCES actor.org_unit(id)
51                                                  DEFERRABLE INITIALLY DEFERRED,
52         code           TEXT             NOT NULL,
53         description    TEXT             NOT NULL,
54         library_initiated BOOL          NOT NULL DEFAULT FALSE,
55         CONSTRAINT event_type_once_per_org UNIQUE ( org_unit, code )
56 );
57
58 CREATE TABLE acq.claim_policy_action (
59         id              SERIAL       PRIMARY KEY,
60         claim_policy    INT          NOT NULL REFERENCES acq.claim_policy
61                                  ON DELETE CASCADE
62                                      DEFERRABLE INITIALLY DEFERRED,
63         action_interval INTERVAL     NOT NULL,
64         action          INT          NOT NULL REFERENCES acq.claim_event_type
65                                      DEFERRABLE INITIALLY DEFERRED,
66         CONSTRAINT action_sequence UNIQUE (claim_policy, action_interval)
67 );
68
69 CREATE TABLE acq.provider (
70     id                  SERIAL  PRIMARY KEY,
71     name                TEXT    NOT NULL,
72     owner               INT     NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
73     currency_type       TEXT    NOT NULL REFERENCES acq.currency_type (code) DEFERRABLE INITIALLY DEFERRED,
74     code                TEXT    NOT NULL,
75     holding_tag         TEXT,
76     san                 TEXT,
77     edi_default         INT,          -- REFERENCES acq.edi_account (id) DEFERRABLE INITIALLY DEFERRED
78         active              BOOL    NOT NULL DEFAULT TRUE,
79         prepayment_required BOOL    NOT NULL DEFAULT FALSE,
80     url                 TEXT,
81     email               TEXT,
82     phone               TEXT,
83     fax_phone           TEXT,
84     default_copy_count  INT     NOT NULL DEFAULT 0,
85         default_claim_policy INT    REFERENCES acq.claim_policy
86                                     DEFERRABLE INITIALLY DEFERRED,
87     CONSTRAINT provider_name_once_per_owner UNIQUE (name,owner),
88         CONSTRAINT code_once_per_owner UNIQUE (code, owner)
89 );
90
91 CREATE TABLE acq.provider_holding_subfield_map (
92     id          SERIAL  PRIMARY KEY,
93     provider    INT     NOT NULL REFERENCES acq.provider (id) DEFERRABLE INITIALLY DEFERRED,
94     name        TEXT    NOT NULL, -- barcode, price, etc
95     subfield    TEXT    NOT NULL,
96     CONSTRAINT name_once_per_provider UNIQUE (provider,name)
97 );
98
99 CREATE TABLE acq.provider_address (
100         id              SERIAL  PRIMARY KEY,
101         valid           BOOL    NOT NULL DEFAULT TRUE,
102         address_type    TEXT,
103     provider    INT     NOT NULL REFERENCES acq.provider (id) DEFERRABLE INITIALLY DEFERRED,
104         street1         TEXT    NOT NULL,
105         street2         TEXT,
106         city            TEXT    NOT NULL,
107         county          TEXT,
108         state           TEXT    NOT NULL,
109         country         TEXT    NOT NULL,
110         post_code       TEXT    NOT NULL,
111         fax_phone       TEXT
112 );
113
114 CREATE TABLE acq.provider_contact (
115         id              SERIAL  PRIMARY KEY,
116     provider    INT NOT NULL REFERENCES acq.provider (id) DEFERRABLE INITIALLY DEFERRED,
117     name    TEXT NOT NULL,
118     role    TEXT, -- free-form.. e.g. "our sales guy"
119     email   TEXT,
120     phone   TEXT
121 );
122
123 CREATE TABLE acq.provider_contact_address (
124         id                      SERIAL  PRIMARY KEY,
125         valid                   BOOL    NOT NULL DEFAULT TRUE,
126         address_type    TEXT,
127         contact                 INT         NOT NULL REFERENCES acq.provider_contact (id) DEFERRABLE INITIALLY DEFERRED,
128         street1                 TEXT    NOT NULL,
129         street2                 TEXT,
130         city                    TEXT    NOT NULL,
131         county                  TEXT,
132         state                   TEXT    NOT NULL,
133         country                 TEXT    NOT NULL,
134         post_code               TEXT    NOT NULL,
135         fax_phone               TEXT
136 );
137
138 CREATE TABLE acq.provider_note (
139         id              SERIAL                          PRIMARY KEY,
140         provider    INT                         NOT NULL REFERENCES acq.provider (id) DEFERRABLE INITIALLY DEFERRED,
141         creator         INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
142         editor          INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
143         create_time     TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
144         edit_time       TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
145         value           TEXT                    NOT NULL
146 );
147 CREATE INDEX acq_pro_note_pro_idx      ON acq.provider_note ( provider );
148 CREATE INDEX acq_pro_note_creator_idx  ON acq.provider_note ( creator );
149 CREATE INDEX acq_pro_note_editor_idx   ON acq.provider_note ( editor );
150
151
152 CREATE TABLE acq.funding_source (
153         id              SERIAL  PRIMARY KEY,
154         name            TEXT    NOT NULL,
155         owner           INT     NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
156         currency_type   TEXT    NOT NULL REFERENCES acq.currency_type (code) DEFERRABLE INITIALLY DEFERRED,
157         code            TEXT    UNIQUE,
158         CONSTRAINT funding_source_name_once_per_owner UNIQUE (name,owner)
159 );
160
161 CREATE TABLE acq.funding_source_credit (
162         id      SERIAL     PRIMARY KEY,
163         funding_source INT      NOT NULL REFERENCES acq.funding_source (id) DEFERRABLE INITIALLY DEFERRED,
164         amount         NUMERIC  NOT NULL,
165         note           TEXT,
166         deadline_date  TIMESTAMPTZ,
167         effective_date TIMESTAMPTZ NOT NULL default now()
168 );
169
170 CREATE VIEW acq.ordered_funding_source_credit AS
171     SELECT
172         CASE WHEN deadline_date IS NULL THEN
173             2
174         ELSE
175             1
176         END AS sort_priority,
177         CASE WHEN deadline_date IS NULL THEN
178             effective_date
179         ELSE
180             deadline_date
181         END AS sort_date,
182         id,
183         funding_source,
184         amount,
185         note
186     FROM
187         acq.funding_source_credit;
188
189 COMMENT ON VIEW acq.ordered_funding_source_credit IS $$
190 The acq.ordered_funding_source_credit view is a prioritized
191 ordering of funding source credits.  When ordered by the first
192 three columns, this view defines the order in which the various
193 credits are to be tapped for spending, subject to the allocations
194 in the acq.fund_allocation table.
195
196 The first column reflects the principle that we should spend
197 money with deadlines before spending money without deadlines.
198
199 The second column reflects the principle that we should spend the
200 oldest money first.  For money with deadlines, that means that we
201 spend first from the credit with the earliest deadline.  For
202 money without deadlines, we spend first from the credit with the
203 earliest effective date.
204
205 The third column is a tie breaker to ensure a consistent
206 ordering.
207 $$;
208
209 CREATE TABLE acq.fund (
210     id              SERIAL  PRIMARY KEY,
211     org             INT     NOT NULL REFERENCES actor.org_unit (id) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
212     name            TEXT    NOT NULL,
213     year            INT     NOT NULL DEFAULT EXTRACT( YEAR FROM NOW() ),
214     currency_type   TEXT    NOT NULL REFERENCES acq.currency_type (code) DEFERRABLE INITIALLY DEFERRED,
215     code            TEXT,
216         rollover        BOOL    NOT NULL DEFAULT FALSE,
217         propagate       BOOL    NOT NULL DEFAULT TRUE,
218         active          BOOL    NOT NULL DEFAULT TRUE,
219         balance_warning_percent INT,
220         balance_stop_percent    INT,
221     CONSTRAINT name_once_per_org_year UNIQUE (org,name,year),
222     CONSTRAINT code_once_per_org_year UNIQUE (org, code, year),
223         CONSTRAINT acq_fund_rollover_implies_propagate CHECK ( propagate OR NOT rollover )
224 );
225
226 CREATE TABLE acq.fund_debit (
227         id                      SERIAL  PRIMARY KEY,
228         fund                    INT     NOT NULL REFERENCES acq.fund (id) DEFERRABLE INITIALLY DEFERRED,
229         origin_amount           NUMERIC NOT NULL,  -- pre-exchange-rate amount
230         origin_currency_type    TEXT    NOT NULL REFERENCES acq.currency_type (code) DEFERRABLE INITIALLY DEFERRED,
231         amount                  NUMERIC NOT NULL,
232         encumbrance             BOOL    NOT NULL DEFAULT TRUE,
233         debit_type              TEXT    NOT NULL,
234         xfer_destination        INT     REFERENCES acq.fund (id) DEFERRABLE INITIALLY DEFERRED,
235         create_time     TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
236 );
237
238 CREATE TABLE acq.fund_allocation (
239     id          SERIAL  PRIMARY KEY,
240     funding_source        INT     NOT NULL REFERENCES acq.funding_source (id) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
241     fund        INT     NOT NULL REFERENCES acq.fund (id) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
242     amount      NUMERIC NOT NULL,
243     allocator   INT NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
244     note        TEXT,
245         create_time TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
246 );
247 CREATE INDEX fund_alloc_allocator_idx ON acq.fund_allocation ( allocator );
248
249 CREATE TABLE acq.fund_allocation_percent
250 (
251     id                   SERIAL            PRIMARY KEY,
252     funding_source       INT               NOT NULL REFERENCES acq.funding_source
253                                                DEFERRABLE INITIALLY DEFERRED,
254     org                  INT               NOT NULL REFERENCES actor.org_unit
255                                                DEFERRABLE INITIALLY DEFERRED,
256     fund_code            TEXT,
257     percent              NUMERIC           NOT NULL,
258     allocator            INTEGER           NOT NULL REFERENCES actor.usr
259                                                DEFERRABLE INITIALLY DEFERRED,
260     note                 TEXT,
261     create_time          TIMESTAMPTZ       NOT NULL DEFAULT now(),
262     CONSTRAINT logical_key UNIQUE( funding_source, org, fund_code ),
263     CONSTRAINT percentage_range CHECK( percent >= 0 AND percent <= 100 )
264 );
265
266 -- Trigger function to validate combination of org_unit and fund_code
267
268 CREATE OR REPLACE FUNCTION acq.fund_alloc_percent_val()
269 RETURNS TRIGGER AS $$
270 --
271 DECLARE
272 --
273 dummy int := 0;
274 --
275 BEGIN
276     SELECT
277         1
278     INTO
279         dummy
280     FROM
281         acq.fund
282     WHERE
283         org = NEW.org
284         AND code = NEW.fund_code
285         LIMIT 1;
286     --
287     IF dummy = 1 then
288         RETURN NEW;
289     ELSE
290         RAISE EXCEPTION 'No fund exists for org % and code %', NEW.org, NEW.fund_code;
291     END IF;
292 END;
293 $$ LANGUAGE plpgsql;
294
295 CREATE TRIGGER acq_fund_alloc_percent_val_trig
296     BEFORE INSERT OR UPDATE ON acq.fund_allocation_percent
297     FOR EACH ROW EXECUTE PROCEDURE acq.fund_alloc_percent_val();
298
299 -- To do: trigger to verify that percentages don't add up to more than 100
300
301 CREATE OR REPLACE FUNCTION acq.fap_limit_100()
302 RETURNS TRIGGER AS $$
303 DECLARE
304 --
305 total_percent numeric;
306 --
307 BEGIN
308     SELECT
309         sum( percent )
310     INTO
311         total_percent
312     FROM
313         acq.fund_allocation_percent AS fap
314     WHERE
315         fap.funding_source = NEW.funding_source;
316     --
317     IF total_percent > 100 THEN
318         RAISE EXCEPTION 'Total percentages exceed 100 for funding_source %',
319             NEW.funding_source;
320     ELSE
321         RETURN NEW;
322     END IF;
323 END;
324 $$ LANGUAGE plpgsql;
325
326 CREATE TRIGGER acqfap_limit_100_trig
327     AFTER INSERT OR UPDATE ON acq.fund_allocation_percent
328     FOR EACH ROW EXECUTE PROCEDURE acq.fap_limit_100();
329
330 CREATE TABLE acq.picklist (
331         id              SERIAL                          PRIMARY KEY,
332         owner           INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
333         creator         INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
334         editor          INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
335         org_unit        INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
336         name            TEXT                            NOT NULL,
337         create_time     TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
338         edit_time       TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
339         CONSTRAINT name_once_per_owner UNIQUE (name,owner)
340 );
341 CREATE INDEX acq_picklist_owner_idx   ON acq.picklist ( owner );
342 CREATE INDEX acq_picklist_creator_idx ON acq.picklist ( creator );
343 CREATE INDEX acq_picklist_editor_idx  ON acq.picklist ( editor );
344
345 CREATE TABLE acq.cancel_reason (
346         id            SERIAL            PRIMARY KEY,
347         org_unit      INTEGER           NOT NULL REFERENCES actor.org_unit( id )
348                                         DEFERRABLE INITIALLY DEFERRED,
349         label         TEXT              NOT NULL,
350         description   TEXT              NOT NULL,
351                 keep_debits   BOOL              NOT NULL DEFAULT FALSE,
352         CONSTRAINT acq_cancel_reason_one_per_org_unit UNIQUE( org_unit, label )
353 );
354
355 -- Reserve ids 1-999 for stock reasons
356 -- Reserve ids 1000-1999 for EDI reasons
357 -- 2000+ are available for staff to create
358
359 SELECT SETVAL('acq.cancel_reason_id_seq'::TEXT, 2000);
360
361 DROP TRIGGER IF EXISTS acq_no_deleted_reserved_cancel_reasons ON acq.cancel_reason;
362
363 CREATE TRIGGER acq_no_deleted_reserved_cancel_reasons BEFORE DELETE ON acq.cancel_reason
364     FOR EACH ROW EXECUTE PROCEDURE evergreen.protect_reserved_rows_from_delete(2000);
365
366 CREATE TABLE acq.purchase_order (
367         id              SERIAL                          PRIMARY KEY,
368         owner           INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
369         creator         INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
370         editor          INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
371         ordering_agency INT                             NOT NULL REFERENCES actor.org_unit (id) DEFERRABLE INITIALLY DEFERRED,
372         create_time     TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
373         edit_time       TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
374         provider        INT                             NOT NULL REFERENCES acq.provider (id) DEFERRABLE INITIALLY DEFERRED,
375         state                   TEXT                                    NOT NULL DEFAULT 'new',
376         order_date              TIMESTAMP WITH TIME ZONE,
377         name                    TEXT                                    NOT NULL,
378         cancel_reason   INT                     REFERENCES acq.cancel_reason( id )
379                                             DEFERRABLE INITIALLY DEFERRED,
380         prepayment_required BOOLEAN NOT NULL DEFAULT FALSE,
381     CONSTRAINT valid_po_state CHECK (state IN ('new','pending','on-order','received','cancelled'))
382 );
383 CREATE INDEX po_owner_idx ON acq.purchase_order (owner);
384 CREATE INDEX po_provider_idx ON acq.purchase_order (provider);
385 CREATE INDEX po_state_idx ON acq.purchase_order (state);
386 CREATE INDEX po_creator_idx  ON acq.purchase_order ( creator );
387 CREATE INDEX po_editor_idx   ON acq.purchase_order ( editor );
388 CREATE INDEX acq_po_org_name_order_date_idx ON acq.purchase_order( ordering_agency, name, order_date );
389
390 -- The name should default to the id, as text.  We can't reference a column
391 -- in a DEFAULT clause, so we use a trigger:
392
393 CREATE OR REPLACE FUNCTION acq.purchase_order_name_default () RETURNS TRIGGER 
394 AS $$
395 BEGIN
396         IF NEW.name IS NULL THEN
397                 NEW.name := NEW.id::TEXT;
398         END IF;
399
400         RETURN NEW;
401 END;
402 $$ LANGUAGE PLPGSQL;
403
404 CREATE TRIGGER po_name_default_trg
405   BEFORE INSERT OR UPDATE ON acq.purchase_order
406   FOR EACH ROW EXECUTE PROCEDURE acq.purchase_order_name_default ();
407
408 -- The order name should be unique for a given ordering agency on a given order date
409 -- (truncated to midnight), but only where the order_date is not NULL.  Conceptually
410 -- this rule requires a check constraint with a subquery.  However you can't have a
411 -- subquery in a CHECK constraint, so we fake it with a trigger.
412
413 CREATE OR REPLACE FUNCTION acq.po_org_name_date_unique () RETURNS TRIGGER 
414 AS $$
415 DECLARE
416         collision INT;
417 BEGIN
418         --
419         -- If order_date is not null, then make sure we don't have a collision
420         -- on order_date (truncated to day), org, and name
421         --
422         IF NEW.order_date IS NULL THEN
423                 RETURN NEW;
424         END IF;
425         --
426         -- In the WHERE clause, we compare the order_dates without regard to time of day.
427         -- We use a pair of inequalities instead of comparing truncated dates so that the
428         -- query can do an indexed range scan.
429         --
430         SELECT 1 INTO collision
431         FROM acq.purchase_order
432         WHERE
433                 ordering_agency = NEW.ordering_agency
434                 AND name = NEW.name
435                 AND order_date >= date_trunc( 'day', NEW.order_date )
436                 AND order_date <  date_trunc( 'day', NEW.order_date ) + '1 day'::INTERVAL
437                 AND id <> NEW.id;
438         --
439         IF collision IS NULL THEN
440                 -- okay, no collision
441                 RETURN NEW;
442         ELSE
443                 -- collision; nip it in the bud
444                 RAISE EXCEPTION 'Colliding purchase orders: ordering_agency %, date %, name ''%''',
445                         NEW.ordering_agency, NEW.order_date, NEW.name;
446         END IF;
447 END;
448 $$ LANGUAGE PLPGSQL;
449
450 CREATE TRIGGER po_org_name_date_unique_trg
451   BEFORE INSERT OR UPDATE ON acq.purchase_order
452   FOR EACH ROW EXECUTE PROCEDURE acq.po_org_name_date_unique ();
453
454 CREATE TABLE acq.po_note (
455         id              SERIAL                          PRIMARY KEY,
456         purchase_order  INT                             NOT NULL REFERENCES acq.purchase_order (id) DEFERRABLE INITIALLY DEFERRED,
457         creator         INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
458         editor          INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
459         create_time     TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
460         edit_time       TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
461         value           TEXT                    NOT NULL,
462         vendor_public BOOLEAN       NOT NULL DEFAULT FALSE
463 );
464 CREATE INDEX po_note_po_idx ON acq.po_note (purchase_order);
465 CREATE INDEX acq_po_note_creator_idx  ON acq.po_note ( creator );
466 CREATE INDEX acq_po_note_editor_idx   ON acq.po_note ( editor );
467
468 CREATE TABLE acq.lineitem (
469         id                  BIGSERIAL                   PRIMARY KEY,
470         creator             INT                         NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
471         editor              INT                         NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
472         selector            INT                         NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
473         provider            INT                         REFERENCES acq.provider (id) DEFERRABLE INITIALLY DEFERRED,
474         purchase_order      INT                         REFERENCES acq.purchase_order (id) DEFERRABLE INITIALLY DEFERRED,
475         picklist            INT                         REFERENCES acq.picklist (id) DEFERRABLE INITIALLY DEFERRED,
476         expected_recv_time  TIMESTAMP WITH TIME ZONE,
477         create_time         TIMESTAMP WITH TIME ZONE    NOT NULL DEFAULT NOW(),
478         edit_time           TIMESTAMP WITH TIME ZONE    NOT NULL DEFAULT NOW(),
479         marc                TEXT                        NOT NULL,
480         eg_bib_id           BIGINT                      REFERENCES biblio.record_entry (id) DEFERRABLE INITIALLY DEFERRED,
481         source_label        TEXT,
482         state               TEXT                        NOT NULL DEFAULT 'new',
483         cancel_reason       INT                         REFERENCES acq.cancel_reason( id )
484                                                     DEFERRABLE INITIALLY DEFERRED,
485         estimated_unit_price NUMERIC,
486         claim_policy        INT                         REFERENCES acq.claim_policy
487                                                                 DEFERRABLE INITIALLY DEFERRED,
488     queued_record       BIGINT                      REFERENCES vandelay.queued_bib_record (id)
489                                                         ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED,
490     CONSTRAINT picklist_or_po CHECK (picklist IS NOT NULL OR purchase_order IS NOT NULL)
491 );
492 CREATE INDEX li_po_idx ON acq.lineitem (purchase_order);
493 CREATE INDEX li_pl_idx ON acq.lineitem (picklist);
494 CREATE INDEX li_creator_idx   ON acq.lineitem ( creator );
495 CREATE INDEX li_editor_idx    ON acq.lineitem ( editor );
496 CREATE INDEX li_selector_idx  ON acq.lineitem ( selector );
497 CREATE INDEX li_queued_record_idx ON acq.lineitem ( queued_record );
498
499 CREATE TABLE acq.lineitem_alert_text (
500     id               SERIAL         PRIMARY KEY,
501     code             TEXT           NOT NULL,
502     description      TEXT,
503         owning_lib       INT            NOT NULL
504                                         REFERENCES actor.org_unit(id)
505                                         DEFERRABLE INITIALLY DEFERRED,
506         CONSTRAINT alert_one_code_per_org UNIQUE (code, owning_lib)
507 );
508
509 CREATE TABLE acq.lineitem_note (
510         id              SERIAL                          PRIMARY KEY,
511         lineitem        INT                             NOT NULL REFERENCES acq.lineitem (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
512         creator         INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
513         editor          INT                             NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
514         create_time     TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
515         edit_time       TIMESTAMP WITH TIME ZONE        NOT NULL DEFAULT NOW(),
516         value           TEXT                    NOT NULL,
517         alert_text      INT                                              REFERENCES acq.lineitem_alert_text(id)
518                                                                                  DEFERRABLE INITIALLY DEFERRED,
519         vendor_public BOOLEAN       NOT NULL DEFAULT FALSE
520 );
521 CREATE INDEX li_note_li_idx ON acq.lineitem_note (lineitem);
522 CREATE INDEX li_note_creator_idx  ON acq.lineitem_note ( creator );
523 CREATE INDEX li_note_editor_idx   ON acq.lineitem_note ( editor );
524
525 CREATE TABLE acq.lineitem_detail (
526     id          BIGSERIAL       PRIMARY KEY,
527     lineitem    INT         NOT NULL REFERENCES acq.lineitem (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
528     fund        INT         REFERENCES acq.fund (id) DEFERRABLE INITIALLY DEFERRED,
529     fund_debit  INT         REFERENCES acq.fund_debit (id) DEFERRABLE INITIALLY DEFERRED,
530     eg_copy_id  BIGINT,     -- REFERENCES asset.copy (id) ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED, -- XXX could be an serial.issuance
531     barcode     TEXT,
532     cn_label    TEXT,
533     note        TEXT,
534     collection_code TEXT,
535     circ_modifier   TEXT    REFERENCES config.circ_modifier (code) ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED,
536     owning_lib  INT         REFERENCES actor.org_unit (id) ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED,
537     location    INT         REFERENCES asset.copy_location (id) ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED,
538     recv_time   TIMESTAMP WITH TIME ZONE,
539         receiver                INT         REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED,
540         cancel_reason   INT     REFERENCES acq.cancel_reason( id ) DEFERRABLE INITIALLY DEFERRED
541 );
542
543 CREATE INDEX li_detail_li_idx ON acq.lineitem_detail (lineitem);
544 CREATE INDEX lineitem_detail_fund_debit_idx ON acq.lineitem_detail (fund_debit);
545
546 CREATE TABLE acq.lineitem_attr_definition (
547         id              BIGSERIAL       PRIMARY KEY,
548         code            TEXT            NOT NULL,
549         description     TEXT            NOT NULL,
550         remove          TEXT            NOT NULL DEFAULT '',
551         ident           BOOL            NOT NULL DEFAULT FALSE
552 );
553
554 CREATE TABLE acq.lineitem_marc_attr_definition (
555         id              BIGINT  PRIMARY KEY DEFAULT NEXTVAL('acq.lineitem_attr_definition_id_seq'),
556         xpath           TEXT            NOT NULL
557 ) INHERITS (acq.lineitem_attr_definition);
558
559 CREATE TABLE acq.lineitem_provider_attr_definition (
560         id              BIGINT  PRIMARY KEY DEFAULT NEXTVAL('acq.lineitem_attr_definition_id_seq'),
561         xpath           TEXT            NOT NULL,
562         provider        INT     NOT NULL REFERENCES acq.provider (id) DEFERRABLE INITIALLY DEFERRED
563 ) INHERITS (acq.lineitem_attr_definition);
564
565 CREATE TABLE acq.lineitem_generated_attr_definition (
566         id              BIGINT  PRIMARY KEY DEFAULT NEXTVAL('acq.lineitem_attr_definition_id_seq'),
567         xpath           TEXT            NOT NULL
568 ) INHERITS (acq.lineitem_attr_definition);
569
570 CREATE TABLE acq.lineitem_usr_attr_definition (
571         id              BIGINT  PRIMARY KEY DEFAULT NEXTVAL('acq.lineitem_attr_definition_id_seq'),
572         usr             INT     NOT NULL REFERENCES actor.usr (id) DEFERRABLE INITIALLY DEFERRED
573 ) INHERITS (acq.lineitem_attr_definition);
574 CREATE INDEX li_usr_attr_def_usr_idx  ON acq.lineitem_usr_attr_definition ( usr );
575
576 CREATE TABLE acq.lineitem_local_attr_definition (
577         id              BIGINT  PRIMARY KEY DEFAULT NEXTVAL('acq.lineitem_attr_definition_id_seq')
578 ) INHERITS (acq.lineitem_attr_definition);
579
580 CREATE TABLE acq.lineitem_attr (
581         id              BIGSERIAL       PRIMARY KEY,
582         definition      BIGINT          NOT NULL,
583         lineitem        BIGINT          NOT NULL REFERENCES acq.lineitem (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
584         attr_type       TEXT            NOT NULL,
585         attr_name       TEXT            NOT NULL,
586         attr_value      TEXT            NOT NULL,
587         order_ident     BOOLEAN         NOT NULL DEFAULT FALSE
588 );
589
590 CREATE INDEX li_attr_li_idx ON acq.lineitem_attr (lineitem);
591 CREATE INDEX li_attr_value_idx ON acq.lineitem_attr (attr_value);
592 CREATE INDEX li_attr_definition_idx ON acq.lineitem_attr (definition);
593
594
595 -- Seed data
596
597
598 INSERT INTO acq.lineitem_marc_attr_definition ( code, description, xpath ) VALUES ('title','Title of work','//*[@tag="245"]/*[contains("abcmnopr",@code)]');
599 INSERT INTO acq.lineitem_marc_attr_definition ( code, description, xpath ) VALUES ('author','Author of work','//*[@tag="100" or @tag="110" or @tag="113"]/*[contains("ad",@code)]');
600 INSERT INTO acq.lineitem_marc_attr_definition ( code, description, xpath ) VALUES ('language','Language of work','//*[@tag="240"]/*[@code="l"][1]');
601 INSERT INTO acq.lineitem_marc_attr_definition ( code, description, xpath ) VALUES ('pagination','Pagination','//*[@tag="300"]/*[@code="a"][1]');
602 INSERT INTO acq.lineitem_marc_attr_definition ( code, description, xpath, remove ) VALUES ('isbn','ISBN','//*[@tag="020"]/*[@code="a"]', $r$(?:-|\s.+$)$r$);
603 INSERT INTO acq.lineitem_marc_attr_definition ( code, description, xpath, remove ) VALUES ('issn','ISSN','//*[@tag="022"]/*[@code="a"]', $r$(?:-|\s.+$)$r$);
604 INSERT INTO acq.lineitem_marc_attr_definition ( code, description, xpath, remove ) VALUES ('upc', 'UPC', '//*[@tag="024" and @ind1="1"]/*[@code="a"]', $r$(?:-|\s.+$)$r$);
605 INSERT INTO acq.lineitem_marc_attr_definition ( code, description, xpath ) VALUES ('price','Price','//*[@tag="020" or @tag="022"]/*[@code="c"][1]');
606 INSERT INTO acq.lineitem_marc_attr_definition ( code, description, xpath ) VALUES ('identifier','Identifier','//*[@tag="001"]');
607 INSERT INTO acq.lineitem_marc_attr_definition ( code, description, xpath ) VALUES ('publisher','Publisher','//*[@tag="260"]/*[@code="b"][1]');
608 INSERT INTO acq.lineitem_marc_attr_definition ( code, description, xpath ) VALUES ('pubdate','Publication Date','//*[@tag="260"]/*[@code="c"][1]');
609 INSERT INTO acq.lineitem_marc_attr_definition ( code, description, xpath ) VALUES ('edition','Edition','//*[@tag="250"]/*[@code="a"][1]');
610
611 INSERT INTO acq.lineitem_local_attr_definition ( code, description ) VALUES ('estimated_price', 'Estimated Price');
612
613
614 CREATE TABLE acq.distribution_formula (
615         id              SERIAL PRIMARY KEY,
616         owner   INT NOT NULL
617                         REFERENCES actor.org_unit(id) DEFERRABLE INITIALLY DEFERRED,
618         name    TEXT NOT NULL,
619         skip_count      INT NOT NULL DEFAULT 0,
620         CONSTRAINT acqdf_name_once_per_owner UNIQUE (name, owner)
621 );
622
623 CREATE TABLE acq.distribution_formula_entry (
624         id                      SERIAL PRIMARY KEY,
625         formula         INTEGER NOT NULL REFERENCES acq.distribution_formula(id)
626                                 ON DELETE CASCADE
627                                 DEFERRABLE INITIALLY DEFERRED,
628         position        INTEGER NOT NULL,
629         item_count      INTEGER NOT NULL,
630         owning_lib      INTEGER REFERENCES actor.org_unit(id)
631                                 DEFERRABLE INITIALLY DEFERRED,
632         location        INTEGER REFERENCES asset.copy_location(id),
633         fund            INTEGER REFERENCES acq.fund (id),
634         circ_modifier   TEXT REFERENCES config.circ_modifier (code),
635         collection_code TEXT,
636         CONSTRAINT acqdfe_lib_once_per_formula UNIQUE( formula, position ),
637         CONSTRAINT acqdfe_must_be_somewhere
638                                 CHECK( owning_lib IS NOT NULL OR location IS NOT NULL ) 
639 );
640
641 CREATE TABLE acq.distribution_formula_application (
642     id BIGSERIAL PRIMARY KEY,
643     creator INT NOT NULL REFERENCES actor.usr(id) DEFERRABLE INITIALLY DEFERRED,
644     create_time TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
645     formula INT NOT NULL
646         REFERENCES acq.distribution_formula(id) DEFERRABLE INITIALLY DEFERRED,
647     lineitem INT NOT NULL
648         REFERENCES acq.lineitem(id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED
649 );
650
651 CREATE INDEX acqdfa_df_idx
652     ON acq.distribution_formula_application(formula);
653 CREATE INDEX acqdfa_li_idx
654     ON acq.distribution_formula_application(lineitem);
655 CREATE INDEX acqdfa_creator_idx
656     ON acq.distribution_formula_application(creator);
657
658 CREATE TABLE acq.fund_tag (
659         id              SERIAL PRIMARY KEY,
660         owner   INT NOT NULL
661                         REFERENCES actor.org_unit(id) DEFERRABLE INITIALLY DEFERRED,
662         name    TEXT NOT NULL,
663         CONSTRAINT acqft_tag_once_per_owner UNIQUE (name, owner)
664 );
665
666 CREATE TABLE acq.fund_tag_map (
667         id                      SERIAL PRIMARY KEY,
668         fund            INTEGER NOT NULL REFERENCES acq.fund(id)
669                                 DEFERRABLE INITIALLY DEFERRED,
670         tag         INTEGER REFERENCES acq.fund_tag(id)
671                                 ON DELETE CASCADE
672                                 DEFERRABLE INITIALLY DEFERRED,
673         CONSTRAINT acqftm_fund_once_per_tag UNIQUE( fund, tag )
674 );
675
676 CREATE TABLE acq.fund_transfer (
677     id               SERIAL         PRIMARY KEY,
678     src_fund         INT            NOT NULL REFERENCES acq.fund( id )
679                                     DEFERRABLE INITIALLY DEFERRED,
680     src_amount       NUMERIC        NOT NULL,
681     dest_fund        INT            REFERENCES acq.fund( id )
682                                     DEFERRABLE INITIALLY DEFERRED,
683     dest_amount      NUMERIC,
684     transfer_time    TIMESTAMPTZ    NOT NULL DEFAULT now(),
685     transfer_user    INT            NOT NULL REFERENCES actor.usr( id )
686                                     DEFERRABLE INITIALLY DEFERRED,
687     note             TEXT,
688         funding_source_credit INT       NOT NULL REFERENCES acq.funding_source_credit( id )
689                                     DEFERRABLE INITIALLY DEFERRED
690 );
691
692 CREATE INDEX acqftr_usr_idx
693 ON acq.fund_transfer( transfer_user );
694
695 COMMENT ON TABLE acq.fund_transfer IS $$
696 Fund Transfer
697 Each row represents the transfer of money from a source fund
698 to a destination fund.  There should be corresponding entries
699 in acq.fund_allocation.  The purpose of acq.fund_transfer is
700 to record how much money moved from which fund to which other
701 fund.
702
703 The presence of two amount fields, rather than one, reflects
704 the possibility that the two funds are denominated in different
705 currencies.  If they use the same currency type, the two
706 amounts should be the same.
707 $$;
708
709 CREATE TABLE acq.fiscal_calendar (
710         id              SERIAL         PRIMARY KEY,
711         name            TEXT           NOT NULL
712 );
713
714 -- Create a default calendar (though we don't specify its contents). 
715 -- Create a foreign key in actor.org_unit, initially pointing to
716 -- the default calendar.
717
718 INSERT INTO acq.fiscal_calendar (
719     name
720 ) VALUES (
721
722     'Default'
723 );
724
725 ALTER TABLE actor.org_unit ADD FOREIGN KEY
726         (fiscal_calendar) REFERENCES acq.fiscal_calendar( id )
727         DEFERRABLE INITIALLY DEFERRED;
728
729 CREATE TABLE acq.fiscal_year (
730         id              SERIAL         PRIMARY KEY,
731         calendar        INT            NOT NULL
732                                        REFERENCES acq.fiscal_calendar
733                                        ON DELETE CASCADE
734                                        DEFERRABLE INITIALLY DEFERRED,
735         year            INT            NOT NULL,
736         year_begin      TIMESTAMPTZ    NOT NULL,
737         year_end        TIMESTAMPTZ    NOT NULL,
738         CONSTRAINT acq_fy_logical_key  UNIQUE ( calendar, year ),
739     CONSTRAINT acq_fy_physical_key UNIQUE ( calendar, year_begin )
740 );
741
742 CREATE TABLE acq.edi_attr (
743     key     TEXT PRIMARY KEY,
744     label   TEXT NOT NULL UNIQUE
745 );
746
747 CREATE TABLE acq.edi_attr_set (
748     id      SERIAL  PRIMARY KEY,
749     label   TEXT NOT NULL UNIQUE
750 );
751
752 CREATE TABLE acq.edi_attr_set_map (
753     id          SERIAL  PRIMARY KEY,
754     attr_set    INTEGER NOT NULL REFERENCES acq.edi_attr_set(id) 
755                 ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
756     attr        TEXT NOT NULL REFERENCES acq.edi_attr(key) 
757                 ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
758     CONSTRAINT edi_attr_set_map_attr_once UNIQUE (attr_set, attr)
759 );
760
761 CREATE TABLE acq.edi_account (      -- similar tables can extend remote_account for other parts of EG
762     provider    INT     NOT NULL REFERENCES acq.provider          (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
763     in_dir      TEXT,   -- incoming messages dir (probably different than config.remote_account.path, the outgoing dir)
764     vendcode    TEXT,
765     vendacct    TEXT,
766     attr_set    INTEGER REFERENCES acq.edi_attr_set(id) -- NULL OK
767 ) INHERITS (config.remote_account);
768
769 -- We need a UNIQUE constraint here also, to support the FK from acq.provider.edi_default
770 ALTER TABLE acq.edi_account ADD PRIMARY KEY (id);
771
772 CREATE TABLE acq.edi_message (
773     id               SERIAL          PRIMARY KEY,
774     account          INTEGER         REFERENCES acq.edi_account(id)
775                                      DEFERRABLE INITIALLY DEFERRED,
776     remote_file      TEXT,
777     create_time      TIMESTAMPTZ     NOT NULL DEFAULT now(),
778     translate_time   TIMESTAMPTZ,
779     process_time     TIMESTAMPTZ,
780     error_time       TIMESTAMPTZ,
781     status           TEXT            NOT NULL DEFAULT 'new'
782                                      CONSTRAINT status_value CHECK
783                                      ( status IN (
784                                         'new',          -- needs to be translated
785                                         'translated',   -- needs to be processed
786                                         'trans_error',  -- error in translation step
787                                         'processed',    -- needs to have remote_file deleted
788                                         'proc_error',   -- error in processing step
789                                         'delete_error', -- error in deletion
790                                                                                 'retry',        -- need to retry
791                                         'complete'      -- done
792                                      )),
793     edi              TEXT,
794     jedi             TEXT,
795     error            TEXT,
796     purchase_order   INT             REFERENCES acq.purchase_order
797                                      DEFERRABLE INITIALLY DEFERRED,
798         message_type     TEXT            NOT NULL CONSTRAINT valid_message_type CHECK
799                                          ( message_type IN (
800                                                                              'ORDERS',
801                                                                              'ORDRSP',
802                                                                              'INVOIC',
803                                                                              'OSTENQ',
804                                                                              'OSTRPT'
805                                                                          ))
806 );
807 CREATE INDEX edi_message_account_status_idx ON acq.edi_message (account,status);
808 CREATE INDEX edi_message_po_idx ON acq.edi_message (purchase_order);
809 CREATE INDEX edi_message_remote_file_idx ON acq.edi_message (evergreen.lowercase(remote_file));
810
811 -- Note below that the primary key is NOT a SERIAL type.  We will periodically truncate and rebuild
812 -- the table, assigning ids programmatically instead of using a sequence.
813 CREATE TABLE acq.debit_attribution (
814     id                     INT         NOT NULL PRIMARY KEY,
815     fund_debit             INT         NOT NULL
816                                        REFERENCES acq.fund_debit
817                                        DEFERRABLE INITIALLY DEFERRED,
818     debit_amount           NUMERIC     NOT NULL,
819     funding_source_credit  INT         REFERENCES acq.funding_source_credit
820                                        DEFERRABLE INITIALLY DEFERRED,
821     credit_amount          NUMERIC
822 );
823
824 CREATE INDEX acq_attribution_debit_idx
825     ON acq.debit_attribution( fund_debit );
826
827 CREATE INDEX acq_attribution_credit_idx
828     ON acq.debit_attribution( funding_source_credit );
829
830 -- Invoicing
831
832 CREATE TABLE acq.invoice_method (
833     code    TEXT    PRIMARY KEY,
834     name    TEXT    NOT NULL -- i18n-ize
835 );
836
837 CREATE TABLE acq.invoice_payment_method (
838     code    TEXT    PRIMARY KEY,
839     name    TEXT    NOT NULL -- i18n-ize
840 );
841
842 CREATE TABLE acq.invoice (
843     id          SERIAL      PRIMARY KEY,
844     receiver    INT         NOT NULL REFERENCES actor.org_unit (id),
845     provider    INT         NOT NULL REFERENCES acq.provider (id),
846     shipper     INT         NOT NULL REFERENCES acq.provider (id),
847     recv_date   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
848     recv_method TEXT        NOT NULL REFERENCES acq.invoice_method (code) DEFAULT 'EDI',
849     inv_type    TEXT,       -- A "type" field is desired, but no idea what goes here
850     inv_ident   TEXT        NOT NULL, -- vendor-supplied invoice id/number
851         payment_auth TEXT,
852         payment_method TEXT     REFERENCES acq.invoice_payment_method (code)
853                                 DEFERRABLE INITIALLY DEFERRED,
854         note        TEXT,
855     complete    BOOL        NOT NULL DEFAULT FALSE,
856     CONSTRAINT  inv_ident_once_per_provider UNIQUE(provider, inv_ident)
857 );
858
859 CREATE TABLE acq.invoice_entry (
860     id              SERIAL      PRIMARY KEY,
861     invoice         INT         NOT NULL REFERENCES acq.invoice (id) ON DELETE CASCADE,
862     purchase_order  INT         REFERENCES acq.purchase_order (id) ON UPDATE CASCADE ON DELETE SET NULL,
863     lineitem        INT         REFERENCES acq.lineitem (id) ON UPDATE CASCADE ON DELETE SET NULL,
864     inv_item_count  INT         NOT NULL, -- How many acqlids did they say they sent
865     phys_item_count INT, -- and how many did staff count
866     note            TEXT,
867     billed_per_item BOOL,
868     cost_billed     NUMERIC(8,2),
869     actual_cost     NUMERIC(8,2),
870         amount_paid     NUMERIC (8,2)
871 );
872
873 CREATE INDEX ie_inv_idx on acq.invoice_entry (invoice);
874 CREATE INDEX ie_po_idx on acq.invoice_entry (purchase_order);
875 CREATE INDEX ie_li_idx on acq.invoice_entry (lineitem);
876
877 ALTER TABLE acq.fund_debit 
878     ADD COLUMN invoice_entry INTEGER 
879         REFERENCES acq.invoice_entry (id)
880         ON DELETE SET NULL;
881
882 CREATE INDEX fund_debit_invoice_entry_idx ON acq.fund_debit (invoice_entry);
883
884 CREATE TABLE acq.invoice_item_type (
885     code    TEXT    PRIMARY KEY,
886     name    TEXT    NOT NULL,  -- i18n-ize
887         prorate BOOL    NOT NULL DEFAULT FALSE,
888     blanket BOOL    NOT NULL DEFAULT FALSE,
889     CONSTRAINT aiit_not_blanket_and_prorate
890         CHECK (blanket IS FALSE OR prorate IS FALSE)
891 );
892
893 CREATE TABLE acq.po_item (
894         id              SERIAL      PRIMARY KEY,
895         purchase_order  INT         REFERENCES acq.purchase_order (id)
896                                     ON UPDATE CASCADE ON DELETE SET NULL
897                                     DEFERRABLE INITIALLY DEFERRED,
898         fund_debit      INT         REFERENCES acq.fund_debit (id)
899                                     DEFERRABLE INITIALLY DEFERRED,
900         inv_item_type   TEXT        NOT NULL
901                                     REFERENCES acq.invoice_item_type (code)
902                                     DEFERRABLE INITIALLY DEFERRED,
903         title           TEXT,
904         author          TEXT,
905         note            TEXT,
906         estimated_cost  NUMERIC(8,2),
907         fund            INT         REFERENCES acq.fund (id)
908                                     DEFERRABLE INITIALLY DEFERRED,
909     target          BIGINT
910 );
911
912 CREATE INDEX poi_po_idx ON acq.po_item (purchase_order);
913
914 CREATE TABLE acq.invoice_item ( -- for invoice-only debits: taxes/fees/non-bib items/etc
915     id              SERIAL      PRIMARY KEY,
916     invoice         INT         NOT NULL REFERENCES acq.invoice (id) ON UPDATE CASCADE ON DELETE CASCADE,
917     purchase_order  INT         REFERENCES acq.purchase_order (id) ON UPDATE CASCADE ON DELETE SET NULL,
918     fund_debit      INT         REFERENCES acq.fund_debit (id),
919     inv_item_type   TEXT        NOT NULL REFERENCES acq.invoice_item_type (code),
920     title           TEXT,
921     author          TEXT,
922     note            TEXT,
923     cost_billed     NUMERIC(8,2),
924     actual_cost     NUMERIC(8,2),
925         fund            INT         REFERENCES acq.fund (id)
926                                     DEFERRABLE INITIALLY DEFERRED,
927         amount_paid     NUMERIC (8,2),
928         po_item         INT         REFERENCES acq.po_item (id)
929                                     DEFERRABLE INITIALLY DEFERRED,
930     target          BIGINT
931 );
932
933 CREATE INDEX ii_inv_idx on acq.invoice_item (invoice);
934 CREATE INDEX ii_po_idx on acq.invoice_item (purchase_order);
935 CREATE INDEX ii_poi_idx on acq.invoice_item (po_item);
936
937 -- Patron requests
938 CREATE TABLE acq.user_request_type (
939     id      SERIAL  PRIMARY KEY,
940     label   TEXT    NOT NULL UNIQUE -- i18n-ize
941 );
942
943 CREATE TABLE acq.user_request (
944     id                  SERIAL  PRIMARY KEY,
945     usr                 INT     NOT NULL REFERENCES actor.usr (id), -- requesting user
946     hold                BOOL    NOT NULL DEFAULT TRUE,
947
948     pickup_lib          INT     NOT NULL REFERENCES actor.org_unit (id), -- pickup lib
949     holdable_formats    TEXT,           -- nullable, for use in hold creation
950     phone_notify        TEXT,
951     email_notify        BOOL    NOT NULL DEFAULT TRUE,
952     lineitem            INT     REFERENCES acq.lineitem (id) ON DELETE CASCADE,
953     eg_bib              BIGINT  REFERENCES biblio.record_entry (id) ON DELETE CASCADE,
954     request_date        TIMESTAMPTZ NOT NULL DEFAULT NOW(), -- when they requested it
955     need_before         TIMESTAMPTZ,    -- don't create holds after this
956     max_fee             TEXT,
957   
958     request_type        INT     NOT NULL REFERENCES acq.user_request_type (id),
959     isxn                TEXT,
960     title               TEXT,
961     volume              TEXT,
962     author              TEXT,
963     article_title       TEXT,
964     article_pages       TEXT,
965     publisher           TEXT,
966     location            TEXT,
967     pubdate             TEXT,
968     mentioned           TEXT,
969     other_info          TEXT,
970         cancel_reason       INT    REFERENCES acq.cancel_reason( id )
971                                    DEFERRABLE INITIALLY DEFERRED
972 );
973
974
975 -- Functions
976
977 CREATE TYPE acq.flat_lineitem_holding_subfield AS (lineitem int, holding int, subfield text, data text);
978 CREATE OR REPLACE FUNCTION acq.extract_holding_attr_table (lineitem int, tag text) RETURNS SETOF acq.flat_lineitem_holding_subfield AS $$
979 DECLARE
980     counter INT;
981     lida    acq.flat_lineitem_holding_subfield%ROWTYPE;
982 BEGIN
983
984     SELECT  COUNT(*) INTO counter
985       FROM  oils_xpath_table(
986                 'id',
987                 'marc',
988                 'acq.lineitem',
989                 '//*[@tag="' || tag || '"]',
990                 'id=' || lineitem
991             ) as t(i int,c text);
992
993     FOR i IN 1 .. counter LOOP
994         FOR lida IN
995             SELECT  * 
996               FROM  (   SELECT  id,i,t,v
997                           FROM  oils_xpath_table(
998                                     'id',
999                                     'marc',
1000                                     'acq.lineitem',
1001                                     '//*[@tag="' || tag || '"][position()=' || i || ']/*/@code|' ||
1002                                         '//*[@tag="' || tag || '"][position()=' || i || ']/*[@code]',
1003                                     'id=' || lineitem
1004                                 ) as t(id int,t text,v text)
1005                     )x
1006         LOOP
1007             RETURN NEXT lida;
1008         END LOOP;
1009     END LOOP;
1010
1011     RETURN;
1012 END;
1013 $$ LANGUAGE PLPGSQL;
1014
1015 CREATE TYPE acq.flat_lineitem_detail AS (lineitem int, holding int, attr text, data text);
1016 CREATE OR REPLACE FUNCTION acq.extract_provider_holding_data ( lineitem_i int ) RETURNS SETOF acq.flat_lineitem_detail AS $$
1017 DECLARE
1018     prov_i  INT;
1019     tag_t   TEXT;
1020     lida    acq.flat_lineitem_detail%ROWTYPE;
1021 BEGIN
1022     SELECT provider INTO prov_i FROM acq.lineitem WHERE id = lineitem_i;
1023     IF NOT FOUND THEN RETURN; END IF;
1024
1025     SELECT holding_tag INTO tag_t FROM acq.provider WHERE id = prov_i;
1026     IF NOT FOUND OR tag_t IS NULL THEN RETURN; END IF;
1027
1028     FOR lida IN
1029         SELECT  lineitem_i,
1030                 h.holding,
1031                 a.name,
1032                 h.data
1033           FROM  acq.extract_holding_attr_table( lineitem_i, tag_t ) h
1034                 JOIN acq.provider_holding_subfield_map a USING (subfield)
1035           WHERE a.provider = prov_i
1036     LOOP
1037         RETURN NEXT lida;
1038     END LOOP;
1039
1040     RETURN;
1041 END;
1042 $$ LANGUAGE PLPGSQL;
1043
1044 -- select * from acq.extract_provider_holding_data(699);
1045
1046 CREATE OR REPLACE FUNCTION public.extract_acq_marc_field ( BIGINT, TEXT, TEXT) RETURNS TEXT AS $$
1047         SELECT extract_marc_field('acq.lineitem', $1, $2, $3);
1048 $$ LANGUAGE SQL;
1049
1050 CREATE OR REPLACE FUNCTION public.extract_acq_marc_field_set ( BIGINT, TEXT, TEXT) RETURNS SETOF TEXT AS $$
1051         SELECT extract_marc_field_set('acq.lineitem', $1, $2, $3);
1052 $$ LANGUAGE SQL;
1053
1054
1055 /*
1056 CREATE OR REPLACE FUNCTION public.extract_bib_marc_field ( BIGINT, TEXT ) RETURNS TEXT AS $$
1057         SELECT public.extract_marc_field('biblio.record_entry', $1, $2);
1058 $$ LANGUAGE SQL;
1059
1060 CREATE OR REPLACE FUNCTION public.extract_authority_marc_field ( BIGINT, TEXT ) RETURNS TEXT AS $$
1061         SELECT public.extract_marc_field('authority.record_entry', $1, $2);
1062 $$ LANGUAGE SQL;
1063 */
1064 -- For example:
1065 -- INSERT INTO acq.lineitem_provider_attr_definition ( provider, code, description, xpath ) VALUES (1,'price','Price','//*[@tag="020" or @tag="022"]/*[@code="a"][1]');
1066
1067 /*
1068 Suggested vendor fields:
1069         vendor_price
1070         vendor_currency
1071         vendor_avail
1072         vendor_po
1073         vendor_identifier
1074 */
1075
1076 CREATE OR REPLACE FUNCTION public.ingest_acq_marc ( ) RETURNS TRIGGER AS $function$
1077 DECLARE
1078         value           TEXT;
1079         atype           TEXT;
1080         prov            INT;
1081         pos             INT;
1082         adef            RECORD;
1083         xpath_string    TEXT;
1084 BEGIN
1085         FOR adef IN SELECT *,tableoid FROM acq.lineitem_attr_definition LOOP
1086
1087                 SELECT relname::TEXT INTO atype FROM pg_class WHERE oid = adef.tableoid;
1088
1089                 IF (atype NOT IN ('lineitem_usr_attr_definition','lineitem_local_attr_definition')) THEN
1090                         IF (atype = 'lineitem_provider_attr_definition') THEN
1091                                 SELECT provider INTO prov FROM acq.lineitem_provider_attr_definition WHERE id = adef.id;
1092                                 CONTINUE WHEN NEW.provider IS NULL OR prov <> NEW.provider;
1093                         END IF;
1094                         
1095                         IF (atype = 'lineitem_provider_attr_definition') THEN
1096                                 SELECT xpath INTO xpath_string FROM acq.lineitem_provider_attr_definition WHERE id = adef.id;
1097                         ELSIF (atype = 'lineitem_marc_attr_definition') THEN
1098                                 SELECT xpath INTO xpath_string FROM acq.lineitem_marc_attr_definition WHERE id = adef.id;
1099                         ELSIF (atype = 'lineitem_generated_attr_definition') THEN
1100                                 SELECT xpath INTO xpath_string FROM acq.lineitem_generated_attr_definition WHERE id = adef.id;
1101                         END IF;
1102
1103             xpath_string := REGEXP_REPLACE(xpath_string,$re$//?text\(\)$$re$,'');
1104
1105             IF (adef.code = 'title' OR adef.code = 'author') THEN
1106                 -- title and author should not be split
1107                 -- FIXME: once oils_xpath can grok XPATH 2.0 functions, we can use
1108                 -- string-join in the xpath and remove this special case
1109                         SELECT extract_acq_marc_field(id, xpath_string, adef.remove) INTO value FROM acq.lineitem WHERE id = NEW.id;
1110                         IF (value IS NOT NULL AND value <> '') THEN
1111                                     INSERT INTO acq.lineitem_attr (lineitem, definition, attr_type, attr_name, attr_value)
1112                                     VALUES (NEW.id, adef.id, atype, adef.code, value);
1113                 END IF;
1114             ELSE
1115                 pos := 1;
1116                 LOOP
1117                     -- each application of the regex may produce multiple values
1118                     FOR value IN
1119                         SELECT * FROM extract_acq_marc_field_set(
1120                             NEW.id, xpath_string || '[' || pos || ']', adef.remove)
1121                         LOOP
1122
1123                         IF (value IS NOT NULL AND value <> '') THEN
1124                             INSERT INTO acq.lineitem_attr
1125                                 (lineitem, definition, attr_type, attr_name, attr_value)
1126                                 VALUES (NEW.id, adef.id, atype, adef.code, value);
1127                         ELSE
1128                             EXIT;
1129                         END IF;
1130                     END LOOP;
1131                     IF NOT FOUND THEN
1132                         EXIT;
1133                     END IF;
1134                     pos := pos + 1;
1135                END LOOP;
1136             END IF;
1137
1138                 END IF;
1139
1140         END LOOP;
1141
1142         RETURN NULL;
1143 END;
1144 $function$ LANGUAGE PLPGSQL;
1145
1146 CREATE OR REPLACE FUNCTION public.cleanup_acq_marc ( ) RETURNS TRIGGER AS $$
1147 BEGIN
1148         IF TG_OP = 'UPDATE' THEN
1149                 DELETE FROM acq.lineitem_attr
1150                         WHERE lineitem = OLD.id AND attr_type IN ('lineitem_provider_attr_definition', 'lineitem_marc_attr_definition','lineitem_generated_attr_definition');
1151                 RETURN NEW;
1152         ELSE
1153                 DELETE FROM acq.lineitem_attr WHERE lineitem = OLD.id;
1154                 RETURN OLD;
1155         END IF;
1156 END;
1157 $$ LANGUAGE PLPGSQL;
1158
1159 CREATE TRIGGER cleanup_lineitem_trigger
1160         BEFORE UPDATE OR DELETE ON acq.lineitem
1161         FOR EACH ROW EXECUTE PROCEDURE public.cleanup_acq_marc();
1162
1163 CREATE TRIGGER ingest_lineitem_trigger
1164         AFTER INSERT OR UPDATE ON acq.lineitem
1165         FOR EACH ROW EXECUTE PROCEDURE public.ingest_acq_marc();
1166
1167 CREATE OR REPLACE FUNCTION acq.exchange_ratio ( from_ex TEXT, to_ex TEXT ) RETURNS NUMERIC AS $$
1168 DECLARE
1169     rat NUMERIC;
1170 BEGIN
1171     IF from_ex = to_ex THEN
1172         RETURN 1.0;
1173     END IF;
1174
1175     SELECT ratio INTO rat FROM acq.exchange_rate WHERE from_currency = from_ex AND to_currency = to_ex;
1176
1177     IF FOUND THEN
1178         RETURN rat;
1179     ELSE
1180         SELECT ratio INTO rat FROM acq.exchange_rate WHERE from_currency = to_ex AND to_currency = from_ex;
1181         IF FOUND THEN
1182             RETURN 1.0/rat;
1183         END IF;
1184     END IF;
1185
1186     RETURN NULL;
1187
1188 END;
1189 $$ LANGUAGE PLPGSQL;
1190
1191 CREATE OR REPLACE FUNCTION acq.exchange_ratio ( TEXT, TEXT, NUMERIC ) RETURNS NUMERIC AS $$
1192     SELECT $3 * acq.exchange_ratio($1, $2);
1193 $$ LANGUAGE SQL;
1194
1195 CREATE OR REPLACE FUNCTION acq.find_bad_fy()
1196 /*
1197         Examine the acq.fiscal_year table, comparing successive years.
1198         Report any inconsistencies, i.e. years that overlap, have gaps
1199     between them, or are out of sequence.
1200 */
1201 RETURNS SETOF RECORD AS $$
1202 DECLARE
1203         first_row  BOOLEAN;
1204         curr_year  RECORD;
1205         prev_year  RECORD;
1206         return_rec RECORD;
1207 BEGIN
1208         first_row := true;
1209         FOR curr_year in
1210                 SELECT
1211                         id,
1212                         calendar,
1213                         year,
1214                         year_begin,
1215                         year_end
1216                 FROM
1217                         acq.fiscal_year
1218                 ORDER BY
1219                         calendar,
1220                         year_begin
1221         LOOP
1222                 --
1223                 IF first_row THEN
1224                         first_row := FALSE;
1225                 ELSIF curr_year.calendar    = prev_year.calendar THEN
1226                         IF curr_year.year_begin > prev_year.year_end THEN
1227                                 -- This ugly kludge works around the fact that older
1228                                 -- versions of PostgreSQL don't support RETURN QUERY SELECT
1229                                 FOR return_rec IN SELECT
1230                                         prev_year.id,
1231                                         prev_year.year,
1232                                         'Gap between fiscal years'::TEXT
1233                                 LOOP
1234                                         RETURN NEXT return_rec;
1235                                 END LOOP;
1236                         ELSIF curr_year.year_begin < prev_year.year_end THEN
1237                                 FOR return_rec IN SELECT
1238                                         prev_year.id,
1239                                         prev_year.year,
1240                                         'Overlapping fiscal years'::TEXT
1241                                 LOOP
1242                                         RETURN NEXT return_rec;
1243                                 END LOOP;
1244                         ELSIF curr_year.year < prev_year.year THEN
1245                                 FOR return_rec IN SELECT
1246                                         prev_year.id,
1247                                         prev_year.year,
1248                                         'Fiscal years out of order'::TEXT
1249                                 LOOP
1250                                         RETURN NEXT return_rec;
1251                                 END LOOP;
1252                         END IF;
1253                 END IF;
1254                 --
1255                 prev_year := curr_year;
1256         END LOOP;
1257         --
1258         RETURN;
1259 END;
1260 $$ LANGUAGE plpgsql;
1261
1262 CREATE OR REPLACE FUNCTION acq.transfer_fund(
1263         old_fund   IN INT,
1264         old_amount IN NUMERIC,     -- in currency of old fund
1265         new_fund   IN INT,
1266         new_amount IN NUMERIC,     -- in currency of new fund
1267         user_id    IN INT,
1268         xfer_note  IN TEXT         -- to be recorded in acq.fund_transfer
1269         -- ,funding_source_in IN INT  -- if user wants to specify a funding source (see notes)
1270 ) RETURNS VOID AS $$
1271 /* -------------------------------------------------------------------------------
1272
1273 Function to transfer money from one fund to another.
1274
1275 A transfer is represented as a pair of entries in acq.fund_allocation, with a
1276 negative amount for the old (losing) fund and a positive amount for the new
1277 (gaining) fund.  In some cases there may be more than one such pair of entries
1278 in order to pull the money from different funding sources, or more specifically
1279 from different funding source credits.  For each such pair there is also an
1280 entry in acq.fund_transfer.
1281
1282 Since funding_source is a non-nullable column in acq.fund_allocation, we must
1283 choose a funding source for the transferred money to come from.  This choice
1284 must meet two constraints, so far as possible:
1285
1286 1. The amount transferred from a given funding source must not exceed the
1287 amount allocated to the old fund by the funding source.  To that end we
1288 compare the amount being transferred to the amount allocated.
1289
1290 2. We shouldn't transfer money that has already been spent or encumbered, as
1291 defined by the funding attribution process.  We attribute expenses to the
1292 oldest funding source credits first.  In order to avoid transferring that
1293 attributed money, we reverse the priority, transferring from the newest funding
1294 source credits first.  There can be no guarantee that this approach will
1295 avoid overcommitting a fund, but no other approach can do any better.
1296
1297 In this context the age of a funding source credit is defined by the
1298 deadline_date for credits with deadline_dates, and by the effective_date for
1299 credits without deadline_dates, with the proviso that credits with deadline_dates
1300 are all considered "older" than those without.
1301
1302 ----------
1303
1304 In the signature for this function, there is one last parameter commented out,
1305 named "funding_source_in".  Correspondingly, the WHERE clause for the query
1306 driving the main loop has an OR clause commented out, which references the
1307 funding_source_in parameter.
1308
1309 If these lines are uncommented, this function will allow the user optionally to
1310 restrict a fund transfer to a specified funding source.  If the source
1311 parameter is left NULL, then there will be no such restriction.
1312
1313 ------------------------------------------------------------------------------- */ 
1314 DECLARE
1315         same_currency      BOOLEAN;
1316         currency_ratio     NUMERIC;
1317         old_fund_currency  TEXT;
1318         old_remaining      NUMERIC;  -- in currency of old fund
1319         new_fund_currency  TEXT;
1320         new_fund_active    BOOLEAN;
1321         new_remaining      NUMERIC;  -- in currency of new fund
1322         curr_old_amt       NUMERIC;  -- in currency of old fund
1323         curr_new_amt       NUMERIC;  -- in currency of new fund
1324         source_addition    NUMERIC;  -- in currency of funding source
1325         source_deduction   NUMERIC;  -- in currency of funding source
1326         orig_allocated_amt NUMERIC;  -- in currency of funding source
1327         allocated_amt      NUMERIC;  -- in currency of fund
1328         source             RECORD;
1329 BEGIN
1330         --
1331         -- Sanity checks
1332         --
1333         IF old_fund IS NULL THEN
1334                 RAISE EXCEPTION 'acq.transfer_fund: old fund id is NULL';
1335         END IF;
1336         --
1337         IF old_amount IS NULL THEN
1338                 RAISE EXCEPTION 'acq.transfer_fund: amount to transfer is NULL';
1339         END IF;
1340         --
1341         -- The new fund and its amount must be both NULL or both not NULL.
1342         --
1343         IF new_fund IS NOT NULL AND new_amount IS NULL THEN
1344                 RAISE EXCEPTION 'acq.transfer_fund: amount to transfer to receiving fund is NULL';
1345         END IF;
1346         --
1347         IF new_fund IS NULL AND new_amount IS NOT NULL THEN
1348                 RAISE EXCEPTION 'acq.transfer_fund: receiving fund is NULL, its amount is not NULL';
1349         END IF;
1350         --
1351         IF user_id IS NULL THEN
1352                 RAISE EXCEPTION 'acq.transfer_fund: user id is NULL';
1353         END IF;
1354         --
1355         -- Initialize the amounts to be transferred, each denominated
1356         -- in the currency of its respective fund.  They will be
1357         -- reduced on each iteration of the loop.
1358         --
1359         old_remaining := old_amount;
1360         new_remaining := new_amount;
1361         --
1362         -- RAISE NOTICE 'Transferring % in fund % to % in fund %',
1363         --      old_amount, old_fund, new_amount, new_fund;
1364         --
1365         -- Get the currency types of the old and new funds.
1366         --
1367         SELECT
1368                 currency_type
1369         INTO
1370                 old_fund_currency
1371         FROM
1372                 acq.fund
1373         WHERE
1374                 id = old_fund;
1375         --
1376         IF old_fund_currency IS NULL THEN
1377                 RAISE EXCEPTION 'acq.transfer_fund: old fund id % is not defined', old_fund;
1378         END IF;
1379         --
1380         IF new_fund IS NOT NULL THEN
1381                 SELECT
1382                         currency_type,
1383                         active
1384                 INTO
1385                         new_fund_currency,
1386                         new_fund_active
1387                 FROM
1388                         acq.fund
1389                 WHERE
1390                         id = new_fund;
1391                 --
1392                 IF new_fund_currency IS NULL THEN
1393                         RAISE EXCEPTION 'acq.transfer_fund: new fund id % is not defined', new_fund;
1394                 ELSIF NOT new_fund_active THEN
1395                         --
1396                         -- No point in putting money into a fund from whence you can't spend it
1397                         --
1398                         RAISE EXCEPTION 'acq.transfer_fund: new fund id % is inactive', new_fund;
1399                 END IF;
1400                 --
1401                 IF new_amount = old_amount THEN
1402                         same_currency := true;
1403                         currency_ratio := 1;
1404                 ELSE
1405                         --
1406                         -- We'll have to translate currency between funds.  We presume that
1407                         -- the calling code has already applied an appropriate exchange rate,
1408                         -- so we'll apply the same conversion to each sub-transfer.
1409                         --
1410                         same_currency := false;
1411                         currency_ratio := new_amount / old_amount;
1412                 END IF;
1413         END IF;
1414         --
1415         -- Identify the funding source(s) from which we want to transfer the money.
1416         -- The principle is that we want to transfer the newest money first, because
1417         -- we spend the oldest money first.  The priority for spending is defined
1418         -- by a sort of the view acq.ordered_funding_source_credit.
1419         --
1420         FOR source in
1421                 SELECT
1422                         ofsc.id,
1423                         ofsc.funding_source,
1424                         ofsc.amount,
1425                         ofsc.amount * acq.exchange_ratio( fs.currency_type, old_fund_currency )
1426                                 AS converted_amt,
1427                         fs.currency_type
1428                 FROM
1429                         acq.ordered_funding_source_credit AS ofsc,
1430                         acq.funding_source fs
1431                 WHERE
1432                         ofsc.funding_source = fs.id
1433                         and ofsc.funding_source IN
1434                         (
1435                                 SELECT funding_source
1436                                 FROM acq.fund_allocation
1437                                 WHERE fund = old_fund
1438                         )
1439                         -- and
1440                         -- (
1441                         --      ofsc.funding_source = funding_source_in
1442                         --      OR funding_source_in IS NULL
1443                         -- )
1444                 ORDER BY
1445                         ofsc.sort_priority desc,
1446                         ofsc.sort_date desc,
1447                         ofsc.id desc
1448         LOOP
1449                 --
1450                 -- Determine how much money the old fund got from this funding source,
1451                 -- denominated in the currency types of the source and of the fund.
1452                 -- This result may reflect transfers from previous iterations.
1453                 --
1454                 SELECT
1455                         COALESCE( sum( amount ), 0 ),
1456                         COALESCE( sum( amount )
1457                                 * acq.exchange_ratio( source.currency_type, old_fund_currency ), 0 )
1458                 INTO
1459                         orig_allocated_amt,     -- in currency of the source
1460                         allocated_amt           -- in currency of the old fund
1461                 FROM
1462                         acq.fund_allocation
1463                 WHERE
1464                         fund = old_fund
1465                         and funding_source = source.funding_source;
1466                 --      
1467                 -- Determine how much to transfer from this credit, in the currency
1468                 -- of the fund.   Begin with the amount remaining to be attributed:
1469                 --
1470                 curr_old_amt := old_remaining;
1471                 --
1472                 -- Can't attribute more than was allocated from the fund:
1473                 --
1474                 IF curr_old_amt > allocated_amt THEN
1475                         curr_old_amt := allocated_amt;
1476                 END IF;
1477                 --
1478                 -- Can't attribute more than the amount of the current credit:
1479                 --
1480                 IF curr_old_amt > source.converted_amt THEN
1481                         curr_old_amt := source.converted_amt;
1482                 END IF;
1483                 --
1484                 curr_old_amt := trunc( curr_old_amt, 2 );
1485                 --
1486                 old_remaining := old_remaining - curr_old_amt;
1487                 --
1488                 -- Determine the amount to be deducted, if any,
1489                 -- from the old allocation.
1490                 --
1491                 IF old_remaining > 0 THEN
1492                         --
1493                         -- In this case we're using the whole allocation, so use that
1494                         -- amount directly instead of applying a currency translation
1495                         -- and thereby inviting round-off errors.
1496                         --
1497                         source_deduction := - curr_old_amt;
1498                 ELSE 
1499                         source_deduction := trunc(
1500                                 ( - curr_old_amt ) *
1501                                         acq.exchange_ratio( old_fund_currency, source.currency_type ),
1502                                 2 );
1503                 END IF;
1504                 --
1505                 IF source_deduction <> 0 THEN
1506                         --
1507                         -- Insert negative allocation for old fund in fund_allocation,
1508                         -- converted into the currency of the funding source
1509                         --
1510                         INSERT INTO acq.fund_allocation (
1511                                 funding_source,
1512                                 fund,
1513                                 amount,
1514                                 allocator,
1515                                 note
1516                         ) VALUES (
1517                                 source.funding_source,
1518                                 old_fund,
1519                                 source_deduction,
1520                                 user_id,
1521                                 'Transfer to fund ' || new_fund
1522                         );
1523                 END IF;
1524                 --
1525                 IF new_fund IS NOT NULL THEN
1526                         --
1527                         -- Determine how much to add to the new fund, in
1528                         -- its currency, and how much remains to be added:
1529                         --
1530                         IF same_currency THEN
1531                                 curr_new_amt := curr_old_amt;
1532                         ELSE
1533                                 IF old_remaining = 0 THEN
1534                                         --
1535                                         -- This is the last iteration, so nothing should be left
1536                                         --
1537                                         curr_new_amt := new_remaining;
1538                                         new_remaining := 0;
1539                                 ELSE
1540                                         curr_new_amt := trunc( curr_old_amt * currency_ratio, 2 );
1541                                         new_remaining := new_remaining - curr_new_amt;
1542                                 END IF;
1543                         END IF;
1544                         --
1545                         -- Determine how much to add, if any,
1546                         -- to the new fund's allocation.
1547                         --
1548                         IF old_remaining > 0 THEN
1549                                 --
1550                                 -- In this case we're using the whole allocation, so use that amount
1551                                 -- amount directly instead of applying a currency translation and
1552                                 -- thereby inviting round-off errors.
1553                                 --
1554                                 source_addition := curr_new_amt;
1555                         ELSIF source.currency_type = old_fund_currency THEN
1556                                 --
1557                                 -- In this case we don't need a round trip currency translation,
1558                                 -- thereby inviting round-off errors:
1559                                 --
1560                                 source_addition := curr_old_amt;
1561                         ELSE 
1562                                 source_addition := trunc(
1563                                         curr_new_amt *
1564                                                 acq.exchange_ratio( new_fund_currency, source.currency_type ),
1565                                         2 );
1566                         END IF;
1567                         --
1568                         IF source_addition <> 0 THEN
1569                                 --
1570                                 -- Insert positive allocation for new fund in fund_allocation,
1571                                 -- converted to the currency of the founding source
1572                                 --
1573                                 INSERT INTO acq.fund_allocation (
1574                                         funding_source,
1575                                         fund,
1576                                         amount,
1577                                         allocator,
1578                                         note
1579                                 ) VALUES (
1580                                         source.funding_source,
1581                                         new_fund,
1582                                         source_addition,
1583                                         user_id,
1584                                         'Transfer from fund ' || old_fund
1585                                 );
1586                         END IF;
1587                 END IF;
1588                 --
1589                 IF trunc( curr_old_amt, 2 ) <> 0
1590                 OR trunc( curr_new_amt, 2 ) <> 0 THEN
1591                         --
1592                         -- Insert row in fund_transfer, using amounts in the currency of the funds
1593                         --
1594                         INSERT INTO acq.fund_transfer (
1595                                 src_fund,
1596                                 src_amount,
1597                                 dest_fund,
1598                                 dest_amount,
1599                                 transfer_user,
1600                                 note,
1601                                 funding_source_credit
1602                         ) VALUES (
1603                                 old_fund,
1604                                 trunc( curr_old_amt, 2 ),
1605                                 new_fund,
1606                                 trunc( curr_new_amt, 2 ),
1607                                 user_id,
1608                                 xfer_note,
1609                                 source.id
1610                         );
1611                 END IF;
1612                 --
1613                 if old_remaining <= 0 THEN
1614                         EXIT;                   -- Nothing more to be transferred
1615                 END IF;
1616         END LOOP;
1617 END;
1618 $$ LANGUAGE plpgsql;
1619
1620 CREATE OR REPLACE FUNCTION acq.attribute_debits() RETURNS VOID AS $$
1621 /*
1622 Function to attribute expenditures and encumbrances to funding source credits,
1623 and thereby to funding sources.
1624
1625 Read the debits in chonological order, attributing each one to one or
1626 more funding source credits.  Constraints:
1627
1628 1. Don't attribute more to a credit than the amount of the credit.
1629
1630 2. For a given fund, don't attribute more to a funding source than the
1631 source has allocated to that fund.
1632
1633 3. Attribute debits to credits with deadlines before attributing them to
1634 credits without deadlines.  Otherwise attribute to the earliest credits
1635 first, based on the deadline date when present, or on the effective date
1636 when there is no deadline.  Use funding_source_credit.id as a tie-breaker.
1637 This ordering is defined by an ORDER BY clause on the view
1638 acq.ordered_funding_source_credit.
1639
1640 Start by truncating the table acq.debit_attribution.  Then insert a row
1641 into that table for each attribution.  If a debit cannot be fully
1642 attributed, insert a row for the unattributable balance, with the 
1643 funding_source_credit and credit_amount columns NULL.
1644 */
1645 DECLARE
1646         curr_fund_source_bal RECORD;
1647         seqno                INT;     -- sequence num for credits applicable to a fund
1648         fund_credit          RECORD;  -- current row in temp t_fund_credit table
1649         fc                   RECORD;  -- used for loading t_fund_credit table
1650         sc                   RECORD;  -- used for loading t_fund_credit table
1651         --
1652         -- Used exclusively in the main loop:
1653         --
1654         deb                 RECORD;   -- current row from acq.fund_debit table
1655         curr_credit_bal     RECORD;   -- current row from temp t_credit table
1656         debit_balance       NUMERIC;  -- amount left to attribute for current debit
1657         conv_debit_balance  NUMERIC;  -- debit balance in currency of the fund
1658         attr_amount         NUMERIC;  -- amount being attributed, in currency of debit
1659         conv_attr_amount    NUMERIC;  -- amount being attributed, in currency of source
1660         conv_cred_balance   NUMERIC;  -- credit_balance in the currency of the fund
1661         conv_alloc_balance  NUMERIC;  -- allocated balance in the currency of the fund
1662         attrib_count        INT;      -- populates id of acq.debit_attribution
1663 BEGIN
1664         --
1665         -- Load a temporary table.  For each combination of fund and funding source,
1666         -- load an entry with the total amount allocated to that fund by that source.
1667         -- This sum may reflect transfers as well as original allocations.  We will
1668         -- reduce this balance whenever we attribute debits to it.
1669         --
1670         CREATE TEMP TABLE t_fund_source_bal
1671         ON COMMIT DROP AS
1672                 SELECT
1673                         fund AS fund,
1674                         funding_source AS source,
1675                         sum( amount ) AS balance
1676                 FROM
1677                         acq.fund_allocation
1678                 GROUP BY
1679                         fund,
1680                         funding_source
1681                 HAVING
1682                         sum( amount ) > 0;
1683         --
1684         CREATE INDEX t_fund_source_bal_idx
1685                 ON t_fund_source_bal( fund, source );
1686         -------------------------------------------------------------------------------
1687         --
1688         -- Load another temporary table.  For each fund, load zero or more
1689         -- funding source credits from which that fund can get money.
1690         --
1691         CREATE TEMP TABLE t_fund_credit (
1692                 fund        INT,
1693                 seq         INT,
1694                 credit      INT
1695         ) ON COMMIT DROP;
1696         --
1697         FOR fc IN
1698                 SELECT DISTINCT fund
1699                 FROM acq.fund_allocation
1700                 ORDER BY fund
1701         LOOP                  -- Loop over the funds
1702                 seqno := 1;
1703                 FOR sc IN
1704                         SELECT
1705                                 ofsc.id
1706                         FROM
1707                                 acq.ordered_funding_source_credit AS ofsc
1708                         WHERE
1709                                 ofsc.funding_source IN
1710                                 (
1711                                         SELECT funding_source
1712                                         FROM acq.fund_allocation
1713                                         WHERE fund = fc.fund
1714                                 )
1715                 ORDER BY
1716                     ofsc.sort_priority,
1717                     ofsc.sort_date,
1718                     ofsc.id
1719                 LOOP                        -- Add each credit to the list
1720                         INSERT INTO t_fund_credit (
1721                                 fund,
1722                                 seq,
1723                                 credit
1724                         ) VALUES (
1725                                 fc.fund,
1726                                 seqno,
1727                                 sc.id
1728                         );
1729                         --RAISE NOTICE 'Fund % credit %', fc.fund, sc.id;
1730                         seqno := seqno + 1;
1731                 END LOOP;     -- Loop over credits for a given fund
1732         END LOOP;         -- Loop over funds
1733         --
1734         CREATE INDEX t_fund_credit_idx
1735                 ON t_fund_credit( fund, seq );
1736         -------------------------------------------------------------------------------
1737         --
1738         -- Load yet another temporary table.  This one is a list of funding source
1739         -- credits, with their balances.  We shall reduce those balances as we
1740         -- attribute debits to them.
1741         --
1742         CREATE TEMP TABLE t_credit
1743         ON COMMIT DROP AS
1744         SELECT
1745             fsc.id AS credit,
1746             fsc.funding_source AS source,
1747             fsc.amount AS balance,
1748             fs.currency_type AS currency_type
1749         FROM
1750             acq.funding_source_credit AS fsc,
1751             acq.funding_source fs
1752         WHERE
1753             fsc.funding_source = fs.id
1754                         AND fsc.amount > 0;
1755         --
1756         CREATE INDEX t_credit_idx
1757                 ON t_credit( credit );
1758         --
1759         -------------------------------------------------------------------------------
1760         --
1761         -- Now that we have loaded the lookup tables: loop through the debits,
1762         -- attributing each one to one or more funding source credits.
1763         -- 
1764         truncate table acq.debit_attribution;
1765         --
1766         attrib_count := 0;
1767         FOR deb in
1768                 SELECT
1769                         fd.id,
1770                         fd.fund,
1771                         fd.amount,
1772                         f.currency_type,
1773                         fd.encumbrance
1774                 FROM
1775                         acq.fund_debit fd,
1776                         acq.fund f
1777                 WHERE
1778                         fd.fund = f.id
1779                 ORDER BY
1780                         fd.id
1781         LOOP
1782                 --RAISE NOTICE 'Debit %, fund %', deb.id, deb.fund;
1783                 --
1784                 debit_balance := deb.amount;
1785                 --
1786                 -- Loop over the funding source credits that are eligible
1787                 -- to pay for this debit
1788                 --
1789                 FOR fund_credit IN
1790                         SELECT
1791                                 credit
1792                         FROM
1793                                 t_fund_credit
1794                         WHERE
1795                                 fund = deb.fund
1796                         ORDER BY
1797                                 seq
1798                 LOOP
1799                         --RAISE NOTICE '   Examining credit %', fund_credit.credit;
1800                         --
1801                         -- Look up the balance for this credit.  If it's zero, then
1802                         -- it's not useful, so treat it as if you didn't find it.
1803                         -- (Actually there shouldn't be any zero balances in the table,
1804                         -- but we check just to make sure.)
1805                         --
1806                         SELECT *
1807                         INTO curr_credit_bal
1808                         FROM t_credit
1809                         WHERE
1810                                 credit = fund_credit.credit
1811                                 AND balance > 0;
1812                         --
1813                         IF curr_credit_bal IS NULL THEN
1814                                 --
1815                                 -- This credit is exhausted; try the next one.
1816                                 --
1817                                 CONTINUE;
1818                         END IF;
1819                         --
1820                         --
1821                         -- At this point we have an applicable credit with some money left.
1822                         -- Now see if the relevant funding_source has any money left.
1823                         --
1824                         -- Look up the balance of the allocation for this combination of
1825                         -- fund and source.  If you find such an entry, but it has a zero
1826                         -- balance, then it's not useful, so treat it as unfound.
1827                         -- (Actually there shouldn't be any zero balances in the table,
1828                         -- but we check just to make sure.)
1829                         --
1830                         SELECT *
1831                         INTO curr_fund_source_bal
1832                         FROM t_fund_source_bal
1833                         WHERE
1834                                 fund = deb.fund
1835                                 AND source = curr_credit_bal.source
1836                                 AND balance > 0;
1837                         --
1838                         IF curr_fund_source_bal IS NULL THEN
1839                                 --
1840                                 -- This fund/source doesn't exist or is already exhausted,
1841                                 -- so we can't use this credit.  Go on to the next one.
1842                                 --
1843                                 CONTINUE;
1844                         END IF;
1845                         --
1846                         -- Convert the available balances to the currency of the fund
1847                         --
1848                         conv_alloc_balance := curr_fund_source_bal.balance * acq.exchange_ratio(
1849                                 curr_credit_bal.currency_type, deb.currency_type );
1850                         conv_cred_balance := curr_credit_bal.balance * acq.exchange_ratio(
1851                                 curr_credit_bal.currency_type, deb.currency_type );
1852                         --
1853                         -- Determine how much we can attribute to this credit: the minimum
1854                         -- of the debit amount, the fund/source balance, and the
1855                         -- credit balance
1856                         --
1857                         --RAISE NOTICE '   deb bal %', debit_balance;
1858                         --RAISE NOTICE '      source % balance %', curr_credit_bal.source, conv_alloc_balance;
1859                         --RAISE NOTICE '      credit % balance %', curr_credit_bal.credit, conv_cred_balance;
1860                         --
1861                         conv_attr_amount := NULL;
1862                         attr_amount := debit_balance;
1863                         --
1864                         IF attr_amount > conv_alloc_balance THEN
1865                                 attr_amount := conv_alloc_balance;
1866                                 conv_attr_amount := curr_fund_source_bal.balance;
1867                         END IF;
1868                         IF attr_amount > conv_cred_balance THEN
1869                                 attr_amount := conv_cred_balance;
1870                                 conv_attr_amount := curr_credit_bal.balance;
1871                         END IF;
1872                         --
1873                         -- If we're attributing all of one of the balances, then that's how
1874                         -- much we will deduct from the balances, and we already captured
1875                         -- that amount above.  Otherwise we must convert the amount of the
1876                         -- attribution from the currency of the fund back to the currency of
1877                         -- the funding source.
1878                         --
1879                         IF conv_attr_amount IS NULL THEN
1880                                 conv_attr_amount := attr_amount * acq.exchange_ratio(
1881                                         deb.currency_type, curr_credit_bal.currency_type );
1882                         END IF;
1883                         --
1884                         -- Insert a row to record the attribution
1885                         --
1886                         attrib_count := attrib_count + 1;
1887                         INSERT INTO acq.debit_attribution (
1888                                 id,
1889                                 fund_debit,
1890                                 debit_amount,
1891                                 funding_source_credit,
1892                                 credit_amount
1893                         ) VALUES (
1894                                 attrib_count,
1895                                 deb.id,
1896                                 attr_amount,
1897                                 curr_credit_bal.credit,
1898                                 conv_attr_amount
1899                         );
1900                         --
1901                         -- Subtract the attributed amount from the various balances
1902                         --
1903                         debit_balance := debit_balance - attr_amount;
1904                         curr_fund_source_bal.balance := curr_fund_source_bal.balance - conv_attr_amount;
1905                         --
1906                         IF curr_fund_source_bal.balance <= 0 THEN
1907                                 --
1908                                 -- This allocation is exhausted.  Delete it so
1909                                 -- that we don't waste time looking at it again.
1910                                 --
1911                                 DELETE FROM t_fund_source_bal
1912                                 WHERE
1913                                         fund = curr_fund_source_bal.fund
1914                                         AND source = curr_fund_source_bal.source;
1915                         ELSE
1916                                 UPDATE t_fund_source_bal
1917                                 SET balance = balance - conv_attr_amount
1918                                 WHERE
1919                                         fund = curr_fund_source_bal.fund
1920                                         AND source = curr_fund_source_bal.source;
1921                         END IF;
1922                         --
1923                         IF curr_credit_bal.balance <= 0 THEN
1924                                 --
1925                                 -- This funding source credit is exhausted.  Delete it
1926                                 -- so that we don't waste time looking at it again.
1927                                 --
1928                                 --DELETE FROM t_credit
1929                                 --WHERE
1930                                 --      credit = curr_credit_bal.credit;
1931                                 --
1932                                 DELETE FROM t_fund_credit
1933                                 WHERE
1934                                         credit = curr_credit_bal.credit;
1935                         ELSE
1936                                 UPDATE t_credit
1937                                 SET balance = curr_credit_bal.balance
1938                                 WHERE
1939                                         credit = curr_credit_bal.credit;
1940                         END IF;
1941                         --
1942                         -- Are we done with this debit yet?
1943                         --
1944                         IF debit_balance <= 0 THEN
1945                                 EXIT;       -- We've fully attributed this debit; stop looking at credits.
1946                         END IF;
1947                 END LOOP;       -- End loop over credits
1948                 --
1949                 IF debit_balance <> 0 THEN
1950                         --
1951                         -- We weren't able to attribute this debit, or at least not
1952                         -- all of it.  Insert a row for the unattributed balance.
1953                         --
1954                         attrib_count := attrib_count + 1;
1955                         INSERT INTO acq.debit_attribution (
1956                                 id,
1957                                 fund_debit,
1958                                 debit_amount,
1959                                 funding_source_credit,
1960                                 credit_amount
1961                         ) VALUES (
1962                                 attrib_count,
1963                                 deb.id,
1964                                 debit_balance,
1965                                 NULL,
1966                                 NULL
1967                         );
1968                 END IF;
1969         END LOOP;   -- End of loop over debits
1970 END;
1971 $$ LANGUAGE 'plpgsql';
1972
1973 CREATE OR REPLACE FUNCTION acq.copy_fund_tags(
1974         old_fund_id INTEGER,
1975         new_fund_id INTEGER
1976 ) RETURNS VOID AS $$
1977 DECLARE
1978 fund_tag_rec    RECORD;
1979 BEGIN
1980        
1981         FOR fund_tag_rec IN SELECT * FROM acq.fund_tag_map WHERE fund=old_fund_id LOOP
1982                 BEGIN
1983                      INSERT INTO acq.fund_tag_map(fund, tag) VALUES(new_fund_id, fund_tag_rec.tag);
1984                 EXCEPTION
1985                         WHEN unique_violation THEN
1986                         --    RAISE NOTICE 'Fund tag already propagated', old_fund.id;
1987                         CONTINUE;
1988                 END;
1989         END LOOP;
1990         RETURN;
1991 END;
1992 $$ LANGUAGE plpgsql;
1993
1994 CREATE OR REPLACE FUNCTION acq.propagate_funds_by_org_tree(
1995         old_year INTEGER,
1996         user_id INTEGER,
1997         org_unit_id INTEGER,
1998     include_desc BOOL DEFAULT TRUE
1999 ) RETURNS VOID AS $$
2000 DECLARE
2001 --
2002 new_id      INT;
2003 old_fund    RECORD;
2004 org_found   BOOLEAN;
2005 --
2006 BEGIN
2007         --
2008         -- Sanity checks
2009         --
2010         IF old_year IS NULL THEN
2011                 RAISE EXCEPTION 'Input year argument is NULL';
2012         ELSIF old_year NOT BETWEEN 2008 and 2200 THEN
2013                 RAISE EXCEPTION 'Input year is out of range';
2014         END IF;
2015         --
2016         IF user_id IS NULL THEN
2017                 RAISE EXCEPTION 'Input user id argument is NULL';
2018         END IF;
2019         --
2020         IF org_unit_id IS NULL THEN
2021                 RAISE EXCEPTION 'Org unit id argument is NULL';
2022         ELSE
2023                 SELECT TRUE INTO org_found
2024                 FROM actor.org_unit
2025                 WHERE id = org_unit_id;
2026                 --
2027                 IF org_found IS NULL THEN
2028                         RAISE EXCEPTION 'Org unit id is invalid';
2029                 END IF;
2030         END IF;
2031         --
2032         -- Loop over the applicable funds
2033         --
2034         FOR old_fund in SELECT * FROM acq.fund
2035         WHERE
2036                 year = old_year
2037                 AND propagate
2038                 AND ( ( include_desc AND org IN ( SELECT id FROM actor.org_unit_descendants( org_unit_id ) ) )
2039                 OR (NOT include_desc AND org = org_unit_id ) )
2040     
2041         LOOP
2042                 BEGIN
2043                         INSERT INTO acq.fund (
2044                                 org,
2045                                 name,
2046                                 year,
2047                                 currency_type,
2048                                 code,
2049                                 rollover,
2050                                 propagate,
2051                                 balance_warning_percent,
2052                                 balance_stop_percent
2053                         ) VALUES (
2054                                 old_fund.org,
2055                                 old_fund.name,
2056                                 old_year + 1,
2057                                 old_fund.currency_type,
2058                                 old_fund.code,
2059                                 old_fund.rollover,
2060                                 true,
2061                                 old_fund.balance_warning_percent,
2062                                 old_fund.balance_stop_percent
2063                         )
2064                         RETURNING id INTO new_id;
2065                 EXCEPTION
2066                         WHEN unique_violation THEN
2067                                 --RAISE NOTICE 'Fund % already propagated', old_fund.id;
2068                                 CONTINUE;
2069                 END;
2070
2071                 PERFORM acq.copy_fund_tags(old_fund.id,new_id);
2072
2073                 --RAISE NOTICE 'Propagating fund % to fund %',
2074                 --      old_fund.code, new_id;
2075         END LOOP;
2076 END;
2077 $$ LANGUAGE plpgsql;
2078
2079 CREATE OR REPLACE FUNCTION acq.propagate_funds_by_org_unit( old_year INTEGER, user_id INTEGER, org_unit_id INTEGER ) RETURNS VOID AS $$
2080     SELECT acq.propagate_funds_by_org_tree( $1, $2, $3, FALSE );
2081 $$ LANGUAGE SQL;
2082
2083 CREATE OR REPLACE FUNCTION acq.rollover_funds_by_org_tree(
2084         old_year INTEGER,
2085         user_id INTEGER,
2086         org_unit_id INTEGER,
2087     encumb_only BOOL DEFAULT FALSE,
2088     include_desc BOOL DEFAULT TRUE
2089 ) RETURNS VOID AS $$
2090 DECLARE
2091 --
2092 new_fund    INT;
2093 new_year    INT := old_year + 1;
2094 org_found   BOOL;
2095 perm_ous    BOOL;
2096 xfer_amount NUMERIC := 0;
2097 roll_fund   RECORD;
2098 deb         RECORD;
2099 detail      RECORD;
2100 roll_distrib_forms BOOL;
2101 --
2102 BEGIN
2103         --
2104         -- Sanity checks
2105         --
2106         IF old_year IS NULL THEN
2107                 RAISE EXCEPTION 'Input year argument is NULL';
2108     ELSIF old_year NOT BETWEEN 2008 and 2200 THEN
2109         RAISE EXCEPTION 'Input year is out of range';
2110         END IF;
2111         --
2112         IF user_id IS NULL THEN
2113                 RAISE EXCEPTION 'Input user id argument is NULL';
2114         END IF;
2115         --
2116         IF org_unit_id IS NULL THEN
2117                 RAISE EXCEPTION 'Org unit id argument is NULL';
2118         ELSE
2119                 --
2120                 -- Validate the org unit
2121                 --
2122                 SELECT TRUE
2123                 INTO org_found
2124                 FROM actor.org_unit
2125                 WHERE id = org_unit_id;
2126                 --
2127                 IF org_found IS NULL THEN
2128                         RAISE EXCEPTION 'Org unit id % is invalid', org_unit_id;
2129                 ELSIF encumb_only THEN
2130                         SELECT INTO perm_ous value::BOOL FROM
2131                         actor.org_unit_ancestor_setting(
2132                                 'acq.fund.allow_rollover_without_money', org_unit_id
2133                         );
2134                         IF NOT FOUND OR NOT perm_ous THEN
2135                                 RAISE EXCEPTION 'Encumbrance-only rollover not permitted at org %', org_unit_id;
2136                         END IF;
2137                 END IF;
2138         END IF;
2139         --
2140         -- Loop over the propagable funds to identify the details
2141         -- from the old fund plus the id of the new one, if it exists.
2142         --
2143         FOR roll_fund in
2144         SELECT
2145             oldf.id AS old_fund,
2146             oldf.org,
2147             oldf.name,
2148             oldf.currency_type,
2149             oldf.code,
2150                 oldf.rollover,
2151             newf.id AS new_fund_id
2152         FROM
2153         acq.fund AS oldf
2154         LEFT JOIN acq.fund AS newf
2155                 ON ( oldf.code = newf.code )
2156         WHERE
2157                     oldf.year = old_year
2158                 AND oldf.propagate
2159         AND newf.year = new_year
2160                 AND ( ( include_desc AND oldf.org IN ( SELECT id FROM actor.org_unit_descendants( org_unit_id ) ) )
2161                 OR (NOT include_desc AND oldf.org = org_unit_id ) )
2162         LOOP
2163                 --RAISE NOTICE 'Processing fund %', roll_fund.old_fund;
2164                 --
2165                 IF roll_fund.new_fund_id IS NULL THEN
2166                         --
2167                         -- The old fund hasn't been propagated yet.  Propagate it now.
2168                         --
2169                         INSERT INTO acq.fund (
2170                                 org,
2171                                 name,
2172                                 year,
2173                                 currency_type,
2174                                 code,
2175                                 rollover,
2176                                 propagate,
2177                                 balance_warning_percent,
2178                                 balance_stop_percent
2179                         ) VALUES (
2180                                 roll_fund.org,
2181                                 roll_fund.name,
2182                                 new_year,
2183                                 roll_fund.currency_type,
2184                                 roll_fund.code,
2185                                 true,
2186                                 true,
2187                                 roll_fund.balance_warning_percent,
2188                                 roll_fund.balance_stop_percent
2189                         )
2190                         RETURNING id INTO new_fund;
2191
2192                         PERFORM acq.copy_fund_tags(roll_fund.id,new_fund);
2193
2194                 ELSE
2195                         new_fund = roll_fund.new_fund_id;
2196                 END IF;
2197                 --
2198                 -- Determine the amount to transfer
2199                 --
2200                 SELECT amount
2201                 INTO xfer_amount
2202                 FROM acq.fund_spent_balance
2203                 WHERE fund = roll_fund.old_fund;
2204                 --
2205                 IF xfer_amount <> 0 THEN
2206                         IF NOT encumb_only AND roll_fund.rollover THEN
2207                                 --
2208                                 -- Transfer balance from old fund to new
2209                                 --
2210                                 --RAISE NOTICE 'Transferring % from fund % to %', xfer_amount, roll_fund.old_fund, new_fund;
2211                                 --
2212                                 PERFORM acq.transfer_fund(
2213                                         roll_fund.old_fund,
2214                                         xfer_amount,
2215                                         new_fund,
2216                                         xfer_amount,
2217                                         user_id,
2218                                         'Rollover'
2219                                 );
2220                         ELSE
2221                                 --
2222                                 -- Transfer balance from old fund to the void
2223                                 --
2224                                 -- RAISE NOTICE 'Transferring % from fund % to the void', xfer_amount, roll_fund.old_fund;
2225                                 --
2226                                 PERFORM acq.transfer_fund(
2227                                         roll_fund.old_fund,
2228                                         xfer_amount,
2229                                         NULL,
2230                                         NULL,
2231                                         user_id,
2232                                         'Rollover into the void'
2233                                 );
2234                         END IF;
2235                 END IF;
2236                 --
2237                 IF roll_fund.rollover THEN
2238                         --
2239                         -- Move any lineitems from the old fund to the new one
2240                         -- where the associated debit is an encumbrance.
2241                         --
2242                         -- Any other tables tying expenditure details to funds should
2243                         -- receive similar treatment.  At this writing there are none.
2244                         --
2245                         UPDATE acq.lineitem_detail
2246                         SET fund = new_fund
2247                         WHERE
2248                         fund = roll_fund.old_fund -- this condition may be redundant
2249                         AND fund_debit in
2250                         (
2251                                 SELECT id
2252                                 FROM acq.fund_debit
2253                                 WHERE
2254                                 fund = roll_fund.old_fund
2255                                 AND encumbrance
2256                         );
2257                         --
2258                         -- Move encumbrance debits from the old fund to the new fund
2259                         --
2260                         UPDATE acq.fund_debit
2261                         SET fund = new_fund
2262                         wHERE
2263                                 fund = roll_fund.old_fund
2264                                 AND encumbrance;
2265                 END IF;
2266
2267                 -- Rollover distribution formulae funds
2268                 SELECT INTO roll_distrib_forms value::BOOL FROM
2269                         actor.org_unit_ancestor_setting(
2270                                 'acq.fund.rollover_distrib_forms', org_unit_id
2271                         );
2272
2273                 IF roll_distrib_forms THEN
2274                         UPDATE acq.distribution_formula_entry 
2275                                 SET fund = roll_fund.new_fund_id
2276                                 WHERE fund = roll_fund.old_fund;
2277                 END IF;
2278
2279                 --
2280                 -- Mark old fund as inactive, now that we've closed it
2281                 --
2282                 UPDATE acq.fund
2283                 SET active = FALSE
2284                 WHERE id = roll_fund.old_fund;
2285         END LOOP;
2286 END;
2287 $$ LANGUAGE plpgsql;
2288
2289
2290
2291
2292 CREATE OR REPLACE FUNCTION acq.rollover_funds_by_org_unit( old_year INTEGER, user_id INTEGER, org_unit_id INTEGER, encumb_only BOOL DEFAULT FALSE ) RETURNS VOID AS $$
2293     SELECT acq.rollover_funds_by_org_tree( $1, $2, $3, $4, FALSE );
2294 $$ LANGUAGE SQL;
2295
2296 CREATE OR REPLACE VIEW acq.funding_source_credit_total AS
2297     SELECT  funding_source,
2298             SUM(amount) AS amount
2299       FROM  acq.funding_source_credit
2300       GROUP BY 1;
2301
2302 CREATE OR REPLACE VIEW acq.funding_source_allocation_total AS
2303     SELECT  funding_source,
2304             SUM(a.amount)::NUMERIC(100,2) AS amount
2305     FROM  acq.fund_allocation a
2306     GROUP BY 1;
2307
2308 CREATE OR REPLACE VIEW acq.funding_source_balance AS
2309     SELECT  COALESCE(c.funding_source, a.funding_source) AS funding_source,
2310             SUM(COALESCE(c.amount,0.0) - COALESCE(a.amount,0.0))::NUMERIC(100,2) AS amount
2311       FROM  acq.funding_source_credit_total c
2312             FULL JOIN acq.funding_source_allocation_total a USING (funding_source)
2313       GROUP BY 1;
2314
2315 CREATE OR REPLACE VIEW acq.fund_allocation_total AS
2316     SELECT  fund,
2317             SUM(a.amount * acq.exchange_ratio(s.currency_type, f.currency_type))::NUMERIC(100,2) AS amount
2318     FROM acq.fund_allocation a
2319          JOIN acq.fund f ON (a.fund = f.id)
2320          JOIN acq.funding_source s ON (a.funding_source = s.id)
2321     GROUP BY 1;
2322
2323 CREATE OR REPLACE VIEW acq.fund_debit_total AS
2324     SELECT  fund.id AS fund, 
2325             sum(COALESCE(fund_debit.amount, 0::numeric)) AS amount
2326     FROM acq.fund fund
2327         LEFT JOIN acq.fund_debit fund_debit ON fund.id = fund_debit.fund
2328     GROUP BY fund.id;
2329
2330 CREATE OR REPLACE VIEW acq.fund_encumbrance_total AS
2331     SELECT 
2332         fund.id AS fund, 
2333         sum(COALESCE(fund_debit.amount, 0::numeric)) AS amount 
2334     FROM acq.fund fund
2335         LEFT JOIN acq.fund_debit fund_debit ON fund.id = fund_debit.fund 
2336     WHERE fund_debit.encumbrance GROUP BY fund.id;
2337
2338 CREATE OR REPLACE VIEW acq.fund_spent_total AS
2339     SELECT  fund.id AS fund, 
2340             sum(COALESCE(fund_debit.amount, 0::numeric)) AS amount 
2341     FROM acq.fund fund
2342         LEFT JOIN acq.fund_debit fund_debit ON fund.id = fund_debit.fund 
2343     WHERE NOT fund_debit.encumbrance 
2344     GROUP BY fund.id;
2345
2346 CREATE OR REPLACE VIEW acq.fund_combined_balance AS
2347     SELECT  c.fund, 
2348             c.amount - COALESCE(d.amount, 0.0) AS amount
2349     FROM acq.fund_allocation_total c
2350     LEFT JOIN acq.fund_debit_total d USING (fund);
2351
2352 CREATE OR REPLACE VIEW acq.fund_spent_balance AS
2353     SELECT  c.fund,
2354             c.amount - COALESCE(d.amount,0.0) AS amount
2355       FROM  acq.fund_allocation_total c
2356             LEFT JOIN acq.fund_spent_total d USING (fund);
2357
2358 -- For each fund: the total allocation from all sources, in the
2359 -- currency of the fund (or 0 if there are no allocations)
2360
2361 CREATE VIEW acq.all_fund_allocation_total AS
2362 SELECT
2363     f.id AS fund,
2364     COALESCE( SUM( a.amount * acq.exchange_ratio(
2365         s.currency_type, f.currency_type))::numeric(100,2), 0 )
2366     AS amount
2367 FROM
2368     acq.fund f
2369         LEFT JOIN acq.fund_allocation a
2370             ON a.fund = f.id
2371         LEFT JOIN acq.funding_source s
2372             ON a.funding_source = s.id
2373 GROUP BY
2374     f.id;
2375
2376 -- For every fund: the total encumbrances (or 0 if none),
2377 -- in the currency of the fund.
2378
2379 CREATE VIEW acq.all_fund_encumbrance_total AS
2380 SELECT
2381         f.id AS fund,
2382         COALESCE( encumb.amount, 0 ) AS amount
2383 FROM
2384         acq.fund AS f
2385                 LEFT JOIN (
2386                         SELECT
2387                                 fund,
2388                                 sum( amount ) AS amount
2389                         FROM
2390                                 acq.fund_debit
2391                         WHERE
2392                                 encumbrance
2393                         GROUP BY fund
2394                 ) AS encumb
2395                         ON f.id = encumb.fund;
2396
2397 -- For every fund: the total spent (or 0 if none),
2398 -- in the currency of the fund.
2399
2400 CREATE VIEW acq.all_fund_spent_total AS
2401 SELECT
2402     f.id AS fund,
2403     COALESCE( spent.amount, 0 ) AS amount
2404 FROM
2405     acq.fund AS f
2406         LEFT JOIN (
2407             SELECT
2408                 fund,
2409                 sum( amount ) AS amount
2410             FROM
2411                 acq.fund_debit
2412             WHERE
2413                 NOT encumbrance
2414             GROUP BY fund
2415         ) AS spent
2416             ON f.id = spent.fund;
2417
2418 -- For each fund: the amount not yet spent, in the currency
2419 -- of the fund.  May include encumbrances.
2420
2421 CREATE VIEW acq.all_fund_spent_balance AS
2422 SELECT
2423         c.fund,
2424         c.amount - d.amount AS amount
2425 FROM acq.all_fund_allocation_total c
2426     LEFT JOIN acq.all_fund_spent_total d USING (fund);
2427
2428 -- For each fund: the amount neither spent nor encumbered,
2429 -- in the currency of the fund
2430
2431 CREATE VIEW acq.all_fund_combined_balance AS
2432 SELECT
2433      a.fund,
2434      a.amount - COALESCE( c.amount, 0 ) AS amount
2435 FROM
2436      acq.all_fund_allocation_total a
2437         LEFT OUTER JOIN (
2438             SELECT
2439                 fund,
2440                 SUM( amount ) AS amount
2441             FROM
2442                 acq.fund_debit
2443             GROUP BY
2444                 fund
2445         ) AS c USING ( fund );
2446
2447 CREATE TABLE acq.claim_type (
2448         id             SERIAL           PRIMARY KEY,
2449         org_unit       INT              NOT NULL REFERENCES actor.org_unit(id)
2450                                                  DEFERRABLE INITIALLY DEFERRED,
2451         code           TEXT             NOT NULL,
2452         description    TEXT             NOT NULL,
2453         CONSTRAINT claim_type_once_per_org UNIQUE ( org_unit, code )
2454 );
2455
2456 CREATE TABLE acq.claim (
2457         id             SERIAL           PRIMARY KEY,
2458         type           INT              NOT NULL REFERENCES acq.claim_type
2459                                                  DEFERRABLE INITIALLY DEFERRED,
2460         lineitem_detail BIGINT          NOT NULL REFERENCES acq.lineitem_detail
2461                                                  DEFERRABLE INITIALLY DEFERRED
2462 );
2463
2464 CREATE INDEX claim_lid_idx ON acq.claim( lineitem_detail );
2465
2466 CREATE TABLE acq.claim_event (
2467         id             BIGSERIAL        PRIMARY KEY,
2468         type           INT              NOT NULL REFERENCES acq.claim_event_type
2469                                                  DEFERRABLE INITIALLY DEFERRED,
2470         claim          SERIAL           NOT NULL REFERENCES acq.claim
2471                                                  DEFERRABLE INITIALLY DEFERRED,
2472         event_date     TIMESTAMPTZ      NOT NULL DEFAULT now(),
2473         creator        INT              NOT NULL REFERENCES actor.usr
2474                                                  DEFERRABLE INITIALLY DEFERRED,
2475         note           TEXT
2476 );
2477
2478 CREATE INDEX claim_event_claim_date_idx ON acq.claim_event( claim, event_date );
2479
2480 -- And the serials version of claiming
2481 CREATE TABLE acq.serial_claim (
2482     id     SERIAL           PRIMARY KEY,
2483     type   INT              NOT NULL REFERENCES acq.claim_type
2484                                      DEFERRABLE INITIALLY DEFERRED,
2485     item    BIGINT          NOT NULL REFERENCES serial.item
2486                                      DEFERRABLE INITIALLY DEFERRED
2487 );
2488
2489 CREATE INDEX serial_claim_lid_idx ON acq.serial_claim( item );
2490
2491 CREATE TABLE acq.serial_claim_event (
2492     id             BIGSERIAL        PRIMARY KEY,
2493     type           INT              NOT NULL REFERENCES acq.claim_event_type
2494                                              DEFERRABLE INITIALLY DEFERRED,
2495     claim          SERIAL           NOT NULL REFERENCES acq.serial_claim
2496                                              DEFERRABLE INITIALLY DEFERRED,
2497     event_date     TIMESTAMPTZ      NOT NULL DEFAULT now(),
2498     creator        INT              NOT NULL REFERENCES actor.usr
2499                                              DEFERRABLE INITIALLY DEFERRED,
2500     note           TEXT
2501 );
2502
2503 CREATE INDEX serial_claim_event_claim_date_idx ON acq.serial_claim_event( claim, event_date );
2504
2505 CREATE OR REPLACE VIEW acq.lineitem_summary AS
2506     SELECT 
2507         li.id AS lineitem, 
2508         (
2509             SELECT COUNT(lid.id) 
2510             FROM acq.lineitem_detail lid
2511             WHERE lineitem = li.id
2512         ) AS item_count,
2513         (
2514             SELECT COUNT(lid.id) 
2515             FROM acq.lineitem_detail lid
2516             WHERE recv_time IS NOT NULL AND lineitem = li.id
2517         ) AS recv_count,
2518         (
2519             SELECT COUNT(lid.id) 
2520             FROM acq.lineitem_detail lid
2521                 JOIN acq.cancel_reason acqcr ON (acqcr.id = lid.cancel_reason)
2522             WHERE acqcr.keep_debits IS FALSE AND lineitem = li.id
2523         ) AS cancel_count,
2524         (
2525             SELECT COUNT(lid.id) 
2526             FROM acq.lineitem_detail lid
2527                 JOIN acq.cancel_reason acqcr ON (acqcr.id = lid.cancel_reason)
2528             WHERE acqcr.keep_debits IS TRUE AND lineitem = li.id
2529         ) AS delay_count,
2530         (
2531             SELECT COUNT(lid.id) 
2532             FROM acq.lineitem_detail lid
2533                 JOIN acq.fund_debit debit ON (lid.fund_debit = debit.id)
2534             WHERE NOT debit.encumbrance AND lineitem = li.id
2535         ) AS invoice_count,
2536         (
2537             SELECT COUNT(DISTINCT(lid.id)) 
2538             FROM acq.lineitem_detail lid
2539                 JOIN acq.claim claim ON (claim.lineitem_detail = lid.id)
2540             WHERE lineitem = li.id
2541         ) AS claim_count,
2542         (
2543             SELECT (COUNT(lid.id) * li.estimated_unit_price)::NUMERIC(8,2)
2544             FROM acq.lineitem_detail lid
2545             WHERE lid.cancel_reason IS NULL AND lineitem = li.id
2546         ) AS estimated_amount,
2547         (
2548             SELECT SUM(debit.amount)::NUMERIC(8,2)
2549             FROM acq.lineitem_detail lid
2550                 JOIN acq.fund_debit debit ON (lid.fund_debit = debit.id)
2551             WHERE debit.encumbrance AND lineitem = li.id
2552         ) AS encumbrance_amount,
2553         (
2554             SELECT SUM(debit.amount)::NUMERIC(8,2)
2555             FROM acq.lineitem_detail lid
2556                 JOIN acq.fund_debit debit ON (lid.fund_debit = debit.id)
2557             WHERE NOT debit.encumbrance AND lineitem = li.id
2558         ) AS paid_amount
2559
2560         FROM acq.lineitem AS li;
2561
2562 COMMIT;