openbilibili/app/admin/main/member/service/realname.go

package service

import (
	"bufio"
	"bytes"
	"context"
	"crypto/md5"
	"encoding/hex"
	"fmt"
	"image"
	"image/jpeg"
	"image/png"
	"io/ioutil"
	mrand "math/rand"
	"os"
	"strconv"
	"strings"
	"syscall"
	"time"

	"go-common/app/admin/main/member/conf"
	"go-common/app/admin/main/member/model"
	memmdl "go-common/app/service/main/member/model"
	"go-common/library/ecode"
	"go-common/library/log"
	"go-common/library/net/metadata"
	"go-common/library/queue/databus/report"

	"github.com/nfnt/resize"
	"github.com/pkg/errors"
)

// consts
const (
	_512KiloBytes = 512 * 1024
)

// RealnameList .
func (s *Service) RealnameList(ctx context.Context, arg *model.ArgRealnameList) (list []*model.RespRealnameApply, total int, err error) {
	list = make([]*model.RespRealnameApply, 0)
	switch arg.Channel {
	case model.ChannelMain:
		return s.realnameMainList(ctx, arg)
	case model.ChannelAlipay:
		return s.realnameAlipayList(ctx, arg)
	}
	return
}

func (s *Service) realnameMainList(ctx context.Context, arg *model.ArgRealnameList) (list []*model.RespRealnameApply, total int, err error) {
	var (
		dl []*model.DBRealnameApply
	)
	if arg.Card != "" {
		// 如果查询证件号, 则通过证件号MD5 realname_info 查询到 对应的 mids
		var (
			infos []*model.DBRealnameInfo
			mids  []int64
			md5   = cardMD5(arg.Card, arg.DBCardType(), arg.Country)
		)
		log.Info("realnameMainList card: %s, md5: %s", arg.Card, md5)
		if infos, err = s.dao.RealnameInfoByCardMD5(ctx, md5, arg.State.DBStatus(), model.ChannelMain.DBChannel()); err != nil {
			return
		}
		log.Info("realnameMainList infos : %+v", infos)
		if len(infos) <= 0 {
			return
		}
		for _, i := range infos {
			log.Info("realnameMainList info: %+v", i)
			mids = append(mids, i.MID)
		}
		log.Info("realnameMainList mids: %+v", mids)
		if dl, total, err = s.dao.RealnameMainList(ctx, mids, arg.DBCardType(), arg.DBCountry(), arg.OPName, arg.TSFrom, arg.TSTo, arg.DBState(), arg.PN, arg.PS, arg.IsDesc); err != nil {
			return
		}
	} else {
		var (
			mids []int64
		)
		if arg.MID > 0 {
			mids = append(mids, arg.MID)
		}
		if dl, total, err = s.dao.RealnameMainList(ctx, mids, arg.DBCardType(), arg.DBCountry(), arg.OPName, arg.TSFrom, arg.TSTo, arg.DBState(), arg.PN, arg.PS, arg.IsDesc); err != nil {
			return
		}
	}
	var (
		midMap = make(map[int64]int) // map[mid]count
		mids   []int64
		imgIDs []int64
	)
	// 审核 db 数据解析进 list
	for _, d := range dl {
		midMap[d.MID] = 0
		var (
			r = &model.RespRealnameApply{}
		)
		r.ParseDBMainApply(d)
		imgIDs = append(imgIDs, d.HandIMG, d.FrontIMG, d.BackIMG)
		list = append(list, r)
	}
	// 没有数据则返回
	if len(midMap) <= 0 {
		return
	}
	// 获取实名申请次数
	for mid := range midMap {
		if midMap[mid], err = s.dao.RealnameApplyCount(ctx, mid); err != nil {
			return
		}
		mids = append(mids, mid)
	}
	// 获取mid的昵称 & 等级信息
	var (
		memsArg = &memmdl.ArgMemberMids{
			Mids: mids,
		}
		memMap map[int64]*memmdl.Member
		imgMap map[int64]*model.DBRealnameApplyIMG
	)
	if memMap, err = s.memberRPC.Members(ctx, memsArg); err != nil {
		err = errors.WithStack(err)
		return
	}
	// 获取证件照信息
	if imgMap, err = s.dao.RealnameApplyIMG(ctx, imgIDs); err != nil {
		return
	}
	for _, ra := range list {
		if mem, ok := memMap[ra.MID]; ok {
			ra.ParseMember(mem)
		}
		for _, id := range ra.IMGIDs {
			if img, ok := imgMap[id]; ok {
				ra.ParseDBApplyIMG(img.IMGData)
			}
		}
		ra.Times = midMap[ra.MID]
	}
	return
}

