@product7/product7-js 0.1.0

package/src/api/services/MessengerService.js

@@ -0,0 +1,279 @@
+import { MOCK_CONVERSATIONS, MOCK_MESSAGES } from '../mock-data/index.js';
+import { delay } from '../utils/helpers.js';
+
+export class MessengerService {
+	constructor(baseAPI) {
+		this.api = baseAPI;
+	}
+
+	async getMessengerSettings() {
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			return {
+				status: true,
+				data: {
+					enabled: true,
+					greeting_message: 'Hi there! How can we help?',
+					team_name: 'Support Team',
+					response_time: 'Usually replies within a few minutes',
+				},
+			};
+		}
+
+		return this.api._makeRequest('/widget/messenger/settings', {
+			method: 'GET',
+			headers: { Authorization: `Bearer ${this.api.sessionToken}` },
+		});
+	}
+
+	async checkAgentsOnline() {
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			return {
+				status: true,
+				data: {
+					agents_online: true,
+					online_count: 2,
+					response_time: 'Usually replies within a few minutes',
+				},
+			};
+		}
+
+		return this.api._makeRequest('/widget/messenger/agents/online', {
+			method: 'GET',
+			headers: { Authorization: `Bearer ${this.api.sessionToken}` },
+		});
+	}
+
+	async getConversations(options = {}) {
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			await delay(300);
+			return {
+				status: true,
+				data: MOCK_CONVERSATIONS,
+				meta: { total: MOCK_CONVERSATIONS.length, page: 1, limit: 20 },
+			};
+		}
+
+		const endpoint = this.api._getEndpointWithParams(
+			'/widget/messenger/conversations',
+			options
+		);
+		return this.api._makeRequest(endpoint, {
+			method: 'GET',
+			headers: { Authorization: `Bearer ${this.api.sessionToken}` },
+		});
+	}
+
+	async getConversation(conversationId) {
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			await delay(200);
+			const conv = MOCK_CONVERSATIONS.find((c) => c.id === conversationId);
+			return {
+				status: true,
+				data: { ...conv, messages: MOCK_MESSAGES[conversationId] || [] },
+			};
+		}
+
+		return this.api._makeRequest(
+			`/widget/messenger/conversations/${conversationId}`,
+			{
+				method: 'GET',
+				headers: { Authorization: `Bearer ${this.api.sessionToken}` },
+			}
+		);
+	}
+
+	async startConversation(data) {
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			await delay(300);
+			const newConv = {
+				id: 'conv_' + Date.now(),
+				subject: data.subject || 'New conversation',
+				status: 'open',
+				last_message_at: new Date().toISOString(),
+				created_at: new Date().toISOString(),
+				messages: [
+					{
+						id: 'msg_' + Date.now(),
+						content: data.message,
+						sender_type: 'customer',
+						created_at: new Date().toISOString(),
+						attachments: data.attachments || [],
+					},
+				],
+			};
+			MOCK_CONVERSATIONS.unshift(newConv);
+			MOCK_MESSAGES[newConv.id] = newConv.messages;
+			return { status: true, data: newConv };
+		}
+
+		return this.api._makeRequest('/widget/messenger/conversations', {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				Authorization: `Bearer ${this.api.sessionToken}`,
+			},
+			body: JSON.stringify({
+				message: data.message,
+				subject: data.subject || '',
+				attachments: data.attachments || [],
+			}),
+		});
+	}
+
+	async sendMessage(conversationId, data) {
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			await delay(200);
+			const newMessage = {
+				id: 'msg_' + Date.now(),
+				content: data.content,
+				sender_type: 'customer',
+				created_at: new Date().toISOString(),
+				attachments: data.attachments || [],
+			};
+			if (!MOCK_MESSAGES[conversationId]) {
+				MOCK_MESSAGES[conversationId] = [];
+			}
+			MOCK_MESSAGES[conversationId].push(newMessage);
+			return { status: true, data: newMessage };
+		}
+
+		return this.api._makeRequest(
+			`/widget/messenger/conversations/${conversationId}/messages`,
+			{
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+					Authorization: `Bearer ${this.api.sessionToken}`,
+				},
+				body: JSON.stringify({
+					content: data.content,
+					attachments: data.attachments || [],
+				}),
+			}
+		);
+	}
+
+	async getUnreadCount() {
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			const count = MOCK_CONVERSATIONS.reduce(
+				(sum, c) => sum + (c.unread || 0),
+				0
+			);
+			return {
+				status: true,
+				data: { unread_count: count, unread_conversations: count > 0 ? 1 : 0 },
+			};
+		}
+
+		return this.api._makeRequest('/widget/messenger/unread', {
+			method: 'GET',
+			headers: { Authorization: `Bearer ${this.api.sessionToken}` },
+		});
+	}
+
+	async markConversationAsRead(conversationId) {
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			return { status: true };
+		}
+
+		return this.api._makeRequest(
+			`/widget/messenger/conversations/${conversationId}/read`,
+			{
+				method: 'POST',
+				headers: { Authorization: `Bearer ${this.api.sessionToken}` },
+			}
+		);
+	}
+
+	async getMessages(conversationId, options = {}) {
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			await delay(200);
+			return {
+				status: true,
+				data: MOCK_MESSAGES[conversationId] || [],
+				meta: { total: 0, page: 1, limit: 50 },
+			};
+		}
+
+		const params = { ...options };
+		const endpoint = this.api._getEndpointWithParams(
+			`/widget/messenger/conversations/${conversationId}/messages`,
+			params
+		);
+		return this.api._makeRequest(endpoint, {
+			method: 'GET',
+			headers: { Authorization: `Bearer ${this.api.sessionToken}` },
+		});
+	}
+
+	async identifyContact(data) {
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			await delay(300);
+			return {
+				status: true,
+				data: {
+					contact_id: 'mock_contact_' + Date.now(),
+					email: data.email,
+					name: data.name || '',
+					is_new: true,
+				},
+			};
+		}
+
+		return this.api._makeRequest('/widget/messenger/identify', {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				Authorization: `Bearer ${this.api.sessionToken}`,
+			},
+			body: JSON.stringify({
+				email: data.email,
+				name: data.name || '',
+				phone: data.phone || '',
+				company: data.company || '',
+				avatar_url: data.avatar_url || '',
+				metadata: data.metadata || {},
+			}),
+		});
+	}
+
+	async sendTypingIndicator(conversationId, isTyping) {
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			return { status: true };
+		}
+
+		return this.api._makeRequest(
+			`/widget/messenger/conversations/${conversationId}/typing`,
+			{
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+					Authorization: `Bearer ${this.api.sessionToken}`,
+				},
+				body: JSON.stringify({ is_typing: isTyping }),
+			}
+		);
+	}
+}

