Examples
========

This section provides practical examples of how to use the Taglife API for common use cases.

Authentication Examples
----------------------

Basic Authentication
~~~~~~~~~~~~~~~~~~~

**JavaScript/Node.js:**

.. code-block:: javascript

   const axios = require('axios');

   // Login and get token
   async function login(username, password) {
     try {
       const response = await axios.post('https://api.taglife.com/api/auth/token/', {
         username: username,
         password: password
       });
       
       return response.data.token;
     } catch (error) {
       console.error('Login failed:', error.response.data);
       throw error;
     }
   }

   // Use token for authenticated requests
   async function getCampaigns(token) {
     try {
       const response = await axios.get('https://api.taglife.com/api/get/campaigns/', {
         headers: {
           'Authorization': `JWT ${token}`,
           'Content-Type': 'application/json'
         }
       });
       
       return response.data;
     } catch (error) {
       console.error('Failed to get campaigns:', error.response.data);
       throw error;
     }
   }

   // Example usage
   async function main() {
     try {
       const token = await login('your_username', 'your_password');
       const campaigns = await getCampaigns(token);
       console.log('Available campaigns:', campaigns);
     } catch (error) {
       console.error('Error:', error.message);
     }
   }

**Python:**

.. code-block:: python

   import requests
   import json

   class TaglifeAPI:
       def __init__(self, base_url='https://api.taglife.com'):
           self.base_url = base_url
           self.token = None

       def login(self, username, password):
           """Login and get JWT token"""
           url = f"{self.base_url}/api/auth/token/"
           data = {
               'username': username,
               'password': password
           }
           
           response = requests.post(url, json=data)
           response.raise_for_status()
           
           result = response.json()
           self.token = result['token']
           return result

       def get_headers(self):
           """Get headers with authentication token"""
           return {
               'Authorization': f'JWT {self.token}',
               'Content-Type': 'application/json'
           }

       def get_campaigns(self):
           """Get available campaigns"""
           url = f"{self.base_url}/api/get/campaigns/"
           response = requests.get(url, headers=self.get_headers())
           response.raise_for_status()
           return response.json()

   # Example usage
   api = TaglifeAPI()
   try:
       # Login
       result = api.login('your_username', 'your_password')
       print(f"Logged in as: {result['user']['username']}")
       
       # Get campaigns
       campaigns = api.get_campaigns()
       print(f"Found {len(campaigns)} campaigns")
       
   except requests.exceptions.RequestException as e:
       print(f"API Error: {e}")

**cURL:**

.. code-block:: bash

   # Login and get token
   TOKEN=$(curl -s -X POST https://api.taglife.com/api/auth/token/ \
     -H "Content-Type: application/json" \
     -d '{"username": "your_username", "password": "your_password"}' \
     | jq -r '.token')

   echo "Token: $TOKEN"

   # Use token to get campaigns
   curl -X GET https://api.taglife.com/api/get/campaigns/ \
     -H "Authorization: JWT $TOKEN" \
     -H "Content-Type: application/json"

Social Authentication
~~~~~~~~~~~~~~~~~~~~

**Facebook Authentication:**

.. code-block:: javascript

   // After getting Facebook access token from Facebook SDK
   async function authenticateWithFacebook(facebookAccessToken) {
     try {
       const response = await axios.post('https://api.taglife.com/api/auth/facebook/', {
         access_token: facebookAccessToken
       });
       
       return response.data;
     } catch (error) {
       console.error('Facebook authentication failed:', error.response.data);
       throw error;
     }
   }

**Instagram Authentication:**

.. code-block:: python

   def authenticate_with_instagram(instagram_access_token):
       """Authenticate using Instagram access token"""
       url = f"{self.base_url}/api/auth/instagram/"
       data = {
           'access_token': instagram_access_token
       }
       
       response = requests.post(url, json=data)
       response.raise_for_status()
       return response.json()

Campaign Management Examples
---------------------------

Getting Available Campaigns
~~~~~~~~~~~~~~~~~~~~~~~~~~

**JavaScript:**

.. code-block:: javascript

   async function getAvailableCampaigns(token) {
     try {
       const response = await axios.get('https://api.taglife.com/api/get/campaigns/', {
         headers: {
           'Authorization': `JWT ${token}`,
           'Content-Type': 'application/json'
         },
         params: {
           status: 'active',
           networks: 'instagram,facebook',
           categories: 'fashion,beauty'
         }
       });
       
       return response.data;
     } catch (error) {
       console.error('Failed to get campaigns:', error.response.data);
       throw error;
     }
   }

**Python:**

