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     getUsers(course_ids?: Number[]): Promise<IdlObject[]> {
  49         if (!course_ids) {
  50             return this.pcrud.retrieveAll('acmcu',
  51                 {}, {atomic: true}).toPromise();
  52         } else {
  53             return this.pcrud.search('acmcu', {course: course_ids},
  54                 {}, {atomic: true}).toPromise();
  55         }
  56     }
  57
  58     fleshMaterial(material): Promise<any> {
  59         console.log(material)
  60         return new Promise((resolve, reject) => {
  61             let item = this.idl.create('acp');
  62             this.net.request(
  63                 'open-ils.circ',
  64                 'open-ils.circ.copy_details.retrieve',
  65                 this.auth.token(), material.item()
  66             ).subscribe(res => {
  67                 if (res && res.copy) {
  68                     item = res.copy;
  69                     item.call_number(res.volume);
  70                     item._title = res.mvr.title();
  71                     item.circ_lib(this.org.get(item.circ_lib()));
  72                     item._id = material.id();
  73                     if (material.relationship())
  74                         item._relationship = material.relationship();
  75                 }
  76             }, err => {
  77                 reject(err);
  78             }, () => resolve(item));
  79         });
  80     }
  81
  82     fleshUser(course_user): Promise<any> {
  83         return new Promise((resolve, reject) => {
  84             let user = this.idl.create('au');
  85             this.net.request(
  86                 'open-ils.actor',
  87                 'open-ils.actor.user.fleshed.retrieve',
  88                 this.auth.token(), course_user.usr()
  89             ).subscribe(patron => {
  90                 user = patron;
  91                 user._id = course_user.id();
  92                 if (course_user.usr_role()) user._role = course_user.usr_role();
  93                 if (course_user.is_public()) user._is_public = course_user.is_public();
  94             }, err => {
  95                 reject(err);
  96             }, () => resolve(user));
  97         });
  98     }
  99
 100     getCoursesFromMaterial(copy_id): Promise<any> {
 101         let id_list = [];
 102         return new Promise((resolve, reject) => {
 103
 104             return this.pcrud.search('acmcm', {item: copy_id})
 105             .subscribe(materials => {
 106                 if (materials) {
 107                     id_list.push(materials.course());
 108                 }
 109             }, err => {
 110                 console.debug(err);
 111                 reject(err);
 112             }, () => {
 113                 if (id_list.length) {
 114                     return this.getCourses(id_list).then(courses => {
 115                         resolve(courses);
 116                     });
 117
 118                 }
 119             });
 120         });
 121     }
 122
 123     fetchCopiesInCourseFromRecord(record_id) {
 124         let cp_list = [];
 125         let course_list = [];
 126         return new Promise((resolve, reject) => {
 127             this.net.request(
 128                 'open-ils.cat',
 129                 'open-ils.cat.asset.copy_tree.global.retrieve',
 130                 this.auth.token(), record_id
 131             ).subscribe(copy_tree => {
 132                 copy_tree.forEach(cn => {
 133                     cn.copies().forEach(cp => {
 134                         cp_list.push(cp.id());
 135                     });
 136                 });
 137             }, err => reject(err),
 138             () => {
 139                 resolve(this.getCoursesFromMaterial(cp_list));
 140             });
 141         });
 142     }
 143
 144     // Creating a new acmcm Entry
 145     associateMaterials(item, args) {
 146         let material = this.idl.create('acmcm');
 147         material.item(item.id());
 148         if (item.call_number() && item.call_number().record()) {
 149             material.record(item.call_number().record());
 150         }
 151         material.course(args.currentCourse.id());
 152         if (args.relationship) material.relationship(args.relationship);
 153
 154         // Apply temporary fields to the item
 155         if (args.isModifyingStatus && args.tempStatus) {
 156             material.original_status(item.status());
 157             item.status(args.tempStatus);
 158         }
 159         if (args.isModifyingLocation && args.tempLocation) {
 160             material.original_location(item.location());
 161             item.location(args.tempLocation);
 162         }
 163         if (args.isModifyingCircMod) {
 164             material.original_circ_modifier(item.circ_modifier());
 165             item.circ_modifier(args.tempCircMod);
 166             if (!args.tempCircMod) item.circ_modifier(null);
 167         }
 168         if (args.isModifyingCallNumber) {
 169             material.original_callnumber(item.call_number());
 170         }
 171         let response = {
 172             item: item,
 173             material: this.pcrud.create(material).toPromise()
 174         };
 175
 176         return response;
 177     }
 178
 179     associateUsers(patron_id, args) {
 180         let new_user = this.idl.create('acmcu');
 181         if (args.is_public) new_user.is_public(args.is_public);
 182         if (args.role) new_user.usr_role(args.role);
 183         new_user.course(args.currentCourse.id());
 184         new_user.usr(patron_id);
 185         return this.pcrud.create(new_user).toPromise()
 186     }
 187
 188     disassociateMaterials(courses) {
 189         return new Promise((resolve, reject) => {
 190             let course_ids = [];
 191             let course_library_hash = {};
 192             courses.forEach(course => {
 193                 course_ids.push(course.id());
 194                 course_library_hash[course.id()] = course.owning_lib();
 195             });
 196             this.pcrud.search('acmcm', {course: course_ids}).subscribe(material => {
 197                 material.isdeleted(true);
 198                 this.resetItemFields(material, course_library_hash[material.course()]);
 199                 this.pcrud.autoApply(material).subscribe(res => {
 200                 }, err => {
 201                     reject(err);
 202                 }, () => {
 203                     resolve(material);
 204                 });
 205             }, err => {
 206                 reject(err)
 207             }, () => {
 208                 resolve(courses);
 209             });
 210         });
 211     }
 212
 213     disassociateUsers(user) {
 214         return new Promise((resolve, reject) => {
 215             let user_ids = [];
 216             let course_library_hash = {};
 217             user.forEach(course => {
 218                 user_ids.push(course.id());
 219                 course_library_hash[course.id()] = course.owning_lib();
 220             });
 221             this.pcrud.search('acmcu', {user: user_ids}).subscribe(user => {
 222                 user.course(user_ids);
 223                 this.pcrud.autoApply(user).subscribe(res => {
 224                     console.debug(res);
 225                 }, err => {
 226                     reject(err);
 227                 }, () => {
 228                     resolve(user);
 229                 });
 230             }, err => {
 231                 reject(err)
 232             }, () => {
 233                 resolve(user_ids);
 234             });
 235         });
 236     }
 237
 238     resetItemFields(material, course_lib) {
 239         this.pcrud.retrieve('acp', material.item(),
 240             {flesh: 3, flesh_fields: {acp: ['call_number']}}).subscribe(copy => {
 241             if (material.original_status()) {
 242                 copy.status(material.original_status());
 243             }
 244             if (copy.circ_modifier() != material.original_circ_modifier()) {
 245                 copy.circ_modifier(material.original_circ_modifier());
 246             }
 247             if (material.original_location()) {
 248                 copy.location(material.original_location());
 249             }
 250             if (material.original_callnumber()) {
 251                 this.pcrud.retrieve('acn', material.original_callnumber()).subscribe(cn => {
 252                     this.updateItem(copy, course_lib, cn.label(), true);
 253                 });
 254             } else {
 255                 this.updateItem(copy, course_lib, copy.call_number().label(), false);
 256             }
 257         });
 258     }
 259
 260     updateItem(item: IdlObject, course_lib, call_number, updatingVolume) {
 261         return new Promise((resolve, reject) => {
 262             this.pcrud.update(item).subscribe(item_id => {
 263                 if (updatingVolume) {
 264                     let cn = item.call_number();
 265                     return this.net.request(
 266                         'open-ils.cat', 'open-ils.cat.call_number.find_or_create',
 267                         this.auth.token(), call_number, cn.record(),
 268                         course_lib, cn.prefix(), cn.suffix(),
 269                         cn.label_class()
 270                     ).subscribe(res => {
 271                         let event = this.evt.parse(res);
 272                         if (event) return;
 273                         return this.net.request(
 274                             'open-ils.cat', 'open-ils.cat.transfer_copies_to_volume',
 275                             this.auth.token(), res.acn_id, [item.id()]
 276                         ).subscribe(transfered_res => {
 277                             console.debug("Copy transferred to volume with code " + transfered_res);
 278                         }, err => {
 279                             reject(err);
 280                         }, () => {
 281                             resolve(item);
 282                         });
 283                     }, err => {
 284                         reject(err);
 285                     }, () => {
 286                         resolve(item);
 287                     });
 288                 } else {
 289                     this.pcrud.update(item).subscribe(rse => {
 290                         resolve(item);
 291                     }, err => {
 292                         reject(item);
 293                     });
 294                 }
 295             });
 296         });
 297     }
 298
 299 }