def validate(self, ids, context={}):
        obj = self.browse(ids)[0]
        if not obj.lines:
            raise Exception("Product list is empty")
        pick = obj.picking_id
        if obj.mode == "backorder":
            vals = {
                "picking_id": pick.id,
                "lines": [],
            }
            for line in obj.lines:
                if not line.qty_actual:
                    raise Exception("Missing actual qty for product %s" % line.product_id.code)
                line_vals = {
                    "product_id": line.product_id.id,
                    "qty": line.qty_actual,
                    "uom_id": line.uom_id.id,
                }
                vals["lines"].append(("create", line_vals))
            val_id = get_model("pick.validate").create(vals)
            res = get_model("pick.validate").do_validate([val_id])
            obj.clear()
            return {
                "flash": res["flash"],
            }
        elif obj.mode == "loss":
            if not obj.location_loss_id:
                raise Exception("Missing inventory loss location")

            pick.set_done(context=context)  # XXX
            obj.clear()
            return {
                "flash": "Picking validated successfully",
                "focus_field": "picking_id",
            }

 def reconcile(self, ids, context={}):
     print("MoveLine.reconcile", ids)
     rec_id = get_model("account.reconcile").create({})
     all_ids = ids[:]
     for line in self.browse(ids):
         rec = line.reconcile_id
         if not rec:
             continue
         for rline in rec.lines:
             all_ids.append(rline.id)
     all_ids = list(set(all_ids))
     acc_id = None
     for obj in self.browse(all_ids):
         if not acc_id:
             acc_id = obj.account_id.id
         else:
             if obj.account_id.id != acc_id:
                 acc=get_model("account.account").browse(acc_id)
                 raise Exception("Can only reconcile transactions of same account (%s / %s)"%(obj.account_id.code,acc.code))
     self.write(all_ids, {"reconcile_id": rec_id})
     inv_ids=[]
     for obj in self.browse(all_ids):
         move=obj.move_id
         rel=move.related_id
         if rel._model=="account.invoice":
             inv_ids.append(rel.id)
     if inv_ids:
         get_model("account.invoice").function_store(inv_ids)

