@ludo.ninja/components 2.3.6 → 2.3.8

package/build/api/server-identities/mutations/useRemoveWallet/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("../../../../store/ui");
+const useRemoveWallet = ({ userId }) => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate, { error }] = api_1.identitySchema.useRemoveWalletMutation({
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        refetchQueries: [
+            {
+                query: api_1.identitySchema.FetchUserWalletsDocument,
+                fetchPolicy: 'no-cache',
+                context: {
+                    uri: api_1.hosts.identityHost,
+                },
+                variables: { userId },
+            },
+        ],
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    return { removeWallet, error };
+    function removeWallet({ blockchain, address, chainId, }) {
+        return mutate({
+            variables: { blockchain, address, chainId },
+        });
+    }
+};
+exports.default = useRemoveWallet;

package/build/api/server-identities/mutations/useRevokeToken/index.d.ts

@@ -0,0 +1,4 @@
+declare const useRevokeToken: () => {
+    revokeToken: () => Promise<void>;
+};
+export default useRevokeToken;

package/build/api/server-identities/mutations/useRevokeToken/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const useRevokeToken = () => {
+    const [mutate] = (0, client_1.useMutation)(api_1.authSchema.RevokeTokenDocument, {
+        context: {
+            uri: api_1.hosts.authHost,
+        },
+    });
+    return { revokeToken };
+    async function revokeToken() {
+        try {
+            await mutate();
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.default = useRevokeToken;

package/build/api/server-identities/mutations/useSaveEmailOfJoiner/index.d.ts

@@ -0,0 +1,7 @@
+import { identitySchema as schema } from '@ludo.ninja/api';
+declare const useSaveEmailOfJoiner: () => {
+    saveEmailOfJoiner: ({ email, isSubscribed, }: schema.IMutationSaveEmailOfJoinerArgs) => Promise<import("@apollo/client").FetchResult<schema.ISaveEmailOfJoinerMutation>>;
+    error: import("@apollo/client").ApolloError | undefined;
+    loading: boolean;
+};
+export default useSaveEmailOfJoiner;

package/build/api/server-identities/mutations/useSaveEmailOfJoiner/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("../../../../store/ui");
+const useSaveEmailOfJoiner = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate, { error, loading }] = api_1.identitySchema.useSaveEmailOfJoinerMutation({
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: () => {
+            openAlert({
+                ...data_1.alertSuccess,
+                caption: 'Success!',
+                text: 'You subscribed',
+            });
+        },
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    return { saveEmailOfJoiner, error, loading };
+    async function saveEmailOfJoiner({ email, isSubscribed, }) {
+        return mutate({
+            variables: { email, isSubscribed },
+        });
+    }
+};
+exports.default = useSaveEmailOfJoiner;

package/build/api/server-identities/mutations/useUnfollowProfile/index.d.ts

@@ -0,0 +1,7 @@
+declare const useUnfollowProfile: (followingUserId: string) => {
+    unfollowProfile: (options?: import("@apollo/client").MutationFunctionOptions<any, import("@apollo/client").OperationVariables, {
+        uri: string;
+    }, import("@apollo/client").ApolloCache<any>> | undefined) => Promise<import("@apollo/client").FetchResult<any>>;
+    isUnFollowedProfile: boolean;
+};
+export default useUnfollowProfile;

package/build/api/server-identities/mutations/useUnfollowProfile/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const ui_1 = require("../../../../store/ui");
+const UNFOLLOW_PROFILE_MUTATION = (0, client_1.gql) `
+  mutation UnfollowProfile($followingUserId: ID!) {
+    unfollowProfile(followingUserId: $followingUserId)
+  }
+`;
+const useUnfollowProfile = (followingUserId) => {
+    const [isUnFollowedProfile, setIsUnFollowed] = (0, react_1.useState)(false);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [unfollowProfile, {}] = (0, client_1.useMutation)(UNFOLLOW_PROFILE_MUTATION, {
+        variables: { followingUserId },
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: ({ unfollowProfile }) => {
+            setIsUnFollowed(unfollowProfile);
+            openAlert({
+                type: type_1.alertVariants.success,
+                caption: 'You successfully unsubscribed!',
+                text: '',
+            });
+        },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+            setIsUnFollowed(false);
+        },
+    });
+    return { unfollowProfile, isUnFollowedProfile };
+};
+exports.default = useUnfollowProfile;

package/build/api/server-identities/queries/useFetchProfile/index.d.ts

@@ -0,0 +1,16 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { identitySchema as schema } from '@ludo.ninja/api';
+import { ProfileEntity } from '@ludo.ninja/core';
+declare const prefetchProfile: ({ userId }: schema.IQueryFetchProfileArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchProfile: null;
+    };
+}>;
+declare const useFetchProfile: ({ userId }: schema.IQueryFetchProfileArgs, prefetchedProfile: ProfileEntity | null) => {
+    refetch: (variables?: Partial<import("@apollo/client").OperationVariables> | undefined) => Promise<import("@apollo/client").ApolloQueryResult<any>>;
+    data: any;
+    clientProfileData: ProfileEntity | null;
+    clientProfileLoading: boolean;
+    clientProfileError: import("@apollo/client").ApolloError | undefined;
+};
+export { prefetchProfile, useFetchProfile };

package/build/api/server-identities/queries/useFetchProfile/index.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchProfile = exports.prefetchProfile = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const core_1 = require("@ludo.ninja/core");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const store_1 = require("../../../../modules/user/store");
+const ui_1 = require("../../../../store/ui");
+const prefetchProfile = ({ userId }, apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.identitySchema.FetchProfileDocument,
+        variables: { userId },
+        context: { uri: api_1.hosts.serverIdentityHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchProfile: null },
+        };
+    });
+};
+exports.prefetchProfile = prefetchProfile;
+const useFetchProfile = ({ userId }, prefetchedProfile) => {
+    const [profile, setProfile] = (0, react_1.useState)(prefetchedProfile);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { profileData, isLoadingProfileData, user } = (0, store_1.useUserStore)((state) => ({
+        profileData: state.profileData,
+        isLoadingProfileData: state.isLoadingProfileData,
+        user: state.user,
+    }));
+    const [fetchProfile, { data, error, refetch }] = (0, client_1.useLazyQuery)(api_1.identitySchema.FetchProfileDocument, {
+        variables: { userId },
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: ({ fetchProfile }) => {
+            setProfile(new core_1.ProfileEntity({
+                ...fetchProfile,
+                wallets: fetchProfile.wallets.sort((wallet, nextWallet) => Number(nextWallet?.mainWallet) - Number(wallet?.mainWallet))
+            }));
+            setIsLoading(false);
+        },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+            setProfile(null);
+            setIsLoading(false);
+        },
+    });
+    (0, react_1.useEffect)(() => {
+        if (!prefetchedProfile) {
+            if (userId === user?.userId) {
+                if (!isLoadingProfileData && !profileData) {
+                    setProfile(null);
+                    setIsLoading(true);
+                    fetchProfile();
+                }
+                else {
+                    setProfile(profileData);
+                }
+            }
+            else {
+                setProfile(null);
+                setIsLoading(true);
+                fetchProfile();
+            }
+        }
+    }, [isLoadingProfileData, profileData, userId]);
+    return {
+        refetch,
+        data,
+        clientProfileData: profile,
+        clientProfileLoading: isLoading,
+        clientProfileError: error,
+    };
+};
+exports.useFetchProfile = useFetchProfile;

