// Code generated by $GOPATH/src/go-common/app/tool/cache/gen. DO NOT EDIT.

/*
  Package dao is a generated cache proxy package.
  It is generated from:
  type _cache interface {
		// cache: -nullcache=&model.Promotion{PromoID:-1} -check_null_code=$!=nil&&$.PromoID==-1
		Promo(c context.Context, promoID int64) (*model.Promotion, error)
		// cache: -nullcache=&model.PromotionGroup{GroupID:-1} -check_null_code=$!=nil&&$.GroupID==-1
		PromoGroup(c context.Context, groupID int64) (*model.PromotionGroup, error)
		// cache: -nullcache=&model.PromotionOrder{OrderID:-1} -check_null_code=$!=nil&&$.OrderID==-1
		PromoOrder(c context.Context, orderID int64) (*model.PromotionOrder, error)
		// cache: -nullcache=[]*model.PromotionOrder{{GroupID:-1}} -check_null_code=len($)==1&&$[0].GroupID==-1
		PromoOrders(c context.Context, groupID int64) ([]*model.PromotionOrder, error)

		// cache: -nullcache=[]*model.OrderMain{{OrderID:-1}} -check_null_code=len($)==1&&$[0].OrderID==-1
		Orders(context.Context, *model.OrderMainQuerier) ([]*model.OrderMain, error)
		// cache: -nullcache=-1 -check_null_code=$==-1
		OrderCount(context.Context, *model.OrderMainQuerier) (int64, error)
		// cache: -nullcache=&model.OrderDetail{OrderID:0} -check_null_code=$!=nil&&$.OrderID==0
		OrderDetails(context.Context, []int64) (map[int64]*model.OrderDetail, error)
		// cache: -nullcache=[]*model.OrderSKU{{OrderID:-1}} -check_null_code=len($)==1&&$[0].OrderID==-1
		OrderSKUs(context.Context, []int64) (map[int64][]*model.OrderSKU, error)
		// cache: -nullcache=&model.OrderPayCharge{ChargeID:""} -check_null_code=$!=nil&&$.ChargeID==""
		OrderPayCharges(context.Context, []int64) (map[int64]*model.OrderPayCharge, error)

		// cache:
		SkuByItemID(c context.Context, itemID int64) (map[string]*model.SKUStock, error)
		// cache:
		GetSKUs(c context.Context, skuIds []int64, withNewStock bool) (map[int64]*model.SKUStock, error)
		// cache:
		Stocks(c context.Context, keys []int64, isLocked bool) (res map[int64]int64, err error)

		// cache: -nullcache=[]*model.Ticket{{ID:-1}} -check_null_code=len($)==1&&$[0].ID==-1
		TicketsByOrderID(c context.Context, orderID int64) (res []*model.Ticket, err error)
		// cache: -nullcache=[]*model.Ticket{{ID:-1}} -check_null_code=len($)==1&&$[0].ID==-1
		TicketsByScreen(c context.Context, screenID int64, UID int64) (res []*model.Ticket, err error)
		// cache: -nullcache=&model.Ticket{ID:-1} -check_null_code=$!=nil&&$.ID==-1
		TicketsByID(c context.Context, id []int64) (res map[int64]*model.Ticket, err error)
		// cache: -nullcache=&model.TicketSend{ID:-1} -check_null_code=$!=nil&&$.ID==-1
		TicketSend(c context.Context, SendTID []int64, TIDType string) (res map[int64]*model.TicketSend, err error)
	}
*/

package dao

import (
	"context"

	"go-common/app/service/openplatform/ticket-sales/model"
	"go-common/library/net/metadata"
	"go-common/library/stat/prom"
)

var _ _cache

// Promo get data from cache if miss will call source method, then add to cache.
func (d *Dao) Promo(c context.Context, id int64) (res *model.Promotion, err error) {
	addCache := true
	res, err = d.CachePromo(c, id)
	if err != nil {
		addCache = false
		err = nil
	}
	defer func() {
		if res != nil && res.PromoID == -1 {
			res = nil
		}
	}()
	if res != nil {
		prom.CacheHit.Incr("Promo")
		return
	}
	prom.CacheMiss.Incr("Promo")
	res, err = d.RawPromo(c, id)
	if err != nil {
		return
	}
	miss := res
	if miss == nil {
		miss = &model.Promotion{PromoID: -1}
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCachePromo(metadata.WithContext(c), id, miss)
	})
	return
}

