Golang开源量化自我与物联网数据管理平台插件库connectordb的使用

Heedy简介

Heedy是一个个人数据仓库和可扩展的分析引擎，专为量化自我和物联网数据管理而设计。它解决了现有服务数据孤岛的问题，将所有数据集中到一个自托管的开源系统中。

主要特点

1. 开源且自托管：保证数据隐私和安全，完全由用户自己控制
2. 可扩展：通过插件系统可以添加新功能、集成其他服务或修改核心功能

运行Heedy

Heedy支持Mac和Linux系统（包括树莓派），通过命令行启动：

chmod +x ./heedy  # 允许执行文件
./heedy           # 运行heedy

然后访问 http://localhost:1324 设置数据库。

Docker运行方式

mkdir myheedy
docker run --rm -d -p 1324:1324 -v $PWD/myheedy:/data --user $UID --name heedy dkumor/heedy

插件系统

Heedy的强大功能主要来自插件系统。一些值得关注的插件：

• fitbit - 与Fitbit同步，访问和分析可穿戴设备数据
• notebook - 在Heedy中直接使用Jupyter笔记本分析数据

Golang连接示例

以下是一个使用Golang连接Heedy API的基本示例：

package main

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

// HeedyAPI 表示与Heedy服务器的连接
type HeedyAPI struct {
	BaseURL string
	Token   string
}

// NewHeedyAPI 创建一个新的Heedy API客户端
func NewHeedyAPI(baseURL, token string) *HeedyAPI {
	return &HeedyAPI{
		BaseURL: baseURL,
		Token:   token,
	}
}

// GetUser 获取当前用户信息
func (h *HeedyAPI) GetUser() (map[string]interface{}, error) {
	url := fmt.Sprintf("%s/api/users/@me", h.BaseURL)
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	
	req.Header.Set("X-Heedy-As", "admin")
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", h.Token))
	
	client := &http.Client{}
	resp, err := 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
	}
	
	var result map[string]interface{}
	err = json.Unmarshal(body, &result)
	if err != nil {
		return nil, err
	}
	
	return result, nil
}

// CreateStream 创建一个新的数据流
func (h *HeedyAPI) CreateStream(name, schema string) (map[string]interface{}, error) {
	url := fmt.Sprintf("%s/api/streams", h.BaseURL)
	
	data := map[string]interface{}{
		"name":   name,
		"schema": schema,
	}
	
	jsonData, err := json.Marshal(data)
	if err != nil {
		return nil, err
	}
	
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return nil, err
	}
	
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Heedy-As", "admin")
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", h.Token))
	
	client := &http.Client{}
	resp, err := 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
	}
	
	var result map[string]interface{}
	err = json.Unmarshal(body, &result)
	if err != nil {
		return nil, err
	}
	
	return result, nil
}

func main() {
	// 初始化Heedy API客户端
	api := NewHeedyAPI("http://localhost:1324", "your_access_token_here")
	
	// 获取用户信息
	user, err := api.GetUser()
	if err != nil {
		fmt.Printf("Error getting user: %v\n", err)
		return
	}
	fmt.Printf("User info: %+v\n", user)
	
	// 创建新的数据流
	stream, err := api.CreateStream("temperature", "number")
	if err != nil {
		fmt.Printf("Error creating stream: %v\n", err)
		return
	}
	fmt.Printf("Created stream: %+v\n", stream)
}

数据流操作示例

以下是一个更完整的示例，展示如何创建数据流并插入数据：

package main

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

type HeedyClient struct {
	BaseURL string
	Token   string
}

func NewHeedyClient(baseURL, token string) *HeedyClient {
	return &HeedyClient{
		BaseURL: baseURL,
		Token:   token,
	}
}

// InsertData 向指定流中插入数据
func (h *HeedyClient) InsertData(streamID string, data interface{}) error {
	url := fmt.Sprintf("%s/api/streams/%s/data", h.BaseURL, streamID)
	
	jsonData, err := json.Marshal(data)
	if err != nil {
		return err
	}
	
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return err
	}
	
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Heedy-As", "admin")
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", h.Token))
	
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	
	if resp.StatusCode != http.StatusOK {
		body, _ := ioutil.ReadAll(resp.Body)
		return fmt.Errorf("API error: %s - %s", resp.Status, string(body))
	}
	
	return nil
}

// QueryData 查询流数据
func (h *HeedyClient) QueryData(streamID string, query map[string]interface{}) ([]interface{}, error) {
	url := fmt.Sprintf("%s/api/streams/%s/data/query", h.BaseURL, streamID)
	
	jsonData, err := json.Marshal(query)
	if err != nil {
		return nil, err
	}
	
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return nil, err
	}
	
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Heedy-As", "admin")
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", h.Token))
	
	client := &http.Client{}
	resp, err := 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
	}
	
	var result []interface{}
	err = json.Unmarshal(body, &result)
	if err != nil {
		return nil, err
	}
	
	return result, nil
}

func main() {
	client := NewHeedyClient("http://localhost:1324", "your_access_token_here")
	
	// 插入温度数据
	tempData := map[string]interface{}{
		"t": time.Now().Unix(),
		"d": 22.5,
	}
	
	err := client.InsertData("temperature", tempData)
	if err != nil {
		fmt.Printf("Error inserting data: %v\n", err)
		return
	}
	fmt.Println("Data inserted successfully")
	
	// 查询最近24小时的数据
	query := map[string]interface{}{
		"t1": time.Now().Add(-24 * time.Hour).Unix(),
		"t2": time.Now().Unix(),
	}
	
	data, err := client.QueryData("temperature", query)
	if err != nil {
		fmt.Printf("Error querying data: %v\n", err)
		return
	}
	
	fmt.Printf("Query results: %+v\n", data)
}

构建Heedy

要构建Heedy，需要Go 1.18+和Node.js环境：

git clone https://github.com/heedy/heedy
cd heedy
make

调试版本使用：

make debug

Heedy提供了一个强大的平台来管理个人和物联网数据，通过Golang可以方便地与其API交互，实现数据的收集、存储和分析。