Crear una diapositiva

En esta página, se describe cómo agregar diapositivas a un documento existente de Presentaciones de Google presentación.

Presentaciones

Cada página individual de un archivo de Presentaciones es una diapositiva.

Para agregar una diapositiva a la presentación, necesitas el ID de presentación. Puedes encontrar el ID de la presentación abriéndola en Presentaciones y mirando su URL:

https://docs.google.com/presentation/d/presentationID/edit

Para agregar una diapositiva, usa el Método batchUpdate() con el ID de presentación e incluye un CreateSlideRequest en el cuerpo de la solicitud. El ID de la diapositiva nueva se muestra en el cuerpo de la respuesta.

Ejemplo

En el siguiente ejemplo se muestra cómo agregar una diapositiva a una presentación. Todos los campos para CreateSlideRequest son opcionales. En este ejemplo, se crea la diapositiva como la segunda, con TITLE_AND_TWO_COLUMNS y un ID de objeto explícito.

Apps Script

slides/api/Snippets.gs
/**
 * Creates a slide
 * @param {string} presentationId
 * @param {string} pageId
 * @returns {*}
 */
function createSlide(presentationId, pageId) {
  // See Presentation.insertSlide(...) to learn how to add a slide using SlidesApp.
  // http://developers.google.com/apps-script/reference/slides/presentation#appendslidelayout
  const requests = [{
    createSlide: {
      objectId: pageId,
      insertionIndex: '1',
      slideLayoutReference: {
        predefinedLayout: 'TITLE_AND_TWO_COLUMNS'
      }
    }
  }];

  // If you wish to populate the slide with elements, add element create requests here,
  // using the pageId.

  // Execute the request.
  try {
    const createSlideResponse = Slides.Presentations.batchUpdate({
      requests: requests
    }, presentationId);
    console.log('Created slide with ID: %s', createSlideResponse.replies[0].createSlide.objectId);
    return createSlideResponse;
  } catch (err) {
    // TODO (Developer) - Handle exception
    console.log('Failed with error: %s', err.error);
  }
};

Go

slides/snippets/presentations.go
// Add a slide at index 1 using the predefined "TITLE_AND_TWO_COLUMNS" layout
// and the ID "MyNewSlide_001".
slideId := "MyNewSlide_001"
requests := []*slides.Request{{
	CreateSlide: &slides.CreateSlideRequest{
		ObjectId:       slideId,
		InsertionIndex: 1,
		SlideLayoutReference: &slides.LayoutReference{
			PredefinedLayout: "TITLE_AND_TWO_COLUMNS",
		},
	},
}}

// If you wish to populate the slide with elements, add create requests here,
// using the slide ID specified above.

// Execute the request.
body := &slides.BatchUpdatePresentationRequest{
	Requests: requests,
}
response, err := slidesService.Presentations.BatchUpdate(presentationId, body).Do()
if err != nil {
	log.Fatalf("Unable to create slide. %v", err)
}
fmt.Printf("Created slide with ID: %s", response.Replies[0].CreateSlide.ObjectId)

Java

slides/snippets/src/main/java/CreateSlide.java
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.slides.v1.Slides;
import com.google.api.services.slides.v1.SlidesScopes;
import com.google.api.services.slides.v1.model.BatchUpdatePresentationRequest;
import com.google.api.services.slides.v1.model.BatchUpdatePresentationResponse;
import com.google.api.services.slides.v1.model.CreateSlideRequest;
import com.google.api.services.slides.v1.model.CreateSlideResponse;
import com.google.api.services.slides.v1.model.LayoutReference;
import com.google.api.services.slides.v1.model.Request;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/* Class to demonstrate the use of Create Slides API */
public class CreateSlide {
  /**
   * Creates a new slide.
   *
   * @param presentationId - id of the presentation.
   * @return slide id
   * @throws IOException - if credentials file not found.
   */
  public static BatchUpdatePresentationResponse createSlide(String presentationId)
      throws IOException {
        /* Load pre-authorized user credentials from the environment.
           TODO(developer) - See https://developers.google.com/identity for
            guides on implementing OAuth2 for your application. */
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Collections.singleton(SlidesScopes.PRESENTATIONS));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Create the slides API client
    Slides service = new Slides.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Slides samples")
        .build();

