Metadata-Version: 2.4
Name: id_crud
Version: 0.2.0
Summary: Base CRUD modules
Requires-Python: >=3.11
Description-Content-Type: text/markdown
Requires-Dist: SQLAlchemy>=2.0
Requires-Dist: pydantic>=2.0
Requires-Dist: internal_calls==0.2

# id_monitoring

build from source
```
git clone id_monitoring
python -m build id_monitoring
cd id_monitoring
bash push.sh
```

setup
```python
```

usage in code
```python
```



```
    @RollBackGuard
    async def get_notes(self, db: AsyncSession, record_id: UUID):
        record = await db.get(self.model, record_id)
        if not record:
            raise HTTPException(404, "record not found")

        notes = deepcopy(record.note or {})
        notes.pop(self.MD_KEY, None)
        return notes

    @RollBackGuard
    async def get_note(self, db: AsyncSession, record_id: UUID, note_id: str):
        record = await db.get(self.model, record_id)
        if not record:
            raise HTTPException(404, "record not found")

        notes = record.note or {}
        return notes.get(note_id, {})

    @RollBackGuard
    async def add_note(self, db: AsyncSession, record_id: UUID, creator: UUID, form: sch.Note):
        record = await db.get(self.model, record_id)
        if not record:
            raise HTTPException(404, "record not found")

        notes = deepcopy(record.note or {})
        notes.setdefault(self.MD_KEY, {"next_key": 0})

        current_key = notes[self.MD_KEY].get("next_key", 0)
        notes[self.MD_KEY]["next_key"] = current_key + 1

        notes[str(current_key)] = {
            "creator_id": str(creator),
            "created_datetime": str(ir_now()),
            "content": form.content,
            "attachment": form.attachment,
        }

        record.note = notes
        await db.commit()
        await db.refresh(record)
        return {"result": f"note added. ID=`{current_key}`"}

    @RollBackGuard
    async def update_note(self, db: AsyncSession, record_id: UUID, note_id: str, form: sch.Note, user):
        record = await db.get(self.model, record_id)
        if not record:
            raise HTTPException(404, "record not found")

        notes = deepcopy(record.note or {})
        note = notes.get(note_id)
        if not note:
            raise HTTPException(404, "note not found")

        creator = note.get("creator_id", None)
        if creator is None or creator != str(user):
            raise HTTPException(404, "only creater can edit the note")

        note["content"] = form.content
        note["attachment"] = form.attachment

        record.note = notes
        await db.commit()
        await db.refresh(record)

        return {"result": f"note updated."}
    #TODO: Soft delete
    # TODO: Seperate
```
