@mundogamernetwork/shared-ui 1.1.60 → 1.1.62

package/services/campaignService.ts

@@ -0,0 +1,389 @@
+import axios, { type AxiosInstance } from "axios"
+
+// Campaign service wraps the key-campaigns API used by TV, community, and agency.
+// Two clients:
+//   mainClient — public endpoints (/public/keys*), no auth required for listing
+//   authClient — authenticated endpoints (/api/v1/*), withCredentials
+
+let _mainClient: AxiosInstance | null = null
+let _authClient: AxiosInstance | null = null
+
+function getMainClient(): AxiosInstance {
+	if (_mainClient) return _mainClient
+
+	const baseURL =
+		import.meta.env.VITE_CAMPAIGN_API_URL ||
+		import.meta.env.VITE_API_BASE_URL ||
+		""
+
+	_mainClient = axios.create({ baseURL })
+
+	_mainClient.interceptors.request.use((config) => {
+		const SUPPORTED_LOCALES = ["en", "pt-BR", "es", "de", "ro", "ar-AE"]
+		const seg =
+			typeof location === "undefined" ? "" : location.pathname.split("/")[1] || ""
+		const lang = SUPPORTED_LOCALES.includes(seg) ? seg : "en"
+		config.params = { ...config.params, lang }
+		if (
+			import.meta.env.VITE_APP_ENV !== "production" &&
+			typeof window !== "undefined" &&
+			import.meta.env.VITE_BEARER_TOKEN
+		) {
+			config.headers.Authorization = `Bearer ${import.meta.env.VITE_BEARER_TOKEN}`
+		}
+		return config
+	})
+
+	return _mainClient
+}
+
+function getAuthClient(): AxiosInstance {
+	if (_authClient) return _authClient
+
+	const baseURL =
+		import.meta.env.VITE_CAMPAIGN_API_URL ||
+		import.meta.env.VITE_API_BASE_URL ||
+		""
+
+	_authClient = axios.create({ baseURL, withCredentials: true })
+
+	_authClient.interceptors.request.use((config) => {
+		const SUPPORTED_LOCALES = ["en", "pt-BR", "es", "de", "ro", "ar-AE"]
+		const seg =
+			typeof location === "undefined" ? "" : location.pathname.split("/")[1] || ""
+		const lang = SUPPORTED_LOCALES.includes(seg) ? seg : "en"
+		config.params = { ...config.params, lang }
+		if (
+			import.meta.env.VITE_APP_ENV !== "production" &&
+			typeof window !== "undefined" &&
+			import.meta.env.VITE_BEARER_TOKEN
+		) {
+			config.headers.Authorization = `Bearer ${import.meta.env.VITE_BEARER_TOKEN}`
+		}
+		return config
+	})
+
+	return _authClient
+}
+
+// Lazy proxies so the clients are only initialised when first used
+const mainClient = new Proxy({} as AxiosInstance, {
+	get(_t, prop) {
+		return (getMainClient() as any)[prop]
+	},
+})
+
+const authClient = new Proxy({} as AxiosInstance, {
+	get(_t, prop) {
+		return (getAuthClient() as any)[prop]
+	},
+})
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface Campaign {
+	id: number
+	name: string
+	slug: string
+	cover_src: string
+	featured: boolean
+	type: {
+		id: number
+		name: string
+	}
+	game: {
+		id: number
+		url_banner_src: string
+		url_cover_src?: string
+		slug?: string
+		name?: string
+		summary?: string
+	}
+	time_to_expire: string
+	end_date?: string
+	start_date?: string
+	available_count?: number
+	is_exclusive?: boolean
+	is_tier_locked?: boolean
+	access_tier?: string
+	early_access_hours?: number
+	user_can_access?: boolean
+	available_at_for_user?: string | null
+	max_keys_for_user?: number
+	streamer_type_id?: number
+	status?: number | boolean
+	quantity?: number
+	request_user_status?: number
+	platforms?: Array<{ id: number; name: string; slug: string }>
+	regions?: Array<{ id: number; name: string; slug: string }>
+	requests?: Array<{ id: number; key_item_id?: number; admin_notes?: string }>
+	company?: { name: string; email?: string; twitter?: string; thumbnail_url?: string }
+	streamer_type?: { description?: string }
+	meets_streamer_level?: boolean
+}
+
+export interface CampaignRequest {
+	id: number
+	status_request: {
+		id: number
+		slug: string
+		name: string
+		color: string
+	}
+	key: Campaign
+	key_item_id?: number
+}
+
+export interface CampaignType {
+	id: number
+	name: string
+	localized_name?: string
+}
+
+export interface Platform {
+	id: number
+	name: string
+	slug: string
+}
+
+export interface CampaignsResponse {
+	data: Campaign[]
+	meta: {
+		pagination: {
+			total: number
+			count: number
+			per_page: number
+			current_page: number
+			total_pages: number
+			links?: { previous?: string; next?: string }
+		}
+	}
+	status: string
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function buildListParams(opts: {
+	filter?: Record<string, any>
+	page?: number
+	per_page?: number | string
+	sort?: string
+	order?: string
+}): Record<string, any> {
+	const params: Record<string, any> = {}
+	if (opts.page !== undefined) params["page"] = opts.page
+	if (opts.per_page !== undefined) params["per_page"] = opts.per_page
+	if (opts.sort) params["sort"] = opts.sort
+	if (opts.order) params["order"] = opts.order
+	if (opts.filter) {
+		for (const [k, v] of Object.entries(opts.filter)) {
+			params[`filter[${k}]`] = v
+		}
+	}
+	return params
+}
+
+// ---------------------------------------------------------------------------
+// Public endpoints (mainClient — no auth)
+// ---------------------------------------------------------------------------
+
+/**
+ * List campaigns.
+ * @param params  - filter/page/sort params (may include filter[type_id], filter[platform_id], etc.)
+ * @param mgPlatform - platform tag injected as filter[mg_platform] (default: 'MGTV')
+ */
+export const fetchCampaigns = (
+	params: Record<string, any> = {},
+	mgPlatform = "MGTV",
+) => {
+	return mainClient.get<CampaignsResponse>("/public/keys", {
+		params: {
+			...buildListParams({
+				filter: {
+					...(params.filter || {}),
+					include_early_access_locked: true,
+					mg_platform: mgPlatform,
+				},
+				page: params.page || 1,
+				per_page: params.per_page || 15,
+				sort: params.sort || "id",
+				order: params.order || "desc",
+			}),
+			// pass through any extra flat params (e.g. filter[type_id])
+			...Object.fromEntries(
+				Object.entries(params).filter(([k]) => !["page", "per_page", "sort", "order", "filter"].includes(k)),
+			),
+		},
+	})
+}
+
+/**
+ * List featured campaigns shown in the hero slider.
+ * @param mgPlatform - platform tag (default: 'MGTV')
+ */
+export const fetchFeaturedCampaigns = (mgPlatform = "MGTV") => {
+	return mainClient.get<CampaignsResponse>("/public/keys", {
+		params: buildListParams({
+			filter: {
+				is_public: true,
+				status: 1,
+				mg_platform: mgPlatform,
+			},
+			sort: "id",
+			order: "desc",
+			per_page: 12,
+		}),
+	})
+}
+
+/**
+ * Fetch a single campaign by slug and return a normalised shape.
+ */
+export const fetchCampaignBySlug = async (slug: string) => {
+	const { data } = await mainClient.get(`/public/keys/${slug}`)
+
+	if (!data?.data) throw new Error("Campaign data not found")
+
+	const k = data.data
+	return {
+		id: k.id,
+		name: k.name,
+		slug: k.slug,
+		cover: k.cover_src,
+		game_cover: k.game?.url_cover_src,
+		game_slug: k.game?.slug,
+		time_to_expire: k.time_to_expire,
+		request_status: k.request_user_status,
+		end: k.end_date,
+		start: k.start_date,
+		company: k.company?.name,
+		email: k.company?.email,
+		twitter: k.company?.twitter,
+		logo: k.company?.thumbnail_url,
+		status: k.status,
+		quantity: k.quantity,
+		available_count: k.available_count ?? 0,
+		streamer_type: k.streamer_type_id,
+		streamer_description: k.streamer_type?.description,
+		access_tier: k.access_tier ?? "free",
+		is_exclusive: k.is_exclusive ?? false,
+		is_tier_locked: k.is_tier_locked ?? false,
+		early_access_hours: k.early_access_hours ?? 0,
+		user_can_access: k.user_can_access !== false,
+		meets_streamer_level: k.meets_streamer_level !== false,
+		available_at_for_user: k.available_at_for_user ?? null,
+		max_keys_for_user: k.max_keys_for_user ?? 1,
+		game_summary: k.game?.summary,
+		request_id: k.requests?.[0]?.id,
+		request_item_id: k.requests?.[0]?.key_item_id,
+		request_admin_notes: k.requests?.[0]?.admin_notes ?? null,
+		platforms: (k.platforms || []).map((p: any) => ({ id: p.id, name: p.name, slug: p.slug })),
+		regions: (k.regions || []).map((r: any) => ({ id: r.id, name: r.name, slug: r.slug })),
+	}
+}
+
+/**
+ * Fetch platforms for a specific campaign (public).
+ */
+export const fetchKeyPlatforms = (keyId: number, params: Record<string, any> = {}) => {
+	return mainClient.get(`/public/keys/${keyId}/platforms`, { params })
+}
+
+/**
+ * Fetch regions for a specific campaign (public).
+ */
+export const fetchKeyRegions = (keyId: number, params: Record<string, any> = {}) => {
+	return mainClient.get(`/public/keys/${keyId}/regions`, { params })
+}
+
+// ---------------------------------------------------------------------------
+// Auth-required endpoints (authClient — withCredentials)
+// ---------------------------------------------------------------------------
+
+/**
+ * Fetch available campaign types.
+ */
+export const fetchCampaignTypes = (params: Record<string, any> = {}) => {
+	const queryString = Object.entries(params)
+		.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+		.join("&")
+	return authClient.get(`/api/v1/public/key-types${queryString ? `?${queryString}` : ""}`)
+}
+
+/**
+ * Fetch active platforms (for the platform filter select).
+ */
+export const fetchCampaignPlatforms = () => {
+	return authClient.get("/api/v1/platforms/currently")
+}
+
+/**
+ * Fetch the authenticated user's own key requests.
+ */
+export const fetchMyRequests = (params: Record<string, any> = {}) => {
+	const queryString = Object.entries(params)
+		.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+		.join("&")
+	return authClient.get(`/api/v1/key-requests-me${queryString ? `?${queryString}` : ""}`)
+}
+
+/**
+ * Fetch users who have redeemed a specific campaign key.
+ */
+export const fetchRedeemedUsers = (
+	keyId: number,
+	params: Record<string, any> = {},
+	includeMaterials = false,
+) => {
+	const merged = includeMaterials ? { ...params, include: "materials" } : params
+	const queryString = Object.entries(merged)
+		.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+		.join("&")
+	return authClient.get(`/api/v1/public/keys/${keyId}/redeemed-users${queryString ? `?${queryString}` : ""}`)
+}
+
+/**
+ * Request a key for a campaign.
+ */
+export const requestKey = (data: Record<string, any>) => {
+	return authClient.post("/api/v1/public/key-requests", data)
+}
+
+/**
+ * Reveal a previously granted key.
+ */
+export const revealKey = (requestId: number) => {
+	return authClient.get(`/api/v1/public/key-requests/${requestId}/reveal`)
+}
+
+/**
+ * Fetch required actions for a campaign.
+ */
+export const fetchKeyActions = (keyId: number) => {
+	return authClient.get(`/api/v1/public/keys/${keyId}/actions`)
+}
+
+/**
+ * Submit a content material for a key request.
+ */
+export const submitMaterial = (data: Record<string, any>) => {
+	return authClient.post("/api/v1/public/key-materials", data)
+}
+
+/**
+ * Fetch all materials submitted for a key request.
+ */
+export const fetchMaterialsByRequest = (requestId: number) => {
+	return authClient.get(`/api/v1/public/key-materials?filter[key_request_id]=${requestId}&per_page=all`)
+}
+
+/**
+ * Fetch a single key request by ID.
+ */
+export const fetchKeyRequestById = (requestId: number) => {
+	return authClient.get(`/api/v1/public/key-requests/${requestId}`)
+}

package/stores/campaigns.ts

@@ -0,0 +1,161 @@
+import { defineStore } from "pinia"
+import {
+	fetchCampaigns,
+	fetchFeaturedCampaigns,
+	fetchMyRequests,
+	fetchCampaignTypes,
+	fetchCampaignPlatforms,
+	type Campaign,
+	type CampaignType,
+	type Platform,
+} from "../services/campaignService"
+
+interface CampaignListState {
+	data: Campaign[]
+	status: "init" | "pending" | "success" | "error"
+	total: number
+}
+
+interface CampaignTypeState {
+	data: CampaignType[]
+	status: "init" | "pending" | "success" | "error"
+}
+
+interface PlatformState {
+	data: Platform[]
+	status: "init" | "pending" | "success" | "error"
+}
+
+interface MyRequestsState {
+	data: any[]
+	status: "init" | "pending" | "success" | "error"
+}
+
+interface FeaturedCampaignsState {
+	data: Campaign[]
+	status: "init" | "pending" | "success" | "error"
+}
+
+export const useCampaignsStore = defineStore("campaigns-store", {
+	state: () => ({
+		campaigns: {
+			data: [] as Campaign[],
+			status: "init",
+			total: 0,
+		} as CampaignListState,
+
+		featuredCampaigns: {
+			data: [] as Campaign[],
+			status: "init",
+		} as FeaturedCampaignsState,
+
+		myRequests: {
+			data: [] as any[],
+			status: "init",
+		} as MyRequestsState,
+
+		campaignTypes: {
+			data: [] as CampaignType[],
+			status: "init",
+		} as CampaignTypeState,
+
+		platforms: {
+			data: [] as Platform[],
+			status: "init",
+		} as PlatformState,
+	}),
+
+	actions: {
+		async fetchCampaigns(params: Record<string, any> = {}, mgPlatform?: string) {
+			this.campaigns.status = "pending"
+			try {
+				const response = await fetchCampaigns(params, mgPlatform)
+				this.campaigns.data = response.data.data
+				this.campaigns.total = response.data.meta?.pagination?.total ?? response.data.data.length
+				this.campaigns.status = "success"
+				return response.data
+			} catch (error) {
+				this.campaigns.status = "error"
+				throw error
+			}
+		},
+
+		async fetchFeaturedCampaigns(mgPlatform?: string) {
+			this.featuredCampaigns.status = "pending"
+			try {
+				const response = await fetchFeaturedCampaigns(mgPlatform)
+				this.featuredCampaigns.data = response.data.data
+				this.featuredCampaigns.status = "success"
+				return response.data
+			} catch (error) {
+				this.featuredCampaigns.status = "error"
+				throw error
+			}
+		},
+
+		async fetchMyRequests(params: Record<string, any> = {}) {
+			this.myRequests.status = "pending"
+			try {
+				const response = await fetchMyRequests(params)
+				this.myRequests.data = response.data.data || response.data
+				this.myRequests.status = "success"
+				return response.data
+			} catch (error) {
+				this.myRequests.status = "error"
+				throw error
+			}
+		},
+
+		async fetchCampaignTypes() {
+			this.campaignTypes.status = "pending"
+			try {
+				const response = await fetchCampaignTypes({
+					"filter[only_used]": 1,
+					page: 1,
+					per_page: 50,
+					sort: "id",
+					order: "asc",
+				})
+				this.campaignTypes.data = response.data.data || response.data
+				this.campaignTypes.status = "success"
+				return response.data
+			} catch (error) {
+				this.campaignTypes.status = "error"
+				throw error
+			}
+		},
+
+		async fetchCampaignPlatforms() {
+			this.platforms.status = "pending"
+			try {
+				const response = await fetchCampaignPlatforms()
+				this.platforms.data = (response.data.data || response.data).map((p: any) => ({
+					id: p.id,
+					name: p.name,
+					slug: p.slug,
+				}))
+				this.platforms.status = "success"
+				return response.data
+			} catch (error) {
+				this.platforms.status = "error"
+				throw error
+			}
+		},
+
+		resetCampaigns() {
+			this.campaigns.data = []
+			this.campaigns.status = "init"
+			this.campaigns.total = 0
+		},
+	},
+
+	getters: {
+		allCampaigns: (state) => state.campaigns.data,
+		allFeaturedCampaigns: (state) => state.featuredCampaigns.data,
+		allMyRequests: (state) => state.myRequests.data,
+		allCampaignTypes: (state) => state.campaignTypes.data,
+		allPlatforms: (state) => state.platforms.data,
+		isLoading: (state) =>
+			state.campaigns.status === "pending" || state.myRequests.status === "pending",
+	},
+})