    // Add a slide at index 1 using the predefined "TITLE_AND_TWO_COLUMNS" layout
    List<Request> requests = new ArrayList<>();
    String slideId = "MyNewSlide_001";
    BatchUpdatePresentationResponse response = null;
    try {
      requests.add(new Request()
          .setCreateSlide(new CreateSlideRequest()
              .setObjectId(slideId)
              .setInsertionIndex(1)
              .setSlideLayoutReference(new LayoutReference()
                  .setPredefinedLayout("TITLE_AND_TWO_COLUMNS"))));

      // If you wish to populate the slide with elements, add create requests here,
      // using the slide ID specified above.

      // Execute the request.
      BatchUpdatePresentationRequest body =
          new BatchUpdatePresentationRequest().setRequests(requests);
      response = service.presentations().batchUpdate(presentationId, body).execute();
      CreateSlideResponse createSlideResponse = response.getReplies().get(0).getCreateSlide();
      // Prints the slide id.
      System.out.println("Created slide with ID: " + createSlideResponse.getObjectId());
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      GoogleJsonError error = e.getDetails();
      if (error.getCode() == 400) {
        System.out.printf(" Id '%s' should be unique among all pages and page elements.\n",
            presentationId);
      } else if (error.getCode() == 404) {
        System.out.printf("Presentation not found with id '%s'.\n", presentationId);
      } else {
        throw e;
      }
    }
    return response;
  }
}

JavaScript

slides/snippets/slides_create_slide.js
function createSlide(presentationId, pageId, callback) {
  const requests = [
    {
      createSlide: {
        objectId: pageId,
        insertionIndex: '1',
        slideLayoutReference: {
          predefinedLayout: 'TITLE_AND_TWO_COLUMNS',
        },
      },
    },
  ];
  // If you wish to populate the slide with elements, add element create requests here,
  // using the pageId.
  // Execute the request.
  try {
    gapi.client.slides.presentations
        .batchUpdate({
          presentationId: presentationId,
          requests: requests,
        })
        .then((createSlideResponse) => {
          const objectId =
          createSlideResponse.result.replies[0].createSlide.objectId;
          console.log(`Created slide with ID: ${objectId}`);
          if (callback) callback(createSlideResponse);
        });
  } catch (err) {
    document.getElementById('content').innerText = err.message;
    return;
  }
}

Node.js

slides/snippets/slides_create_slide.js
/**
 * Creates a new slide in a presentation.
 * @param {string} presentationId The presentation ID.
 * @param {string} pageId The object ID for the new slide.
 */
async function createSlide(presentationId, pageId) {
  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');

  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/presentations',
  });

  const service = google.slides({version: 'v1', auth});
  const requests = [
    {
      createSlide: {
        objectId: pageId,
        insertionIndex: '1',
        slideLayoutReference: {
          predefinedLayout: 'TITLE_AND_TWO_COLUMNS',
        },
      },
    },
  ];
  // If you wish to populate the slide with elements, add element create requests here,
  // using the pageId.

  // Execute the request.
  try {
    const res = await service.presentations.batchUpdate({
      presentationId,
      resource: {
        requests,
      },
    });
    console.log(
        `Created slide with ID: ${res.data.replies[0].createSlide.objectId}`,
    );
    return res;
  } catch (err) {
    // TODO (developer) - handle exception
    throw err;
  }
}

PHP

slides/snippets/src/SlidesCreateSlide.php
use Google\Client;
use Google\Service\Drive;
use Google\Service\Slides\Request;
use Google\Service\Slides\BatchUpdatePresentationRequest;