func (s *Service) realnameAlipayList(ctx context.Context, arg *model.ArgRealnameList) (list []*model.RespRealnameApply, total int, err error) {
	var (
		dl []*model.DBRealnameAlipayApply
	)
	if arg.Card != "" {
		// 如果查询证件号, 则通过证件号MD5 realname_info 查询到 对应的 mids
		var (
			infos []*model.DBRealnameInfo
			mids  []int64
			md5   = cardMD5(arg.Card, arg.DBCardType(), arg.Country)
		)
		log.Info("realnameAlipayList card: %s, md5: %s", arg.Card, md5)
		if infos, err = s.dao.RealnameInfoByCardMD5(ctx, md5, arg.State.DBStatus(), model.ChannelAlipay.DBChannel()); err != nil {
			return
		}
		log.Info("realnameAlipayList infos : %+v", infos)
		if len(infos) <= 0 {
			return
		}
		for _, i := range infos {
			log.Info("realnameAlipayList info: %+v", i)
			mids = append(mids, i.MID)
		}
		log.Info("realnameAlipayList mids: %+v", mids)
		if dl, total, err = s.dao.RealnameAlipayList(ctx, mids, 0, 0, arg.State.DBStatus(), arg.PN, arg.PS, arg.IsDesc); err != nil {
			return
		}
	} else {
		var (
			mids []int64
		)
		if arg.MID > 0 {
			mids = append(mids, arg.MID)
		}
		if dl, total, err = s.dao.RealnameAlipayList(ctx, mids, arg.TSFrom, arg.TSTo, arg.State.DBStatus(), arg.PN, arg.PS, arg.IsDesc); err != nil {
			return
		}
	}
	log.Info("realnameAlipayList dl: %+v, total: %d", dl, total)
	var (
		midMap = make(map[int64]int)
	)
	// append to list
	for _, d := range dl {
		midMap[d.MID] = 0
		var (
			r = &model.RespRealnameApply{}
		)
		r.ParseDBAlipayApply(d)
		list = append(list, r)
	}
	if len(midMap) <= 0 {
		return
	}
	var mids []int64
	for mid := range midMap {
		if midMap[mid], err = s.dao.RealnameApplyCount(ctx, mid); err != nil {
			return
		}
		mids = append(mids, mid)
	}
	var (
		memsArg = &memmdl.ArgMemberMids{
			Mids: mids,
		}
		memMap map[int64]*memmdl.Member
	)
	if memMap, err = s.memberRPC.Members(ctx, memsArg); err != nil {
		err = errors.WithStack(err)
		return
	}
	for _, ra := range list {
		if mem, ok := memMap[ra.MID]; ok {
			ra.ParseMember(mem)
		}
		ra.Times = midMap[ra.MID]
	}
	return
}

func cardMD5(card string, cardType int, country int) (res string) {
	if card == "" || cardType < 0 || country < 0 {
		return
	}
	var (
		lowerCode = strings.ToLower(card)
		key       = fmt.Sprintf("%s_%s_%d_%d", model.RealnameSalt, lowerCode, cardType, country)
	)
	return fmt.Sprintf("%x", md5.Sum([]byte(key)))
}

// RealnamePendingList .
func (s *Service) RealnamePendingList(ctx context.Context, arg *model.ArgRealnamePendingList) (list []*model.RespRealnameApply, total int, err error) {
	var (
		larg = &model.ArgRealnameList{
			Channel: arg.Channel,
			State:   model.RealnameApplyStatePending,
			TSFrom:  time.Now().Add(-time.Hour * 24 * 7).Unix(),
			PS:      arg.PS,
			PN:      arg.PN,
		}
	)
	return s.RealnameList(ctx, larg)
}

