fohow_api/go/gopath/src/fohow.com/apps/init.go

package apps

import (
	"fmt"
	"fohow.com/apps/models/token_model"
	"regexp"
	"strings"
	// "time"

	"github.com/astaxie/beego"
	"github.com/astaxie/beego/context"
	"github.com/user_agent"
	// "github.com/uuid"
	// "fohow.com/apps/controllers/user_controller"
	// "fohow.com/apps/models/balance_model"
	"fohow.com/apps/models/channel_gzh_qrcode_model"
	"fohow.com/apps/models/user_model"
)

const (
	SessionUserKey   = "uid"
	SessionWxUserKey = "wxuid" //用于小程序
	// SessionWxXcxUserKey = "wxxcxuid"
	XcxSessionKey = "XcxSessionKey" // 小程序用于加密解密数据的key
)

var (
	// 共用
	ComNotAllow = []string{"notAllow", "权限不够，请联系管理员"}

	BindFail         = []string{"bindFail", "迁移失败，请联系管理员"}
	HasBind          = []string{"hasBind", "该会员编号已绑定会员"}
	DailySignRepeat  = []string{"dailySignRepeat", "已经领取过啦"}
	RedisError       = []string{"redisError", "redis初始化错误"}
	RedisGetError    = []string{"redisGetError", "redisGet错误"}
	RedisJsonError   = []string{"redisJsonError", "json转换错误"}
	OrderRefundError = []string{"orderRefundError", "退款失败"}
	OtherSNotAllow   = []string{"othersNotAllow", "非店长无法在专区下单！"}
	AlreadyShop      = []string{"alreadyShop", "您已经是店主，请勿重复申请"}
	AlreadyAgent     = []string{"alreadyShop", "该会员已是代理，请勿重复申请"}

	ShopNoRepit           = []string{"shopNoRepit", "请勿重复申请"}
	NoCart                = []string{"noCart", "请选择您需要结算的产品"}
	NoExist               = []string{"noExist", "该记录不存在"}
	TokenError            = []string{"tokenError", "生成令牌出错"}
	HasOver               = []string{"hasOver", "已结束"}
	NoShopSale            = []string{"noShopSale", "该商品非专区商品"}
	HasPaied              = []string{"hasPaied", "已支付"}
	AccountError          = []string{"accountError", "账户异常"}
	GongZhongHaoNoExist   = []string{"gongZhongHaoNoExist", "公众号不存在"}
	Error                 = []string{"error", "未知错误"}
	TypeError             = []string{"error", "类型错误"}
	CountError            = []string{"countError", "数量错误"}
	RegisterUserError     = []string{"registerUserError", "注册会员错误"}
	BindingWxPhoneError   = []string{"bindingWxPhone", "绑定失败"}
	XcxAuthorizeError     = []string{"XcxAuthorizeError", "授权失败"}
	PicVerifyCodeError    = []string{"picVerifyCodeError", "图片验证码错误"}
	WxUserInfoError       = []string{"wxUserInfoError", "微信会员信息错误！"}
	ChannelNotMatch       = []string{"channelNotMatch", "渠道不匹配"}
	ChanneloExist         = []string{"channelNoExist", "渠道不存在"}
	UploadFileError       = []string{"uploadFileError", "上传文件失败！"}
	UploadFileTypeInvalid = []string{"uploadFileTypeError", "上传文件类型错误！仅支持以下格式：doc|docx|pdf|ppt|pptx|zip"}
	UploadImgTypeInvalid  = []string{"uploadImgTypeError", "上传文件类型错误！仅支持以下格式：png|jpg|jpeg"}

	// 登录相关
	HasLogin            = []string{"hasLogin", "已登录"}
	HasLogout           = []string{"hasLogout", "已登出"}
	UserNeedLogin       = []string{"userNeedLogin", "授权无效，需要用户登录"}
	UserAuthorizeFailed = []string{"userAuthorizeFailed", "用户授权失败"}
	UserNeedTel         = []string{"userNeedTel", "需要用户绑定手机"}
	UserTelNotMatch     = []string{"userTelNotMatch", "手机号码不匹配，请使用当前登录用户的号码"}
	WxUserNeedLogin     = []string{"wxUserNeedLogin", "需要微信用户登录"}
	NotWeixinClient     = []string{"notWeixinClient", "不是微信客户端"}
	SignupNotOpen       = []string{"signupNotOpen", "注册暂未开放，敬请期待"}
	ProductErrorType    = []string{"productErrorType", "请您前往店铺专区下单"}

	// 支付相关
	PayWayNoMatch = []string{"payWayNoMatch", "请选择正确的支付方式"}
	//请输入充值数额
	RechargeCountWrong = []string{"rechargeCountWrong", "请输入充值数额"}
	// 关注
	WxUserNeedSubscribe = []string{"wxUserNeedSubscribe", "请先关注公众号"}
	TGDKjNeedSub        = []string{"TGDKjNeedSub", "请先进入公众号领取大刀"}

	BlackUser  = []string{"blackUser", "对不起，您已被拉黑"}
	BlackUrl   = []string{"blackUrl", "对不起，网址不允许访问"}
	BlackOrder = []string{"blackOrder", "该订单作弊，已被拉黑"}

	CreateOrderFail = []string{"createOrderFail", "创建订单失败"}

	OnlyPlayInWeixin = []string{"onlyPlayInWeixin", "只能在微信客户端进行"}
	OrderNotExist    = []string{"orderNotExist", "订单不存在"}
	OrderExist       = []string{"orderExist", "订单已存在"}
	DetailNotAllow   = []string{"detailNotAllow", "评论内容不能为空"}
	DetailHasCommend = []string{"detailHasCommend", "商品已评论"}

	PayFail               = []string{"payFail", "支付失败"}
	ParamsError           = []string{"paramsError", "参数错误"}
	ValidParamsError      = []string{"validateParamsError", "验证参数错误"}
	ParamsRequired        = []string{"paramsRequired", "缺少参数"}
	ProductStockZero      = []string{"productStockZero", "商品库存为零"}
	ProductStockNotEnough = []string{"productStockNotEnough", "商品库存不足"}
	ProductNotExist       = []string{"productNotExist", "产品不存在"}
	ProductNotApproved    = []string{"productNotApproved", "产品还未上架"}
	ProductOffSale        = []string{"productOffSale", "产品已经下架"}
	OverLimitCount        = []string{"overLimitCount", "超过限购数量"}
	SingleOverLimitCount  = []string{"singleOverLimitCount", "超过限购数量"}

	PurchasedReachLimit = []string{"purchasedReachLimit", "已购买总数已达到限购数量"}

	RedirectTo = []string{"redirectTo", "302跳转"}
	ReduceFail = []string{"reduceFail", "帮砍失败"}

	UserNotExist = []string{"userNotExist", "用户不存在"}

	AddressNotExist     = []string{"addressNotExist", "地址不存在"}
	UserAddressFull     = []string{"userAddressFull", "最多添加5条地址"}
	UploadUserHeadError = []string{"uploadUserHeadError", "上传头像错误"}
	AddressNotMatch     = []string{"addressNotMatch", "地址不匹配"}
	NotUnPay            = []string{"notUnPay", "无法支付，该订单已支付或者已过期"}
	NotRightPayWay      = []string{"notRightPayWay", "无法支付，该订单只支持微信支付"}
	HasAlreadyPay       = []string{"hasAlreadyPay", "该订单已支付过"}
	NotPayInTime        = []string{"notPayInTime", "没在规定时间内完成支付"}
	PayWayNotAllow      = []string{"payWayNotAllow", "不支持该支付方式"}
	PayNoAuthed         = []string{"payNoAuthed", "支付未授权"}
	PhoneInvalid        = []string{"phoneInvalid", "手机号码格式不正确"}
	PhoneExist          = []string{"phoneExist", "手机号码已被注册,请更换其他号码"}
	SMSInvalid          = []string{"smsInvalid", "短信验证码不正确"}
	CodesSendTooOften   = []string{"codesSendTooOften", "短信验证码发送过于频繁，请半小时后重试"}

	WxMenusCreatedFailed = []string{"wxMenusCreatedFailed", "微信菜单创建失败"}
	//小程序相关
	XcxGetSessionKeyError = []string{"xcxGetSessionKeyError", "获取session key失败"}

	RailAdminIPReduced            = []string{"railsAdminIPReduced", "拒绝此IP访问，权限不够"}
	TelCodesError                 = []string{"telCodeError", "验证码错误"}
	TelCodesTypeError             = []string{"telCodesTypeError", "验证码类型错误"}
	PasswordError                 = []string{"passwordError", "密码错误"}
	LoginPwdSameWithTradePwdError = []string{"loginPwdSameWithTradePwdError", "登录密码与交易密码不能相同，请重新设置"}
	OrginalPasswordError          = []string{"orginalPasswordError", "原始密码错误"}
	TelCodesExpired               = []string{"telCodeExpired", "验证码已过期"}
	LoginPasswordError            = []string{"loginPasswordError", "登录密码错误"}
	TradePasswordError            = []string{"tradePasswordError", "交易密码错误"}
	TradePasswordEmptry           = []string{"tradePasswordEmpty", "未设置交易密码"}
	UpdatePasswordError           = []string{"updatePasswordError", "更新密码出错"}
	PasswordLengthError           = []string{"passwordLengthError", "密码长度错误，需要6-20位"}
	GetCaptchaError               = []string{"getCaptchaError", "获取图片验证码错误"}

	BindingBankCardEmpty     = []string{"bindingBankCardEmpty", "绑定银行卡错误，请完善银行卡信息"}
	BindingWxUserError       = []string{"bindingWxUserError", "绑定微信错误，请重试"}
	BindingUserTelError      = []string{"bindingUserTelError", "绑定电话错误，请重试"}
	BindingIdCardEmpty       = []string{"bindingIdCardEmpty", "绑定身份证错误，请填写真实姓名及身份证号"}
	UserHasBindIdCard        = []string{"userHasBindIdCard", "该用户已绑定了身份证，请联系客服更改"}
	BindingIdCardExist       = []string{"bindingIdCardExist", "该身份证已被绑定，请更换其他身份证"}
	BindingIdCardLengthError = []string{"bindingIdCardLengthError", "身份证位数不合法"}
	BindingTelExisted        = []string{"bindingTelExisted", "该号码已绑定了微信用户，请尝试其他号码"}
	WxUserHasBindingTel      = []string{"wxUserHasBindingTel", "该微信用户已经绑定了手机，请勿重复绑定"}
	WxUserNotExist           = []string{"wxUserNotExist", "微信用户不存在"}
	WxUserNotRegistD5c       = []string{"wxUserNotRegistD5c", "用户在第五创没有绑定手机号码"}
	IdCardAgeNotBeAdult      = []string{"idCardAgeNotBeAdult", "未满18岁，身份认证失败"}

	// 工具tool相关
	DownloadError        = []string{"downloadError", "阿里云下载文件错误"}
	ConvertToBase64Error = []string{"convertToBase64Error", "转base64错误"}
	//资金账户相关
	CentNotEnough                    = []string{"centNotEnough", "积分余额不足"}
	BalanceNotExist                  = []string{"balanceNotExist", "资金明细不存在"}
	BalanceNotEnough                 = []string{"balanceNotEnough", "余额不足"}
	BalanceNotEnoughForCharge        = []string{"balanceNotEnoughForCharge", "可提现余额不足支付手续费，无法提现"}
	TakeCashAmountLessThanCharge     = []string{"balanceAmountLessThanCharge", "提现金额需大于手续费金额"}
	TakeCashAmountInvalid            = []string{"takeCashAmountInvalid", "提现金额不合法，仅支持小数点后两位。如：88.88"}
	RechargeAmountInvalid            = []string{"RechargeAmountInvalid", "充值金额不合法，仅支持小数点后两位。如：88.88"}
	BankCardNotFound                 = []string{"bankCardNotFound", "请先绑定银行卡"}
	BankCardNoInvalid                = []string{"bankCardNoInvalid", "银行卡号不合法，请重新输入"}
	BankCardNotMatch                 = []string{"bankCardNotMatch", "银行卡号不匹配，请使用实名认证的本人银行卡绑定，如认证信息有误，请联系客服更改"}
	BankCardHasNoRecordOnLianLianPay = []string{"bankCardHasNoRecordOnLianLianPay", "该银行卡在连连支付无记录，请先充值"}
	BankCardCountLimit               = []string{"bankCardCountLimit", "银行卡绑定数量限制"}
	CanNotDeleteDefaultBankCard      = []string{"canNotDeleteDefaultBankCard", "不能删除默认银行卡"}
	BankCardHasBound                 = []string{"bankCardHasBound", "该银行卡已有绑定记录"}
	BalanceToCashErr                 = []string{"balanceToCashErr", "余额转提货券失败"}

	//春节红包
	ActivityNotStart = []string{"activityNotStart", "活动尚未开始"}
	ActivityIsEnd    = []string{"activityIsEnd", "活动已经结束"}
	HasGotLuckyMoney = []string{"hasGotLuckyMoney", "你已经拿过红包了"}

	//商家
	OrderNotBelongToCurrentUser       = []string{"orderNotBelongToCurrentUser", "订单不属于当前用户。"}
	OrderStatusNotSuit                = []string{"orderStatusNotSuit", "只能处理待发货、待收货的订单"}
	OrderAlreadyDispatch              = []string{"orderAlreadyDispatch", "该订单已经被处理发货"}
	OrderAlreadyRefund                = []string{"orderAlreadyRefund", "该订单已经被处理退款"}
	OrderRefundFaild                  = []string{"orderRefundFaild", "退款失败，请联系客服"}
	CurrentMerIsNotSuperAdminMerchant = []string{"currentMerIsNotSuperAdminMerchant", "当前用户不是商家超级管理员"}
	CurrentMerIsNotManageTheProduct   = []string{"currentMerIsNotManageTheProduct", "当前用户不负责管理该商品"}
	//移动讯兑
	DataUnMarsha1Error = []string{"dataUnMarsha1Error", "数据解析错误"}

	//项目
	ProjectNoExist          = []string{"projectNoExist", "项目不存在"}
	ProjectInvestWayNoExist = []string{"projectInvestWayNoExist", "该资助方式不存在"}

	//微信公众号登录
	NetworkBusy = []string{"networkBusy", "对不起，网络繁忙，请稍后再试"}

	//秒杀活动
	SeckillNotStart = []string{"seckillNotStart", "秒杀活动尚未开始"}
	SeckillIsEnd    = []string{"seckillIsEnd", "秒杀活动已经结束"}
	SeckillNotAllow = []string{"seckillNotAllow", "秒杀商品不允许加入购物车"}

	OnlyNew        = []string{"onlyNew", "仅限新人购买"}
	OrderNotEnough = []string{"orderNotEnough", "订单金额不满足"}
	HasPatched     = []string{"hasPached", "已发放"}
)

