⚙ Configuración — 2 scripts obligatorios

Por qué 2 scripts: AdsApp solo existe dentro de Google Ads y no puede desplegarse como App Web. Se necesita un puente.

Script 1 — Apps Script (script.google.com) = el endpoint web:
Crea un proyecto nuevo → pega el código → Desplegar → App Web → Ejecutar como: Yo → Acceso: Cualquier persona → copia la URL al campo Endpoint arriba.

Script 2 — Google Ads Script (ads.google.com → Herramientas → Scripts):
Crea un nuevo script → pega el 2° bloque → actualiza ENDPOINT con la URL del Script 1 → ejecútalo manualmente una vez y programa diario.

Tráfico web — GA4 (opcional): en el editor del Script 1 → menú Servicios (+) → añade Google Analytics Data API → pega el ID numérico de tu propiedad GA4 en GA4_PROPERTY (analytics.google.com → Administrar → Detalles de la propiedad) → Desplegar → Administrar implementaciones → ✏ → Nueva versión. El panel "Tráfico del sitio web" se llena solo.

// ── Script 1: Apps Script (script.google.com) ──────────────────────────
// Proyecto nuevo → pega este código → Desplegar → App Web
// Ejecutar como: Yo  |  Quién tiene acceso: Cualquier persona

var SECRET = 'thelab2025';

// ── Tráfico web (GA4) — opcional ──
// 1) En el editor: menú izquierdo → Servicios (+) → "Google Analytics Data API" → Añadir.
// 2) Pega aquí el ID NUMÉRICO de la propiedad GA4 (analytics.google.com → Administrar → Detalles de la propiedad).
var GA4_PROPERTY = '';

function doPost(e) {
  try {
    var body = JSON.parse(e.postData.contents);
    if (body.secret !== SECRET) return json({ok:false, error:'No autorizado'});

    if (body.type === 'mutation') {
      var muts = JSON.parse(PropertiesService.getScriptProperties().getProperty('ads_mutations') || '[]');
      muts.push({op:body.op, id:body.id||'', data:body.data, timestamp:body.timestamp||new Date().toISOString(), status:'pending'});
      PropertiesService.getScriptProperties().setProperty('ads_mutations', JSON.stringify(muts));
      return json({ok:true, queued:true, pending:muts.filter(function(m){return m.status==='pending';}).length});
    }

    if (body.type === 'update_mutations') {
      PropertiesService.getScriptProperties().setProperty('ads_mutations', JSON.stringify(body.mutations));
      return json({ok:true});
    }

    PropertiesService.getScriptProperties().setProperty('ads_cache', JSON.stringify({
      guardado: new Date().toISOString(),
      gasto: body.gasto, impresiones: body.impresiones, clics: body.clics,
      conversiones: body.conversiones, valor_conversion: body.valor_conversion,
      campanas: body.campanas, terminos: body.terminos || [], keywords: body.keywords || []
    }));
    return json({ok:true, saved:true});
  } catch(err) { return json({ok:false, error:err.message}); }
}

function doGet(e) {
  try {
    var action = e && e.parameter && e.parameter.action;
    if (action === 'mutations') {
      var muts = JSON.parse(PropertiesService.getScriptProperties().getProperty('ads_mutations') || '[]');
      return json({ok:true, mutations:muts});
    }
    if (action === 'web') {
      return json(webStats(parseInt((e && e.parameter && e.parameter.days) || 30)));
    }
    var days = parseInt((e && e.parameter && e.parameter.days) || 30);
    var raw = PropertiesService.getScriptProperties().getProperty('ads_cache');
    if (!raw) return json({ok:false, error:'Sin datos aún — ejecuta el Script 2 en Google Ads primero'});
    var data = JSON.parse(raw);
    data.ok = true;
    data.periodo = days + ' días';
    return json(data);
  } catch(err) { return json({ok:false, error:err.message}); }
}

