147 lines
3.0 KiB
Go
147 lines
3.0 KiB
Go
package main
|
|
|
|
import (
|
|
"errors"
|
|
)
|
|
|
|
type MemDB struct {
|
|
MovieList map[int]*Movie
|
|
TagList map[int]*Tag
|
|
TagToMovie map[string][]int
|
|
mId int
|
|
tId int
|
|
}
|
|
|
|
func CreateMemDB() *MemDB {
|
|
return &MemDB{make(map[int]*Movie), make(map[int]*Tag), make(map[string][]int), 1, 1}
|
|
}
|
|
|
|
func (m *MemDB) CreateMovie(title, imdb string) (Movie, error) {
|
|
mov := Movie{m.mId, title, imdb, []*Tag{}}
|
|
m.MovieList[m.mId] = &mov
|
|
m.mId = m.mId + 1
|
|
return mov, nil
|
|
}
|
|
|
|
func (m *MemDB) UpdateMovie(id int, title string, imdb string) error {
|
|
m.MovieList[id].Title = title
|
|
m.MovieList[id].Imdb = imdb
|
|
return nil
|
|
}
|
|
func (m *MemDB) GetMovies(limit ...int) ([]Movie, error) {
|
|
lim := -1
|
|
var res []Movie
|
|
if len(limit) > 0 {
|
|
lim = limit[0]
|
|
}
|
|
count := 0
|
|
for _, mov := range m.MovieList {
|
|
if count == lim {
|
|
break
|
|
}
|
|
res = append(res, *mov)
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (m *MemDB) GetMovieById(id int) (Movie, error) {
|
|
mov := m.MovieList[id]
|
|
if mov.ID == 0 {
|
|
return *mov, errors.New("No movie found!")
|
|
} else {
|
|
return *mov, nil
|
|
}
|
|
}
|
|
|
|
func (m *MemDB) GetMoviesByTag(id int) ([]Movie, error) {
|
|
tag := m.TagList[id]
|
|
if tag.Name == "" {
|
|
return []Movie{}, nil //nonexistent tag is a valid option
|
|
}
|
|
var res []Movie
|
|
movies := m.TagToMovie[tag.Name]
|
|
for _, movID := range movies {
|
|
res = append(res, *m.MovieList[movID])
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (m *MemDB) DeleteMovie(id int) error {
|
|
delete(m.MovieList, id)
|
|
return nil
|
|
}
|
|
|
|
func (m *MemDB) CreateTag(name string) (Tag, error) {
|
|
tag := Tag{m.tId, name}
|
|
m.TagList[m.tId] = &tag
|
|
m.tId = m.tId + 1
|
|
return tag, nil
|
|
}
|
|
|
|
func (m *MemDB) DeleteTag(id int) error {
|
|
tag := m.TagList[id]
|
|
delete(m.TagList, id)
|
|
delete(m.TagToMovie, tag.Name)
|
|
return nil
|
|
}
|
|
|
|
func (m *MemDB) GetTags(limit ...int) ([]Tag, error) {
|
|
lim := -1
|
|
var res []Tag
|
|
if len(limit) > 0 {
|
|
lim = limit[0]
|
|
}
|
|
count := 0
|
|
for _, tag := range m.TagList {
|
|
if count == lim {
|
|
break
|
|
}
|
|
res = append(res, *tag)
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (m *MemDB) GetTagById(id int) (Tag, error) {
|
|
tag := m.TagList[id]
|
|
if tag.ID == 0 {
|
|
return *tag, errors.New("No tag found!")
|
|
} else {
|
|
return *tag, nil
|
|
}
|
|
}
|
|
|
|
func (m *MemDB) TagMovie(tagId int, movieId int) error {
|
|
mov := m.MovieList[movieId]
|
|
tag := m.TagList[tagId]
|
|
if mov.ID == 0 {
|
|
return errors.New("No movie found for tagging!")
|
|
}
|
|
if tag.ID == 0 {
|
|
return errors.New("No tag found for tagging!")
|
|
}
|
|
m.TagToMovie[tag.Name] = append(m.TagToMovie[tag.Name], movieId)
|
|
mov.Tags = append(mov.Tags, tag)
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m *MemDB) UnTagMovie(tagId int, movieId int) error {
|
|
mov := m.MovieList[movieId]
|
|
tag := m.TagList[tagId]
|
|
if mov.ID == 0 {
|
|
return errors.New("No movie found for untagging!")
|
|
}
|
|
if tag.ID == 0 {
|
|
return errors.New("No tag found for untagging!")
|
|
}
|
|
for i, v := range m.TagToMovie[tag.Name] {
|
|
if v == movieId {
|
|
m.TagToMovie[tag.Name][i] = m.TagToMovie[tag.Name][len(m.TagToMovie[tag.Name])-1]
|
|
m.TagToMovie[tag.Name] = m.TagToMovie[tag.Name][:len(m.TagToMovie[tag.Name])-1]
|
|
break
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|