fohow_api/go/gopath/src/fohow.com/apps/models/balance_model/takecash.go

package balance_model

import (
	"fmt"
	"time"

	"github.com/astaxie/beego"
	"github.com/astaxie/beego/orm"

	"fohow.com/cache"
)

const (
	take_cash_orders_tablename = "take_cash_orders"

	ORDER_ID_PREFIX_TX = "TX" //提现

	//状态：提现失败(pay_state:0,audit_state:2), 提现中(pay_state:0,audit_state:0,1), 已完成(pay_state:1, audit_state:1)
	STATE_CN_REJECTED    = "提现失败"
	STATE_CN_IN_PROGRESS = "提现中"
	STATE_CN_SUCESS      = "已完成"

	TAKE_CASH_LIMIT = 1        //每天提现次数限制
	AUTOTAKE_STATE  = int64(1) //自动提现状态

	REAL_STATE = int64(0) //强制检验

	TAKE_CASH_TIMEOUT_REMARK = "超时未确认，请您重新提现！"
)

type TakeCashOrder struct {
	Id         int64     `orm:"column(id);pk"                                       json:"id"`           // int(11)
	WxUId      int64     `orm:"column(wx_uid)"                                      json:"wx_uid"`       // int(11)
	OrderId    string    `orm:"column(order_id)"                                    json:"order_id"`     // varchar(64)
	TradeNo    string    `orm:"column(trade_no);null"                               json:"trade_no"`     // varchar(64)
	Count      int64     `orm:"column(count);null"                                  json:"count"`        // bigint(20)
	FeiCount   int64     `orm:"column(fei_count)"                                   json:"fei_count"`    // int(11)
	FreeCount  int64     `orm:"column(free_count)"                                  json:"free_count"`   // int(11)
	Fee        int64     `orm:"column(fee);null"                                    json:"fee"`          // bigint(20)
	State      int64     `orm:"column(pay_state);null"                              json:"pay_state"`    // tinyint(1)
	RealState  int64     `orm:"column(real_state);null"                              json:"-"`           // tinyint(1)
	AuditState int64     `orm:"column(audit_state);null"                            json:"audit_state"`  // tinyint(1)
	PaiedAt    int64     `orm:"column(paied_at);null"                               json:"paied_at"`     // int(11)
	Remark     string    `orm:"column(remark);null"                                 json:"remark"`       // varchar(255)
	ExpcPayAt  time.Time `orm:"column(expc_pay_at);null;auto_now_add;type(datetime)" json:"expc_pay_at"` // datetime
	//银行信息
	BankName    string    `orm:"column(bank_name)"     json:"bank_name"`
	BankAccount string    `orm:"column(bank_account)"     json:"bank_account"`
	AccountName string    `orm:"column(account_name)"     json:"account_name"`
	CreatedAt   time.Time `orm:"column(created_at);null;auto_now_add;type(datetime)" json:"created_at"` // datetime
	UpdatedAt   time.Time `orm:"column(updated_at);null;auto_now;type(datetime)"     json:"updated_at"` // datetime
}

func (self *TakeCashOrder) TableName() string {
	return take_cash_orders_tablename
}

func (self *TakeCashOrder) Create(wxUId, count, feiCount, freeCount int64) (item *TakeCashOrder) {
	oId := createOrderId(ORDER_ID_PREFIX_TX)
	item = &TakeCashOrder{
		Count:     count,
		FeiCount:  feiCount,
		FreeCount: freeCount,
		WxUId:     wxUId,
		OrderId:   oId,
		RealState: REAL_STATE,
	}

	id, err := orm.NewOrm().Insert(item)
	if err != nil {
		beego.BeeLogger.Error("Create TakeCashOrder err=[%s]", err)
		return nil
	}
	item.Id = id
	return item
}

func (self *TakeCashOrder) Save() error {
	if _, err := orm.NewOrm().Update(self); err != nil {
		beego.BeeLogger.Error("Save take cash order id=[%d] .err=[%s]", self.Id, err)
		return err
	}
	return nil
}