def get_all_balances(date_from=None, date_to=None, track1=None, track2=None):
    t = time.time()
    k = (date_from, date_to, track1, track2)
    if k in _acc_bal_cache:
        res, res_t = _acc_bal_cache[k]
        if t - res_t <= 10:
            print("cache hit", k)
            return res
    print("cache miss", k)
    if track1:
        res = get_model("account.track.categ").search([["code", "=", track1]])
        if not res:
            raise Exception("Invalid tracking category: %s" % track1)
        track_id = res[0]
    else:
        track_id = None
    if track2:
        res = get_model("account.track.categ").search([["code", "=", track2]])
        if not res:
            raise Exception("Invalid tracking category: %s" % track2)
        track2_id = res[0]
    else:
        track2_id = None
    ctx = {
        "date_from": date_from,
        "date_to": date_to,
        "track_id": track_id,
        "track2_id": track2_id,
    }
    res = get_model("account.account").search_read([["type", "!=", "view"]], ["code", "balance"], context=ctx)
    _acc_bal_cache[k] = (res, t)
    return res

 def add_products(self, ids, context={}):
     obj = self.browse(ids)[0]
     pricelist = obj.pricelist_id
     categ_ids = [c.id for c in obj.product_categs]
     for prod in get_model("product").search_browse([["categs.id", "in", categ_ids]]):
         factor = pricelist.factor or 1.0
         if pricelist.base_price == "product":
             base_price = prod.sale_price or 0
         elif pricelist.base_price == "other_pricelist":
             if not pricelist.other_pricelist_id:
                 raise Exception("Missing base price list")
             base_price = get_model("price.list").get_price(
                 pricelist.other_pricelist_id.id, prod.id, 1) or 0  # XXX: qty
         elif pricelist.base_price == "volume":
             base_price = prod.volume or 0
         else:
             raise Exception("Invalid base price type")
         price = utils.round_amount(base_price * factor, pricelist.rounding, pricelist.rounding_method)
         vals = {
             "list_id": pricelist.id,
             "product_id": prod.id,
             "price": price,
         }
         get_model("price.list.item").create(vals)
     return {
         "next": {
             "name": "pricelist_item",
         },
         "flash": "Products added to price list",
     }

 def compute_thai_tax(self, context={}):
     emp_id = context.get("employee_id")
     if emp_id != 'null':
         emp_id = int(emp_id)
     emp = get_model("hr.employee").browse(emp_id)
     period = context.get("period", 12)
     date = context.get("date")
     vals = {}
     vals["B1"] = max(0, self.get_yearly_provident_fund(context=context) - 10000)
     #vals["B2"]=emp.gov_pension_fund or 0
     vals["B2"] = 0
     vals["B3"] = emp.teacher_fund or 0
     vals["B4"] = emp.old_disabled or 0
     vals["B5"] = emp.old_disabled_spouse or 0
     vals["B6"] = emp.severance_pay or 0
     vals["B7"] = vals["B1"] + vals["B2"] + vals["B3"] + vals["B4"] + vals["B5"] + vals["B6"]
     vals["C1"] = 30000
     vals["C2"] = 30000 if emp.spouse_filing_status in ("joint", "no_income") else 0
     vals["C3a"] = 15000 * (emp.num_child1 or 0)
     vals["C3b"] = 17000 * (emp.num_child2 or 0)
     vals["C4a"] = 30000 if emp.father_id_no else 0
     vals["C4b"] = 30000 if emp.mother_id_no else 0
     vals["C4c"] = 30000 if emp.spouse_father_id_no else 0
     vals["C4d"] = 30000 if emp.spouse_mother_id_no else 0
     vals["C5"] = emp.disabled_support or 0
     vals["C6"] = emp.parent_health_insurance or 0
     vals["C7"] = emp.life_insurance or 0
     vals["C8"] = min(10000, self.get_yearly_provident_fund(context=context))
     vals["C9"] = emp.retirement_mutual_fund or 0
     vals["C10"] = emp.long_term_equity_fund or 0
     vals["C11"] = emp.interest_residence or 0
     vals["C12"] = emp.other_deduct or 0
     vals["C13"] = self.get_yearly_social_security(context=context)
     vals["C14"] = vals["C1"] + vals["C2"] + vals["C3a"] + vals["C3b"] + vals["C4a"] + vals["C4b"] + vals["C4c"] + vals["C4d"] + \
         vals["C5"] + vals["C6"] + vals["C7"] + vals["C8"] + vals["C9"] + \
         vals["C10"] + vals["C11"] + vals["C12"] + vals["C13"]
     vals["A1"] = self.get_yearly_income(context=context) + vals["B6"]
     vals["A2"] = vals["B7"]
     vals["A3"] = vals["A1"] - vals["A2"]
     vals["A4"] = min(0.4 * vals["A3"], 60000)  # XXX: use settings
     vals["A5"] = vals["A3"] - vals["A4"]
     vals["A6"] = vals["C14"]
     vals["A7"] = vals["A5"] - vals["A6"]
     vals["A8"] = min(2 * (emp.education_donation or 0), 0.1 * vals["A7"])
     vals["A9"] = vals["A7"] - vals["A8"]
     vals["A10"] = min(emp.other_donation or 0, 0.1 * vals["A9"])
     vals["A11"] = vals["A9"] - vals["A10"]
     vals["A12"] = get_model("hr.tax.rate").compute_tax(vals["A11"])
     vals["A13"] = emp.house_deduct or 0
     vals["A14"] = max(0, vals["A12"] - vals["A13"])
     vals["A15"] = emp.wht_amount or 0
     vals["A16"] = vals["A14"] - vals["A15"]
     vals["A17"] = 0  # XXX
     vals["A18"] = 0
     vals["A19"] = 0
     vals["A20"] = vals["A16"]
     vals["A21"] = 0
     vals["A22"] = vals["A20"]
     vals["tax_month"] = vals["A12"] / period
     return vals