package/build/api/server-identities/queries/useFetchUserWallets/index.d.ts

@@ -0,0 +1,10 @@
+import { identitySchema as schema } from "@ludo.ninja/api";
+declare const useFetchUserWallets: ({ userId }: schema.IQueryFetchUserWalletsArgs) => {
+    refetch: (variables?: Partial<schema.Exact<{
+        userId: string;
+    }>> | undefined) => Promise<import("@apollo/client").ApolloQueryResult<schema.IFetchUserWalletsQuery>>;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    userWallets: schema.IWallet[];
+};
+export default useFetchUserWallets;

package/build/api/server-identities/queries/useFetchUserWallets/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@ludo.ninja/api");
+const react_1 = require("react");
+const useFetchUserWallets = ({ userId }) => {
+    const { loading, error, data, refetch } = api_1.identitySchema.useFetchUserWalletsQuery({
+        variables: { userId },
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+    });
+    const userWallets = (0, react_1.useMemo)(() => {
+        return (data?.fetchUserWallets
+            ?.slice()
+            .sort((wallet, nextWallet) => Number(nextWallet?.mainWallet) - Number(wallet?.mainWallet)) || null);
+    }, [data]);
+    return {
+        refetch,
+        loading,
+        error,
+        userWallets,
+    };
+};
+exports.default = useFetchUserWallets;

