stock.request.order

def action_confirm(self):
    if not self.stock_request_ids:
        raise UserError(
            _("There should be at least one request item for confirming the order.")
        )
    self.mapped("stock_request_ids").action_confirm()
    return True

def action_draft(self):
    self.mapped("stock_request_ids").action_draft()
    return True

def action_cancel(self):
    self.mapped("stock_request_ids").action_cancel()
    return True

def action_done(self):
    return True

def action_view_transfer(self):
    action = self.env["ir.actions.act_window"]._for_xml_id(
        "stock.action_picking_tree_all"
    )

    pickings = self.mapped("picking_ids")
    if len(pickings) > 1:
        action["domain"] = [("id", "in", pickings.ids)]
    elif pickings:
        action["views"] = [(self.env.ref("stock.view_picking_form").id, "form")]
        action["res_id"] = pickings.id
    return action

def action_view_stock_requests(self):
    action = self.env["ir.actions.act_window"]._for_xml_id(
        "stock_request.action_stock_request_form"
    )
    if len(self.stock_request_ids) > 1:
        action["domain"] = [("order_id", "in", self.ids)]
    elif self.stock_request_ids:
        action["views"] = [
            (self.env.ref("stock_request.view_stock_request_form").id, "form")
        ]
        action["res_id"] = self.stock_request_ids.id
    return action

@api.depends("stock_request_ids.state")
def _compute_state(self):
    for item in self:
        states = item.stock_request_ids.mapped("state")
        if not item.stock_request_ids or all(x == "draft" for x in states):
            item.state = "draft"
        elif all(x == "cancel" for x in states):
            item.state = "cancel"
        elif all(x in ("done", "cancel") for x in states):
            item.state = "done"
        else:
            item.state = "open"

@api.depends("warehouse_id", "location_id", "stock_request_ids")
def _compute_route_ids(self):
    # Complex logic to determine available routes
    # See source for full implementation

@api.depends("stock_request_ids")
def _compute_route_id(self):
    for order in self:
        if order.stock_request_ids:
            first_route = order.stock_request_ids[0].route_id or False
            if any(r.route_id != first_route for r in order.stock_request_ids):
                first_route = False
            order.route_id = first_route

@api.depends("stock_request_ids.allocation_ids")
def _compute_picking_ids(self):
    for record in self:
        record.picking_ids = record.stock_request_ids.mapped("picking_ids")
        record.picking_count = len(record.picking_ids)

@api.depends("stock_request_ids")
def _compute_move_ids(self):
    for record in self:
        record.move_ids = record.stock_request_ids.mapped("move_ids")

@api.depends("stock_request_ids")
def _compute_stock_request_count(self):
    for record in self:
        record.stock_request_count = len(record.stock_request_ids)

def _inverse_route_id(self):
    for order in self:
        if order.route_id:
            order.stock_request_ids.write({"route_id": order.route_id.id})

@api.onchange("route_id")
def _onchange_route_id(self):
    if self.route_id:
        for request in self.stock_request_ids:
            request.route_id = self.route_id

def change_childs(self):
    if not self._context.get("no_change_childs", False):
        for line in self.stock_request_ids:
            line.warehouse_id = self.warehouse_id
            line.location_id = self.location_id
            line.company_id = self.company_id
            line.picking_policy = self.picking_policy
            line.expected_date = self.expected_date
            line.requested_by = self.requested_by
            line.procurement_group_id = self.procurement_group_id

def get_parents(self):
    location = self.location_id
    result = location
    while location.location_id:
        location = location.location_id
        result |= location
    return result

@api.model
def default_get(self, fields):
    res = super().default_get(fields)
    warehouse = None
    if "warehouse_id" not in res and res.get("company_id"):
        warehouse = self.env["stock.warehouse"].search(
            [("company_id", "=", res["company_id"])], limit=1
        )
    if warehouse:
        res["warehouse_id"] = warehouse.id
        res["location_id"] = warehouse.lot_stock_id.id
    return res

@api.constrains("warehouse_id", "company_id")
def _check_warehouse_company(self):
    if any(
        request.warehouse_id.company_id != request.company_id for request in self
    ):
        raise ValidationError(
            _(
                "The company of the stock request must match with "
                "that of the warehouse."
            )
        )

@api.constrains("location_id", "company_id")
def _check_location_company(self):
    if any(
        request.location_id.company_id
        and request.location_id.company_id != request.company_id
        for request in self
    ):
        raise ValidationError(
            _(
                "The company of the stock request must match with "
                "that of the location."
            )
        )

@api.model_create_multi
def create(self, vals_list):
    vals_list_upd = []
    for vals in vals_list:
        upd_vals = vals.copy()
        if upd_vals.get("name", "/") == "/":
            upd_vals["name"] = self.env["ir.sequence"].next_by_code(
                "stock.request.order"
            )
        vals_list_upd.append(upd_vals)
    return super().create(vals_list_upd)

def unlink(self):
    if self.filtered(lambda r: r.state != "draft"):
        raise UserError(_("Only orders on draft state can be unlinked"))
    return super().unlink()

@api.model
def _create_from_product_multiselect(self, products):
    if not products:
        return False
    if products._name not in ("product.product", "product.template"):
        raise ValidationError(
            _("This action only works in the context of products")
        )
    if products._name == "product.template":
        products = self.env["product.product"].search(
            [("product_tmpl_id", "in", products.ids)]
        )
    expected = self.default_get(["expected_date"])["expected_date"]
    order = self.env["stock.request.order"].create(
        dict(
            expected_date=expected,
            stock_request_ids=[
                (
                    0,
                    0,
                    dict(
                        product_id=product.id,
                        product_uom_id=product.uom_id.id,
                        product_uom_qty=1.0,
                        expected_date=expected,
                    ),
                )
                for product in products
            ],
        )
    )
    # Returns action to view created order