// PromoGroup get data from cache if miss will call source method, then add to cache.
func (d *Dao) PromoGroup(c context.Context, id int64) (res *model.PromotionGroup, err error) {
	addCache := true
	res, err = d.CachePromoGroup(c, id)
	if err != nil {
		addCache = false
		err = nil
	}
	defer func() {
		if res != nil && res.GroupID == -1 {
			res = nil
		}
	}()
	if res != nil {
		prom.CacheHit.Incr("PromoGroup")
		return
	}
	prom.CacheMiss.Incr("PromoGroup")
	res, err = d.RawPromoGroup(c, id)
	if err != nil {
		return
	}
	miss := res
	if miss == nil {
		miss = &model.PromotionGroup{GroupID: -1}
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCachePromoGroup(metadata.WithContext(c), id, miss)
	})
	return
}

// PromoOrder get data from cache if miss will call source method, then add to cache.
func (d *Dao) PromoOrder(c context.Context, id int64) (res *model.PromotionOrder, err error) {
	addCache := true
	res, err = d.CachePromoOrder(c, id)
	if err != nil {
		addCache = false
		err = nil
	}
	defer func() {
		if res != nil && res.OrderID == -1 {
			res = nil
		}
	}()
	if res != nil {
		prom.CacheHit.Incr("PromoOrder")
		return
	}
	prom.CacheMiss.Incr("PromoOrder")
	res, err = d.RawPromoOrder(c, id)
	if err != nil {
		return
	}
	miss := res
	if miss == nil {
		miss = &model.PromotionOrder{OrderID: -1}
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCachePromoOrder(metadata.WithContext(c), id, miss)
	})
	return
}

// PromoOrders get data from cache if miss will call source method, then add to cache.
func (d *Dao) PromoOrders(c context.Context, id int64) (res []*model.PromotionOrder, err error) {
	addCache := true
	res, err = d.CachePromoOrders(c, id)
	if err != nil {
		addCache = false
		err = nil
	}
	defer func() {
		if len(res) == 1 && res[0].GroupID == -1 {
			res = nil
		}
	}()
	if len(res) != 0 {
		prom.CacheHit.Incr("PromoOrders")
		return
	}
	prom.CacheMiss.Incr("PromoOrders")
	res, err = d.RawPromoOrders(c, id)
	if err != nil {
		return
	}
	miss := res
	if len(miss) == 0 {
		miss = []*model.PromotionOrder{{GroupID: -1}}
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCachePromoOrders(metadata.WithContext(c), id, miss)
	})
	return
}

// Orders get data from cache if miss will call source method, then add to cache.
func (d *Dao) Orders(c context.Context, id *model.OrderMainQuerier) (res []*model.OrderMain, err error) {
	addCache := true
	res, err = d.CacheOrders(c, id)
	if err != nil {
		addCache = false
		err = nil
	}
	defer func() {
		if len(res) == 1 && res[0].OrderID == -1 {
			res = nil
		}
	}()
	if len(res) != 0 {
		prom.CacheHit.Incr("Orders")
		return
	}
	prom.CacheMiss.Incr("Orders")
	res, err = d.RawOrders(c, id)
	if err != nil {
		return
	}
	miss := res
	if len(miss) == 0 {
		miss = []*model.OrderMain{{OrderID: -1}}
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCacheOrders(metadata.WithContext(c), id, miss)
	})
	return
}

// OrderCount get data from cache if miss will call source method, then add to cache.
func (d *Dao) OrderCount(c context.Context, id *model.OrderMainQuerier) (res int64, err error) {
	addCache := true
	res, err = d.CacheOrderCount(c, id)
	if err != nil {
		addCache = false
		err = nil
	}
	defer func() {
		if res == -1 {
			res = 0
		}
	}()
	if res != 0 {
		prom.CacheHit.Incr("OrderCount")
		return
	}
	prom.CacheMiss.Incr("OrderCount")
	res, err = d.RawOrderCount(c, id)
	if err != nil {
		return
	}
	miss := res
	if miss == 0 {
		miss = -1
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCacheOrderCount(metadata.WithContext(c), id, miss)
	})
	return
}