type BaseController struct {
	beego.Controller
	OnlyCheckUserLoginAction     []string
	ExceptCheckUserLoginAction   []string
	OnlyCheckWxUserLoginAction   []string
	ExceptCheckWxUserLoginAction []string
	UserNeedLoginAction          []string
}

type Result struct {
	Status int           `json:"status"`
	Result []interface{} `json:"result"`
}

//定义正确结果集
func (self *BaseController) FormatResult(result []interface{}) *Result {
	return &Result{
		Status: 200,
		Result: result,
	}
}

func (self *BaseController) GetCurrentUserId() int64 {
	uId, _ := self.GetSession(SessionUserKey).(int64)
	return uId
}

func (self *BaseController) GetCurrentUser(useCache bool) *user_model.User {
	id := self.GetCurrentUserId()
	if id <= 0 {
		return nil
	}
	u := user_model.GetUserById(id, useCache)
	if u == nil {
		beego.BeeLogger.Error("User Not Found, uid=%d", id)
	}
	return u
}

func (self *BaseController) GetCurrentWxUserId() int64 {
	id, _ := self.GetSession(SessionWxUserKey).(int64)
	return id
}

func (self *BaseController) GetCurrentWxUser(useCache bool) *user_model.WxUser {
	id := self.GetCurrentWxUserId()
	if id <= 0 {
		return nil
	}
	u := user_model.GetWxUserById(id, useCache)
	if u == nil {
		beego.BeeLogger.Error("WxUser Not Found, id=%d", id)
	}
	return u
}

