Cash Deposits

// Register user identity
async function registerUserIdentity(userData) {
  try {
    const response = await fetch('https://sandbox-api.moveusd.com/v1/identity', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-KEY': process.env.MOVEUSD_API_KEY,
        'X-API-SECRET': process.env.MOVEUSD_API_SECRET
      },
      body: JSON.stringify({
        referenceId: userData.referenceId,
        email: userData.email,
        phone: userData.phone,
        hasExistingIdv: false, // Set to true if user already completed KYC
        idv: {
          // For new users who need to complete IDV
          countryOfResidence: 'US'
        }
      })
    });

    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(`API Error: ${errorData.message}`);
    }

    return await response.json();
  } catch (error) {
    console.error('Failed to register user identity:', error);
    throw error;
  }
}

// Example usage
try {
  const identity = await registerUserIdentity({
    referenceId: 'user123',
    email: '[email protected]',
    phone: '+15555551234'
  });
  
  // Store the identity ID for future deposit requests
  const identityId = identity.id;
  console.log(`User registered with identity ID: ${identityId}`);
  
  // Note: The user will need to complete identity verification if they haven't already
  if (identity.status === 'REQUIRES_IDV') {
    // Provide user with a link to complete verification
    console.log('User needs to complete identity verification');
  }
  
} catch (error) {
  showErrorMessage('Unable to register user identity. Please try again.');
}

// Create a cash deposit request
async function createCashDeposit(identityId, amountUsd) {
  try {
    const response = await fetch('https://sandbox-api.moveusd.com/v1/deposit/cash', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-KEY': process.env.MOVEUSD_API_KEY,
        'X-API-SECRET': process.env.MOVEUSD_API_SECRET
      },
      body: JSON.stringify({
        identityId: identityId,
        amount: {
          amount: 100,
          currency: "USD",
        },
        // other fields as required
      })
    });

    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(`API Error: ${errorData.message}`);
    }

    return await response.json();
  } catch (error) {
    console.error('Failed to create cash deposit:', error);
    throw error;
  }
}

// Example usage
try {
  const depositRequest = await createCashDeposit('id_1234567890', 50); // $50 deposit
  
  // Store the deposit request ID for future reference
  saveDepositRequestId(depositRequest.id);
  
  // Display the barcode to the customer
  displayBarcode(depositRequest.barcode, depositRequest.barcode_number);
  
  // Show deposit details to the customer
  displayDepositDetails({
    amount: depositRequest.amount / 100, // Convert from cents
    fee: depositRequest.fee / 100, // Convert from cents
    expiresAt: new Date(depositRequest.expires_at)
  });
} catch (error) {
  showErrorMessage('Unable to create deposit request. Please try again.');
}

// CashDepositBarcode.jsx
import React, { useState, useEffect } from 'react';
import { format } from 'date-fns';

const CashDepositBarcode = ({ depositRequest }) => {
  const [timeRemaining, setTimeRemaining] = useState('');
  
  // Calculate and update time remaining until expiration
  useEffect(() => {
    const updateTimeRemaining = () => {
      const now = new Date();
      const expiresAt = new Date(depositRequest.expires_at);
      const diffMs = expiresAt - now;
      
      if (diffMs <= 0) {
        setTimeRemaining('Expired');
        return;
      }
      
      const hours = Math.floor(diffMs / (1000 * 60 * 60));
      const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60));
      setTimeRemaining(`${hours}h ${minutes}m`);
    };
    
    updateTimeRemaining();
    const interval = setInterval(updateTimeRemaining, 60000); // Update every minute
    
    return () => clearInterval(interval);
  }, [depositRequest.expires_at]);
  
  return (
    <div className="cash-deposit-barcode">
      <h2>Cash Deposit Barcode</h2>
      
      <div className="barcode-container">
        <img 
          src={depositRequest.barcode} 
          alt="Cash Deposit Barcode" 
          className="barcode-image"
        />
        <div className="barcode-number">
          <span>{depositRequest.barcode_number}</span>
          <p className="barcode-help">If scanning fails, cashier can enter this number</p>
        </div>
      </div>
      
      <div className="deposit-details">
        <div className="detail-row">
          <span>Deposit Amount:</span>
          <span className="amount">${(depositRequest.amount / 100).toFixed(2)}</span>
        </div>
        
        {depositRequest.fee > 0 && (
          <div className="detail-row">
            <span>Service Fee:</span>
            <span className="fee">${(depositRequest.fee / 100).toFixed(2)}</span>
          </div>
        )}
        
        <div className="detail-row">
          <span>Total to Pay:</span>
          <span className="total">${((depositRequest.amount + depositRequest.fee) / 100).toFixed(2)}</span>
        </div>
        
        <div className="detail-row expiration">
          <span>Expires in:</span>
          <span className="time-remaining">{timeRemaining}</span>
          <p className="expiration-date">
            {format(new Date(depositRequest.expires_at), 'MMM d, yyyy h:mm a')}
          </p>
        </div>
      </div>
      
      <div className="instructions">
        <h3>How to Complete Your Deposit</h3>
        <ol>
          <li>Visit any participating retail location (Walmart, 7-Eleven, etc.)</li>
          <li>Show this barcode to the cashier</li>
          <li>Hand the cashier the cash amount shown above</li>
          <li>Keep your receipt until deposit is confirmed</li>
          <li>Your account will be credited within minutes</li>
        </ol>
      </div>
      
      <button className="find-locations-btn" onClick={onFindLocations}>
        Find Nearby Locations
      </button>
    </div>
  );
};

