235 lines
7.0 KiB
Go
235 lines
7.0 KiB
Go
package sql
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"git.dragon-labs.de/alphyron/group_helper/config"
|
|
"git.dragon-labs.de/alphyron/group_helper/logic"
|
|
"git.dragon-labs.de/alphyron/group_helper/models"
|
|
"github.com/jinzhu/gorm"
|
|
_ "github.com/jinzhu/gorm/dialects/mssql"
|
|
_ "github.com/jinzhu/gorm/dialects/mysql"
|
|
_ "github.com/jinzhu/gorm/dialects/postgres"
|
|
_ "github.com/jinzhu/gorm/dialects/sqlite"
|
|
"log"
|
|
)
|
|
|
|
type groupHelperRepository struct {
|
|
Conn *gorm.DB
|
|
}
|
|
|
|
func newMySQLConnection(host string, database string, user string, password string) (*gorm.DB, error) {
|
|
return gorm.Open("mysql", fmt.Sprintf("%s:%s@(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", user, password, host, database))
|
|
}
|
|
|
|
func newPostgresConnection(host string, port int, database string, user string, password string) (*gorm.DB, error) {
|
|
return gorm.Open("postgres", fmt.Sprintf("host=%s port=%d user=%s dbname=%s password=%s", host, port, user, database, password))
|
|
}
|
|
|
|
func newSQLiteConnection(path string) (*gorm.DB, error) {
|
|
return gorm.Open("sqlite3", path)
|
|
}
|
|
|
|
func newMsSqlConnection(host string, database string, user string, password string) (*gorm.DB, error) {
|
|
return gorm.Open("mssql", fmt.Sprintf("sqlserver://%s:%s@%s?database=%s", user, password, host, database))
|
|
}
|
|
|
|
// NewUserRepository tamdp, test
|
|
func NewGroupHelperRepository(config *config.DatabaseConfig) (logic.GroupHelperRepository, error) {
|
|
var (
|
|
db *gorm.DB
|
|
err error
|
|
)
|
|
|
|
switch config.DatabaseType {
|
|
case "mysql":
|
|
db, err = newMySQLConnection(fmt.Sprintf("%s:%d", config.Host, config.Port), config.Database, config.Username, config.Password)
|
|
break
|
|
case "postgres":
|
|
db, err = newPostgresConnection(config.Host, config.Port, config.Database, config.Username, config.Password)
|
|
break
|
|
case "sqlite3":
|
|
db, err = newSQLiteConnection(config.Host)
|
|
break
|
|
case "mssql":
|
|
db, err = newMsSqlConnection(fmt.Sprintf("%s:%d", config.Host, config.Port), config.Database, config.Username, config.Password)
|
|
break
|
|
}
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if db == nil {
|
|
return nil, errors.New("no valid type given (mysql,postgres,sqlite3,mssql)")
|
|
}
|
|
|
|
db.LogMode(config.Debug)
|
|
return &groupHelperRepository{Conn: db}, nil
|
|
}
|
|
|
|
// NewUserRepositoryDBConnection creates a user repository with an existing gorm database connection
|
|
func NewUserRepositoryDBConnection(db *gorm.DB) logic.GroupHelperRepository {
|
|
return &groupHelperRepository{Conn: db}
|
|
}
|
|
|
|
func (g groupHelperRepository) CreateGroup(group *models.Group) (*models.Group, error) {
|
|
err := g.Conn.Create(group).Error
|
|
|
|
if err != nil {
|
|
return nil, errors.New("problem while creating a group - " + err.Error())
|
|
}
|
|
|
|
return group, nil
|
|
}
|
|
|
|
func (g groupHelperRepository) UpdateGroup(group *models.Group) (*models.Group, error) {
|
|
err := g.Conn.Model(&models.Group{}).Where("id = ?", group.ID).Update(models.Group{
|
|
Size: group.Size,
|
|
UserJoinMessage: group.UserJoinMessage,
|
|
UserVerifiedMessage: group.UserVerifiedMessage,
|
|
UserLeaveMessage: group.UserLeaveMessage,
|
|
UserKickMessage: group.UserKickMessage,
|
|
ForbidWriting: group.ForbidWriting,
|
|
OnlineCheck: group.OnlineCheck,
|
|
KickCooldown: group.KickCooldown,
|
|
AdminGroupID: group.AdminGroupID,
|
|
}).Error
|
|
return group, err
|
|
}
|
|
|
|
func (g groupHelperRepository) GetGroupByID(id int64) (*models.Group, error) {
|
|
var group models.Group
|
|
|
|
defaultGroup := &models.Group{}
|
|
defaultGroup.FillDefaultValues()
|
|
defaultGroup.GroupID = id
|
|
|
|
err := g.Conn.Preload("ControlledGroups").Where("group_id = ?", id).First(&group)
|
|
|
|
if err.RecordNotFound() {
|
|
return g.CreateGroup(defaultGroup)
|
|
}
|
|
return &group, err.Error
|
|
}
|
|
|
|
func (g groupHelperRepository) GetGroupDatabaseSize(group *models.Group) (int, error) {
|
|
association := g.Conn.Model(group).Association("Users")
|
|
|
|
if err := association.Error; err != nil {
|
|
return -1, errors.New("problem while getting the size of users connected with the group - " + err.Error())
|
|
}
|
|
|
|
return association.Count(), nil
|
|
}
|
|
|
|
func (g groupHelperRepository) CreateUser(user *models.User) (*models.User, error) {
|
|
err := g.Conn.Create(user).Error
|
|
|
|
if err != nil {
|
|
return nil, errors.New("problem while creating a user - " + err.Error())
|
|
}
|
|
|
|
return user, nil
|
|
}
|
|
|
|
func (g groupHelperRepository) GetUserByID(userID int64) (*models.User, error) {
|
|
var user models.User
|
|
db := g.Conn.Where("user_id = ?", userID).First(&user)
|
|
|
|
if db.RecordNotFound() {
|
|
return g.CreateUser(&models.User{
|
|
UserID: userID,
|
|
})
|
|
}
|
|
|
|
if db.Error != nil {
|
|
return nil, errors.New("problem while getting the user by his user id - " + db.Error.Error())
|
|
}
|
|
return &user, nil
|
|
}
|
|
|
|
func (g groupHelperRepository) UserJoinGroup(user *models.User, group *models.Group) (bool, error) {
|
|
|
|
err := g.Conn.Model(user).Association("Groups").Append(group).Error
|
|
|
|
if err != nil {
|
|
return false, errors.New("problem while connect the user with the group - " + err.Error())
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func (g groupHelperRepository) UserLeaveGroup(user *models.User, group *models.Group) (bool, error) {
|
|
log.Println("DELETE")
|
|
err := g.Conn.Exec("DELETE FROM `GroupUser` WHERE `group_id` = ? AND `user_id` = ?", group.ID, user.ID).Error
|
|
|
|
if err != nil {
|
|
return false, errors.New("problem while disconnecting the user from the group - " + err.Error())
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func (g groupHelperRepository) IsUserInGroup(user *models.User, group *models.Group) (bool, error) {
|
|
association := g.Conn.Model(user).Association("Groups")
|
|
|
|
if err := association.Error; err != nil {
|
|
return false, errors.New("problem while checking if the user is connected with the group - " + err.Error())
|
|
}
|
|
|
|
association = association.Find(group)
|
|
|
|
if err := association.Error; err != nil {
|
|
return false, errors.New("problem while find the user is connected with the group - " + err.Error())
|
|
}
|
|
|
|
return association.Count() > 0, nil
|
|
}
|
|
|
|
func (g groupHelperRepository) ListGroups() ([]*models.Group, error) {
|
|
var groups []*models.Group
|
|
err := g.Conn.Find(&groups).Error
|
|
|
|
if err != nil {
|
|
return nil, errors.New("problem while getting all group - " + err.Error())
|
|
}
|
|
return groups, nil
|
|
}
|
|
|
|
func (g groupHelperRepository) ListGroupUsers(group *models.Group) ([]*models.User, error) {
|
|
err := g.Conn.Model(group).Preload("Users").Find(group).Error
|
|
|
|
if err != nil {
|
|
return nil, errors.New("problem while getting all users from group - " + err.Error())
|
|
}
|
|
return group.Users, nil
|
|
}
|
|
|
|
func (g groupHelperRepository) ListUsers() ([]*models.User, error) {
|
|
var users []*models.User
|
|
err := g.Conn.Find(&users).Error
|
|
|
|
if err != nil {
|
|
return nil, errors.New("problem while getting all users - " + err.Error())
|
|
}
|
|
return users, nil
|
|
}
|
|
|
|
func (g groupHelperRepository) InitRepository() error {
|
|
return g.Conn.AutoMigrate(models.Group{}, models.User{}).Error
|
|
}
|
|
|
|
func (g groupHelperRepository) GetGroupByDBID(id uint64) (*models.Group, error) {
|
|
var group models.Group
|
|
|
|
defaultGroup := &models.Group{}
|
|
defaultGroup.FillDefaultValues()
|
|
defaultGroup.ID = id
|
|
|
|
err := g.Conn.Preload("ControlledGroups").Where("id = ?", id).First(&group)
|
|
|
|
if err.RecordNotFound() {
|
|
return g.CreateGroup(defaultGroup)
|
|
}
|
|
return &group, err.Error
|
|
}
|