//sceneId, 关注场景id
func (self *BaseController) CheckWxUserSubscribe(sceneId int64) {
	beego.BeeLogger.Info("check wx_user subscribe")
	ctx := self.Ctx
	if !isWxClient(ctx) {
		return
	}
	wxUserId, ok := ctx.Input.Session(SessionWxUserKey).(int64)
	if ok {
		wxUser := user_model.GetWxUserById(wxUserId, false)
		if wxUser == nil {
			beego.BeeLogger.Error("WxUser Not Found, id=%d", wxUserId)
		} else {
			if wxUser.Subscribe == 0 {
				qrcode := channel_gzh_qrcode_model.GetBySceneId(sceneId, true)
				if qrcode == nil {
					//默认二维码
					qrcode = channel_gzh_qrcode_model.GetBySceneId(25, true)
				}
				qrcodeUrl := qrcode.QrcodeImg
				errCode := &ErrCode{
					Code:     WxUserNeedSubscribe[0],
					Msg:      WxUserNeedSubscribe[1],
					Redirect: qrcodeUrl,
					Data:     nil,
				}
				ctx.Output.SetStatus(403)
				ctx.Output.JSON(errCode, true, true)
				self.StopRun()
			}
		}
	} else {
		beego.BeeLogger.Error("WxUser Not Login")
	}
}

