Random Joke to Google Spreadsheet

Test this app for free
87
import requests
import json
from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from abilities import acquire_user_oauth_tokens


def get_random_joke():
    response = requests.get("https://official-joke-api.appspot.com/random_joke")
    joke_data = json.loads(response.text)
    joke = f"{joke_data['setup']} - {joke_data['punchline']}"
    return joke


def create_new_spreadsheet(credentials):
    try:
        service = build("sheets", "v4", credentials=credentials)
        spreadsheet = {"properties": {"title": "Random Joke Spreadsheet"}}
        spreadsheet = service.spreadsheets().create(body=spreadsheet).execute()
        print(f"Created spreadsheet with ID: {spreadsheet.get('spreadsheetId')}")
        return spreadsheet.get("spreadsheetId"), spreadsheet.get("spreadsheetUrl")
    except HttpError as error:
        print(f"An error occurred: {error}")
Get full code

Frequently Asked Questions

How can businesses use the Random Joke to Google Spreadsheet app to engage with their customers?

Businesses can leverage the Random Joke to Google Spreadsheet app in various creative ways to engage with customers. For example, they could use it as part of a daily social media campaign, sharing a new joke each day and encouraging followers to interact. It could also be used in email marketing campaigns to add a touch of humor to newsletters. Additionally, customer service teams could use the app to lighten the mood during support interactions, potentially improving customer satisfaction.

What are the potential benefits of automating joke collection for content creators?

The Random Joke to Google Spreadsheet app offers several benefits for content creators: - Time-saving: Automatically collects and organizes jokes, reducing manual effort. - Consistency: Ensures a steady stream of new content for various platforms. - Organization: Stores jokes in a structured format, making it easy to search and categorize. - Inspiration: Provides a quick source of ideas for content creation or writer's block. - Analytics: Allows creators to track which jokes resonate most with their audience by analyzing spreadsheet data.

How can the Random Joke to Google Spreadsheet app be adapted for educational purposes?

The app can be adapted for educational purposes in several ways: - Language learning: Modify it to collect jokes in different languages, helping students practice comprehension and cultural nuances. - Writing prompts: Use the jokes as writing prompts for creative writing exercises. - Data analysis: Teach students to analyze the collected jokes for patterns, themes, or linguistic features. - Programming lessons: Use the app's code as a base for teaching API interactions, OAuth authentication, and working with Google Sheets API.

How can I modify the Random Joke to Google Spreadsheet app to fetch jokes from a different API?

To fetch jokes from a different API, you'll need to modify the get_random_joke() function. Here's an example of how you might change it to use a different joke API:

python def get_random_joke(): response = requests.get("https://v2.jokeapi.dev/joke/Any?type=twopart") joke_data = json.loads(response.text) if joke_data['type'] == 'twopart': joke = f"{joke_data['setup']} - {joke_data['delivery']}" else: joke = joke_data['joke'] return joke

This example uses the JokeAPI, which has a different structure than the original API. Make sure to adjust the joke formatting according to the new API's response structure.

How can I extend the Random Joke to Google Spreadsheet app to categorize jokes in different sheets based on their type?

To categorize jokes in different sheets, you'll need to modify the add_joke_to_spreadsheet() function and add logic to determine the joke's category. Here's an example of how you might do this:

```python def add_joke_to_spreadsheet(joke, category, credentials, spreadsheet_id): try: service = build("sheets", "v4", credentials=credentials)

       # Check if the sheet for this category exists, if not, create it
       sheet_metadata = service.spreadsheets().get(spreadsheetId=spreadsheet_id).execute()
       sheet_names = [sheet['properties']['title'] for sheet in sheet_metadata['sheets']]
       if category not in sheet_names:
           request_body = {
               'requests': [{
                   'addSheet': {
                       'properties': {
                           'title': category
                       }
                   }
               }]
           }
           service.spreadsheets().batchUpdate(spreadsheetId=spreadsheet_id, body=request_body).execute()

       range_name = f"{category}!A1:A"
       values = [[joke]]
       body = {"values": values}
       result = service.spreadsheets().values().append(
           spreadsheetId=spreadsheet_id,
           range=range_name,
           valueInputOption="RAW",
           insertDataOption="INSERT_ROWS",
           body=body
       ).execute()
       print(f"Added joke to {category} sheet: {joke}")
   except HttpError as error:
       print(f"An error occurred: {error}")

```

