tpeetz/kontor
1
0
Fork 0
Code Issues 6 Pull Requests 2 Actions Packages Projects Releases 2 Wiki Activity

import other kontor repos into directories

Browse Source
This commit is contained in:
Thomas Peetz
2025-01-09 19:28:50 +01:00
committed by Thomas Peetz
parent 28746adfbb
commit b424e95e05
319 changed files with 17211 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
go/pkg/tysc/card.go
+20
View File
@@ -0,0 +1,20 @@
package tysc
import (
"gopkg.in/mgo.v2/bson"
)
// Card defines the data model for TYSC cards.
type Card struct {
ID bson.ObjectId `json:"_id" bson:"_id,omitempty"`
Player bson.ObjectId `json:"player" bson:"player,omitempty"`
Team bson.ObjectId `json:"team" bson:"team,omitempty"`
Manufacturer bson.ObjectId `json:"manufacturer" bson:"manufacturer,omitempty"`
CardSet bson.ObjectId `json:"cardset" bson:"cardset,omitempty"`
ParallelSet bson.ObjectId `json:"parallelset" bson:"paralelset,omitempty"`
InsertSet bson.ObjectId `json:"insertset" bson:"insertset,omitempty"`
Rookie bool `json:"rookie" bson:"rookie,omitempty"`
Year int `json:"year" bson:"year,omitempty"`
Number int `json:"number" bson:"number,omitempty"`
Model string `json:"model" bson:"model,omitempty"`
}
go/pkg/tysc/card_dao.go
+66
View File
@@ -0,0 +1,66 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
mgo "gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson"
)
// CardDAO extends the type BaseDAO.
type CardDAO struct {
Db dao.BaseDAO
}
const (
// CARDCOLLECTION defines the collection name for storing cards.
CARDCOLLECTION = "card"
// CARDMODEL defines the name of the card data model.
CARDMODEL = "kontor.tysc.card"
)
// FindAll retrieves the list of cards from the database.
func (m *CardDAO) FindAll() ([]Card, error) {
m.Db.Connect()
var cards []Card
err := m.Db.MongoDb.C(CARDCOLLECTION).Find(bson.M{"model": CARDMODEL}).All(&cards)
return cards, err
}
// FindByID returns an card with given id or returns the error.
func (m *CardDAO) FindByID(id string) (Card, error) {
m.Db.Connect()
var card Card
err := m.Db.MongoDb.C(CARDCOLLECTION).FindId(bson.ObjectIdHex(id)).One(&card)
return card, err
}
// Insert a card into database.
func (m *CardDAO) Insert(card Card) error {
m.Db.Connect()
card.Model = CARDMODEL
err := m.Db.MongoDb.C(CARDCOLLECTION).Insert(&card)
return err
}
// Upsert a card into database.
func (m *CardDAO) Upsert(card Card) (*mgo.ChangeInfo, error) {
m.Db.Connect()
card.Model = CARDMODEL
info, err := m.Db.MongoDb.C(CARDCOLLECTION).Upsert(bson.M{"number": card.Number}, &card)
return info, err
}
// Update an existing card.
func (m *CardDAO) Update(card Card) error {
m.Db.Connect()
err := m.Db.MongoDb.C(CARDCOLLECTION).UpdateId(card.ID, &card)
return err
}
// Delete an existing card.
func (m *CardDAO) Delete(card Card) error {
m.Db.Connect()
err := m.Db.MongoDb.C(CARDCOLLECTION).Remove(&card)
return err
}
go/pkg/tysc/card_test.go
+110
View File
@@ -0,0 +1,110 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
"reflect"
"testing"
"gopkg.in/mgo.v2/bson"
)
var cardModelTestTable = []struct {
name string
typeName string
}{
{"Id", "string"},
{"Player", "string"},
{"Team", "string"},
{"Manufacturer", "string"},
{"CardSet", "string"},
{"ParallelSet", "string"},
{"InsertSet", "string"},
{"Rookie", "bool"},
{"Year", "int"},
{"Number", "int"},
{"Model", "string"},
}
func TestCardModel(t *testing.T) {
m := Card{}
if reflect.TypeOf(m).NumField() != len(cardModelTestTable) {
t.Fail()
}
for index, testData := range cardModelTestTable {
givenType := reflect.TypeOf(m).Field(index).Type.Kind().String()
if givenType != testData.typeName {
t.Fail()
}
}
}
func TestListCards(t *testing.T) {
var (
cardDao = CardDAO{Db: dao.TestDb}
)
cards, err := cardDao.FindAll()
if err != nil {
t.Fail()
}
if len(cards) != 0 {
t.Fail()
}
}
func TestInsertCard(t *testing.T) {
var (
cardDao = CardDAO{Db: dao.TestDb}
card = Card{}
cards []Card
)
card.ID = bson.NewObjectId()
card.Number = 1
err := cardDao.Insert(card)
if err != nil {
t.Fail()
}
cards, err = cardDao.FindAll()
if err != nil {
t.Fail()
}
if len(cards) != 1 {
t.Fail()
}
}
func TestUpsertCard(t *testing.T) {
var (
cardDao = CardDAO{Db: dao.TestDb}
card = Card{}
)
card.ID = bson.NewObjectId()
card.Number = 2
cardDao.Upsert(card)
cards, err := cardDao.FindAll()
if err != nil {
t.Fail()
}
if len(cards) != 2 {
t.Fail()
}
}
func TestDeleteCard(t *testing.T) {
var (
cardDao = CardDAO{Db: dao.TestDb}
)
cards, err := cardDao.FindAll()
if err != nil {
t.Fail()
}
for _, card := range cards {
cardDao.Delete(card)
}
cards, err = cardDao.FindAll()
if err != nil {
t.Fail()
}
if len(cards) != 0 {
t.Fail()
}
}
go/pkg/tysc/cardset.go
+13
View File
@@ -0,0 +1,13 @@
package tysc
import (
"gopkg.in/mgo.v2/bson"
)
// CardSet defines the data model for TYSC card sets with id, name and manufacturer.
type CardSet struct {
ID bson.ObjectId `json:"_id" bson:"_id,omitempty"`
Name string `json:"name" bson:"name"`
Manufacturer bson.ObjectId `json:"manufacturer" bson:"manufacturer,omitempty"`
Model string `json:"model" bson:"model,omitempty"`
}
go/pkg/tysc/cardset_dao.go
+82
View File
@@ -0,0 +1,82 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
mgo "gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson"
)
// CardSetDAO extends the type BaseDAO.
type CardSetDAO struct {
Db dao.BaseDAO
}
const (
// CARDSETCOLLECTION defines the collection name for storing cards sets.
CARDSETCOLLECTION = "cardSet"
// CARDSETMODEL defines the name of the card set data model.
CARDSETMODEL = "kontor.tysc.cardSet"
)
// FindAll retrieves the list of card sets from the database.
func (m *CardSetDAO) FindAll() ([]CardSet, error) {
m.Db.Connect()
var cardSets []CardSet
err := m.Db.MongoDb.C(CARDSETCOLLECTION).Find(bson.M{"model": CARDSETMODEL}).All(&cardSets)
return cardSets, err
}
// FindByID returns a card set with given id or returns the error.
func (m *CardSetDAO) FindByID(id string) (CardSet, error) {
m.Db.Connect()
var cardSet CardSet
err := m.Db.MongoDb.C(CARDSETCOLLECTION).FindId(bson.ObjectIdHex(id)).One(&cardSet)
return cardSet, err
}
// FindByManufacturer returns a card set with given manufacturer or returns the error.
func (m *CardSetDAO) FindByManufacturer(manufacturer string) ([]CardSet, error) {
m.Db.Connect()
var cardSets []CardSet
err := m.Db.MongoDb.C(CARDSETCOLLECTION).Find(bson.M{"model": CARDSETMODEL, "manufacturer": bson.ObjectIdHex(manufacturer)}).All(&cardSets)
return cardSets, err
}
// FindByName returns a card set with given name or returns the error.
func (m *CardSetDAO) FindByName(name string) (CardSet, error) {
m.Db.Connect()
var cardSet CardSet
err := m.Db.MongoDb.C(CARDSETCOLLECTION).Find(bson.M{"name": name, "model": CARDSETMODEL}).One(&cardSet)
return cardSet, err
}
// Insert an card set into database.
func (m *CardSetDAO) Insert(cardSet CardSet) error {
m.Db.Connect()
cardSet.Model = CARDSETMODEL
err := m.Db.MongoDb.C(CARDSETCOLLECTION).Insert(&cardSet)
return err
}
// Upsert an card set into database.
func (m *CardSetDAO) Upsert(cardSet CardSet) (*mgo.ChangeInfo, error) {
m.Db.Connect()
cardSet.Model = CARDSETMODEL
info, err := m.Db.MongoDb.C(CARDSETCOLLECTION).Upsert(bson.M{"name": cardSet.Name}, &cardSet)
return info, err
}
// Update an existing card set.
func (m *CardSetDAO) Update(cardSet CardSet) error {
m.Db.Connect()
err := m.Db.MongoDb.C(CARDSETCOLLECTION).UpdateId(cardSet.ID, &cardSet)
return err
}
// Delete an existing card set.
func (m *CardSetDAO) Delete(cardSet CardSet) error {
m.Db.Connect()
err := m.Db.MongoDb.C(CARDSETCOLLECTION).Remove(&cardSet)
return err
}
go/pkg/tysc/cardset_test.go
+103
View File
@@ -0,0 +1,103 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
"reflect"
"testing"
"gopkg.in/mgo.v2/bson"
)
var cardsetModelTestTable = []struct {
name string
typeName string
}{
{"Id", "string"},
{"Name", "string"},
{"Manufacturer", "string"},
{"Model", "string"},
}
func TestCardSetModel(t *testing.T) {
m := CardSet{}
if reflect.TypeOf(m).NumField() != len(cardsetModelTestTable) {
t.Fail()
}
for index, testData := range cardsetModelTestTable {
givenType := reflect.TypeOf(m).Field(index).Type.Kind().String()
if givenType != testData.typeName {
t.Fail()
}
}
}
func TestListCardSets(t *testing.T) {
var (
cardsetDao = CardSetDAO{Db: dao.TestDb}
)
cardSets, err := cardsetDao.FindAll()
if err != nil {
t.Fail()
}
if len(cardSets) != 0 {
t.Fail()
}
}
func TestInsertCardSet(t *testing.T) {
var (
cardsetDao = CardSetDAO{Db: dao.TestDb}
cardSet = CardSet{}
cardSets []CardSet
)
cardSet.ID = bson.NewObjectId()
cardSet.Name = "test"
err := cardsetDao.Insert(cardSet)
if err != nil {
t.Fail()
}
cardSets, err = cardsetDao.FindAll()
if err != nil {
t.Fail()
}
if len(cardSets) != 1 {
t.Fail()
}
}
func TestUpsertCardSet(t *testing.T) {
var (
cardsetDao = CardSetDAO{Db: dao.TestDb}
cardSet = CardSet{}
)
cardSet.ID = bson.NewObjectId()
cardSet.Name = "test2"
cardsetDao.Upsert(cardSet)
cardSets, err := cardsetDao.FindAll()
if err != nil {
t.Fail()
}
if len(cardSets) != 2 {
t.Fail()
}
}
func TestDeleteCardSet(t *testing.T) {
var (
cardsetDao = CardSetDAO{Db: dao.TestDb}
)
cardSets, err := cardsetDao.FindAll()
if err != nil {
t.Fail()
}
for _, cardSet := range cardSets {
cardsetDao.Delete(cardSet)
}
cardSets, err = cardsetDao.FindAll()
if err != nil {
t.Fail()
}
if len(cardSets) != 0 {
t.Fail()
}
}
go/pkg/tysc/insertset.go
+13
View File
@@ -0,0 +1,13 @@
package tysc
import (
"gopkg.in/mgo.v2/bson"
)
// InsertSet defines the data model for TYSC inserts sets with id, name and manufacturer.
type InsertSet struct {
ID bson.ObjectId `json:"_id" bson:"_id,omitempty"`
Name string `json:"name" bson:"name"`
Manufacturer bson.ObjectId `json:"manufacturer" bson:"manufacturer,omitempty"`
Model string `json:"model" bson:"model,omitempty"`
}
go/pkg/tysc/insertset_dao.go
+82
View File
@@ -0,0 +1,82 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
mgo "gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson"
)
// InsertSetDAO extends the type BaseDAO.
type InsertSetDAO struct {
Db dao.BaseDAO
}
const (
// INSERTSETCOLLECTION defines the collection name for storing insert sets.
INSERTSETCOLLECTION = "insertSet"
// INSERTSETMODEL defines the name of the insert set data model.
INSERTSETMODEL = "kontor.tysc.insertSet"
)
// FindAll retrieves the list of cards from the database.
func (m *InsertSetDAO) FindAll() ([]InsertSet, error) {
m.Db.Connect()
var insertSets []InsertSet
err := m.Db.MongoDb.C(INSERTSETCOLLECTION).Find(bson.M{"model": INSERTSETMODEL}).All(&insertSets)
return insertSets, err
}
// FindByID returns an card with given id or returns the error.
func (m *InsertSetDAO) FindByID(id string) (InsertSet, error) {
m.Db.Connect()
var insertSet InsertSet
err := m.Db.MongoDb.C(INSERTSETCOLLECTION).FindId(bson.ObjectIdHex(id)).One(&insertSet)
return insertSet, err
}
// FindByManufacturer returns a insert set with given manufacturer or returns the error.
func (m *InsertSetDAO) FindByManufacturer(manufacturer string) ([]InsertSet, error) {
m.Db.Connect()
var insertSets []InsertSet
err := m.Db.MongoDb.C(INSERTSETCOLLECTION).Find(bson.M{"model": INSERTSETMODEL, "manufacturer": bson.ObjectIdHex(manufacturer)}).All(&insertSets)
return insertSets, err
}
// FindByName returns a insert set with given name or returns the error.
func (m *InsertSetDAO) FindByName(name string) (InsertSet, error) {
m.Db.Connect()
var insertSet InsertSet
err := m.Db.MongoDb.C(INSERTSETCOLLECTION).Find(bson.M{"name": name, "model": INSERTSETMODEL}).One(&insertSet)
return insertSet, err
}
// Insert an insert set into database.
func (m *InsertSetDAO) Insert(insertSet InsertSet) error {
m.Db.Connect()
insertSet.Model = INSERTSETMODEL
err := m.Db.MongoDb.C(INSERTSETCOLLECTION).Insert(&insertSet)
return err
}
// Upsert an insert set into database.
func (m *InsertSetDAO) Upsert(insertSet InsertSet) (*mgo.ChangeInfo, error) {
m.Db.Connect()
insertSet.Model = INSERTSETMODEL
info, err := m.Db.MongoDb.C(INSERTSETCOLLECTION).Upsert(bson.M{"name": insertSet.Name}, &insertSet)
return info, err
}
// Update an existing insert set.
func (m *InsertSetDAO) Update(insertSet InsertSet) error {
m.Db.Connect()
err := m.Db.MongoDb.C(INSERTSETCOLLECTION).UpdateId(insertSet.ID, &insertSet)
return err
}
// Delete an existing insert set.
func (m *InsertSetDAO) Delete(insertSet InsertSet) error {
m.Db.Connect()
err := m.Db.MongoDb.C(INSERTSETCOLLECTION).Remove(&insertSet)
return err
}
go/pkg/tysc/insertset_test.go
+103
View File
@@ -0,0 +1,103 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
"reflect"
"testing"
"gopkg.in/mgo.v2/bson"
)
var insertsetModelTestTable = []struct {
name string
typeName string
}{
{"Id", "string"},
{"Name", "string"},
{"Manufacturer", "string"},
{"Model", "string"},
}
func TestInsertSetModel(t *testing.T) {
m := InsertSet{}
if reflect.TypeOf(m).NumField() != len(insertsetModelTestTable) {
t.Fail()
}
for index, testData := range insertsetModelTestTable {
givenType := reflect.TypeOf(m).Field(index).Type.Kind().String()
if givenType != testData.typeName {
t.Fail()
}
}
}
func TestListInsertSets(t *testing.T) {
var (
insertsetDao = InsertSetDAO{Db: dao.TestDb}
)
insertSets, err := insertsetDao.FindAll()
if err != nil {
t.Fail()
}
if len(insertSets) != 0 {
t.Fail()
}
}
func TestInsertInsertSet(t *testing.T) {
var (
insertsetDao = InsertSetDAO{Db: dao.TestDb}
insertSet = InsertSet{}
insertSets []InsertSet
)
insertSet.ID = bson.NewObjectId()
insertSet.Name = "test"
err := insertsetDao.Insert(insertSet)
if err != nil {
t.Fail()
}
insertSets, err = insertsetDao.FindAll()
if err != nil {
t.Fail()
}
if len(insertSets) != 1 {
t.Fail()
}
}
func TestUpsertInsertSet(t *testing.T) {
var (
insertsetDao = InsertSetDAO{Db: dao.TestDb}
insertSet = InsertSet{}
)
insertSet.ID = bson.NewObjectId()
insertSet.Name = "test2"
insertsetDao.Upsert(insertSet)
insertSets, err := insertsetDao.FindAll()
if err != nil {
t.Fail()
}
if len(insertSets) != 2 {
t.Fail()
}
}
func TestDeleteInsertSet(t *testing.T) {
var (
insertsetDao = InsertSetDAO{Db: dao.TestDb}
)
insertSets, err := insertsetDao.FindAll()
if err != nil {
t.Fail()
}
for _, insertSet := range insertSets {
insertsetDao.Delete(insertSet)
}
insertSets, err = insertsetDao.FindAll()
if err != nil {
t.Fail()
}
if len(insertSets) != 0 {
t.Fail()
}
}
go/pkg/tysc/manufacturer.go
+12
View File
@@ -0,0 +1,12 @@
package tysc
import (
"gopkg.in/mgo.v2/bson"
)
// Manufacturer defines the data model for TYSC manufacturers with id, and name.
type Manufacturer struct {
ID bson.ObjectId `json:"_id" bson:"_id,omitempty"`
Name string `json:"name" bson:"name"`
Model string `json:"model" bson:"model,omitempty"`
}
go/pkg/tysc/manufacturer_dao.go
+74
View File
@@ -0,0 +1,74 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
mgo "gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson"
)
// ManufacturerDAO extends the type BaseDAO.
type ManufacturerDAO struct {
Db dao.BaseDAO
}
const (
// MANUFACTURERCOLLECTION defines the collection name for storing manufacturers.
MANUFACTURERCOLLECTION = "manufacturer"
// MANUFACTURERMODEL defines the name of the manufacturer data model.
MANUFACTURERMODEL = "kontor.tysc.manufacturer"
)
// FindAll retrieves the list of manufacturers from the database.
func (m *ManufacturerDAO) FindAll() ([]Manufacturer, error) {
m.Db.Connect()
var manufacturers []Manufacturer
err := m.Db.MongoDb.C(MANUFACTURERCOLLECTION).Find(bson.M{"model": MANUFACTURERMODEL}).All(&manufacturers)
return manufacturers, err
}
// FindByID returns a manufacturer with given id or returns the error.
func (m *ManufacturerDAO) FindByID(id string) (Manufacturer, error) {
m.Db.Connect()
var manufacturer Manufacturer
err := m.Db.MongoDb.C(MANUFACTURERCOLLECTION).FindId(bson.ObjectIdHex(id)).One(&manufacturer)
return manufacturer, err
}
// FindByName returns a manufacturer with given name or returns the error.
func (m *ManufacturerDAO) FindByName(name string) (Manufacturer, error) {
m.Db.Connect()
var manufacturer Manufacturer
err := m.Db.MongoDb.C(MANUFACTURERCOLLECTION).Find(bson.M{"name": name, "model": MANUFACTURERMODEL}).One(&manufacturer)
return manufacturer, err
}
// Insert a manufacturer into database.
func (m *ManufacturerDAO) Insert(manufacturer Manufacturer) error {
m.Db.Connect()
manufacturer.Model = MANUFACTURERMODEL
err := m.Db.MongoDb.C(MANUFACTURERCOLLECTION).Insert(&manufacturer)
return err
}
// Upsert a manufacturer into database.
func (m *ManufacturerDAO) Upsert(manufacturer Manufacturer) (*mgo.ChangeInfo, error) {
m.Db.Connect()
manufacturer.Model = MANUFACTURERMODEL
info, err := m.Db.MongoDb.C(MANUFACTURERCOLLECTION).Upsert(bson.M{"name": manufacturer.Name}, &manufacturer)
return info, err
}
// Update an existing manufacturer.
func (m *ManufacturerDAO) Update(manufacturer Manufacturer) error {
m.Db.Connect()
err := m.Db.MongoDb.C(MANUFACTURERCOLLECTION).UpdateId(manufacturer.ID, &manufacturer)
return err
}
// Delete an existing manufacturer.
func (m *ManufacturerDAO) Delete(manufacturer Manufacturer) error {
m.Db.Connect()
err := m.Db.MongoDb.C(MANUFACTURERCOLLECTION).Remove(&manufacturer)
return err
}
go/pkg/tysc/manufacturer_test.go
+102
View File
@@ -0,0 +1,102 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
"reflect"
"testing"
"gopkg.in/mgo.v2/bson"
)
var manufacturerModelTestTable = []struct {
name string
typeName string
}{
{"Id", "string"},
{"Name", "string"},
{"Model", "string"},
}
func TestManufacturerModel(t *testing.T) {
m := Manufacturer{}
if reflect.TypeOf(m).NumField() != len(manufacturerModelTestTable) {
t.Fail()
}
for index, testData := range manufacturerModelTestTable {
givenType := reflect.TypeOf(m).Field(index).Type.Kind().String()
if givenType != testData.typeName {
t.Fail()
}
}
}
func TestListManufacturers(t *testing.T) {
var (
manufacturerDao = ManufacturerDAO{Db: dao.TestDb}
)
manufacturers, err := manufacturerDao.FindAll()
if err != nil {
t.Fail()
}
if len(manufacturers) != 0 {
t.Fail()
}
}
func TestInsertManufacturer(t *testing.T) {
var (
manufacturerDao = ManufacturerDAO{Db: dao.TestDb}
manufacturer = Manufacturer{}
manufacturers []Manufacturer
)
manufacturer.ID = bson.NewObjectId()
manufacturer.Name = "test"
err := manufacturerDao.Insert(manufacturer)
if err != nil {
t.Fail()
}
manufacturers, err = manufacturerDao.FindAll()
if err != nil {
t.Fail()
}
if len(manufacturers) != 1 {
t.Fail()
}
}
func TestUpsertManufacturer(t *testing.T) {
var (
manufacturerDao = ManufacturerDAO{Db: dao.TestDb}
manufacturer = Manufacturer{}
)
manufacturer.ID = bson.NewObjectId()
manufacturer.Name = "test2"
manufacturerDao.Upsert(manufacturer)
manufacturers, err := manufacturerDao.FindAll()
if err != nil {
t.Fail()
}
if len(manufacturers) != 2 {
t.Fail()
}
}
func TestDeleteManufacturer(t *testing.T) {
var (
manufacturerDao = ManufacturerDAO{Db: dao.TestDb}
)
manufacturers, err := manufacturerDao.FindAll()
if err != nil {
t.Fail()
}
for _, manufacturer := range manufacturers {
manufacturerDao.Delete(manufacturer)
}
manufacturers, err = manufacturerDao.FindAll()
if err != nil {
t.Fail()
}
if len(manufacturers) != 0 {
t.Fail()
}
}
go/pkg/tysc/parallelset.go
+13
View File
@@ -0,0 +1,13 @@
package tysc
import (
"gopkg.in/mgo.v2/bson"
)
// ParallelSet defines the data model for TYSC parallel sets with id, name and manufacturer.
type ParallelSet struct {
ID bson.ObjectId `json:"_id" bson:"_id,omitempty"`
Name string `json:"name" bson:"name"`
Manufacturer bson.ObjectId `json:"manufacturer" bson:"manufacturer,omitempty"`
Model string `json:"model" bson:"model,omitempty"`
}
go/pkg/tysc/parallelset_dao.go
+82
View File
@@ -0,0 +1,82 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
mgo "gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson"
)
// ParallelSetDAO extends the type BaseDAO.
type ParallelSetDAO struct {
Db dao.BaseDAO
}
const (
// PARALLELSETCOLLECTION defines the collection name for storing parallel sets.
PARALLELSETCOLLECTION = "parallelSet"
// PARALLELSETMODEL defines the name of the parallel set data model.
PARALLELSETMODEL = "kontor.tysc.parallelSet"
)
// FindAll retrieves the list of parallel sets from the database.
func (m *ParallelSetDAO) FindAll() ([]ParallelSet, error) {
m.Db.Connect()
var parallelSets []ParallelSet
err := m.Db.MongoDb.C(PARALLELSETCOLLECTION).Find(bson.M{"model": PARALLELSETMODEL}).All(&parallelSets)
return parallelSets, err
}
// FindByID returns a parallel set with given id or returns the error.
func (m *ParallelSetDAO) FindByID(id string) (ParallelSet, error) {
m.Db.Connect()
var parallelSet ParallelSet
err := m.Db.MongoDb.C(PARALLELSETCOLLECTION).FindId(bson.ObjectIdHex(id)).One(&parallelSet)
return parallelSet, err
}
// FindByManufacturer returns a paralle set with given manufacturer or returns the error.
func (m *ParallelSetDAO) FindByManufacturer(manufacturer string) ([]ParallelSet, error) {
m.Db.Connect()
var parallelSets []ParallelSet
err := m.Db.MongoDb.C(PARALLELSETCOLLECTION).Find(bson.M{"model": PARALLELSETMODEL, "manufacturer": bson.ObjectIdHex(manufacturer)}).All(&parallelSets)
return parallelSets, err
}
// FindByName returns a parallel set with given name or returns the error.
func (m *ParallelSetDAO) FindByName(name string) (ParallelSet, error) {
m.Db.Connect()
var parallelSet ParallelSet
err := m.Db.MongoDb.C(PARALLELSETCOLLECTION).Find(bson.M{"name": name, "model": PARALLELSETMODEL}).One(&parallelSet)
return parallelSet, err
}
// Insert a parallel set into database.
func (m *ParallelSetDAO) Insert(parallelSet ParallelSet) error {
m.Db.Connect()
parallelSet.Model = PARALLELSETMODEL
err := m.Db.MongoDb.C(PARALLELSETCOLLECTION).Insert(&parallelSet)
return err
}
// Upsert a parallel set into database.
func (m *ParallelSetDAO) Upsert(parallelSet ParallelSet) (*mgo.ChangeInfo, error) {
m.Db.Connect()
parallelSet.Model = PARALLELSETMODEL
info, err := m.Db.MongoDb.C(PARALLELSETCOLLECTION).Upsert(bson.M{"name": parallelSet.Name}, &parallelSet)
return info, err
}
// Update an existing parallel set.
func (m *ParallelSetDAO) Update(parallelSet ParallelSet) error {
m.Db.Connect()
err := m.Db.MongoDb.C(PARALLELSETCOLLECTION).UpdateId(parallelSet.ID, &parallelSet)
return err
}
// Delete an existing parallel set.
func (m *ParallelSetDAO) Delete(parallelSet ParallelSet) error {
m.Db.Connect()
err := m.Db.MongoDb.C(PARALLELSETCOLLECTION).Remove(&parallelSet)
return err
}
go/pkg/tysc/parallelset_test.go
+103
View File
@@ -0,0 +1,103 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
"reflect"
"testing"
"gopkg.in/mgo.v2/bson"
)
var parallelsetModelTestTable = []struct {
name string
typeName string
}{
{"Id", "string"},
{"Name", "string"},
{"Manufacturer", "string"},
{"Model", "string"},
}
func TestParallelSetModel(t *testing.T) {
m := ParallelSet{}
if reflect.TypeOf(m).NumField() != len(parallelsetModelTestTable) {
t.Fail()
}
for index, testData := range parallelsetModelTestTable {
givenType := reflect.TypeOf(m).Field(index).Type.Kind().String()
if givenType != testData.typeName {
t.Fail()
}
}
}
func TestListParallelSets(t *testing.T) {
var (
parallelsetDao = ParallelSetDAO{Db: dao.TestDb}
)
parallelSets, err := parallelsetDao.FindAll()
if err != nil {
t.Fail()
}
if len(parallelSets) != 0 {
t.Fail()
}
}
func TestInsertParallelSet(t *testing.T) {
var (
parallelsetDao = ParallelSetDAO{Db: dao.TestDb}
parallelSet = ParallelSet{}
parallelSets []ParallelSet
)
parallelSet.ID = bson.NewObjectId()
parallelSet.Name = "test"
err := parallelsetDao.Insert(parallelSet)
if err != nil {
t.Fail()
}
parallelSets, err = parallelsetDao.FindAll()
if err != nil {
t.Fail()
}
if len(parallelSets) != 1 {
t.Fail()
}
}
func TestUpsertParallelSet(t *testing.T) {
var (
parallelsetDao = ParallelSetDAO{Db: dao.TestDb}
parallelSet = ParallelSet{}
)
parallelSet.ID = bson.NewObjectId()
parallelSet.Name = "test2"
parallelsetDao.Upsert(parallelSet)
parallelSets, err := parallelsetDao.FindAll()
if err != nil {
t.Fail()
}
if len(parallelSets) != 2 {
t.Fail()
}
}
func TestDeleteParallelSet(t *testing.T) {
var (
parallelsetDao = ParallelSetDAO{Db: dao.TestDb}
)
parallelSets, err := parallelsetDao.FindAll()
if err != nil {
t.Fail()
}
for _, parallelSet := range parallelSets {
parallelsetDao.Delete(parallelSet)
}
parallelSets, err = parallelsetDao.FindAll()
if err != nil {
t.Fail()
}
if len(parallelSets) != 0 {
t.Fail()
}
}
go/pkg/tysc/player.go
+13
View File
@@ -0,0 +1,13 @@
package tysc
import (
"gopkg.in/mgo.v2/bson"
)
// Player defines the data model for TYSC players with id, first and lastname.
type Player struct {
ID bson.ObjectId `json:"_id" bson:"_id,omitempty"`
Firstname string `json:"firstname" bson:"firstname"`
Lastname string `json:"lastname" bson:"lastname"`
Model string `json:"model" bson:"model,omitempty"`
}
go/pkg/tysc/player_dao.go
+74
View File
@@ -0,0 +1,74 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
mgo "gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson"
)
// PlayerDAO extends the type BaseDAO.
type PlayerDAO struct {
Db dao.BaseDAO
}
const (
// PLAYERCOLLECTION defines the collection name for storing players.
PLAYERCOLLECTION = "player"
// PLAYERMODEL defines the name of the player data model.
PLAYERMODEL = "kontor.tysc.player"
)
// FindAll retrieves the list of players from the database.
func (m *PlayerDAO) FindAll() ([]Player, error) {
m.Db.Connect()
var players []Player
err := m.Db.MongoDb.C(PLAYERCOLLECTION).Find(bson.M{"model": PLAYERMODEL}).All(&players)
return players, err
}
// FindByID returns a player with given id or returns the error.
func (m *PlayerDAO) FindByID(id string) (Player, error) {
m.Db.Connect()
var player Player
err := m.Db.MongoDb.C(PLAYERCOLLECTION).FindId(bson.ObjectIdHex(id)).One(&player)
return player, err
}
// FindByLastName returns a player with given last name or returns the error.
func (m *PlayerDAO) FindByLastName(lastname string) (Player, error) {
m.Db.Connect()
var player Player
err := m.Db.MongoDb.C(PLAYERCOLLECTION).Find(bson.M{"lastname": lastname, "model": PLAYERMODEL}).One(&player)
return player, err
}
// Insert a player into database.
func (m *PlayerDAO) Insert(player Player) error {
m.Db.Connect()
player.Model = PLAYERMODEL
err := m.Db.MongoDb.C(PLAYERCOLLECTION).Insert(&player)
return err
}
// Upsert a player into database.
func (m *PlayerDAO) Upsert(player Player) (*mgo.ChangeInfo, error) {
m.Db.Connect()
player.Model = PLAYERMODEL
info, err := m.Db.MongoDb.C(PLAYERCOLLECTION).Upsert(bson.M{"lastname": player.Lastname}, &player)
return info, err
}
// Update an existing player.
func (m *PlayerDAO) Update(player Player) error {
m.Db.Connect()
err := m.Db.MongoDb.C(PLAYERCOLLECTION).UpdateId(player.ID, &player)
return err
}
// Delete an existing player.
func (m *PlayerDAO) Delete(player Player) error {
m.Db.Connect()
err := m.Db.MongoDb.C(PLAYERCOLLECTION).Remove(&player)
return err
}
go/pkg/tysc/player_test.go
+103
View File
@@ -0,0 +1,103 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
"reflect"
"testing"
"gopkg.in/mgo.v2/bson"
)
var playerModelTestTable = []struct {
name string
typeName string
}{
{"Id", "string"},
{"Firstname", "string"},
{"Lastname", "string"},
{"Model", "string"},
}
func TestPlayerModel(t *testing.T) {
m := Player{}
if reflect.TypeOf(m).NumField() != len(playerModelTestTable) {
t.Fail()
}
for index, testData := range playerModelTestTable {
givenType := reflect.TypeOf(m).Field(index).Type.Kind().String()
if givenType != testData.typeName {
t.Fail()
}
}
}
func TestListPlayers(t *testing.T) {
var (
playerDao = PlayerDAO{Db: dao.TestDb}
)
players, err := playerDao.FindAll()
if err != nil {
t.Fail()
}
if players != nil {
t.Fail()
}
}
func TestInsertPlayer(t *testing.T) {
var (
playerDao = PlayerDAO{Db: dao.TestDb}
player = Player{}
players []Player
)
player.ID = bson.NewObjectId()
player.Lastname = "test"
err := playerDao.Insert(player)
if err != nil {
t.Fail()
}
players, err = playerDao.FindAll()
if err != nil {
t.Fail()
}
if len(players) != 1 {
t.Fail()
}
}
func TestUpsertPlayer(t *testing.T) {
var (
playerDao = PlayerDAO{Db: dao.TestDb}
player = Player{}
)
player.ID = bson.NewObjectId()
player.Lastname = "test2"
playerDao.Upsert(player)
players, err := playerDao.FindAll()
if err != nil {
t.Fail()
}
if len(players) != 2 {
t.Fail()
}
}
func TestDeletePlayer(t *testing.T) {
var (
playerDao = PlayerDAO{Db: dao.TestDb}
)
players, err := playerDao.FindAll()
if err != nil {
t.Fail()
}
for _, player := range players {
playerDao.Delete(player)
}
players, err = playerDao.FindAll()
if err != nil {
t.Fail()
}
if len(players) != 0 {
t.Fail()
}
}
go/pkg/tysc/position.go
+14
View File
@@ -0,0 +1,14 @@
package tysc
import (
"gopkg.in/mgo.v2/bson"
)
// Position defines the data model for TYSC positions with id, name, description and sport.
type Position struct {
ID bson.ObjectId `json:"_id" bson:"_id,omitempty"`
Name string `json:"name" bson:"name"`
Description string `json:"description" bson:"description"`
Sport bson.ObjectId `json:"sport" bson:"sport,omitempty"`
Model string `json:"model" bson:"model,omitempty"`
}
go/pkg/tysc/position_dao.go
+74
View File
@@ -0,0 +1,74 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
mgo "gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson"
)
// PositionDAO extends the type BaseDAO.
type PositionDAO struct {
Db dao.BaseDAO
}
const (
// POSITIONCOLLECTION defines the collection name for storing positions.
POSITIONCOLLECTION = "position"
// POSITIONMODEL defines the name of the position data model.
POSITIONMODEL = "kontor.tysc.position"
)
// FindAll retrieves the list of positions from the database.
func (m *PositionDAO) FindAll() ([]Position, error) {
m.Db.Connect()
var positions []Position
err := m.Db.MongoDb.C(POSITIONCOLLECTION).Find(bson.M{"model": POSITIONMODEL}).All(&positions)
return positions, err
}
// FindByID returns a position with given id or returns the error.
func (m *PositionDAO) FindByID(id string) (Position, error) {
m.Db.Connect()
var position Position
err := m.Db.MongoDb.C(POSITIONCOLLECTION).FindId(bson.ObjectIdHex(id)).One(&position)
return position, err
}
// FindByName returns a position with given name or returns the error.
func (m *PositionDAO) FindByName(name string) (Position, error) {
m.Db.Connect()
var position Position
err := m.Db.MongoDb.C(POSITIONCOLLECTION).Find(bson.M{"name": name, "model": POSITIONMODEL}).One(&position)
return position, err
}
// Insert a position into database.
func (m *PositionDAO) Insert(position Position) error {
m.Db.Connect()
position.Model = POSITIONMODEL
err := m.Db.MongoDb.C(POSITIONCOLLECTION).Insert(&position)
return err
}
// Upsert a position into database.
func (m *PositionDAO) Upsert(position Position) (*mgo.ChangeInfo, error) {
m.Db.Connect()
position.Model = POSITIONMODEL
info, err := m.Db.MongoDb.C(POSITIONCOLLECTION).Upsert(bson.M{"name": position.Name}, &position)
return info, err
}
// Update an existing position.
func (m *PositionDAO) Update(position Position) error {
m.Db.Connect()
err := m.Db.MongoDb.C(POSITIONCOLLECTION).UpdateId(position.ID, &position)
return err
}
// Delete an existing position.
func (m *PositionDAO) Delete(position Position) error {
m.Db.Connect()
err := m.Db.MongoDb.C(POSITIONCOLLECTION).Remove(&position)
return err
}
go/pkg/tysc/position_test.go
+104
View File
@@ -0,0 +1,104 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
"reflect"
"testing"
"gopkg.in/mgo.v2/bson"
)
var positionModelTestTable = []struct {
name string
typeName string
}{
{"Id", "string"},
{"Name", "string"},
{"Description", "string"},
{"Sport", "string"},
{"Model", "string"},
}
func TestPositionModel(t *testing.T) {
m := Position{}
if reflect.TypeOf(m).NumField() != len(positionModelTestTable) {
t.Fail()
}
for index, testData := range positionModelTestTable {
givenType := reflect.TypeOf(m).Field(index).Type.Kind().String()
if givenType != testData.typeName {
t.Fail()
}
}
}
func TestListPositions(t *testing.T) {
var (
positionDao = PositionDAO{Db: dao.TestDb}
)
positions, err := positionDao.FindAll()
if err != nil {
t.Fail()
}
if len(positions) != 0 {
t.Fail()
}
}
func TestInsertPosition(t *testing.T) {
var (
positionDao = PositionDAO{Db: dao.TestDb}
position = Position{}
positions []Position
)
position.ID = bson.NewObjectId()
position.Name = "test"
err := positionDao.Insert(position)
if err != nil {
t.Fail()
}
positions, err = positionDao.FindAll()
if err != nil {
t.Fail()
}
if len(positions) != 1 {
t.Fail()
}
}
func TestUpsertPosition(t *testing.T) {
var (
positionDao = PositionDAO{Db: dao.TestDb}
position = Position{}
)
position.ID = bson.NewObjectId()
position.Name = "test2"
positionDao.Upsert(position)
positions, err := positionDao.FindAll()
if err != nil {
t.Fail()
}
if len(positions) != 2 {
t.Fail()
}
}
func TestDeletePosition(t *testing.T) {
var (
positionDao = PositionDAO{Db: dao.TestDb}
)
positions, err := positionDao.FindAll()
if err != nil {
t.Fail()
}
for _, position := range positions {
positionDao.Delete(position)
}
positions, err = positionDao.FindAll()
if err != nil {
t.Fail()
}
if len(positions) != 0 {
t.Fail()
}
}
go/pkg/tysc/routes.go
+22
View File
@@ -0,0 +1,22 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/auth"
"github.com/gin-gonic/gin"
)
// GetRoutes returns all routes for TYSC related data.
func GetRoutes(router *gin.Engine) {
tyscRoutes := router.Group("/tysc")
tyscRoutes.GET("/", auth.EnsureLoggedIn(), showIndexPage)
tyscRoutes.GET("/sport", auth.EnsureLoggedIn(), showSportList)
tyscRoutes.GET("/position", auth.EnsureLoggedIn(), showIndexPage)
tyscRoutes.GET("/team", auth.EnsureLoggedIn(), showIndexPage)
tyscRoutes.GET("/player", auth.EnsureLoggedIn(), showIndexPage)
tyscRoutes.GET("/manufacturer", auth.EnsureLoggedIn(), showIndexPage)
tyscRoutes.GET("/cardset", auth.EnsureLoggedIn(), showIndexPage)
tyscRoutes.GET("/parallelset", auth.EnsureLoggedIn(), showIndexPage)
tyscRoutes.GET("/insertset", auth.EnsureLoggedIn(), showIndexPage)
tyscRoutes.GET("/card", auth.EnsureLoggedIn(), showIndexPage)
}
go/pkg/tysc/sport.go
+12
View File
@@ -0,0 +1,12 @@
package tysc
import (
"gopkg.in/mgo.v2/bson"
)
// Sport defines the data model for TYSC sports with id, and name.
type Sport struct {
ID bson.ObjectId `json:"_id" bson:"_id,omitempty"`
Name string `json:"name" bson:"name"`
Model string `json:"model" bson:"model,omitempty"`
}
go/pkg/tysc/sport_dao.go
+74
View File
@@ -0,0 +1,74 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
mgo "gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson"
)
// SportDAO extends the type BaseDAO.
type SportDAO struct {
Db dao.BaseDAO
}
const (
// SPORTCOLLECTION defines the collection name for storing sports.
SPORTCOLLECTION = "sport"
// SPORTMODEL defines the name of the sport data model.
SPORTMODEL = "kontor.tysc.sport"
)
// FindAll retrieves the list of sports from the database.
func (m *SportDAO) FindAll() ([]Sport, error) {
m.Db.Connect()
var sports []Sport
err := m.Db.MongoDb.C(SPORTCOLLECTION).Find(bson.M{"model": SPORTMODEL}).All(&sports)
return sports, err
}
// FindByID returns a sport with given id or returns the error.
func (m *SportDAO) FindByID(id string) (Sport, error) {
m.Db.Connect()
var sport Sport
err := m.Db.MongoDb.C(SPORTCOLLECTION).FindId(bson.ObjectIdHex(id)).One(&sport)
return sport, err
}
// FindByName returns a sport with given name or returns the error.
func (m *SportDAO) FindByName(name string) (Sport, error) {
m.Db.Connect()
var sport Sport
err := m.Db.MongoDb.C(SPORTCOLLECTION).Find(bson.M{"name": name, "model": SPORTMODEL}).One(&sport)
return sport, err
}
// Insert a sport into database.
func (m *SportDAO) Insert(sport Sport) error {
m.Db.Connect()
sport.Model = SPORTMODEL
err := m.Db.MongoDb.C(SPORTCOLLECTION).Insert(&sport)
return err
}
// Upsert a sport into database.
func (m *SportDAO) Upsert(sport Sport) (*mgo.ChangeInfo, error) {
m.Db.Connect()
sport.Model = SPORTMODEL
info, err := m.Db.MongoDb.C(SPORTCOLLECTION).Upsert(bson.M{"name": sport.Name}, &sport)
return info, err
}
// Update an existing sport.
func (m *SportDAO) Update(sport Sport) error {
m.Db.Connect()
err := m.Db.MongoDb.C(SPORTCOLLECTION).UpdateId(sport.ID, &sport)
return err
}
// Delete an existing sport.
func (m *SportDAO) Delete(sport Sport) error {
m.Db.Connect()
err := m.Db.MongoDb.C(SPORTCOLLECTION).Remove(&sport)
return err
}
go/pkg/tysc/sport_test.go
+102
View File
@@ -0,0 +1,102 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
"reflect"
"testing"
"gopkg.in/mgo.v2/bson"
)
var sportModelTestTable = []struct {
name string
typeName string
}{
{"Id", "string"},
{"Name", "string"},
{"Model", "string"},
}
func TestSport(t *testing.T) {
m := Sport{}
if reflect.TypeOf(m).NumField() != len(sportModelTestTable) {
t.Fail()
}
for index, testData := range sportModelTestTable {
givenType := reflect.TypeOf(m).Field(index).Type.Kind().String()
if givenType != testData.typeName {
t.Fail()
}
}
}
func TestListSports(t *testing.T) {
var (
sportDao = SportDAO{Db: dao.TestDb}
)
sports, err := sportDao.FindAll()
if err != nil {
t.Fail()
}
if len(sports) != 0 {
t.Fail()
}
}
func TestInsertSport(t *testing.T) {
var (
sportDao = SportDAO{Db: dao.TestDb}
sport = Sport{}
sports []Sport
)
sport.ID = bson.NewObjectId()
sport.Name = "test"
err := sportDao.Insert(sport)
if err != nil {
t.Fail()
}
sports, err = sportDao.FindAll()
if err != nil {
t.Fail()
}
if len(sports) != 1 {
t.Fail()
}
}
func TestUpsertSport(t *testing.T) {
var (
sportDao = SportDAO{Db: dao.TestDb}
sport = Sport{}
)
sport.ID = bson.NewObjectId()
sport.Name = "test2"
sportDao.Upsert(sport)
sports, err := sportDao.FindAll()
if err != nil {
t.Fail()
}
if len(sports) != 2 {
t.Fail()
}
}
func TestDeleteSport(t *testing.T) {
var (
sportDao = SportDAO{Db: dao.TestDb}
)
sports, err := sportDao.FindAll()
if err != nil {
t.Fail()
}
for _, sport := range sports {
sportDao.Delete(sport)
}
sports, err = sportDao.FindAll()
if err != nil {
t.Fail()
}
if len(sports) != 0 {
t.Fail()
}
}
go/pkg/tysc/team.go
+14
View File
@@ -0,0 +1,14 @@
package tysc
import (
"gopkg.in/mgo.v2/bson"
)
// Team defines the data model for TYSC teams with id, name and sport.
type Team struct {
ID bson.ObjectId `json:"_id" bson:"_id,omitempty"`
Name string `json:"name" bson:"name"`
Shortname string `json:"shortname" bson:"shortname"`
Sport bson.ObjectId `json:"sport" bson:"sport,omitempty"`
Model string `json:"model" bson:"model,omitempty"`
}
go/pkg/tysc/team_dao.go
+74
View File
@@ -0,0 +1,74 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
mgo "gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson"
)
// TeamDAO extends the type BaseDAO.
type TeamDAO struct {
Db dao.BaseDAO
}
const (
// TEAMCOLLECTION defines the collection name for storing teams.
TEAMCOLLECTION = "team"
// TEAMMODEL defines the name of the team data model.
TEAMMODEL = "kontor.tysc.team"
)
// FindAll retrieves the list of cards from the database.
func (m *TeamDAO) FindAll() ([]Team, error) {
m.Db.Connect()
var teams []Team
err := m.Db.MongoDb.C(TEAMCOLLECTION).Find(bson.M{"model": TEAMMODEL}).All(&teams)
return teams, err
}
// FindByID returns a team with given id or returns the error.
func (m *TeamDAO) FindByID(id string) (Team, error) {
m.Db.Connect()
var team Team
err := m.Db.MongoDb.C(TEAMCOLLECTION).FindId(bson.ObjectIdHex(id)).One(&team)
return team, err
}
// FindByName returns a team with given name or returns the error.
func (m *TeamDAO) FindByName(name string) (Team, error) {
m.Db.Connect()
var team Team
err := m.Db.MongoDb.C(TEAMCOLLECTION).Find(bson.M{"name": name, "model": TEAMMODEL}).One(&team)
return team, err
}
// Insert a team into database
func (m *TeamDAO) Insert(team Team) error {
m.Db.Connect()
team.Model = TEAMMODEL
err := m.Db.MongoDb.C(TEAMCOLLECTION).Insert(&team)
return err
}
// Upsert a team into database
func (m *TeamDAO) Upsert(team Team) (*mgo.ChangeInfo, error) {
m.Db.Connect()
team.Model = TEAMMODEL
info, err := m.Db.MongoDb.C(TEAMCOLLECTION).Upsert(bson.M{"name": team.Name}, &team)
return info, err
}
// Update an existing team.
func (m *TeamDAO) Update(team Team) error {
m.Db.Connect()
err := m.Db.MongoDb.C(TEAMCOLLECTION).UpdateId(team.ID, &team)
return err
}
// Delete an existing team.
func (m *TeamDAO) Delete(team Team) error {
m.Db.Connect()
err := m.Db.MongoDb.C(TEAMCOLLECTION).Remove(&team)
return err
}
go/pkg/tysc/team_test.go
+103
View File
@@ -0,0 +1,103 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
"reflect"
"testing"
"gopkg.in/mgo.v2/bson"
)
var teamModelTestTable = []struct {
name string
typeName string
}{
{"Id", "string"},
{"Name", "string"},
{"Shortname", "string"},
{"Sport", "string"},
{"Model", "string"},
}
func TestTeamModel(t *testing.T) {
m := Team{}
if reflect.TypeOf(m).NumField() != len(teamModelTestTable) {
t.Fail()
}
for index, testData := range teamModelTestTable {
givenType := reflect.TypeOf(m).Field(index).Type.Kind().String()
if givenType != testData.typeName {
t.Fail()
}
}
}
func TestListTeams(t *testing.T) {
var (
teamDao = TeamDAO{Db: dao.TestDb}
)
teams, err := teamDao.FindAll()
if err != nil {
t.Fail()
}
if teams != nil {
t.Fail()
}
}
func TestInsertTeam(t *testing.T) {
var (
teamDao = TeamDAO{Db: dao.TestDb}
team = Team{}
teams []Team
)
team.ID = bson.NewObjectId()
err := teamDao.Insert(team)
if err != nil {
t.Fail()
}
teams, err = teamDao.FindAll()
if err != nil {
t.Fail()
}
if len(teams) != 1 {
t.Fail()
}
}
func TestUpsertTeam(t *testing.T) {
var (
teamDao = TeamDAO{Db: dao.TestDb}
team = Team{}
)
team.ID = bson.NewObjectId()
team.Name = "test2"
teamDao.Upsert(team)
teams, err := teamDao.FindAll()
if err != nil {
t.Fail()
}
if len(teams) != 2 {
t.Fail()
}
}
func TestDeleteTeam(t *testing.T) {
var (
teamDao = TeamDAO{Db: dao.TestDb}
)
teams, err := teamDao.FindAll()
if err != nil {
t.Fail()
}
for _, team := range teams {
teamDao.Delete(team)
}
teams, err = teamDao.FindAll()
if err != nil {
t.Fail()
}
if len(teams) != 0 {
t.Fail()
}
}
go/pkg/tysc/views.go
+22
View File
@@ -0,0 +1,22 @@
package tysc
import (
"gitlab.thpeetz.de/kontor/kontor-go/pkg/dao"
"gitlab.thpeetz.de/kontor/kontor-go/pkg/util"
"net/http"
"github.com/gin-gonic/gin"
)
func showIndexPage(c *gin.Context) {
util.Render(c, gin.H{"title": "TradeYourSportsCards", "payload": nil}, "tysc/index.html")
}
func showSportList(c *gin.Context) {
var dao = SportDAO{Db: dao.KontorDb}
if sports, err := dao.FindAll(); err == nil {
util.Render(c, gin.H{"title": "TYSC Sport List", "payload": sports}, "tysc/sports.html")
} else {
c.AbortWithError(http.StatusNotFound, err)
}
}