func checkWxUserLogin(ctx *context.Context) {
	//beego.BeeLogger.Info("show the request : %s from UserAgent: %s", ctx.Input.URI(), ctx.Input.UserAgent())
	//检测 token 是否合法
	var inputToken string
	beego.BeeLogger.Warn("request authorizationData : %s", ctx.Request.Header.Get("Authorization"))
	requestAuthordata := ctx.Request.Header.Get("Authorization")
	if len(requestAuthordata) > 0 {
		authorizationData := strings.SplitN(ctx.Request.Header.Get("Authorization"), " ", 2)
		if len(authorizationData) != 2 {
			errCode := &ErrCode{
				Code:     UserNeedLogin[0],
				Msg:      UserNeedLogin[1],
				Redirect: "",
				Data:     nil,
			}
			//换成userNeedLogin
			ctx.Output.SetStatus(403)
			ctx.Output.JSON(errCode, true, true)
		} else {
			inputToken = authorizationData[1]
			var wxUser *user_model.WxUser
			user_token, err := token_model.ValidateToken(inputToken)
			wxUser = user_model.GetWxUserById(user_token.Id, true)
			if err != nil || wxUser == nil {
				beego.BeeLogger.Warn("token error : %v", err)
				// 验证 Token 无效
				errCode := &ErrCode{
					Code:     UserNeedLogin[0],
					Msg:      UserNeedLogin[1],
					Redirect: "",
					Data:     nil,
				}
				ctx.Output.SetStatus(403)
				ctx.Output.JSON(errCode, true, true)
			} else {
				ctx.Output.Session(SessionUserKey, wxUser.UserId)
				ctx.Output.Session(SessionWxUserKey, wxUser.Id)
			}
		}
	} else {
		errCode := &ErrCode{
			Code:     UserNeedLogin[0],
			Msg:      UserNeedLogin[1],
			Redirect: "",
			Data:     nil,
		}
		ctx.Output.SetStatus(401)
		ctx.Output.JSON(errCode, true, true)
	}
	return
}