// OrderDetails get data from cache if miss will call source method, then add to cache.
func (d *Dao) OrderDetails(c context.Context, keys []int64) (res map[int64]*model.OrderDetail, err error) {
	if len(keys) == 0 {
		return
	}
	addCache := true
	res, err = d.CacheOrderDetails(c, keys)
	if err != nil {
		addCache = false
		res = nil
		err = nil
	}
	var miss []int64
	for _, key := range keys {
		if (res == nil) || (res[key] == nil) {
			miss = append(miss, key)
		}
	}
	prom.CacheHit.Add("OrderDetails", int64(len(keys)-len(miss)))
	defer func() {
		for k, v := range res {
			if v != nil && v.OrderID == 0 {
				delete(res, k)
			}
		}
	}()
	if len(miss) == 0 {
		return
	}
	var missData map[int64]*model.OrderDetail
	prom.CacheMiss.Add("OrderDetails", int64(len(miss)))
	missData, err = d.RawOrderDetails(c, miss)
	if res == nil {
		res = make(map[int64]*model.OrderDetail)
	}
	for k, v := range missData {
		res[k] = v
	}
	if err != nil {
		return
	}
	for _, key := range keys {
		if res[key] == nil {
			if missData == nil {
				missData = make(map[int64]*model.OrderDetail, len(keys))
			}
			missData[key] = &model.OrderDetail{OrderID: 0}
		}
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCacheOrderDetails(metadata.WithContext(c), missData)
	})
	return
}

// OrderSKUs get data from cache if miss will call source method, then add to cache.
func (d *Dao) OrderSKUs(c context.Context, keys []int64) (res map[int64][]*model.OrderSKU, err error) {
	if len(keys) == 0 {
		return
	}
	addCache := true
	res, err = d.CacheOrderSKUs(c, keys)
	if err != nil {
		addCache = false
		res = nil
		err = nil
	}
	var miss []int64
	for _, key := range keys {
		if (res == nil) || (len(res[key]) == 0) {
			miss = append(miss, key)
		}
	}
	prom.CacheHit.Add("OrderSKUs", int64(len(keys)-len(miss)))
	defer func() {
		for k, v := range res {
			if len(v) == 1 && v[0].OrderID == -1 {
				delete(res, k)
			}
		}
	}()
	if len(miss) == 0 {
		return
	}
	var missData map[int64][]*model.OrderSKU
	prom.CacheMiss.Add("OrderSKUs", int64(len(miss)))
	missData, err = d.RawOrderSKUs(c, miss)
	if res == nil {
		res = make(map[int64][]*model.OrderSKU)
	}
	for k, v := range missData {
		res[k] = v
	}
	if err != nil {
		return
	}
	for _, key := range keys {
		if len(res[key]) == 0 {
			if missData == nil {
				missData = make(map[int64][]*model.OrderSKU, len(keys))
			}
			missData[key] = []*model.OrderSKU{{OrderID: -1}}
		}
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCacheOrderSKUs(metadata.WithContext(c), missData)
	})
	return
}

// OrderPayCharges get data from cache if miss will call source method, then add to cache.
func (d *Dao) OrderPayCharges(c context.Context, keys []int64) (res map[int64]*model.OrderPayCharge, err error) {
	if len(keys) == 0 {
		return
	}
	addCache := true
	res, err = d.CacheOrderPayCharges(c, keys)
	if err != nil {
		addCache = false
		res = nil
		err = nil
	}
	var miss []int64
	for _, key := range keys {
		if (res == nil) || (res[key] == nil) {
			miss = append(miss, key)
		}
	}
	prom.CacheHit.Add("OrderPayCharges", int64(len(keys)-len(miss)))
	defer func() {
		for k, v := range res {
			if v != nil && v.ChargeID == "" {
				delete(res, k)
			}
		}
	}()
	if len(miss) == 0 {
		return
	}
	var missData map[int64]*model.OrderPayCharge
	prom.CacheMiss.Add("OrderPayCharges", int64(len(miss)))
	missData, err = d.RawOrderPayCharges(c, miss)
	if res == nil {
		res = make(map[int64]*model.OrderPayCharge)
	}
	for k, v := range missData {
		res[k] = v
	}
	if err != nil {
		return
	}
	for _, key := range keys {
		if res[key] == nil {
			if missData == nil {
				missData = make(map[int64]*model.OrderPayCharge, len(keys))
			}
			missData[key] = &model.OrderPayCharge{ChargeID: ""}
		}
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCacheOrderPayCharges(metadata.WithContext(c), missData)
	})
	return
}

