173 lines
5.3 KiB
Go
173 lines
5.3 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/csv"
|
|
"strings"
|
|
// "encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"glpi"
|
|
"os"
|
|
"reflect"
|
|
"strconv"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
var (
|
|
glpiServerAPI string
|
|
glpiUserToken string
|
|
glpiAppToken string
|
|
glpiAssetsType string
|
|
glpiVersion bool
|
|
operation string
|
|
inFileName string
|
|
inFormat string
|
|
inCSVSeparator string
|
|
inCSVComment string
|
|
outFileName string
|
|
outFormat string
|
|
outCSVSeparator string
|
|
outCSVComment string
|
|
)
|
|
|
|
func CSVToGLPI(glpiAPI *glpi.Session, fileName string) {
|
|
file, err := os.Open(fileName)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer file.Close()
|
|
|
|
reader := csv.NewReader(file)
|
|
reader.Comment, _ = utf8.DecodeRuneInString(inCSVComment)
|
|
reader.Comma, _ = utf8.DecodeRuneInString(inCSVSeparator)
|
|
reader.TrimLeadingSpace = true
|
|
|
|
headers, err := reader.Read()
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
for {
|
|
record, err := reader.Read()
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
break
|
|
}
|
|
fmt.Println(record)
|
|
var (
|
|
recordMap glpi.GlpiPhone
|
|
)
|
|
|
|
// recordMap.Name = "test"
|
|
// Read the headers and find field name in structure
|
|
for fieldIndex, fieldName := range headers {
|
|
s := reflect.ValueOf(&recordMap).Elem()
|
|
typeOfT := s.Type()
|
|
for i := 0; i < s.NumField(); i++ {
|
|
// if the field is found in the structure, we assign it a value of the appropriate type
|
|
if strings.EqualFold(strings.ToLower(fieldName), strings.ToLower(typeOfT.Field(i).Name)) {
|
|
switch fmt.Sprint(typeOfT.Field(i).Type) {
|
|
case "int":
|
|
convValue, _ := strconv.Atoi(record[fieldIndex])
|
|
s.Field(i).SetInt(int64(convValue))
|
|
case "string":
|
|
s.Field(i).SetString(record[fieldIndex])
|
|
case "bool":
|
|
convValue, _ := strconv.ParseBool(record[fieldIndex])
|
|
s.Field(i).SetBool(convValue)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// fmt.Println(recordMap)
|
|
fmt.Println("Added", glpiAssetsType, "with ID:", glpiAPI.ItemOperation("add", glpiAssetsType, recordMap))
|
|
}
|
|
}
|
|
|
|
func ExportFromGLPI(glpiAPI *glpi.Session, fileName string) {
|
|
fmt.Println(fileName)
|
|
// file, err := os.Open(fileName)
|
|
// if err != nil {
|
|
// panic(err)
|
|
// }
|
|
// defer file.Close()
|
|
|
|
// reader := csv.NewReader(file)
|
|
// reader.Comma = outCSVSeparator
|
|
}
|
|
|
|
func main() {
|
|
|
|
flag.StringVar(&glpiServerAPI, "glpi-server-api", "", "Glpi instance API URL. GLPI_SERVER_URL")
|
|
flag.StringVar(&glpiUserToken, "glpi-user-token", "", "Glpi user API token. GLPI_USER_TOKEN")
|
|
flag.StringVar(&glpiAppToken, "glpi-app-token", "", "Glpi aplication API token. GLPI_APP_TOKEN")
|
|
flag.StringVar(&glpiAssetsType, "glpi-assets-type", "", "Glpi assets type (aka Computer, Printer, Phone, e.t.c.)")
|
|
flag.BoolVar(&glpiVersion, "glpi-version", false, "Get the Glpi version")
|
|
|
|
flag.StringVar(&operation, "operation", "", "import - import data to GLPI from file\n\texport - export data from GLPI to file\n\t")
|
|
|
|
flag.StringVar(&inFileName, "in-file", "", "the name of the file containing the imported data")
|
|
flag.StringVar(&inFormat, "in-format", "csv", "input file data format")
|
|
flag.StringVar(&inCSVSeparator, "in-csv-separator", ";", "input csv-file separator")
|
|
flag.StringVar(&inCSVComment, "in-csv-comment", "#", "input csv-file comments symbol")
|
|
|
|
flag.StringVar(&outFileName, "out-file", "", "the name of the file containing the exported data")
|
|
flag.StringVar(&outFormat, "out-format", "json", "Output format: 'go' - go map, 'json' - json string, 'csv' - common separated value")
|
|
flag.StringVar(&outCSVSeparator, "out-csv-separator", ";", "output csv-file separator")
|
|
flag.StringVar(&outCSVComment, "out-csv-comment", "#", "output csv-file comments symbol")
|
|
flag.Parse()
|
|
|
|
//-----------------------------------------------------------
|
|
if glpiServerAPI == "" && os.Getenv("GLPI_SERVER_API") == "" {
|
|
fmt.Println("Send error: make sure environment variables `GLPI_SERVER_API`, or used with '-glpi-server-api' argument")
|
|
os.Exit(1)
|
|
} else if glpiServerAPI == "" && os.Getenv("GLPI_SERVER_API") != "" {
|
|
glpiServerAPI = os.Getenv("GLPI_SERVER_API")
|
|
}
|
|
|
|
if glpiUserToken == "" && os.Getenv("GLPI_USER_TOKEN") == "" {
|
|
fmt.Println("Send error: make sure environment variables `GLPI_USER_TOKEN`, or used with '-glpi-user-token' argument")
|
|
os.Exit(1)
|
|
} else if glpiUserToken == "" && os.Getenv("GLPI_USER_TOKEN") != "" {
|
|
glpiUserToken = os.Getenv("GLPI_USER_TOKEN")
|
|
}
|
|
|
|
if glpiAppToken == "" && os.Getenv("GLPI_APP_TOKEN") == "" {
|
|
fmt.Println("Send error: make sure environment variables `GLPI_APP_TOKEN`, or used with '-glpi-app-token' argument")
|
|
os.Exit(1)
|
|
} else if glpiAppToken == "" && os.Getenv("GLPI_APP_TOKEN") != "" {
|
|
glpiAppToken = os.Getenv("GLPI_APP_TOKEN")
|
|
}
|
|
|
|
glpiSession, err := glpi.NewSession(glpiServerAPI, glpiUserToken, glpiAppToken)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
return
|
|
}
|
|
_, err = glpiSession.InitSession()
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
return
|
|
}
|
|
|
|
if glpiVersion {
|
|
fmt.Println("GLPI version:", glpiSession.Version())
|
|
}
|
|
|
|
switch operation {
|
|
case "import":
|
|
if inFileName == "" || glpiAssetsType == "" {
|
|
fmt.Println("Setting the input file name and glpi assets type, use the '-in-file' and '-glpi-assets-type' argument")
|
|
} else {
|
|
CSVToGLPI(glpiSession, inFileName)
|
|
}
|
|
case "export":
|
|
if outFileName == "" {
|
|
fmt.Println("Setting the output file name, use the '-out-file' argument")
|
|
} else {
|
|
ExportFromGLPI(glpiSession, outFileName)
|
|
}
|
|
}
|
|
glpiSession.KillSession()
|
|
}
|