// 状态值中文
func (self *TakeCashOrder) GetStateCn() string {
	stateCn := ""
	switch self.State {
	case 0:
		switch self.AuditState {
		case 0:
			stateCn = STATE_CN_IN_PROGRESS

		case 1:
			stateCn = STATE_CN_IN_PROGRESS

		case 2:
			stateCn = STATE_CN_REJECTED
		}
	case 1:
		switch self.AuditState {
		case 1:
			stateCn = STATE_CN_SUCESS
		}
	case 2:
		stateCn = STATE_CN_REJECTED
	}

	return stateCn
}

func GetTakeCashOrderByOId(oId string, useCache bool) *TakeCashOrder {
	k := fmt.Sprintf("balance_model.GetTakeCashOrderByOId[%s]", oId)
	if useCache {
		if order, ok := cache.Cache.Get(k).(*TakeCashOrder); ok {
			return order
		}
	}
	order := new(TakeCashOrder)
	o := orm.NewOrm()
	err := o.QueryTable(order).Filter("order_id", oId).Limit(1).One(order)
	if err != nil {
		beego.Debug("GetOrderByOrderId is not found err=[%s], oId=%s", err, oId)
		return nil
	} else {
		cache.Cache.Put(k, order, 5*time.Minute)
		return order
	}
}

func GetTakeCashOrderById(id int64, useCache bool) *TakeCashOrder {
	k := fmt.Sprintf("balance_model.GetTakeCashOrderById[%d]", id)
	if useCache {
		if order, ok := cache.Cache.Get(k).(*TakeCashOrder); ok {
			return order
		}
	}
	order := new(TakeCashOrder)
	o := orm.NewOrm()
	err := o.QueryTable(order).Filter("id", id).Limit(1).One(order)
	if err != nil {
		beego.Debug("GetTakeCashOrderById is not found err=[%s], id=%d", err, id)
		return nil
	} else {
		cache.Cache.Put(k, order, 5*time.Minute)
		return order
	}
}

// 获取某人的提现流列表
func GetTakeCashOrderListByWxUId(wxUId, page, perPage int64, useCache bool) (list []*TakeCashOrder) {
	k := fmt.Sprintf("balance_model.GetTakeCashOrderListByWxUId.wxUId(%d).page(%d).perPage(%d)", wxUId, page, perPage)
	if useCache {
		if s, ok := cache.Cache.Get(k).([]*TakeCashOrder); ok {
			return s
		}
	}

	order := new(TakeCashOrder)
	qs := orm.NewOrm().QueryTable(order)
	qs = qs.Filter("wx_uid", wxUId)

	if _, err := qs.OrderBy("-created_at", "-id").
		Limit(perPage, (page-1)*perPage).All(&list); err != nil {
		beego.BeeLogger.Debug("get GetTakeCashOrderListByWxUId with wxUId=%d, err=[%s]", wxUId, err)
		return nil
	}

	cache.Cache.Put(k, list, 5*time.Minute)
	return list
}

// 获取某人的提现流列表总条数
func GetTakeCashOrderCountByWxUId(wxUId int64, useCache bool) int64 {

	k := fmt.Sprintf("balance_model.GetTakeCashOrderCountByWxUId.wxUId(%d)", wxUId)
	if useCache {
		if s, ok := cache.Cache.Get(k).(int64); ok {
			return s
		}
	}

	item := new(TakeCashOrder)
	o := orm.NewOrm()
	count, _ := o.QueryTable(item).Filter("wx_uid", wxUId).Count()

	if count > 0 {
		cache.Cache.Put(k, count, 5*time.Minute)
	}
	return count
}

