func NewGDrive() *GDrive { var err error usr, err := user.Current() if err != nil { return nil } tokenCacheDir := filepath.Join(usr.HomeDir, ".credentials") os.MkdirAll(tokenCacheDir, 0700) tokenCacheFile := filepath.Join(tokenCacheDir, url.QueryEscape("drive-go-quickstart.json")) b, err := ioutil.ReadFile("gdrive_client_secret.json") if err != nil { logError.Printf("Unable to read client secret file: %v", err) return nil } cfg, err := google.ConfigFromJSON(b, drive.DriveScope) if err != nil { logError.Printf("Unable to parse client secret file to config: %v", err) return nil } return &GDrive{ clientSecret: "gdrive_client_secret.json", cacheFile: tokenCacheFile, config: cfg, } }
// CreateGmailConfig returns OAuth 2.0 config. func CreateGmailConfig() (*oauth2.Config, error) { b, err := readClient() if err != nil { return nil, err } return google.ConfigFromJSON(b, gmail.GmailComposeScope, gmail.GmailModifyScope) }
func main() { ctx := context.Background() b, err := ioutil.ReadFile("client_secret.json") if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(b, drive.DriveMetadataReadonlyScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } client := getClient(ctx, config) srv, err := drive.New(client) if err != nil { log.Fatalf("Unable to retrieve drive Client %v", err) } r, err := srv.Files.List().PageSize(100). Fields("nextPageToken, files(id, name)").Do() if err != nil { log.Fatalf("Unable to retrieve files.", err) } fmt.Println("Files:") if len(r.Files) > 0 { for _, i := range r.Files { fmt.Printf("%s (%s)\n", i.Name, i.Id) } } else { fmt.Print("No files found.") } }
// InstalledAppClient creates an oauth authenticated client for an installed // app based on the credentials from the developer console from an // account labeled 'Client ID for native application'. // cacheFilePath is the path to where the token should be cached, // configFilePath is the path to the config file downloaded from GCE and // scopes is the list of desired oauth2 scopes. // If transport is nil, the default transport will be used. // If the cache file does not contain a token the oauth2 flow will be trigger. func InstalledAppClient(cacheFilePath, configFilePath string, transport http.RoundTripper, scopes ...string) (*http.Client, error) { jsonKey, err := ioutil.ReadFile(configFilePath) if err != nil { return nil, err } config, err := google.ConfigFromJSON(jsonKey, scopes...) if err != nil { return nil, err } tokenSource, err := newCachingTokenSource(cacheFilePath, oauth2.NoContext, config) if err != nil { return nil, err } client := &http.Client{ Transport: &oauth2.Transport{ Source: tokenSource, Base: transport, }, Timeout: util.REQUEST_TIMEOUT, } return client, nil }
func getFilesFromGDrive() { ctx := context.Background() b, err := ioutil.ReadFile("client_secret.json") if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(b, drive.DriveMetadataReadonlyScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } client := gdrive.GetClient(ctx, config) srv, err := drive.New(client) if err != nil { log.Fatalf("Unable to retrieve drive Client %v", err) } r, err := srv.Files.List().MaxResults(10).Do() if err != nil { log.Fatalf("Unable to retrieve files.", err) } fmt.Println("Files:") if len(r.Items) > 0 { for _, i := range r.Items { fmt.Printf("%s (%s)\n", i.Title, i.Id) } } else { fmt.Print("No files found.") } }
// InitFromMetadataOrJSON must be called before any other login methods. // // InitFromMetadataOrJSON will eventually replace all instances of Init, at // which point it will be renamed back to Init(). // // The function first tries to load the cookie salt, client id, and client // secret from GCE project level metadata. If that fails it looks for a // "client_secret.json" file in the current directory to extract the client id // and client secret from. If both of those fail then it returns an error. // // The authWhiteList is the space separated list of domains and email addresses // that are allowed to log in. The authWhiteList will be overwritten from // GCE instance level metadata if present. func InitFromMetadataOrJSON(redirectURL, scopes string, authWhiteList string) error { cookieSalt, clientID, clientSecret := tryLoadingFromMetadata() if clientID == "" { b, err := ioutil.ReadFile("client_secret.json") if err != nil { return fmt.Errorf("Failed to read from metadata and from client_secret.json file: %s", err) } config, err := google.ConfigFromJSON(b) if err != nil { return fmt.Errorf("Failed to read from metadata and decode client_secret.json file: %s", err) } clientID = config.ClientID clientSecret = config.ClientSecret } secureCookie = securecookie.New([]byte(cookieSalt), nil) oauthConfig.ClientId = clientID oauthConfig.ClientSecret = clientSecret oauthConfig.RedirectURL = redirectURL oauthConfig.Scope = scopes // We allow for meta data to not be present. whiteList, err := metadata.Get(metadata.AUTH_WHITE_LIST) if err != nil { glog.Infof("Failed to retrieve auth whitelist from instance meta data: %s", err) } else { authWhiteList = whiteList } activeDomainWhiteList, activeEmailWhiteList = splitAuthWhiteList(authWhiteList) return nil }
func uploadfile(filename string) { ctx := context.Background() b, err := ioutil.ReadFile("client_secret.json") if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(b, drive.DriveScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } client := getClient(ctx, config) svn, err := drive.New(client) fmt.Printf("Svn type is %T\n", svn) if err != nil { log.Fatalf("Unable to retrieve drive Client %v", err) } m, err := os.Open(filename) if err != nil { fmt.Printf("An error occurred: %v\n", err) } //f := &drive.File{Title: filename} fmt.Printf("\nHi\n") r, err := svn.Files.Insert(&drive.File{Title: filename}).Media(m).Do() if err != nil { fmt.Printf("An error occurred: %v\n", err) } defer m.Close() fmt.Printf("\nBye\n %T", r) }
func (c *Cal2Command) runGoogle(args []string) int { ctx, _ := context.WithTimeout(context.Background(), 1*time.Minute) config, err := google.ConfigFromJSON([]byte(clientSecret), calendar.CalendarScope) if err != nil { c.UI.Error(fmt.Sprintf("unable to parse client secrete file to config: %v", err)) return failure } u, err := stringInput(c.UI, "Username:"******"unable to retrieve calendar client %v", err)) return failure } events, err := srv.Events.List("primary"). ShowDeleted(false). SingleEvents(true). TimeMin(time.Now().AddDate(0, -1, 0).Format(time.RFC3339)). OrderBy("startTime").Do() if err != nil { c.UI.Error(fmt.Sprintf("unable to retrieve user events: $v", err)) return failure } n := 0 recurring := map[string]bool{} for _, e := range events.Items { if e.RecurringEventId != "" { recurring[e.RecurringEventId] = true continue // don't ingest recurring instances } c.UI.Output(fmt.Sprintf("Processing: %v", e.Summary)) _, err := ingestEvent(ctx, c.DBClient, c.UserID, e) if err != nil { c.UI.Error(err.Error()) return failure } n++ } for id := range recurring { e, err := srv.Events.Get("primary", id).Do() if err != nil { c.UI.Error(err.Error()) return failure } _, err = ingestEvent(ctx, c.DBClient, c.UserID, e) if err != nil { c.UI.Error(err.Error()) return failure } } return success }
func (yt *YouTube) createConfig() error { b, err := ioutil.ReadFile(yt.configFilename) if err != nil { return err } yt.config, err = google.ConfigFromJSON(b, "https://www.googleapis.com/auth/youtube") return err }
func form(c web.C, w http.ResponseWriter, r *http.Request) { b, err := ioutil.ReadFile("client_secret.json") if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) } config, err := google.ConfigFromJSON(b, drive.DriveMetadataReadonlyScope, drive.DriveFileScope, plus.UserinfoProfileScope) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) } config.RedirectURL = redirectUrl ctx := context.Background() authToken := c.Env["access-token"].(oauth2.Token) plusClient := config.Client(ctx, &authToken) plusService, err := plus.New(plusClient) user, err := plusService.People.Get("me").Do() if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) } templateData := make(map[string]interface{}) templateData["Image"] = user.Image.Url templateData["Name"] = user.DisplayName session, err := store.Get(r, "p2drive") if err != nil { http.Error(w, err.Error(), 500) return } if flashes := session.Flashes("error"); len(flashes) > 0 { templateData["ErrorFlash"] = flashes[0] } if flashes := session.Flashes("success"); len(flashes) > 0 { templateData["SuccessFlash"] = flashes[0] } session.Save(r, w) if err := templates.Render(w, "projects-param2drive-form.html", templateData); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) } }
func GetConfig() *oauth2.Config { b, err := ioutil.ReadFile("client_id.json") if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(b, gmail.GmailModifyScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } return config }
func GoogleAuthConfig(keyPath string, debug bool) *oauth2.Config { jsonKey, err := ioutil.ReadFile(keyPath) if err != nil { log.Fatal(err) } conf, _ := google.ConfigFromJSON(jsonKey, "profile") if debug { conf.RedirectURL = "http://localhost:8080/auth/google/callback" } return conf }
func main() { client_secret_file := flag.String("client_secret_file", "", "Full Path of Client Secret File") gDrive_folder_id := flag.String("gDrive_folder_id", "", "Folder ID of Google Drive") backup_package_file := flag.String("backup_file", "", "Full Paht of backup file") flag.Parse() if *client_secret_file == "" || *gDrive_folder_id == "" || *backup_package_file == "" { fmt.Println("Please Input all arguments") os.Exit(-1) } else { ctx := context.Background() b, err := ioutil.ReadFile(*client_secret_file) if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(b, drive.DriveScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } client := getClient(ctx, config) srv, err := drive.New(client) if err != nil { log.Fatalf("Unable to create Drive service: %v", err) } fmt.Println("Client Secret File -> ", *client_secret_file) fmt.Println("Google Driver Folder ID -> ", *gDrive_folder_id) fmt.Println("Backup File Name -> ", *backup_package_file) goFile, err := os.Open(*backup_package_file) uploadfiles := new(drive.File) p := &drive.ParentReference{Id: *gDrive_folder_id} uploadfiles.Parents = []*drive.ParentReference{p} currentTime := time.Now() uploadfiles.Title = fmt.Sprintf("%04d%02d%02d-%02d%02d.tar.bz2", currentTime.Year(), currentTime.Month(), currentTime.Day(), currentTime.Hour(), currentTime.Minute()) r, err := srv.Files.Insert(uploadfiles).Media(goFile).Do() if err != nil { log.Fatalf("Unable to retrieve files.", err) } fmt.Println("\n\nDownload URL = ", r.DownloadUrl, " \n File ID = ", r.Id, "\n File Name = ", r.OriginalFilename) } }
func initGoogleCalendarApi() { b, err := ioutil.ReadFile("/etc/sac/google_api_secret.json") if err != nil { Log.Fatalf("Unable to read client secret file: %v", err) } oauthConfig, err = google.ConfigFromJSON(b, calendar.CalendarReadonlyScope) if err != nil { Log.Fatalf("Unable to parse client secret file to config: %v", err) } Log.Info("Read Google API oauth config.") }
func main() { ctx := context.Background() b, err := ioutil.ReadFile("client_secret.json") if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(b, gmail.GmailReadonlyScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } client := getClient(ctx, config) srv, err := gmail.New(client) if err != nil { log.Fatalf("Unable to retrieve gmail Client %v", err) } user := "******" r, err := srv.Users.Labels.List(user).Do() if err != nil { log.Fatalf("Unable to retrieve labels. %v", err) } if len(r.Labels) > 0 { fmt.Print("Labels:\n") for _, l := range r.Labels { fmt.Printf("- %s\n", l.Name) } } else { fmt.Print("No labels found.") } msgsCall := srv.Users.Messages.List(user) msgsCall.MaxResults(1) msgs, er := msgsCall.Do() if er != nil { log.Fatalf("Unable to retrieve messages. %v", er) } if len(msgs.Messages) > 0 { var wg sync.WaitGroup fmt.Print("Messages:\n") for _, m := range msgs.Messages { wg.Add(1) go readAndRespond(user, srv, m, &wg) } wg.Wait() } else { fmt.Print("No messages found.") } }
func main() { ctx := context.Background() b, err := ioutil.ReadFile("client_secret.json") if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(b, calendar.CalendarReadonlyScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } client := getClient(ctx, config) srv, err := calendar.New(client) if err != nil { log.Fatalf("Unable to retrieve calendar Client %v", err) } //events, err := srv.Events.List("primary").ShowDeleted(false).SingleEvents(true).OrderBy("startTime").Do() now := time.Now() startDate := now //.AddDate(0, -1, 0) endDate := now.AddDate(0, 1, 0) fmt.Printf("Reading dates from %s to %s", startDate, now) events, err := srv.Events.List("primary").ShowDeleted(false). SingleEvents(true).TimeMin(startDate.Format(time.RFC3339)).TimeMax(endDate.Format(time.RFC3339)).OrderBy("startTime").Do() if err != nil { log.Fatalf("Unable to retrieve next ten of the user's events. %v", err) } fmt.Println("Upcoming events:") if len(events.Items) > 0 { for _, i := range events.Items { if i.Visibility != "private" && i.Visibility != "confidential" { // If the DateTime is an empty string the Event is an all-day Event. // So only Date is available. fmt.Printf("NEW ENTRY\n") js, _ := json.Marshal(i) fmt.Printf(string(js)) } } } else { fmt.Printf("No upcoming events found.\n") } var stats Stats stats, err = dumpStats(events, endDate) if err != nil { log.Fatalf("Could not dump stats. %v", err) } js, _ := json.Marshal(stats) fmt.Printf(string(js)) }
// NewGoogleDrive reads the information from the supplied secret file and // parses it into the config of a new googledrive object. It returns the newly // created object. func NewGoogleDrive(filepath string) (*GoogleDrive, error) { secret, err := ioutil.ReadFile(filepath) if err != nil { return nil, err } config, err := google.ConfigFromJSON(secret, drive.DriveScope) if err != nil { return nil, err } return &GoogleDrive{config: config}, nil }
func Handler(w http.ResponseWriter, r *http.Request) { // c := appengine.NewContext(r) b, err := ioutil.ReadFile("client_secret.json") if err != nil { panic(err) } config, err := google.ConfigFromJSON(b, drive.DriveReadonlyScope) authUrl := config.AuthCodeURL("state-token", oauth2.AccessTypeOnline) w.Header().Set("Location", authUrl) w.WriteHeader(http.StatusFound) return }
func GetGCloudClientSource(credentialsFilePath string, tokenCacheFilePath string, tryWebUI bool) (ClientSource, error) { credentialsJson, err := ioutil.ReadFile(credentialsFilePath) if err != nil { return nil, fmt.Errorf("failed to read google cloud client-secret file: %v", err) } conf, err := google.ConfigFromJSON(credentialsJson, storage.ScopeFullControl, datastore.ScopeDatastore, datastore.ScopeUserEmail, ) if err != nil { return nil, fmt.Errorf("invalid google cloud key json: %v", err) } revertToWebUI := func() (ClientSource, error) { if !tryWebUI { return nil, fmt.Errorf("OAuth2 token cache invalid.") } token, err := GetGCloudTokenViaWebUI(conf) if err != nil { return nil, fmt.Errorf("Failed to get valid gcloud token: %v", err) } if err := updateGCloudTokenCache(token, tokenCacheFilePath); err != nil { return nil, fmt.Errorf("Failed to update token cache: %v", err) } // FIXME: Token cache is not updated if token was refreshed by tokenRefresher from conf.Client return func(ctx context.Context) *http.Client { return conf.Client(ctx, token) }, nil } token, err := getGCloudTokenCached(tokenCacheFilePath) if err != nil { return revertToWebUI() } if !token.Valid() { // try refresh token, err = conf.TokenSource(oauth2.NoContext, token).Token() if err != nil { return revertToWebUI() } if updateGCloudTokenCache(token, tokenCacheFilePath); err != nil { return nil, fmt.Errorf("Failed to update token cache: %v", err) } } // FIXME: Token cache is not updated if token was refreshed by tokenRefresher from conf.Client return func(ctx context.Context) *http.Client { return conf.Client(ctx, token) }, nil }
func main() { log.SetFlags(log.LstdFlags | log.Lshortfile) googleJsonKey, err := ioutil.ReadFile(GOOGLE_CLIENT_SECRET_FILE_PATH) if err != nil { log.Fatalln("unable to read file ", GOOGLE_CLIENT_SECRET_FILE_PATH, ":", err) } facebookJsonKey, err := ioutil.ReadFile(FACEBOOK_CLIENT_SECRET_FILE_PATH) if err != nil { log.Fatalln("unable to read file ", FACEBOOK_CLIENT_SECRET_FILE_PATH, ":", err) } // do I need more scopes? // https://developers.google.com/+/domains/authentication/scopes googleConfig, err := google.ConfigFromJSON(googleJsonKey) if err != nil { log.Fatalln("unable to get google provider config:", err) } facebookConfig := &genericConfig{} err = json.Unmarshal(facebookJsonKey, facebookConfig) if err != nil { log.Fatalln("unable to get facebook provider config:", err) } //I need "profile", "email", scopes. gplus and facebook provide these by //default. goth.UseProviders( gplus.New(googleConfig.ClientID, googleConfig.ClientSecret, AUTH_CALLBACK_URL), facebook.New(facebookConfig.Client_id, facebookConfig.Client_secret, AUTH_CALLBACK_URL), ) chat = NewChat() router = pat.New() router.Get("/ws", WsHandler) router.Get("/oauth2callback", AuthCallbackHandler) router.Get("/auth/{provider}", BeginAuthHandler) router.Get("/", AuthChoiceHandler) // router.Add("GET", "/app", http.FileServer(http.Dir("app/"))) // router.PathPrefix("/app").Handler(http.FileServer(http.Dir("app/"))) http.Handle("/", router) http.Handle("/app/", http.StripPrefix("/app/", http.FileServer(http.Dir("app/")))) go http.ListenAndServeTLS(":8080", "cert.crt", "key.key", nil) http.ListenAndServe(":8000", http.HandlerFunc(redirectHandler)) }
func getNewService() (*gmail.Service, error) { b, err := ioutil.ReadFile("client_secret.json") if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(b, gmail.MailGoogleComScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } client := getClient(context.Background(), config) srv, err := gmail.New(client) return srv, err }
func NewClient(cfg Config) (*http.Client, error) { ctx := context.Background() b, err := ioutil.ReadFile(cfg.SecretFile) if err != nil { return nil, fmt.Errorf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(b, cfg.Scope) if err != nil { return nil, fmt.Errorf("Unable to parse client secret file to config: %v", err) } return getClient(ctx, config) }
func genClient(filename string) *http.Client { ctx := context.Background() b, err := ioutil.ReadFile(filename) if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(b, calendar.CalendarReadonlyScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } return getClient(filename, ctx, config) }
func getConfig() *oauth2.Config { clientIdFile, err := ioutil.ReadFile(clientIdFile) if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(clientIdFile, drive.DriveScope, calendar.CalendarScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } return config }
func getGmailConfig() (*oauth2.Config, error) { b, err := ioutil.ReadFile("client_secret.json") if err != nil { return nil, err } config, err := google.ConfigFromJSON(b, gmail.GmailReadonlyScope) if err != nil { return nil, err } return config, nil }
func main() { b, err := ioutil.ReadFile(CONFIG_DIR + "google_api_secret.json") if err != nil { Log.Fatalf("Unable to read client secret file: %v", err) } oauthConfig, err = google.ConfigFromJSON(b, calendar.CalendarReadonlyScope) if err != nil { Log.Fatalf("Unable to parse client secret file to config: %v", err) } http.HandleFunc("/register", registerHandler) http.HandleFunc("/oauth2callback", oauthCallbackHandler) Log.Fatal(http.ListenAndServeTLS(":2443", KEY_DIR+"cert.pem", KEY_DIR+"key.pem", nil)) }
func AppendLog(msg string) { ctx := context.Background() b, err := ioutil.ReadFile("client_secret.json") if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(b, drive.DriveScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } client := getClient(ctx, config) srv, err := drive.New(client) if err != nil { log.Fatalf("Unable to retrieve drive Client %v", err) } children, err := GetLog(srv, "0B14gQeVTanyZfnhwalk2OG9UVHVucHhLOE44ZHlySnpIM0FvdmYzMjNiOUZVVjEySzBzZk0") if err != nil { fmt.Println(err) } if children != nil { fileId := children.Id content, err := GetFile(srv, client, fileId) if err != nil { fmt.Println(err) return } content = content + "\n" + msg // remove redundant empty line reBlank := regexp.MustCompile(`([ \t]*\n){2,}`) output := reBlank.ReplaceAllLiteralString(content, "\n") UpdateFile(srv, fileId, output) } else { // create a new file f := &drive.File{Title: ThisWeek(), MimeType: "text/plain"} p := &drive.ParentReference{Id: "0B14gQeVTanyZfnhwalk2OG9UVHVucHhLOE44ZHlySnpIM0FvdmYzMjNiOUZVVjEySzBzZk0"} f.Parents = []*drive.ParentReference{p} _, err := srv.Files.Insert(f).Media(bytes.NewReader([]byte(msg))).Do() if err != nil { fmt.Printf("An error occurred: %v\n", err) } } }
func getCalendarEvents() []event { ctx := context.Background() b, err := ioutil.ReadFile(config.CalendarSecret) if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } calendarConfig, err := google.ConfigFromJSON(b, calendar.CalendarReadonlyScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } client := getClient(ctx, calendarConfig) srv, err := calendar.New(client) if err != nil { log.Fatalf("Unable to retrieve calendar Client %v", err) } t := time.Now().Format(time.RFC3339) events, err := srv.Events.List(config.FullCalendarID).ShowDeleted(false).SingleEvents(true).TimeMin(t).MaxResults(30).OrderBy("startTime").Do() if err != nil { log.Fatalf("Unable to retrieve next ten of the user's events. %v", err) } var compiledEvents []event for _, i := range events.Items { var dateStart, dateEnd string // If the DateTime is an empty string the Event is an all-day Event. // So only Date is available. if i.Start.DateTime != "" { startDate, _ := time.Parse(time.RFC3339, i.Start.DateTime) endDate, _ := time.Parse(time.RFC3339, i.End.DateTime) dateStart = startDate.Format("2006-01-02") dateEnd = endDate.Format("2006-01-02") } else { startDate, _ := time.Parse("2006-01-02", i.Start.Date) endDate, _ := time.Parse("2006-01-02", i.End.Date) dateStart = startDate.Format("2006-01-02") dateEnd = endDate.Format("2006-01-02") } compiledEvents = append(compiledEvents, event{Date: dateStart, EndDate: dateEnd, Event: i}) } return compiledEvents }
func main() { ctx := context.Background() b, err := ioutil.ReadFile("client_secret.json") if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(b, calendar.CalendarScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } client := getClient(ctx, config) srv, err := calendar.New(client) if err != nil { log.Fatalf("Unable to retrieve calendar Client %v", err) } args := os.Args[1:] if len(args) != 1 { log.Fatalf("Must provide a day you are working from home") } dateString := getDateString() event := &calendar.Event{ Summary: nameFromEnv() + " WFH", Location: "Home", Description: "Working from home", Start: &calendar.EventDateTime{ Date: *dateString, }, End: &calendar.EventDateTime{ Date: *dateString, }, } calendarId := calendarIdFromEnv() event, err = srv.Events.Insert(calendarId, event).Do() if err != nil { log.Fatalf("Unable to create event. %v\n", err) } fmt.Printf("Event created: %s\n", event.HtmlLink) }
func newReportsServiceWithSecret(bytes []byte) (*ar.Service, error) { config, err := google.ConfigFromJSON(bytes, ar.AdminReportsAuditReadonlyScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) return nil, err } ctx := context.Background() client := getClient(ctx, config) srv, err := ar.New(client) if err != nil { log.Fatalf("Unable to retrieve reports client %v", err) return nil, err } return srv, err }