func checkUserLogin(ctx *context.Context) {
	beego.BeeLogger.Info("check user login")
	userId, ok := ctx.Input.Session(SessionUserKey).(int64)
	if ok {
		_, ok := ctx.Input.Session(SessionWxUserKey).(int64)
		if !ok {
			beego.BeeLogger.Info("user has login, try to set seesion[wx_user]")
			// 如果用户登录了，且有绑定了wx_user，则设置微信用户登录
			wxUser := user_model.GetWxUserByUserId(userId, true)
			if wxUser != nil {
				ctx.Output.Session(SessionWxUserKey, wxUser.Id)
			}
		}
	} else {
		_, ok := ctx.Input.Session(SessionWxUserKey).(int64)
		if ok {
			beego.BeeLogger.Info("user not login, wx_user is login,and try to ask user binding tel.")
			// 如果用户没登录了，但采用微信账户登录，则需要微信用户绑定手机从而创建用户记录
			errCode := &ErrCode{
				Code:     UserNeedTel[0],
				Msg:      UserNeedTel[1],
				Redirect: fmt.Sprintf("%s/user/binding/state", beego.AppConfig.String("WWWHost")),
				Data:     nil,
			}
			ctx.Output.SetStatus(401)
			ctx.Output.JSON(errCode, true, true)
			return
		}
		errCode := &ErrCode{
			Code:     UserNeedLogin[0],
			Msg:      UserNeedLogin[1],
			Redirect: "",
			Data:     nil,
		}
		ctx.Output.SetStatus(401)
		ctx.Output.JSON(errCode, true, true)
		return
	}
}

//检查来自大后台的请求是否为服务器IP
func CheckIsInvokeFromRailsAdmin(ctx *context.Context) {
	s := strings.Split(ctx.Request.RemoteAddr, ":")
	ip := s[0]
	beego.BeeLogger.Debug("railsadmin request ip is: %s", ip)
	if ip != beego.AppConfig.String("RailsAdminAddr") {
		errCode := &ErrCode{
			Code:     RailAdminIPReduced[0],
			Msg:      RailAdminIPReduced[1],
			Redirect: "",
			Data:     nil,
		}
		ctx.Output.SetStatus(403)
		ctx.Output.JSON(errCode, true, true)
	}
}

