इस पेज का अनुवाद Cloud Translation API से किया गया है.

क्विकस्टार्ट आज़माएं

क्विकस्टार्ट, ऐसे ऐप्लिकेशन को सेट अप करने और चलाने का तरीका बताता है जो Google Workspace API.

Google Workspace क्विकस्टार्ट, एपीआई क्लाइंट लाइब्रेरी का इस्तेमाल करके, पुष्टि करने और अनुमति देने के फ़्लो की जानकारी. हमारा सुझाव है कि की मदद से अपने ऐप्लिकेशन के लिए क्लाइंट लाइब्रेरी का इस्तेमाल किया हो. इस क्विकस्टार्ट में, पुष्टि करने के लिए आसान तरीके का इस्तेमाल किया गया है. यह तरीका, टेस्टिंग एनवायरमेंट के लिए सही है. हमारा सुझाव है कि प्रोडक्शन एनवायरमेंट के लिए, अपने ऐप्लिकेशन के लिए सही ऐक्सेस क्रेडेंशियल चुनने से पहले, पुष्टि और अनुमति के बारे में जानें.

ऐसा Go कमांड-लाइन ऐप्लिकेशन बनाएं जो Google Apps Script API.

मकसद

अपना एनवायरमेंट सेट अप करें.
सैंपल सेट अप करें.
सैंपल चलाएं.

ज़रूरी शर्तें

Go का सबसे नया वर्शन.
Git का सबसे नया वर्शन.
Google Cloud प्रोजेक्ट.

आपके पास ऐसा Google खाता होना चाहिए जिसमें Google Drive चालू हो.

अपना एनवायरमेंट सेट अप करें

इस क्विकस्टार्ट को पूरा करने के लिए, अपना एनवायरमेंट सेट अप करें.

एपीआई चालू करना

Google API का इस्तेमाल करने से पहले, आपको उन्हें Google Cloud प्रोजेक्ट में चालू करना होगा. किसी एक Google Cloud प्रोजेक्ट में, एक या उससे ज़्यादा एपीआई चालू किए जा सकते हैं.

Google Cloud Console में, Google Apps Script API चालू करें.

एपीआई को चालू करना

OAuth की सहमति वाली स्क्रीन को कॉन्फ़िगर करना

अगर इस शुरुआती लेख को पूरा करने के लिए, किसी नए Google Cloud प्रोजेक्ट का इस्तेमाल किया जा रहा है, तो OAuth की सहमति वाली स्क्रीन को कॉन्फ़िगर करें और खुद को टेस्ट उपयोगकर्ता के तौर पर जोड़ें. अगर आपने पहले आपने अपने Cloud प्रोजेक्ट के लिए यह चरण पूरा किया है, तो अगले सेक्शन पर जाएं.

Google Cloud Console में, मेन्यू > एपीआई और सेवाएं > OAuth की सहमति वाली स्क्रीन पर जाएं.
उस स्क्रीन पर जाएं जहां OAuth के लिए सहमति दी जाती है
उपयोगकर्ता टाइप के लिए इंटरनल चुनें. इसके बाद, बनाएं पर क्लिक करें.
ऐप्लिकेशन रजिस्ट्रेशन फ़ॉर्म भरें. इसके बाद, सेव करें और जारी रखें पर क्लिक करें.
फ़िलहाल, दायरों को जोड़ना स्किप किया जा सकता है. इसके बाद, सेव करें और जारी रखें पर क्लिक करें. आने वाले समय में, जब आप अपने Google Workspace संगठन के बाहर इस्तेमाल करने के लिए कोई ऐप्लिकेशन बनाएं, तो आपको उपयोगकर्ता टाइप को बाहरी में बदलना होगा. इसके बाद, अपने ऐप्लिकेशन के लिए अनुमति के ज़रूरी स्कोप जोड़ें.
अपने ऐप्लिकेशन के रजिस्ट्रेशन की खास जानकारी देखें. बदलाव करने के लिए, बदलाव करें पर क्लिक करें. अगर ऐप्लिकेशन का रजिस्ट्रेशन ठीक है, तो डैशबोर्ड पर वापस जाएं पर क्लिक करें.

डेस्कटॉप ऐप्लिकेशन के लिए क्रेडेंशियल को अनुमति दें

असली उपयोगकर्ताओं की पुष्टि करने और अपने ऐप्लिकेशन में उपयोगकर्ता का डेटा ऐक्सेस करने के लिए, आपको ये काम करने होंगे एक या उससे ज़्यादा OAuth 2.0 क्लाइंट आईडी बनाएं. Client-ID का इस्तेमाल, के लिए एक ऐप्लिकेशन बनाया है. अगर आपका ऐप्लिकेशन एक से ज़्यादा प्लैटफ़ॉर्म पर चलता है, आपको हर प्लैटफ़ॉर्म के लिए एक अलग क्लाइंट आईडी बनाना होगा.

Google Cloud Console में, मेन्यू > एपीआई और सेवाएं > क्रेडेंशियल.
क्रेडेंशियल पर जाएं
क्रेडेंशियल बनाएं > OAuth क्लाइंट आईडी पर क्लिक करें.
ऐप्लिकेशन टाइप > डेस्कटॉप ऐप्लिकेशन पर क्लिक करें.
नाम फ़ील्ड में, क्रेडेंशियल के लिए कोई नाम लिखें. यह नाम सिर्फ़ Google Cloud Console में दिखता है.
बनाएं पर क्लिक करें. OAuth क्लाइंट की बनाई गई स्क्रीन दिखेगी. इसमें आपका नया क्लाइंट आईडी और क्लाइंट सीक्रेट दिखेगा.
ठीक है पर क्लिक करें. नया क्रेडेंशियल, OAuth 2.0 क्लाइंट आईडी के तहत दिखता है.
डाउनलोड की गई JSON फ़ाइल को credentials.json के तौर पर सेव करें और फ़ाइल को अपनी वर्किंग डायरेक्ट्री में सेव कर सकते हैं.

