Method _handle_response_relayed

chirpstack/src/downlink/data.rs:225–288

(
        downlink_id: u32,
        relay_ctx: RelayContext,
        ufs: UplinkFrameSet,
        tenant: tenant::Tenant,
        application: application::Application,
        device_profile: device_

    #[allow(clippy::too_many_arguments)]
    async fn _handle_response_relayed(
        downlink_id: u32,
        relay_ctx: RelayContext,
        ufs: UplinkFrameSet,
        tenant: tenant::Tenant,
        application: application::Application,
        device_profile: device_profile::DeviceProfile,
        device: device::Device,
        must_send: bool,
        must_ack: bool,
        mac_commands: Vec<lrwn::MACCommandSet>,
    ) -> Result<()> {
        trace!("Downlink relayed response flow");

        let (network_conf, region_conf) = {
            let ds = device.get_device_session()?;
            (
                config::get_region_network(&ds.region_config_id)
                    .context("Get network config for region")?,
                region::get(&ds.region_config_id).context("Get region config for region")?,
            )
        };

        let mut ctx = Data {
            relay_context: Some(relay_ctx),
            uplink_frame_set: Some(ufs),
            tenant,
            application,
            device_profile,
            device,
            network_conf,
            region_conf,
            must_send,
            must_ack,
            mac_commands,
            downlink_gateway: None,
            downlink_frame: gw::DownlinkFrame {
                downlink_id,
                ..Default::default()
            },
            downlink_frame_items: Vec::new(),
            immediately: false,
            device_queue_item: None,
            more_device_queue_items: false,
        };

        ctx.select_downlink_gateway(true)?;
        ctx.set_tx_info_relayed()?;
        ctx.get_next_device_queue_item(true).await?;
        ctx.set_mac_commands().await?;
        if ctx._something_to_send() {
            ctx.set_phy_payloads()?;
            ctx.wrap_phy_payloads_in_forward_downlink_req()?;
            ctx.save_downlink_frame_relayed().await?;
            ctx.update_device().await?;
            ctx.send_downlink_frame().await?;
        } else if ctx._must_respond_to_relay() {
            ctx.set_phy_payloads_relay()?;