func (self *BaseController) Prepare() {
	//beego.BeeLogger.Info("invote controller Prepare func")
	needChkWxUserLogin := true
	//needChkUserLogin := true
	// needChkWxUserSubscribe := false
	_, actionName := self.GetControllerAndAction()

	if len(self.ExceptCheckWxUserLoginAction) > 0 {
		for _, an := range self.ExceptCheckWxUserLoginAction {
			if strings.ToLower(an) == "*" || strings.ToLower(an) == strings.ToLower(actionName) {
				needChkWxUserLogin = false
				break
			}
		}
	}

	if needChkWxUserLogin {
		checkWxUserLogin(self.Ctx)
	}

}

type ErrCode struct {
	Status   int               `json:"status"`
	Code     string            `json:"err_code"`
	Msg      string            `json:"err_msg"`
	Redirect string            `json:"redirect_to"`
	Data     map[string]string `json:"data"`
}

//定义返回错误信息
func (self *BaseController) ReturnError(status int, code []string, redirect string, data map[string]string) {
	errCode := &ErrCode{
		Status:   status,
		Code:     code[0],
		Msg:      code[1],
		Redirect: redirect,
		Data:     data,
	}
	// jsonErrCode, err := json.Marshal(errCode)
	// if err != nil {
	// 	beego.BeeLogger.Error("json encode error=[%s]", err)
	// }
	self.Ctx.Output.SetStatus(status)
	// self.Ctx.Output.Header("Content-Type", "application/json; charset=utf-8")
	self.Ctx.Output.JSON(errCode, true, true)
	self.StopRun()
	// self.ServeJson(status, string(jsonErrCode))
}

//TODO校验是否微信客户端
func (self *BaseController) IsWxClient() bool {
	return isWxClient(self.Ctx)
}

//TODO校验是否微信客户端
func isWxClient(ctx *context.Context) bool {
	agent := ctx.Input.UserAgent()
	b := getRealBrowser(agent)
	isWxClient := b == "wx"
	return isWxClient
}

// 是否是手机端
func (self *BaseController) IsMobile() bool {
	ua := strings.ToLower(self.Ctx.Input.UserAgent())
	if ua == "" {
		return true
	}
	ok, _ := regexp.MatchString("iphone|nokia|sony|ericsson|mot|samsung|sgh|lg|philips|panasonic|alcatel|lenovo|cldc|midp|wap|mobile", ua)
	return ok
}

// 是否是开发模式
func (self *BaseController) IsDev() bool {
	//return beego.BConfig.RunMode == beego.DEV
	return beego.AppConfig.String("Env") != "production"
}

func getRealBrowser(ua string) string {
	userAgent := user_agent.New(ua)
	browser, _ := userAgent.Browser()
	browser = strings.ToLower(browser)
	if browser == "internet explorer" {
		browser = "ie"
	}
	lowerUa := strings.ToLower(ua)
	// beego.BeeLogger.Warning("ua=%s", lowerUa)
	if strings.Contains(lowerUa, "micromessenger") {
		browser = "wx"
	}
	if strings.Contains(lowerUa, "wechatdevtools") {
		browser = "wx"
	}
	return browser
}

func (self *BaseController) GetFullImgUrl(img string) string {
	if img == "" {
		return ""
	}
	if strings.HasPrefix(img, "http://") || strings.HasPrefix(img, "https://") {
		return img
	} else {
		return fmt.Sprintf("%s/%s", beego.AppConfig.String("AliCDNImgHost"), img)
	}
}

func (self *BaseController) GetCdnFullImgUrl(img string) string {
	if img == "" {
		return ""
	}
	if strings.HasPrefix(img, "http://") || strings.HasPrefix(img, "https://") {
		return img
	} else {
		return fmt.Sprintf("%s/%s", beego.AppConfig.String("AliCDNImgHost"), img)
	}
}

// ServeJSON sends a json response with encoding charset.
func (c *BaseController) ServeResultJSON(encoding ...bool) {
	from := c.GetString("source")
	beego.BeeLogger.Warn("from--%s", from)
	type Result struct {
		Result interface{} `json:"result"`
	}
	var (
		hasIndent   = true
		hasEncoding = false
	)
	if beego.AppConfig.String("RunMode") == "prod" {
		hasIndent = false
	}
	if len(encoding) > 0 && encoding[0] == true {
		hasEncoding = true
	}
	if from == beego.AppConfig.String("SourceList") {
		c.Data["json"] = &Result{Result: c.Data["json"]}
	}
	c.Ctx.Output.JSON(c.Data["json"], hasIndent, hasEncoding)
}