auto commit

Makefile

@@ -20,4 +20,8 @@ gen:
 	#protoc -I ./third_party -I ./proto --ts_out=./api --go_out=./api --go-grpc_out=./api --kit_out=./api --gin-kit_out=./api --validate_out="lang=go:./api" ./proto/*.proto
 	protoc -I ./third_party -I ./proto --ts_out=prefix=/api/v1/sendmail:./api --go_out=./api --go-grpc_out=./api --kit_out=./api --validate_out="lang=go:./api" ./proto/*.proto
 auth:
-	protoc --go_out=. ./third_party/auth/auth.proto
+	protoc --go_out=. ./third_party/auth/auth.proto
+gitpush:
+	git add .
+	git commit -m "auto commit"
+	git push

api/user_http.pb.go

@@ -2,8 +2,8 @@ package user
 
 import (
 	"context"
-	"git.diulo.com/mogfee/kit/transport/http"
 	"git.diulo.com/mogfee/kit/middleware/jwt"
+	"git.diulo.com/mogfee/kit/transport/http"
 )
 
 type UserHTTPServer interface {

middleware/jwt/default.go

@@ -50,7 +50,8 @@ func (j *JwtDefault) Validate(ctx context.Context, permission string, permission
 	for _, v := range allowPers {
 		allowMap[v] = true
 	}
-	fmt.Printf("permissions:%+v\n", allowMap)
+	fmt.Printf("permissions:%+v\n", permissions)
+	fmt.Printf("allowMap:%+v\n", allowMap)
 	for _, v := range permissions {
 		if allowMap[v] {
 			return nil

model/accountmodel.go

@@ -0,0 +1,18 @@
+package model
+
+import "gorm.io/gorm"
+
+type (
+	AccountModel interface {
+		accountModel
+	}
+	customAccountModel struct {
+		*defaultAccountModel
+	}
+)
+
+func NewAccountModel(db *gorm.DB) AccountModel {
+	return &customAccountModel{
+		defaultAccountModel: newAccountDAO(db),
+	}
+}

model/accountmodel_gen.go

@@ -0,0 +1,133 @@
+package model
+
+import (
+	"context"
+	"gorm.io/gorm"
+)
+
+type (
+	accountModel interface {
+		Insert(ctx context.Context, data *Account) error
+		Update(ctx context.Context, id int64, updates map[string]any) error
+		Delete(ctx context.Context, id int64) error
+		FindOne(ctx context.Context, id int64) (*Account, error)
+		FindUserId(ctx context.Context, userId int32, userType int32) (*Account, error)
+	}
+	Account struct {
+		updates        map[string]any
+		Ac             string `gorm:"column:ac"`
+		Id             int64  `gorm:"column:id"`
+		UserId         int32  `gorm:"column:user_id"`
+		UserType       int32  `gorm:"column:user_type"` //1 user 2 employer
+		Name           string `gorm:"column:name"`
+		Email          string `gorm:"column:email"`
+		Password       string `gorm:"column:password"`
+		Phone          string `gorm:"column:phone"` //+80-18010489927
+		WechatUniqueId string `gorm:"column:wechat_unique_id"`
+	}
+	defaultAccountModel struct {
+		db *gorm.DB
+	}
+)
+
+func (s *Account) TableName() string {
+	return "account"
+}
+
+func NewAccount() *Account {
+	return &Account{
+		updates: make(map[string]any),
+	}
+}
+
+func (s *Account) SetAc(ac string) *Account {
+	s.Ac = ac
+	s.set("ac", ac)
+	return s
+}
+
+func (s *Account) SetId(id int64) *Account {
+	s.Id = id
+	s.set("id", id)
+	return s
+}
+
+func (s *Account) SetUserId(userId int32) *Account {
+	s.UserId = userId
+	s.set("user_id", userId)
+	return s
+}
+
+func (s *Account) SetUserType(userType int32) *Account {
+	s.UserType = userType
+	s.set("user_type", userType)
+	return s
+}
+
+func (s *Account) SetName(name string) *Account {
+	s.Name = name
+	s.set("name", name)
+	return s
+}
+
+func (s *Account) SetEmail(email string) *Account {
+	s.Email = email
+	s.set("email", email)
+	return s
+}
+
+func (s *Account) SetPassword(password string) *Account {
+	s.Password = password
+	s.set("password", password)
+	return s
+}
+
+func (s *Account) SetPhone(phone string) *Account {
+	s.Phone = phone
+	s.set("phone", phone)
+	return s
+}
+
+func (s *Account) SetWechatUniqueId(wechatUniqueId string) *Account {
+	s.WechatUniqueId = wechatUniqueId
+	s.set("wechat_unique_id", wechatUniqueId)
+	return s
+}
+
+func (s *Account) set(key string, val any) {
+	s.updates[key] = val
+}
+
+func (s *Account) UpdateColumn() map[string]any {
+	return s.updates
+}
+
+func newAccountDAO(db *gorm.DB) *defaultAccountModel {
+	return &defaultAccountModel{
+		db: db,
+	}
+}
+
+func (s *defaultAccountModel) Insert(ctx context.Context, data *Account) error {
+	return s.db.Create(data).Error
+}
+
+func (s *defaultAccountModel) Update(ctx context.Context, id int64, updates map[string]any) error {
+	return s.db.Model(Account{}).Where("id=?", id).Updates(updates).Error
+}
+
+func (s *defaultAccountModel) Delete(ctx context.Context, id int64) error {
+	return s.db.Where("id=?", id).Delete(&Account{}).Error
+}
+
+func (s *defaultAccountModel) FindOne(ctx context.Context, id int64) (*Account, error) {
+	row := Account{}
+	err := s.db.Where("id=?", id).Find(&row).Error
+	return findResultWithError(&row, err)
+}
+
+func (s *defaultAccountModel) FindUserId(ctx context.Context, userId int32, userType int32) (*Account, error) {
+	row := Account{}
+	err := s.db.Where("user_id=? and user_type=?", userId, userType).Find(&row).Error
+	return findResultWithError(&row, err)
+}

model/joblist1model.go

@@ -0,0 +1,18 @@
+package model
+
+import "gorm.io/gorm"
+
+type (
+	JobList1Model interface {
+		jobList1Model
+	}
+	customJobList1Model struct {
+		*defaultJobList1Model
+	}
+)
+
+func NewJobList1Model(db *gorm.DB) JobList1Model {
+	return &customJobList1Model{
+		defaultJobList1Model: newJobList1DAO(db),
+	}
+}

model/joblist1model_gen.go

@@ -0,0 +1,84 @@
+package model
+
+import (
+	"context"
+	"gorm.io/gorm"
+)
+
+type (
+	jobList1Model interface {
+		Insert(ctx context.Context, data *JobList1) error
+		Update(ctx context.Context, jobId string, updates map[string]any) error
+		Delete(ctx context.Context, jobId string) error
+		FindOne(ctx context.Context, jobId string) (*JobList1, error)
+		FindTitle(ctx context.Context, title string) (*JobList1, error)
+	}
+	JobList1 struct {
+		updates map[string]any
+		JobId   string `gorm:"column:jobId"`
+		Title   string `gorm:"column:title"`
+	}
+	defaultJobList1Model struct {
+		db *gorm.DB
+	}
+)
+
+func (s *JobList1) TableName() string {
+	return "job_list1"
+}
+
+func NewJobList1() *JobList1 {
+	return &JobList1{
+		updates: make(map[string]any),
+	}
+}
+
+func (s *JobList1) SetJobId(jobId string) *JobList1 {
+	s.JobId = jobId
+	s.set("jobId", jobId)
+	return s
+}
+
+func (s *JobList1) SetTitle(title string) *JobList1 {
+	s.Title = title
+	s.set("title", title)
+	return s
+}
+
+func (s *JobList1) set(key string, val any) {
+	s.updates[key] = val
+}
+
+func (s *JobList1) UpdateColumn() map[string]any {
+	return s.updates
+}
+
+func newJobList1DAO(db *gorm.DB) *defaultJobList1Model {
+	return &defaultJobList1Model{
+		db: db,
+	}
+}
+
+func (s *defaultJobList1Model) Insert(ctx context.Context, data *JobList1) error {
+	return s.db.Create(data).Error
+}
+
+func (s *defaultJobList1Model) Update(ctx context.Context, jobId string, updates map[string]any) error {
+	return s.db.Model(JobList1{}).Where("jobId=?", jobId).Updates(updates).Error
+}
+
+func (s *defaultJobList1Model) Delete(ctx context.Context, jobId string) error {
+	return s.db.Where("jobId=?", jobId).Delete(&JobList1{}).Error
+}
+
+func (s *defaultJobList1Model) FindOne(ctx context.Context, jobId string) (*JobList1, error) {
+	row := JobList1{}
+	err := s.db.Where("jobId=?", jobId).Find(&row).Error
+	return findResultWithError(&row, err)
+}
+
+func (s *defaultJobList1Model) FindTitle(ctx context.Context, title string) (*JobList1, error) {
+	row := JobList1{}
+	err := s.db.Where("title=?", title).Find(&row).Error
+	return findResultWithError(&row, err)
+}

model/joblist2model.go

@@ -0,0 +1,18 @@
+package model
+
+import "gorm.io/gorm"
+
+type (
+	JobList2Model interface {
+		jobList2Model
+	}
+	customJobList2Model struct {
+		*defaultJobList2Model
+	}
+)
+
+func NewJobList2Model(db *gorm.DB) JobList2Model {
+	return &customJobList2Model{
+		defaultJobList2Model: newJobList2DAO(db),
+	}
+}

model/joblist2model_gen.go

@@ -0,0 +1,84 @@
+package model
+
+import (
+	"context"
+	"gorm.io/gorm"
+)
+
+type (
+	jobList2Model interface {
+		Insert(ctx context.Context, data *JobList2) error
+		Update(ctx context.Context, jobId string, updates map[string]any) error
+		Delete(ctx context.Context, jobId string) error
+		FindOne(ctx context.Context, jobId string) (*JobList2, error)
+		FindTitle(ctx context.Context, title string) (*JobList2, error)
+	}
+	JobList2 struct {
+		updates map[string]any
+		JobId   string `gorm:"column:job_id"`
+		Title   string `gorm:"column:title"`
+	}
+	defaultJobList2Model struct {
+		db *gorm.DB
+	}
+)
+
+func (s *JobList2) TableName() string {
+	return "job_list2"
+}
+
+func NewJobList2() *JobList2 {
+	return &JobList2{
+		updates: make(map[string]any),
+	}
+}
+
+func (s *JobList2) SetJobId(jobId string) *JobList2 {
+	s.JobId = jobId
+	s.set("job_id", jobId)
+	return s
+}
+
+func (s *JobList2) SetTitle(title string) *JobList2 {
+	s.Title = title
+	s.set("title", title)
+	return s
+}
+
+func (s *JobList2) set(key string, val any) {
+	s.updates[key] = val
+}
+
+func (s *JobList2) UpdateColumn() map[string]any {
+	return s.updates
+}
+
+func newJobList2DAO(db *gorm.DB) *defaultJobList2Model {
+	return &defaultJobList2Model{
+		db: db,
+	}
+}
+
+func (s *defaultJobList2Model) Insert(ctx context.Context, data *JobList2) error {
+	return s.db.Create(data).Error
+}
+
+func (s *defaultJobList2Model) Update(ctx context.Context, jobId string, updates map[string]any) error {
+	return s.db.Model(JobList2{}).Where("job_id=?", jobId).Updates(updates).Error
+}
+
+func (s *defaultJobList2Model) Delete(ctx context.Context, jobId string) error {
+	return s.db.Where("job_id=?", jobId).Delete(&JobList2{}).Error
+}
+
+func (s *defaultJobList2Model) FindOne(ctx context.Context, jobId string) (*JobList2, error) {
+	row := JobList2{}
+	err := s.db.Where("job_id=?", jobId).Find(&row).Error
+	return findResultWithError(&row, err)
+}
+
+func (s *defaultJobList2Model) FindTitle(ctx context.Context, title string) (*JobList2, error) {
+	row := JobList2{}
+	err := s.db.Where("title=?", title).Find(&row).Error
+	return findResultWithError(&row, err)
+}

model/joblistmodel.go

@@ -0,0 +1,18 @@
+package model
+
+import "gorm.io/gorm"
+
+type (
+	JobListModel interface {
+		jobListModel
+	}
+	customJobListModel struct {
+		*defaultJobListModel
+	}
+)
+
+func NewJobListModel(db *gorm.DB) JobListModel {
+	return &customJobListModel{
+		defaultJobListModel: newJobListDAO(db),
+	}
+}

model/joblistmodel_gen.go

@@ -0,0 +1,84 @@
+package model
+
+import (
+	"context"
+	"gorm.io/gorm"
+)
+
+type (
+	jobListModel interface {
+		Insert(ctx context.Context, data *JobList) error
+		Update(ctx context.Context, jobId int32, updates map[string]any) error
+		Delete(ctx context.Context, jobId int32) error
+		FindOne(ctx context.Context, jobId int32) (*JobList, error)
+		FindTitle(ctx context.Context, title string) (*JobList, error)
+	}
+	JobList struct {
+		updates map[string]any
+		JobId   int32  `gorm:"column:jobId"`
+		Title   string `gorm:"column:title"`
+	}
+	defaultJobListModel struct {
+		db *gorm.DB
+	}
+)
+
+func (s *JobList) TableName() string {
+	return "job_list"
+}
+
+func NewJobList() *JobList {
+	return &JobList{
+		updates: make(map[string]any),
+	}
+}
+
+func (s *JobList) SetJobId(jobId int32) *JobList {
+	s.JobId = jobId
+	s.set("jobId", jobId)
+	return s
+}
+
+func (s *JobList) SetTitle(title string) *JobList {
+	s.Title = title
+	s.set("title", title)
+	return s
+}
+
+func (s *JobList) set(key string, val any) {
+	s.updates[key] = val
+}
+
+func (s *JobList) UpdateColumn() map[string]any {
+	return s.updates
+}
+
+func newJobListDAO(db *gorm.DB) *defaultJobListModel {
+	return &defaultJobListModel{
+		db: db,
+	}
+}
+
+func (s *defaultJobListModel) Insert(ctx context.Context, data *JobList) error {
+	return s.db.Create(data).Error
+}
+
+func (s *defaultJobListModel) Update(ctx context.Context, jobId int32, updates map[string]any) error {
+	return s.db.Model(JobList{}).Where("jobId=?", jobId).Updates(updates).Error
+}
+
+func (s *defaultJobListModel) Delete(ctx context.Context, jobId int32) error {
+	return s.db.Where("jobId=?", jobId).Delete(&JobList{}).Error
+}
+
+func (s *defaultJobListModel) FindOne(ctx context.Context, jobId int32) (*JobList, error) {
+	row := JobList{}
+	err := s.db.Where("jobId=?", jobId).Find(&row).Error
+	return findResultWithError(&row, err)
+}
+
+func (s *defaultJobListModel) FindTitle(ctx context.Context, title string) (*JobList, error) {
+	row := JobList{}
+	err := s.db.Where("title=?", title).Find(&row).Error
+	return findResultWithError(&row, err)
+}

model/usermodel.go

@@ -0,0 +1,18 @@
+package model
+
+import "gorm.io/gorm"
+
+type (
+	UserModel interface {
+		userModel
+	}
+	customUserModel struct {
+		*defaultUserModel
+	}
+)
+
+func NewUserModel(db *gorm.DB) UserModel {
+	return &customUserModel{
+		defaultUserModel: newUserDAO(db),
+	}
+}

model/usermodel_gen.go

@@ -0,0 +1,182 @@
+package model
+
+import (
+	"context"
+	"gorm.io/gorm"
+)
+
+type (
+	userModel interface {
+		Insert(ctx context.Context, data *User) error
+		Update(ctx context.Context, id int64, updates map[string]any) error
+		Delete(ctx context.Context, id int64) error
+		FindOne(ctx context.Context, id int64) (*User, error)
+	}
+	User struct {
+		updates              map[string]any
+		Id                   int64  `gorm:"column:id"`
+		Name                 string `gorm:"column:name"`
+		Email                string `gorm:"column:email"`
+		Password             string `gorm:"column:password"`
+		Phone                string `gorm:"column:phone"` //+80-18010489927
+		Wechat               string `gorm:"column:wechat"`
+		FirstName            string `gorm:"column:first_name"`
+		LastName             string `gorm:"column:last_name"`
+		Gender               int32  `gorm:"column:gender"`
+		Skype                string `gorm:"column:skype"`
+		Birthday             int32  `gorm:"column:birthday"`
+		CurrentLocation      int32  `gorm:"column:current_location"`
+		CurrentLocationOther string `gorm:"column:current_location_other"`
+		WorkExperience       int32  `gorm:"column:work_experience"`
+		Country              int32  `gorm:"column:country"`
+		CountryOther         string `gorm:"column:country_other"`
+		AboutMe              string `gorm:"column:about_me"`
+	}
+	defaultUserModel struct {
+		db *gorm.DB
+	}
+)
+
+func (s *User) TableName() string {
+	return "user"
+}
+
+func NewUser() *User {
+	return &User{
+		updates: make(map[string]any),
+	}
+}
+
+func (s *User) SetId(id int64) *User {
+	s.Id = id
+	s.set("id", id)
+	return s
+}
+
+func (s *User) SetName(name string) *User {
+	s.Name = name
+	s.set("name", name)
+	return s
+}
+
+func (s *User) SetEmail(email string) *User {
+	s.Email = email
+	s.set("email", email)
+	return s
+}
+
+func (s *User) SetPassword(password string) *User {
+	s.Password = password
+	s.set("password", password)
+	return s
+}
+
+func (s *User) SetPhone(phone string) *User {
+	s.Phone = phone
+	s.set("phone", phone)
+	return s
+}
+
+func (s *User) SetWechat(wechat string) *User {
+	s.Wechat = wechat
+	s.set("wechat", wechat)
+	return s
+}
+
+func (s *User) SetFirstName(firstName string) *User {
+	s.FirstName = firstName
+	s.set("first_name", firstName)
+	return s
+}
+
+func (s *User) SetLastName(lastName string) *User {
+	s.LastName = lastName
+	s.set("last_name", lastName)
+	return s
+}
+
+func (s *User) SetGender(gender int32) *User {
+	s.Gender = gender
+	s.set("gender", gender)
+	return s
+}
+
+func (s *User) SetSkype(skype string) *User {
+	s.Skype = skype
+	s.set("skype", skype)
+	return s
+}
+
+func (s *User) SetBirthday(birthday int32) *User {
+	s.Birthday = birthday
+	s.set("birthday", birthday)
+	return s
+}
+
+func (s *User) SetCurrentLocation(currentLocation int32) *User {
+	s.CurrentLocation = currentLocation
+	s.set("current_location", currentLocation)
+	return s
+}
+
+func (s *User) SetCurrentLocationOther(currentLocationOther string) *User {
+	s.CurrentLocationOther = currentLocationOther
+	s.set("current_location_other", currentLocationOther)
+	return s
+}
+
+func (s *User) SetWorkExperience(workExperience int32) *User {
+	s.WorkExperience = workExperience
+	s.set("work_experience", workExperience)
+	return s
+}
+
+func (s *User) SetCountry(country int32) *User {
+	s.Country = country
+	s.set("country", country)
+	return s
+}
+
+func (s *User) SetCountryOther(countryOther string) *User {
+	s.CountryOther = countryOther
+	s.set("country_other", countryOther)
+	return s
+}
+
+func (s *User) SetAboutMe(aboutMe string) *User {
+	s.AboutMe = aboutMe
+	s.set("about_me", aboutMe)
+	return s
+}
+
+func (s *User) set(key string, val any) {
+	s.updates[key] = val
+}
+
+func (s *User) UpdateColumn() map[string]any {
+	return s.updates
+}
+
+func newUserDAO(db *gorm.DB) *defaultUserModel {
+	return &defaultUserModel{
+		db: db,
+	}
+}
+
+func (s *defaultUserModel) Insert(ctx context.Context, data *User) error {
+	return s.db.Create(data).Error
+}
+
+func (s *defaultUserModel) Update(ctx context.Context, id int64, updates map[string]any) error {
+	return s.db.Model(User{}).Where("id=?", id).Updates(updates).Error
+}
+
+func (s *defaultUserModel) Delete(ctx context.Context, id int64) error {
+	return s.db.Where("id=?", id).Delete(&User{}).Error
+}
+
+func (s *defaultUserModel) FindOne(ctx context.Context, id int64) (*User, error) {
+	row := User{}
+	err := s.db.Where("id=?", id).Find(&row).Error
+	return findResultWithError(&row, err)
+}

model/vars.go

@@ -0,0 +1,34 @@
+package model
+
+import (
+	"git.diulo.com/mogfee/kit/errors"
+	"gorm.io/gorm"
+)
+
+var ErrNotFound = errors.BadRequest("DB_NOT_FOUND", "数据不存在")
+var ErrIdRequest = errors.BadRequest("DB_ID_REQUIRED", "id不能为空")
+
+func IsErrNotFound(err error) bool {
+	return errors.Reason(err) == "DB_NOT_FOUND"
+}
+
+func IsErrIdRequest(err error) bool {
+	return errors.Reason(err) == "DB_ID_REQUIRED"
+}
+func findResultWithError[T any](data T, err error) (T, error) {
+	switch err {
+	case nil:
+		return data, nil
+	case gorm.ErrRecordNotFound:
+		return data, ErrNotFound
+	default:
+		return data, err
+	}
+}
+func GetPage(page int32, size int32) (offset int, pageSize int) {
+	if page <= 1 {
+		page = 1
+	}
+	offset = int((page - 1) * size)
+	return offset, int(size)
+}