// SkuByItemID get data from cache if miss will call source method, then add to cache.
func (d *Dao) SkuByItemID(c context.Context, id int64) (res map[string]*model.SKUStock, err error) {
	addCache := true
	res, err = d.CacheSkuByItemID(c, id)
	if err != nil {
		addCache = false
		err = nil
	}
	if len(res) != 0 {
		prom.CacheHit.Incr("SkuByItemID")
		return
	}
	prom.CacheMiss.Incr("SkuByItemID")
	res, err = d.RawSkuByItemID(c, id)
	if err != nil {
		return
	}
	miss := res
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCacheSkuByItemID(metadata.WithContext(c), id, miss)
	})
	return
}

// GetSKUs get data from cache if miss will call source method, then add to cache.
func (d *Dao) GetSKUs(c context.Context, keys []int64, withNewStock bool) (res map[int64]*model.SKUStock, err error) {
	if len(keys) == 0 {
		return
	}
	addCache := true
	res, err = d.CacheGetSKUs(c, keys, withNewStock)
	if err != nil {
		addCache = false
		res = nil
		err = nil
	}
	var miss []int64
	for _, key := range keys {
		if (res == nil) || (res[key] == nil) {
			miss = append(miss, key)
		}
	}
	prom.CacheHit.Add("GetSKUs", int64(len(keys)-len(miss)))
	if len(miss) == 0 {
		return
	}
	var missData map[int64]*model.SKUStock
	prom.CacheMiss.Add("GetSKUs", int64(len(miss)))
	missData, err = d.RawGetSKUs(c, miss, withNewStock)
	if res == nil {
		res = make(map[int64]*model.SKUStock)
	}
	for k, v := range missData {
		res[k] = v
	}
	if err != nil {
		return
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCacheGetSKUs(metadata.WithContext(c), missData, withNewStock)
	})
	return
}

// Stocks get data from cache if miss will call source method, then add to cache.
func (d *Dao) Stocks(c context.Context, keys []int64, isLocked bool) (res map[int64]int64, err error) {
	if len(keys) == 0 {
		return
	}
	addCache := true
	res, err = d.CacheStocks(c, keys, isLocked)
	if err != nil {
		addCache = false
		res = nil
		err = nil
	}
	var miss []int64
	for _, key := range keys {
		if _, ok := res[key]; !ok {
			miss = append(miss, key)
		}
	}
	prom.CacheHit.Add("Stocks", int64(len(keys)-len(miss)))
	if len(miss) == 0 {
		return
	}
	var missData map[int64]int64
	prom.CacheMiss.Add("Stocks", int64(len(miss)))
	missData, err = d.RawStocks(c, miss, isLocked)
	if res == nil {
		res = make(map[int64]int64)
	}
	for k, v := range missData {
		res[k] = v
	}
	if err != nil {
		return
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCacheStocks(metadata.WithContext(c), missData, isLocked)
	})
	return
}

// TicketsByOrderID get data from cache if miss will call source method, then add to cache.
func (d *Dao) TicketsByOrderID(c context.Context, id int64) (res []*model.Ticket, err error) {
	addCache := true
	res, err = d.CacheTicketsByOrderID(c, id)
	if err != nil {
		addCache = false
		err = nil
	}
	defer func() {
		if len(res) == 1 && res[0].ID == -1 {
			res = nil
		}
	}()
	if len(res) != 0 {
		prom.CacheHit.Incr("TicketsByOrderID")
		return
	}
	prom.CacheMiss.Incr("TicketsByOrderID")
	res, err = d.RawTicketsByOrderID(c, id)
	if err != nil {
		return
	}
	miss := res
	if len(miss) == 0 {
		miss = []*model.Ticket{{ID: -1}}
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCacheTicketsByOrderID(metadata.WithContext(c), id, miss)
	})
	return
}

