NTO/boilerplate
Archived
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

del: clean template

Browse Source
This commit is contained in:
Goga Coder
2025-03-16 11:33:19 +07:00
parent 3f8b548cd0
commit eb50e9a2ac
85 changed files with 737 additions and 16392 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
internal/services/customer.go
View File

@@ -1,69 +0,0 @@
package services
import (
"app/internal/dal"
"app/internal/database"
"app/internal/models"
"app/internal/utils"
"errors"
"gorm.io/gen/field"
"gorm.io/gorm"
)
type CustomerService struct {
}
type Customer = models.Customer
func (service *CustomerService) Create(item Customer) (Customer, error) {
utils.ReplaceEmptySlicesWithNil(&item)
err := dal.Customer.Create(&item)
if err != nil {
return item, err
}
err = utils.AppendAssociations(database.GetInstance(), &item)
return item, err
}
func (service *CustomerService) GetAll() ([]*Customer, error) {
var customers []*Customer
customers, err := dal.Customer.Preload(field.Associations).Find()
return customers, err
}
func (service *CustomerService) GetById(id uint) (*Customer, error) {
item, err := dal.Customer.Preload(field.Associations).Where(dal.Customer.Id.Eq(id)).First()
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
} else {
return nil, err
}
}
return item, nil
}
func (service *CustomerService) Update(item Customer) (Customer, error) {
utils.ReplaceEmptySlicesWithNil(&item)
_, err := dal.Customer.Updates(&item)
if err != nil {
return item, err
}
err = utils.UpdateAssociations(database.GetInstance(), &item)
if err != nil {
return item, err
}
return item, err
}
func (service *CustomerService) Delete(id uint) error {
_, err := dal.Customer.Unscoped().Where(dal.Customer.Id.Eq(id)).Delete()
return err
}
func (service *CustomerService) Count() (int64, error) {
amount, err := dal.Customer.Count()
return amount, err
}
func (service *CustomerService) SortedByOrder(fieldsSortingOrder []utils.SortField) ([]*Customer, error) {
return utils.SortByOrder(fieldsSortingOrder, Customer{})
}
func (service *CustomerService) SearchByAllTextFields(phrase string) ([]*Customer, error) {
return utils.FindPhraseByStringFields[Customer](phrase, Customer{})
}

414
internal/services/default_data.go
View File