.. code-block:: python

   def get_available_campaigns(self, status='active', networks=None, categories=None):
       """Get available campaigns with filters"""
       url = f"{self.base_url}/api/get/campaigns/"
       params = {'status': status}
       
       if networks:
           params['networks'] = ','.join(networks)
       if categories:
           params['categories'] = ','.join(categories)
       
       response = requests.get(url, headers=self.get_headers(), params=params)
       response.raise_for_status()
       return response.json()

Joining a Campaign
~~~~~~~~~~~~~~~~~

**JavaScript:**

.. code-block:: javascript

   async function joinCampaign(token, campaignId) {
     try {
       const response = await axios.post(`https://api.taglife.com/api/campaigns/${campaignId}/join/`, {}, {
         headers: {
           'Authorization': `JWT ${token}`,
           'Content-Type': 'application/json'
         }
       });
       
       return response.data;
     } catch (error) {
       console.error('Failed to join campaign:', error.response.data);
       throw error;
     }
   }

**Python:**

.. code-block:: python

   def join_campaign(self, campaign_id):
       """Join a campaign"""
       url = f"{self.base_url}/api/campaigns/{campaign_id}/join/"
       response = requests.post(url, headers=self.get_headers())
       response.raise_for_status()
       return response.json()

Completing a Task
~~~~~~~~~~~~~~~~

**JavaScript:**

.. code-block:: javascript

   async function completeTask(token, taskId, submissionData) {
     try {
       const formData = new FormData();
       formData.append('post_url', submissionData.postUrl);
       formData.append('reach', submissionData.reach);
       formData.append('engagement', submissionData.engagement);
       
       // Add screenshots
       submissionData.screenshots.forEach((screenshot, index) => {
         formData.append(`screenshots`, screenshot);
       });
       
       const response = await axios.post(`https://api.taglife.com/api/tasks/${taskId}/complete/`, formData, {
         headers: {
           'Authorization': `JWT ${token}`,
           'Content-Type': 'multipart/form-data'
         }
       });
       
       return response.data;
     } catch (error) {
       console.error('Failed to complete task:', error.response.data);
       throw error;
     }
   }

**Python:**

.. code-block:: python

   def complete_task(self, task_id, post_url, reach, engagement, screenshots):
       """Complete a task with submission"""
       url = f"{self.base_url}/api/tasks/{task_id}/complete/"
       
       data = {
           'post_url': post_url,
           'reach': reach,
           'engagement': engagement
       }
       
       files = []
       for screenshot in screenshots:
           files.append(('screenshots', screenshot))
       
       response = requests.post(url, headers=self.get_headers(), data=data, files=files)
       response.raise_for_status()
       return response.json()

Social Network Management Examples
---------------------------------

Connecting Social Networks
~~~~~~~~~~~~~~~~~~~~~~~~~

**Instagram Connection:**

.. code-block:: javascript

   async function connectInstagram(token, instagramData) {
     try {
       const response = await axios.post('https://api.taglife.com/api/connect/instagram/', {
         network_id: instagramData.username,
         network_url: instagramData.profileUrl,
         followers: instagramData.followers,
         category: instagramData.category,
         engagement_rate: instagramData.engagementRate
       }, {
         headers: {
           'Authorization': `JWT ${token}`,
           'Content-Type': 'application/json'
         }
       });
       
       return response.data;
     } catch (error) {
       console.error('Failed to connect Instagram:', error.response.data);
       throw error;
     }
   }

**Facebook Page Connection:**

.. code-block:: python

   def connect_facebook_page(self, page_id, page_name, page_url, followers, category):
       """Connect a Facebook page"""
       url = f"{self.base_url}/api/connect/facebook/pages/"
       data = {
           'page_id': page_id,
           'page_name': page_name,
           'page_url': page_url,
           'followers': followers,
           'category': category
       }
       
       response = requests.post(url, headers=self.get_headers(), json=data)
       response.raise_for_status()
       return response.json()

Getting Social Networks
~~~~~~~~~~~~~~~~~~~~~~

**JavaScript:**

.. code-block:: javascript

   async function getSocialNetworks(token) {
     try {
       const response = await axios.get('https://api.taglife.com/api/connect/networks/', {
         headers: {
           'Authorization': `JWT ${token}`,
           'Content-Type': 'application/json'
         }
       });
       
       return response.data;
     } catch (error) {
       console.error('Failed to get social networks:', error.response.data);
       throw error;
     }
   }

**Python:**

.. code-block:: python

   def get_social_networks(self):
       """Get user's connected social networks"""
       url = f"{self.base_url}/api/connect/networks/"
       response = requests.get(url, headers=self.get_headers())
       response.raise_for_status()
       return response.json()