export default CashDepositBarcode;

// Function to find nearby retail locations
async function findNearbyLocations(params) {
  try {
    // Build query string from params
    const queryParams = new URLSearchParams();
    
    if (params.latitude && params.longitude) {
      queryParams.append('latitude', params.latitude);
      queryParams.append('longitude', params.longitude);
    } else if (params.zipCode) {
      queryParams.append('zip_code', params.zipCode);
    } else {
      throw new Error('Either latitude/longitude or zip_code is required');
    }
    
    if (params.radius) queryParams.append('radius', params.radius);
    if (params.limit) queryParams.append('limit', params.limit);
    if (params.retailer) queryParams.append('retailer', params.retailer);
    
    const url = `https://sandbox-api.moveusd.com/v1/deposit/cash/location?${queryParams.toString()}`;
    
    const response = await fetch(url, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
        'X-API-KEY': process.env.MOVEUSD_API_KEY,
        'X-API-SECRET': process.env.MOVEUSD_API_SECRET
      }
    });

    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(`API Error: ${errorData.message}`);
    }

    return await response.json();
  } catch (error) {
    console.error('Failed to find nearby locations:', error);
    throw error;
  }
}

// Example usage with browser geolocation
function showNearbyLocations() {
  if (navigator.geolocation) {
    navigator.geolocation.getCurrentPosition(
      // Success callback
      async (position) => {
        try {
          const locations = await findNearbyLocations({
            latitude: position.coords.latitude,
            longitude: position.coords.longitude,
            radius: 5, // 5 miles
            limit: 10
          });
          
          displayLocationsOnMap(locations.locations);
          displayLocationsList(locations.locations);
        } catch (error) {
          showErrorMessage('Unable to find nearby locations. Please try again.');
        }
      },
      // Error callback
      (error) => {
        console.error('Geolocation error:', error);
        // Fall back to ZIP code entry
        promptForZipCode();
      }
    );
  } else {
    // Browser doesn't support geolocation
    promptForZipCode();
  }
}

// Function to display locations in a list
function displayLocationsList(locations) {
  const listContainer = document.getElementById('locations-list');
  listContainer.innerHTML = '';
  
  if (locations.length === 0) {
    listContainer.innerHTML = '<p>No locations found in your area.</p>';
    return;
  }
  
  locations.forEach(location => {
    const locationElement = document.createElement('div');
    locationElement.className = 'location-item';
    
    locationElement.innerHTML = `
      <h3>${location.retailer_name}</h3>
      <p class="address">
        ${location.address}<br>
        ${location.city}, ${location.state} ${location.zip_code}
      </p>
      <p class="distance">${location.distance.toFixed(1)} miles away</p>
      <p class="hours">${formatHours(location.hours)}</p>
      <button class="directions-btn" onclick="openDirections('${encodeURIComponent(location.address + ', ' + location.city + ', ' + location.state + ' ' + location.zip_code)}')">
        Get Directions
      </button>
    `;
    
    listContainer.appendChild(locationElement);
  });
}

// Helper function to format operating hours
function formatHours(hours) {
  if (!hours) return 'Hours not available';
  
  // Format hours based on your needs
  return hours;
}

// Open directions in maps application/website
function openDirections(address) {
  const mapsUrl = `https://maps.google.com/maps?q=${address}`;
  window.open(mapsUrl, '_blank');
}

