aswi2023one-team-to-rule-them-all-gitlab/src/stores/actions/itemThunks.ts @ 2135f53d

import { createAsyncThunk } from "@reduxjs/toolkit"
import { getItemRequest } from "../../api/itemservice"
import { getItemNotesRequest } from "../../api/notesservice"
import { Certainty, Concordance, Item } from "../../types/item";


export const getItem = createAsyncThunk(
    "item/getItem",
    async (itemId: string) => {
        try {
            console.log("GET item/getItem/" + itemId);

            const response = await getItemRequest(itemId);
        
            // data with image
            if (response.status === 200 && response.data.object.length > 1) {
                const authorName = response.data.object[1]?.name?.[0]?.getty_data?.display_name || null;
                const imageUrl = response.data.object[1]?.images?.[0]?.file || null;
                const title = response.data.object[1]?.images?.[0]?.text || null;
                const institution = {
                    name: response.data.object[1]?.institution || null,
                    inventoryNumber: response.data.object[1]?.id_number || null,
                    country: response.data.object[1]?.country || null,
                    city: response.data.object[1]?.city || null
                };
                const repository = response.data.object[1]?.repository || null;
                const provenance = response.data.object[1]?.provenance || null;
                const description = response.data.object[1]?.physical_description || null;
                
                return {
                    id: itemId,
                    fullView: true,
                    concordances: response.data.concordances ?
                         [{id: itemId, cert: response.data.object[1]?.cert || Certainty.Unknown}].concat(response.data.concordances)
                         :
                         [{id: itemId, cert: response.data.object[1]?.cert || Certainty.Unknown}],
                    authorDisplayName: response.data.object[0]?.name?.[0]?.getty_data?.display_name || null,
                    workName: response.data.object[0]?.caption || null,
                    inventoryItem: response.data.text || null,
                    searchSubjects: response.data.search_subject || null,
                    authorName,
                    imageUrl,
                    title,
                    institution,
                    repository,
                    provenance,
                    description
                }
            }
            // data without image
            else if (response.status === 200 && response.data.object.length == 1) {
                return {
                    id: itemId,
                    fullView: false,
                    concordances: response.data.concordances ?
                    [{id: itemId, cert: response.data.object[1]?.cert || Certainty.Unknown}].concat(response.data.concordances)
                    :
                    [{id: itemId, cert: response.data.object[1]?.cert || Certainty.Unknown}],
                    authorDisplayName: response.data.object[0]?.name?.[0]?.getty_data?.display_name || null,
                    workName: response.data.object[0]?.caption || null,
                    inventoryItem: response.data.text || null,
                    searchSubjects: response.data.search_subject || null,
                }
            }
            else {
                console.log("Error " + response.data);
                return Promise.reject(response.data ? response.data : "Error")
            }
        } catch (err: any) {
            
            console.log(err);
            return Promise.reject(err.response.data)
        }
    }
)

  export const setConcordances = (concordances: Concordance[]) => {
    return {
      type: "item/setConcordances",
      payload: {
        concordances,
      },
    };
  };

// export const getItemConcordances = createAsyncThunk(
//     "item/getItemConcordances",
//     async (itemId : string) => {
//         try {
//             const response = await getItemConcordancesRequest(itemId)
//             console.log(response)
//             if (response.status === 200) {
//                 return {
//                     // TODO set item concordances
//                 }
//             } else {
//                 return Promise.reject(response.data ? response.data : "Error")
//             }
//         } catch (err: any) {
//             return Promise.reject(err.response.data)
//         }
//     }
// )

export const getItemNotes = createAsyncThunk(
    "item/getItemNotes",
    async ({item, relatedComments}: {item: Item, relatedComments: boolean}) => {
        try {
            console.log("GET notes/getNotes/" + item.id);

            const response = await getItemNotesRequest(item, relatedComments);

            if (response.status === 200) {
                if(response.data.length > 0){

                    let notes = [];
                    for(let i = 0; i < response.data.length; i++){
                        let note = response.data[i];
                        notes.push({
                            uuid: (note as any).uuid,
                            username: (note as any).created_by,
                            userId: (note as any).created_by_id,
                            note: (note as any).note,
                            avatarUrl: (note as any).avatar,
                            items: (note as any).items,
                            createdTime: (note as any).created, 
                            updatedTime: (note as any).updated,
                            noteColor: (note as any).note_color,
                            reply_to: (note as any).reply_to
                        })
                    }

                    return {
                        notes,
                    }
                }
                else{
                    // no notes for this item
                    return {
                        notes: [],
                    }
                }
            }
            else {
                return Promise.reject(response.data ? response.data : "Error")
            }
        } catch (err: any) {
            return Promise.reject(err.response.data)
        }
    }
)