@@ -3,20 +3,28 @@ package services
import (
"app/internal/dialogs"
"fmt"
"time"
)
func InsertDefaultData() {
insertWorkshops()
insertProductTypes()
insertCustomers()
insertOrders()
insertTasks()
insertPrepTasks()
insertShifts()
insertTeamTypes()
insertWorkers()
insertTeamTasks()
insertPosts()
}
// Example of usage
//func insertProductTypes() {
// InsertDefaultEntityData(&ProductTypeService{}, []ProductType{
// {Id: 1, Name: "Сырые пиломатериалы"},
// {Id: 2, Name: "Сухие пиломатериалы"},
// {Id: 3, Name: "Строганные доски"},
// {Id: 4, Name: "Рейки"},
// {Id: 5, Name: "Брус"},
// {Id: 6, Name: "Пеллеты"},
// })
//}
func insertPosts() {
InsertDefaultEntityData(&PostService{}, []Post{
{Text: "В Кузбассе начали строить дома выше, чтобы их жители стали ближе к Богу."},
})
}
func InsertDefaultEntityData[T any](service Service[T], entities []T) {
@@ -27,387 +35,3 @@ func InsertDefaultEntityData[T any](service Service[T], entities []T) {
}
}
}
func insertWorkshops() {
InsertDefaultEntityData(&WorkshopService{}, []Workshop{
{
Id: 1,
Name: "Лесопильный комплекс",
WorkAreas: []WorkArea{
{
Id: 1,
Name: "Лесопильная линия №1",
Description: "Используется для распиловки тонкомеров, например, реек.",
PrepTasks: nil,
Performance: 50,
},
{
Id: 2,
Name: "Лесопильная линия №2",
Description: "Используется для распиловки среднего леса.",
PrepTasks: nil,
Performance: 100,
},
},
Tasks: nil,
},
{
Id: 2,
Name: "Сушильный комплекс",
WorkAreas: []WorkArea{
{Id: 3, Name: "Сушильная камера №1", Performance: 50},
{Id: 4, Name: "Сушильная камера №2", Performance: 60},
{Id: 5, Name: "Сушильная камера №3", Performance: 80},
{Id: 6, Name: "Сушильная камера №4", Performance: 85},
},
Tasks: nil,
},
{
Id: 3,
Name: "Цех строжки и обработки",
WorkAreas: []WorkArea{
{
Id: 7,
Name: "Линия строжки №1",
Description: "Используется для строжки тонкомеров",
Performance: 50,
},
{
Id: 8,
Name: "Линия строжки №2",
Description: "Используется для строжки среднего леса",
Performance: 80,
},
{
Id: 9,
Name: "Линия строжки №3",
Description: "Используется для строжки среднего леса",
Performance: 100,
},
},
Tasks: nil,
},
{
Id: 4,
Name: "Пеллетный цех",
WorkAreas: []WorkArea{
{Id: 10, Name: "Дробилка", Performance: 800},
{Id: 11, Name: "Сушилка", Performance: 900},
{Id: 12, Name: "Гранулятор №1", Performance: 900},
{Id: 13, Name: "Гранулятор №2", Performance: 600},
},
Tasks: nil,
},
})
}
func insertProductTypes() {
InsertDefaultEntityData(&ProductTypeService{}, []ProductType{
{Id: 1, Name: "Сырые пиломатериалы"},
{Id: 2, Name: "Сухие пиломатериалы"},
{Id: 3, Name: "Строганные доски"},
{Id: 4, Name: "Рейки"},
{Id: 5, Name: "Брус"},
{Id: 6, Name: "Пеллеты"},
})
}
func insertCustomers() {
InsertDefaultEntityData(&CustomerService{}, []Customer{
{
Id: 1,
Title: "Rivalli",
Contact: "Телефон: +74955855525",
Orders: []Order{},
},
{
Id: 2,
Title: "Elemfort",
Contact: "Телефон: +79270988888",
Orders: []Order{},
},
{
Id: 3,
Title: "Квазар",
Contact: "Телефон: +78002342134",
Orders: []Order{},
},
})
}
func insertOrders() {
InsertDefaultEntityData(&OrderService{}, []Order{
{
Status: "Согласован клиентом",
ProductAmount: 400,
ProductTypeId: 1,
Description: "Сырая древесина для Rivalli",
DeadlineDate: time.Date(2025, 6, 25, 0, 0, 0, 0, time.Local).Unix(),
CustomerId: 1,
},
{
Status: "Согласован клиентом",
ProductTypeId: 3,
ProductAmount: 300,
Description: "Сухая древесина для производителя мебели. Контракт #574853",
DeadlineDate: time.Date(2025, 6, 10, 0, 0, 0, 0, time.Local).Unix(),
CustomerId: 2,
},
{
Status: "Согласован клиентом",
ProductAmount: 100,
ProductTypeId: 4,
Description: "Контракт #234342",
DeadlineDate: time.Date(2025, 12, 5, 0, 0, 0, 0, time.Local).Unix(),
CustomerId: 3,
},
{
Status: "Согласован клиентом",
ProductAmount: 800,
ProductTypeId: 6,
Description: "Производство пеллет",
DeadlineDate: time.Date(2025, 2, 5, 0, 0, 0, 0, time.Local).Unix(),
CustomerId: 3,
},
{
Status: "Черновик",
ProductAmount: 100,
ProductTypeId: 6,
Description: "Производство пеллет. Заказ на стадии согласования",
DeadlineDate: time.Date(2026, 2, 5, 0, 0, 0, 0, time.Local).Unix(),
CustomerId: 1,
},
})
}
func insertTasks() {
InsertDefaultEntityData(&TaskService{}, []Task{
{
Id: 1,
Description: "Обработка сырых пиломатериалов",
ProductTypeId: 2,
Workshops: []*Workshop{{Id: 1}},
OrderId: 1,
ProductionStart: time.Date(2025, 11, 25, 0, 0, 0, 0, time.Local).Unix(),
Amount: 10,
},
{
Id: 2,
Description: "Распиловка леса",
ProductTypeId: 1,
Workshops: []*Workshop{{Id: 1}, {Id: 2}},
OrderId: 2,
ProductionStart: time.Date(2025, 8, 15, 0, 0, 0, 0, time.Local).Unix(),
Amount: 1,
},
{
Id: 3,
Description: "Строгание реек",
ProductTypeId: 3,
Workshops: []*Workshop{{Id: 1}, {Id: 2}},
OrderId: 3,
ProductionStart: time.Date(2025, 7, 10, 0, 0, 0, 0, time.Local).Unix(),
Amount: 5,
},
{
Id: 4,
Description: "Производство пеллет",
ProductTypeId: 6,
Workshops: []*Workshop{{Id: 4}},
OrderId: 4,
ProductionStart: time.Date(2025, 4, 5, 0, 0, 0, 0, time.Local).Unix(),
Amount: 1,
},
})
}
func insertPrepTasks() {
InsertDefaultEntityData(&PrepTaskService{}, []PrepTask{
{
Id: 1,
Description: "Подготовка лесопильной линии. Материал для обработки: сырые пиломатериалы",
TaskId: 1,
WorkAreaId: 2,
Deadline: time.Date(2025, 11, 10, 0, 0, 0, 0, time.Local).Unix(),
},
{
Id: 2,
Description: "Подготовка лесопильной линии. Материал для обработки: сухие пиломатериалы",
TaskId: 2,
WorkAreaId: 1,
Deadline: time.Date(2025, 8, 10, 0, 0, 0, 0, time.Local).Unix(),
},
{
Id: 3,
Description: "Подготовка сушильной камеры. Сушка распиленных сухих пиломатериалов",
TaskId: 2,
WorkAreaId: 3,
Deadline: time.Date(2025, 8, 15, 0, 0, 0, 0, time.Local).Unix(),
},
{
Id: 4,
Description: "Подготовка лесопильного цеха для производства реек. Сушка древесины для производства реек",
TaskId: 3,
WorkAreaId: 2,
Deadline: time.Date(2025, 8, 15, 0, 0, 0, 0, time.Local).Unix(),
},
{
Id: 5,
Description: "Подготовка сушильной камеры. Сушка распиленных сухих реек",
TaskId: 3,
WorkAreaId: 3,
Deadline: time.Date(2025, 8, 15, 0, 0, 0, 0, time.Local).Unix(),
},
{
Id: 6,
Description: "Подготовка дробилки для производства пеллет",
TaskId: 4,
WorkAreaId: 10,
Deadline: time.Date(2025, 4, 1, 0, 0, 0, 0, time.Local).Unix(),
},
{
Id: 7,
Description: "Подготовка сушилки для производства пеллет",
TaskId: 4,
WorkAreaId: 11,
Deadline: time.Date(2025, 4, 2, 0, 0, 0, 0, time.Local).Unix(),
},
{
Id: 8,
Description: "Подготовка гранулятора №1 для производства пеллет",
TaskId: 4,
WorkAreaId: 12,
Deadline: time.Date(2025, 4, 3, 0, 0, 0, 0, time.Local).Unix(),
},
{
Id: 9,
Description: "Подготовка гранулятора №2 для производства пеллет",
TaskId: 4,
WorkAreaId: 13,
Deadline: time.Date(2025, 4, 4, 0, 0, 0, 0, time.Local).Unix(),
},
})
}
func insertShifts() {
InsertDefaultEntityData(&ShiftService{}, []Shift{
{
Id: 1,
Description: "Распилка лесоматериалов",
ProductTypeId: 1,
ProductAmount: 45,
ShiftDate: time.Date(2025, 11, 20, 0, 0, 0, 0, time.Local).Unix(),
WorkAreaId: 2,
},
{
Id: 2,
Description: "Обработка сухой древесины",
ProductTypeId: 3,
ProductAmount: 39,
ShiftDate: time.Date(2025, 8, 13, 0, 0, 0, 0, time.Local).Unix(),
WorkAreaId: 1,
},
{
Id: 3,
Description: "Сушка реек",
ProductTypeId: 4,
ProductAmount: 55,
ShiftDate: time.Date(2025, 7, 8, 0, 0, 0, 0, time.Local).Unix(),
WorkAreaId: 4,
},
{
Id: 4,
Description: "Грануляция паллет",
ProductTypeId: 6,
ProductAmount: 890,
ShiftDate: time.Date(2025, 4, 1, 0, 0, 0, 0, time.Local).Unix(),
WorkAreaId: 12,
},
})
}
func insertTeamTypes() {
InsertDefaultEntityData(&TeamTypeService{}, []TeamType{
{Id: 1, Name: "Бригада по распиловке"},
{Id: 2, Name: "Бригада по сушке"},
{Id: 3, Name: "Бригада по обработке"},
{Id: 4, Name: "Бригада пеллетного цеха"},
})
}
func insertWorkers() {
InsertDefaultEntityData(&WorkerService{}, []Worker{
{Id: 1, Name: "Иванов Иван Иванович", WorkshopId: 1},
{Id: 2, Name: "Петров Петр Петрович", WorkshopId: 1},
{Id: 3, Name: "Сидоров Сидор Сидорович", WorkshopId: 1},
{Id: 4, Name: "Пеллетчиков Пеллет Пеллетович", WorkshopId: 4},
{Id: 5, Name: "Кузнецов Кузьма Кузьмич", WorkshopId: 2},
{Id: 6, Name: "Смирнов Сергей Сергеевич", WorkshopId: 2},
{Id: 7, Name: "Васильев Василий Васильевич", WorkshopId: 3},
{Id: 8, Name: "Михайлов Михаил Михайлович", WorkshopId: 3},
{Id: 10, Name: "Александров Александр Александрович", WorkshopId: 4},
{Id: 11, Name: "Николаев Николай Николаевич", WorkshopId: 4},
{Id: 12, Name: "Дмитриев Дмитрий Дмитриевич", WorkshopId: 4},
{Id: 13, Name: "Дмитриев Дмитрий Федорович", WorkshopId: 4},
})
}
func insertTeamTasks() {
InsertDefaultEntityData(&TeamTaskService{}, []TeamTask{
{
Id: 1,
TeamTypeId: 1,
TeamMembers: []*Worker{
{Id: 1},
},
WorkAreaId: 2,
ShiftDuties: "1/1",
WorkStartDate: time.Date(2024, 12, 5, 0, 0, 0, 0, time.Local).Unix(),
TeamLeaderId: 13,
},
{
Id: 2,
TeamTypeId: 1,
TeamMembers: []*Worker{
{Id: 2}, {Id: 3},
},
WorkAreaId: 1,
ShiftDuties: "1/1",
WorkStartDate: time.Date(2024, 12, 10, 0, 0, 0, 0, time.Local).Unix(),
TeamLeaderId: 2,
},
{
Id: 3,
TeamTypeId: 2,
TeamMembers: []*Worker{
{Id: 5}, {Id: 6},
},
WorkAreaId: 3,
ShiftDuties: "1/1",
WorkStartDate: time.Date(2025, 1, 7, 0, 0, 0, 0, time.Local).Unix(),
TeamLeaderId: 5,
},
{
Id: 4,
TeamTypeId: 3,
TeamMembers: []*Worker{
{Id: 7}, {Id: 8},
},
WorkAreaId: 8,
ShiftDuties: "2/2",
WorkStartDate: time.Date(2025, 2, 10, 0, 0, 0, 0, time.Local).Unix(),
TeamLeaderId: 7,
},
{
Id: 5,
TeamTypeId: 4,
TeamMembers: []*Worker{
{Id: 4}, {Id: 10}, {Id: 11}, {Id: 12},
},
WorkAreaId: 12,
ShiftDuties: "2/2",
WorkStartDate: time.Date(2025, 3, 10, 0, 0, 0, 0, time.Local).Unix(),
TeamLeaderId: 10,
},
})
}