// webhook-handler.js
const express = require('express');
const crypto = require('crypto');
const bodyParser = require('body-parser');

const app = express();

// Use raw body parser for webhook signature verification
app.use('/webhooks/moveusd', 
  bodyParser.json({
    verify: (req, res, buf) => {
      req.rawBody = buf.toString();
    }
  })
);

// Verify webhook signature
function verifyWebhookSignature(req) {
  const signature = req.headers['x-moveusd-signature'];
  const webhookSecret = process.env.MOVEUSD_WEBHOOK_SECRET;
  
  if (!signature || !webhookSecret) {
    return false;
  }
  
  const hmac = crypto.createHmac('sha256', webhookSecret);
  const expectedSignature = hmac.update(req.rawBody).digest('hex');
  
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  );
}

// Webhook handler for MoveUSD events
app.post('/webhooks/moveusd', async (req, res) => {
  try {
    // Verify webhook signature
    if (!verifyWebhookSignature(req)) {
      console.error('Invalid webhook signature');
      return res.status(401).send('Invalid signature');
    }
    
    const event = req.body;
    
    // Acknowledge receipt of the webhook immediately
    // This prevents MoveUSD from retrying the webhook
    res.status(200).send('Webhook received');
    
    // Process the event based on type
    switch (event.event) {
      case 'deposit.created':
        await handleDepositCreated(event.data);
        break;
        
      case 'deposit.in_progress':
        await handleDepositInProgress(event.data);
        break;
        
      case 'deposit.completed':
        await handleDepositCompleted(event.data);
        break;
        
      case 'deposit.cancelled':
        await handleDepositCancelled(event.data);
        break;
        
      case 'deposit.expired':
        await handleDepositExpired(event.data);
        break;
        
      case 'deposit.failed':
        await handleDepositFailed(event.data);
        break;
        
      default:
        console.log(`Unhandled event type: ${event.event}`);
    }
  } catch (error) {
    console.error('Error processing webhook:', error);
    // We've already sent a 200 response, so we just log the error
  }
});

// Handler functions for different event types
async function handleDepositCreated(data) {
  console.log('Deposit created:', data.id);
  // Update deposit status in your database
  await updateDepositStatus(data.id, 'PENDING');
}

async function handleDepositInProgress(data) {
  console.log('Deposit in progress:', data.id);
  // Update deposit status in your database
  await updateDepositStatus(data.id, 'IN_PROGRESS');
  
  // Notify the customer that their barcode has been scanned
  await sendCustomerNotification(
    data.identity_id,
    'deposit_in_progress',
    'Your cash deposit is being processed at the retail location.'
  );
}

async function handleDepositCompleted(data) {
  console.log('Deposit completed:', data.id);
  
  try {
    // Update deposit status in your database
    await updateDepositStatus(data.id, 'COMPLETED');
    
    // Credit the customer's account balance
    await creditCustomerAccount(
      data.identity_id,
      data.amount,
      {
        deposit_id: data.id,
        deposit_type: 'CASH',
        retailer: data.retailer
      }
    );
    
    // Notify the customer of successful deposit
    await sendCustomerNotification(
      data.identity_id,
      'deposit_success',
      `Your cash deposit of $${(data.amount / 100).toFixed(2)} has been successfully processed and added to your account.`
    );
    
    // Record the transaction for reporting
    await recordCompletedDeposit(data);
  } catch (error) {
    console.error('Error processing completed deposit:', error);
    // Implement retry or manual review process
    await flagDepositForReview(data.id, error.message);
  }
}

async function handleDepositCancelled(data) {
  console.log('Deposit cancelled:', data.id);
  // Update deposit status in your database
  await updateDepositStatus(data.id, 'CANCELLED');
  
  // Notify the customer
  await sendCustomerNotification(
    data.identity_id,
    'deposit_cancelled',
    'Your cash deposit request has been cancelled.'
  );
}

async function handleDepositExpired(data) {
  console.log('Deposit expired:', data.id);
  // Update deposit status in your database
  await updateDepositStatus(data.id, 'EXPIRED');
  
  // Notify the customer
  await sendCustomerNotification(
    data.identity_id,
    'deposit_expired',
    'Your cash deposit request has expired. Please create a new deposit request if you still wish to deposit cash.'
  );
}

