Replicate labels/tags with resources (fixes #2718) (#2728)

Author: paulbert

src/app/configuration/configuration.service.ts

@@ -77,6 +77,8 @@ export class ConfigurationService {
       // create replicator for pulling from parent at first as we do not have session
       this.syncService.sync({ ...replicatorObj, db: 'courses' }, credentials),
       this.syncService.sync({ ...replicatorObj, db: 'resources' }, credentials),
+      this.syncService.sync({ ...replicatorObj, db: 'exams' }, credentials),
+      this.syncService.sync({ ...replicatorObj, db: 'tags' }, credentials),
       this.syncService.sync(userReplicator, credentials)
     ]);
   }

src/app/manager-dashboard/manager-dashboard.component.ts

@@ -198,8 +198,13 @@ export class ManagerDashboardComponent implements OnInit, OnDestroy {
       const removedItems = previousList.filter(item => selected.findIndex(i => i._id === item.id) < 0)
         .map(item => ({ ...item, sendOnAccept: false }));
       const dataUpdate = selected.map(item => ({ ...item, sendOnAccept: true })).concat(removedItems);
-      if (db === 'courses') {
-        this.handleCourseAttachments(selected, previousList);
+      switch (db) {
+        case 'courses':
+          this.handleCourseAttachments(selected, previousList);
+          break;
+        case 'resources':
+          this.handleResourceAttachments(selected);
+          break;
       }
       this.couchService.post(db + '/_bulk_docs', { docs: dataUpdate }).subscribe(res => {
         this.planetMessageService.showMessage('Send on accept list updated');
@@ -216,6 +221,15 @@ export class ManagerDashboardComponent implements OnInit, OnDestroy {
     this.sendOnAcceptOkClick('exams', previousExams)(exams);
   }
 
+  handleResourceAttachments(resources) {
+    const tagIds = [].concat.apply([], resources.map((resource: any) => resource.tags || []));
+    if (tagIds.length > 0) {
+      this.couchService.findAll('tags', findDocuments({ '_id': { '$in': tagIds } })).subscribe((tags) => {
+        this.sendOnAcceptOkClick('tags', [])(tags);
+      });
+    }
+  }
+
   resetPin() {
     const userName = 'org.couchdb.user:satellite';
     this.couchService.get('_users/' + userName)

src/app/manager-dashboard/manager-fetch.component.ts

@@ -76,7 +76,7 @@ export class ManagerFetchComponent implements OnInit, AfterViewInit {
 
   getPushedItem() {
     const itemsToPull = this.selection.selected.map(id => findByIdInArray(this.pushedItems.data, id));
-    const replicators = this.createRepicatorsArray(itemsToPull, []);
+    const replicators = this.syncService.createRepicatorsArray(itemsToPull, 'pull', []);
     const deleteItems = itemsToPull.map(sentItem => ({ _id: sentItem._id, _rev: sentItem._rev, _deleted: true }));
     if (replicators.length > 0) {
       this.syncService.confirmPasswordAndRunReplicators(replicators).pipe(
@@ -87,31 +87,4 @@ export class ManagerFetchComponent implements OnInit, AfterViewInit {
     }
   }
 
-  createRepicatorsArray(itemsToPull, replicators = []) {
-    return itemsToPull.reduce((newReplicators: any[], item: any) => {
-      const pullItem = item.item;
-      let pullObject = newReplicators.find((replicator: any) => replicator.db === item.db);
-      if (!pullObject) {
-        pullObject = { db: item.db, type: 'pull', date: true, items: [ pullItem ] };
-        newReplicators.push(pullObject);
-      } else {
-        pullObject.items.push(pullItem);
-      }
-      if (item.db === 'courses') {
-        return this.coursesItemsToPull(pullItem, newReplicators);
-      }
-      return newReplicators;
-    }, replicators);
-  }
-
-  coursesItemsToPull(course, replicators) {
-    return this.createRepicatorsArray(
-      [].concat.apply([], course.steps.map(step =>
-        step.resources.map(r => ({ item: r, db: 'resources' }))
-        .concat(step.exam ? [ { item: step.exam, db: 'exams' } ] : []))
-      ),
-      replicators
-    );
-  }
-
 }

src/app/resources/resources.component.ts

@@ -247,8 +247,8 @@ export class ResourcesComponent implements OnInit, AfterViewInit, OnDestroy {
 
   shareResource(type, resources) {
     const msg = (type === 'pull' ? 'fetch' : 'send'),
-      items = resources.map(id => this.resources.data.find((resource: any) => resource._id === id));
-    this.syncService.confirmPasswordAndRunReplicators([ { db: this.dbName, items, type: type, date: true } ])
+      items = resources.map(id => ({ item: this.resources.data.find((resource: any) => resource._id === id), db: this.dbName }));
+    this.syncService.confirmPasswordAndRunReplicators(this.syncService.createRepicatorsArray(items, type) )
     .subscribe((response: any) => {
       this.planetMessageService.showMessage(resources.length + ' ' + this.dbName + ' ' + 'queued to ' + msg);
     }, () => error => this.planetMessageService.showMessage(error));

src/app/shared/sync.service.ts

@@ -73,4 +73,44 @@ export class SyncService {
     };
   }
 
+  createRepicatorsArray(items, type: 'pull' | 'push', replicators = []) {
+    return items.reduce((newReplicators: any[], item: any) => {
+      const doc = item.item;
+      let syncObject = newReplicators.find((replicator: any) => replicator.db === item.db);
+      if (!syncObject) {
+        syncObject = { db: item.db, type, date: true, items: [ doc ] };
+        newReplicators.push(syncObject);
+      } else {
+        syncObject.items.push(doc);
+      }
+      switch (item.db) {
+        case 'courses':
+          return this.coursesItemsToSync(doc, type, newReplicators);
+        case 'resources':
+          return this.resourcesItemsToSync(doc, type, newReplicators);
+        default:
+          return newReplicators;
+      }
+    }, replicators);
+  }
+
+  coursesItemsToSync(course, type, replicators) {
+    return this.createRepicatorsArray(
+      [].concat.apply([], course.steps.map(step =>
+        step.resources.map(r => ({ item: r, db: 'resources' }))
+        .concat(step.exam ? [ { item: step.exam, db: 'exams' } ] : []))
+      ),
+      type,
+      replicators
+    );
+  }
+
+  resourcesItemsToSync(resource, type, replicators) {
+    return resource.tags === undefined ? replicators : this.createRepicatorsArray(
+      resource.tags.map(tag => ({ item: { _id: tag }, db: 'tags' })),
+      type,
+      replicators
+    );
+  }
+
 }