Function update_user

chirpstack/src/storage/tenant.rs:411–511

(
    tu: TenantUser,
    device_profiles: &[TenantUserDeviceProfile],
    applications: &[TenantUserApplication],
)

}

pub async fn update_user(
    tu: TenantUser,
    device_profiles: &[TenantUserDeviceProfile],
    applications: &[TenantUserApplication],
) -> Result<TenantUser, Error> {
    let mut c = get_async_db_conn().await?;
    let tu: TenantUser = c
        .transaction::<TenantUser, Error, _>(async |c| {
            let tu: TenantUser = diesel::update(
                tenant_user::dsl::tenant_user
                    .filter(tenant_user::dsl::tenant_id.eq(&tu.tenant_id))
                    .filter(tenant_user::dsl::user_id.eq(&tu.user_id)),
            )
            .set(&tu)
            .get_result(c)
            .await
            .map_err(|e| Error::from_diesel(e, tu.user_id.to_string()))?;

            // delete device-profile links
            diesel::delete(
                tenant_user_device_profile::table.filter(
                    tenant_user_device_profile::user_id.eq(&tu.user_id).and(
                        tenant_user_device_profile::device_profile_id.eq_any(
                            device_profile::table
                                .filter(device_profile::tenant_id.eq(&tu.tenant_id))
                                .select(device_profile::id),
                        ),
                    ),
                ),
            )
            .execute(c)
            .await
            .map_err(|e| Error::from_diesel(e, tu.user_id.to_string()))?;

            // delete application links
            diesel::delete(
                tenant_user_application::table.filter(
                    tenant_user_application::user_id.eq(&tu.user_id).and(
                        tenant_user_application::application_id.eq_any(
                            application::table
                                .filter(application::tenant_id.eq(&tu.tenant_id))
                                .select(application::id),
                        ),
                    ),
                ),
            )
            .execute(c)
            .await
            .map_err(|e| Error::from_diesel(e, tu.user_id.to_string()))?;

            // re-create device-profiles
            for dp in device_profiles {
                // make sure dp exists under same tenant
                let _: storage::device_profile::DeviceProfile = device_profile::table
                    .filter(
                        device_profile::id
                            .eq(dp.device_profile_id)
                            .and(device_profile::tenant_id.eq(&tu.tenant_id)),