// Tráfico del sitio desde GA4 (Analytics Data API). Cachea 30 min; tiempo real 60 s.
function webStats(days) {
  try {
    if (!GA4_PROPERTY) return {ok:false, web:true, error:'no-config'};
    if (typeof AnalyticsData === 'undefined') return {ok:false, web:true, error:'no-service'};
    var cache = CacheService.getScriptCache();
    var hit = cache.get('web_stats_' + days);
    var out = hit ? JSON.parse(hit) : null;
    if (!out) {
      var prop = 'properties/' + GA4_PROPERTY;
      var rango = [{startDate: days + 'daysAgo', endDate: 'today'}];
      var res = AnalyticsData.Properties.batchRunReports({requests: [
        {dateRanges: rango, metrics: [{name:'activeUsers'},{name:'newUsers'},{name:'sessions'},{name:'screenPageViews'},{name:'averageSessionDuration'}]},
        {dateRanges: rango, dimensions: [{name:'date'}], metrics: [{name:'activeUsers'},{name:'sessions'}], orderBys: [{dimension:{dimensionName:'date'}}], limit: 120},
        {dateRanges: rango, dimensions: [{name:'sessionDefaultChannelGroup'}], metrics: [{name:'activeUsers'},{name:'sessions'}], orderBys: [{metric:{metricName:'activeUsers'}, desc:true}], limit: 8},
        {dateRanges: rango, dimensions: [{name:'pagePath'}], metrics: [{name:'screenPageViews'},{name:'activeUsers'}], orderBys: [{metric:{metricName:'screenPageViews'}, desc:true}], limit: 10}
      ]}, prop);
      var reps = res.reports || [];
      var filas = function(rep){ return (rep && rep.rows) || []; };
      var mv = function(row, i){ return Number((row.metricValues && row.metricValues[i] && row.metricValues[i].value) || 0); };
      var dv = function(row, i){ return (row.dimensionValues && row.dimensionValues[i] && row.dimensionValues[i].value) || ''; };
      var tot = filas(reps[0])[0] || {};
      out = {
        ok: true, web: true,
        usuarios: mv(tot,0), nuevos: mv(tot,1), sesiones: mv(tot,2), vistas: mv(tot,3), duracion: mv(tot,4),
        dias: filas(reps[1]).map(function(r){ return {fecha: dv(r,0), usuarios: mv(r,0), sesiones: mv(r,1)}; }),
        canales: filas(reps[2]).map(function(r){ return {canal: dv(r,0), usuarios: mv(r,0), sesiones: mv(r,1)}; }),
        paginas: filas(reps[3]).map(function(r){ return {ruta: dv(r,0), vistas: mv(r,0), usuarios: mv(r,1)}; }),
        guardado: new Date().toISOString()
      };
      cache.put('web_stats_' + days, JSON.stringify(out), 1800);
    }
    var rt = cache.get('web_rt');
    if (rt === null) {
      try {
        var rres = AnalyticsData.Properties.runRealtimeReport({metrics:[{name:'activeUsers'}]}, 'properties/' + GA4_PROPERTY);
        rt = String((rres.rows && rres.rows[0] && rres.rows[0].metricValues[0].value) || 0);
      } catch(e2) { rt = '-1'; }
      cache.put('web_rt', rt, 60);
    }
    out.ahora = Number(rt);
    return out;
  } catch(err) { return {ok:false, web:true, error:err.message}; }
}

function json(obj) {
  return ContentService.createTextOutput(JSON.stringify(obj))
    .setMimeType(ContentService.MimeType.JSON);
}

Copiar

// ── Script 2: Google Ads Script ────────────────────────────────────────
// ads.google.com → Herramientas → Scripts → + Nuevo script
// Actualiza ENDPOINT con la URL del Script 1. Programa ejecución: cada hora.
// IMPORTANTE: usa executeInParallel para crear campañas desde MCC.

var ENDPOINT    = 'PEGA_AQUI_LA_URL_DEL_SCRIPT_1';
var SECRET      = 'thelab2025';
// ID de la cuenta cliente SIN guiones (ej: 7577812099)
var CUSTOMER_ID = 'PEGA_AQUI_EL_CUSTOMER_ID';
// Modo seguro: las campañas nuevas quedan como BORRADOR en
// Google Ads → Acciones masivas → Cargas (revísalas y aplícalas a mano).
// Cuando confirmes que se crean bien, ponlo en false para que se
// apliquen automáticamente. (Solo afecta la CREACIÓN de campañas.)
var PREVIEW_NUEVAS_CAMPANAS = true;