// RealnameAuditApply .
func (s *Service) RealnameAuditApply(ctx context.Context, arg *model.ArgRealnameAuditApply, adminName string, adminID int64) (err error) {
	var (
		mid int64
	)
	// 1. check the apply state
	switch arg.Channel {
	case model.ChannelMain:
		var apply *model.DBRealnameApply
		if apply, err = s.dao.RealnameMainApply(ctx, arg.ID); err != nil {
			return
		}
		if apply.IsPassed() {
			return
		}
		mid = apply.MID
	case model.ChannelAlipay:
		var apply *model.DBRealnameAlipayApply
		if apply, err = s.dao.RealnameAlipayApply(ctx, arg.ID); err != nil {
			return
		}
		if apply.Status == model.RealnameApplyStateNone.DBStatus() || apply.Status == model.RealnameApplyStateRejective.DBStatus() {
			return
		}
		mid = apply.MID
	}

	var (
		state      = 0
		msgTitle   = ""
		msgContent = ""
		mc         = "2_2_1"
		expNotify  = false
	)
	switch arg.Action {
	case model.RealnameActionPass:
		state = model.RealnameApplyStatePassed.DBStatus()
		msgTitle = "您提交的实名认证已审核通过"
		msgContent = "恭喜，您提交的实名认证已通过审核"
		expNotify = true
	case model.RealnameActionReject:
		state = model.RealnameApplyStateRejective.DBStatus()
		msgTitle = "您提交的实名认证未通过审核"
		msgContent = fmt.Sprintf(`抱歉，您提交的实名认证未通过审核，驳回原因：%s。请修改后重新提交实名认证。`, arg.Reason)
	default:
		err = ecode.RequestErr
		return
	}

	// 2. do something
	switch arg.Channel {
	case model.ChannelMain:
		if err = s.dao.UpdateOldRealnameApply(ctx, arg.ID, state, adminName, adminID, time.Now(), arg.Reason); err != nil {
			return
		}
	case model.ChannelAlipay:
		if err = s.dao.UpdateRealnameAlipayApply(ctx, arg.ID, adminID, adminName, state, arg.Reason); err != nil {
			return
		}
		if err = s.dao.UpdateRealnameInfo(ctx, mid, state, arg.Reason); err != nil {
			return
		}
	}
	go func() {
		if err := s.dao.RawMessage(context.Background(), mc, msgTitle, msgContent, []int64{mid}); err != nil {
			log.Error("%+v", err)
		}
		if expNotify {
			expMsg := &model.AddExpMsg{
				Event: "identify",
				Mid:   mid,
				IP:    metadata.String(ctx, metadata.RemoteIP),
				Ts:    time.Now().Unix(),
			}
			if err := s.dao.PubExpMsg(ctx, expMsg); err != nil {
				log.Error("%+v", err)
			}
		}
	}()
	return
}

// RealnameReasonList .
func (s *Service) RealnameReasonList(ctx context.Context, arg *model.ArgRealnameReasonList) (list []string, total int, err error) {
	return s.dao.RealnameReasonList(ctx)
}

// RealnameSetReason .
func (s *Service) RealnameSetReason(ctx context.Context, arg *model.ArgRealnameSetReason) (err error) {
	return s.dao.UpdateRealnameReason(ctx, arg.Reasons)
}

// RealnameSearchCard .
func (s *Service) RealnameSearchCard(ctx context.Context, cards []string, cardType int, country int) (data map[string]int64, err error) {
	var (
		hashmap = make(map[string]string) //map[hash]card
		hashes  = make([]string, 0)
		list    []*model.DBRealnameInfo
	)
	for _, card := range cards {
		hash := cardMD5(card, cardType, country)
		hashmap[hash] = card
		hashes = append(hashes, hash)
	}
	if list, err = s.dao.RealnameSearchCards(ctx, hashes); err != nil {
		return
	}
	data = make(map[string]int64)
	for _, l := range list {
		if rawCode, ok := hashmap[l.CardMD5]; ok {
			data[rawCode] = l.MID
		}
	}
	return
}

// RealnameUnbind is.
func (s *Service) RealnameUnbind(ctx context.Context, mid int64, adminName string, adminID int64) (err error) {
	var (
		info *model.DBRealnameInfo
	)
	if info, err = s.dao.RealnameInfo(ctx, mid); err != nil {
		return
	}
	if info == nil {
		err = ecode.RealnameAlipayApplyInvalid
		return
	}
	if info.Status != model.RealnameApplyStatePassed.DBStatus() {
		return
	}
	if err = s.dao.UpdateRealnameInfo(ctx, mid, model.RealnameApplyStateRejective.DBStatus(), "管理后台解绑"); err != nil {
		return
	}
	switch info.Channel {
	case model.ChannelMain.DBChannel():
		if err = s.dao.RejectRealnameMainApply(ctx, mid, adminName, adminID, "管理后台解绑"); err != nil {
			return
		}
	case model.ChannelAlipay.DBChannel():
		if err = s.dao.RejectRealnameAlipayApply(ctx, mid, adminName, adminID, "管理后台解绑"); err != nil {
			return
		}
	default:
		log.Warn("Failed to reject realname apply: unrecognized channel: %+v", info)
	}

	go func() {
		r := &report.ManagerInfo{
			Uname:    adminName,
			UID:      adminID,
			Business: model.RealnameManagerLogID,
			Type:     0,
			Oid:      mid,
			Action:   model.LogActionRealnameUnbind,
			Ctime:    time.Now(),
		}
		if err = report.Manager(r); err != nil {
			log.Error("Send manager log failed : %+v , report : %+v", err, r)
			err = nil
			return
		}
		log.Info("Send manager log success report : %+v", r)
	}()
	return
}