// TicketsByScreen get data from cache if miss will call source method, then add to cache.
func (d *Dao) TicketsByScreen(c context.Context, id int64, UID int64) (res []*model.Ticket, err error) {
	addCache := true
	res, err = d.CacheTicketsByScreen(c, id, UID)
	if err != nil {
		addCache = false
		err = nil
	}
	defer func() {
		if len(res) == 1 && res[0].ID == -1 {
			res = nil
		}
	}()
	if len(res) != 0 {
		prom.CacheHit.Incr("TicketsByScreen")
		return
	}
	prom.CacheMiss.Incr("TicketsByScreen")
	res, err = d.RawTicketsByScreen(c, id, UID)
	if err != nil {
		return
	}
	miss := res
	if len(miss) == 0 {
		miss = []*model.Ticket{{ID: -1}}
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCacheTicketsByScreen(metadata.WithContext(c), id, miss, UID)
	})
	return
}

// TicketsByID get data from cache if miss will call source method, then add to cache.
func (d *Dao) TicketsByID(c context.Context, keys []int64) (res map[int64]*model.Ticket, err error) {
	if len(keys) == 0 {
		return
	}
	addCache := true
	res, err = d.CacheTicketsByID(c, keys)
	if err != nil {
		addCache = false
		res = nil
		err = nil
	}
	var miss []int64
	for _, key := range keys {
		if (res == nil) || (res[key] == nil) {
			miss = append(miss, key)
		}
	}
	prom.CacheHit.Add("TicketsByID", int64(len(keys)-len(miss)))
	defer func() {
		for k, v := range res {
			if v != nil && v.ID == -1 {
				delete(res, k)
			}
		}
	}()
	if len(miss) == 0 {
		return
	}
	var missData map[int64]*model.Ticket
	prom.CacheMiss.Add("TicketsByID", int64(len(miss)))
	missData, err = d.RawTicketsByID(c, miss)
	if res == nil {
		res = make(map[int64]*model.Ticket)
	}
	for k, v := range missData {
		res[k] = v
	}
	if err != nil {
		return
	}
	for _, key := range keys {
		if res[key] == nil {
			if missData == nil {
				missData = make(map[int64]*model.Ticket, len(keys))
			}
			missData[key] = &model.Ticket{ID: -1}
		}
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCacheTicketsByID(metadata.WithContext(c), missData)
	})
	return
}

// TicketSend get data from cache if miss will call source method, then add to cache.
func (d *Dao) TicketSend(c context.Context, keys []int64, TIDType string) (res map[int64]*model.TicketSend, err error) {
	if len(keys) == 0 {
		return
	}
	addCache := true
	res, err = d.CacheTicketSend(c, keys, TIDType)
	if err != nil {
		addCache = false
		res = nil
		err = nil
	}
	var miss []int64
	for _, key := range keys {
		if (res == nil) || (res[key] == nil) {
			miss = append(miss, key)
		}
	}
	prom.CacheHit.Add("TicketSend", int64(len(keys)-len(miss)))
	defer func() {
		for k, v := range res {
			if v != nil && v.ID == -1 {
				delete(res, k)
			}
		}
	}()
	if len(miss) == 0 {
		return
	}
	var missData map[int64]*model.TicketSend
	prom.CacheMiss.Add("TicketSend", int64(len(miss)))
	missData, err = d.RawTicketSend(c, miss, TIDType)
	if res == nil {
		res = make(map[int64]*model.TicketSend)
	}
	for k, v := range missData {
		res[k] = v
	}
	if err != nil {
		return
	}
	for _, key := range keys {
		if res[key] == nil {
			if missData == nil {
				missData = make(map[int64]*model.TicketSend, len(keys))
			}
			missData[key] = &model.TicketSend{ID: -1}
		}
	}
	if !addCache {
		return
	}
	d.cache.Save(func() {
		d.AddCacheTicketSend(metadata.WithContext(c), missData, TIDType)
	})
	return
}