1

dao/project_dao.go

@@ -256,14 +256,14 @@ func (d *ProjectDao) AddProjectAndAccount(projectData *models.CmProject, account
 	}
 
 	// 1.写入项目表
-	_, err = session.Insert(projectData)
-	if err != nil {
+	if _, err = session.Insert(projectData); err != nil {
 		log.Println(err)
 		session.Rollback()
 		return errors.New("新增项目出错")
 	}
 
 	// 2.写入账号表
+	accountData.ProjectId = projectData.Id
 	_, err = session.Insert(accountData)
 	if err != nil {
 		log.Println(err)
@@ -271,6 +271,17 @@ func (d *ProjectDao) AddProjectAndAccount(projectData *models.CmProject, account
 		return errors.New("新增账号出错")
 	}
 
+	// 更新项目表里的管理员信息
+	updateData := &models.CmProject{}
+	updateData.Id = projectData.Id
+	updateData.UserId = accountData.Id
+	updateData.UserAccount = accountData.Name
+	if _, err = session.Where("id = ? ", projectData.Id).Update(updateData); err != nil {
+		log.Println(err)
+		session.Rollback()
+		return errors.New("更新管理员信息出错")
+	}
+
 	// 3. 提交事务
 	err = session.Commit()
 	if err != nil {

lib/jlzf.go

@@ -7,8 +7,10 @@
 package lib
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
+	"log"
 	"time"
 
 	"github.com/dgrijalva/jwt-go"
@@ -24,6 +26,17 @@ type Jlzf struct {
 	Token   string
 }
 
+// 计量接口返回
+type jlResult struct {
+	Code int        `json:"code" `
+	Data dataResult `json:"data" `
+	Msg  string     `json:"msg" `
+}
+type dataResult struct {
+	Account map[string]interface{} `json:"account" `
+	Project map[string]interface{} `json:"project" `
+}
+
 //创建项目用户service
 func NewJlzf() *Jlzf {
 	// 自动识别开发环境和生产环境
@@ -32,7 +45,6 @@ func NewJlzf() *Jlzf {
 	if debug {
 		AuthUrl = "http://ljr.jl.com:7002"
 	}
-
 	return &Jlzf{
 		AuthUrl: AuthUrl,
 	}
@@ -52,47 +64,41 @@ func makeTokenString(claimsData jwt.MapClaims) (string, error) {
 }
 
 // 拉取计量项目信息
-func (j *Jlzf) GetProjectAndAccount(code string, account string) (map[string]interface{}, error) {
+func (j *Jlzf) GetProjectAndAccount(code string, account string) (map[string]interface{}, map[string]interface{}, error) {
 	var (
 		tokenString string
 		err         error
-		resultData  map[string]interface{}
+		resultByte  []byte
+		jlResult    jlResult
 	)
 	// 1.生成请求数据
-	expirationTime := time.Now().Add(24 * time.Hour)
+	expirationTime := time.Now().Add(3 * time.Second)
 	claimsData := jwt.MapClaims{
 		"data": map[string]string{"code": code, "account": account},
 		"exp":  expirationTime.Unix(),
-		// "StandardClaims": jwt.StandardClaims{
-		// 	ExpiresAt: expirationTime.Unix(),
-		// },
+		"iat":  time.Now().Unix(),
 	}
 	// 1-1.生成token
 	if tokenString, err = makeTokenString(claimsData); err != nil {
-		return nil, errors.New("生成请求token错误")
+		return nil, nil, errors.New("生成请求token错误")
 	}
 	fmt.Println(tokenString)
 	// 1-2.发送请求
-	if resultData, err = utils.PullData("GET", j.AuthUrl+"/management/project", tokenString); err != nil {
-		return nil, errors.New(fmt.Sprintf("计量错误，err= %s", err))
+	if resultByte, err = utils.PullData("GET", j.AuthUrl+"/management/account?auth="+tokenString, ""); err != nil {
+		return nil, nil, errors.New(fmt.Sprintf("计量错误，err= %s", err))
+	}
+	// fmt.Println(string(body))
+	// result := map[string]interface{}{}
+	err = json.Unmarshal(resultByte, &jlResult)
+	if err != nil {
+		log.Println("请求移除, error=", err)
+		return nil, nil, errors.New("解析数据错误")
+	}
+	if jlResult.Code != 0 {
+		return nil, nil, errors.New(fmt.Sprintf("%s", jlResult.Msg))
 	}
 
-	fmt.Println(resultData)
-	return resultData, nil
-	// client := &http.Client{}
-	// data := url.Values{}
-	// data.Set("auth", tokenString)
-	// parameter := strings.NewReader(data.Encode())
-	// reqest, err := http.NewRequest("GET", j.AuthUrl, parameter)
-	// if err != nil {
-	// 	return nil, errors.New("计量网络出现问题")
-	// }
-	// reqest.Header.Add("Content-Type", "application/x-www-form-urlencoded")
-	// // 发送请求
-	// response, err := client.Do(reqest)
-}
-func (j *Jlzf) GetAccount() error {
-	return nil
+	return jlResult.Data.Project, jlResult.Data.Account, nil
 }
 
 // 验证计量支付项目账号的登陆密码

models/cm_project.go

@@ -5,7 +5,7 @@ import (
 )
 
 type CmProject struct {
-	Id               int       `xorm:"not null pk comment('自增ID') INT(11)"`
+	Id               int       `xorm:"not null pk autoincr comment('自增ID') INT(11)"`
 	Code             string    `xorm:"comment('项目编号') VARCHAR(32)"`
 	EnterpriseId     int       `xorm:"comment('企业id') INT(11)"`
 	UserId           int       `xorm:"comment('管理员id(sso用户)') INT(11)"`
@@ -22,6 +22,7 @@ type CmProject struct {
 	CreateCategory   string    `xorm:"comment('创建办事处') VARCHAR(32)"`
 	InsideCategoryid string    `xorm:"comment('项目所在办事处Id') VARCHAR(32)"`
 	InsideCategory   string    `xorm:"comment('项目所在办事处') VARCHAR(32)"`
+	JlReciprocate    int       `xorm:"comment('计量互通（1开启）') TINYINT(4)"`
 	MaxUser          int       `xorm:"comment('最大创建用户数(删除)') TINYINT(4)"`
 	Name             string    `xorm:"comment('项目名称') VARCHAR(128)"`
 	Creator          int64     `xorm:"comment('创建者') BIGINT(20)"`

models/cm_project_account.go

@@ -28,6 +28,7 @@ type CmProjectAccount struct {
 	ContractPermission string    `xorm:"comment('合同权限(json)') TEXT"`
 	QualityPermission  string    `xorm:"comment('质量巡检权限(json)') TEXT"`
 	SafePermission     string    `xorm:"comment('安全巡检权限(json)') TEXT"`
+	JlAuth             int       `xorm:"comment('计量授权（1授权）') TINYINT(4)"`
 	Cooperation        int       `xorm:"comment('协作') TINYINT(4)"`
 	LastNotice         time.Time `xorm:"comment('待办事项，通知') DATETIME"`
 	SignPath           string    `xorm:"comment('电子签名图片地址') VARCHAR(512)"`

services/jl_service.go

@@ -8,17 +8,19 @@ package services
 
 import (
 	"errors"
-	"fmt"
 	"net/http"
 	"net/url"
 	"strconv"
+	"time"
 
+	"github.com/dgrijalva/jwt-go"
 	"go.mod/comm"
 	"go.mod/conf"
 	"go.mod/dao"
 	"go.mod/datasource"
 	"go.mod/lib"
 	"go.mod/models"
+	"go.mod/web/utils"
 	"go.mod/web/viewmodels"
 )
 
@@ -52,94 +54,179 @@ func (s *JlService) IsCode(code string) map[string]interface{} {
 	return data
 }
 
-// 从计量来的项目和管理员账号，添加入项目管理
+// 从计量 创建 项目和管理员账号
 func (s *JlService) ProjectAdd(claimsData *viewmodels.Jl) (map[string]interface{}, error) {
 
 	var (
-		err          error
-		JlResultData map[string]interface{}
-		accountData  *models.CmProjectAccount
+		err             error
+		JlResultProject map[string]interface{}
+		JlResultAccount map[string]interface{}
+		accountData     *models.CmProjectAccount
+		sync            int
 	)
 
+	sync = 0
 	Jlzf := lib.NewJlzf()
 	// 1.获得计量 账号和项目 信息
-	if JlResultData, err = Jlzf.GetProjectAndAccount(claimsData.Code, claimsData.Account); err != nil {
+	if JlResultProject, JlResultAccount, err = Jlzf.GetProjectAndAccount(claimsData.Code, claimsData.Account); err != nil {
 		return nil, err
 	}
-	fmt.Println(JlResultData)
+	accountGroup := int(JlResultAccount["accountGroup"].(float64))
 
-	// 2.获得本地项目
-	projectData := s.dao.GetCode(claimsData.Code)
-	// 项目不存在
-	if projectData.Id == 0 {
-		// 2-1. 创建项目和账号 TODO
-		project := &models.CmProject{}
+	// fmt.Println(JlResultProject)
+	// fmt.Println(JlResultAccount)
+	// 2. 计量账号 是否是管理员
+	// 管理员 --只能管理员才能创建项目
+	if JlResultAccount["isAdmin"].(float64) == 1 {
+		// 2-1. 获得本地项目
+		projectData := s.dao.GetCode(claimsData.Code)
+		// 2-1-1.项目不存在(账号肯定不存在) - 创建项目
+		if projectData.Id == 0 {
+			//组合数据-项目 - 标注授权开启互通
+			categoryId := strconv.FormatFloat(JlResultProject["categoryId"].(float64), 'f', 0, 64)
 
-		account := &models.CmProjectAccount{}
-		if err = s.dao.AddProjectAndAccount(project, account); err != nil {
-			return nil, err
-		}
-		// 	project := &models.CmProject{}
-		// project.Name = projectVM.Name
-		// project.Code = projectVM.Code
-		// project.CategoryId = projectVM.CategoryId
-		// project.Category = projectVM.Category
-		// project.InsideCategoryid = projectVM.InsideCategoryid
-		// project.InsideCategory = projectVM.InsideCategory
-		// project.StaffId = projectVM.StaffId
-		// project.StaffName = projectVM.StaffName
-		// project.CreateTime = time.Now()
-		// project.CreateName = projectVM.CreateName
-		// project.CreateCategory = projectVM.CreateCategory
-		// project.Remark = projectVM.Remark
+			project := &models.CmProject{}
+			project.Name = JlResultProject["name"].(string)
+			project.Code = JlResultProject["code"].(string)
 
-	} else {
-		// 2-2. 是否有该账号
-		accountData = s.accountDao.GetAccountProjectId(claimsData.Account, projectData.Id)
-		// 2-2-1 账号不存在
-		if accountData.Id == 0 {
-			// 2-2-2. 创建 账号 TODO
+			project.StaffName = JlResultProject["staff"].(string)
+			project.CategoryId = categoryId
+			project.Category = JlResultProject["category"].(string)
+			project.InsideCategoryid = categoryId
+			project.InsideCategory = JlResultProject["category"].(string)
+			project.CreateTime = time.Now()
+			project.CreateName = "计量授权创建"
+			project.JlReciprocate = 1
+
+			//组合数据-账号 - 标注 计量授权账号-设置为管理员
 			account := &models.CmProjectAccount{}
-			if err = s.accountDao.Add(account); err != nil {
+			account.Account = JlResultAccount["account"].(string)
+			account.Password = "JL"
+			account.AccountGroup = accountGroup
+			account.Name = JlResultAccount["name"].(string)
+			account.Company = JlResultAccount["company"].(string)
+			account.Position = JlResultAccount["role"].(string)
+			account.Mobile = JlResultAccount["mobile"].(string)
+			account.Telephone = JlResultAccount["telephone"].(string)
+			account.Enable = 1
+			account.IsAdmin = 1
+			account.CreateTime = time.Now()
+			account.JlAuth = 1
+
+			// 创建项目和账号
+			if err = s.dao.AddProjectAndAccount(project, account); err != nil {
+				return nil, err
+			}
+			sync = 1
+		} else {
+			// 1.需要开启互通
+			project := &models.CmProject{}
+			project.JlReciprocate = 1
+			project.Id = projectData.Id
+			if err := s.dao.Update(project, []string{"jl_reciprocate"}); err != nil {
 				return nil, err
 			}
-		}
-	}
 
-	data := map[string]interface{}{
-		"sync": 1,
+			// 计量授权账号
+			account := &models.CmProjectAccount{}
+			account.JlAuth = 1
+			// 1-2. 获得账号-计量账号在项目管理中
+			accountData = s.accountDao.GetAccountProjectId(claimsData.Account, projectData.Id)
+			// 1-3. 不存在
+			if accountData.Id == 0 {
+				// 管理员-是否存在 ——需求还不明确，是否要设置成管理员 -先不做 ——NOTODO
+				// adminAccount := s.accountDao.GetAdmin(projectData.Id)
+				// 管理员不存在设置管理员
+				// if adminAccount.Id == 0 {
+				// 	account.IsAdmin = 1
+				// }
+				account.ProjectId = projectData.Id
+				account.Account = JlResultAccount["account"].(string)
+				account.Password = "JL"
+				account.AccountGroup = accountGroup
+				account.Name = JlResultAccount["name"].(string)
+				account.Company = JlResultAccount["company"].(string)
+				account.Position = JlResultAccount["role"].(string)
+				account.Mobile = JlResultAccount["mobile"].(string)
+				account.Telephone = JlResultAccount["telephone"].(string)
+				account.Enable = 1
+				account.CreateTime = time.Now()
+				if err := s.accountDao.Add(account); err != nil {
+					return nil, err
+				}
+			} else {
+				// 存在
+				account.Id = accountData.Id
+				if err := s.accountDao.Update(account, []string{"jl_auth"}); err != nil {
+					return nil, err
+				}
+			}
+			sync = 1
+		}
+	} else {
+		//2-2. 普通账号
+		return nil, errors.New("只能由 管理员 创建 项目管理项目")
 	}
-	return data, nil
+	return map[string]interface{}{"sync": sync}, nil
 }
 
+// 授权登陆
 func (s *JlService) AuthLogin(claimsData *viewmodels.Jl, writer http.ResponseWriter) (*viewmodels.ProjectAccount, error) {
+
+	var (
+		err error
+		// JlResultProject map[string]interface{}
+		JlResultAccount map[string]interface{}
+	)
+
 	// 1-1.工程项目是否存在
 	projectInfo := s.dao.GetCode(claimsData.Code)
 
 	if projectInfo.Id == 0 {
 		return nil, errors.New("工程建设管理员还未创建项目，禁止登录")
 	}
-	// 1-2.获得项目管理员
-	projectAdminInfo := s.accountDao.Get(projectInfo.UserId, projectInfo.Id)
-	if projectAdminInfo.Id == 0 {
-		return nil, errors.New("工程建设管理员不存在，禁止登录")
+	// // 1-2.获得项目管理员- 授权登陆不需要验证管理员
+	// projectAdminInfo := s.accountDao.Get(projectInfo.UserId, projectInfo.Id)
+	// if projectAdminInfo.Id == 0 {
+	// 	return nil, errors.New("工程建设管理员不存在，禁止登录")
+	// }
+
+	// 计量 的 项目下 是否存在 账号
+	Jlzf := lib.NewJlzf()
+	// 1.获得计量 账号和项目 信息 - 表示验证通过
+	if _, JlResultAccount, err = Jlzf.GetProjectAndAccount(claimsData.Code, claimsData.Account); err != nil {
+		return nil, errors.New("计量 校验失败-未找到项目或账号")
 	}
 
 	// 2.验证登陆-临时
 	projectAccountInfo := s.accountDao.GetAccountProjectId(claimsData.Account, projectInfo.Id)
-	// 未账号改账号
+	account := &models.CmProjectAccount{}
+	account.JlAuth = 1
+	// 本地没有账号
 	if projectAccountInfo.Id == 0 {
-		// 到计量拉取普通账号 - TODO
-		// Jlzf := lib.NewJlzf()
-		// // 1.获得计量 账号和项目 信息
-		// if JlResultData, err := Jlzf.GetProjectAndAccount(claimsData.Code, claimsData.Account); err != nil {
-		// 	return nil, err
-		// }
-		// // 2-. 创建 账号 TODO
-		// account := &models.CmProjectAccount{}
-		// if err := s.accountDao.Add(account); err != nil {
-		// 	return nil, err
-		// }
+		accountGroup := int(JlResultAccount["accountGroup"].(float64))
+		account.ProjectId = projectInfo.Id
+		account.Account = JlResultAccount["account"].(string)
+		account.Password = "JL"
+		account.AccountGroup = accountGroup
+		account.Name = JlResultAccount["name"].(string)
+		account.Company = JlResultAccount["company"].(string)
+		account.Position = JlResultAccount["role"].(string)
+		account.Mobile = JlResultAccount["mobile"].(string)
+		account.Telephone = JlResultAccount["telephone"].(string)
+		account.Enable = 1
+		account.CreateTime = time.Now()
+		if err := s.accountDao.Add(account); err != nil {
+			return nil, err
+		}
+		// 覆盖原来的信息
+		projectAccountInfo = account
+	} else if projectAccountInfo.JlAuth == 0 {
+		// 更新为互通授权账号
+		account.Id = projectAccountInfo.Id
+		if err := s.accountDao.Update(account, []string{"jl_auth"}); err != nil {
+			return nil, err
+		}
 	}
 	// 2-1.账号停用
 	if projectAccountInfo.Enable == 0 {
@@ -177,3 +264,35 @@ func (s *JlService) AuthLogin(claimsData *viewmodels.Jl, writer http.ResponseWri
 	viewAccountData := comm.MakeProjectAccountVM(projectAccountInfo)
 	return &viewAccountData, nil
 }
+
+func (s *JlService) ProjectExist(projectId int, accountId int) (map[string]interface{}, error) {
+	exist := 0
+	projectData := s.dao.Get(projectId)
+	if projectData.Id == 0 {
+		return nil, errors.New("项目未找到")
+	}
+	if projectData.JlReciprocate != 1 {
+		return nil, errors.New("计量未开通 跳转")
+	}
+	accountData := s.accountDao.Get(accountId, projectId)
+	if accountData.Id == 0 {
+		return nil, errors.New("账号未找到")
+	}
+	if accountData.JlAuth != 1 {
+		return nil, errors.New("计量未开通 此账号 跳转")
+	}
+
+	// 计量 的 项目下 是否存在 账号
+	Jlzf := lib.NewJlzf()
+	// 1.获得计量 账号和项目 信息 - 表示验证通过
+	if _, _, err := Jlzf.GetProjectAndAccount(projectData.Code, accountData.Account); err != nil {
+		return nil, errors.New("计量 校验失败-未找到项目或账号")
+	}
+	exist = 1
+	tokenString, _ := utils.CreateJlToken(jwt.MapClaims{
+		"code":    projectData.Code,
+		"account": accountData.Account,
+		"exp":     time.Now().Add(24 * time.Hour).Unix(),
+	})
+	return map[string]interface{}{"exist": exist, "token": tokenString}, nil
+}

services/login_service.go

@@ -86,8 +86,8 @@ func (s *loginService) ValidProjectAccount(loginData viewmodels.Login, writer ht
 		return nil, errors.New("该账号已被停用")
 	}
 
+	// TODO 计量授权账号 优先验证计量密码，不通过在验证项目管理密码（有的话）
 	password := comm.CreatePasswordSign(loginData.Password, loginData.Account)
-
 	if projectAccountInfo.Password != password {
 		return nil, errors.New("密码不正确")
 	}

web/external/jl_ex.go

@@ -148,4 +148,26 @@ func (c *JlEx) PostAuthLogin() {
 	})
 }
 
-//
+//校验计量账号
+func (c *JlEx) PostProjectExist() {
+	var (
+		projectId int
+		accountId int
+		err       error
+	)
+	projectId, err = utils.GetProjectId(c.Ctx)
+	accountId, err = utils.GetProjectAccountId(c.Ctx)
+
+	JlService := services.NewJlService()
+	result, err := JlService.ProjectExist(projectId, accountId)
+	if err != nil {
+		c.Ctx.JSON(iris.Map{"code": -1, "msg": fmt.Sprintf("%s", err)})
+		return
+	}
+	c.Ctx.JSON(iris.Map{
+		"code": 0,
+		"msg":  "",
+		"data": result,
+	})
+
+}

web/routes/routes.go

@@ -255,19 +255,22 @@ func Configure(b *bootstrap.Bootstrapper) {
 	backstageAccountCM.Router.Use(middleware.SetCsrf)
 	backstageAccountCM.Handle(new(backstage.ProjectAccountBs))
 
-	managerCM := mvc.New(b.Party("/api/backstage/manager"))
+	managerCM := mvc.New(b.Party("/api/backstage/manager", b.Protect))
 	managerCM.Register(managerService)
 	managerCM.Router.Use(middleware.SessionsBackstageAuth)
+	managerCM.Router.Use(middleware.SetCsrf)
 	managerCM.Handle(new(backstage.ManagerBs))
 
-	groupCM := mvc.New(b.Party("/api/backstage/group"))
+	groupCM := mvc.New(b.Party("/api/backstage/group", b.Protect))
 	groupCM.Register(groupService)
 	groupCM.Router.Use(middleware.SessionsBackstageAuth)
+	groupCM.Router.Use(middleware.SetCsrf)
 	groupCM.Handle(new(backstage.GroupBs))
 
-	versionCM := mvc.New(b.Party("/api/backstage/version"))
+	versionCM := mvc.New(b.Party("/api/backstage/version", b.Protect))
 	versionCM.Register(versionService)
 	versionCM.Router.Use(middleware.SessionsBackstageAuth)
+	versionCM.Router.Use(middleware.SetCsrf)
 	versionCM.Handle(new(backstage.VersionBs))
 
 	//CSRF相关

web/utils/utils.go

@@ -7,7 +7,6 @@
 package utils
 
 import (
-	"encoding/json"
 	"errors"
 	"fmt"
 	"io/ioutil"
@@ -139,19 +138,28 @@ func CreateRuleCode(code int64, count int64, len int) string {
 	}
 }
 
+// 对计量请求token
+func CreateJlToken(data jwt.MapClaims) (string, error) {
+	var (
+		tokenString string
+		err         error
+	)
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, data)
+	if tokenString, err = token.SignedString([]byte(conf.JLSecretKey)); err != nil {
+		return "", err
+	}
+	return tokenString, nil
+}
+
 // 验证并解析JWT
 func ValidateJwt(tokenStr string) (jwt.MapClaims, error) {
 	// 0.测试时使用
 	// 在这里声明令牌的到期时间，我们将其保留为5分钟
-	expirationTime := time.Now().Add(5 * time.Minute)
-	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
-		"code":    "gs01",
-		"account": "蓝健荣",
-		"StandardClaims": jwt.StandardClaims{
-			ExpiresAt: expirationTime.Unix(),
-		},
+	tokenString, _ := CreateJlToken(jwt.MapClaims{
+		"code":    "QL3D3",
+		"account": "lanjianrong",
+		"exp":     time.Now().Add(24 * time.Hour).Unix(),
 	})
-	tokenString, _ := token.SignedString([]byte(conf.JLSecretKey))
 	log.Println("JWT 5分钟过期-开发使用,=", tokenString)
 
 	// 1.验证并解析JWT
@@ -163,6 +171,15 @@ func ValidateJwt(tokenStr string) (jwt.MapClaims, error) {
 		return nil, err
 	}
 	if !parseAuth.Valid {
+		if ve, ok := err.(*jwt.ValidationError); ok {
+			if ve.Errors&jwt.ValidationErrorMalformed != 0 {
+				return nil, errors.New("无效签名")
+			} else if ve.Errors&(jwt.ValidationErrorExpired|jwt.ValidationErrorNotValidYet) != 0 {
+				return nil, errors.New("过期签名")
+			} else {
+				return nil, errors.New("无效签名")
+			}
+		}
 		return nil, errors.New("无效签名")
 	}
 
@@ -176,24 +193,30 @@ func ValidateJwt(tokenStr string) (jwt.MapClaims, error) {
 	return claims, nil
 }
 
-func PullData(method string, authUrl string, tokenString string) (map[string]interface{}, error) {
+func PullData(method string, authUrl string, tokenString string) ([]byte, error) {
 
-	// 1.构建请求体
+	var (
+		err    error
+		reqest *http.Request
+	)
 	client := &http.Client{}
-	data := url.Values{}
-	data.Set("auth", tokenString)
-	parameter := strings.NewReader(data.Encode())
-
-	// 2.开始请求准备
-	reqest, err := http.NewRequest(method, authUrl, parameter)
+	if method == "POST" || method == "post" {
+		// 1.构建请求体
+		data := url.Values{}
+		data.Set("auth", tokenString)
+		parameter := strings.NewReader(data.Encode())
+		// 2.开始请求准备
+		reqest, err = http.NewRequest(method, authUrl, parameter)
+		reqest.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	} else if method == "GET" || method == "get" {
+		reqest, err = http.NewRequest(method, authUrl, nil)
+		reqest.Header.Add("Content-Type", "application/json; charset=utf-8")
+	}
 	if err != nil {
 		log.Println("请求移除, error=", err)
 		return nil, errors.New("网络出现问题")
 	}
-	if method == "POST" || method == "post" {
-		reqest.Header.Add("Content-Type", "application/x-www-form-urlencoded")
-	}
-	fmt.Println(reqest)
+
 	// 3.发送请求
 	response, err := client.Do(reqest)
 	if err != nil {
@@ -206,19 +229,20 @@ func PullData(method string, authUrl string, tokenString string) (map[string]int
 
 	// 4.结构化返回数据
 	body, _ := ioutil.ReadAll(response.Body)
+	return body, nil
 	// fmt.Println(string(body))
-	result := map[string]interface{}{}
-	err = json.Unmarshal(body, &result)
-	if err != nil {
-		log.Println("请求移除, error=", err)
-		return nil, errors.New("解析数据错误")
-	}
+	// result := map[string]interface{}{}
+	// err = json.Unmarshal(body, &result)
+	// if err != nil {
+	// 	log.Println("请求移除, error=", err)
+	// 	return nil, errors.New("解析数据错误")
+	// }
 
-	if result["code"] != 0 {
-		return nil, errors.New(fmt.Sprintf("%s", result["msg"]))
-	}
+	// if result["code"].(float64) != 0 {
+	// 	return nil, errors.New(fmt.Sprintf("%s", result["msg"]))
+	// }
 
-	return result, nil
+	// return result, nil
 }
 
 // // 获得项目ID