// RealnameImage return img
func (s *Service) RealnameImage(ctx context.Context, token string) ([]byte, error) {
	filePath := fmt.Sprintf("%s/%s.txt", conf.Conf.Realname.DataDir, token)
	_, err := os.Stat(filePath)
	if os.IsNotExist(err) {
		log.Info("file : %s , not found", filePath)
		return nil, ecode.RequestErr
	}
	file, err := os.Open(filePath)
	if err != nil {
		return nil, errors.WithStack(err)
	}
	defer file.Close()
	img, err := ioutil.ReadAll(file)
	if err != nil {
		return nil, errors.WithStack(err)
	}
	return s.mainCryptor.IMGDecrypt(img)
}

// FetchRealnameImage is
func (s *Service) FetchRealnameImage(ctx context.Context, token string) ([]byte, error) {
	img, err := s.dao.GetRealnameImageCache(ctx, asIMGData(token))
	if err == nil && len(img) > 0 {
		return img, nil
	}
	if err != nil {
		log.Warn("Failed to get realname image from cache: %s: %+v", token, err)
	}

	img, err = s.RealnameImage(ctx, token)
	if err != nil {
		return nil, err
	}

	if len(img) <= _512KiloBytes {
		return img, nil
	}

	striped, err := StripImage(img)
	if err != nil {
		log.Warn("Failed to strip image: %+v", err)
		return img, nil
	}
	return striped, nil
}

// RealnameImagePreview return preview img
func (s *Service) RealnameImagePreview(ctx context.Context, token string, borderSize uint) (data []byte, err error) {
	var (
		src []byte
	)
	if src, err = s.RealnameImage(ctx, token); err != nil {
		return
	}
	if len(src) == 0 {
		return
	}
	var (
		img                 image.Image
		imgWidth, imgHeight int
		imgFormat           string
		sr                  = bytes.NewReader(src)
	)
	if img, imgFormat, err = image.Decode(sr); err != nil {
		log.Warn("Failed to decode image: %+v, return origin image data directly", err)
		return src, nil
	}
	imgWidth, imgHeight = img.Bounds().Dx(), img.Bounds().Dy()
	log.Info("Decode img : %s , format : %s , width : %d , height : %d ", token, imgFormat, imgWidth, imgHeight)
	if imgFormat != "png" && imgFormat != "jpg" && imgFormat != "jpeg" {
		return
	}
	if imgWidth > imgHeight {
		img = resize.Resize(borderSize, 0, img, resize.Lanczos3)
	} else {
		img = resize.Resize(0, borderSize, img, resize.Lanczos3)
	}
	var (
		bb bytes.Buffer
		bw = bufio.NewWriter(&bb)
	)
	switch imgFormat {
	case "jpg", "jpeg":
		if err = jpeg.Encode(bw, img, nil); err != nil {
			err = errors.WithStack(err)
			return
		}
	case "png":
		if err = png.Encode(bw, img); err != nil {
			err = errors.WithStack(err)
			return
		}
	}
	data = bb.Bytes()
	return
}