function main() {
  var isMCC = typeof AdsManagerApp !== 'undefined';
  Logger.log('Contexto: ' + (isMCC ? 'MCC' : 'cuenta directa'));

  if (isMCC) {
    if (!CUSTOMER_ID || CUSTOMER_ID === 'PEGA_AQUI_EL_CUSTOMER_ID') {
      Logger.log('ERROR: Configura CUSTOMER_ID al inicio del script.');
      return;
    }
    var accIt = AdsManagerApp.accounts().withIds([CUSTOMER_ID]).get();
    if (!accIt.hasNext()) {
      Logger.log('ERROR: Cuenta ' + CUSTOMER_ID + ' no encontrada en este Manager.');
      return;
    }
    // select() permite lectura; las mutaciones van por executeInParallel
    AdsManagerApp.select(accIt.next());
    Logger.log('MCC: cuenta seleccionada ' + CUSTOMER_ID);
  }

  // 1. Enviar estadísticas de campañas al Script 1
  _enviarStats();

  // 2. Obtener mutaciones pendientes
  var muts = _fetchMutaciones();
  if (!muts) return;

  // 3. Aplicar mutaciones
  if (isMCC) {
    // executeInParallel da contexto nativo de cuenta para aplicar las mutaciones
    AdsManagerApp.accounts()
      .withIds([CUSTOMER_ID])
      .executeInParallel('_aplicarMutaciones', '_finalizarMutaciones', JSON.stringify(muts));
  } else {
    // Cuenta directa: llamada inmediata
    var result = _aplicarMutaciones(JSON.stringify(muts));
    _reportarResultados(JSON.parse(result));
  }
}

