DataSource.gs

// DataSource.gs - Base data source interface and management
function getDataSourceConfig() {
  return {
    'ga4': {
      name: 'Google Analytics 4',
      authType: 'oauth2',
      scopes: [
        'https://www.googleapis.com/auth/analytics.readonly',
        'https://www.googleapis.com/auth/userinfo.email'
      ],
      baseUrl: 'https://analyticsdata.googleapis.com/v1beta',
      adminUrl: 'https://analyticsadmin.googleapis.com/v1beta',
      icon: '📊',
      color: '#ff6d01'
    },
    'hubspot': {
      name: 'HubSpot',
      authType: 'oauth2',
      scopes: ['crm.objects.contacts.read', 'crm.objects.companies.read', 'crm.objects.deals.read'],
      baseUrl: 'https://api.hubapi.com',
      icon: '🔄',
      color: '#ff7a59'
    },
    'google_ads': {
      name: 'Google Ads',
      authType: 'oauth2',
      scopes: [
        'https://www.googleapis.com/auth/adwords'
      ],
      baseUrl: 'https://googleads.googleapis.com/v14',
      icon: '🎯',
      color: '#4285f4'
    },
    'facebook_ads': {
      name: 'Facebook Ads',
      authType: 'oauth2',
      scopes: ['ads_read', 'ads_management'],
      baseUrl: 'https://graph.facebook.com/v18.0',
      icon: '📘',
      color: '#1877f2'
    },
    'spotify': {
      name: 'Spotify',
      authType: 'oauth2',
      scopes: ['user-read-private', 'user-read-email', 'user-read-playbook-state'],
      baseUrl: 'https://api.spotify.com/v1',
      icon: '🎵',
      color: '#1db954'
    }
  };
}

function getAllDataSourceStatus() {
  try {
    var config = getDataSourceConfig();
    var status = {};
    var sourceIds = Object.keys(config);
    
    for (var i = 0; i < sourceIds.length; i++) {
      var sourceId = sourceIds[i];
      status[sourceId] = {
        connected: isDataSourceConnected(sourceId),
        lastSync: getDataSourceLastSync(sourceId),
        syncCount: getDataSourceUsage(sourceId)
      };
    }
    
    return status;
  } catch (error) {
    Logger.log('Error getting all data source status: ' + error.toString());
    return {};
  }
}

function isDataSourceConnected(dataSourceId) {
  try {
    var key = 'AUTH_' + dataSourceId.toUpperCase() + '_CONNECTED';
    var connected = PropertiesService.getScriptProperties().getProperty(key);
    return connected === 'true';
  } catch (error) {
    Logger.log('Error checking connection for ' + dataSourceId + ': ' + error.toString());
    return false;
  }
}

function setDataSourceConnected(dataSourceId, connected) {
  try {
    var key = 'AUTH_' + dataSourceId.toUpperCase() + '_CONNECTED';
    PropertiesService.getScriptProperties().setProperty(key, connected.toString());
    
    if (connected) {
      setDataSourceLastSync(dataSourceId, new Date().getTime());
    }
    
    return { success: true };
  } catch (error) {
    Logger.log('Error setting connection status for ' + dataSourceId + ': ' + error.toString());
    return { success: false, error: error.toString() };
  }
}

function getDataSourceLastSync(dataSourceId) {
  try {
    var key = 'LAST_SYNC_' + dataSourceId.toUpperCase();
    var timestamp = PropertiesService.getScriptProperties().getProperty(key);
    return timestamp ? parseInt(timestamp) : null;
  } catch (error) {
    Logger.log('Error getting last sync for ' + dataSourceId + ': ' + error.toString());
    return null;
  }
}

function setDataSourceLastSync(dataSourceId, timestamp) {
  try {
    var key = 'LAST_SYNC_' + dataSourceId.toUpperCase();
    PropertiesService.getScriptProperties().setProperty(key, timestamp.toString());
    return { success: true };
  } catch (error) {
    Logger.log('Error setting last sync for ' + dataSourceId + ': ' + error.toString());
    return { success: false, error: error.toString() };
  }
}

function connectDataSource(dataSourceId) {
  try {
    var config = getDataSourceConfig();
    if (!config[dataSourceId]) {
      return {
        success: false,
        error: 'Unknown data source: ' + dataSourceId
      };
    }
    
    var sourceConfig = config[dataSourceId];
    
    // Handle different authentication types
    if (sourceConfig.authType === 'oauth2') {
      return initiateOAuth2Flow(dataSourceId, sourceConfig);
    } else {
      return {
        success: false,
        error: 'Unsupported authentication type: ' + sourceConfig.authType
      };
    }
  } catch (error) {
    Logger.log('Error connecting data source ' + dataSourceId + ': ' + error.toString());
    return {
      success: false,
      error: error.toString()
    };
  }
}