2
internal/services/excel.go
View File

@@ -9,6 +9,7 @@ type ExcelModule struct{}
var ExcelService = application.NewService(&ExcelModule{})
func (s *ExcelModule) ImportAllEntities() error {
// Example of usage:
//postTypeService := PostTypeService{}
//filepath, err := dialogs.OpenFileDialog("Импорт данных")
//if err != nil {
@@ -39,6 +40,7 @@ func (s *ExcelModule) ImportAllEntities() error {
}
func (s *ExcelModule) ExportAllEntities() error {
// Example of usage:
//postService := PostService{}
//exporter := excel.Exporter[Post]{
// SheetName: "Посты",

69
internal/services/order.go
View File

@@ -1,69 +0,0 @@
package services
import (
"app/internal/dal"
"app/internal/database"
"app/internal/models"
"app/internal/utils"
"errors"
"gorm.io/gen/field"
"gorm.io/gorm"
)
type OrderService struct {
}
type Order = models.Order
func (service *OrderService) Create(item Order) (Order, error) {
utils.ReplaceEmptySlicesWithNil(&item)
err := dal.Order.Create(&item)
if err != nil {
return item, err
}
err = utils.AppendAssociations(database.GetInstance(), &item)
return item, err
}
func (service *OrderService) GetAll() ([]*Order, error) {
var orders []*Order
orders, err := dal.Order.Preload(field.Associations).Find()
return orders, err
}
func (service *OrderService) GetById(id uint) (*Order, error) {
item, err := dal.Order.Preload(field.Associations).Where(dal.Order.Id.Eq(id)).First()
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
} else {
return nil, err
}
}
return item, nil
}
func (service *OrderService) Update(item Order) (Order, error) {
utils.ReplaceEmptySlicesWithNil(&item)
_, err := dal.Order.Updates(&item)
if err != nil {
return item, err
}
err = utils.UpdateAssociations(database.GetInstance(), &item)
if err != nil {
return item, err
}
return item, err
}
func (service *OrderService) Delete(id uint) error {
_, err := dal.Order.Unscoped().Where(dal.Order.Id.Eq(id)).Delete()
return err
}
func (service *OrderService) Count() (int64, error) {
amount, err := dal.Order.Count()
return amount, err
}
func (service *OrderService) SortedByOrder(fieldsSortingOrder []utils.SortField) ([]*Order, error) {
return utils.SortByOrder(fieldsSortingOrder, Order{})
}
func (service *OrderService) SearchByAllTextFields(phrase string) ([]*Order, error) {
return utils.FindPhraseByStringFields[Order](phrase, Order{})
}