You would then need to determine the category of each joke before calling this function. This modification allows the Random Joke to Google Spreadsheet app to organize jokes into different sheets based on their categories.

Created: | Last Updated:

This app fetches a random joke from an API, creates a new Google Spreadsheet, adds the joke to the new Google Spreadsheet, and responds back to the user with the URL to the new Google Spreadsheet using user's OAuth tokens for authentication.

Introduction to the Random Joke to Google Spreadsheet Template

Welcome to the step-by-step guide on how to use the Random Joke to Google Spreadsheet template. This template is designed to fetch a random joke from an online API and create a new Google Spreadsheet where the joke will be added. You will then receive a URL to access your new spreadsheet. This process is automated and requires minimal input from you, thanks to the Lazy platform.

To get started, simply click on "Start with this Template" on the Lazy platform. This will set up the template in your Lazy Builder interface.

External Integrations

Before you can use this template, you need to ensure that you have the following:

  • A Google account with access to Google Sheets.
  • Authorization tokens for OAuth 2.0 to authenticate with the Google Sheets API. These tokens will be acquired through the Lazy platform's built-in abilities module, so you don't need to worry about setting them up manually.

Once you have these prerequisites in place, you're ready to proceed with using the template.

Using the Test Button

After initializing the template with "Start with this Template," you can use the Test button to begin the deployment of the app. The Lazy CLI will launch, and you will be prompted to provide any required user input. In this case, the app will handle the OAuth tokens for you, so you won't need to input them manually.

When you use the Test button, if the code requires an API, Lazy will provide you with a dedicated server link to use the API. Since this template does not host a frontend or use FastAPI, you won't receive a docs link, and there's no need for additional integration steps.

How to Use the Interface

Once the app is deployed, you will interact with it through the Lazy CLI. The app will automatically fetch a random joke and proceed to create a new Google Spreadsheet. It will then add the joke to the spreadsheet and provide you with the URL to your new Google Spreadsheet.

If you encounter any issues or have questions, the Lazy customer support team is available to assist you. Enjoy your new app and the laughter that comes with your random jokes!

Remember, this template is designed to be easy to use, requiring minimal setup and no environment secrets or additional environment variables. Just follow the steps above, and you'll have your Random Joke to Google Spreadsheet app up and running in no time on the Lazy platform.



Here are 5 key business benefits for this template:

Template Benefits

  1. Automated Content Generation: This template demonstrates how to automatically create and populate spreadsheets with content from external sources, which can be adapted for various business needs such as daily reports, inventory updates, or customer feedback collection.

  2. API Integration Showcase: The template showcases integration with both external APIs (joke API) and Google Sheets API, illustrating how businesses can leverage multiple services to create more powerful and automated workflows.

  3. OAuth Implementation: By incorporating OAuth authentication, this template provides a secure way to access user data, which is crucial for businesses handling sensitive information or integrating with third-party services.

  4. Productivity Enhancement: The automation of spreadsheet creation and data entry can significantly reduce manual work, allowing employees to focus on more value-added tasks and improving overall productivity.

  5. Customizable Foundation: While this template uses a joke API as an example, it provides a solid foundation that can be easily customized for various business applications, such as creating daily sales reports, tracking project progress, or aggregating data from multiple sources into a single spreadsheet.

Technologies

Boost Productivity in Google Chrome with Lazy AI: Automate Tasks, Streamline Workflows and More Boost Productivity in Google Chrome with Lazy AI: Automate Tasks, Streamline Workflows and More
Optimize Google Sheets with Lazy AI: Automate Data Analysis, Reporting and More Optimize Google Sheets with Lazy AI: Automate Data Analysis, Reporting and More

Similar templates