function createSlide($presentationId, $pageId)
{
    /* Load pre-authorized user credentials from the environment.
   TODO(developer) - See https://developers.google.com/identity for
    guides on implementing OAuth2 for your application. */
    $client = new Google\Client();
    $client->useApplicationDefaultCredentials();
    $client->addScope(Google\Service\Drive::DRIVE);
    $slidesService = new Google_Service_Slides($client);
    try {
        $requests = array();
        $requests[] = new Google_Service_Slides_Request(array(
            'createSlide' => array(
                'objectId' => $pageId,
                'insertionIndex' => 1,
                'slideLayoutReference' => array(
                    'predefinedLayout' => 'TITLE_AND_TWO_COLUMNS'
                )
            )
        ));
        $batchUpdateRequest = new Google_Service_Slides_BatchUpdatePresentationRequest(array(
            'requests' => $requests
        ));

        //execute the request 
        $response = $slidesService->presentations->batchUpdate($presentationId, $batchUpdateRequest);
        $createSlideResponse = $response->getReplies()[0]->getCreateSlide();
        printf("Created slide with ID: %s\n", $createSlideResponse->getObjectId());
        return $response;
    } catch (Exception $e) {
        echo 'Message: ' . $e->getMessage();
    }
}

Python

slides/snippets/slides_create_slide.py
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def create_slide(presentation_id, page_id):
  """
  Creates the Presentation the user has access to.
  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.\n
  """
  creds, _ = google.auth.default()
  # pylint: disable=maybe-no-member
  try:
    service = build("slides", "v1", credentials=creds)
    # Add a slide at index 1 using the predefined
    # 'TITLE_AND_TWO_COLUMNS' layout and the ID page_id.
    requests = [
        {
            "createSlide": {
                "objectId": page_id,
                "insertionIndex": "1",
                "slideLayoutReference": {
                    "predefinedLayout": "TITLE_AND_TWO_COLUMNS"
                },
            }
        }
    ]

    # If you wish to populate the slide with elements,
    # add element create requests here, using the page_id.

    # Execute the request.
    body = {"requests": requests}
    response = (
        service.presentations()
        .batchUpdate(presentationId=presentation_id, body=body)
        .execute()
    )
    create_slide_response = response.get("replies")[0].get("createSlide")
    print(f"Created slide with ID:{(create_slide_response.get('objectId'))}")
  except HttpError as error:
    print(f"An error occurred: {error}")
    print("Slides not created")
    return error

  return response


if __name__ == "__main__":
  # Put the presentation_id, Page_id of slides whose list needs
  # to be submitted.
  create_slide("12SQU9Ik-ShXecJoMtT-LlNwEPiFR7AadnxV2KiBXCnE", "My4ndpage")

Rita

slides/snippets/lib/file_snippets.rb
body = Google::Apis::SlidesV1::Presentation.new
requests = [{
  create_slide: {
    object_id_prop:         page_id,
    insertion_index:        '1',
    slide_layout_reference: {
      predefined_layout: 'TITLE_AND_TWO_COLUMNS'
    }
  }
}]

# If you wish to populate the slide with elements, add element create requests here,
# using the page_id.

# Execute the request.
req = Google::Apis::SlidesV1::BatchUpdatePresentationRequest.new(requests: requests)
response = slides_service.batch_update_presentation(presentation_id, req)
create_slide_response = response.replies[0].create_slide
puts "Created slide with ID: #{create_slide_response.object_id}"

Después de crear la diapositiva, puedes agregarle texto y formas.

Completa los marcadores de posición

Los diseños normalmente tienen formas de marcador de posición que se copian en la diapositiva cuando está crear. CreateSlideRequest te permite especificar los IDs de objeto que se usan para estos los marcadores de posición copiados a través del campo placeholderIdMappings Esto te permite modificar los marcadores de posición copiados en la misma solicitud batchUpdate, lo que mejora en el rendimiento y ahorras cuota. Para obtener más información, consulta la Muestra de CreateSlideRequest.