async function handleDepositFailed(data) {
  console.log('Deposit failed:', data.id, data.failure_reason);
  // Update deposit status in your database
  await updateDepositStatus(data.id, 'FAILED', data.failure_reason);
  
  // Notify the customer
  await sendCustomerNotification(
    data.identity_id,
    'deposit_failed',
    `Your cash deposit could not be processed. Reason: ${data.failure_reason}`
  );
  
  // Flag for customer support if needed
  await flagDepositForReview(data.id, data.failure_reason);
}

// Helper functions (implementation depends on your specific app)
async function updateDepositStatus(depositId, status, failureReason = null) {
  // Update deposit record in your database
  // Implementation depends on your database and ORM
}

async function creditCustomerAccount(identityId, amount, metadata) {
  // Add the deposited amount to the customer's account balance
  // Implementation depends on your account management system
}

async function sendCustomerNotification(identityId, type, message) {
  // Send push notification, email, or in-app message to the customer
  // Implementation depends on your notification system
}

async function recordCompletedDeposit(data) {
  // Record the deposit for accounting and reporting purposes
  // Implementation depends on your reporting system
}

async function flagDepositForReview(depositId, reason) {
  // Flag deposit for manual review by customer support
  // Implementation depends on your support workflow
}

// Start the server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Webhook server listening on port ${PORT}`);
});

// Function to cancel a cash deposit request
async function cancelCashDeposit(depositId) {
  try {
    const response = await fetch(`https://sandbox-api.moveusd.com/v1/deposit/cash/${depositId}/cancel`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-KEY': process.env.MOVEUSD_API_KEY,
        'X-API-SECRET': process.env.MOVEUSD_API_SECRET
      }
    });

    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(`API Error: ${errorData.message}`);
    }

    return await response.json();
  } catch (error) {
    console.error('Failed to cancel cash deposit:', error);
    throw error;
  }
}

// Example usage with confirmation dialog
function showCancellationConfirmation(depositId) {
  // Display a confirmation dialog to the user
  if (confirm('Are you sure you want to cancel this deposit request?')) {
    cancelDepositRequest(depositId);
  }
}

async function cancelDepositRequest(depositId) {
  try {
    // Show loading indicator
    showLoadingSpinner();
    
    // Call the API to cancel the deposit
    const result = await cancelCashDeposit(depositId);
    
    // Hide loading indicator
    hideLoadingSpinner();
    
    // Update the UI to show the deposit is cancelled
    updateDepositStatusUI(depositId, 'CANCELLED');
    
    // Show success message
    showSuccessMessage('Your deposit request has been cancelled.');
    
    // Optionally, redirect to another page
    // window.location.href = '/deposits';
  } catch (error) {
    // Hide loading indicator
    hideLoadingSpinner();
    
    // Show error message based on the type of error
    if (error.message.includes('already in progress')) {
      showErrorMessage('This deposit cannot be cancelled because it is already being processed at a retail location.');
    } else if (error.message.includes('already completed')) {
      showErrorMessage('This deposit cannot be cancelled because it has already been completed.');
    } else {
      showErrorMessage('Unable to cancel deposit request. Please try again or contact support.');
    }
  }
}

// UI helper functions
function showLoadingSpinner() {
  // Show loading spinner implementation
}

function hideLoadingSpinner() {
  // Hide loading spinner implementation
}

function updateDepositStatusUI(depositId, status) {
  // Update UI to reflect new deposit status
  const statusElement = document.querySelector(`#deposit-${depositId} .status`);
  if (statusElement) {
    statusElement.textContent = status;
    statusElement.className = `status status-${status.toLowerCase()}`;
  }
  
  // If the deposit is cancelled, update other UI elements
  if (status === 'CANCELLED') {
    // Hide the barcode
    const barcodeElement = document.querySelector(`#deposit-${depositId} .barcode-container`);
    if (barcodeElement) {
      barcodeElement.style.display = 'none';
    }
    
    // Show cancelled message
    const messageElement = document.querySelector(`#deposit-${depositId} .message`);
    if (messageElement) {
      messageElement.textContent = 'This deposit request has been cancelled.';
      messageElement.className = 'message message-cancelled';
    }
    
    // Hide cancel button
    const cancelButton = document.querySelector(`#deposit-${depositId} .cancel-btn`);
    if (cancelButton) {
      cancelButton.style.display = 'none';
    }
    
    // Show create new button
    const newDepositButton = document.querySelector(`#deposit-${depositId} .new-deposit-btn`);
    if (newDepositButton) {
      newDepositButton.style.display = 'block';
    }
  }
}

function showSuccessMessage(message) {
  // Show success message implementation
}

function showErrorMessage(message) {
  // Show error message implementation
}