69
internal/services/post.go Normal file
View File

@@ -0,0 +1,69 @@
package services
import (
"app/internal/dal"
"app/internal/database"
"app/internal/models"
"app/internal/utils"
"errors"
"gorm.io/gen/field"
"gorm.io/gorm"
)
type PostService struct {
}
type Post = models.Post
func (service *PostService) Create(item Post) (Post, error) {
utils.ReplaceEmptySlicesWithNil(&item)
err := dal.Post.Create(&item)
if err != nil {
return item, err
}
err = utils.AppendAssociations(database.GetInstance(), &item)
return item, err
}
func (service *PostService) GetAll() ([]*Post, error) {
var posts []*Post
posts, err := dal.Post.Preload(field.Associations).Find()
return posts, err
}
func (service *PostService) GetById(id uint) (*Post, error) {
item, err := dal.Post.Preload(field.Associations).Where(dal.Post.Id.Eq(id)).First()
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
} else {
return nil, err
}
}
return item, nil
}
func (service *PostService) Update(item Post) (Post, error) {
utils.ReplaceEmptySlicesWithNil(&item)
_, err := dal.Post.Updates(&item)
if err != nil {
return item, err
}
err = utils.UpdateAssociations(database.GetInstance(), &item)
if err != nil {
return item, err
}
return item, err
}
func (service *PostService) Delete(id uint) error {
_, err := dal.Post.Unscoped().Where(dal.Post.Id.Eq(id)).Delete()
return err
}
func (service *PostService) Count() (int64, error) {
amount, err := dal.Post.Count()
return amount, err
}
func (service *PostService) SortedByOrder(fieldsSortingOrder []utils.SortField) ([]*Post, error) {
return utils.SortByOrder(fieldsSortingOrder, Post{})
}
func (service *PostService) SearchByAllTextFields(phrase string) ([]*Post, error) {
return utils.FindPhraseByStringFields[Post](phrase, Post{})
}

