/
item_repository.go
150 lines (139 loc) · 4.67 KB
/
item_repository.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
package items
import (
"encoding/json"
"log"
"github.com/charisworks/charisworks-backend/internal/utils"
"gorm.io/gorm"
)
type ItemRepository struct {
DB *gorm.DB
}
func (r ItemRepository) GetItemOverview(itemId string) (overview Overview, err error) {
DBItem := new(utils.InternalItem)
if err := r.DB.Table("items").Select("items.*, users.*").Joins("JOIN users ON items.manufacturer_user_id = users.id").Where("items.id = ?", itemId).First(DBItem).Error; err != nil {
log.Print("DB error: ", err)
if err.Error() == "record not found" {
err = &utils.InternalError{Message: utils.InternalErrorNotFound}
} else {
err = &utils.InternalError{Message: utils.InternalErrorDB}
}
return overview, err
}
tags := new([]string)
json.Unmarshal([]byte(DBItem.Item.Tags), &tags)
overview = Overview{
Item_id: DBItem.Item.Id,
Properties: OverviewProperties{
Name: DBItem.Item.Name,
Price: DBItem.Item.Price,
Details: OverviewDetails{
Status: Status(DBItem.Item.Status),
Stock: DBItem.Item.Stock,
Size: DBItem.Item.Size,
Description: DBItem.Item.Description,
Tags: *tags,
},
},
Manufacturer: ManufacturerDetails{
Name: DBItem.User.DisplayName,
StripeAccountId: DBItem.User.StripeAccountId,
Description: DBItem.User.Description,
UserId: DBItem.User.Id,
},
}
return overview, nil
}
func getItemPreview(db *gorm.DB, page int, pageSize int, conditions map[string]interface{}, tags []string) ([]Preview, int, error) {
previews := new([]Preview)
items := new([]utils.Item)
offset := (page - 1) * pageSize
query := db.Model(&utils.Item{})
for key, value := range conditions {
query = query.Where(key, value)
}
for _, tag := range tags {
query = query.Where("tags LIKE ?", "%"+tag+"%")
}
totalElements := query.Find(&items).RowsAffected
err := query.Offset(offset).Limit(pageSize).Find(&items).Error
if err != nil {
log.Print("DB error: ", err)
if err.Error() == "record not found" {
err = &utils.InternalError{Message: utils.InternalErrorNotFound}
} else {
err = &utils.InternalError{Message: utils.InternalErrorDB}
}
return nil, 0, &utils.InternalError{Message: utils.InternalErrorDB}
}
for _, item := range *items {
preview := new(Preview)
preview.Item_id = item.Id
preview.Properties.Details.Status = Status(item.Status)
preview.Properties.Name = item.Name
preview.Properties.Price = item.Price
*previews = append(*previews, *preview)
}
return *previews, int(totalElements), nil
}
func (r ItemRepository) GetPreviewList(pageNum int, pageSize int, conditions map[string]interface{}, tags []string) ([]Preview, int, error) {
ItemPreview, totalElements, err := getItemPreview(r.DB, pageNum, pageSize, conditions, tags)
if err != nil {
return nil, 0, err
}
return ItemPreview, totalElements, nil
}
type GetStatus struct {
DB *gorm.DB
}
func (r GetStatus) GetItem(itemId string) (status ItemStatus, err error) {
ItemRepository := new(utils.Item)
if err := r.DB.Table("items").Where("id = ?", itemId).First(ItemRepository).Error; err != nil {
log.Print("DB error: ", err)
if err.Error() == "record not found" {
err = &utils.InternalError{Message: utils.InternalErrorNotFound}
} else {
err = &utils.InternalError{Message: utils.InternalErrorDB}
}
return status, err
}
status = *new(ItemStatus)
status.Stock = ItemRepository.Stock
status.Status = Status(ItemRepository.Status)
return status, nil
}
type Updater struct {
DB *gorm.DB
}
func (r Updater) ReduceStock(itemId string, Quantity int) error {
ItemRepository := new(utils.Item)
if err := r.DB.Table("items").Where("id = ?", itemId).First(ItemRepository).Error; err != nil {
log.Print("DB error: ", err)
if err.Error() == "record not found" {
err = &utils.InternalError{Message: utils.InternalErrorNotFound}
} else {
err = &utils.InternalError{Message: utils.InternalErrorDB}
}
return err
}
condition := map[string]interface{}{"stock": ItemRepository.Stock - Quantity}
if err := r.DB.Table("items").Where("id = ?", itemId).Updates(condition).Error; err != nil {
log.Print("DB error: ", err)
if err.Error() == "record not found" {
err = &utils.InternalError{Message: utils.InternalErrorNotFound}
} else {
err = &utils.InternalError{Message: utils.InternalErrorDB}
}
return err
}
return nil
}
func (r Updater) StatusUpdate(itemId string, State Status) {
ItemRepository := new(utils.Item)
if err := r.DB.Table("items").Where("id = ?", itemId).First(ItemRepository).Error; err != nil {
log.Print("DB error: ", err)
}
ItemRepository.Status = string(State)
if err := r.DB.Table("items").Where("id = ?", itemId).Updates(ItemRepository).Error; err != nil {
log.Print("DB error: ", err)
}
}