baseapi/platformapi/weixinapi/sns.go

package weixinapi

import (
	"bytes"

	"git.rosy.net.cn/baseapi/utils"
)

type SNSTokenInfo struct {
	AccessToken  string `json:"access_token"`
	ExpiresIn    int    `json:"expires_in"`
	RefreshToken string `json:"refresh_token"`
	OpenID       string `json:"openid"`
	Scope        string `json:"scope"`
}

type SNSUserInfo struct {
	OpenID     string      `json:"openid"`
	NickName   string      `json:"nickname"`
	Sex        int         `json:"sex"`
	Province   string      `json:"province"`
	City       string      `json:"city"`
	Country    string      `json:"country"`
	HeadImgURL string      `json:"headimgurl"`
	Privilege  interface{} `json:"privilege"`
	UnionID    string      `json:"unionid"`
}

type SessionInfo struct {
	OpenID     string `json:"openid"`
	SessionKey string `json:"session_key"`
	UnionID    string `json:"unionid"`
}

type MiniUserInfo struct {
	OpenID          string `json:"openId"`
	NickName        string `json:"nickName"`
	Gender          int    `json:"gender"`
	Language        string `json:"language"`
	City            string `json:"city"`
	PhoneNumber     string `json:"phoneNumber"`
	PurePhoneNumber string `json:"purePhoneNumber"`
	Province        string `json:"province"`
	Country         string `json:"country"`
	CountryCode     string `json:"countryCode"`
	AvatarURL       string `json:"avatarUrl"`
	UnionID         string `json:"unionId"`
	Watermark       struct {
		Timestamp int    `json:"timestamp"`
		Appid     string `json:"appid"`
	} `json:"watermark"`
}

func mapData2SNSToken(result map[string]interface{}) *SNSTokenInfo {
	return &SNSTokenInfo{
		AccessToken:  utils.Interface2String(result["access_token"]),
		ExpiresIn:    int(utils.MustInterface2Int64(result["expires_in"])),
		RefreshToken: utils.Interface2String(result["refresh_token"]),
		OpenID:       utils.Interface2String(result["openid"]),
		Scope:        utils.Interface2String(result["scope"]),
	}
}

func (a *API) SNSRetrieveToken(code string) (tokenInfo *SNSTokenInfo, err error) {
	//"grant_type", "authorization_code",
	result, err := a.AccessAPI("sns/oauth2/access_token", utils.Params2Map("code", code), "")
	if err != nil {
		return nil, err
	}
	return mapData2SNSToken(result), nil
}

func (a *API) SNSRefreshToken(refreshToken string) (tokenInfo *SNSTokenInfo, err error) {
	result, err := a.AccessAPI("sns/oauth2/refresh_token", utils.Params2Map("grant_type", "refresh_token", "refresh_token", refreshToken), "")
	if err != nil {
		return nil, err
	}
	return mapData2SNSToken(result), nil
}

func (a *API) SNSGetUserInfo(accessToken, openid string) (*SNSUserInfo, error) {
	result, err := a.AccessAPI("sns/userinfo", map[string]interface{}{
		"access_token": accessToken,
		"openid":       openid,
	}, "")
	if err == nil {
		retVal := &SNSUserInfo{
			OpenID:     utils.Interface2String(result["openid"]),
			NickName:   utils.Interface2String(result["nickname"]),
			Sex:        int(utils.MustInterface2Int64(result["sex"])),
			Province:   utils.Interface2String(result["province"]),
			City:       utils.Interface2String(result["city"]),
			Country:    utils.Interface2String(result["country"]),
			HeadImgURL: utils.Interface2String(result["headimgurl"]),
			Privilege:  result["privilege"],
			UnionID:    utils.Interface2String(result["unionid"]),
		}
		return retVal, nil
	}
	return nil, err
}

func (a *API) SNSIsOpenIDValid(accessToken, openid string) (bool, error) {
	_, err := a.AccessAPI("sns/auth", map[string]interface{}{
		"access_token": accessToken,
		"openid":       openid,
	}, "")
	if err == nil {
		return true, nil
	}
	return false, err
}

func (a *API) SNSCode2Session(jsCode string) (sessionInfo *SessionInfo, err error) {
	result, err := a.AccessAPI("sns/jscode2session", map[string]interface{}{
		"js_code":    jsCode,
		"grant_type": "authorization_code",
	}, "")
	if err == nil {
		return &SessionInfo{
			OpenID:     utils.Interface2String(result["openid"]),
			SessionKey: utils.Interface2String(result["session_key"]),
			UnionID:    utils.Interface2String(result["unionid"]),
		}, nil
	}
	return nil, err
}

// 待删除
func (a *API) SNSDecodeMiniProgramData(encryptedData, sessionKey, iv string) (decryptedData []byte, err error) {
	return SNSDecodeMiniProgramData(encryptedData, sessionKey, iv)
}

func SNSDecodeMiniProgramData(encryptedData, sessionKey, iv string) (decryptedData []byte, err error) {
	decodedDataList, err := utils.Base64DecodeMultiString(encryptedData, sessionKey, iv)
	if err != nil {
		return nil, err
	}
	decryptedData, err = utils.AESCBCDecpryt(decodedDataList[0], decodedDataList[1], decodedDataList[2])
	return decryptedData, err
}

func PKCSUnPadding(origData []byte) []byte {
	length := len(origData)
	unpadding := int(origData[length-1])
	return origData[:(length - unpadding)]
}

func PKCSPadding(ciphertext []byte, blockSize int) []byte {
	padding := blockSize - len(ciphertext)%blockSize
	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
	return append(ciphertext, padtext...)
}