69
internal/services/preptask.go
View File

@@ -1,69 +0,0 @@
package services
import (
"app/internal/dal"
"app/internal/database"
"app/internal/models"
"app/internal/utils"
"errors"
"gorm.io/gen/field"
"gorm.io/gorm"
)
type PrepTaskService struct {
}
type PrepTask = models.PrepTask
func (service *PrepTaskService) Create(item PrepTask) (PrepTask, error) {
utils.ReplaceEmptySlicesWithNil(&item)
err := dal.PrepTask.Create(&item)
if err != nil {
return item, err
}
err = utils.AppendAssociations(database.GetInstance(), &item)
return item, err
}
func (service *PrepTaskService) GetAll() ([]*PrepTask, error) {
var preptasks []*PrepTask
preptasks, err := dal.PrepTask.Preload(field.Associations).Find()
return preptasks, err
}
func (service *PrepTaskService) GetById(id uint) (*PrepTask, error) {
item, err := dal.PrepTask.Preload(field.Associations).Where(dal.PrepTask.Id.Eq(id)).First()
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
} else {
return nil, err
}
}
return item, nil
}
func (service *PrepTaskService) Update(item PrepTask) (PrepTask, error) {
utils.ReplaceEmptySlicesWithNil(&item)
_, err := dal.PrepTask.Updates(&item)
if err != nil {
return item, err
}
err = utils.UpdateAssociations(database.GetInstance(), &item)
if err != nil {
return item, err
}
return item, err
}
func (service *PrepTaskService) Delete(id uint) error {
_, err := dal.PrepTask.Unscoped().Where(dal.PrepTask.Id.Eq(id)).Delete()
return err
}
func (service *PrepTaskService) Count() (int64, error) {
amount, err := dal.PrepTask.Count()
return amount, err
}
func (service *PrepTaskService) SortedByOrder(fieldsSortingOrder []utils.SortField) ([]*PrepTask, error) {
return utils.SortByOrder(fieldsSortingOrder, PrepTask{})
}
func (service *PrepTaskService) SearchByAllTextFields(phrase string) ([]*PrepTask, error) {
return utils.FindPhraseByStringFields[PrepTask](phrase, PrepTask{})
}

69
internal/services/producttype.go
View File

@@ -1,69 +0,0 @@
package services
import (
"app/internal/dal"
"app/internal/database"
"app/internal/models"
"app/internal/utils"
"errors"
"gorm.io/gen/field"
"gorm.io/gorm"
)
type ProductTypeService struct {
}
type ProductType = models.ProductType
func (service *ProductTypeService) Create(item ProductType) (ProductType, error) {
utils.ReplaceEmptySlicesWithNil(&item)
err := dal.ProductType.Create(&item)
if err != nil {
return item, err
}
err = utils.AppendAssociations(database.GetInstance(), &item)
return item, err
}
func (service *ProductTypeService) GetAll() ([]*ProductType, error) {
var producttypes []*ProductType
producttypes, err := dal.ProductType.Preload(field.Associations).Find()
return producttypes, err
}
func (service *ProductTypeService) GetById(id uint) (*ProductType, error) {
item, err := dal.ProductType.Preload(field.Associations).Where(dal.ProductType.Id.Eq(id)).First()
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
} else {
return nil, err
}
}
return item, nil
}
func (service *ProductTypeService) Update(item ProductType) (ProductType, error) {
utils.ReplaceEmptySlicesWithNil(&item)
_, err := dal.ProductType.Updates(&item)
if err != nil {
return item, err
}
err = utils.UpdateAssociations(database.GetInstance(), &item)
if err != nil {
return item, err
}
return item, err
}
func (service *ProductTypeService) Delete(id uint) error {
_, err := dal.ProductType.Unscoped().Where(dal.ProductType.Id.Eq(id)).Delete()
return err
}
func (service *ProductTypeService) Count() (int64, error) {
amount, err := dal.ProductType.Count()
return amount, err
}
func (service *ProductTypeService) SortedByOrder(fieldsSortingOrder []utils.SortField) ([]*ProductType, error) {
return utils.SortByOrder(fieldsSortingOrder, ProductType{})
}
func (service *ProductTypeService) SearchByAllTextFields(phrase string) ([]*ProductType, error) {
return utils.FindPhraseByStringFields[ProductType](phrase, ProductType{})
}

12
internal/services/services.go
View File