Payment Management Examples
--------------------------

Getting Balance
~~~~~~~~~~~~~~

**JavaScript:**

.. code-block:: javascript

   async function getBalance(token) {
     try {
       const response = await axios.get('https://api.taglife.com/api/payments/balance/', {
         headers: {
           'Authorization': `JWT ${token}`,
           'Content-Type': 'application/json'
         }
       });
       
       return response.data;
     } catch (error) {
       console.error('Failed to get balance:', error.response.data);
       throw error;
     }
   }

**Python:**

.. code-block:: python

   def get_balance(self):
       """Get user's current balance"""
       url = f"{self.base_url}/api/payments/balance/"
       response = requests.get(url, headers=self.get_headers())
       response.raise_for_status()
       return response.json()

Requesting Payout
~~~~~~~~~~~~~~~~

**JavaScript:**

.. code-block:: javascript

   async function requestPayout(token, amount, method, paymentDetails) {
     try {
       const response = await axios.post('https://api.taglife.com/api/payments/payouts/', {
         amount: amount,
         method: method,
         bank_account: paymentDetails.bankAccount,
         paypal_email: paymentDetails.paypalEmail
       }, {
         headers: {
           'Authorization': `JWT ${token}`,
           'Content-Type': 'application/json'
         }
       });
       
       return response.data;
     } catch (error) {
       console.error('Failed to request payout:', error.response.data);
       throw error;
     }
   }

**Python:**

.. code-block:: python

   def request_payout(self, amount, method, bank_account_id=None, paypal_email=None):
       """Request a payout"""
       url = f"{self.base_url}/api/payments/payouts/"
       data = {
           'amount': amount,
           'method': method
       }
       
       if bank_account_id:
           data['bank_account'] = bank_account_id
       if paypal_email:
           data['paypal_email'] = paypal_email
       
       response = requests.post(url, headers=self.get_headers(), json=data)
       response.raise_for_status()
       return response.json()

Adding Bank Account
~~~~~~~~~~~~~~~~~~

**JavaScript:**

.. code-block:: javascript

   async function addBankAccount(token, bankData) {
     try {
       const response = await axios.post('https://api.taglife.com/api/payments/bank-accounts/', {
         bank_name: bankData.bankName,
         account_number: bankData.accountNumber,
         routing_number: bankData.routingNumber,
         account_type: bankData.accountType,
         account_holder_name: bankData.accountHolderName
       }, {
         headers: {
           'Authorization': `JWT ${token}`,
           'Content-Type': 'application/json'
         }
       });
       
       return response.data;
     } catch (error) {
       console.error('Failed to add bank account:', error.response.data);
       throw error;
     }
   }

**Python:**

.. code-block:: python

   def add_bank_account(self, bank_name, account_number, routing_number, account_type, account_holder_name):
       """Add a bank account for payouts"""
       url = f"{self.base_url}/api/payments/bank-accounts/"
       data = {
           'bank_name': bank_name,
           'account_number': account_number,
           'routing_number': routing_number,
           'account_type': account_type,
           'account_holder_name': account_holder_name
       }
       
       response = requests.post(url, headers=self.get_headers(), json=data)
       response.raise_for_status()
       return response.json()

User Management Examples
------------------------

Updating Profile
~~~~~~~~~~~~~~~

**JavaScript:**

.. code-block:: javascript

   async function updateProfile(token, profileData) {
     try {
       const response = await axios.patch('https://api.taglife.com/api/users/profile/', {
         first_name: profileData.firstName,
         last_name: profileData.lastName,
         country: profileData.country,
         city: profileData.city,
         language: profileData.language
       }, {
         headers: {
           'Authorization': `JWT ${token}`,
           'Content-Type': 'application/json'
         }
       });
       
       return response.data;
     } catch (error) {
       console.error('Failed to update profile:', error.response.data);
       throw error;
     }
   }

**Python:**

.. code-block:: python

   def update_profile(self, first_name=None, last_name=None, country=None, city=None, language=None):
       """Update user profile"""
       url = f"{self.base_url}/api/users/profile/"
       data = {}
       
       if first_name:
           data['first_name'] = first_name
       if last_name:
           data['last_name'] = last_name
       if country:
           data['country'] = country
       if city:
           data['city'] = city
       if language:
           data['language'] = language
       
       response = requests.patch(url, headers=self.get_headers(), json=data)
       response.raise_for_status()
       return response.json()

Updating Preferences
~~~~~~~~~~~~~~~~~~~

**JavaScript:**