function initiateOAuth2Flow(dataSourceId, sourceConfig) {
  try {
    // For GA4, use existing authentication flow
    if (dataSourceId === 'ga4') {
      var authUrl = getAuthUrl();
      return {
        success: true,
        authUrl: authUrl
      };
    }
    
    // For other data sources, implement specific OAuth flows
    switch (dataSourceId) {
      case 'google_ads':
        return initiateGoogleAdsAuth(sourceConfig);
      case 'facebook_ads':
        return initiateFacebookAdsAuth(sourceConfig);
      case 'spotify':
        return initiateSpotifyAuth(sourceConfig);
      case 'hubspot':
        return initiateHubSpotAuth(sourceConfig);
      default:
        return {
          success: false,
          error: 'Authentication not yet implemented for ' + dataSourceId
        };
    }
  } catch (error) {
    Logger.log('Error initiating OAuth2 flow for ' + dataSourceId + ': ' + error.toString());
    return {
      success: false,
      error: error.toString()
    };
  }
}

function disconnectDataSource(dataSourceId) {
  try {
    // Remove authentication tokens
    var keys = [
      'AUTH_' + dataSourceId.toUpperCase() + '_CONNECTED',
      'AUTH_' + dataSourceId.toUpperCase() + '_TOKEN',
      'AUTH_' + dataSourceId.toUpperCase() + '_REFRESH_TOKEN',
      'AUTH_' + dataSourceId.toUpperCase() + '_EXPIRES'
    ];
    
    var properties = PropertiesService.getScriptProperties();
    for (var i = 0; i < keys.length; i++) {
      properties.deleteProperty(keys[i]);
    }
    
    return { success: true };
  } catch (error) {
    Logger.log('Error disconnecting data source ' + dataSourceId + ': ' + error.toString());
    return {
      success: false,
      error: error.toString()
    };
  }
}

function openDataSourceSidebar(dataSourceId) {
  try {
    setSelectedDataSource(dataSourceId);
    var config = getDataSourceConfig();
    var sourceName = config[dataSourceId] ? config[dataSourceId].name : 'Data Source';
    
    var html = HtmlService.createHtmlOutputFromFile('Sidebar')
      .setTitle(sourceName + ' Connector')
      .setWidth(320);
    SpreadsheetApp.getUi().showSidebar(html);
    
    return { success: true };
  } catch (error) {
    Logger.log('Error opening data source sidebar: ' + error.toString());
    return {
      success: false,
      error: error.toString()
    };
  }
}

function getDataSourceMetadata(dataSourceId) {
  try {
    switch (dataSourceId) {
      case 'ga4':
        return {
          dimensions: getAvailableDimensions(),
          metrics: getAvailableMetrics(),
          properties: []
        };
      case 'google_ads':
        return getGoogleAdsMetadata();
      case 'facebook_ads':
        return getFacebookAdsMetadata();
      case 'spotify':
        return getSpotifyMetadata();
      case 'hubspot':
        return getHubSpotMetadata();
      default:
        return {
          dimensions: [],
          metrics: [],
          properties: []
        };
    }
  } catch (error) {
    Logger.log('Error getting metadata for ' + dataSourceId + ': ' + error.toString());
    return {
      dimensions: [],
      metrics: [],
      properties: []
    };
  }
}

// Placeholder implementations for other data sources
function initiateGoogleAdsAuth(sourceConfig) {
  // Full implementation is now in GoogleAds.gs
  return initiateGoogleAdsAuth(sourceConfig);
}

function initiateFacebookAdsAuth(sourceConfig) {
  return {
    success: false,
    error: 'Facebook Ads authentication coming soon'
  };
}

function initiateSpotifyAuth(sourceConfig) {
  return {
    success: false,
    error: 'Spotify authentication coming soon'
  };
}

function initiateHubSpotAuth(sourceConfig) {
  // Full implementation is now in HubSpot.gs
  return initiateHubSpotAuth(sourceConfig);
}

function getHubSpotMetadata() {
  // Full implementation is now in HubSpot.gs
  return getHubSpotMetadata();
}

function getGoogleAdsMetadata() {
  // Full implementation is now in GoogleAds.gs
  return getGoogleAdsMetadata();
}