@@ -5,15 +5,5 @@ import (
)
var ExportedServices = []application.Service{
application.NewService(&CustomerService{}),
application.NewService(&OrderService{}),
application.NewService(&PrepTaskService{}),
application.NewService(&ProductTypeService{}),
application.NewService(&ShiftService{}),
application.NewService(&TaskService{}),
application.NewService(&TeamTaskService{}),
application.NewService(&TeamTypeService{}),
application.NewService(&WorkAreaService{}),
application.NewService(&WorkerService{}),
application.NewService(&WorkshopService{}),
application.NewService(&Post{}),
}

69
internal/services/shift.go
View File

@@ -1,69 +0,0 @@
package services
import (
"app/internal/dal"
"app/internal/database"
"app/internal/models"
"app/internal/utils"
"errors"
"gorm.io/gen/field"
"gorm.io/gorm"
)
type ShiftService struct {
}
type Shift = models.Shift
func (service *ShiftService) Create(item Shift) (Shift, error) {
utils.ReplaceEmptySlicesWithNil(&item)
err := dal.Shift.Create(&item)
if err != nil {
return item, err
}
err = utils.AppendAssociations(database.GetInstance(), &item)
return item, err
}
func (service *ShiftService) GetAll() ([]*Shift, error) {
var shifts []*Shift
shifts, err := dal.Shift.Preload(field.Associations).Find()
return shifts, err
}
func (service *ShiftService) GetById(id uint) (*Shift, error) {
item, err := dal.Shift.Preload(field.Associations).Where(dal.Shift.Id.Eq(id)).First()
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
} else {
return nil, err
}
}
return item, nil
}
func (service *ShiftService) Update(item Shift) (Shift, error) {
utils.ReplaceEmptySlicesWithNil(&item)
_, err := dal.Shift.Updates(&item)
if err != nil {
return item, err
}
err = utils.UpdateAssociations(database.GetInstance(), &item)
if err != nil {
return item, err
}
return item, err
}
func (service *ShiftService) Delete(id uint) error {
_, err := dal.Shift.Unscoped().Where(dal.Shift.Id.Eq(id)).Delete()
return err
}
func (service *ShiftService) Count() (int64, error) {
amount, err := dal.Shift.Count()
return amount, err
}
func (service *ShiftService) SortedByOrder(fieldsSortingOrder []utils.SortField) ([]*Shift, error) {
return utils.SortByOrder(fieldsSortingOrder, Shift{})
}
func (service *ShiftService) SearchByAllTextFields(phrase string) ([]*Shift, error) {
return utils.FindPhraseByStringFields[Shift](phrase, Shift{})
}

69
internal/services/task.go
View File

@@ -1,69 +0,0 @@
package services
import (
"app/internal/dal"
"app/internal/database"
"app/internal/models"
"app/internal/utils"
"errors"
"gorm.io/gen/field"
"gorm.io/gorm"
)
type TaskService struct {
}
type Task = models.Task
func (service *TaskService) Create(item Task) (Task, error) {
utils.ReplaceEmptySlicesWithNil(&item)
err := dal.Task.Create(&item)
if err != nil {
return item, err
}
err = utils.AppendAssociations(database.GetInstance(), &item)
return item, err
}
func (service *TaskService) GetAll() ([]*Task, error) {
var tasks []*Task
tasks, err := dal.Task.Preload(field.Associations).Find()
return tasks, err
}
func (service *TaskService) GetById(id uint) (*Task, error) {
item, err := dal.Task.Preload(field.Associations).Where(dal.Task.Id.Eq(id)).First()
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
} else {
return nil, err
}
}
return item, nil
}
func (service *TaskService) Update(item Task) (Task, error) {
utils.ReplaceEmptySlicesWithNil(&item)
_, err := dal.Task.Updates(&item)
if err != nil {
return item, err
}
err = utils.UpdateAssociations(database.GetInstance(), &item)
if err != nil {
return item, err
}
return item, err
}
func (service *TaskService) Delete(id uint) error {
_, err := dal.Task.Unscoped().Where(dal.Task.Id.Eq(id)).Delete()
return err
}
func (service *TaskService) Count() (int64, error) {
amount, err := dal.Task.Count()
return amount, err
}
func (service *TaskService) SortedByOrder(fieldsSortingOrder []utils.SortField) ([]*Task, error) {
return utils.SortByOrder(fieldsSortingOrder, Task{})
}
func (service *TaskService) SearchByAllTextFields(phrase string) ([]*Task, error) {
return utils.FindPhraseByStringFields[Task](phrase, Task{})
}

69
internal/services/teamtask.go
View File