function _enviarStats() {
  var campaigns = [];
  var t = {gasto:0, impresiones:0, clics:0, conversiones:0, valor_conversion:0};
  try {
    var report = AdsApp.report(
      'SELECT campaign.name, campaign.id, campaign.status, ' +
      'campaign_budget.amount_micros, metrics.impressions, metrics.clicks, ' +
      'metrics.cost_micros, metrics.conversions, metrics.conversions_value, ' +
      'metrics.search_impression_share, metrics.search_budget_lost_impression_share, ' +
      'metrics.search_rank_lost_impression_share ' +
      "FROM campaign WHERE campaign.status != 'REMOVED' AND segments.date DURING LAST_30_DAYS"
    );
    var rows = report.rows();
    while (rows.hasNext()) {
      var row = rows.next();
      var g  = Math.round(parseInt(row['metrics.cost_micros']||0)/1e6);
      var i  = parseInt(row['metrics.impressions']||0);
      var c  = parseInt(row['metrics.clicks']||0);
      var cv = parseFloat(row['metrics.conversions']||0);
      var vc = parseFloat(row['metrics.conversions_value']||0);
      t.gasto+=g; t.impresiones+=i; t.clics+=c; t.conversiones+=cv; t.valor_conversion+=vc;
      campaigns.push({
        id:row['campaign.id'], nombre:row['campaign.name'], estado:row['campaign.status'],
        presupuesto:Math.round(parseInt(row['campaign_budget.amount_micros']||0)/1e6),
        gasto:g, impresiones:i, clics:c, conversiones:cv, valor_conversion:vc,
        is:parseFloat(row['metrics.search_impression_share']||0),
        is_lost_budget:parseFloat(row['metrics.search_budget_lost_impression_share']||0),
        is_lost_rank:parseFloat(row['metrics.search_rank_lost_impression_share']||0)
      });
    }
    Logger.log('Campañas leídas: ' + campaigns.length);
  } catch(e) { Logger.log('Error leyendo campañas: ' + e.message); return; }
  // Términos de búsqueda (los que gastan): el mayor ahorro en Google Ads está aquí
  var searchTerms = [];
  try {
    var stRep = AdsApp.report(
      'SELECT search_term_view.search_term, campaign.name, metrics.clicks, ' +
      'metrics.cost_micros, metrics.conversions ' +
      'FROM search_term_view WHERE segments.date DURING LAST_30_DAYS ' +
      'AND metrics.cost_micros > 1000000 ORDER BY metrics.cost_micros DESC LIMIT 40'
    );
    var stRows = stRep.rows();
    while (stRows.hasNext()) {
      var sr = stRows.next();
      searchTerms.push({
        termino: sr['search_term_view.search_term'], campana: sr['campaign.name'],
        clics: parseInt(sr['metrics.clicks']||0),
        gasto: Math.round(parseInt(sr['metrics.cost_micros']||0)/1e6),
        conversiones: parseFloat(sr['metrics.conversions']||0)
      });
    }
    Logger.log('Términos de búsqueda: ' + searchTerms.length);
  } catch(e) { Logger.log('Aviso términos de búsqueda: ' + e.message); }
  // Palabras clave con Quality Score: dónde mejorar relevancia/landing para bajar el CPC
  var keywords = [];
  try {
    var kwRep = AdsApp.report(
      'SELECT ad_group_criterion.keyword.text, ad_group_criterion.keyword.match_type, ' +
      'ad_group_criterion.quality_info.quality_score, ' +
      'ad_group_criterion.quality_info.creative_quality_score, ' +
      'ad_group_criterion.quality_info.post_click_quality_score, ' +
      'ad_group_criterion.quality_info.search_predicted_ctr, ' +
      'campaign.name, ad_group.name, metrics.impressions, metrics.clicks, ' +
      'metrics.cost_micros, metrics.conversions ' +
      'FROM keyword_view WHERE segments.date DURING LAST_30_DAYS ' +
      "AND ad_group_criterion.status = 'ENABLED' AND metrics.impressions > 0 " +
      'ORDER BY metrics.cost_micros DESC LIMIT 60'
    );
    var kwRows = kwRep.rows();
    while (kwRows.hasNext()) {
      var kr = kwRows.next();
      keywords.push({
        kw: kr['ad_group_criterion.keyword.text'],
        match: kr['ad_group_criterion.keyword.match_type'],
        qs: parseInt(kr['ad_group_criterion.quality_info.quality_score']||0),
        qs_anuncio: kr['ad_group_criterion.quality_info.creative_quality_score'],
        qs_landing: kr['ad_group_criterion.quality_info.post_click_quality_score'],
        qs_ctr: kr['ad_group_criterion.quality_info.search_predicted_ctr'],
        campana: kr['campaign.name'], grupo: kr['ad_group.name'],
        impresiones: parseInt(kr['metrics.impressions']||0),
        clics: parseInt(kr['metrics.clicks']||0),
        gasto: Math.round(parseInt(kr['metrics.cost_micros']||0)/1e6),
        conversiones: parseFloat(kr['metrics.conversions']||0)
      });
    }
    Logger.log('Palabras clave: ' + keywords.length);
  } catch(e) { Logger.log('Aviso palabras clave: ' + e.message); }
  try {
    UrlFetchApp.fetch(ENDPOINT, {
      method:'post', contentType:'application/json', muteHttpExceptions:true,
      payload:JSON.stringify({
        secret:SECRET, campanas:campaigns, terminos:searchTerms, keywords:keywords,
        gasto:t.gasto, impresiones:t.impresiones, clics:t.clics,
        conversiones:t.conversiones, valor_conversion:t.valor_conversion
      })
    });
    Logger.log('Stats enviadas OK.');
  } catch(e) { Logger.log('Error enviando stats: ' + e.message); }
}

function _fetchMutaciones() {
  try {
    var resp = UrlFetchApp.fetch(ENDPOINT + '?action=mutations', {muteHttpExceptions:true});
    var data = JSON.parse(resp.getContentText());
    if (!data.ok || !data.mutations || !data.mutations.length) {
      Logger.log('Sin mutaciones pendientes.');
      return null;
    }
    Logger.log('Mutaciones a procesar: ' + data.mutations.length);
    return data.mutations;
  } catch(e) { Logger.log('Error obteniendo mutaciones: ' + e.message); return null; }
}

