277 lines
6.6 KiB
Go
277 lines
6.6 KiB
Go
package main
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"gitea.seeseepuff.be/seeseemelk/mysqlite"
|
|
"github.com/gin-gonic/gin"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type App struct {
|
|
db *mysqlite.Db
|
|
}
|
|
|
|
func (a *App) postCreateDevice(c *gin.Context) {
|
|
qr, err := strconv.Atoi(c.PostForm("asset-qr"))
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("invalid qr: %v", err))
|
|
}
|
|
|
|
tx, err := a.db.Begin()
|
|
defer tx.MustRollback()
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error beginning tx: %v", err))
|
|
return
|
|
}
|
|
|
|
err = a.DeleteAsset(tx, qr)
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error removing assets: %v", err))
|
|
return
|
|
}
|
|
|
|
// Insert the asset into the database
|
|
var id int
|
|
err = a.createAsset("asset", tx, c, &id)
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error inserting asset: %v", err))
|
|
return
|
|
}
|
|
assetType := c.PostForm("asset-type")
|
|
err = a.createAsset(assetType, tx, c, &id)
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error inserting asset type: %v", err))
|
|
return
|
|
}
|
|
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
|
|
err = tx.Commit()
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
c.Redirect(http.StatusSeeOther, "/")
|
|
}
|
|
|
|
func (a *App) createAsset(assetType string, tx *mysqlite.Tx, c *gin.Context, assetId *int) error {
|
|
for _, assetDescriptor := range DescriptorTree.AssetTypes {
|
|
if assetDescriptor.Id != assetType {
|
|
continue
|
|
}
|
|
|
|
var fields []string
|
|
var questions []string
|
|
var values []string
|
|
|
|
for _, field := range assetDescriptor.Fields {
|
|
fields = append(fields, field.Id)
|
|
questions = append(questions, "?")
|
|
values = append(values, c.PostForm(assetType+"-"+field.Id))
|
|
}
|
|
|
|
if *assetId != 0 {
|
|
fields = append(fields, "asset")
|
|
questions = append(questions, "?")
|
|
values = append(values, strconv.Itoa(*assetId))
|
|
}
|
|
|
|
fieldsStr := strings.Join(fields, ", ")
|
|
questionsStr := strings.Join(questions, ", ")
|
|
err := tx.Query(fmt.Sprintf("INSERT INTO %s (%s) values (%s)", assetDescriptor.Table, fieldsStr, questionsStr)).
|
|
Bind(values).
|
|
Exec()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if *assetId == 0 {
|
|
err := tx.Query("SELECT LAST_INSERT_ROWID()").ScanSingle(assetId)
|
|
if err != nil {
|
|
return fmt.Errorf("error getting last insert id: %v", err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
return errors.New("Create Asset not implemented for type: " + assetType)
|
|
}
|
|
|
|
func (a *App) postCreateDeviceRam(c *gin.Context, qr int, tx *mysqlite.Tx) error {
|
|
var err error
|
|
capacity := 0
|
|
capacityString := c.PostForm("ram_capacity")
|
|
if capacityString != "" {
|
|
capacity, err = strconv.Atoi(c.PostForm("ram_capacity"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
switch c.PostForm("ram_capacity_unit") {
|
|
case "B":
|
|
case "KB":
|
|
capacity *= 1024
|
|
case "MB":
|
|
capacity *= 1024 * 1024
|
|
case "GB":
|
|
capacity *= 1024 * 1024 * 1024
|
|
default:
|
|
return errors.New("invalid ram_capacity_unit")
|
|
}
|
|
|
|
err = tx.Query("INSERT INTO info_ram (asset, type, capacity) VALUES (?, ?, ?)").
|
|
Bind(qr, c.PostForm("ram_type"), capacity).Exec()
|
|
return err
|
|
}
|
|
|
|
func (a *App) postCreateDeviceHdd(c *gin.Context, qr int, tx *mysqlite.Tx) error {
|
|
var err error
|
|
capacity := 0
|
|
capacityString := c.PostForm("hdd_capacity")
|
|
if capacityString != "" {
|
|
capacity, err = strconv.Atoi(c.PostForm("hdd_capacity"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
switch c.PostForm("hdd_capacity_unit") {
|
|
case "B":
|
|
case "KB":
|
|
capacity *= 1024
|
|
case "MB":
|
|
capacity *= 1024 * 1024
|
|
case "GB":
|
|
capacity *= 1024 * 1024 * 1024
|
|
default:
|
|
return errors.New("invalid hdd_capacity_unit")
|
|
}
|
|
|
|
err = tx.Query("INSERT INTO info_hdd (asset, capacity, type, form_factor, connection, rpm) VALUES (?, ?, ?, ?, ?, ?)").
|
|
Bind(qr, capacity, c.PostForm("hdd_type"), c.PostForm("hdd_form_factor"), c.PostForm("hdd_connection"), c.PostForm("hdd_rpm")).
|
|
Exec()
|
|
return err
|
|
}
|
|
|
|
type BrowseVM struct {
|
|
Assets []Asset
|
|
HasRam bool
|
|
}
|
|
|
|
type Asset struct {
|
|
Qr int
|
|
Name string
|
|
Brand string
|
|
Type string
|
|
Description string
|
|
RamType string
|
|
RamCapacity int
|
|
HddCapacity int
|
|
HddType string
|
|
HddFormFactor string
|
|
HddConnection string
|
|
HddRpm int
|
|
}
|
|
|
|
func (a *App) getBrowse(c *gin.Context) {
|
|
brands := c.QueryArray("brand")
|
|
types := c.QueryArray("type")
|
|
|
|
query := `SELECT assets.qr, assets.name, assets.brand, assets.type, assets.description,
|
|
info_ram.type, info_ram.capacity,
|
|
info_hdd.capacity, info_hdd.type, info_hdd.form_factor, info_hdd.connection, info_hdd.rpm
|
|
FROM assets
|
|
LEFT JOIN info_ram ON info_ram.asset = assets.qr
|
|
LEFT JOIN info_hdd ON info_hdd.asset = assets.qr
|
|
WHERE 1=1`
|
|
if len(brands) > 0 {
|
|
query += " AND assets.brand IN (" + placeholders(len(brands)) + ")"
|
|
}
|
|
if len(types) > 0 {
|
|
query += " AND assets.type IN (" + placeholders(len(types)) + ")"
|
|
}
|
|
query += "ORDER BY assets.type, assets.brand, assets.name, assets.qr"
|
|
|
|
vm := &BrowseVM{}
|
|
|
|
var err error
|
|
q := a.db.Query(query).Bind(brands, types)
|
|
for row := range q.Range(&err) {
|
|
var asset Asset
|
|
err := row.Scan(&asset.Qr, &asset.Name, &asset.Brand, &asset.Type, &asset.Description,
|
|
&asset.RamType, &asset.RamCapacity,
|
|
&asset.HddCapacity, &asset.HddType, &asset.HddFormFactor, &asset.HddConnection, &asset.HddRpm)
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
vm.Assets = append(vm.Assets, asset)
|
|
if asset.Type == "ram" {
|
|
vm.HasRam = true
|
|
}
|
|
}
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
|
|
c.HTML(http.StatusOK, "browse", vm)
|
|
}
|
|
|
|
type DeleteVM struct {
|
|
Qr int
|
|
}
|
|
|
|
func (a *App) getDelete(c *gin.Context) {
|
|
qr, err := strconv.Atoi(c.Query("id"))
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusBadRequest, fmt.Errorf("invalid qr: %v", err))
|
|
return
|
|
}
|
|
vm := &DeleteVM{Qr: qr}
|
|
c.HTML(http.StatusOK, "delete", vm)
|
|
}
|
|
|
|
func (a *App) postDelete(c *gin.Context) {
|
|
qr, err := strconv.Atoi(c.Query("id"))
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusBadRequest, fmt.Errorf("invalid qr: %v", err))
|
|
return
|
|
}
|
|
tx, err := a.db.Begin()
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
|
|
err = a.DeleteAsset(tx, qr)
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
|
|
err = tx.Commit()
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
c.Redirect(http.StatusSeeOther, "/")
|
|
}
|
|
|
|
func placeholders(count int) string {
|
|
if count == 0 {
|
|
return ""
|
|
}
|
|
placeholder := "?"
|
|
for count > 1 {
|
|
placeholder += ", ?"
|
|
count--
|
|
}
|
|
return placeholder
|
|
}
|