You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
738 lines
17 KiB
738 lines
17 KiB
// 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 |
|
}
|
|
|