// RealnameExcel export user realname info
func (s *Service) RealnameExcel(ctx context.Context, mids []int64) ([]*model.RealnameExport, error) {
	infos, err := s.dao.BatchRealnameInfo(ctx, mids)
	if err != nil {
		log.Warn("Failed to get realname info with mids: %+v: %+v", mids, err)
		// keep an empty infos
		infos = make(map[int64]*model.DBRealnameInfo)
	}

	pinfos, err := s.dao.PassportQueryByMidsChunked(ctx, mids, 100)
	if err != nil {
		log.Warn("Failed to get passport query by mids: %+v: %+v", mids, err)
		// keep an empty infos
		pinfos = make(map[int64]*model.PassportQueryByMidResult)
	}

	res := make([]*model.RealnameExport, 0, len(mids))
	for _, mid := range mids {
		export := &model.RealnameExport{
			Mid: mid,
		}

		// passport
		func() {
			p, ok := pinfos[mid]
			if !ok {
				log.Warn("Failed to get passport info with mid: %d", mid)
				return
			}
			export.UserID = p.Userid
			export.Uname = p.Name
			export.Tel = p.Tel
		}()

		// realname
		func() {
			info, ok := infos[mid]
			if !ok {
				log.Warn("Failed to get realname info with mid: %d", mid)
				return
			}
			export.Realname = info.Realname
			export.CardType = info.CardType

			cardDecode, err := model.CardDecrypt(info.Card)
			if err != nil {
				log.Error("Failed to decrypt card: %s: %+v", info.Card, err)
				return
			}
			export.CardNum = cardDecode
		}()

		res = append(res, export)
	}
	return res, nil
}

// RealnameSubmit is
func (s *Service) RealnameSubmit(ctx context.Context, arg *model.ArgRealnameSubmit) error {
	encryptedCardNum, err := s.realnameCrypto.CardEncrypt([]byte(arg.CardNum))
	if err != nil {
		return err
	}

	_ = func() error {
		front := &model.DBRealnameApplyIMG{IMGData: asIMGData(arg.FrontImageToken)}
		if err := s.dao.AddRealnameIMG(ctx, front); err != nil {
			return err
		}
		back := &model.DBRealnameApplyIMG{IMGData: asIMGData(arg.BackImageToken)}
		if err := s.dao.AddRealnameIMG(ctx, back); err != nil {
			return err
		}
		apply := &model.DBRealnameApply{
			MID:          arg.Mid,
			Realname:     arg.Realname,
			Country:      arg.Country,
			CardType:     arg.CardType,
			CardNum:      string(encryptedCardNum),
			CardMD5:      cardMD5(arg.CardNum, int(arg.CardType), int(arg.Country)),
			FrontIMG:     front.ID,
			BackIMG:      back.ID,
			Status:       model.RealnameApplyStatePassed.DBStatus(),
			Operator:     arg.Operator,
			OperatorID:   arg.OperatorID,
			OperatorTime: time.Now(),
		}
		if arg.HandImageToken != "" {
			hand := &model.DBRealnameApplyIMG{IMGData: asIMGData(arg.HandImageToken)}
			if err := s.dao.AddRealnameIMG(ctx, hand); err != nil {
				return err
			}
			apply.HandIMG = hand.ID
		}
		if err := s.dao.AddRealnameApply(ctx, apply); err != nil {
			return err
		}
		info := &model.DBRealnameInfo{
			MID:      apply.MID,
			Channel:  model.ChannelMain.DBChannel(),
			Realname: apply.Realname,
			Country:  apply.Country,
			CardType: apply.CardType,
			Card:     apply.CardNum,
			CardMD5:  apply.CardMD5,
			Status:   model.RealnameApplyStatePassed.DBStatus(),
			Reason:   fmt.Sprintf("管理后台提交：%s", arg.Remark),
		}
		return s.dao.SubmitRealnameInfo(ctx, info)
	}

	toOld := func() error {
		front := &model.DeDeIdentificationCardApplyImg{IMGData: asIMGData(arg.FrontImageToken)}
		if err := s.dao.AddOldRealnameIMG(ctx, front); err != nil {
			return err
		}
		back := &model.DeDeIdentificationCardApplyImg{IMGData: asIMGData(arg.BackImageToken)}
		if err := s.dao.AddOldRealnameIMG(ctx, back); err != nil {
			return err
		}
		apply := &model.DeDeIdentificationCardApply{
			MID:           arg.Mid,
			Realname:      arg.Realname,
			Type:          arg.CardType,
			CardData:      string(encryptedCardNum),
			CardForSearch: cardMD5(arg.CardNum, int(arg.CardType), int(arg.Country)),
			FrontImg:      front.ID,
			BackImg:       back.ID,
			ApplyTime:     int32(time.Now().Unix()),
			Operator:      arg.Operator,
			OperatorTime:  int32(time.Now().Unix()),
			Status:        int8(model.RealnameApplyStatePassed.DBStatus()),
			Remark:        fmt.Sprintf("管理后台提交：%s", arg.Remark),
		}
		if arg.HandImageToken != "" {
			hand := &model.DeDeIdentificationCardApplyImg{IMGData: asIMGData(arg.HandImageToken)}
			if err := s.dao.AddOldRealnameIMG(ctx, hand); err != nil {
				return err
			}
			apply.FrontImg2 = hand.ID
		}
		if err := s.dao.AddOldRealnameApply(ctx, apply); err != nil {
			return err
		}
		info := &model.DBRealnameInfo{
			MID:      apply.MID,
			Channel:  model.ChannelMain.DBChannel(),
			Realname: apply.Realname,
			Country:  arg.Country,
			CardType: arg.CardType,
			Card:     apply.CardData,
			CardMD5:  apply.CardForSearch,
			Status:   model.RealnameApplyStatePassed.DBStatus(),
			Reason:   fmt.Sprintf("管理后台提交：%s", arg.Remark),
		}
		return s.dao.SubmitRealnameInfo(ctx, info)
	}

	if err := toOld(); err != nil {
		return err
	}

	report.Manager(&report.ManagerInfo{
		Uname:    arg.Operator,
		UID:      arg.OperatorID,
		Business: model.RealnameManagerLogID,
		Type:     0,
		Oid:      arg.Mid,
		Action:   model.LogActionRealnameSubmit,
		Ctime:    time.Now(),
	})

	return nil
}