वर्कस्पेस तैयार करना

एक मौजूदा डायरेक्ट्री बनाएं:
```
mkdir quickstart
```
काम करने वाली डायरेक्ट्री में बदलें:
```
cd quickstart
```
नया मॉड्यूल शुरू करें:
```
go mod init quickstart
```
Google Apps Script API की Go क्लाइंट लाइब्रेरी और OAuth2.0 पैकेज पाएं:
```
go get google.golang.org/api/script/v1
go get golang.org/x/oauth2/google
```

सैंपल सेट अप करना

अपनी वर्किंग डायरेक्ट्री में, quickstart.go नाम की फ़ाइल बनाएं.

फ़ाइल में, यह कोड चिपकाएं:

apps_script/quickstart/quickstart.go

GitHub पर देखें

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"

	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
	"google.golang.org/api/option"
	"google.golang.org/api/script/v1"
)

// Retrieve a token, saves the token, then returns the generated client.
func getClient(config *oauth2.Config) *http.Client {
	// The file token.json stores the user's access and refresh tokens, and is
	// created automatically when the authorization flow completes for the first
	// time.
	tokFile := "token.json"
	tok, err := tokenFromFile(tokFile)
	if err != nil {
		tok = getTokenFromWeb(config)
		saveToken(tokFile, tok)
	}
	return config.Client(context.Background(), tok)
}

// Request a token from the web, then returns the retrieved token.
func getTokenFromWeb(config *oauth2.Config) *oauth2.Token {
	authURL := config.AuthCodeURL("state-token", oauth2.AccessTypeOffline)
	fmt.Printf("Go to the following link in your browser then type the "+
		"authorization code: \n%v\n", authURL)

	var authCode string
	if _, err := fmt.Scan(&authCode); err != nil {
		log.Fatalf("Unable to read authorization code: %v", err)
	}

	tok, err := config.Exchange(context.TODO(), authCode)
	if err != nil {
		log.Fatalf("Unable to retrieve token from web: %v", err)
	}
	return tok
}

// Retrieves a token from a local file.
func tokenFromFile(file string) (*oauth2.Token, error) {
	f, err := os.Open(file)
	if err != nil {
		return nil, err
	}
	defer f.Close()
	tok := &oauth2.Token{}
	err = json.NewDecoder(f).Decode(tok)
	return tok, err
}

// Saves a token to a file path.
func saveToken(path string, token *oauth2.Token) {
	fmt.Printf("Saving credential file to: %s\n", path)
	f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
	if err != nil {
		log.Fatalf("Unable to cache oauth token: %v", err)
	}
	defer f.Close()
	json.NewEncoder(f).Encode(token)
}

func main() {
	ctx := context.Background()
	b, err := os.ReadFile("credentials.json")
	if err != nil {
		log.Fatalf("Unable to read client secret file: %v", err)
	}

	// If modifying these scopes, delete your previously saved token.json.
	config, err := google.ConfigFromJSON(b, "https://www.googleapis.com/auth/script.projects")
	if err != nil {
		log.Fatalf("Unable to parse client secret file to config: %v", err)
	}
	client := getClient(config)

	srv, err := script.NewService(ctx, option.WithHTTPClient(client))
	if err != nil {
		log.Fatalf("Unable to retrieve Script client: %v", err)
	}

	req := script.CreateProjectRequest{Title: "My Script"}
	createRes, err := srv.Projects.Create(&req).Do()
	if err != nil {
		// The API encountered a problem.
		log.Fatalf("The API returned an error: %v", err)
	}
	content := &script.Content{
		ScriptId: createRes.ScriptId,
		Files: []*script.File{{
			Name:   "hello",
			Type:   "SERVER_JS",
			Source: "function helloWorld() {\n  console.log('Hello, world!');}",
		}, {
			Name: "appsscript",
			Type: "JSON",
			Source: "{\"timeZone\":\"America/New_York\",\"exceptionLogging\":" +
				"\"CLOUD\"}",
		}},
	}
	updateContentRes, err := srv.Projects.UpdateContent(createRes.ScriptId,
		content).Do()
	if err != nil {
		// The API encountered a problem.
		log.Fatalf("The API returned an error: %v", err)
	}
	log.Printf("https://script.google.com/d/%v/edit", updateContentRes.ScriptId)
}

सैंपल चलाना

अपनी वर्किंग डायरेक्ट्री में, सैंपल बनाएं और चलाएं:
```
go run quickstart.go
```

पहली बार सैंपल चलाने पर, आपको ऐक्सेस की अनुमति देने के लिए कहा जाता है:
1. अगर आपने अपने Google खाते में पहले से साइन इन नहीं किया है, तो मांगे जाने पर साइन इन करें. अगर आपने अगर आपने कई खातों में साइन इन किया है, तो अनुमति देने के लिए एक खाता चुनें.
2. स्वीकार करें पर क्लिक करें.
आपका Go ऐप्लिकेशन Google Apps Script API को चलाता है और उसे कॉल करता है.

अनुमति की जानकारी फ़ाइल सिस्टम में सेव होती है, इसलिए अगली बार सैंपल चलाने पर कोड नहीं है, तो आपको प्राधिकरण के लिए संकेत नहीं दिया जाता.