datadis.go

// Package datadis provides a client for the Datadis API to fetch electricity consumption data.
// Datadis is a Spanish electricity data platform that provides access to consumption information.
package datadis

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
	"time"
)

// Client represents a Datadis API client with authentication token and HTTP client.
type Client struct {
	client  *http.Client
	token   string
	baseURL string
}

// Supply represents an electricity supply point with associated metadata.
type Supply struct {
	Address         string `json:"address"`
	Cups            string `json:"cups"`
	Province        string `json:"province"`
	DistributorCode string `json:"distributorCode"`
	PostalCode      string `json:"postalCode"`
	Municipality    string `json:"municipality"`
	Distributor     string `json:"distributor"`
	PointType       int    `json:"pointType"`
	ValidDateFrom   string `json:"validDateFrom"`
	ValidDateTo     string `json:"validDateTo"`
}

// Measurment represents a single electricity consumption measurement.
type Measurment struct {
	Cups         string  `json:"cups"`
	Date         string  `json:"date"`
	Time         string  `json:"time"`
	Consumption  float32 `json:"consumptionKWh"`
	ObtainMethod string  `json:"obtainMethod"`
}

// NewClient creates and returns a new Datadis API client with default configuration.
func NewClient() *Client {
	return &Client{
		client:  &http.Client{},
		baseURL: "https://datadis.es/api-private/api",
	}
}

// Login authenticates with the Datadis API using the provided username and password.
// On successful login, the authentication token is stored in the client for subsequent API calls.
// Returns an error if the login fails or if the HTTP request encounters an issue.
func (c *Client) Login(username, password string) error {
	req, err := http.NewRequest("POST", fmt.Sprintf("https://datadis.es/nikola-auth/tokens/login?username=%s&password=%s", username, password), nil)
	if err != nil {
		return err
	}
	req.Header.Add("Content-Type", "text/plain")
	resp, err := c.client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	token, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return err
	}

	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("login failed (status %d): %s", resp.StatusCode, string(token))
	}

	c.token = string(token)

	return nil
}

// ConsumptionData retrieves electricity consumption measurements for a given supply within a date range.
// The from and to parameters specify the time range (formatted as YYYY/MM).
// Returns a slice of Measurment objects containing consumption data, or an error if the request fails.
// The API response is validated for HTTP status code before parsing JSON.
func (c *Client) ConsumptionData(supply *Supply, from, to time.Time) ([]Measurment, error) {
	sto := to.Format("2006/01")
	sfrom := from.Format("2006/01")
	query := fmt.Sprintf("cups=%s&distributorCode=%s&startDate=%s&endDate=%s&measurementType=%d&pointType=%d", supply.Cups, supply.DistributorCode, url.QueryEscape(sfrom), url.QueryEscape(sto), 0, supply.PointType)
	u := fmt.Sprintf("%s/get-consumption-data?%s", c.baseURL, query)
	req, err := http.NewRequest("GET", u, nil)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Accept", "application/json")
	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", c.token))
	resp, err := c.client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("API error (status %d): %s", resp.StatusCode, string(body))
	}

	var measurements []Measurment
	err = json.Unmarshal(body, &measurements)
	if err != nil {
		return nil, fmt.Errorf("failed to parse JSON response: %w (body: %s)", err, string(body))
	}

	return measurements, nil
}

// Supplies retrieves the list of electricity supply points associated with the authenticated account.
// Returns a slice of Supply objects, or an error if the request fails.
// The API response is validated for HTTP status code before parsing JSON.
func (c *Client) Supplies() ([]Supply, error) {
	u := fmt.Sprintf("%s/get-supplies", c.baseURL)
	req, err := http.NewRequest("GET", u, nil)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Accept", "application/json")
	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", c.token))
	resp, err := c.client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("API error (status %d): %s", resp.StatusCode, string(body))
	}

	var supplies []Supply
	err = json.Unmarshal(body, &supplies)
	if err != nil {
		return nil, fmt.Errorf("failed to parse JSON response: %w (body: %s)", err, string(body))
	}

	return supplies, nil
}