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

   1 import {Injectable} from '@angular/core';
   2 import {AuthService} from '@eg/core/auth.service';
   3 import {EventService} from '@eg/core/event.service';
   4 import {IdlObject, IdlService} from '@eg/core/idl.service';
   5 import {NetService} from '@eg/core/net.service';
   6 import {OrgService} from '@eg/core/org.service';
   7 import {PcrudService} from '@eg/core/pcrud.service';
   8
   9 @Injectable()
  10 export class CourseService {
  11
  12     constructor(
  13         private auth: AuthService,
  14         private evt: EventService,
  15         private idl: IdlService,
  16         private net: NetService,
  17         private org: OrgService,
  18         private pcrud: PcrudService
  19     ) {}
  20
  21     isOptedIn(): Promise<any> {
  22         return new Promise((resolve, reject) => {
  23             this.org.settings('circ.course_materials_opt_in').then(res => {
  24                 resolve(res['circ.course_materials_opt_in']);
  25             });
  26         });
  27     }
  28     getCourses(course_ids?: Number[]): Promise<IdlObject[]> {
  29         if (!course_ids) {
  30             return this.pcrud.retrieveAll('acmc',
  31                 {}, {atomic: true}).toPromise();
  32         } else {
  33             return this.pcrud.search('acmc', {id: course_ids},
  34                 {}, {atomic: true}).toPromise();
  35         }
  36     }
  37
  38     getMaterials(course_ids?: Number[]): Promise<IdlObject[]> {
  39         if (!course_ids) {
  40             return this.pcrud.retrieveAll('acmcm',
  41                 {}, {atomic: true}).toPromise();
  42         } else {
  43             return this.pcrud.search('acmcm', {course: course_ids},
  44                 {}, {atomic: true}).toPromise();
  45         }
  46     }
  47
  48     fleshMaterial(itemId, relationship?): Promise<any> {
  49         return new Promise((resolve, reject) => {
  50             let item = this.idl.create('acp');
  51             this.net.request(
  52                 'open-ils.circ',
  53                 'open-ils.circ.copy_details.retrieve',
  54                 this.auth.token(), itemId
  55             ).subscribe(res => {
  56                 if (res && res.copy) {
  57                     item = res.copy;
  58                     item.call_number(res.volume);
  59                     item._title = res.mvr.title();
  60                     item.circ_lib(this.org.get(item.circ_lib()));
  61                     if (relationship) item._relationship = relationship;
  62                 }
  63             }, err => {
  64                 reject(err);
  65             }, () => resolve(item));
  66         });
  67     }
  68
  69     getCoursesFromMaterial(copy_id): Promise<any> {
  70         let id_list = [];
  71         return new Promise((resolve, reject) => {
  72
  73             return this.pcrud.search('acmcm', {item: copy_id})
  74             .subscribe(materials => {
  75                 if (materials) {
  76                     id_list.push(materials.course());
  77                 }
  78             }, err => {
  79                 console.debug(err);
  80                 reject(err);
  81             }, () => {
  82                 if (id_list.length) {
  83                     return this.getCourses(id_list).then(courses => {
  84                         resolve(courses);
  85                     });
  86
  87                 }
  88             });
  89         });
  90     }
  91
  92     fetchCopiesInCourseFromRecord(record_id) {
  93         let cp_list = [];
  94         let course_list = [];
  95         return new Promise((resolve, reject) => {
  96             this.net.request(
  97                 'open-ils.cat',
  98                 'open-ils.cat.asset.copy_tree.global.retrieve',
  99                 this.auth.token(), record_id
 100             ).subscribe(copy_tree => {
 101                 copy_tree.forEach(cn => {
 102                     cn.copies().forEach(cp => {
 103                         cp_list.push(cp.id());
 104                     });
 105                 });
 106             }, err => reject(err),
 107             () => {
 108                 resolve(this.getCoursesFromMaterial(cp_list));
 109             });
 110         });
 111     }
 112
 113     // Creating a new acmcm Entry
 114     associateMaterials(item, args) {
 115         let material = this.idl.create('acmcm');
 116         material.item(item.id());
 117         if (item.call_number() && item.call_number().record()) {
 118             material.record(item.call_number().record());
 119         }
 120         material.course(args.currentCourse.id());
 121         if (args.relationship) material.relationship(args.relationship);
 122
 123         // Apply temporary fields to the item
 124         if (args.isModifyingStatus && args.tempStatus) {
 125             material.original_status(item.status());
 126             item.status(args.tempStatus);
 127         }
 128         if (args.isModifyingLocation && args.tempLocation) {
 129             material.original_location(item.location());
 130             item.location(args.tempLocation);
 131         }
 132         if (args.isModifyingCircMod) {
 133             material.original_circ_modifier(item.circ_modifier());
 134             item.circ_modifier(args.tempCircMod);
 135             if (!args.tempCircMod) item.circ_modifier(null);
 136         }
 137         if (args.isModifyingCallNumber) {
 138             material.original_callnumber(item.call_number());
 139         }
 140         let response = {
 141             item: item,
 142             material: this.pcrud.create(material).toPromise()
 143         };
 144
 145         return response;
 146     }
 147
 148     disassociateMaterials(courses) {
 149         return new Promise((resolve, reject) => {
 150             let course_ids = [];
 151             let course_library_hash = {};
 152             courses.forEach(course => {
 153                 course_ids.push(course.id());
 154                 course_library_hash[course.id()] = course.owning_lib();
 155             });
 156             this.pcrud.search('acmcm', {course: course_ids}).subscribe(material => {
 157                 material.isdeleted(true);
 158                 this.resetItemFields(material, course_library_hash[material.course()]);
 159                 this.pcrud.autoApply(material).subscribe(res => {
 160                 }, err => {
 161                     reject(err);
 162                 }, () => {
 163                     resolve(material);
 164                 });
 165             }, err => {
 166                 reject(err)
 167             }, () => {
 168                 resolve(courses);
 169             });
 170         });
 171     }
 172
 173     disassociateUsers(user) {
 174         return new Promise((resolve, reject) => {
 175             let user_ids = [];
 176             let course_library_hash = {};
 177             user.forEach(course => {
 178                 user_ids.push(course.id());
 179                 course_library_hash[course.id()] = course.owning_lib();
 180             });
 181             this.pcrud.search('acmcu', {user: user_ids}).subscribe(user => {
 182                 user.course(user_ids);
 183                 this.pcrud.autoApply(user).subscribe(res => {
 184                     console.log(res);
 185                 }, err => {
 186                     reject(err);
 187                 }, () => {
 188                     resolve(user);
 189                 });
 190             }, err => {
 191                 reject(err)
 192             }, () => {
 193                 resolve(user_ids);
 194             });
 195         });
 196     }
 197
 198     resetItemFields(material, course_lib) {
 199         this.pcrud.retrieve('acp', material.item(),
 200             {flesh: 3, flesh_fields: {acp: ['call_number']}}).subscribe(copy => {
 201             if (material.original_status()) {
 202                 copy.status(material.original_status());
 203             }
 204             if (copy.circ_modifier() != material.original_circ_modifier()) {
 205                 copy.circ_modifier(material.original_circ_modifier());
 206             }
 207             if (material.original_location()) {
 208                 copy.location(material.original_location());
 209             }
 210             if (material.original_callnumber()) {
 211                 this.pcrud.retrieve('acn', material.original_callnumber()).subscribe(cn => {
 212                     this.updateItem(copy, course_lib, cn.label(), true);
 213                 });
 214             } else {
 215                 this.updateItem(copy, course_lib, copy.call_number().label(), false);
 216             }
 217         });
 218     }
 219
 220     updateItem(item: IdlObject, course_lib, call_number, updatingVolume) {
 221         return new Promise((resolve, reject) => {
 222             this.pcrud.update(item).subscribe(item_id => {
 223                 if (updatingVolume) {
 224                     let cn = item.call_number();
 225                     return this.net.request(
 226                         'open-ils.cat', 'open-ils.cat.call_number.find_or_create',
 227                         this.auth.token(), call_number, cn.record(),
 228                         course_lib, cn.prefix(), cn.suffix(),
 229                         cn.label_class()
 230                     ).subscribe(res => {
 231                         let event = this.evt.parse(res);
 232                         if (event) return;
 233                         return this.net.request(
 234                             'open-ils.cat', 'open-ils.cat.transfer_copies_to_volume',
 235                             this.auth.token(), res.acn_id, [item.id()]
 236                         ).subscribe(transfered_res => {
 237                             console.debug("Copy transferred to volume with code " + transfered_res);
 238                         }, err => {
 239                             reject(err);
 240                         }, () => {
 241                             resolve(item);
 242                         });
 243                     }, err => {
 244                         reject(err);
 245                     }, () => {
 246                         resolve(item);
 247                     });
 248                 } else {
 249                     this.pcrud.update(item).subscribe(rse => {
 250                         resolve(item);
 251                     }, err => {
 252                         reject(item);
 253                     });
 254                 }
 255             });
 256         });
 257     }
 258
 259 }