main.go

package main

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

	"github.com/pkg/errors"
)

type Subscription struct {
	Metadata []map[string]interface{} `json:"metadata"`
}

type ContasClient struct {
	client  *http.Client
	baseURL string
}

func (c *ContasClient) GetSubscription(ctx context.Context, customerID, subscriptionID string) (Subscription, error) {

	response := struct {
		Subscription Subscription `json:"subscription"`
	}{}

	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("%s/customers/%s/subscriptions/%s", c.baseURL, customerID, subscriptionID), nil)
	if err != nil {
		return response.Subscription, errors.Wrap(err, "assembling request")
	}

	httpResponse, err := c.client.Do(req)
	if err != nil {
		return response.Subscription, errors.Wrap(err, "executing request")
	}
	defer httpResponse.Body.Close()

	if httpResponse.StatusCode != http.StatusOK {
		return response.Subscription, fmt.Errorf("status code %d", httpResponse.StatusCode)
	}

	err = json.NewDecoder(httpResponse.Body).Decode(&response)
	if err != nil {
		return response.Subscription, errors.Wrap(err, "decoding response")
	}

	return response.Subscription, nil
}

func (c *ContasClient) PatchSubscriptionSite(ctx context.Context, customerID, subscriptionID string, site string) error {
	request := map[string]interface{}{
		"subscription": map[string]interface{}{
			"site": site,
		},
	}
	buf, err := json.Marshal(request)
	fmt.Println(string(buf))
	if err != nil {
		return errors.Wrap(err, "marshalling body")
	}

	req, err := http.NewRequest(http.MethodPatch, fmt.Sprintf("%s/customers/%s/subscriptions/%s", c.baseURL, customerID, subscriptionID), bytes.NewBuffer(buf))
	if err != nil {
		return errors.Wrap(err, "assembling request")
	}
	req.Header.Add("Content-Type", "application/json")

	response, err := c.client.Do(req)
	if err != nil {
		return errors.Wrap(err, "executing request")
	}
	if response.StatusCode != http.StatusOK {
		io.Copy(os.Stdout, response.Body)
		return fmt.Errorf("status code %d", response.StatusCode)
	}
	return response.Body.Close()
}

type AuthMiddlware struct {
	http.RoundTripper
	token string
}

func (a *AuthMiddlware) RoundTrip(r *http.Request) (*http.Response, error) {
	r.Header.Add("Authorization", fmt.Sprintf("Apikey %s", a.token))
	return a.RoundTripper.RoundTrip(r)
}

func main() {
	httpClient := &http.Client{}
	httpClient.Transport = &AuthMiddlware{RoundTripper: http.DefaultTransport, token: "3b9be88c-80ec-497f-8dae-c4bf910e23ae"}
	client := ContasClient{client: httpClient, baseURL: "https://contas.rdstation.com.br/api/v1"}

	ctx := context.Background()

	r := csv.NewReader(os.Stdin)
	for {
		record, err := r.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatal(err)
		}

		customerID := record[1]
		site := record[2]
		subscriptionID := record[3]

		subs, err := client.GetSubscription(ctx, customerID, subscriptionID)
		if err != nil {
			log.Println(customerID)
			log.Println(err)
		}
		var actualSite string
		for _, m := range subs.Metadata {
			v, ok := m["key"]
			if ok && v.(string) == "site" {
				actualSite = m["value"].(string)
			}
		}

		if actualSite != site {
			log.Printf("\n\tactual %s\n\texpected %s\n", actualSite, site)
			log.Printf("patching customer %s\n", customerID)
			err = client.PatchSubscriptionSite(ctx, customerID, subscriptionID, site)
			if err != nil {
				log.Println(customerID)
				log.Println(err)
			}
			continue
		}

		log.Printf("customer %s ok", customerID)
	}
}