$ serverless create -t aws-go-dep -p <project-name>

provider:
  name: aws
  runtime: go1.x
  region: ap-northeast-1

$ cd <project-name>
$ make
$ sls deploy

service: GarminStress2Pixela

frameworkVersion: ">=1.28.0 <2.0.0"

provider:
  name: aws
  runtime: go1.x
  region: ap-northeast-1
  # you can add statements to the Lambda function's IAM Role here
  iamRoleStatements:
    - Effect: "Allow"
      Action:
        - "rekognition:DetectText"
      Resource: "*"
    - Effect: "Allow"
      Action:
        - "s3:GetObject"
      Resource: [
        "arn:aws:s3:::pixela-datasource-stress-img-bucket",
        "arn:aws:s3:::pixela-datasource-stress-img-bucket/*"
      ]

package:
 exclude:
   - ./**
 include:
   - ./bin/**

functions:
  garmin-stress2pixela:
    handler: bin/garmin-stress2pixela
    events:
      - s3: <bucket-name>
    # you need to fill the followings with your own
    environment:
      PIXELA_USER: <user-id>
      PIXELA_TOKEN: <your-token>
      PIXELA_GRAPH: <your-graph-id-1>
    timeout: 10

package main

import (
	"context"
	"fmt"
	"math"
	"os"
	"regexp"
	"strings"

	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/rekognition"
	pixela "github.com/gainings/pixela-go-client"
)

// Point is left & top positions of bounding box in the Rekognition result
type Point struct {
	Left float64
	Top  float64
}

// !! fixed number from experiment (maybe require to change your env) !!
var assumedDatePoint = Point{Left: 0.393, Top: 0.111}
var assumedQuantityPoint = Point{Left: 0.268, Top: 0.282}

// Handler is our lambda handler invoked by the `lambda.Start` function call
func Handler(ctx context.Context, s3Event events.S3Event) error {
	// for each s3 object
	for _, record := range s3Event.Records {
		// extract s3 object info
		bucket, key := getS3ObjectFromRecord(record)
		fmt.Printf("[%s] Bucket = %s, Key = %s \n", record.EventSource, bucket, key)

		// execute text detection of Rekognition
		res, rekerr := exeRekognitionDetectText(bucket, key)
		if rekerr != nil {
			fmt.Println("Error")
			fmt.Println(rekerr.Error())
		}

		// extract date & quantity from the above result
		date, quantity := getValueFromRekognitionResult(res.TextDetections)
		fmt.Printf("data: %s, quantity: %s\n", date, quantity)

		// record pixel
		perr := recordPixel(date, quantity)
		fmt.Println(perr)
	}

	return nil
}

func getS3ObjectFromRecord(record events.S3EventRecord) (string, string) {
	s := record.S3
	bucket := s.Bucket.Name
	rep := regexp.MustCompile(`[+]`)
	key := rep.ReplaceAllString(s.Object.Key, " ")

	return bucket, key
}

func exeRekognitionDetectText(bucket, key string) (*rekognition.DetectTextOutput, error) {
	// create Rekognition client
	sess := session.Must(session.NewSession())
	rc := rekognition.New(sess, aws.NewConfig().WithRegion("ap-northeast-1"))

	// set params
	params := &rekognition.DetectTextInput{
		Image: &rekognition.Image{
			S3Object: &rekognition.S3Object{
				Bucket: aws.String(bucket),
				Name:   aws.String(key),
			},
		},
	}
	fmt.Printf("params: %s", params)

	// execute DetectText
	return rc.DetectText(params)
}

func getValueFromRekognitionResult(results []*rekognition.TextDetection) (string, string) {
	dateHypot, quantityHypot := math.MaxFloat64, math.MaxFloat64
	date, quantity := "", ""

	// for each detected text
	for _, td := range results {
		left, top := *td.Geometry.BoundingBox.Left, *td.Geometry.BoundingBox.Top

		// calc hypot with assumed date pos & update value
		tmpDHypot := math.Hypot(math.Abs(left-assumedDatePoint.Left), math.Abs(top-assumedDatePoint.Top))
		if tmpDHypot < dateHypot {
			// if td is most-likely-result (nearest to the assumed point), keep the result (with removing "/")
			dateHypot, date = tmpDHypot, strings.Replace(*td.DetectedText, "/", "", -1)
		}

		// calc hypot with assumed quantity pos & update value
		tmpQHypot := math.Hypot(math.Abs(left-assumedQuantityPoint.Left), math.Abs(top-assumedQuantityPoint.Top))
		if tmpQHypot < quantityHypot {
			// if td is most-likely-result (nearest to the assumed point), keep the result
			quantityHypot, quantity = tmpQHypot, *td.DetectedText
		}
	}

	return date, quantity
}

func recordPixel(date, quantity string) error {
	user := os.Getenv("PIXELA_USER")
	token := os.Getenv("PIXELA_TOKEN")
	graph := os.Getenv("PIXELA_GRAPH")
	c := pixela.NewClient(user, token)

	// try to record
	err := c.RegisterPixel(graph, date, quantity)
	if err == nil {
		fmt.Println("recorded")
		return err
	}

	// if fail, try to update
	err = c.UpdatePixelQuantity(graph, date, quantity)
	if err == nil {
		fmt.Println("updated")
	}

	return err
}

func main() {
	lambda.Start(Handler)
}