commit 25ab5c9b30a546382dca5ce87ba6123466307d06 · dunkirk.sh/akami

+79

handler/main.go

···

       255
       255
        
       

     

       256
       256
        
       	return nil

     

       257
       257
        
       }

     

       258
       258
       +
       

     

       259
       259
       +
       func TestHeartbeat(c *cobra.Command, args []string) error {

     

       260
       260
       +
       	// Initialize a new context with task state

     

       261
       261
       +
       	c.SetContext(context.WithValue(context.Background(), "taskState", &taskState{}))

     

       262
       262
       +
       

     

       263
       263
       +
       	printTask(c, "Validating arguments")

     

       264
       264
       +
       

     

       265
       265
       +
       	configApiKey, _ := c.Flags().GetString("key")

     

       266
       266
       +
       	configApiURL, _ := c.Flags().GetString("url")

     

       267
       267
       +
       

     

       268
       268
       +
       	// If either value is missing, try to load from config file

     

       269
       269
       +
       	if configApiKey == "" || configApiURL == "" {

     

       270
       270
       +
       		userDir, err := os.UserHomeDir()

     

       271
       271
       +
       		if err != nil {

     

       272
       272
       +
       			errorTask(c, "Validating arguments")

     

       273
       273
       +
       			return err

     

       274
       274
       +
       		}

     

       275
       275
       +
       		wakatimePath := filepath.Join(userDir, ".wakatime.cfg")

     

       276
       276
       +
       

     

       277
       277
       +
       		cfg, err := ini.Load(wakatimePath)

     

       278
       278
       +
       		if err != nil {

     

       279
       279
       +
       			errorTask(c, "Validating arguments")

     

       280
       280
       +
       			return errors.New("config file not found and you haven't passed all arguments")

     

       281
       281
       +
       		}

     

       282
       282
       +
       

     

       283
       283
       +
       		settings, err := cfg.GetSection("settings")

     

       284
       284
       +
       		if err != nil {

     

       285
       285
       +
       			errorTask(c, "Validating arguments")

     

       286
       286
       +
       			return errors.New("no settings section in your config")

     

       287
       287
       +
       		}

     

       288
       288
       +
       

     

       289
       289
       +
       		// Only load from config if not provided as parameter

     

       290
       290
       +
       		if configApiKey == "" {

     

       291
       291
       +
       			configApiKey = settings.Key("api_key").String()

     

       292
       292
       +
       			if configApiKey == "" {

     

       293
       293
       +
       				errorTask(c, "Validating arguments")

     

       294
       294
       +
       				return errors.New("couldn't find an api_key in your config")

     

       295
       295
       +
       			}

     

       296
       296
       +
       		}

     

       297
       297
       +
       

     

       298
       298
       +
       		if configApiURL == "" {

     

       299
       299
       +
       			configApiURL = settings.Key("api_url").String()

     

       300
       300
       +
       			if configApiURL == "" {

     

       301
       301
       +
       				errorTask(c, "Validating arguments")

     

       302
       302
       +
       				return errors.New("couldn't find an api_url in your config")

     

       303
       303
       +
       			}

     

       304
       304
       +
       		}

     

       305
       305
       +
       	}

     

       306
       306
       +
       

     

       307
       307
       +
       	completeTask(c, "Arguments look fine!")

     

       308
       308
       +
       

     

       309
       309
       +
       	printTask(c, "Loading api client")

     

       310
       310
       +
       

     

       311
       311
       +
       	client := wakatime.NewClientWithOptions(configApiKey, configApiURL)

     

       312
       312
       +
       	_, err := client.GetStatusBar()

     

       313
       313
       +
       	if err != nil {

     

       314
       314
       +
       		errorTask(c, "Loading api client")

     

       315
       315
       +
       		return err

     

       316
       316
       +
       	}

     

       317
       317
       +
       

     

       318
       318
       +
       	completeTask(c, "Loading api client")

     

       319
       319
       +
       

     

       320
       320
       +
       	c.Println("Sending a test heartbeat to", styles.Muted.Render(configApiURL))

     

       321
       321
       +
       

     

       322
       322
       +
       	printTask(c, "Sending test heartbeat")

     

       323
       323
       +
       

     

       324
       324
       +
       	err = client.SendHeartbeat(testHeartbeat)

     

       325
       325
       +
       

     

       326
       326
       +
       	if err != nil {

     

       327
       327
       +
       		errorTask(c, "Sending test heartbeat")

     

       328
       328
       +
       		return err

     

       329
       329
       +
       	}

     

       330
       330
       +
       

     

       331
       331
       +
       	completeTask(c, "Sending test heartbeat")

     

       332
       332
       +
       

     

       333
       333
       +
       	c.Println("❇️ test heartbeat sent!")

     

       334
       334
       +
       

     

       335
       335
       +
       	return nil

     

       336
       336
       +
       }

+10

main.go

···

       32
       32
        
       		RunE:  handler.Doctor,

     

       33
       33
        
       	})

     

       34
       34
        
       

     

       35
       35
       +
       	cmdTest := &cobra.Command{

     

       36
       36
       +
       		Use:   "test",

     

       37
       37
       +
       		Short: "send a test heartbeat to hackatime or whatever api url you provide",

     

       38
       38
       +
       		RunE:  handler.TestHeartbeat,

     

       39
       39
       +
       		Args:  cobra.NoArgs,

     

       40
       40
       +
       	}

     

       41
       41
       +
       	cmdTest.Flags().StringP("url", "u", "", "The base url for the hackatime client")

     

       42
       42
       +
       	cmdTest.Flags().StringP("key", "k", "", "API key to use for authentication")

     

       43
       43
       +
       	cmd.AddCommand(cmdTest)

     

       44
       44
       +
       

     

       35
       45
        
       	// this is where we get the fancy fang magic ✨

     

       36
       46
        
       	if err := fang.Execute(

     

       37
       47
        
       		context.Background(),