Method get_region

chirpstack/src/api/internal.rs:942–988

(
        &self,
        request: Request<api::GetRegionRequest>,
    )

    }

    async fn get_region(
        &self,
        request: Request<api::GetRegionRequest>,
    ) -> Result<Response<api::GetRegionResponse>, Status> {
        let req = request.get_ref();
        self.validator
            .validate(request.extensions(), validator::ValidateActiveUser::new())
            .await?;

        let conf = config::get();
        let reg = region::get(&req.id).map_err(|e| e.status())?;

        let mut out = api::GetRegionResponse {
            ..Default::default()
        };

        for region_conf in &conf.regions {
            if req.id == region_conf.id {
                out.id.clone_from(&region_conf.id);
                out.description = if region_conf.description.is_empty() {
                    region_conf.id.clone()
                } else {
                    region_conf.description.clone()
                };
                out.region = region_conf.common_name.to_proto().into();
                out.user_info.clone_from(&region_conf.user_info);
                out.rx1_delay = region_conf.network.rx1_delay as u32;
                out.rx1_dr_offset = region_conf.network.rx1_dr_offset as u32;
                out.rx2_dr = region_conf.network.rx2_dr as u32;
                out.rx2_frequency = region_conf.network.rx2_frequency;
                out.class_b_ping_slot_dr = region_conf.network.class_b.ping_slot_dr as u32;
                out.class_b_ping_slot_frequency = region_conf.network.class_b.ping_slot_frequency;
            }
        }

        let enabled_channels = reg.get_enabled_uplink_channel_indices();

        for i in enabled_channels {
            let ch = reg.get_uplink_channel(i).map_err(|e| e.status())?;
            out.uplink_channels.push(api::RegionChannel {
                frequency: ch.frequency,
                data_rates: ch.data_rates.into_iter().map(|v| v as u32).collect(),
            });
        }

        Ok(Response::new(out))
    }

    async fn get_version(
        &self,