be-components 7.6.3 → 7.6.5

package/src/Components/Spring.tsx

@@ -1,6 +1,5 @@
 import React from 'react';
-import { Modal, Platform } from 'react-native';
-import { useSpring, animated } from '@react-spring/web';
+import { Modal } from 'react-native';
 import Text from './Text';
 
 type SpringViewProps = {
@@ -11,52 +10,22 @@ type SpringViewProps = {
     to:number,
     children: any
 }
-const SpringView = ({ style, children, from, to, slide, onResolve }:SpringViewProps) => {
+const SpringView = ({ style, children }:SpringViewProps) => {
 
-    let config:any = {
-        from: { x: from},
-        to: { x: to },
-        friction: 120,
-        tension: 280,
-        //...style
-    }
-    if(slide == 'vertical'){
-        config = {
-            from: { y: from},
-            to: { y: to },
-            //delay: 500,
-            onResolve: () => { if(onResolve){ onResolve() } },
-            //...style
-           // easing: easings.easeInBounce
-        }
-    }
 
+    //const props = useSpring(config)
 
 
-    const props = useSpring(config)
-
-    if(Platform.OS == 'web'){
-        return (
-            <animated.div
-                onAnimationEnd={() => console.log('animation has ended')}
-                style={{ ...props, ...style }}
-                
-            >
-                {children}
-            </animated.div>
-        )
-    } else {
-        return (
-        <Modal 
-        style={{ ...style }}
-        animationType="slide"
-        visible={true}
-        >
-            <Text>HEY THIS SHOULD BE IN HERE!!!</Text>
-            {children}
-        </Modal>
-        )
-    }
+    return (
+    <Modal 
+    style={{ ...style }}
+    animationType="slide"
+    visible={true}
+    >
+        <Text>HEY THIS SHOULD BE IN HERE!!!</Text>
+        {children}
+    </Modal>
+    )
 
     
 }

package/src/NotificationManager/NotificationManagerTabs.tsx

@@ -0,0 +1,178 @@
+import React, { useState } from 'react';
+import { TouchableOpacity, type ViewStyle } from 'react-native';
+import { View, Text } from '../Components/Themed';
+import { useColors } from '../constants/useColors';
+import { Icons } from '../Components';
+import NotificationManager from './index';
+import GroupManagement from './components/GroupManagement';
+import ScheduleNotification from './components/ScheduleNotification';
+import JobManagement from './components/JobManagement';
+import type { NotificationManagerTab, MyPlayerProps, FocusPositionProps, NotificationJobProps, PlayerNotificationProps } from '../types';
+
+interface NotificationManagerTabsProps {
+    player_ids?: string[];
+    me: MyPlayerProps;
+    header_style?: ViewStyle;
+    footer_style?: ViewStyle;
+    float?: boolean;
+    notification_type?: 'order_notifications' | 'competition_notifications' | 'social_notifications';
+    default_path_name?: string;
+    default_params?: Record<string, string>;
+    onFocusPosition?: (pos: FocusPositionProps) => void;
+    onComplete?: (notification: PlayerNotificationProps) => void;
+    onClose?: () => void;
+    defaultTab?: NotificationManagerTab;
+}
+
+const NotificationManagerTabs = ({
+    player_ids = [],
+    me,
+    header_style,
+    footer_style,
+    float,
+    notification_type,
+    default_path_name,
+    default_params,
+    onFocusPosition,
+    onComplete,
+    onClose,
+    defaultTab = 'send'
+}: NotificationManagerTabsProps) => {
+    const Colors = useColors();
+    const [activeTab, setActiveTab] = useState<NotificationManagerTab>(defaultTab);
+    const [editingJob, setEditingJob] = useState<NotificationJobProps | null>(null);
+
+    const tabs: { key: NotificationManagerTab; label: string; icon: React.ReactNode }[] = [
+        {
+            key: 'send',
+            label: 'Send Now',
+            icon: <Icons.SendIcon size={16} color={activeTab === 'send' ? Colors.text.white : Colors.text.h2} />
+        },
+        {
+            key: 'schedule',
+            label: 'Schedule',
+            icon: <Icons.ActivityIcon size={16} color={activeTab === 'schedule' ? Colors.text.white : Colors.text.h2} />
+        },
+        {
+            key: 'jobs',
+            label: 'Manage Jobs',
+            icon: <Icons.ListIcon size={16} color={activeTab === 'jobs' ? Colors.text.white : Colors.text.h2} />
+        },
+        {
+            key: 'groups',
+            label: 'Manage Groups',
+            icon: <Icons.ContactsIcon size={16} color={activeTab === 'groups' ? Colors.text.white : Colors.text.h2} />
+        }
+    ];
+
+    const handleEditJob = (job: NotificationJobProps) => {
+        setEditingJob(job);
+        setActiveTab('schedule');
+    };
+
+    const handleJobSaved = () => {
+        setEditingJob(null);
+        setActiveTab('jobs');
+    };
+
+    const renderTabContent = () => {
+        switch (activeTab) {
+            case 'send':
+                return (
+                    <NotificationManager
+                        player_ids={player_ids}
+                        me={me}
+                        header_style={header_style}
+                        footer_style={footer_style}
+                        float={float !== undefined ? float : false}
+                        notification_type={notification_type}
+                        default_path_name={default_path_name}
+                        default_params={default_params}
+                        onFocusPosition={onFocusPosition}
+                        onComplete={onComplete}
+                        onClose={undefined} // Handled by tabs header
+                    />
+                );
+            case 'groups':
+                return <GroupManagement onFocusPosition={onFocusPosition} />;
+            case 'schedule':
+                return (
+                    <ScheduleNotification
+                        onFocusPosition={onFocusPosition}
+                        editingJob={editingJob}
+                        onJobSaved={handleJobSaved}
+                    />
+                );
+            case 'jobs':
+                return <JobManagement onEditJob={handleEditJob} />;
+            default:
+                return null;
+        }
+    };
+
+    return (
+        <View float style={{ flex: 1 }}>
+            {/* Header with Tabs */}
+            <View type='header' style={{ borderBottomWidth: 1, borderBottomColor: Colors.borders.light }}>
+                <View transparent style={{ flexDirection: 'row', alignItems: 'center', padding: 10 }}>
+                    <View transparent style={{ flex: 1 }}>
+                        <Text theme='h1'>Notification Manager</Text>
+                        <Text theme='description' style={{ marginTop: 3 }}>
+                            Send, schedule, and manage notifications
+                        </Text>
+                    </View>
+                    {onClose && (
+                        <TouchableOpacity onPress={onClose} style={{ padding: 8 }}>
+                            <Icons.CloseIcon size={16} color={Colors.text.h1} />
+                        </TouchableOpacity>
+                    )}
+                </View>
+
+                {/* Tab Navigation */}
+                <View transparent style={{ flexDirection: 'row', paddingHorizontal: 10, paddingBottom: 10 }}>
+                    {tabs.map((tab) => {
+                        const isActive = activeTab === tab.key;
+                        return (
+                            <TouchableOpacity
+                                key={tab.key}
+                                onPress={() => {
+                                    if (tab.key !== 'schedule') {
+                                        setEditingJob(null);
+                                    }
+                                    setActiveTab(tab.key);
+                                }}
+                                style={{
+                                    flex: 1,
+                                    paddingVertical: 10,
+                                    paddingHorizontal: 12,
+                                    marginHorizontal: 4,
+                                    borderRadius: 8,
+                                    backgroundColor: isActive ? Colors.buttons.background.action : Colors.views.background,
+                                    flexDirection: 'row',
+                                    alignItems: 'center',
+                                    justifyContent: 'center'
+                                }}
+                            >
+                                {tab.icon}
+                                <Text
+                                    theme={isActive ? 'h2' : 'description'}
+                                    color={isActive ? Colors.text.white : Colors.text.h2}
+                                    style={{ marginLeft: 6, fontSize: 12, fontWeight: '600' }}
+                                >
+                                    {tab.label}
+                                </Text>
+                            </TouchableOpacity>
+                        );
+                    })}
+                </View>
+            </View>
+
+            {/* Tab Content */}
+            <View style={{ flex: 1 }}>
+                {renderTabContent()}
+            </View>
+        </View>
+    );
+};
+
+export default NotificationManagerTabs;

package/src/NotificationManager/api/index.ts

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { APIOverrides } from '../../ApiOverrides';
-import type { NotificationGroupMemberProps, NotificationGroupProps, PlayerNotificationProps, PublicPlayerProps } from '../../types';
+import type { NotificationGroupMemberProps, NotificationGroupProps, NotificationJobProps, PlayerNotificationProps, PublicPlayerProps } from '../../types';
 
 let AUTH_SVC_API = '';
 
@@ -44,7 +44,7 @@ export const NotificationHelpers = {
         { label: 'Filters', path_name: '/markets/filters', params: {}, requiredParams: [], primary: false },
         { label: 'Live Markets', path_name: '/markets/live', params: {}, requiredParams: [], primary: false },
         { label: 'Parlays', path_name: '/markets/parlays', params: {}, requiredParams: [], primary: false },
-        { label: 'Market Activity', path_name: '/markets/activity/[content_id]', params: { content_id: '' }, requiredParams: ['content_id'], primary: false },
+        { label: 'Market Activity', path_name: '/markets/activity/[content_id]', params: { content_id: '', content_type: '' }, requiredParams: ['content_id'], primary: false },
         { label: 'Contest', path_name: '/markets/contest/[contest_id]', params: { contest_id: '', contest_type: '' }, requiredParams: ['contest_id', 'contest_type'], primary: true },
         { label: 'Filter', path_name: '/markets/filter/[player_filter_id]', params: { player_filter_id: '', mode: '' }, requiredParams: ['player_filter_id'], primary: false },
         { label: 'Fund', path_name: '/markets/fund/[fund_id]', params: { fund_id: '' }, requiredParams: ['fund_id'], primary: false },
@@ -104,22 +104,34 @@ export const NotificationApi = {
 
     /**
      * Send notifications to multiple players
+     * @param player_notification - The notification to send
+     * @param player_ids - Array of player IDs (must be empty if notification_group_id is provided)
+     * @param notification_group_id - Optional group ID (server will fetch members)
      */
-    broadcastNotifications: async(player_notification: PlayerNotificationProps, player_ids: string[]): Promise<{ message: string }> => {
+    broadcastNotifications: async(player_notification: PlayerNotificationProps, player_ids: string[], notification_group_id?: string): Promise<{ message: string }> => {
         try {
-            const resp = await axios.post(`${AUTH_SVC_API}/v1/notifications/bulk/send`, { player_notification, player_ids });
-            console.log(resp.data)
+            const requestBody = notification_group_id
+                ? { player_notification, notification_group_id, player_ids: [] }
+                : { player_notification, player_ids };
+
+            const resp = await axios.post(`${AUTH_SVC_API}/v1/notifications/bulk/send`, requestBody);
             return resp.data;
         } catch (e) {
             console.log('Error broadcasting notifications:', e);
             throw e;
         }
     },
-    getActiveNotificationGroups: async():Promise<NotificationGroupProps[]> => {
+    getActiveNotificationGroups: async(limit?: number, offset?: number):Promise<NotificationGroupProps[]> => {
         try {
-            const resp = await axios.get(`${AUTH_SVC_API}/v1/notifications/groups/active`);
+            const params = new URLSearchParams();
+            params.append('status', 'active');
+            if (limit !== undefined) params.append('limit', limit.toString());
+            if (offset !== undefined) params.append('offset', offset.toString());
+            const resp = await axios.get(`${AUTH_SVC_API}/v1/notifications/groups?${params.toString()}`);
+            console.log('getActiveNotificationGroups response:', resp.data);
             return resp.data.notification_groups
         } catch (e) {
+            console.log('getActiveNotificationGroups error:', e);
             return []
         }
     },
@@ -130,5 +142,226 @@ export const NotificationApi = {
         } catch (e) {
             return []
         }
+    },
+
+    // Group Management Functions
+
+    /**
+     * Get all notification groups
+     */
+    getAllNotificationGroups: async(limit?: number, offset?: number, search?: string): Promise<NotificationGroupProps[]> => {
+        try {
+            const params = new URLSearchParams();
+            if (limit !== undefined) params.append('limit', limit.toString());
+            if (offset !== undefined) params.append('offset', offset.toString());
+            if (search) params.append('search', search);
+            const queryString = params.toString() ? `?${params.toString()}` : '';
+            const resp = await axios.get(`${AUTH_SVC_API}/v1/notifications/groups${queryString}`);
+            return resp.data.notification_groups;
+        } catch (e) {
+            console.log('Error fetching notification groups:', e);
+            return [];
+        }
+    },
+
+    /**
+     * Get notification groups by status
+     */
+    getNotificationGroupsByStatus: async(status: 'active' | 'inactive', limit?: number, offset?: number, search?: string): Promise<NotificationGroupProps[]> => {
+        try {
+            const params = new URLSearchParams();
+            params.append('status', status);
+            if (limit !== undefined) params.append('limit', limit.toString());
+            if (offset !== undefined) params.append('offset', offset.toString());
+            if (search) params.append('search', search);
+            const resp = await axios.get(`${AUTH_SVC_API}/v1/notifications/groups?${params.toString()}`);
+            return resp.data.notification_groups;
+        } catch (e) {
+            console.log('Error fetching notification groups by status:', e);
+            return [];
+        }
+    },
+
+    /**
+     * Get a single notification group by ID
+     */
+    getNotificationGroupById: async(notification_group_id: string): Promise<NotificationGroupProps | null> => {
+        try {
+            const resp = await axios.get(`${AUTH_SVC_API}/v1/notifications/groups/id/${notification_group_id}`);
+            return resp.data.notification_group;
+        } catch (e) {
+            console.log('Error fetching notification group:', e);
+            return null;
+        }
+    },
+
+    /**
+     * Create a new notification group
+     */
+    createNotificationGroup: async(notification_group: Partial<NotificationGroupProps>): Promise<NotificationGroupProps | null> => {
+        try {
+            const resp = await axios.post(`${AUTH_SVC_API}/v1/notifications/groups/create`, { notification_group });
+            return resp.data.notification_group;
+        } catch (e) {
+            console.log('Error creating notification group:', e);
+            throw e;
+        }
+    },
+
+    /**
+     * Update an existing notification group
+     */
+    updateNotificationGroup: async(notification_group: NotificationGroupProps): Promise<NotificationGroupProps | null> => {
+        try {
+            const resp = await axios.put(`${AUTH_SVC_API}/v1/notifications/groups/${notification_group.notification_group_id}`, { notification_group });
+            return resp.data.notification_group;
+        } catch (e) {
+            console.log('Error updating notification group:', e);
+            throw e;
+        }
+    },
+
+    /**
+     * Inactivate a notification group
+     */
+    inactivateNotificationGroup: async(notification_group_id: string): Promise<{ message: string }> => {
+        try {
+            const resp = await axios.put(`${AUTH_SVC_API}/v1/notifications/groups/${notification_group_id}/inactivate`);
+            return resp.data;
+        } catch (e) {
+            console.log('Error inactivating notification group:', e);
+            throw e;
+        }
+    },
+
+    /**
+     * Trigger grouping function to update group members, or manually add members via player_ids array
+     */
+    updateGroupMembers: async(notification_group_id: string, player_ids?: string[]): Promise<{ message: string }> => {
+        try {
+            const body: any = { notification_group_id };
+            if (player_ids && player_ids.length > 0) {
+                body.player_ids = player_ids;
+            }
+            const resp = await axios.post(`${AUTH_SVC_API}/v1/notifications/group/members/load`, body);
+            return resp.data;
+        } catch (e) {
+            console.log('Error updating group members:', e);
+            throw e;
+        }
+    },
+
+    // Job Management Functions
+
+    /**
+     * Get all notification jobs
+     */
+    getAllNotificationJobs: async(limit?: number, offset?: number): Promise<NotificationJobProps[]> => {
+        try {
+            const params = new URLSearchParams();
+            if (limit !== undefined) params.append('limit', limit.toString());
+            if (offset !== undefined) params.append('offset', offset.toString());
+            const queryString = params.toString() ? `?${params.toString()}` : '';
+            const resp = await axios.get(`${AUTH_SVC_API}/v1/notifications/jobs${queryString}`);
+            return resp.data.notification_jobs;
+        } catch (e) {
+            console.log('Error fetching notification jobs:', e);
+            return [];
+        }
+    },
+
+    /**
+     * Get notification jobs by status
+     */
+    getNotificationJobsByStatus: async(status: string, limit?: number, offset?: number): Promise<NotificationJobProps[]> => {
+        try {
+            const params = new URLSearchParams();
+            params.append('status', status);
+            if (limit !== undefined) params.append('limit', limit.toString());
+            if (offset !== undefined) params.append('offset', offset.toString());
+            const resp = await axios.get(`${AUTH_SVC_API}/v1/notifications/jobs?${params.toString()}`);
+            return resp.data.notification_jobs;
+        } catch (e) {
+            console.log('Error fetching notification jobs by status:', e);
+            return [];
+        }
+    },
+
+    /**
+     * Get notification jobs by group ID
+     */
+    getNotificationJobsByGroup: async(notification_group_id: string): Promise<NotificationJobProps[]> => {
+        try {
+            const resp = await axios.get(`${AUTH_SVC_API}/v1/notifications/jobs/group/${notification_group_id}`);
+            return resp.data.notification_jobs;
+        } catch (e) {
+            console.log('Error fetching notification jobs by group:', e);
+            return [];
+        }
+    },
+
+    /**
+     * Get a single notification job by ID
+     */
+    getNotificationJobById: async(notification_job_id: string): Promise<NotificationJobProps | null> => {
+        try {
+            const resp = await axios.get(`${AUTH_SVC_API}/v1/notifications/jobs/${notification_job_id}`);
+            return resp.data.notification_job;
+        } catch (e) {
+            console.log('Error fetching notification job:', e);
+            return null;
+        }
+    },
+
+    /**
+     * Create a new notification job
+     */
+    createNotificationJob: async(notification_job: Partial<NotificationJobProps>): Promise<NotificationJobProps | null> => {
+        try {
+            const resp = await axios.post(`${AUTH_SVC_API}/v1/notifications/jobs/create`, { notification_job });
+            return resp.data.notification_job;
+        } catch (e) {
+            console.log('Error creating notification job:', e);
+            throw e;
+        }
+    },
+
+    /**
+     * Update an existing notification job
+     */
+    updateNotificationJob: async(notification_job: NotificationJobProps): Promise<NotificationJobProps | null> => {
+        try {
+            const resp = await axios.put(`${AUTH_SVC_API}/v1/notifications/jobs/${notification_job.notification_job_id}`, { notification_job });
+            return resp.data.notification_job;
+        } catch (e) {
+            console.log('Error updating notification job:', e);
+            throw e;
+        }
+    },
+
+    /**
+     * Finalize a notification job (mark as ready for sending)
+     */
+    finalizeNotificationJob: async(notification_job_id: string): Promise<{ message: string }> => {
+        try {
+            const resp = await axios.put(`${AUTH_SVC_API}/v1/notifications/jobs/${notification_job_id}/finalize`);
+            return resp.data;
+        } catch (e) {
+            console.log('Error finalizing notification job:', e);
+            throw e;
+        }
+    },
+
+    /**
+     * Cancel a notification job
+     */
+    cancelNotificationJob: async(notification_job_id: string): Promise<{ message: string }> => {
+        try {
+            const resp = await axios.delete(`${AUTH_SVC_API}/v1/notifications/jobs/${notification_job_id}`);
+            return resp.data;
+        } catch (e) {
+            console.log('Error cancelling notification job:', e);
+            throw e;
+        }
     }
 }