Beispiel #1
0
func (s *ProductService) ListStocks(parser *db.QueryParser) ([]*model.Product, error) {

	// func FillProductStocksByIdSet(models []*model.Product) error {
	// 	if nil == models || len(models) == 0 {
	// 		return nil
	// 	}

	// 	var idset = map[int64]bool{}
	// 	for _, m := range models {
	// 		idset[int64(m.Id)] = true
	// 	}
	// 	if allstocks, err := GetAllStocksByIdSet(idset); err != nil {
	// 		return err
	// 	} else {
	// 		if nil != allstocks {
	// 			for _, m := range models {
	// 				if stock, ok := allstocks[int64(m.Id)]; ok {
	// 					m.Stocks = stock
	// 					m.Stock = stock.Total()
	// 				}
	// 			}
	// 		}
	// 	}
	// 	return nil
	// }

	if models, err := productdao.List(parser); err != nil {
		return nil, err
	} else {
		if err := inventorydao.FillProductStocksByIdSet(models); err != nil {
			return nil, err
		}
		return models, nil
	}
}
Beispiel #2
0
func (s *ProductService) List(parser *db.QueryParser, withs Withs) ([]*model.Product, error) {
	if models, err := productdao.List(parser); err != nil {
		return nil, err
	} else {
		// TODO: Print warrning information when has unused withs.
		// fmt.Println("--------------------------------------------------------------------", withs)
		if withs&WITH_PRODUCT_DETAIL > 0 {
			if err := productdao.FillProductPropertiesByIdSet(models); err != nil {
				return nil, err
			}
		}
		if withs&WITH_PRODUCT_INVENTORY > 0 {
			if err := inventorydao.FillProductStocksByIdSet(models); err != nil {
				return nil, err
			}
		}
		return models, nil
	}
}
Beispiel #3
0
func load() {
	cache = make(map[string]Items, 100)

	persons, err := persondao.ListAll("customer")
	// persons, err := personservice.ListCustomer()
	if err != nil {
		panic(err.Error())
	} else {
		debug.Log("[suggest] load %v customers.", len(persons))
		personItems := NewItems(len(persons))
		for i, person := range persons {
			personItems[i] = &Item{
				Id:          person.Id,
				Text:        person.Name,
				QuickString: parseQuickText(person.Name),
				Type:        "1",
			}
		}
		sort.Sort(personItems)
		cache[Customer] = personItems
	}

	factories, err := persondao.ListAll("factory")
	// factories, err := personservice.ListFactory()
	if err != nil {
		panic(err.Error())
	} else {
		debug.Log("[suggest] load %v factories.", len(factories))
		factoryItems := NewItems(len(factories))
		for i, factory := range factories {
			factoryItems[i] = &Item{
				Id:          factory.Id,
				Text:        factory.Name,
				QuickString: parseQuickText(factory.Name), // TODO
				Type:        "2",
			}
		}
		sort.Sort(factoryItems)
		cache[Factory] = factoryItems
	}

	// TODO: chagne to step load.
	parser := productdao.EntityManager().NewQueryParser().Where().Limit(10000) // all limit to 1w
	products, err := productdao.List(parser)
	if err != nil {
		panic(err.Error())
	}
	// products := dal.ListProduct()
	debug.Log("[suggest] load %v products.", len(products))
	productItems := NewItems(len(products))
	for i, product := range products {
		productItems[i] = &Item{
			Id:          product.Id,
			SN:          product.ProductId,
			Text:        product.Name,
			QuickString: parseQuickText(product.Name), // TODO
			Type:        "3",
		}
	}
	sort.Sort(productItems)
	cache[Product] = productItems

	debug.Log("Loading suggest done. Use 0.00 ms.")
}