.. code-block:: javascript

   async function updatePreferences(token, preferences) {
     try {
       const response = await axios.patch('https://api.taglife.com/api/users/preferences/', {
         categories: preferences.categories,
         networks: preferences.networks,
         notifications: preferences.notifications
       }, {
         headers: {
           'Authorization': `JWT ${token}`,
           'Content-Type': 'application/json'
         }
       });
       
       return response.data;
     } catch (error) {
       console.error('Failed to update preferences:', error.response.data);
       throw error;
     }
   }

**Python:**

.. code-block:: python

   def update_preferences(self, categories=None, networks=None, notifications=None):
       """Update user preferences"""
       url = f"{self.base_url}/api/users/preferences/"
       data = {}
       
       if categories:
           data['categories'] = categories
       if networks:
           data['networks'] = networks
       if notifications:
           data['notifications'] = notifications
       
       response = requests.patch(url, headers=self.get_headers(), json=data)
       response.raise_for_status()
       return response.json()

Error Handling Examples
----------------------

**JavaScript:**

.. code-block:: javascript

   class TaglifeAPIError extends Error {
     constructor(message, status, code, details) {
       super(message);
       this.name = 'TaglifeAPIError';
       this.status = status;
       this.code = code;
       this.details = details;
     }
   }

   async function handleAPIRequest(requestFunction) {
     try {
       return await requestFunction();
     } catch (error) {
       if (error.response) {
         const { status, data } = error.response;
         
         switch (status) {
           case 400:
             throw new TaglifeAPIError('Bad Request', status, data.error, data.details);
           case 401:
             throw new TaglifeAPIError('Unauthorized', status, data.error, data.details);
           case 403:
             throw new TaglifeAPIError('Forbidden', status, data.error, data.details);
           case 404:
             throw new TaglifeAPIError('Not Found', status, data.error, data.details);
           case 429:
             throw new TaglifeAPIError('Rate Limited', status, data.error, data.details);
           case 500:
             throw new TaglifeAPIError('Server Error', status, data.error, data.details);
           default:
             throw new TaglifeAPIError('Unknown Error', status, data.error, data.details);
         }
       } else {
         throw new TaglifeAPIError('Network Error', 0, 'NETWORK_ERROR', null);
       }
     }
   }

**Python:**

.. code-block:: python

   class TaglifeAPIError(Exception):
       def __init__(self, message, status_code, error_code, details):
           super().__init__(message)
           self.status_code = status_code
           self.error_code = error_code
           self.details = details

   def handle_api_request(self, request_func):
       """Handle API requests with proper error handling"""
       try:
           return request_func()
       except requests.exceptions.RequestException as e:
           if hasattr(e, 'response') and e.response is not None:
               status_code = e.response.status_code
               try:
                   data = e.response.json()
                   error_code = data.get('error', 'UNKNOWN_ERROR')
                   details = data.get('details', {})
               except ValueError:
                   error_code = 'INVALID_RESPONSE'
                   details = {}
               
               error_messages = {
                   400: 'Bad Request',
                   401: 'Unauthorized',
                   403: 'Forbidden',
                   404: 'Not Found',
                   429: 'Rate Limited',
                   500: 'Server Error'
               }
               
               message = error_messages.get(status_code, 'Unknown Error')
               raise TaglifeAPIError(message, status_code, error_code, details)
           else:
               raise TaglifeAPIError('Network Error', 0, 'NETWORK_ERROR', None)

Complete Integration Example
---------------------------

Here's a complete example of how to integrate with the Taglife API:

**JavaScript/Node.js:**

