Open-ILS/src/eg2/src/app/staff/share/course.service.ts

   1 import {AuthService} from '@eg/core/auth.service';
   2 import {EventService} from '@eg/core/event.service';
   3 import {IdlObject, IdlService} from '@eg/core/idl.service';
   4 import {NetService} from '@eg/core/net.service';
   5 import {PcrudService} from '@eg/core/pcrud.service';
   6
   7 export class CourseService {
   8
   9     constructor(
  10         private auth: AuthService,
  11         private evt: EventService,
  12         private idl: IdlService,
  13         private net: NetService,
  14         private pcrud: PcrudService
  15     ) {}
  16
  17     disassociateMaterials(courses) {
  18         return new Promise((resolve, reject) => {
  19             let course_ids = [];
  20             let course_library_hash = {};
  21             courses.forEach(course => {
  22                 course_ids.push(course.id());
  23                 course_library_hash[course.id()] = course.owning_lib();
  24             });
  25             this.pcrud.search('acmcm', {course: course_ids}).subscribe(material => {
  26                 material.isdeleted(true);
  27                 this.resetItemFields(material, course_library_hash[material.course()]);
  28                 this.pcrud.autoApply(material).subscribe(res => {
  29                     console.log(res);
  30                 }, err => {
  31                     reject(err);
  32                 }, () => {
  33                     resolve(material);
  34                 });
  35             }, err => {
  36                 reject(err)
  37             }, () => {
  38                 resolve(courses);
  39             });
  40         });
  41     }
  42
  43     resetItemFields(material, course_lib) {
  44         this.pcrud.retrieve('acp', material.item(),
  45             {flesh: 3, flesh_fields: {acp: ['call_number']}}).subscribe(copy => {
  46             if (material.original_status()) {
  47                 copy.status(material.original_status());
  48             }
  49             if (copy.circ_modifier() != material.original_circ_modifier()) {
  50                 copy.circ_modifier(material.original_circ_modifier());
  51             }
  52             if (material.original_location()) {
  53                 copy.location(material.original_location());
  54             }
  55             if (material.original_callnumber()) {
  56                 this.pcrud.retrieve('acn', material.original_callnumber()).subscribe(cn => {
  57                     this.updateItem(copy, course_lib, cn.label(), true);
  58                 });
  59             } else {
  60                 this.updateItem(copy, course_lib, copy.call_number().label(), false);
  61             }
  62         });
  63     }
  64
  65     updateItem(item: IdlObject, course_lib, call_number, updatingVolume) {
  66         return new Promise((resolve, reject) => {
  67             this.pcrud.update(item).subscribe(item_id => {
  68                 if (updatingVolume) {
  69                     let cn = item.call_number();
  70                     return this.net.request(
  71                         'open-ils.cat', 'open-ils.cat.call_number.find_or_create',
  72                         this.auth.token(), call_number, cn.record(),
  73                         course_lib, cn.prefix(), cn.suffix(),
  74                         cn.label_class()
  75                     ).subscribe(res => {
  76                         let event = this.evt.parse(res);
  77                         if (event) return;
  78                         return this.net.request(
  79                             'open-ils.cat', 'open-ils.cat.transfer_copies_to_volume',
  80                             this.auth.token(), res.acn_id, [item.id()]
  81                         ).subscribe(transfered_res => {
  82                             console.debug("Copy transferred to volume with code " + transfered_res);
  83                         }, err => {
  84                             reject(err);
  85                         }, () => {
  86                             resolve(item);
  87                         });
  88                     }, err => {
  89                         reject(err);
  90                     }, () => {
  91                         resolve(item);
  92                     });
  93                 } else {
  94                     return this.pcrud.update(item);
  95                 }
  96             });
  97         });
  98     }
  99
 100 }