// RealnameFileUpload is
func (s *Service) RealnameFileUpload(ctx context.Context, mid int64, data []byte) (src string, err error) {
	var (
		md5Engine = md5.New()
		hashMID   string
		hashRand  string
		fileName  string
		dirPath   string
		dateStr   string
	)
	md5Engine.Write([]byte(strconv.FormatInt(mid, 10)))
	hashMID = hex.EncodeToString(md5Engine.Sum(nil))
	md5Engine.Reset()
	md5Engine.Write([]byte(strconv.FormatInt(time.Now().Unix(), 10)))
	md5Engine.Write([]byte(strconv.FormatInt(mrand.Int63n(1000000), 10)))
	hashRand = hex.EncodeToString(md5Engine.Sum(nil))
	fileName = fmt.Sprintf("%s_%s.txt", hashMID[:6], hashRand)
	dateStr = time.Now().Format("20060102")
	dirPath = fmt.Sprintf("%s/%s/", s.c.Realname.DataDir, dateStr)

	var (
		dataFile      *os.File
		writeFileSize int
		encrptedData  []byte
	)

	_, err = os.Stat(dirPath)
	if os.IsNotExist(err) {
		mask := syscall.Umask(0)
		defer syscall.Umask(mask)
		if err = os.MkdirAll(dirPath, 0777); err != nil {
			err = errors.WithStack(err)
			return
		}
	}
	if encrptedData, err = s.mainCryptor.IMGEncrypt(data); err != nil {
		err = errors.WithStack(err)
		return
	}
	if dataFile, err = os.Create(dirPath + fileName); err != nil {
		err = errors.Wrapf(err, "create file %s failed", dirPath+fileName)
		return
	}
	defer dataFile.Close()
	if writeFileSize, err = dataFile.Write(encrptedData); err != nil {
		err = errors.Wrapf(err, "write file %s size %d failed", dirPath+fileName, len(encrptedData))
		return
	}
	if writeFileSize != len(encrptedData) {
		err = errors.Errorf("Write file data to %s , expected %d actual %d", dirPath+fileName, len(encrptedData), writeFileSize)
		return
	}
	src = fmt.Sprintf("%s/%s", dateStr, strings.TrimSuffix(fileName, ".txt"))
	return
}

func asIMGData(imgToken string) string {
	return model.RealnameImgPrefix + imgToken + model.RealnameImgSuffix
}

func asIMGToken(IMGData string) string {
	token := strings.TrimPrefix(IMGData, "/idenfiles/")
	token = strings.TrimSuffix(token, ".txt")
	return token
}

// StripImage is
func StripImage(raw []byte) ([]byte, error) {
	i, format, err := image.Decode(bytes.NewReader(raw))
	if err != nil {
		return nil, errors.WithStack(err)
	}

	out := &bytes.Buffer{}
	switch format {
	case "jpg", "jpeg":
		if err := jpeg.Encode(out, i, &jpeg.Options{Quality: jpeg.DefaultQuality}); err != nil {
			return nil, errors.WithStack(err)
		}
	default:
		return nil, errors.Errorf("Unsupported type: %s", format)
	}
	return out.Bytes(), nil
}