Postiz-android/artifacts/postiz-mobile/hooks/useNotifications.ts

import * as Notifications from "expo-notifications";
import { useCallback, useEffect, useRef } from "react";
import { Platform } from "react-native";
import { usePostiz } from "@/context/PostizContext";
import { PostizPost } from "@/context/PostizContext";

Notifications.setNotificationHandler({
  handleNotification: async () => ({
    shouldShowAlert: true,
    shouldPlaySound: true,
    shouldSetBadge: true,
    shouldShowBanner: true,
    shouldShowList: true,
  }),
});

const POLL_INTERVAL_MS = 15 * 60 * 1000;
const SEEN_KEY = "postiz_seen_statuses";

async function getSeenStatuses(): Promise<Record<string, string>> {
  try {
    const { default: AsyncStorage } = await import(
      "@react-native-async-storage/async-storage"
    );
    const raw = await AsyncStorage.getItem(SEEN_KEY);
    return raw ? JSON.parse(raw) : {};
  } catch {
    return {};
  }
}

async function saveSeenStatuses(map: Record<string, string>) {
  try {
    const { default: AsyncStorage } = await import(
      "@react-native-async-storage/async-storage"
    );
    await AsyncStorage.setItem(SEEN_KEY, JSON.stringify(map));
  } catch {}
}

async function sendStatusNotification(post: PostizPost) {
  const isError = post.status === "ERROR";
  await Notifications.scheduleNotificationAsync({
    content: {
      title: isError ? "Post failed to publish" : "Post published!",
      body:
        post.content.length > 80
          ? post.content.slice(0, 80) + "…"
          : post.content,
      data: { postId: post.id },
    },
    trigger: null,
  });
}

export function useNotifications() {
  const { client, isConfigured } = usePostiz();
  const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
  const permissionGranted = useRef(false);

  const requestPermissions = useCallback(async () => {
    if (Platform.OS === "web") return false;
    const { status: existing } = await Notifications.getPermissionsAsync();
    if (existing === "granted") {
      permissionGranted.current = true;
      return true;
    }
    const { status } = await Notifications.requestPermissionsAsync();
    permissionGranted.current = status === "granted";
    return permissionGranted.current;
  }, []);

  const checkForStatusChanges = useCallback(async () => {
    if (!client || !permissionGranted.current) return;

    try {
      const now = new Date();
      const from = new Date(now);
      from.setDate(from.getDate() - 7);

      const res = await client.get("/posts", {
        params: {
          startDate: from.toISOString(),
          endDate: now.toISOString(),
        },
      });

      const posts: PostizPost[] = Array.isArray(res.data)
        ? res.data
        : res.data?.posts ?? [];

      const seen = await getSeenStatuses();
      const updated: Record<string, string> = { ...seen };
      const toNotify: PostizPost[] = [];

      for (const post of posts) {
        const prev = seen[post.id];
        if (prev === undefined) {
          updated[post.id] = post.status;
          continue;
        }
        if (
          prev !== post.status &&
          (post.status === "PUBLISHED" || post.status === "ERROR")
        ) {
          toNotify.push(post);
        }
        updated[post.id] = post.status;
      }

      await saveSeenStatuses(updated);

      for (const post of toNotify) {
        await sendStatusNotification(post);
      }
    } catch {}
  }, [client]);

  useEffect(() => {
    if (!isConfigured || Platform.OS === "web") return;

    let mounted = true;

    (async () => {
      const granted = await requestPermissions();
      if (!granted || !mounted) return;

      await checkForStatusChanges();

      intervalRef.current = setInterval(() => {
        checkForStatusChanges();
      }, POLL_INTERVAL_MS);
    })();

    return () => {
      mounted = false;
      if (intervalRef.current) {
        clearInterval(intervalRef.current);
        intervalRef.current = null;
      }
    };
  }, [isConfigured, requestPermissions, checkForStatusChanges]);

  return { requestPermissions };
}