ElasticView

English

简体中文

English

简体中文

Appearance

Backend Development ​

Learn how to implement the server-side logic for your ElasticView plugin using Go.

Technology Stack ​

Core Technologies ​

  • Go: Primary programming language
  • Gin: HTTP web framework
  • GORM: ORM for database operations

Plugin Implementation ​

Main Plugin Structure ​

go
// main.go
package main

import (
    "github.com/gin-gonic/gin"
    "github.com/1340691923/ElasticView/pkg/plugin"
)

type MyPlugin struct {
    plugin.BasePlugin
    config *Config
}

// Config represents plugin configuration
type Config struct {
    APIKey          string `json:"api_key"`
    RefreshInterval int    `json:"refresh_interval"`
}

// Init initializes the plugin
func (p *MyPlugin) Init() error {
    // Load configuration
    if err := p.LoadConfig(&p.config); err != nil {
        return err
    }
    
    return nil
}

// Routes defines HTTP routes
func (p *MyPlugin) Routes(router *gin.RouterGroup) {
    api := router.Group("/api")
    {
        api.GET("/status", p.getStatus)
        api.GET("/data", p.getData)
        api.POST("/data", p.createData)
    }
}

func main() {
    plugin.Register(&MyPlugin{})
}

HTTP Handlers ​

Request Handlers ​

go
func (p *MyPlugin) getStatus(c *gin.Context) {
    status := map[string]interface{}{
        "status":  "active",
        "version": "1.0.0",
    }
    
    c.JSON(200, status)
}

func (p *MyPlugin) getData(c *gin.Context) {
    // Get data logic
    data := []map[string]interface{}{
        {"id": 1, "name": "Item 1"},
        {"id": 2, "name": "Item 2"},
    }
    
    c.JSON(200, gin.H{
        "data": data,
    })
}

func (p *MyPlugin) createData(c *gin.Context) {
    var req map[string]interface{}
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(400, gin.H{"error": "Invalid request"})
        return
    }
    
    // Create data logic
    c.JSON(201, gin.H{
        "message": "Data created successfully",
        "data": req,
    })
}

Database Integration ​

Data Models ​

go
type Data struct {
    ID        uint   `gorm:"primarykey" json:"id"`
    Name      string `gorm:"not null" json:"name"`
    Type      string `gorm:"not null" json:"type"`
    Value     string `gorm:"type:text" json:"value"`
    CreatedAt time.Time `json:"created_at"`
}

Configuration Management ​

go
type Config struct {
    APIKey          string `json:"api_key"`
    RefreshInterval int    `json:"refresh_interval"`
    DatabaseURL     string `json:"database_url"`
}

func (p *MyPlugin) LoadConfig(config interface{}) error {
    return p.BasePlugin.LoadConfig(config)
}

Error Handling ​

go
func (p *MyPlugin) handleError(c *gin.Context, err error) {
    c.JSON(500, gin.H{
        "error": "Internal server error",
        "message": err.Error(),
    })
}

Testing ​

Unit Tests ​

go
func TestGetStatus(t *testing.T) {
    plugin := &MyPlugin{}
    router := gin.New()
    router.GET("/status", plugin.getStatus)
    
    req := httptest.NewRequest("GET", "/status", nil)
    w := httptest.NewRecorder()
    
    router.ServeHTTP(w, req)
    
    assert.Equal(t, 200, w.Code)
}

Best Practices ​

Code Organization ​

  • Follow Go conventions and best practices
  • Use dependency injection for better testability
  • Implement proper error handling

Performance ​

  • Use connection pooling for databases
  • Implement caching for frequently accessed data
  • Use goroutines for concurrent operations

Security ​

  • Validate all inputs
  • Use parameterized queries
  • Implement proper authentication

Next Steps ​