def get_categs(condition):
    print("get_categs")
    res=get_model("product").read_group(["categ_id"],condition=condition)
    categ_nums={}
    for r in res:
        categ_id=r["categ_id"][0] if r["categ_id"] else None
        categ_nums.setdefault(categ_id,0)
        categ_nums[categ_id]+=r["_count"]
    res=get_model("product.categ").search_read([],["code","name","parent_id"])
    categ_ids={}
    for r in res:
        categ_ids[r["id"]]=r
    top_categs=[]
    for r in res:
        parent_id=r["parent_id"][0] if r["parent_id"] else None
        if parent_id:
            parent=categ_ids[parent_id]
            parent.setdefault("sub_categories",[]).append(r)
        else:
            top_categs.append(r)
    for categ_id,num in categ_nums.items():
        if not categ_id:
            continue
        categ=categ_ids[categ_id]
        categ["num_products"]=num
    def _set_total_num(c):
        for s in c.get("sub_categories",[]):
            _set_total_num(s)
        if c.get("num_products") is None:
            c["num_products"]=0
        for s in c.get("sub_categories",[]):
            c["num_products"]+=s["num_products"]
    for c in top_categs:
        _set_total_num(c)
    return top_categs

 def check_sent_emails(self, context={}):
     print("send_sent_emails")
     res = get_model("email.account").search([["type", "=", "mailgun"]])  # XXX
     if not res:
         return
     acc_id = res[0]
     get_model("email.account").check_sent_emails([acc_id])

 def get_unit_price(self,ids,context={}):
     settings=get_model("settings").browse(1)
     vals={}
     for obj in self.browse(ids):
         pick=obj.picking_id
         if pick:
             if pick.currency_rate:
                 currency_rate = pick.currency_rate
             else:
                 if pick.currency_id.id == settings.currency_id.id:
                     currency_rate = 1
                 else:
                     rate_from = pick.currency_id.get_rate(date=pick.date)
                     if not rate_from:
                         raise Exception("Missing currency rate for %s" % pick.currency_id.code)
                     rate_to = settings.currency_id.get_rate(date=pick.date)
                     if not rate_to:
                         raise Exception("Missing currency rate for %s" % settings.currency_id.code)
                     currency_rate = rate_from / rate_to
             price=obj.unit_price_cur or 0
             price_conv=get_model("currency").convert(price,pick.currency_id.id,settings.currency_id.id,rate=currency_rate)
         else:
             price_conv=None
         vals[obj.id]=price_conv
     return vals

 def _get_loc_to(self, context={}):
     print("_get_loc_to", context)
     data = context.get("data")
     settings = get_model("settings").browse(1)
     if data:
         journal_id = data.get("journal_id")
         if journal_id:
             journal = get_model("stock.journal").browse(journal_id)
             if journal.location_to_id:
                 return journal.location_to_id.id
     pick_type = context.get("pick_type")
     pick_type = context.get("pick_type")
     if pick_type == "in":
         journal = settings.pick_in_journal_id
     elif pick_type == "out":
         journal = settings.pick_out_journal_id
     elif pick_type == "internal":
         journal = settings.pick_internal_journal_id
     else:
         journal = None
     if journal and journal.location_from_id:
         return journal.location_to_id.id
     if pick_type != "out":
         return None
     res = get_model("stock.location").search([["type", "=", "customer"]])
     if not res:
         return None
     return res[0]

 def onchange_container(self, context={}):
     data = context["data"]
     cont_id = data.get("container_id")
     if not cont_id:
         return
     cont = get_model("stock.container").browse(cont_id)
     contents = cont.get_contents()
     lines = []
     for (prod_id, lot_id, loc_id), (qty, amt, qty2) in contents.items():
         prod = get_model("product").browse(prod_id)
         line_vals = {
             "product_id": prod_id,
             "qty": qty,
             "uom_id": prod.uom_id.id,
             "qty2": qty2,
             "location_from_id": loc_id,
             "location_to_id": None,
             "lot_id": lot_id,
             "container_from_id": cont_id,
         }
         if data["type"] == "internal":
             line_vals["container_to_id"] = cont_id
         lines.append(line_vals)
     data["lines"] = lines
     return data

 def update_cost_price(self, context):
     data = context["data"]
     path = context["path"]
     line = get_data_path(data, path, parent=True)
     cost_price_cur=line["cost_price_cur"] or 0
     qty=line["qty"] or 0
     currency_id=data["currency_id"]
     if not currency_id:
         raise Exception("Missing currency")
     currency=get_model("currency").browse(currency_id)
     currency_rate=data["currency_rate"]
     date=data["date"]
     settings=get_model("settings").browse(1)
     if not currency_rate:
         if currency_id == settings.currency_id.id:
             currency_rate = 1
         else:
             rate_from = currency.get_rate(date=date)
             if not rate_from:
                 raise Exception("Missing currency rate for %s" % currency.code)
             rate_to = settings.currency_id.get_rate(date=date)
             if not rate_to:
                 raise Exception("Missing currency rate for %s" % settings.currency_id.code)
             currency_rate = rate_from / rate_to
     cost_price=get_model("currency").convert(cost_price_cur,currency_id,settings.currency_id.id,rate=currency_rate)
     cost_amount=cost_price*qty
     line["cost_price"]=cost_price
     line["cost_amount"]=cost_amount
     return data

 def to_draft(self,ids,context={}):
     for obj in self.browse(ids):
         move_ids=[]
         for move in obj.lines:
             move_ids.append(move.id)
         get_model("stock.move").to_draft(move_ids)
         obj.write({"state":"draft"})

 def delete(self, ids, **kw):
     move_ids = []
     for obj in self.browse(ids):
         for line in obj.lines:
             move_ids.append(line.id)
     get_model("stock.move").delete(move_ids)  # to update stored functions
     super().delete(ids, **kw)

 def make_po(self, ids, context={}):
     suppliers = {}
     for obj in self.browse(ids):
         if obj.qty_virt >= obj.min_qty:
             continue
         prod = obj.product_id
         if prod.supply_method!="purchase":
             raise Exception("Supply method for product %s is not set to 'Purchase'"%prod.code)
         res = get_model("stock.orderpoint").search([["product_id", "=", prod.id]])
         if res:
             op = get_model("stock.orderpoint").browse(res)[0]
             max_qty = op.max_qty
         else:
             max_qty = 0
         diff_qty = max_qty - obj.qty_virt
         if prod.purchase_uom_id:
             purch_uom=prod.purchase_uom_id
             if not prod.purchase_to_stock_uom_factor:
                 raise Exception("Missing purchase order -> stock uom factor for product %s"%prod.code)
             purch_qty=diff_qty/prod.purchase_to_stock_uom_factor
         else:
             purch_uom=prod.uom_id
             purch_qty=diff_qty
         if prod.purchase_qty_multiple:
             n=math.ceil(purch_qty/prod.purchase_qty_multiple)
             purch_qty=n*prod.purchase_qty_multiple
         if prod.purchase_uom_id:
             qty_stock=purch_qty*prod.purchase_to_stock_uom_factor
         else:
             qty_stock=None
         line_vals = {
             "product_id": prod.id,
             "description": prod.name_get()[0][1],
             "qty": purch_qty,
             "uom_id": purch_uom.id,
             "unit_price": prod.purchase_price or 0,
             "tax_id": prod.purchase_tax_id.id,
             "qty_stock": qty_stock,
         }
         if not prod.suppliers:
             raise Exception("Missing default supplier for product %s" % prod.name)
         contact_id = prod.suppliers[0].supplier_id.id
         suppliers.setdefault(contact_id, []).append(line_vals)
     if not suppliers:
         raise Exception("Nothing to order")
     count = 0
     for contact_id, lines in suppliers.items():
         vals = {
             "contact_id": contact_id,
             "lines": [("create", x) for x in lines],
         }
         purch_id = get_model("purchase.order").create(vals)
         count += 1
     return {
         "next": {
             "name": "purchase",
             "tab": "Draft",
         },
         "flash": "%d purchase orders created" % count,
     }

 def create(self, vals, **kw):
     new_id = super().create(vals, **kw)
     inv_id = vals["invoice_id"]
     cred_id = vals["credit_id"]
     get_model("account.invoice").function_store([inv_id, cred_id])
     self.post([new_id])
     return new_id

 def create(self,vals,*args,**kw):
     new_id=super().create(vals,*args,**kw)
     obj=self.browse(new_id)
     user_id=access.get_active_user()
     user=get_model("base.user").browse(user_id)
     if obj.related_id._model=="issue":
         issue=obj.related_id
         project=issue.project_id
         contact=issue.contact_id
         emails=issue.get_email_addresses()
         subject="New message by %s for issue %s"%(user.name,issue.number)
         if obj.subject:
             subject+=": %s"%obj.subject
         if emails:
             vals={
                 "from_addr": "[email protected]", # XXX
                 "to_addrs": ",".join(emails),
                 "subject": subject,
                 "body": obj.body,
                 "state": "to_send",
                 "name_id": "contact,%s"%contact.id,
                 "related_id": "issue,%s"%issue.id,
             }
             get_model("email.message").create(vals)
     return new_id