package/build/api/server-medias/mutations/useDeleteUserpic/index.d.ts

@@ -0,0 +1,6 @@
+declare const useDeleteUserpic: () => {
+    deleteUserpic: (options?: import("@apollo/client").MutationFunctionOptions<any, import("@apollo/client").OperationVariables, {
+        uri: string;
+    }, import("@apollo/client").ApolloCache<any>> | undefined) => Promise<import("@apollo/client").FetchResult<any>>;
+};
+export default useDeleteUserpic;

package/build/api/server-medias/mutations/useDeleteUserpic/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const DELETE_USERPIC_MUTATION = (0, client_1.gql) `
+  mutation DeleteUserpic {
+    deleteUserpic
+  }
+`;
+const useDeleteUserpic = () => {
+    const [deleteUserpic] = (0, client_1.useMutation)(DELETE_USERPIC_MUTATION, {
+        context: {
+            uri: api_1.hosts.mediasHost,
+        },
+        refetchQueries: [api_1.mediasSchema.FetchUserpicDocument],
+        // onError: (err) => console.log(err),
+    });
+    return { deleteUserpic };
+};
+exports.default = useDeleteUserpic;

package/build/api/server-medias/mutations/useUploadUserpic/index.d.ts

@@ -0,0 +1,4 @@
+declare const useUploadUserpic: () => {
+    uploadUserpic: (file: File) => Promise<import("@apollo/client").FetchResult<any>>;
+};
+export default useUploadUserpic;

package/build/api/server-medias/mutations/useUploadUserpic/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const UPLOAD_USERPIC_MUTATION = (0, client_1.gql) `
+  mutation UploadUserpic($file: Upload!) {
+    uploadUserpic(file: $file)
+  }
+`;
+const useUploadUserpic = () => {
+    const [mutate] = (0, client_1.useMutation)(UPLOAD_USERPIC_MUTATION, {
+        context: {
+            uri: api_1.hosts.mediasHost,
+        },
+        refetchQueries: [api_1.mediasSchema.FetchUserpicDocument],
+        // onError: (err) => {
+        //   throw new Error(err as string)
+        // },
+    });
+    return { uploadUserpic };
+    async function uploadUserpic(file) {
+        return await mutate({
+            variables: { file },
+        });
+    }
+};
+exports.default = useUploadUserpic;

package/build/api/server-medias/queries/useFetchUserPic/index.d.ts

@@ -0,0 +1,12 @@
+import { mediasSchema as schema } from '@ludo.ninja/api';
+declare const useFetchUserpic: () => {
+    data: schema.IFetchUserpicQuery | undefined;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    refetch: (variables?: Partial<schema.Exact<{
+        userId: string;
+    }>> | undefined) => Promise<import("@apollo/client").ApolloQueryResult<schema.IFetchUserpicQuery>>;
+    load: (userId: string) => void;
+    userPic: string | null;
+};
+export default useFetchUserpic;

package/build/api/server-medias/queries/useFetchUserPic/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const api_1 = require("@ludo.ninja/api");
+const env_1 = require("../../../../store/env");
+const useFetchUserpic = () => {
+    const getMediaENVDomain = (0, env_1.useEnvStore)((state) => state.getMediaDomain);
+    const [userPic, setUserPic] = (0, react_1.useState)(null);
+    const [fetchUserpic, { data, error, loading, refetch }] = api_1.mediasSchema.useFetchUserpicLazyQuery({
+        context: {
+            uri: api_1.hosts.mediasHost,
+        },
+        onCompleted: ({ fetchUserpic }) => {
+            if (fetchUserpic) {
+                setUserPic(`${getMediaENVDomain()}/userpics/${fetchUserpic}`);
+            }
+            else {
+                setUserPic(null);
+            }
+        },
+        onError: () => {
+            setUserPic(null);
+        },
+    });
+    function load(userId) {
+        fetchUserpic({
+            variables: { userId },
+        });
+    }
+    return {
+        data,
+        loading,
+        error,
+        refetch,
+        load,
+        userPic,
+    };
+};
+exports.default = useFetchUserpic;

