142 lines
3.5 KiB
Go
142 lines
3.5 KiB
Go
package data
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
|
|
"git.agecem.com/agecem/bottin-agenda/models"
|
|
_ "github.com/jackc/pgx/stdlib"
|
|
"github.com/jmoiron/sqlx"
|
|
"github.com/spf13/viper"
|
|
)
|
|
|
|
// DataClient is a postgres client based on sqlx
|
|
type DataClient struct {
|
|
PostgresConnection PostgresConnection
|
|
DB sqlx.DB
|
|
}
|
|
|
|
type PostgresConnection struct {
|
|
User string
|
|
Password string
|
|
Database string
|
|
Host string
|
|
Port int
|
|
SSL bool
|
|
}
|
|
|
|
func NewDataClientFromViper() (*DataClient, error) {
|
|
client, err := NewDataClient(PostgresConnection{
|
|
User: viper.GetString("db.user"),
|
|
Password: viper.GetString("db.password"),
|
|
Host: viper.GetString("db.host"),
|
|
Port: viper.GetInt("db.port"),
|
|
Database: viper.GetString("db.database"),
|
|
})
|
|
|
|
return client, err
|
|
}
|
|
|
|
func NewDataClient(connection PostgresConnection) (*DataClient, error) {
|
|
client := &DataClient{PostgresConnection: connection}
|
|
|
|
connectionString := fmt.Sprintf("postgres://%s:%s@%s:%d/%s",
|
|
client.PostgresConnection.User,
|
|
client.PostgresConnection.Password,
|
|
client.PostgresConnection.Host,
|
|
client.PostgresConnection.Port,
|
|
client.PostgresConnection.Database,
|
|
)
|
|
|
|
db, err := sqlx.Connect("pgx", connectionString)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
client.DB = *db
|
|
|
|
return client, nil
|
|
}
|
|
|
|
func (d *DataClient) Seed() (int64, error) {
|
|
result, err := d.DB.Exec(models.Schema)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
rows, err := result.RowsAffected()
|
|
if err != nil {
|
|
return rows, err
|
|
}
|
|
|
|
return rows, nil
|
|
}
|
|
|
|
// InsertTransactions inserts a slice of Transaction into a database, returning the transactions inserted and any error encountered
|
|
func (d *DataClient) InsertTransactions(transactions []models.Transaction) ([]models.Transaction, error) {
|
|
var rowsInserted []models.Transaction
|
|
|
|
// Start transaction
|
|
tx, err := d.DB.Beginx()
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return rowsInserted, err
|
|
}
|
|
|
|
for _, transaction := range transactions {
|
|
// Check values
|
|
if transaction.MembreID == "" {
|
|
tx.Rollback()
|
|
return rowsInserted, errors.New("Impossible d'insérer une transaction sans membre_id")
|
|
}
|
|
|
|
rows, err := tx.NamedQuery("INSERT INTO transactions (membre_id, given_at, is_perpetual) VALUES (:membre_id, current_timestamp, :is_perpetual) RETURNING id, membre_id, is_perpetual;", &transaction)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return rowsInserted, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var transactionRow models.Transaction
|
|
if err := rows.Scan(&transactionRow.ID, &transactionRow.MembreID, &transactionRow.IsPerpetual); err != nil {
|
|
tx.Rollback()
|
|
return rowsInserted, err
|
|
}
|
|
|
|
rowsInserted = append(rowsInserted, transactionRow)
|
|
}
|
|
}
|
|
|
|
err = tx.Commit()
|
|
if err != nil {
|
|
return rowsInserted, err
|
|
}
|
|
|
|
return rowsInserted, nil
|
|
}
|
|
|
|
func (d *DataClient) GetTransaction(membreID string, is_perpetual bool) (models.Transaction, error) {
|
|
var transaction models.Transaction
|
|
|
|
//err := d.DB.NamedQuery("SELECT * FROM transactions WHERE membre_id=:membre_id AND is_perpetual=:is_perpetual LIMIT 1;"
|
|
err := d.DB.Get(&transaction, "SELECT * FROM transactions WHERE membre_id = $1 AND is_perpetual = $2 LIMIT 1;", membreID, is_perpetual)
|
|
if err != nil {
|
|
return transaction, err
|
|
}
|
|
|
|
if transaction.ID == "" {
|
|
return transaction, fmt.Errorf("Aucune transaction trouvée")
|
|
}
|
|
|
|
return transaction, nil
|
|
}
|
|
|
|
func (d *DataClient) ListTransactions() ([]models.Transaction, error) {
|
|
var transactions []models.Transaction
|
|
if err := d.DB.Select(&transactions, "SELECT * FROM transactions LIMIT 20000;"); err != nil {
|
|
return transactions, err
|
|
}
|
|
|
|
return transactions, nil
|
|
}
|