X-Git-Url: https://git.arvados.org/arvados-workbench2.git/blobdiff_plain/085aaccee3eea289a443f227cdd856c2761940ca..311448f71e5a5cc1ffcfe6d5b7c5214fa196f1b1:/src/services/favorite-service/favorite-service.ts

diff --git a/src/services/favorite-service/favorite-service.ts b/src/services/favorite-service/favorite-service.ts
index 1b902b07..8b66455b 100644
--- a/src/services/favorite-service/favorite-service.ts
+++ b/src/services/favorite-service/favorite-service.ts
@@ -2,67 +2,87 @@
 //
 // SPDX-License-Identifier: AGPL-3.0
 
-import LinkService from "../link-service/link-service";
-import GroupsService, { GroupContentsResource } from "../groups-service/groups-service";
-import { LinkResource, LinkClass } from "../../models/link";
-import FilterBuilder from "../../common/api/filter-builder";
-import { ListArguments, ListResults } from "../../common/api/common-resource-service";
-import OrderBuilder from "../../common/api/order-builder";
+import { LinkService } from "../link-service/link-service";
+import { GroupsService, GroupContentsResource } from "../groups-service/groups-service";
+import { LinkClass } from "models/link";
+import { FilterBuilder, joinFilters } from "services/api/filter-builder";
+import { ListResults } from 'services/common-service/common-service';
 
-export interface FavoriteListArguments extends ListArguments {
-    filters?: FilterBuilder<LinkResource>;
-    order?: OrderBuilder<LinkResource>;
+export interface FavoriteListArguments {
+    limit?: number;
+    offset?: number;
+    filters?: string;
+    linkOrder?: string;
+    contentOrder?: string;
 }
-export default class FavoriteService {
+
+export class FavoriteService {
     constructor(
         private linkService: LinkService,
-        private groupsService: GroupsService
+        private groupsService: GroupsService,
     ) { }
 
-    create(data: { userUuid: string; resourceUuid: string; }) {
+    create(data: { userUuid: string; resource: { uuid: string; name: string } }) {
         return this.linkService.create({
             ownerUuid: data.userUuid,
             tailUuid: data.userUuid,
-            headUuid: data.resourceUuid,
+            headUuid: data.resource.uuid,
             linkClass: LinkClass.STAR,
-            name: data.resourceUuid
+            name: data.resource.name
         });
     }
 
     delete(data: { userUuid: string; resourceUuid: string; }) {
         return this.linkService
             .list({
-                filters: FilterBuilder
-                    .create<LinkResource>()
-                    .addEqual('tailUuid', data.userUuid)
-                    .addEqual('headUuid', data.resourceUuid)
-                    .addEqual('linkClass', LinkClass.STAR)
+                filters: new FilterBuilder()
+                    .addEqual('owner_uuid', data.userUuid)
+                    .addEqual('head_uuid', data.resourceUuid)
+                    .addEqual('link_class', LinkClass.STAR)
+                    .getFilters()
             })
             .then(results => Promise.all(
                 results.items.map(item => this.linkService.delete(item.uuid))));
     }
 
-    list(userUuid: string, args: FavoriteListArguments = {}): Promise<ListResults<GroupContentsResource>> {
-        const listFilter = FilterBuilder
-            .create<LinkResource>()
-            .addEqual('tailUuid', userUuid)
-            .addEqual('linkClass', LinkClass.STAR);
+    list(userUuid: string, { filters, limit, offset, linkOrder, contentOrder }: FavoriteListArguments = {}, showOnlyOwned: boolean = true): Promise<ListResults<GroupContentsResource>> {
+        const listFilters = new FilterBuilder()
+            .addEqual('owner_uuid', userUuid)
+            .addEqual('link_class', LinkClass.STAR)
+            .getFilters();
 
         return this.linkService
             .list({
-                ...args,
-                filters: args.filters ? args.filters.concat(listFilter) : listFilter
+                filters: joinFilters(filters || '', listFilters),
+                limit,
+                offset,
+                order: linkOrder
             })
             .then(results => {
                 const uuids = results.items.map(item => item.headUuid);
-                return this.groupsService.contents(userUuid, {
-                    limit: args.limit,
-                    offset: args.offset,
-                    filters: FilterBuilder.create<GroupContentsResource>().addIn('uuid', uuids),
+                return this.groupsService.contents(showOnlyOwned ? userUuid : '', {
+                    limit,
+                    offset,
+                    order: contentOrder,
+                    filters: new FilterBuilder().addIn('uuid', uuids).getFilters(),
                     recursive: true
                 });
             });
     }
 
+    checkPresenceInFavorites(userUuid: string, resourceUuids: string[]): Promise<Record<string, boolean>> {
+        return this.linkService
+            .list({
+                filters: new FilterBuilder()
+                    .addIn("head_uuid", resourceUuids)
+                    .addEqual("owner_uuid", userUuid)
+                    .addEqual("link_class", LinkClass.STAR)
+                    .getFilters()
+            })
+            .then(({ items }) => resourceUuids.reduce((results, uuid) => {
+                const isFavorite = items.some(item => item.headUuid === uuid);
+                return { ...results, [uuid]: isFavorite };
+            }, {}));
+    }
 
-}
\ No newline at end of file
+}