// Corre en contexto nativo de cuenta (via executeInParallel o directamente)
// Recibe y devuelve JSON string
function _aplicarMutaciones(mutsJson) {
  var muts = JSON.parse(mutsJson);
  for (var k = 0; k < muts.length; k++) {
    var m = muts[k];
    if (m.status !== 'pending') continue;
    try {
      if (m.op === 'create') {
        // Google Ads Scripts NO permite crear campañas con builders
        // (AdsApp.newCampaignBuilder no existe). La vía soportada es la carga
        // masiva (bulk upload) con el formato CSV del Editor de Google Ads.
        var _grupo = 'Grupo 1 - ' + m.data.nombre;
        var _kws = (m.data.palabrasClave && m.data.palabrasClave.length) ? m.data.palabrasClave : [];
        var _mt = m.data.concordancia || 'FRASE';
        function _wrapKw(k){ return (_mt === 'EXACTA') ? ('[' + k + ']') : (_mt === 'AMPLIA') ? k : ('"' + k + '"'); }
        var _maxCpc = parseInt(m.data.maxCpc, 10) || 800;

        // PLAN B: si la campaña YA EXISTE (cascarón creado a mano en la UI —
        // que sí permite responder la pregunta de anuncios políticos UE),
        // la COMPLETAMOS con builders nativos (grupo, keywords, RSA,
        // negativas, presupuesto) sin pasar por el CSV.
        var _existente = _buscarCampana(null, m.data.nombre);
        if (_existente) {
          _completarCampana(_existente, m, _grupo, _kws, _mt, _maxCpc);
          muts[k].status = 'aplicado';
          continue;
        }
        // El CSV de carga masiva solo acepta de forma fiable 'cpc' (CPC manual).
        // La estrategia elegida (Maximizar clics/conversiones, tCPA, tROAS) se
        // activa a mano en Google Ads al revisar la campaña recién creada.
        var _bs = 'cpc';
        if (m.data.pujaEstrategia && m.data.pujaEstrategia !== 'MANUAL_CPC') {
          Logger.log('Nota: activar la estrategia ' + m.data.pujaEstrategia + ' a mano en la campaña "' + m.data.nombre + '" (el CSV la crea con CPC manual + tope).');
        }
        var _ad = m.data.anuncio || null;
        var _titulos = (_ad && _ad.titulos && _ad.titulos.length) ? _ad.titulos.slice(0, 15) : [];
        var _descs = (_ad && _ad.descripciones && _ad.descripciones.length) ? _ad.descripciones.slice(0, 4) : [];
        var _conAnuncio = !!(_ad && _ad.finalUrl && _titulos.length >= 3 && _descs.length >= 2);
        // 'EU political ads': declaración obligatoria desde sept 2025 (regulación UE)
        // aunque la campaña solo sirva en Chile. Sin la columna, la carga entera falla
        // con "Falta un valor en 'Anuncios políticos de la UE'".
        var _cols = ['Campaign', 'Campaign status', 'Budget', 'Bid Strategy type',
                     'Campaign type', 'EU political ads', 'Ad group', 'Max CPC', 'Keyword'];
        if (_conAnuncio) {
          _cols = _cols.concat(['Ad type', 'Final URL', 'Path 1', 'Path 2']);
          for (var h = 0; h < _titulos.length; h++) _cols.push('Headline ' + (h + 1));
          for (var d = 0; d < _descs.length; d++) _cols.push('Description ' + (d + 1));
        }
        var _up = AdsApp.bulkUploads().newCsvUpload(_cols, {moneyInMicros: false});
        // Fila de campaña (presupuesto y Max CPC en moneda de la cuenta, p. ej. CLP)
        _up.append({
          'Campaign': m.data.nombre,
          'Campaign status': (m.data.estado === 'PAUSED') ? 'Paused' : 'Enabled',
          'Budget': m.data.presupuesto,
          'Bid Strategy type': _bs,
          'Campaign type': 'Search Only',
          // Declaración obligatoria (regulación UE): booleano según los docs de
          // Ads Scripts — 'false' = no contiene publicidad política de la UE.
          'EU political ads': 'false'
        });
        // Fila de grupo de anuncios
        _up.append({'Campaign': m.data.nombre, 'Ad group': _grupo, 'Max CPC': _maxCpc});
        // Filas de palabras clave (concordancia segun m.data.concordancia: FRASE / EXACTA / AMPLIA)
        for (var kw = 0; kw < _kws.length; kw++) {
          _up.append({'Campaign': m.data.nombre, 'Ad group': _grupo, 'Keyword': _wrapKw(_kws[kw])});
        }
        // Fila de anuncio responsivo de búsqueda (RSA), si hay datos suficientes
        if (_conAnuncio) {
          var _fila = {'Campaign': m.data.nombre, 'Ad group': _grupo,
                       'Ad type': 'Responsive search ad', 'Final URL': _ad.finalUrl};
          if (_ad.path1) _fila['Path 1'] = _ad.path1;
          if (_ad.path2) _fila['Path 2'] = _ad.path2;
          for (var hh = 0; hh < _titulos.length; hh++) _fila['Headline ' + (hh + 1)] = _titulos[hh];
          for (var dd = 0; dd < _descs.length; dd++) _fila['Description ' + (dd + 1)] = _descs[dd];
          _up.append(_fila);
        }
        _up.forCampaignManagement();
        if (PREVIEW_NUEVAS_CAMPANAS) {
          _up.preview();
          Logger.log('BORRADOR (preview) listo: ' + m.data.nombre + ' — revísalo y aplícalo en ' +
                     'Google Ads -> Acciones masivas -> Cargas. Pon PREVIEW_NUEVAS_CAMPANAS=false para aplicar solo.');
        } else {
          _up.apply();
          Logger.log('OK creada (bulk upload): ' + m.data.nombre + ' · ' + _kws.length +
                     ' keywords · ' + (_conAnuncio ? 'con anuncio RSA' : 'sin anuncio'));
          Logger.log('Si en 3 min no aparece en Campañas (revisa Subidas): crea a mano una campaña de Búsqueda ' +
                     'vacía con el nombre EXACTO "' + m.data.nombre + '" en la UI, vuelve a guardar la campaña ' +
                     'desde el dashboard y ejecuta este script: la completará con keywords y anuncio sin usar CSV.');
          // Palabras clave negativas (best-effort; si la campana aun no aparece, reintenta el proximo ciclo)
          var _negs = (m.data.negativas && m.data.negativas.length) ? m.data.negativas : [];
          if (_negs.length) {
            try {
              var _cIt = AdsApp.campaigns().withCondition("campaign.name = '" + String(m.data.nombre).replace(/'/g, '') + "'").get();
              if (_cIt.hasNext()) {
                var _cNeg = _cIt.next();
                for (var _n = 0; _n < _negs.length; _n++) _cNeg.createNegativeKeyword(_negs[_n]);
                Logger.log('OK ' + _negs.length + ' negativos agregados a ' + m.data.nombre);
              } else {
                Logger.log('Negativos pendientes: la campana aun no aparece — se agregaran a mano o al reintentar');
              }
            } catch(_eN) { Logger.log('No se pudieron agregar negativos: ' + _eN.message); }
          }
        }
        muts[k].status = 'aplicado';

      } else if (m.op === 'edit') {
        var camp = _buscarCampana(m.id, m.data && m.data.nombre);
        if (camp) {
          if (m.data.nombre && camp.setName && camp.getName() !== m.data.nombre) { try { camp.setName(m.data.nombre); } catch(_eN2) {} }
          if (m.data.estado === 'ENABLED') camp.enable();
          if (m.data.estado === 'PAUSED') camp.pause();
          if (m.data.presupuesto) camp.getBudget().setAmount(m.data.presupuesto);
          muts[k].status = 'aplicado';
          Logger.log('OK editada: ' + m.id);
        } else {
          muts[k].status = 'error';
          muts[k].error = 'Campaña no encontrada: ' + m.id + ' (si es una campaña Smart/inteligente, Scripts no puede editarla — pausala en ads.google.com)';
        }

      } else if (m.op === 'negative') {
        // Agrega palabra clave negativa: a la campaña (por id o nombre) o a nivel cuenta
        var term = m.data && m.data.termino; var added = false;
        if (term) {
          var itN = m.id ? AdsApp.campaigns().withIds([Number(m.id)]).get()
                         : AdsApp.campaigns().withCondition("campaign.name = '" + (m.data.campana||'').replace(/'/g,"") + "'").get();
          if (itN.hasNext()) { itN.next().createNegativeKeyword('[' + term + ']'); added = true; }
        }
        muts[k].status = added ? 'aplicado' : 'error';
        if (!added) muts[k].error = 'No se pudo agregar el negativo (campaña no encontrada)';
        Logger.log((added?'OK':'ERR') + ' negativo: ' + term);

      } else if (m.op === 'pause_keyword') {
        // Pausa la(s) palabra(s) clave que coincidan con el texto (acotado a la campaña si se indica)
        var kwt = m.data && m.data.termino; var paused = 0;
        if (kwt) {
          var sel = AdsApp.keywords()
            .withCondition("ad_group_criterion.keyword.text = '" + kwt.replace(/'/g, '') + "'");
          if (m.data.campana) sel = sel.withCondition("campaign.name = '" + m.data.campana.replace(/'/g, '') + "'");
          var kwIt = sel.get();
          while (kwIt.hasNext()) { kwIt.next().pause(); paused++; }
        }
        muts[k].status = paused > 0 ? 'aplicado' : 'error';
        if (paused === 0) muts[k].error = 'Palabra clave no encontrada: ' + kwt;
        Logger.log((paused > 0 ? 'OK' : 'ERR') + ' pausar keyword: ' + kwt + ' (' + paused + ')');

      } else if (m.op === 'delete') {
        var campD = _buscarCampana(m.id, m.data && m.data.nombre);
        if (campD) {
          campD.pause();
          muts[k].status = 'aplicado';
          Logger.log('OK pausada: ' + m.id);
        } else {
          muts[k].status = 'error';
          muts[k].error = 'Campaña no encontrada: ' + m.id + ' (si es una campaña Smart/inteligente, Scripts no puede pausarla — hazlo en ads.google.com)';
        }
      }
    } catch(e) {
      muts[k].status = 'error';
      muts[k].error = e.message;
      Logger.log('[Error] op=' + m.op + ' → ' + e.message);
    }
  }
  return JSON.stringify(muts);
}

// Busca una campaña por ID (numérico) o por nombre, en todos los tipos que
// Ads Scripts puede mutar: estándar (Search/Display), Performance Max, Video
// y Shopping. Nota: los reportes GAQL listan también campañas Smart, pero
// esas NO son accesibles para mutación desde Scripts.
function _buscarCampana(id, nombre) {
  var factories = [function(){ return AdsApp.campaigns(); }];
  if (AdsApp.performanceMaxCampaigns) factories.push(function(){ return AdsApp.performanceMaxCampaigns(); });
  if (AdsApp.videoCampaigns) factories.push(function(){ return AdsApp.videoCampaigns(); });
  if (AdsApp.shoppingCampaigns) factories.push(function(){ return AdsApp.shoppingCampaigns(); });
  var i, it;
  var idNum = Number(id);
  if (idNum) {
    for (i = 0; i < factories.length; i++) {
      try { it = factories[i]().withIds([idNum]).get(); if (it.hasNext()) return it.next(); } catch(e) {}
    }
  }
  if (nombre) {
    for (i = 0; i < factories.length; i++) {
      try {
        it = factories[i]().withCondition("campaign.name = '" + String(nombre).replace(/'/g, '') + "'").get();
        if (it.hasNext()) return it.next();
      } catch(e) {}
    }
  }
  return null;
}

// PLAN B de creación: completa una campaña EXISTENTE (cascarón hecho en la UI)
// con grupo de anuncios, keywords, anuncio RSA, negativas y presupuesto,
// usando builders nativos de Ads Scripts (sin CSV, sin campo político UE).
function _completarCampana(camp, m, grupoNombre, kws, mt, maxCpc) {
  try { if (m.data.presupuesto) camp.getBudget().setAmount(m.data.presupuesto); } catch(e) {}
  try {
    if (m.data.estado === 'PAUSED') camp.pause();
    else if (m.data.estado === 'ENABLED') camp.enable();
  } catch(e) {}

  // Grupo de anuncios: reutiliza si ya existe (idempotente para reintentos)
  var ag = null;
  try {
    var agIt = camp.adGroups().withCondition("ad_group.name = '" + grupoNombre.replace(/'/g, '') + "'").get();
    if (agIt.hasNext()) ag = agIt.next();
  } catch(e) {}
  if (!ag) {
    try {
      var agOp = camp.newAdGroupBuilder().withName(grupoNombre).withCpc(maxCpc).build();
      if (agOp.isSuccessful()) ag = agOp.getResult();
      else Logger.log('Grupo de anuncios: ' + agOp.getErrors().join('; '));
    } catch(e) { Logger.log('Grupo de anuncios: ' + e.message); }
  }
  if (!ag) { Logger.log('ERR no se pudo crear/encontrar el grupo en "' + camp.getName() + '"'); return; }

  // Palabras clave con la concordancia elegida
  var kwOk = 0;
  for (var i = 0; i < kws.length; i++) {
    var kw = (mt === 'EXACTA') ? ('[' + kws[i] + ']') : (mt === 'AMPLIA') ? kws[i] : ('"' + kws[i] + '"');
    try { var kOp = ag.newKeywordBuilder().withText(kw).build(); if (kOp.isSuccessful()) kwOk++; } catch(e) {}
  }

  // Anuncio responsivo (RSA)
  var ad = m.data.anuncio;
  var conAd = false;
  if (ad && ad.finalUrl && ad.titulos && ad.titulos.length >= 3 && ad.descripciones && ad.descripciones.length >= 2) {
    try {
      var b = ag.newAd().responsiveSearchAdBuilder()
        .withHeadlines(ad.titulos.slice(0, 15))
        .withDescriptions(ad.descripciones.slice(0, 4))
        .withFinalUrl(ad.finalUrl);
      if (ad.path1) b = b.withPath1(ad.path1);
      if (ad.path2) b = b.withPath2(ad.path2);
      var adOp = b.build();
      conAd = adOp.isSuccessful();
      if (!conAd) Logger.log('RSA: ' + adOp.getErrors().join('; '));
    } catch(e) { Logger.log('RSA: ' + e.message); }
  }

  // Palabras clave negativas
  var negs = (m.data.negativas && m.data.negativas.length) ? m.data.negativas : [];
  for (var n = 0; n < negs.length; n++) {
    try { camp.createNegativeKeyword(negs[n]); } catch(e) {}
  }

  Logger.log('OK completada sobre campaña existente "' + camp.getName() + '": ' + kwOk + '/' + kws.length +
             ' keywords · ' + (conAd ? 'con anuncio RSA' : 'SIN anuncio') + ' · ' + negs.length + ' negativas');
}

// Callback de executeInParallel: recibe array de ManagedAccountStats
function _finalizarMutaciones(results) {
  for (var i = 0; i < results.length; i++) {
    var r = results[i];
    Logger.log('Cuenta ' + r.getCustomerId() + ' → ' + r.getStatus());
    if (r.getStatus() === 'OK') {
      _reportarResultados(JSON.parse(r.getReturnValue()));
    } else {
      Logger.log('Error en cuenta: ' + r.getError());
    }
  }
}

function _reportarResultados(muts) {
  try {
    UrlFetchApp.fetch(ENDPOINT, {
      method:'post', contentType:'application/json', muteHttpExceptions:true,
      payload:JSON.stringify({secret:SECRET, type:'update_mutations', mutations:muts})
    });
    var ok  = muts.filter(function(x){return x.status==='aplicado';}).length;
    var err = muts.filter(function(x){return x.status==='error';}).length;
    Logger.log('Resultado: ' + ok + ' aplicadas, ' + err + ' errores');
  } catch(e) { Logger.log('Error reportando resultados: ' + e.message); }
}

Copiar