function getFacebookAdsMetadata() {
  return {
    dimensions: [
      { name: 'date_start', displayName: 'Date Start', category: 'Time', description: 'Start date' },
      { name: 'campaign_name', displayName: 'Campaign Name', category: 'Campaign', description: 'Campaign name' },
      { name: 'adset_name', displayName: 'Ad Set Name', category: 'Ad Set', description: 'Ad set name' }
    ],
    metrics: [
      { name: 'impressions', displayName: 'Impressions', category: 'Performance', description: 'Number of impressions' },
      { name: 'clicks', displayName: 'Clicks', category: 'Performance', description: 'Number of clicks' },
      { name: 'spend', displayName: 'Spend', category: 'Cost', description: 'Amount spent' },
      { name: 'actions', displayName: 'Actions', category: 'Actions', description: 'Number of actions' }
    ],
    properties: []
  };
}

function getSpotifyMetadata() {
  return {
    dimensions: [
      { name: 'date', displayName: 'Date', category: 'Time', description: 'Date' },
      { name: 'track_name', displayName: 'Track Name', category: 'Track', description: 'Track name' },
      { name: 'artist_name', displayName: 'Artist Name', category: 'Artist', description: 'Artist name' }
    ],
    metrics: [
      { name: 'streams', displayName: 'Streams', category: 'Performance', description: 'Number of streams' },
      { name: 'listeners', displayName: 'Listeners', category: 'Performance', description: 'Number of listeners' },
      { name: 'followers', displayName: 'Followers', category: 'Audience', description: 'Number of followers' }
    ],
    properties: []
  };
}

function getHubSpotMetadata() {
  return {
    dimensions: [
      { name: 'createdate', displayName: 'Create Date', category: 'Time', description: 'Date created' },
      { name: 'firstname', displayName: 'First Name', category: 'Contact', description: 'First name' },
      { name: 'lastname', displayName: 'Last Name', category: 'Contact', description: 'Last name' },
      { name: 'company', displayName: 'Company', category: 'Company', description: 'Company name' }
    ],
    metrics: [
      { name: 'num_contacted_notes', displayName: 'Contact Notes', category: 'Activity', description: 'Number of contact notes' },
      { name: 'num_conversion_events', displayName: 'Conversion Events', category: 'Conversions', description: 'Number of conversion events' },
      { name: 'hs_analytics_num_visits', displayName: 'Visits', category: 'Analytics', description: 'Number of visits' }
    ],
    properties: []
  };
}

function executeDataSourceReport(dataSourceId, config) {
  try {
    switch (dataSourceId) {
      case 'ga4':
        return executeGA4Report(config);
      case 'google_ads':
        return executeGoogleAdsReport(config);
      case 'facebook_ads':
        return executeFacebookAdsReport(config);
      case 'spotify':
        return executeSpotifyReport(config);
      case 'hubspot':
        return executeHubSpotReport(config);
      default:
        return {
          success: false,
          error: 'Report execution not implemented for ' + dataSourceId
        };
    }
  } catch (error) {
    Logger.log('Error executing report for ' + dataSourceId + ': ' + error.toString());
    return {
      success: false,
      error: error.toString()
    };
  }
}

function executeGA4Report(config) {
  var dateRange = config.dateRangeComputed || config.dateRange;
  return fetchGA4Report(
    config.propertyId,
    dateRange.start,
    dateRange.end,
    config.dimensions.join(','),
    config.metrics.join(','),
    config.limit
  );
}

// Placeholder implementations for other data source reports
function executeGoogleAdsReport(config) {
  // Full implementation is now in GoogleAds.gs
  return executeGoogleAdsReport(config);
}

function executeFacebookAdsReport(config) {
  return {
    success: false,
    error: 'Facebook Ads reports coming soon'
  };
}

function executeSpotifyReport(config) {
  return {
    success: false,
    error: 'Spotify reports coming soon'
  };
}

function executeHubSpotReport(config) {
  // Full implementation is now in HubSpot.gs
  return executeHubSpotReport(config);
}

function checkDataSourceAuthentication(dataSourceId) {
  try {
    if (dataSourceId === 'ga4') {
      return {
        isConnected: isAuthenticated(),
        dataSourceId: dataSourceId
      };
    }
    
    if (dataSourceId === 'google_ads') {
      return {
        isConnected: isGoogleAdsAuthenticated(),
        dataSourceId: dataSourceId
      };
    }
    
    if (dataSourceId === 'hubspot') {
      return {
        isConnected: isHubSpotAuthenticated(),
        dataSourceId: dataSourceId
      };
    }
    
    return {
      isConnected: isDataSourceConnected(dataSourceId),
      dataSourceId: dataSourceId
    };
  } catch (error) {
    Logger.log('Error checking authentication for ' + dataSourceId + ': ' + error.toString());
    return {
      isConnected: false,
      dataSourceId: dataSourceId,
      error: error.toString()
    };
  }
}