@@ -1,69 +0,0 @@
package services
import (
"app/internal/dal"
"app/internal/database"
"app/internal/models"
"app/internal/utils"
"errors"
"gorm.io/gen/field"
"gorm.io/gorm"
)
type TeamTaskService struct {
}
type TeamTask = models.TeamTask
func (service *TeamTaskService) Create(item TeamTask) (TeamTask, error) {
utils.ReplaceEmptySlicesWithNil(&item)
err := dal.TeamTask.Create(&item)
if err != nil {
return item, err
}
err = utils.AppendAssociations(database.GetInstance(), &item)
return item, err
}
func (service *TeamTaskService) GetAll() ([]*TeamTask, error) {
var teamtasks []*TeamTask
teamtasks, err := dal.TeamTask.Preload(field.Associations).Find()
return teamtasks, err
}
func (service *TeamTaskService) GetById(id uint) (*TeamTask, error) {
item, err := dal.TeamTask.Preload(field.Associations).Where(dal.TeamTask.Id.Eq(id)).First()
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
} else {
return nil, err
}
}
return item, nil
}
func (service *TeamTaskService) Update(item TeamTask) (TeamTask, error) {
utils.ReplaceEmptySlicesWithNil(&item)
_, err := dal.TeamTask.Updates(&item)
if err != nil {
return item, err
}
err = utils.UpdateAssociations(database.GetInstance(), &item)
if err != nil {
return item, err
}
return item, err
}
func (service *TeamTaskService) Delete(id uint) error {
_, err := dal.TeamTask.Unscoped().Where(dal.TeamTask.Id.Eq(id)).Delete()
return err
}
func (service *TeamTaskService) Count() (int64, error) {
amount, err := dal.TeamTask.Count()
return amount, err
}
func (service *TeamTaskService) SortedByOrder(fieldsSortingOrder []utils.SortField) ([]*TeamTask, error) {
return utils.SortByOrder(fieldsSortingOrder, TeamTask{})
}
func (service *TeamTaskService) SearchByAllTextFields(phrase string) ([]*TeamTask, error) {
return utils.FindPhraseByStringFields[TeamTask](phrase, TeamTask{})
}

69
internal/services/teamtype.go
View File

@@ -1,69 +0,0 @@
package services
import (
"app/internal/dal"
"app/internal/database"
"app/internal/models"
"app/internal/utils"
"errors"
"gorm.io/gen/field"
"gorm.io/gorm"
)
type TeamTypeService struct {
}
type TeamType = models.TeamType
func (service *TeamTypeService) Create(item TeamType) (TeamType, error) {
utils.ReplaceEmptySlicesWithNil(&item)
err := dal.TeamType.Create(&item)
if err != nil {
return item, err
}
err = utils.AppendAssociations(database.GetInstance(), &item)
return item, err
}
func (service *TeamTypeService) GetAll() ([]*TeamType, error) {
var teamtypes []*TeamType
teamtypes, err := dal.TeamType.Preload(field.Associations).Find()
return teamtypes, err
}
func (service *TeamTypeService) GetById(id uint) (*TeamType, error) {
item, err := dal.TeamType.Preload(field.Associations).Where(dal.TeamType.Id.Eq(id)).First()
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
} else {
return nil, err
}
}
return item, nil
}
func (service *TeamTypeService) Update(item TeamType) (TeamType, error) {
utils.ReplaceEmptySlicesWithNil(&item)
_, err := dal.TeamType.Updates(&item)
if err != nil {
return item, err
}
err = utils.UpdateAssociations(database.GetInstance(), &item)
if err != nil {
return item, err
}
return item, err
}
func (service *TeamTypeService) Delete(id uint) error {
_, err := dal.TeamType.Unscoped().Where(dal.TeamType.Id.Eq(id)).Delete()
return err
}
func (service *TeamTypeService) Count() (int64, error) {
amount, err := dal.TeamType.Count()
return amount, err
}
func (service *TeamTypeService) SortedByOrder(fieldsSortingOrder []utils.SortField) ([]*TeamType, error) {
return utils.SortByOrder(fieldsSortingOrder, TeamType{})
}
func (service *TeamTypeService) SearchByAllTextFields(phrase string) ([]*TeamType, error) {
return utils.FindPhraseByStringFields[TeamType](phrase, TeamType{})
}

69
internal/services/workarea.go
View File

@@ -1,69 +0,0 @@
package services
import (
"app/internal/dal"
"app/internal/database"
"app/internal/models"
"app/internal/utils"
"errors"
"gorm.io/gen/field"
"gorm.io/gorm"
)
type WorkAreaService struct {
}
type WorkArea = models.WorkArea
func (service *WorkAreaService) Create(item WorkArea) (WorkArea, error) {
utils.ReplaceEmptySlicesWithNil(&item)
err := dal.WorkArea.Create(&item)
if err != nil {
return item, err
}
err = utils.AppendAssociations(database.GetInstance(), &item)
return item, err
}
func (service *WorkAreaService) GetAll() ([]*WorkArea, error) {
var workareas []*WorkArea
workareas, err := dal.WorkArea.Preload(field.Associations).Find()
return workareas, err
}
func (service *WorkAreaService) GetById(id uint) (*WorkArea, error) {
item, err := dal.WorkArea.Preload(field.Associations).Where(dal.WorkArea.Id.Eq(id)).First()
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
} else {
return nil, err
}
}
return item, nil
}
func (service *WorkAreaService) Update(item WorkArea) (WorkArea, error) {
utils.ReplaceEmptySlicesWithNil(&item)
_, err := dal.WorkArea.Updates(&item)
if err != nil {
return item, err
}
err = utils.UpdateAssociations(database.GetInstance(), &item)
if err != nil {
return item, err
}
return item, err
}
func (service *WorkAreaService) Delete(id uint) error {
_, err := dal.WorkArea.Unscoped().Where(dal.WorkArea.Id.Eq(id)).Delete()
return err
}
func (service *WorkAreaService) Count() (int64, error) {
amount, err := dal.WorkArea.Count()
return amount, err
}
func (service *WorkAreaService) SortedByOrder(fieldsSortingOrder []utils.SortField) ([]*WorkArea, error) {
return utils.SortByOrder(fieldsSortingOrder, WorkArea{})
}
func (service *WorkAreaService) SearchByAllTextFields(phrase string) ([]*WorkArea, error) {
return utils.FindPhraseByStringFields[WorkArea](phrase, WorkArea{})
}