package/src/api/services/SurveyService.js

@@ -0,0 +1,127 @@
+import { APIError } from '../../utils/errors.js';
+import { MOCK_SURVEYS } from '../mock-data/index.js';
+import { delay, getDeviceInfo } from '../utils/helpers.js';
+
+export class SurveyService {
+	constructor(baseAPI) {
+		this.api = baseAPI;
+	}
+
+	async getActiveSurveys(context = {}) {
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			await delay(200);
+			return { success: true, data: MOCK_SURVEYS };
+		}
+
+		const respondent = this._getRespondentContext(context);
+
+		const params = {
+			url:
+				context.url ||
+				(typeof window !== 'undefined' ? window.location.href : ''),
+			...getDeviceInfo(),
+			...(respondent.respondent_id && {
+				respondent_id: respondent.respondent_id,
+			}),
+			...(respondent.email && { email: respondent.email }),
+			...(context.includeEligibility !== undefined && {
+				include_eligibility: context.includeEligibility,
+			}),
+			...(context.userProperties && {
+				user_properties: context.userProperties,
+			}),
+		};
+
+		return this.api._handleAuthRetry(async () => {
+			const endpoint = this.api._getEndpointWithParams(
+				'/widget/surveys/active',
+				params
+			);
+			return await this.api._makeRequest(endpoint, {
+				method: 'GET',
+				headers: { Authorization: `Bearer ${this.api.sessionToken}` },
+			});
+		});
+	}
+
+	_getRespondentContext(context = {}) {
+		const metadata =
+			typeof this.api.getMetadata === 'function'
+				? this.api.getMetadata() || {}
+				: {};
+
+		return {
+			respondent_id:
+				context.respondentId || context.userId || metadata.user_id || null,
+			email: context.email || metadata.email || null,
+		};
+	}
+
+	async submitSurveyResponse(surveyId, responseData) {
+		if (!surveyId) throw new APIError(400, 'Survey ID is required');
+
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			await delay(300);
+			return {
+				success: true,
+				data: {
+					id: 'mock_response_' + Date.now(),
+					survey_id: surveyId,
+					...responseData,
+				},
+				message: 'Survey response submitted successfully!',
+			};
+		}
+
+		const respondent = this._getRespondentContext(responseData);
+
+		const payload = {
+			rating: responseData.rating,
+			feedback: responseData.feedback || '',
+			answers: responseData.answers || {},
+			...(respondent.respondent_id && {
+				respondent_id: respondent.respondent_id,
+			}),
+			...(respondent.email && { email: respondent.email }),
+		};
+
+		return this.api._handleAuthRetry(async () => {
+			return await this.api._makeRequest(
+				`/widget/surveys/${surveyId}/responses`,
+				{
+					method: 'POST',
+					body: JSON.stringify(payload),
+					headers: {
+						'Content-Type': 'application/json',
+						Authorization: `Bearer ${this.api.sessionToken}`,
+					},
+				}
+			);
+		});
+	}
+
+	async dismissSurvey(surveyId) {
+		if (!surveyId) throw new APIError(400, 'Survey ID is required');
+
+		await this.api._ensureSession();
+
+		if (this.api.mock) {
+			await delay(100);
+			return { success: true, message: 'Survey dismissed successfully' };
+		}
+
+		return this.api._handleAuthRetry(async () => {
+			return await this.api._makeRequest(
+				`/widget/surveys/${surveyId}/dismiss`,
+				{
+					method: 'POST',
+					headers: { Authorization: `Bearer ${this.api.sessionToken}` },
+				}
+			);
+		});
+	}
+}

package/src/api/utils/helpers.js

@@ -0,0 +1,30 @@
+export const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export function getDeviceInfo() {
+	if (typeof navigator === 'undefined') {
+		return { device: null, browser: null, os: null };
+	}
+
+	const ua = navigator.userAgent;
+
+	let device = 'desktop';
+	if (/Mobi|Android/i.test(ua)) {
+		device = /Tablet|iPad/i.test(ua) ? 'tablet' : 'mobile';
+	}
+
+	let browser = 'unknown';
+	if (ua.includes('Firefox')) browser = 'firefox';
+	else if (ua.includes('Edg')) browser = 'edge';
+	else if (ua.includes('Chrome')) browser = 'chrome';
+	else if (ua.includes('Safari')) browser = 'safari';
+	else if (ua.includes('Opera') || ua.includes('OPR')) browser = 'opera';
+
+	let os = 'unknown';
+	if (ua.includes('Windows')) os = 'windows';
+	else if (ua.includes('Mac')) os = 'macos';
+	else if (ua.includes('Linux')) os = 'linux';
+	else if (ua.includes('Android')) os = 'android';
+	else if (ua.includes('iPhone') || ua.includes('iPad')) os = 'ios';
+
+	return { device, browser, os };
+}