micro-core-cli/servicetmpl.go at master · Jarnpher553/micro-core-cli · GitHub

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
package main

const serviceTmpl = `
package services

import (
	"{{name}}/model"
	"{{name}}/middlewares"

	"github.com/Jarnpher553/micro-core/copier"
	"github.com/Jarnpher553/micro-core/erro"
	"github.com/Jarnpher553/micro-core/model/dto"
	"github.com/Jarnpher553/micro-core/repo"
	"github.com/Jarnpher553/micro-core/service"
)

type {{title .Name}} struct {
	*service.BaseService
}

func (s *{{title .Name}}) Use(handler *service.Handler) {
	handler.UseMiddleware(service.AuthMiddleware(), middlewares.Permission("{{name}}.{{trimSuffix .Name "Service"}}"))
}

func (s *{{title .Name}}) Post(handler *service.Handler) service.HandlerFunc {
	return func(ctx *service.Ctx) {
		var in model.{{title .Dto.Request.Name}}

		if err := ctx.ShouldBind(&in); err != nil {
			ctx.Failure(erro.ErrReqContent, err)
			return
		}

		var entity model.{{title .Orm.Name}}
		_ = copier.Copy(&in, &entity)

		if err := s.Repo().Insert(&entity); err != nil {
			ctx.Failure(erro.ErrDbInsert, err)
			return
		}

		ctx.Success(nil)
	}
}

func (s *{{title .Name}}) Put(handler *service.Handler) service.HandlerFunc {
	return func(ctx *service.Ctx) {
		id := ctx.Param("id")

		var in model.{{title .Dto.Request.Name}}
		if err := ctx.ShouldBind(&in); err != nil {
			ctx.Failure(erro.ErrReqContent, err)
			return
		}

		if err := s.Repo().ModifyFunc(&model.{{title .Orm.Name}}{}, func(entity interface{}) {
			instant := entity.(*model.{{title .Orm.Name}})
			_ = copier.Copy(&in, instant)
		}, "id = ?", id); err != nil {
			ctx.Failure(erro.ErrDbModify, err)
			return
		}

		ctx.Success(nil)
	}
}

func (s *{{title .Name}}) Delete(handler *service.Handler) service.HandlerFunc {
	return func(ctx *service.Ctx) {
		id := ctx.Param("id")

		if err := s.Repo().Remove(&model.{{title .Orm.Name}}{}, "id = ?", id); err != nil {
			ctx.Failure(erro.ErrDbRemove, err)
			return
		}

		ctx.Success(nil)
	}
}

func (s *{{title .Name}}) GetList(handler *service.Handler) service.HandlerFunc {
	return func(ctx *service.Ctx) {
		var in dto.PagedIn
		if err := ctx.ShouldBind(&in); err != nil {
			ctx.Failure(erro.ErrReqContent, err)
			return
		}

		var entity []model.{{title .Dto.Response.Name}}
		var count int
		var err error
		if count, err = s.Repo().Query(&entity,
			repo.Model(&model.{{title .Orm.Name}}{}),
			repo.Page(in.PageNum, in.PerCount),
			repo.Order("created_time"),
		); err != nil {
			ctx.Failure(erro.ErrDbRead, err)
			return
		}

		ctx.Success(dto.PagedOut{
			TotalCount: count,
			PerCount:   in.PerCount,
			PageNum:    in.PageNum,
			QueryCount: len(entity),
			Rows:       entity,
		})
	}
}

func (s *{{title .Name}}) Get(handler *service.Handler) service.HandlerFunc {
	return func(ctx *service.Ctx) {
		id := ctx.Param("id")

		var out model.{{title .Dto.Response.Name}}
		if _, err := s.Repo().Query(&out, repo.Model(&model.{{title .Orm.Name}}{}), repo.Where("id = ?", id)); err != nil {
			ctx.Failure(erro.ErrDbRead, err)
			return
		}

		ctx.Success(&out)
	}
}
`