def get_last_level(categ):
    while(get_model("product.categ").search_browse([["parent_id","=",categ.id]])):
        categ = get_model("product.categ").search_browse([["parent_id","=",categ.id]],order="code")[0]
    if categ.parent_id:
        return get_model("product.categ").search_browse([["parent_id","=",categ.parent_id.id]])
    else:
        return None

 def get_balance_90d(self, ids, context={}, nocache=False):
     if not nocache:
         min_ctime = time.strftime("%Y-%m-%d 00:00:00")
         vals = get_model("field.cache").get_value("account.account", "balance_90d", ids, min_ctime=min_ctime)
         remain_ids = [id for id in ids if id not in vals]
         if remain_ids:
             res = self.get_balance_90d(remain_ids, context=context, nocache=True)
             for id, data in res.items():
                 vals[id] = data
                 get_model("field.cache").set_value("account.account", "balance_90d", id, data)
         return vals
     print("#########################################################################")
     print("get_balance_90d CACHE MISS", ids)
     date_from = datetime.date.today() - datetime.timedelta(days=90)
     date_to = datetime.date.today()
     db = database.get_connection()
     vals = {}
     for id in ids:
         balance = self.get_balance([id], context={"date_to": date_from.strftime("%Y-%m-%d")})[id]["balance"]
         q = "SELECT move_date,debit,credit FROM account_move_line WHERE account_id=%s AND move_date>%s AND move_date<=%s AND move_state='posted' ORDER BY move_date"
         res = db.query(q, id, date_from, date_to)
         d = date_from
         data = []
         for r in res:
             while d.strftime("%Y-%m-%d") < r["move_date"]:
                 data.append([time.mktime(d.timetuple()) * 1000, balance])
                 d += datetime.timedelta(days=1)
             balance += (r["debit"] or 0) - (r["credit"] or 0)
         while d <= date_to:
             data.append([time.mktime(d.timetuple()) * 1000, balance])
             d += datetime.timedelta(days=1)
         vals[id] = data
     return vals