package/build/api/server-opportunities/mutations/useCopyOpportunityShareLink/index.d.ts

@@ -0,0 +1,5 @@
+import { opportunitiesSchema as schema } from '@ludo.ninja/api';
+declare const useCopyOpportunityShareLink: () => {
+    copyOpportunityShareLinkAction: ({ opportunityId, }: schema.IMutationCopyOpportunityShareLinkArgs) => Promise<void>;
+};
+export default useCopyOpportunityShareLink;

package/build/api/server-opportunities/mutations/useCopyOpportunityShareLink/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@ludo.ninja/api");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const ui_1 = require("../../../../store/ui");
+const useCopyOpportunityShareLink = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = api_1.opportunitiesSchema.useCopyOpportunityShareLinkMutation({
+        context: {
+            uri: api_1.hosts.opportunitiesHost,
+        },
+        // onCompleted: () => {
+        // },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+        },
+    });
+    async function copyOpportunityShareLinkAction({ opportunityId, }) {
+        await mutate({
+            variables: { opportunityId },
+        });
+    }
+    return { copyOpportunityShareLinkAction };
+};
+exports.default = useCopyOpportunityShareLink;

package/build/api/server-opportunities/mutations/useDislikeOpportunity.d.ts

@@ -0,0 +1,4 @@
+import { opportunitiesSchema } from '@ludo.ninja/api';
+export declare const useDislikeOpportunity: () => {
+    dislikeOpportunityAction: ({ opportunityId, }: opportunitiesSchema.IMutationDislikeOpportunityArgs) => Promise<void>;
+};

package/build/api/server-opportunities/mutations/useDislikeOpportunity.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDislikeOpportunity = void 0;
+const api_1 = require("@ludo.ninja/api");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const ui_1 = require("../../../store/ui");
+const useDislikeOpportunity = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = api_1.opportunitiesSchema.useDislikeOpportunityMutation({
+        context: {
+            uri: api_1.hosts.opportunitiesHost,
+        },
+        // onCompleted: () => {
+        // },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+        },
+    });
+    async function dislikeOpportunityAction({ opportunityId, }) {
+        await mutate({
+            variables: { opportunityId },
+        });
+    }
+    return { dislikeOpportunityAction };
+};
+exports.useDislikeOpportunity = useDislikeOpportunity;

package/build/api/server-opportunities/mutations/useLikeOpportunity.d.ts

@@ -0,0 +1,4 @@
+import { opportunitiesSchema } from '@ludo.ninja/api';
+export declare const useLikeOpportunity: () => {
+    likeOpportunityAction: ({ opportunityId, }: opportunitiesSchema.IMutationLikeOpportunityArgs) => Promise<void>;
+};

package/build/api/server-opportunities/mutations/useLikeOpportunity.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLikeOpportunity = void 0;
+const api_1 = require("@ludo.ninja/api");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const ui_1 = require("../../../store/ui");
+const useLikeOpportunity = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = api_1.opportunitiesSchema.useLikeOpportunityMutation({
+        context: {
+            uri: api_1.hosts.opportunitiesHost,
+        },
+        // onCompleted: () => {
+        // },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+        },
+    });
+    async function likeOpportunityAction({ opportunityId, }) {
+        await mutate({
+            variables: { opportunityId },
+        });
+    }
+    return { likeOpportunityAction };
+};
+exports.useLikeOpportunity = useLikeOpportunity;

package/build/api/server-opportunities/mutations/useOpenOpportunity/index.d.ts

@@ -0,0 +1,5 @@
+import { opportunitiesSchema as schema } from '@ludo.ninja/api';
+declare const useOpenOpportunity: () => {
+    openOpportunityAction: ({ opportunityId, }: schema.IMutationOpenOpportunityArgs) => Promise<void>;
+};
+export default useOpenOpportunity;