func GetTakeCashOrderListByWxUIdAndTime(wxUId int64, now time.Time, useCache bool) (list []*TakeCashOrder) {

	k := fmt.Sprintf("balance_model.GetTakeCashOrderListByWxUIdAndTime.wxUId(%d).nowDay(%s)", wxUId, now.Format("2006-01-02"))
	if useCache {
		if s, ok := cache.Cache.Get(k).([]*TakeCashOrder); ok {
			return s
		}
	}

	qs := orm.NewOrm()

	sql :=
		`
			SELECT
				*
			FROM
				take_cash_orders
			WHERE
				wx_uid = ?
			AND DATE_FORMAT(
				DATE_ADD(created_at, INTERVAL 8 HOUR),
				'%Y-%m-%d'
			) = ?
			LIMIT ?;

		`

	if _, err := qs.Raw(sql, wxUId, now.Format("2006-01-02")).QueryRows(&list); err != nil {
		beego.BeeLogger.Debug("get GetTakeCashOrderListByWxUIdAndTime with wxUId=%d, err=[%s]", wxUId, err)
		return nil
	}

	if len(list) > 0 {
		cache.Cache.Put(k, list, 5*time.Minute)
	}
	return list

}

// 取正在提现的订单列表
func GetAllTakingCashOrders() (list []*TakeCashOrder) {
	sql := fmt.Sprintf("select * from %s where pay_state=? and audit_state=? and expc_pay_at < ?", take_cash_orders_tablename)
	if _, err := orm.NewOrm().Raw(sql, 0, 1, time.Now().Add(-8*time.Hour)).QueryRows(&list); err != nil {
		return nil
	}
	return list
}

// 取超过24小时仍未完成的提现订单，避免继续审核或继续等待已过期的微信确认收款。
func GetTimeoutTakingCashOrders(limit int) (list []*TakeCashOrder) {
	if limit <= 0 {
		limit = 100
	}
	sql := fmt.Sprintf("SELECT * FROM %s WHERE pay_state=? AND audit_state=? AND created_at < DATE_SUB(NOW(), INTERVAL 24 HOUR) ORDER BY created_at ASC, id ASC LIMIT ?", take_cash_orders_tablename)
	if _, err := orm.NewOrm().Raw(sql, 0, 1, limit).QueryRows(&list); err != nil {
		beego.BeeLogger.Error("GetTimeoutTakingCashOrders err=[%s]", err)
		return nil
	}
	return list
}

func MarkTakeCashOrderTimeout(orderId string) (bool, error) {
	tbn := new(TakeCashOrder).TableName()
	sql := fmt.Sprintf("UPDATE `%s` SET `pay_state`=2, `remark`=?, `updated_at`=NOW() WHERE `order_id`=? AND `pay_state`=0 AND `audit_state`=1 LIMIT 1", tbn)
	res, err := orm.NewOrm().Raw(sql, TAKE_CASH_TIMEOUT_REMARK, orderId).Exec()
	if err != nil {
		beego.BeeLogger.Error("MarkTakeCashOrderTimeout order_id=[%s] err=[%s]", orderId, err)
		return false, err
	}
	rows, err := res.RowsAffected()
	if err != nil {
		beego.BeeLogger.Error("MarkTakeCashOrderTimeout rows affected order_id=[%s] err=[%s]", orderId, err)
		return false, err
	}
	return rows > 0, nil
}

// 充值账户余额
func GetTakeFeeBalance(wxUId int64) int64 {
	type Ret struct {
		Count int64
	}
	ret := &Ret{}
	o := orm.NewOrm()
	tbn := new(TakeCashOrder).TableName()
	sql := fmt.Sprintf("SELECT sum(`free_count`) as count FROM `%s` WHERE wx_uid=?;", tbn)
	err := o.Raw(sql, wxUId).QueryRow(ret)
	if err != nil {
		beego.BeeLogger.Error("GetTakeFeeBalance, wxUser:%d err=[%s]", wxUId, err)
		return 0
	}
	if ret.Count < 0 {
		return 0
	}
	return ret.Count
}