.. code-block:: javascript

   const axios = require('axios');

   class TaglifeAPI {
     constructor(baseURL = 'https://api.taglife.com') {
       this.baseURL = baseURL;
       this.token = null;
     }

     async login(username, password) {
       try {
         const response = await axios.post(`${this.baseURL}/api/auth/token/`, {
           username,
           password
         });
         
         this.token = response.data.token;
         return response.data;
       } catch (error) {
         throw this.handleError(error);
       }
     }

     async getCampaigns(filters = {}) {
       try {
         const response = await axios.get(`${this.baseURL}/api/get/campaigns/`, {
           headers: this.getHeaders(),
           params: filters
         });
         
         return response.data;
       } catch (error) {
         throw this.handleError(error);
       }
     }

     async joinCampaign(campaignId) {
       try {
         const response = await axios.post(`${this.baseURL}/api/campaigns/${campaignId}/join/`, {}, {
           headers: this.getHeaders()
         });
         
         return response.data;
       } catch (error) {
         throw this.handleError(error);
       }
     }

     async completeTask(taskId, submission) {
       try {
         const formData = new FormData();
         Object.keys(submission).forEach(key => {
           formData.append(key, submission[key]);
         });
         
         const response = await axios.post(`${this.baseURL}/api/tasks/${taskId}/complete/`, formData, {
           headers: {
             ...this.getHeaders(),
             'Content-Type': 'multipart/form-data'
           }
         });
         
         return response.data;
       } catch (error) {
         throw this.handleError(error);
       }
     }

     async getBalance() {
       try {
         const response = await axios.get(`${this.baseURL}/api/payments/balance/`, {
           headers: this.getHeaders()
         });
         
         return response.data;
       } catch (error) {
         throw this.handleError(error);
       }
     }

     getHeaders() {
       return {
         'Authorization': `JWT ${this.token}`,
         'Content-Type': 'application/json'
       };
     }

     handleError(error) {
       if (error.response) {
         const { status, data } = error.response;
         return new Error(`API Error ${status}: ${data.message || data.error || 'Unknown error'}`);
       }
       return new Error('Network error');
     }
   }

   // Usage example
   async function main() {
     const api = new TaglifeAPI();
     
     try {
       // Login
       await api.login('your_username', 'your_password');
       console.log('Logged in successfully');
       
       // Get available campaigns
       const campaigns = await api.getCampaigns({
         status: 'active',
         networks: 'instagram,facebook'
       });
       console.log(`Found ${campaigns.length} campaigns`);
       
       // Join a campaign
       if (campaigns.length > 0) {
         const campaign = campaigns[0];
         await api.joinCampaign(campaign.id);
         console.log(`Joined campaign: ${campaign.name}`);
       }
       
       // Check balance
       const balance = await api.getBalance();
       console.log(`Current balance: $${balance.available_balance}`);
       
     } catch (error) {
       console.error('Error:', error.message);
     }
   }

   main();

**Python:**

.. code-block:: python

   import requests
   import json
   from typing import Dict, List, Optional

   class TaglifeAPI:
       def __init__(self, base_url: str = 'https://api.taglife.com'):
           self.base_url = base_url
           self.token: Optional[str] = None

       def login(self, username: str, password: str) -> Dict:
           """Login and get JWT token"""
           url = f"{self.base_url}/api/auth/token/"
           data = {'username': username, 'password': password}
           
           response = requests.post(url, json=data)
           response.raise_for_status()
           
           result = response.json()
           self.token = result['token']
           return result

       def get_campaigns(self, filters: Dict = None) -> List[Dict]:
           """Get available campaigns"""
           url = f"{self.base_url}/api/get/campaigns/"
           params = filters or {}
           
           response = requests.get(url, headers=self.get_headers(), params=params)
           response.raise_for_status()
           return response.json()

       def join_campaign(self, campaign_id: int) -> Dict:
           """Join a campaign"""
           url = f"{self.base_url}/api/campaigns/{campaign_id}/join/"
           
           response = requests.post(url, headers=self.get_headers())
           response.raise_for_status()
           return response.json()

       def complete_task(self, task_id: int, submission: Dict) -> Dict:
           """Complete a task"""
           url = f"{self.base_url}/api/tasks/{task_id}/complete/"
           
           response = requests.post(url, headers=self.get_headers(), json=submission)
           response.raise_for_status()
           return response.json()

       def get_balance(self) -> Dict:
           """Get user balance"""
           url = f"{self.base_url}/api/payments/balance/"
           
           response = requests.get(url, headers=self.get_headers())
           response.raise_for_status()
           return response.json()

       def get_headers(self) -> Dict:
           """Get headers with authentication token"""
           return {
               'Authorization': f'JWT {self.token}',
               'Content-Type': 'application/json'
           }

   # Usage example
   def main():
       api = TaglifeAPI()
       
       try:
           # Login
           result = api.login('your_username', 'your_password')
           print(f"Logged in as: {result['user']['username']}")
           
           # Get available campaigns
           campaigns = api.get_campaigns({
               'status': 'active',
               'networks': 'instagram,facebook'
           })
           print(f"Found {len(campaigns)} campaigns")
           
           # Join a campaign
           if campaigns:
               campaign = campaigns[0]
               result = api.join_campaign(campaign['id'])
               print(f"Joined campaign: {campaign['name']}")
           
           # Check balance
           balance = api.get_balance()
           print(f"Current balance: ${balance['available_balance']}")
           
       except requests.exceptions.RequestException as e:
           print(f"API Error: {e}")
       except Exception as e:
           print(f"Error: {e}")

   if __name__ == "__main__":
       main()