stock.request

def action_confirm(self):
    self._action_confirm()
    return True

def action_draft(self):
    self.write({"state": "draft"})
    return True

def action_cancel(self):
    self.sudo().mapped("move_ids")._action_cancel()
    self.write({"state": "cancel"})
    return True

def action_done(self):
    self.write({"state": "done"})
    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 _prepare_procurement_values(self, group_id=False):
    return {
        "date_planned": self.expected_date,
        "warehouse_id": self.warehouse_id,
        "stock_request_allocation_ids": self.id,
        "group_id": group_id or self.procurement_group_id.id or False,
        "route_ids": self.route_id,
        "stock_request_id": self.id,
    }

def _action_launch_procurement_rule(self):
    # Launch procurement group run method with required fields
    # See source for full implementation

def _action_use_stock_available(self):
    # Create a stock move with the necessary data and mark it as done

def _prepare_stock_move(self, qty):
    return {
        "name": self.product_id.display_name,
        "company_id": self.company_id.id,
        "product_id": self.product_id.id,
        "product_uom_qty": qty,
        "product_uom": self.product_id.uom_id.id,
        "location_id": self.location_id.id,
        "location_dest_id": self.location_id.id,
        "state": "draft",
        "reference": self.name,
    }

def _prepare_stock_request_allocation(self, move):
    return {
        "stock_request_id": self.id,
        "stock_move_id": move.id,
        "requested_product_uom_qty": move.product_uom_qty,
    }

def check_done(self):
    precision = self.env["decimal.precision"].precision_get(
        "Product Unit of Measure"
    )
    for request in self:
        allocated_qty = sum(request.allocation_ids.mapped("allocated_product_qty"))
        qty_done = request.product_id.uom_id._compute_quantity(
            allocated_qty, request.product_uom_id
        )
        if (
            float_compare(
                qty_done, request.product_uom_qty, precision_digits=precision
            )
            >= 0
        ):
            request.action_done()
        elif request._check_cancel_allocation():
            request.write({"state": "cancel"})
    return True

def check_cancel(self):
    for request in self:
        if request._check_cancel_allocation():
            request.write({"state": "cancel"})

@api.depends("allocation_ids", "allocation_ids.stock_move_id")
def _compute_move_ids(self):
    for request in self:
        move_ids = request.allocation_ids.mapped("stock_move_id")
        all_moves = self.env["stock.move"]
        for move in move_ids:
            all_moves |= self._get_all_origin_moves(move)
        request.move_ids = all_moves

@api.depends(
    "allocation_ids",
    "allocation_ids.stock_move_id",
    "allocation_ids.stock_move_id.picking_id",
)
def _compute_picking_ids(self):
    for request in self:
        request.picking_count = 0
        request.picking_ids = self.env["stock.picking"]
        request.picking_ids = request.move_ids.filtered(
            lambda m: m.state != "cancel"
        ).mapped("picking_id")
        request.picking_count = len(request.picking_ids)

@api.depends(
    "allocation_ids",
    "allocation_ids.stock_move_id.state",
    "allocation_ids.stock_move_id.move_line_ids",
    "allocation_ids.stock_move_id.move_line_ids.quantity",
)
def _compute_qty(self):
    # See source for implementation details

@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")
        if "order_id" in upd_vals:
            order_id = self.env["stock.request.order"].browse(upd_vals["order_id"])
            upd_vals["expected_date"] = order_id.expected_date
        else:
            upd_vals["expected_date"] = self._get_expected_date()
        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 requests on draft state can be unlinked"))
    return super().unlink()