let p = match projects::find(db, org_path, proj_path).await {
        Some(p) => p,
        None => return None,
    };

    let p = projects::find(db, org_path, proj_path).await?;

    match p.repository(&repoman.storage_root) {
        Ok(r) => r.changelist(channel, changelist).ok(),

    println!("changelist");
    match p
        .repository(&repoman.storage_root)
        .unwrap()
        .changelist(channel, changelist)
    {
        Ok(out) => Some(out),

    let patch_path = p
        .repository(&repoman.storage_root)
        .unwrap()
        .changestore()
        .change_file(apply)
        .unwrap();

    let repo = p.repository(&repoman.storage_root).unwrap();
    let hash =
        if let Some(h) = crate::models::pijul::changestores::Changestore::hash_from_string(apply) {
            h
        } else {
            return rocket::http::Status::InternalServerError;
        };
    let patch_path = repo.changestore().change_file(hash);
    repo.changestore().ensure_parent_dirs(hash);

    match patch.persist_to(patch_path).await {
        Ok(_) => rocket::http::Status::Accepted,
        Err(_e) => rocket::http::Status::InternalServerError,

    if patch.persist_to(&patch_path).await.is_err() {
        return rocket::http::Status::InternalServerError;

    if !repo.valid_change(hash) {
        // TODO clean up
        println!("Not valid as object");
        return rocket::http::Status::InternalServerError;
    }
    if repo.apply_change_to_channel("main", hash).is_ok() {
        return rocket::http::Status::Accepted;
    };
    rocket::http::Status::InternalServerError

#[derive(FromForm)]
struct IdentitiesReq {
    identities: Vec<String>,
}
use rocket::serde::{json::Json, Serialize};
#[derive(Serialize)]
struct Identities {
    id: Vec<String>,
    rev: u64,
}
// TODO figure out what I'm supposed to send here?
#[get("/<org_path>/<proj_path>/.pijul?<id_req>", rank = 3)]
fn identities(org_path: String, proj_path: String, id_req: IdentitiesReq) -> Json<Identities> {
    println!("{:?}", id_req.identities);
    Json(Identities { id: vec![], rev: 0 })
}

    routes![remote_id, changelist, apply]

    routes![remote_id, changelist, apply, identities]

use libpijul::Base32;
use libpijul::MutTxnT;

use libpijul::{Base32, Hash};
use libpijul::{MutTxnT, MutTxnTExt};

    }
    // Checks if the change is on disk, and if we can deserialize
    pub fn valid_change(&self, hash: Hash) -> bool {
        libpijul::change::Change::deserialize(
            &self.changestore().change_file(hash).to_string_lossy(),
            Some(&hash),
        )
        .is_ok()
    }
    // TODO maybe make a proper channel struct etc later
    pub fn apply_change_to_channel(&self, chan: &str, change: Hash) -> Result<(), anyhow::Error> {
        let mut txn = self.pristine()?.mut_txn_begin()?;
        let chan = if let Some(chan) = txn.load_channel(chan)? {
            chan
        } else {
            bail!("channel not found")
        };
        {
            let mut write_channel = chan.write();
            txn.apply_change(
                &libpijul::changestore::filesystem::FileSystem::from_changes(
                    self.changestore().dir(),
                ),
                &mut write_channel,
                &change,
            )?;
        }
        txn.commit()?;
        Ok(())

            full_path: full_path,

            full_path: full_path.join(libpijul::DOT_DIR),

        // TODO validate the txn needs closing?
        // TODO validate the txn needs closing?
        //
        // Or does the drop function do that?

        println!("loaded channel, changes for: {}, from: {}", channel, from);

            println!("found change");

            let h: libpijul::Hash = hash.into();

            let h: Hash = hash.into();

            println!("{}.{}.{}", offset, h.to_base32(), m.to_base32());

use anyhow::bail;

    pub fn hash_from_string(hash: String) -> Option<Hash> {
        Hash::from_base32(hash.as_bytes())
    }

    // change_file will ensure parent directories are created thus has side-effects on disk
    pub fn change_file(&self, hash: String) -> Result<PathBuf, anyhow::Error> {
        let h = if let Some(h) = Hash::from_base32(hash.as_bytes()) {
            h
        } else {
            bail!("invalid hash to store a change")
        };

    pub fn change_file(&self, hash: Hash) -> PathBuf {

        libpijul::changestore::filesystem::push_filename(&mut path, &h);

        libpijul::changestore::filesystem::push_filename(&mut path, &hash);

        std::fs::create_dir_all(path.parent().unwrap())?;

        path
    }

        Ok(path)

    pub fn ensure_parent_dirs(&self, hash: Hash) -> Result<(), anyhow::Error> {
        println!(
            "parent dir: {}",
            self.change_file(hash).parent().unwrap().display()
        );
        Ok(std::fs::create_dir_all(
            self.change_file(hash).parent().unwrap(),
        )?)

    fn dir(&self) -> PathBuf {

    // Full path the the changes directory, last path elements are thus .pijul/changes
    pub fn dir(&self) -> PathBuf {

serde = "1.0"

features = ["secrets"]

features = ["secrets", "json"]

 "serde",

 "serde_json",