69
internal/services/worker.go
View File

@@ -1,69 +0,0 @@
package services
import (
"app/internal/dal"
"app/internal/database"
"app/internal/models"
"app/internal/utils"
"errors"
"gorm.io/gen/field"
"gorm.io/gorm"
)
type WorkerService struct {
}
type Worker = models.Worker
func (service *WorkerService) Create(item Worker) (Worker, error) {
utils.ReplaceEmptySlicesWithNil(&item)
err := dal.Worker.Create(&item)
if err != nil {
return item, err
}
err = utils.AppendAssociations(database.GetInstance(), &item)
return item, err
}
func (service *WorkerService) GetAll() ([]*Worker, error) {
var workers []*Worker
workers, err := dal.Worker.Preload(field.Associations).Find()
return workers, err
}
func (service *WorkerService) GetById(id uint) (*Worker, error) {
item, err := dal.Worker.Preload(field.Associations).Where(dal.Worker.Id.Eq(id)).First()
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
} else {
return nil, err
}
}
return item, nil
}
func (service *WorkerService) Update(item Worker) (Worker, error) {
utils.ReplaceEmptySlicesWithNil(&item)
_, err := dal.Worker.Updates(&item)
if err != nil {
return item, err
}
err = utils.UpdateAssociations(database.GetInstance(), &item)
if err != nil {
return item, err
}
return item, err
}
func (service *WorkerService) Delete(id uint) error {
_, err := dal.Worker.Unscoped().Where(dal.Worker.Id.Eq(id)).Delete()
return err
}
func (service *WorkerService) Count() (int64, error) {
amount, err := dal.Worker.Count()
return amount, err
}
func (service *WorkerService) SortedByOrder(fieldsSortingOrder []utils.SortField) ([]*Worker, error) {
return utils.SortByOrder(fieldsSortingOrder, Worker{})
}
func (service *WorkerService) SearchByAllTextFields(phrase string) ([]*Worker, error) {
return utils.FindPhraseByStringFields[Worker](phrase, Worker{})
}

69
internal/services/workshop.go
View File

@@ -1,69 +0,0 @@
package services
import (
"app/internal/dal"
"app/internal/database"
"app/internal/models"
"app/internal/utils"
"errors"
"gorm.io/gen/field"
"gorm.io/gorm"
)
type WorkshopService struct {
}
type Workshop = models.Workshop
func (service *WorkshopService) Create(item Workshop) (Workshop, error) {
utils.ReplaceEmptySlicesWithNil(&item)
err := dal.Workshop.Create(&item)
if err != nil {
return item, err
}
err = utils.AppendAssociations(database.GetInstance(), &item)
return item, err
}
func (service *WorkshopService) GetAll() ([]*Workshop, error) {
var workshops []*Workshop
workshops, err := dal.Workshop.Preload(field.Associations).Find()
return workshops, err
}
func (service *WorkshopService) GetById(id uint) (*Workshop, error) {
item, err := dal.Workshop.Preload(field.Associations).Where(dal.Workshop.Id.Eq(id)).First()
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
} else {
return nil, err
}
}
return item, nil
}
func (service *WorkshopService) Update(item Workshop) (Workshop, error) {
utils.ReplaceEmptySlicesWithNil(&item)
_, err := dal.Workshop.Updates(&item)
if err != nil {
return item, err
}
err = utils.UpdateAssociations(database.GetInstance(), &item)
if err != nil {
return item, err
}
return item, err
}
func (service *WorkshopService) Delete(id uint) error {
_, err := dal.Workshop.Unscoped().Where(dal.Workshop.Id.Eq(id)).Delete()
return err
}
func (service *WorkshopService) Count() (int64, error) {
amount, err := dal.Workshop.Count()
return amount, err
}
func (service *WorkshopService) SortedByOrder(fieldsSortingOrder []utils.SortField) ([]*Workshop, error) {
return utils.SortByOrder(fieldsSortingOrder, Workshop{})
}
func (service *WorkshopService) SearchByAllTextFields(phrase string) ([]*Workshop, error) {
return utils.FindPhraseByStringFields[Workshop](phrase, Workshop{})
}