def get_brands(condition):
    print("get_brands")
    res=get_model("product").read_group(["brand_id"],condition=condition)
    brand_nums={}
    for r in res:
        brand_id=r["brand_id"][0] if r["brand_id"] else None
        brand_nums.setdefault(brand_id,0)
        brand_nums[brand_id]+=r["_count"]
    res=get_model("product.brand").search_read([],["code","name","parent_id"])
    brand_ids={}
    for r in res:
        brand_ids[r["id"]]=r
    top_brands=[]
    for r in res:
        parent_id=r["parent_id"][0] if r["parent_id"] else None
        if parent_id:
            parent=brand_ids[parent_id]
            parent.setdefault("sub_brands",[]).append(r)
        else:
            top_brands.append(r)
    for brand_id,num in brand_nums.items():
        if not brand_id:
            continue
        brand=brand_ids[brand_id]
        brand["num_products"]=num
    def _set_total_num(c):
        for s in c.get("sub_brands",[]):
            _set_total_num(s)
        if c.get("num_products") is None:
            c["num_products"]=0
        for s in c.get("sub_brands",[]):
            c["num_products"]+=s["num_products"]
    for c in top_brands:
        _set_total_num(c)
    return top_brands

 def do_reconcile(self, ids, context={}):
     obj = self.browse(ids)[0]
     account_id = obj.account_id.id
     cond = [["account_id", "=", account_id]]
     if obj.contact_id:
         cond.append(["contact_id", "=", obj.contact_id.id])
     if obj.to_date:
         cond.append(["move_date", "<=", obj.to_date])
     num_rec = 0
     unrec = {}
     for line in get_model("account.move.line").search_browse(cond, order="move_id.date,id"):
         if not line.contact_id:
             continue
         if line.reconcile_id and line.reconcile_id.balance < 0:  # TODO: speed
             continue
         amt = line.debit - line.credit
         key2 = "%d,%.2f" % (line.contact_id.id, -amt)
         line2_ids = unrec.get(key2)
         if line2_ids:
             line2_id = line2_ids.pop(0)
             if not line2_ids:
                 del unrec[key2]
             rec_id = get_model("account.reconcile").create({})
             get_model("account.move.line").write([line.id, line2_id], {"reconcile_id": rec_id})
             num_rec += 2
         else:
             key = "%d,%.2f" % (line.contact_id.id, amt)
             unrec.setdefault(key, []).append(line.id)
     return {
         "next": {
             "name": "account_reconcile",
         },
         "flash": "%d transactions reconciled" % num_rec,
     }