package/build/api/server-opportunities/mutations/useOpenOpportunity/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@ludo.ninja/api");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const ui_1 = require("../../../../store/ui");
+const useOpenOpportunity = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = api_1.opportunitiesSchema.useOpenOpportunityMutation({
+        context: {
+            uri: api_1.hosts.opportunitiesHost,
+        },
+        // onCompleted: () => {
+        // },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+        },
+    });
+    async function openOpportunityAction({ opportunityId, }) {
+        await mutate({
+            variables: { opportunityId },
+        });
+    }
+    return { openOpportunityAction };
+};
+exports.default = useOpenOpportunity;

package/build/api/server-opportunities/queries/useGetOpportunities.d.ts

@@ -0,0 +1,4 @@
+export declare const useGetOpportunities: (availableProfileId: string) => {
+    opportunities: import("@ludo.ninja/api/build/graphql_tools/__generated__/opportunitiesHost/schema").Maybe<Pick<import("@ludo.ninja/api/build/graphql_tools/__generated__/opportunitiesHost/schema").IOpportunityV2, "views" | "createdAt" | "shareLink" | "blockchain" | "name" | "description" | "collection" | "liked" | "opportunityId" | "brandId" | "categoryId" | "opportunityStatus" | "opportunityType" | "notificationType" | "brandName" | "brandDescription" | "brandMedia" | "brandUrl" | "brandIndustry" | "categoryName" | "ludoUrl" | "projectUrl" | "activeFrom" | "activeUntil" | "minXpLevel" | "maxXpLevel" | "minRank" | "maxRank" | "media" | "reportLink" | "clicks" | "minWalletValue" | "maxWalletValue" | "participantsLimit" | "availablePlacesForAirdrop">>[];
+    isLoadingOpportunities: boolean;
+};

package/build/api/server-opportunities/queries/useGetOpportunities.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetOpportunities = void 0;
+const store_1 = require("../../../modules/user/store");
+const ui_1 = require("../../../store/ui");
+const api_1 = require("@ludo.ninja/api");
+const schema_1 = require("@ludo.ninja/api/build/graphql_tools/__generated__/opportunitiesHost/schema");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const react_1 = require("react");
+const useGetOpportunities = (availableProfileId) => {
+    const isSignedIn = (0, store_1.useUserStore)((state) => state.isSignedIn);
+    const user = (0, store_1.useUserStore)((state) => state.user);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [opportunities, setOpportunities] = (0, react_1.useState)([]);
+    const [getOpportunities, { loading }] = (0, schema_1.useFetchOpportunitiesForProfileLazyQuery)({
+        context: {
+            uri: api_1.hosts.opportunitiesHost,
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: "Oops, something went wrong.",
+            });
+        },
+    });
+    (0, react_1.useEffect)(() => {
+        if (isSignedIn && !opportunities.length && availableProfileId === user?.userId) {
+            getOpportunities().then((res) => {
+                setOpportunities(res.data?.fetchOpportunitiesForProfile || []);
+            });
+        }
+        if (!isSignedIn) {
+            setOpportunities([]);
+        }
+    }, [isSignedIn]);
+    return {
+        opportunities,
+        isLoadingOpportunities: loading,
+    };
+};
+exports.useGetOpportunities = useGetOpportunities;

package/build/api/server-preferences/mutations/useSaveUserExpectations/index.d.ts

@@ -0,0 +1,4 @@
+declare const useSaveUserExpectations: () => {
+    saveUserExpectations: (expectations: string[]) => Promise<void>;
+};
+export default useSaveUserExpectations;

package/build/api/server-preferences/mutations/useSaveUserExpectations/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("../../../../store/ui");
+const useSaveUserExpectations = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = api_1.preferencesSchema.useSaveUserExpectationsMutation({
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ saveUserExpectations }) => {
+            if (saveUserExpectations) {
+                openAlert({
+                    ...data_1.alertSuccess,
+                    caption: 'Expectations successfully added!',
+                    text: '',
+                });
+            }
+            else {
+                openAlert({
+                    ...data_1.alertError,
+                    caption: 'Sorry something went wrong :(',
+                    text: '',
+                });
+            }
+        },
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    async function saveUserExpectations(expectations) {
+        await mutate({
+            variables: { expectations },
+        });
+    }
+    return { saveUserExpectations };
+};
+exports.default = useSaveUserExpectations;