新增注册登录接口

config/init.go

@@ -34,6 +34,7 @@ func loadExternelConfig(config *system_model.Config) {
 	db.Init(config.Mysql)
 	redis.Init(config.Redis)
 	service.LoginAuthInit(config.Server.Session)
+	service.SendCodeInit(config.Server.Session)
 }
 
 func getEnv() string {

db/enterprise.go

@@ -2,28 +2,14 @@ package db
 
 import (
 	"context"
-	"time"
 	"youngee_b_api/model/gorm_model"
-	"youngee_b_api/model/http_model"
 )
 
-func CreateEnterprise(ctx context.Context, newEnterprise http_model.CreateEnterpriseRequest) (*http_model.CreateEnterpriseData, error) {
+func CreateEnterprise(ctx context.Context, newEnterprise gorm_model.Enterprise) (*int, error) {
 	db := GetReadDB(ctx)
-	enterprise := &gorm_model.Enterprise{
-		Industry:         newEnterprise.Industry,
-		BusinessName:     newEnterprise.BusinessName,
-		UserId:           newEnterprise.UserId,
-		Balance:          0,
-		FrozenBalance:    0,
-		AvailableBalance: 0,
-		LastLoginTime:    time.Now().UTC().Local(),
-	}
-	err := db.Create(&enterprise).Error
+	err := db.Create(&newEnterprise).Error
 	if err != nil {
 		return nil, err
 	}
-	data := &http_model.CreateEnterpriseData{
-		EnterpriseId: enterprise.EnterpriseId,
-	}
-	return data, nil
+	return &newEnterprise.EnterpriseID, nil
 }

db/product.go

@@ -3,26 +3,13 @@ package db
 import (
 	"context"
 	"youngee_b_api/model/gorm_model"
-	"youngee_b_api/model/http_model"
 )
 
-func CreateProduct(ctx context.Context, newProduct http_model.CreateProductRequest) (*http_model.CreateProductData, error) {
+func CreateProduct(ctx context.Context, product gorm_model.YounggeeProduct) (*int, error) {
 	db := GetReadDB(ctx)
-	Product := gorm_model.YounggeeProduct{
-		ProductName:  newProduct.ProductName,
-		ProductType:  newProduct.ProductType,
-		ShopAddress:  newProduct.ShopAddress,
-		ProductPrice: newProduct.ProductPrice,
-		ProductUrl:   newProduct.ProductUrl,
-		EnterpriseID: newProduct.EnterpriseID,
-		BrandName:    newProduct.BrandName,
-	}
-	err := db.Create(&Product).Error
+	err := db.Create(&product).Error
 	if err != nil {
 		return nil, err
 	}
-	data := &http_model.CreateProductData{
-		ProductID: Product.ProductID,
-	}
-	return data, nil
+	return &product.ProductID, nil
 }

db/product_photo.go

@@ -3,20 +3,10 @@ package db
 import (
 	"context"
 	"youngee_b_api/model/gorm_model"
-	"youngee_b_api/model/http_model"
 )
 
-func CreateProductPhoto(ctx context.Context, productID int, newProductPhotos []http_model.CreateProductPhoto) error {
+func CreateProductPhoto(ctx context.Context, productPhotos []gorm_model.YounggeeProductPhoto) error {
 	db := GetReadDB(ctx)
-	productPhotos := []gorm_model.YounggeeProductPhoto{}
-	for _, newPhoto := range newProductPhotos {
-		productPhoto := gorm_model.YounggeeProductPhoto{
-			PhotoUrl:  newPhoto.PhotoUrl,
-			Symbol:    newPhoto.Symbol,
-			ProductID: productID,
-		}
-		productPhotos = append(productPhotos, productPhoto)
-	}
 	err := db.Create(&productPhotos).Error
 	if err != nil {
 		return err

db/project.go

@@ -2,33 +2,14 @@ package db
 
 import (
 	"context"
-	"time"
 	"youngee_b_api/model/gorm_model"
-	"youngee_b_api/model/http_model"
 )
 
-func CreateProject(ctx context.Context, newProject http_model.CreateProjectRequest) (*http_model.CreateProjectData, error) {
+func CreateProject(ctx context.Context, projectInfo gorm_model.ProjectInfo) (*int, error) {
 	db := GetReadDB(ctx)
-	Project := gorm_model.ProjectInfo{
-		ProjectName:     newProject.ProjectName,
-		ProjectStatus:   1,
-		ProjectType:     newProject.ProjectType,
-		TalentType:      newProject.TalentType,
-		ProjectPlatform: newProject.ProjectPlatform,
-		ProjectForm:     newProject.ProjectForm,
-		// RecruitDdl:      newProject.RecruitDdl,
-		RecruitDdl:    time.Now().UTC().Local(),
-		ProjectDetail: newProject.ProjectDetail,
-		ContentType:   newProject.ContentType,
-		EnterpriseID:  newProject.EnterpriseID,
-		ProductID:     newProject.ProductID,
-	}
-	err := db.Create(&Project).Error
+	err := db.Create(&projectInfo).Error
 	if err != nil {
 		return nil, err
 	}
-	data := &http_model.CreateProjectData{
-		ProjectID: Project.ProjectID,
-	}
-	return data, nil
+	return &projectInfo.ProjectID, nil
 }

db/project_photo.go

@@ -3,19 +3,10 @@ package db
 import (
 	"context"
 	"youngee_b_api/model/gorm_model"
-	"youngee_b_api/model/http_model"
 )
 
-func CreateProjectPhoto(ctx context.Context, projectID int, newProjectPhotos []http_model.CreateProjectPhoto) error {
+func CreateProjectPhoto(ctx context.Context, projectPhotos []gorm_model.ProjectPhoto) error {
 	db := GetReadDB(ctx)
-	projectPhotos := []gorm_model.ProjectPhoto{}
-	for _, newPhoto := range newProjectPhotos {
-		projectPhoto := gorm_model.ProjectPhoto{
-			PhotoUrl:  newPhoto.PhotoUrl,
-			ProjectID: projectID,
-		}
-		projectPhotos = append(projectPhotos, projectPhoto)
-	}
 	err := db.Create(&projectPhotos).Error
 	if err != nil {
 		return err

db/recruit_strategy.go

@@ -3,24 +3,10 @@ package db
 import (
 	"context"
 	"youngee_b_api/model/gorm_model"
-	"youngee_b_api/model/http_model"
 )
 
-func CreateRecruitStrategy(ctx context.Context, projectID int, newRecruitStrategy []http_model.CreateRecruitStrategy) error {
+func CreateRecruitStrategy(ctx context.Context, recruitStrategys []gorm_model.RecruitStrategy) error {
 	db := GetReadDB(ctx)
-	recruitStrategys := []gorm_model.RecruitStrategy{}
-	for _, newStrategy := range newRecruitStrategy {
-		recruitStrategy := gorm_model.RecruitStrategy{
-			FeeForm:       newStrategy.FeeForm,
-			StrategyID:    newStrategy.StrategyID,
-			FollowersLow:  newStrategy.FollowersLow,
-			FollowersUp:   newStrategy.FollowersUp,
-			RecruitNumber: newStrategy.RecruitNumber,
-			Offer:         newStrategy.Offer,
-			ProjectID:     projectID,
-		}
-		recruitStrategys = append(recruitStrategys, recruitStrategy)
-	}
 	err := db.Create(&recruitStrategys).Error
 	if err != nil {
 		return err

db/user.go

@@ -2,33 +2,18 @@ package db
 
 import (
 	"context"
-	"time"
 	"youngee_b_api/model/gorm_model"
-	"youngee_b_api/model/http_model"
 
 	"gorm.io/gorm"
 )
 
-func CreateEnterpriseUser(ctx context.Context, newUser http_model.CreateEnterpriseRequest) (*http_model.CreateUserData, error) {
+func CreateUser(ctx context.Context, user gorm_model.User) (*int, error) {
 	db := GetReadDB(ctx)
-	user := &gorm_model.User{
-		Phone:         newUser.Phone,
-		User:          "1001",
-		Username:      newUser.BusinessName,
-		Password:      "1001",
-		RealName:      newUser.RealName,
-		Role:          "3",
-		Email:         newUser.Email,
-		LastLoginTime: time.Now().UTC().Local(),
-	}
 	err := db.Create(&user).Error
 	if err != nil {
 		return nil, err
 	}
-	data := &http_model.CreateUserData{
-		UserID: user.ID,
-	}
-	return data, nil
+	return &user.ID, nil
 }
 
 //GetUserByPhone 查不到返回空

go.mod

@@ -1,6 +1,6 @@
 module youngee_b_api
 
-go 1.17
+go 1.16
 
 require (
 	github.com/GUAIK-ORG/go-snowflake v0.0.0-20200116064823-220c4260e85f

handler/Register.go

@@ -0,0 +1,71 @@
+package handler
+
+import (
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/gin-gonic/gin"
+)
+
+func WrapRegisterHandler(ctx *gin.Context) {
+	handler := newRegisterHandler(ctx)
+	baseRun(handler)
+}
+
+func newRegisterHandler(ctx *gin.Context) *RegisterHandler {
+	return &RegisterHandler{
+		req:  http_model.NewRegisterRequest(),
+		resp: http_model.NewRegisterResponse(),
+		ctx:  ctx,
+	}
+}
+
+type RegisterHandler struct {
+	req  *http_model.RegisterRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *RegisterHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *RegisterHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *RegisterHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *RegisterHandler) run() {
+	data := http_model.RegisterRequest{}
+	data = *h.req
+	// 注册接口处理流程
+	// 1. 在user表中查找phone，判断账号是否存在，若不存在进行下一步，否则返回error，message：账号已存在
+	// 2. 在redis中查找验证码，判断验证码是否正确，若正确进行下一步，否则返回error，message：验证码错误
+	flag, err := service.Register.Register(h.ctx, data.Phone, data.Code)
+	if err != nil {
+		logrus.Errorf("[RegisterHandler] call RegisterUser err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal)
+		return
+	} else if flag != nil {
+		// 3. 先后在user表和enterprise表中增加账号信息
+		res, err := service.Enterprise.CreateEnterpriseUser(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[RegisterHandler] call RegisterUser err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal)
+			return
+		}
+		// 4. 返回ok
+		h.resp.Data = res
+	} else {
+		h.resp.Message = "验证码错误"
+		return
+	}
+}
+
+func (h *RegisterHandler) checkParam() error {
+	return nil
+}

handler/enterprice_create.go

@@ -1,57 +0,0 @@
-package handler
-
-import (
-	"github.com/sirupsen/logrus"
-	"youngee_b_api/consts"
-	"youngee_b_api/model/http_model"
-	"youngee_b_api/service"
-	"youngee_b_api/util"
-
-	"github.com/gin-gonic/gin"
-)
-
-func WrapCreateEnterpriseHandler(ctx *gin.Context) {
-	handler := newCreateEnterpriseHandler(ctx)
-	baseRun(handler)
-}
-
-func newCreateEnterpriseHandler(ctx *gin.Context) *CreateEnterpriseHandler {
-	return &CreateEnterpriseHandler{
-		req:  http_model.NewCreateEnterpriseRequest(),
-		resp: http_model.NewCreateEnterpriseResponse(),
-		ctx:  ctx,
-	}
-}
-
-type CreateEnterpriseHandler struct {
-	req  *http_model.CreateEnterpriseRequest
-	resp *http_model.CommonResponse
-	ctx  *gin.Context
-}
-
-func (h *CreateEnterpriseHandler) getRequest() interface{} {
-	return h.req
-}
-func (h *CreateEnterpriseHandler) getContext() *gin.Context {
-	return h.ctx
-}
-func (h *CreateEnterpriseHandler) getResponse() interface{} {
-	return h.resp
-}
-func (h *CreateEnterpriseHandler) run() {
-	//判断验证码是否正确
-
-	//若正确，创建企业用户
-	data := http_model.CreateEnterpriseRequest{}
-	data = *h.req
-	res, err := service.CreateEnterprise.CreateEnterpriseUser(h.ctx, data)
-	if err != nil {
-		logrus.Errorf("[CreateEnterpriseHandler] call CreateEnterpriseUser err:%+v\n", err)
-		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal)
-		return
-	}
-	h.resp.Data = res
-}
-func (h *CreateEnterpriseHandler) checkParam() error {
-	return nil
-}

handler/password_login.go

@@ -39,8 +39,16 @@ func (h *PasswordLoginHandler) getResponse() interface{} {
 	return h.resp
 }
 func (h *PasswordLoginHandler) run() {
+	// 登录接口处理流程
+	// 1. 在redis中查找验证码，判断验证码是否正确，若正确进行下一步，否则返回error
+	// 2. 在user表中查找phone，判断手机号是否存在，若存在进行下一步，否则返回error，message：账号不存在
+	// 3. 更新user表中登陆时间
+	// 4. 生成tocken
+	// 5. 将userID和tocken存到redis
+	// 6. 返回tocken
+
 	data := http_model.PasswordLoginData{}
-	token, err := service.LoginAuth.AuthPassword(h.ctx, h.req.UserPhone, h.req.UserPasswd)
+	token, err := service.LoginAuth.AuthMSG(h.ctx, h.req.UserPhone, h.req.UserPasswd)
 	if err != nil {
 		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal)
 		log.Info("login fail,req:%+v", h.req)

handler/product_create.go

@@ -1,11 +1,13 @@
 package handler
 
 import (
-	"fmt"
+	"youngee_b_api/consts"
 	"youngee_b_api/model/http_model"
 	"youngee_b_api/service"
+	"youngee_b_api/util"
 
 	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
 )
 
 func WrapCreateProductHandler(ctx *gin.Context) {
@@ -39,11 +41,11 @@ func (h *CreateProductHandler) getResponse() interface{} {
 func (h *CreateProductHandler) run() {
 	data := http_model.CreateProductRequest{}
 	data = *h.req
-	res := service.CreateProduct.CreateProduct(h.ctx, data)
-	if res != nil {
-		fmt.Printf("%+v\n", res)
-	} else {
-		fmt.Printf("error\n")
+	res, err := service.Product.CreateProduct(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[CreateProductHandler] call CreateProduct err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal)
+		return
 	}
 	h.resp.Data = res
 }

handler/project_create.go

@@ -1,11 +1,13 @@
 package handler
 
 import (
-	"fmt"
+	"youngee_b_api/consts"
 	"youngee_b_api/model/http_model"
 	"youngee_b_api/service"
+	"youngee_b_api/util"
 
 	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
 )
 
 func WrapCreateProjectHandler(ctx *gin.Context) {
@@ -39,11 +41,11 @@ func (h *CreateProjectHandler) getResponse() interface{} {
 func (h *CreateProjectHandler) run() {
 	data := http_model.CreateProjectRequest{}
 	data = *h.req
-	res := service.CreateProject.CreateProject(h.ctx, data)
+	res, err := service.Project.CreateProject(h.ctx, data)
 	if res != nil {
-		fmt.Printf("%+v\n", res)
-	} else {
-		fmt.Printf("error\n")
+		logrus.Errorf("[CreateProjectHandler] call CreateProject err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal)
+		return
 	}
 	h.resp.Data = res
 }

handler/send_code.go

@@ -0,0 +1,64 @@
+package handler
+
+import (
+	"fmt"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+
+	"github.com/gin-gonic/gin"
+)
+
+func WrapSendCodeHandler(ctx *gin.Context) {
+	handler := newSendCodeHandler(ctx)
+	baseRun(handler)
+}
+
+func newSendCodeHandler(ctx *gin.Context) *SendCodeHandler {
+	return &SendCodeHandler{
+		req:  http_model.NewSendCodeRequest(),
+		resp: http_model.NewSendCodeResponse(),
+		ctx:  ctx,
+	}
+}
+
+type SendCodeHandler struct {
+	req  *http_model.SendCodeRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *SendCodeHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *SendCodeHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *SendCodeHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *SendCodeHandler) run() {
+
+	data := http_model.SendCodeRequest{}
+	data = *h.req
+	fmt.Println(data.UserPhone)
+	// 1. 生成验证码
+	vcode := service.SendCode.GetCode(h.ctx)
+	// 2. 发送验证码
+	fmt.Println(vcode)
+
+	// 3. {phone:code}存到redis
+	err := service.SendCode.SetSession(h.ctx, data.UserPhone, vcode)
+	if err != nil {
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal)
+		return
+	}
+	res := http_model.SendCodeData{
+		UserPhone: data.UserPhone,
+	}
+	h.resp.Data = res
+}
+func (h *SendCodeHandler) checkParam() error {
+	return nil
+}

main_test.go

@@ -1,32 +1,27 @@
 package main
 
 import (
-	"context"
-	"fmt"
 	"testing"
-	"youngee_b_api/config"
-	"youngee_b_api/model/http_model"
-	"youngee_b_api/service"
 )
 
 func TestGormUser(t *testing.T) {
-	
-}
 
-func TestDbCreateEnterprise(t *testing.T) {
-	ctx := context.Background()
-	config.Init()
-	newEnterprise := http_model.CreateEnterpriseRequest{
-		Industry:     2,
-		BusinessName: "Test公司",
-		RealName:     "测试员",
-		Phone:        "13010101010",
-		Email:        "test@younggee.com",
-	}
-	res := service.CreateEnterprise.CreateEnterpriseUser(ctx, newEnterprise)
-	if res != nil {
-		fmt.Printf("%+v\n", res)
-	} else {
-		fmt.Printf("error\n")
-	}
 }
+
+// func TestDbCreateEnterprise(t *testing.T) {
+// 	ctx := context.Background()
+// 	config.Init()
+// 	newEnterprise := http_model.CreateEnterpriseRequest{
+// 		Industry:     2,
+// 		BusinessName: "Test公司",
+// 		RealName:     "测试员",
+// 		Phone:        "13010101010",
+// 		Email:        "test@younggee.com",
+// 	}
+// 	res := service.CreateEnterprise.CreateEnterpriseUser(ctx, newEnterprise)
+// 	if res != nil {
+// 		fmt.Printf("%+v\n", res)
+// 	} else {
+// 		fmt.Printf("error\n")
+// 	}
+// }

model/gorm_model/enterprise.go

@@ -1,3 +1,4 @@
+// Code generated by sql2gorm. DO NOT EDIT.
 package gorm_model
 
 import (
@@ -5,18 +6,18 @@ import (
 )
 
 type Enterprise struct {
-	EnterpriseId     int       `gorm:"column:enterprise_id;type:int(10) unsigned;primary_key" json:"enterprise_id"` // 企业id
-	Industry         int       `gorm:"column:industry;type:tinyint(4)" json:"industry"`                             // 行业，1-14分别代表能源、化工、材料、机械设备/军工、企业服务/造纸印刷、运输设备、旅游酒店、媒体/信息通信服务、批发/零售、消费品、卫生保健/医疗、金融、建材/建筑/房地产、公共事业
-	BusinessName     string    `gorm:"column:business_name;type:varchar(50)" json:"business_name"`                  // 公司或组织名称
-	UserId           int       `gorm:"column:user_id;type:int(11)" json:"user_id"`                                  // 对应用户id
-	Balance          int       `gorm:"column:balance;type:int(11)" json:"balance"`                                  // 账户余额
-	FrozenBalance    int       `gorm:"column:frozen_balance;type:int(11)" json:"frozen_balance"`                    // 冻结余额
-	AvailableBalance int       `gorm:"column:available_balance;type:int(11)" json:"available_balance"`              // 可用余额
-	LastLoginTime    time.Time `gorm:"column:last_login_time;type:datetime" json:"last_login_time"`                 // 最后一次登陆时间
-	CreatedAt        time.Time `gorm:"column:created_at;type:datetime;" json:"created_at"`                          // 创建时间
-	UpdatedAt        time.Time `gorm:"column:updated_at;type:datetime" json:"updated_at"`                           // 更新时间
+	EnterpriseID     int       `gorm:"column:enterprise_id"` // 企业id
+	Industry         int       `gorm:"column:industry"`                                 // 行业，1-14分别代表能源、化工、材料、机械设备/军工、企业服务/造纸印刷、运输设备、旅游酒店、媒体/信息通信服务、批发/零售、消费品、卫生保健/医疗、金融、建材/建筑/房地产、公共事业
+	BusinessName     string    `gorm:"column:business_name"`                            // 公司或组织名称
+	UserID           int       `gorm:"column:user_id"`                                  // 对应用户id
+	Balance          int       `gorm:"column:balance"`                                  // 账户余额
+	FrozenBalance    int       `gorm:"column:frozen_balance"`                           // 冻结余额
+	AvailableBalance int       `gorm:"column:available_balance"`                        // 可用余额
+	CreatedAt        time.Time `gorm:"column:created_at"`                               // 创建时间
+	UpdatedAt        time.Time `gorm:"column:updated_at"`                               // 更新时间
 }
 
 func (m *Enterprise) TableName() string {
 	return "enterprise"
 }
+

model/http_model/password_login.go

@@ -5,7 +5,6 @@ type PasswordLoginRequest struct {
 	UserPasswd string `json:"user_password"`
 }
 
-//
 type PasswordLoginData struct {
 	Token string `json:"token"`
 }

model/http_model/enterprise_create.go → model/http_model/register.go

@@ -1,6 +1,6 @@
 package http_model
 
-type CreateEnterpriseRequest struct {
+type RegisterRequest struct {
 	EnterpriseId int    `json:"enterprise_id"` // 企业id
 	UserId       int    `json:"user_id"`       // 对应用户id
 	RealName     string `json:"real_name"`     // 真实姓名
@@ -11,18 +11,16 @@ type CreateEnterpriseRequest struct {
 	Code         string `json:"code"`          //验证码
 }
 
-type CreateEnterpriseData struct {
+type RegisterData struct {
+	UserID       int `json:"user_id"`       // 用户id
 	EnterpriseId int `json:"enterprise_id"` // 企业id
 }
-type CreateUserData struct {
-	UserID int `json:"user_id"` // 用户id
-}
 
-func NewCreateEnterpriseRequest() *CreateEnterpriseRequest {
-	return new(CreateEnterpriseRequest)
+func NewRegisterRequest() *RegisterRequest {
+	return new(RegisterRequest)
 }
-func NewCreateEnterpriseResponse() *CommonResponse {
+func NewRegisterResponse() *CommonResponse {
 	resp := new(CommonResponse)
-	resp.Data = new(CreateEnterpriseData)
+	resp.Data = new(RegisterData)
 	return resp
 }

model/http_model/send_code.go

@@ -0,0 +1,18 @@
+package http_model
+
+type SendCodeRequest struct {
+	UserPhone string `json:"user_phone"`
+}
+
+type SendCodeData struct {
+	UserPhone string `json:"user_phone"`
+}
+
+func NewSendCodeRequest() *SendCodeRequest {
+	return new(SendCodeRequest)
+}
+func NewSendCodeResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(SendCodeData)
+	return resp
+}

route/init.go

@@ -1,14 +1,17 @@
 package route
 
 import (
-	"github.com/gin-gonic/gin"
-	"github.com/sirupsen/logrus"
 	"youngee_b_api/handler"
 	"youngee_b_api/middleware"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
 )
 
 func InitRoute(r *gin.Engine) {
 
+	r.POST("/register", handler.WrapRegisterHandler)
+	r.POST("/sendCode", handler.WrapSendCodeHandler)
 	r.POST("/login", handler.WrapPasswordLoginHandler)
 	//r.GET("/test/ping", func(c *gin.Context) {
 	//	resp := http_model.CommonResponse{
@@ -37,7 +40,6 @@ func InitRoute(r *gin.Engine) {
 			logrus.Infof("auth:%+v", auth)
 		})
 		m.POST("/project/create", handler.WrapCreateProjectHandler)
-		m.POST("/enterprise/create", handler.WrapCreateEnterpriseHandler)
 		m.POST("/product/create", handler.WrapCreateProductHandler)
 	}
 

service/enterprise.go

@@ -0,0 +1,53 @@
+package service
+
+import (
+	"context"
+	"time"
+	"youngee_b_api/db"
+	"youngee_b_api/model/gorm_model"
+	"youngee_b_api/model/http_model"
+
+	log "github.com/sirupsen/logrus"
+)
+
+var Enterprise *enterprise
+
+type enterprise struct {
+}
+
+func (*enterprise) CreateEnterpriseUser(ctx context.Context, newEnterprise http_model.RegisterRequest) (*http_model.RegisterData, error) {
+	user := gorm_model.User{
+		Phone:         newEnterprise.Phone,
+		User:          "1001",
+		Username:      newEnterprise.BusinessName,
+		Password:      "1001",
+		RealName:      newEnterprise.RealName,
+		Role:          "3",
+		Email:         newEnterprise.Email,
+		LastLoginTime: time.Now().UTC().Local(),
+	}
+	userId, err := db.CreateUser(ctx, user)
+	if err != nil {
+		log.Infof("[CreateEnterpriseUser] fail,err:%+v", err)
+		return nil, err
+	} else {
+		enterprise := &gorm_model.Enterprise{
+			Industry:         newEnterprise.Industry,
+			BusinessName:     newEnterprise.BusinessName,
+			UserID:           *userId,
+			Balance:          0,
+			FrozenBalance:    0,
+			AvailableBalance: 0,
+		}
+		enterpriseId, err := db.CreateEnterprise(ctx, *enterprise)
+		if err != nil {
+			log.Infof("[CreateEnterpriseUser] fail,err:%+v", err)
+			return nil, err
+		}
+		res := &http_model.RegisterData{
+			EnterpriseId: *enterpriseId,
+			UserID:       *userId,
+		}
+		return res, nil
+	}
+}

service/enterprise_create.go

@@ -1,32 +0,0 @@
-package service
-
-import (
-	"context"
-	"youngee_b_api/db"
-	"youngee_b_api/model/http_model"
-
-	log "github.com/sirupsen/logrus"
-)
-
-var CreateEnterprise *createEnterprise
-
-type createEnterprise struct {
-}
-
-func (*createEnterprise) CreateEnterpriseUser(ctx context.Context, newEnterprise http_model.CreateEnterpriseRequest) (*http_model.CreateEnterpriseData, error) {
-	userId, err := db.CreateEnterpriseUser(ctx, newEnterprise)
-	if err != nil {
-		log.Infof("[CreateEnterpriseUser] fail,err:%+v", err)
-		return nil, err
-	} else {
-		newEnterprise.UserId = int(userId.UserID)
-		res, err := db.CreateEnterprise(ctx, newEnterprise)
-		if err != nil {
-			log.Infof("[CreateEnterpriseUser] fail,err:%+v", err)
-			return nil, err
-		}
-		return res, nil
-	}
-}
-
-// build packgorm httpreqest -> gorm model

service/login_auth.go

@@ -48,9 +48,51 @@ func (l *loginAuth) AuthToken(ctx context.Context, token string) (*redis_model.A
 	return auth, nil
 
 }
-func (l *loginAuth) AuthPassword(ctx context.Context, phone, password string) (string, error) {
+
+func (l *loginAuth) AuthMSG(ctx context.Context, phone string, vcode string) (string, error) {
+	// 验证是否存在
+	user, err := db.GetUserByPhone(ctx, phone)
+	if err != nil {
+		return "", err
+	}
+	code, err := l.getSessionCode(ctx, phone)
+	if err != nil {
+		return "", err
+	}
+	if user == nil {
+		fmt.Printf("user == nil\n")
+	}
+	if string(user.Role) != consts.BRole {
+		fmt.Printf("%+v\n", string(user.Role))
+	}
+	if *code != vcode {
+		fmt.Printf("code:%+v, vcode:%+v\n", *code, vcode)
+	}
+	if user == nil || string(user.Role) != consts.BRole || *code != vcode { // 登录失败
+		logrus.Debugf("[AuthPassword] auth fail,phone:%+v", phone)
+		return "", errors.New("auth fail")
+	}
+	token := l.getToken(ctx, phone)
+	auth := &redis_model.Auth{
+		Phone:    phone,
+		ID:       user.ID,
+		User:     user.User,
+		Username: user.Username,
+		RealName: user.RealName,
+		Role:     user.Role,
+		Email:    user.Email,
+		Token:    token,
+	}
+	if err := l.setSession(ctx, phone, auth); err != nil {
+		fmt.Printf("setSession error\n")
+		return "", err
+	}
+	return token, nil
+}
+
+func (l *loginAuth) AuthPassword(ctx context.Context, phone string, password string) (string, error) {
 	// 验证是否存在
-	user, err := db.GetUserByPhone(ctx, password)
+	user, err := db.GetUserByPhone(ctx, phone)
 	if err != nil {
 		return "", err
 	}
@@ -76,6 +118,7 @@ func (l *loginAuth) AuthPassword(ctx context.Context, phone, password string) (s
 	}
 	return token, nil
 }
+
 func (l *loginAuth) setSession(ctx context.Context, phone string, auth *redis_model.Auth) error {
 	if authJson, err := json.Marshal(auth); err == nil {
 		err = redis.Set(ctx, l.getRedisKey(phone), string(authJson), l.sessionTTL)
@@ -85,6 +128,18 @@ func (l *loginAuth) setSession(ctx context.Context, phone string, auth *redis_mo
 	}
 	return nil
 }
+
+func (l *loginAuth) getSessionCode(ctx context.Context, phone string) (*string, error) {
+	value, err := redis.Get(ctx, l.getRedisKey(phone))
+	if err != nil {
+		if err == consts.RedisNil {
+			return nil, fmt.Errorf("not found in redis,phone:%+v", phone)
+		}
+		return nil, err
+	}
+	return &value, nil
+}
+
 func (l *loginAuth) getSession(ctx context.Context, phone string) (*redis_model.Auth, error) {
 	value, err := redis.Get(ctx, l.getRedisKey(phone))
 	if err != nil {

service/product.go

@@ -0,0 +1,47 @@
+package service
+
+import (
+	"context"
+	"youngee_b_api/db"
+	"youngee_b_api/model/gorm_model"
+	"youngee_b_api/model/http_model"
+)
+
+var Product *product
+
+type product struct {
+}
+
+func (*product) CreateProduct(ctx context.Context, newProduct http_model.CreateProductRequest) (*http_model.CreateProductData, error) {
+	product := gorm_model.YounggeeProduct{
+		ProductName:  newProduct.ProductName,
+		ProductType:  newProduct.ProductType,
+		ShopAddress:  newProduct.ShopAddress,
+		ProductPrice: newProduct.ProductPrice,
+		ProductUrl:   newProduct.ProductUrl,
+		EnterpriseID: newProduct.EnterpriseID,
+		BrandName:    newProduct.BrandName,
+	}
+	productID, err := db.CreateProduct(ctx, product)
+	if err != nil {
+		return nil, err
+	} else {
+		productPhotos := []gorm_model.YounggeeProductPhoto{}
+		for _, photo := range newProduct.ProductPhotos {
+			productPhoto := gorm_model.YounggeeProductPhoto{
+				PhotoUrl:  photo.PhotoUrl,
+				Symbol:    photo.Symbol,
+				ProductID: *productID,
+			}
+			productPhotos = append(productPhotos, productPhoto)
+		}
+		err := db.CreateProductPhoto(ctx, productPhotos)
+		if err != nil {
+			return nil, err
+		}
+	}
+	res := &http_model.CreateProductData{
+		ProductID: *productID,
+	}
+	return res, nil
+}

service/product_create.go

@@ -1,25 +0,0 @@
-package service
-
-import (
-	"context"
-	"youngee_b_api/db"
-	"youngee_b_api/model/http_model"
-)
-
-var CreateProduct *createProduct
-
-type createProduct struct {
-}
-
-func (*createProduct) CreateProduct(ctx context.Context, newProduct http_model.CreateProductRequest) *http_model.CreateProductData {
-	data, err := db.CreateProduct(ctx, newProduct)
-	if err != nil {
-		return nil
-	} else {
-		err := db.CreateProductPhoto(ctx, data.ProductID, newProduct.ProductPhotos)
-		if err != nil {
-			return nil
-		}
-	}
-	return data
-}

service/project.go

@@ -0,0 +1,74 @@
+package service
+
+import (
+	"context"
+	"time"
+	"youngee_b_api/db"
+	"youngee_b_api/model/gorm_model"
+	"youngee_b_api/model/http_model"
+)
+
+var Project *project
+
+type project struct {
+}
+
+func (*project) CreateProject(ctx context.Context, newProject http_model.CreateProjectRequest) (*http_model.CreateProjectData, error) {
+	// build gorm_model.ProjectInfo
+	projectInfo := gorm_model.ProjectInfo{
+		ProjectName:     newProject.ProjectName,
+		ProjectStatus:   1,
+		ProjectType:     newProject.ProjectType,
+		TalentType:      newProject.TalentType,
+		ProjectPlatform: newProject.ProjectPlatform,
+		ProjectForm:     newProject.ProjectForm,
+		RecruitDdl:      time.Now().UTC().Local(),
+		ProjectDetail:   newProject.ProjectDetail,
+		ContentType:     newProject.ContentType,
+		EnterpriseID:    newProject.EnterpriseID,
+		ProductID:       newProject.ProductID,
+	}
+	// db create ProjectInfo
+	projectID, err := db.CreateProject(ctx, projectInfo)
+	if err != nil {
+		return nil, err
+	} else {
+		// build []gorm_model.ProjectPhoto
+		projectPhotos := []gorm_model.ProjectPhoto{}
+		for _, photo := range newProject.ProjectPhotos {
+			projectPhoto := gorm_model.ProjectPhoto{
+				PhotoUrl:  photo.PhotoUrl,
+				ProjectID: *projectID,
+			}
+			projectPhotos = append(projectPhotos, projectPhoto)
+		}
+		// db create ProjectPhoto
+		err := db.CreateProjectPhoto(ctx, projectPhotos)
+		if err != nil {
+			return nil, err
+		} else {
+			// build
+			recruitStrategys := []gorm_model.RecruitStrategy{}
+			for _, strategy := range newProject.RecruitStrategys {
+				recruitStrategy := gorm_model.RecruitStrategy{
+					FeeForm:       strategy.FeeForm,
+					StrategyID:    strategy.StrategyID,
+					FollowersLow:  strategy.FollowersLow,
+					FollowersUp:   strategy.FollowersUp,
+					RecruitNumber: strategy.RecruitNumber,
+					Offer:         strategy.Offer,
+					ProjectID:     *projectID,
+				}
+				recruitStrategys = append(recruitStrategys, recruitStrategy)
+			}
+			err := db.CreateRecruitStrategy(ctx, recruitStrategys)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+	res := &http_model.CreateProjectData{
+		ProjectID: *projectID,
+	}
+	return res, nil
+}

service/project_create.go

@@ -1,30 +0,0 @@
-package service
-
-import (
-	"context"
-	"youngee_b_api/db"
-	"youngee_b_api/model/http_model"
-)
-
-var CreateProject *createProject
-
-type createProject struct {
-}
-
-func (*createProject) CreateProject(ctx context.Context, newProject http_model.CreateProjectRequest) *http_model.CreateProjectData {
-	data, err := db.CreateProject(ctx, newProject)
-	if err != nil {
-		return nil
-	} else {
-		err := db.CreateProjectPhoto(ctx, data.ProjectID, newProject.ProjectPhotos)
-		if err != nil {
-			return nil
-		} else {
-			err := db.CreateRecruitStrategy(ctx, data.ProjectID, newProject.RecruitStrategys)
-			if err != nil {
-				return nil
-			}
-		}
-	}
-	return data
-}

service/register.go

@@ -0,0 +1,52 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"time"
+	"youngee_b_api/consts"
+	"youngee_b_api/db"
+	"youngee_b_api/redis"
+)
+
+var Register *register
+
+type register struct {
+	sessionTTL time.Duration
+}
+
+func (r *register) Register(ctx context.Context, phone string, vcode string) (*string, error) {
+	user, err := db.GetUserByPhone(ctx, phone)
+	if err != nil {
+		return nil, err
+	} else if user != nil {
+		return &phone, nil
+	} else {
+		code, err := r.getSession(ctx, phone)
+		if err != nil {
+			return nil, err
+		} else {
+			fmt.Printf("%+v", code)
+			if *code != vcode {
+				return &phone, nil
+			} else {
+				return nil, nil
+			}
+		}
+	}
+}
+
+func (r *register) getSession(ctx context.Context, phone string) (*string, error) {
+	value, err := redis.Get(ctx, r.getRedisKey(phone))
+	if err != nil {
+		if err == consts.RedisNil {
+			return nil, fmt.Errorf("not found in redis,phone:%+v", phone)
+		}
+		return nil, err
+	}
+	return &value, nil
+}
+
+func (r *register) getRedisKey(key string) string {
+	return fmt.Sprintf("%s%s", consts.SessionRedisPrefix, key)
+}

service/send_code.go

@@ -0,0 +1,42 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"time"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/system_model"
+	"youngee_b_api/redis"
+)
+
+var SendCode *sendCode
+
+func SendCodeInit(config *system_model.Session) {
+	sendCode := new(sendCode)
+	sendCode.sessionTTL = time.Duration(config.TTL) * time.Minute
+	SendCode = sendCode
+}
+
+type sendCode struct {
+	sessionTTL time.Duration
+}
+
+func (s *sendCode) GetCode(ctx context.Context) string {
+	rnd := rand.New(rand.NewSource(time.Now().UnixNano()))
+	vcode := fmt.Sprintf("%06v", rnd.Int31n(1000000))
+	return vcode
+}
+
+func (s *sendCode) SetSession(ctx context.Context, phone string, vcode string) error {
+	fmt.Println(phone)
+	err := redis.Set(ctx, s.getRedisKey(phone), vcode, s.sessionTTL)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s *sendCode) getRedisKey(key string) string {
+	return fmt.Sprintf("%s%s", consts.SessionRedisPrefix, key)
+}

service/user.go

@@ -0,0 +1 @@
+package service