Add the tests to the command file

Merge pull request #74 from gmbrax/test/photoservice-unit-tests
Add the tests for the update on photo service
2026-11-10 14:10:16 +00:00 · 2025-07-21 19:36:37 -03:00 · 2025-07-21 19:01:23 -03:00 · 2025-07-21 18:55:28 -03:00 · 2025-07-21 18:07:18 -03:00 · 2025-07-21 18:07:01 -03:00
43 changed files with 3498 additions and 502 deletions
@@ -1,24 +0,0 @@
 name: Pylint
 on: [push]
 jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ["3.10"]
    steps:
    - uses: actions/checkout@v4
    - name: Set up Python ${{ matrix.python-version }}
      uses: actions/setup-python@v3
      with:
        python-version: ${{ matrix.python-version }}
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
        pip install pylint
    - name: Analysing the code with pylint
      run: |
        pylint --disable=C0114,C0115,C0116 --exit-zero $(git ls-files '*.py')
@@ -0,0 +1,63 @@
 name: Pylint and SonarCloud
 on: 
  push:
    branches: [ main, master, staging ]
  pull_request:
    branches: [ main, master, staging ]
 jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ["3.10"]
    steps:
    - uses: actions/checkout@v4
      with:
        fetch-depth: 0  # Necessário para SonarCloud
    - name: Set up Python ${{ matrix.python-version }}
      uses: actions/setup-python@v4
      with:
        python-version: ${{ matrix.python-version }}
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
        pip install pylint ruff coverage pytest
    - name: Analysing the code with pylint (console output)
      run: |
        pylint --disable=C0114,C0115,C0116 --exit-zero $(git ls-files '*.py') || true
    - name: Generate Pylint report for SonarCloud
      run: |
        pylint --disable=C0114,C0115,C0116 --output-format=json --exit-zero $(git ls-files '*.py') > pylint-report.json || true
    - name: Run Ruff
      run: |
        ruff check --output-format=json . > ruff-report.json || true
    - name: Run tests with coverage (if you have tests)
      run: |
        if [ -d "tests" ] || [ -f "test_*.py" ] || [ -f "*_test.py" ]; then
          coverage run -m pytest || true
          coverage xml || true
        else
          echo "No tests found, skipping coverage"
        fi
    - name: SonarCloud Scan
      uses: SonarSource/sonarqube-scan-action@v5.0.0
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
      with:
        args: >
          -Dsonar.projectKey=gmbrax_Pilgrim
          -Dsonar.organization=gmbrax
          -Dsonar.python.pylint.reportPaths=pylint-report.json
          -Dsonar.python.ruff.reportPaths=ruff-report.json
          -Dsonar.python.coverage.reportPaths=coverage.xml
@@ -1,6 +1,8 @@
 # Database files
 database.db
 .build-vend/
 dist_nuitka/
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
@@ -1,200 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="AutoImportSettings">
    <option name="autoReloadType" value="SELECTIVE" />
  </component>
  <component name="ChangeListManager">
    <list default="true" id="0a7f92e2-b44a-4dfe-8e01-136d1c0c18be" name="Changes" comment="Added the travel_diary id as foreign key to the photos and add a check on the creation to avoid leaving it empty or bad referenced">
      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
      <change beforePath="$PROJECT_DIR$/src/pilgrim/service/photo_service.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/pilgrim/service/photo_service.py" afterDir="false" />
      <change beforePath="$PROJECT_DIR$/src/pilgrim/ui/screens/diary_list_screen.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/pilgrim/ui/screens/diary_list_screen.py" afterDir="false" />
    </list>
    <option name="SHOW_DIALOG" value="false" />
    <option name="HIGHLIGHT_CONFLICTS" value="true" />
    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
    <option name="LAST_RESOLUTION" value="IGNORE" />
  </component>
  <component name="FileTemplateManagerImpl">
    <option name="RECENT_TEMPLATES">
      <list>
        <option value="Python Script" />
      </list>
    </option>
  </component>
  <component name="Git.Settings">
    <option name="RECENT_BRANCH_BY_REPOSITORY">
      <map>
        <entry key="$PROJECT_DIR$" value="proposed_changes" />
      </map>
    </option>
    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
    <option name="UPDATE_TYPE" value="REBASE" />
  </component>
  <component name="GitHubPullRequestSearchHistory">{
  &quot;lastFilter&quot;: {
    &quot;state&quot;: &quot;OPEN&quot;,
    &quot;assignee&quot;: &quot;gmbrax&quot;
  }
 }</component>
  <component name="GithubPullRequestsUISettings">{
  &quot;selectedUrlAndAccountId&quot;: {
    &quot;url&quot;: &quot;https://github.com/gmbrax/Pilgrim.git&quot;,
    &quot;accountId&quot;: &quot;213d8456-c67d-4cfd-99a6-337d47c35b4a&quot;
  }
 }</component>
  <component name="ProjectColorInfo">{
  &quot;associatedIndex&quot;: 0
 }</component>
  <component name="ProjectId" id="2y0y1J9RlHT6m1qL5RuCBf0Ramp" />
  <component name="ProjectViewState">
    <option name="hideEmptyMiddlePackages" value="true" />
    <option name="showLibraryContents" value="true" />
  </component>
  <component name="PropertiesComponent"><![CDATA[{
  "keyToString": {
    "ModuleVcsDetector.initialDetectionPerformed": "true",
    "Python.Database.executor": "Run",
    "Python.command.executor": "Run",
    "Python.main.executor": "Run",
    "Python.pilgrim.executor": "Run",
    "RunOnceActivity.ShowReadmeOnStart": "true",
    "RunOnceActivity.git.unshallow": "true",
    "git-widget-placeholder": "feat-TUI",
    "node.js.detected.package.eslint": "true",
    "node.js.detected.package.tslint": "true",
    "node.js.selected.package.eslint": "(autodetect)",
    "node.js.selected.package.tslint": "(autodetect)",
    "nodejs_package_manager_path": "npm",
    "vue.rearranger.settings.migration": "true"
  }
 }]]></component>
  <component name="RunManager">
    <configuration name="pilgrim" type="PythonConfigurationType" factoryName="Python" temporary="true" nameIsGenerated="true">
      <module name="Pilgrim" />
      <option name="ENV_FILES" value="" />
      <option name="INTERPRETER_OPTIONS" value="" />
      <option name="PARENT_ENVS" value="true" />
      <envs>
        <env name="PYTHONUNBUFFERED" value="1" />
      </envs>
      <option name="SDK_HOME" value="" />
      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/.venv/bin" />
      <option name="IS_MODULE_SDK" value="false" />
      <option name="ADD_CONTENT_ROOTS" value="true" />
      <option name="ADD_SOURCE_ROOTS" value="true" />
      <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/.venv/bin/pilgrim" />
      <option name="PARAMETERS" value="" />
      <option name="SHOW_COMMAND_LINE" value="false" />
      <option name="EMULATE_TERMINAL" value="false" />
      <option name="MODULE_MODE" value="false" />
      <option name="REDIRECT_INPUT" value="false" />
      <option name="INPUT_FILE" value="" />
      <method v="2" />
    </configuration>
    <recent_temporary>
      <list>
        <item itemvalue="Python.pilgrim" />
      </list>
    </recent_temporary>
  </component>
  <component name="SharedIndexes">
    <attachedChunks>
      <set>
        <option value="bundled-js-predefined-d6986cc7102b-6a121458b545-JavaScript-PY-251.25410.159" />
        <option value="bundled-python-sdk-e0ed3721d81e-36ea0e71a18c-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-251.25410.159" />
      </set>
    </attachedChunks>
  </component>
  <component name="TaskManager">
    <task active="true" id="Default" summary="Default task">
      <changelist id="0a7f92e2-b44a-4dfe-8e01-136d1c0c18be" name="Changes" comment="" />
      <created>1748985568579</created>
      <option name="number" value="Default" />
      <option name="presentableId" value="Default" />
      <updated>1748985568579</updated>
      <workItem from="1748985569621" duration="2124000" />
      <workItem from="1748992451560" duration="312000" />
      <workItem from="1749508687224" duration="371000" />
    </task>
    <task id="LOCAL-00001" summary="Added a Back Relationship in Entry to list all the photos">
      <option name="closed" value="true" />
      <created>1749004109515</created>
      <option name="number" value="00001" />
      <option name="presentableId" value="LOCAL-00001" />
      <option name="project" value="LOCAL" />
      <updated>1749004109515</updated>
    </task>
    <task id="LOCAL-00002" summary="Changed the names of the files to conform the python convection and also added photo_in_entry.py to diminish the cyclic import error in pylint">
      <option name="closed" value="true" />
      <created>1749006784623</created>
      <option name="number" value="00002" />
      <option name="presentableId" value="LOCAL-00002" />
      <option name="project" value="LOCAL" />
      <updated>1749006784623</updated>
    </task>
    <task id="LOCAL-00003" summary="Added the Services layer to the code to do the database operation">
      <option name="closed" value="true" />
      <created>1749140898576</created>
      <option name="number" value="00003" />
      <option name="presentableId" value="LOCAL-00003" />
      <option name="project" value="LOCAL" />
      <updated>1749140898576</updated>
    </task>
    <task id="LOCAL-00004" summary="Added the photo_service.py and modified photo.py to have all the crud operations">
      <option name="closed" value="true" />
      <created>1749155713848</created>
      <option name="number" value="00004" />
      <option name="presentableId" value="LOCAL-00004" />
      <option name="project" value="LOCAL" />
      <updated>1749155713848</updated>
    </task>
    <task id="LOCAL-00005" summary="Made some changes to naming in both the classes and the tables of the database to conform the correct naming scheme">
      <option name="closed" value="true" />
      <created>1749164385581</created>
      <option name="number" value="00005" />
      <option name="presentableId" value="LOCAL-00005" />
      <option name="project" value="LOCAL" />
      <updated>1749164385581</updated>
    </task>
    <task id="LOCAL-00006" summary="Added the travel_diary id as foreign key to the photos and add a check on the creation to avoid leaving it empty or bad referenced">
      <option name="closed" value="true" />
      <created>1749168650225</created>
      <option name="number" value="00006" />
      <option name="presentableId" value="LOCAL-00006" />
      <option name="project" value="LOCAL" />
      <updated>1749168650225</updated>
    </task>
    <option name="localTasksCounter" value="7" />
    <servers />
  </component>
  <component name="TypeScriptGeneratedFilesManager">
    <option name="version" value="3" />
  </component>
  <component name="Vcs.Log.Tabs.Properties">
    <option name="TAB_STATES">
      <map>
        <entry key="MAIN">
          <value>
            <State />
          </value>
        </entry>
      </map>
    </option>
  </component>
  <component name="VcsManagerConfiguration">
    <MESSAGE value="Added a Back Relationship in Entry to list all the photos" />
    <MESSAGE value="Changed the names of the files to conform the python convection and also added photo_in_entry.py to diminish the cyclic import error in pylint" />
    <MESSAGE value="Added the Services layer to the code to do the database operation" />
    <MESSAGE value="Added the photo_service.py and modified photo.py to have all the crud operations" />
    <MESSAGE value="Made some changes to naming in both the classes and the tables of the database to conform the correct naming scheme" />
    <MESSAGE value="Added the travel_diary id as foreign key to the photos and add a check on the creation to avoid leaving it empty or bad referenced" />
    <option name="LAST_COMMIT_MESSAGE" value="Added the travel_diary id as foreign key to the photos and add a check on the creation to avoid leaving it empty or bad referenced" />
  </component>
  <component name="com.intellij.coverage.CoverageDataManagerImpl">
    <SUITE FILE_PATH="coverage/Pilgrim$Database.coverage" NAME="Database Coverage Results" MODIFIED="1748987101492" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/src/Database" />
    <SUITE FILE_PATH="coverage/Pilgrim$pilgrim.coverage" NAME="pilgrim Coverage Results" MODIFIED="1749097142827" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/.venv/bin" />
    <SUITE FILE_PATH="coverage/Pilgrim$main.coverage" NAME="main Coverage Results" MODIFIED="1748992510527" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/src" />
    <SUITE FILE_PATH="coverage/Pilgrim$command.coverage" NAME="command Coverage Results" MODIFIED="1748992876551" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/src/Pilgrim" />
  </component>
 </project>
@@ -0,0 +1,68 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
 ## Unreleased
 ## Planned
 * Installation Method 1 (repository compilation)
 * Organization of trips by date, location, or theme
 * Enhanced photo management features
 * Search functionality
 * Export features
 * Testing implementation
 ## [0.0.4] - 2025-07-19
 ### Added
 * Support for creating new diaries asynchronously, with an option to automatically open the newly created diary
 * Unified "Enter" key support for saving or creating diaries across relevant modals
 * Automatic diary list refresh when returning to the diary screen
 * Application configuration management with a new centralized config system
 * Database location and initialization now configurable via the new config manager
 * Automatic migration of database file to the configuration directory
 * Display of database URL on application startup for transparency
 * Duplicate photo detection before photo creation to prevent redundant entries
 * Photo hash indexing to improve photo lookup performance
 ### Changed
 * Enhanced feedback and validation when editing or creating diary names
 * Streamlined and unified save logic for diary modals, reducing duplicated behavior
 * About screen now displays the actual installed application version dynamically
 * Sidebar and photo-related UI text updated to remove emoji icons for a cleaner appearance
 * Sidebar layout and scrolling behavior improved for better usability
 * Photo hash generation now relies on existing service-provided hashes instead of local computation
 ### Improved
 * Enhanced feedback and validation when editing or creating diary names
 * Streamlined and unified save logic for diary modals, reducing duplicated behavior
 * Sidebar layout and scrolling behavior for better usability
 ## [0.0.3] - 2025-07-07
 ### Changed
 * Removed the dependency on textual-dev from pyproject.toml
 ## [0.0.2] - 2025-07-07
 ### Changed
 * Changed the license in pyproject.toml to BSD
 ## [0.0.1] - 2025-07-06
 ### Added
 * Initial alpha release of Pilgrim travel diary application
 * Create and edit travel diaries
 * Create and edit diary entries
 * Photo ingestion system
 * Photo addition and reference via sidebar
 * Text User Interface (TUI) built with Textual framework
 * Pre-compiled binary installation method (Method 2)
 * Support for Linux operating systems
 * Basic project documentation (README)
 ### Known Issues
 * Installation Method 1 not yet implemented
 * No testing suite implemented yet
 * Some features may be unstable in an alpha version
@@ -1,16 +1,17 @@
-# Python_Pilgrim
+# Pilgrim
 ## Overview
-**Python_Pilgrim** is a Python-based travel diary application designed to help users document and manage their travel experiences. The project provides tools for recording trips, organizing travel notes, and storing memories in a structured and accessible format.
+**Pilgrim** is a Python-based travel diary application designed to help users document and manage their travel
 experiences. The project provides tools for recording trips, organizing travel notes, and storing memories in a
 structured and accessible format.
 ## Features
 - Create and manage travel diaries
 - Add, edit, and delete travel entries
 - Organize trips by date, location, or theme
- Store photos, notes, and other media
+- Store photos and add them to the diary entry
 - Export and share travel logs
 ## Requirements
 - Python 3.8 or higher
@@ -21,30 +22,25 @@
 ## Installation
-1. Clone the repository:
+To install the application you must issue the command:
 ```bash
-    git clone https://github.com/gmbrax/Pilgrim.git
+ pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple Pilgrim
    ```
 2. Navigate to the project directory:
    ```bash
    cd Pilgrim
    ```
 3. Create a virtual environment and, then, activate it:
    ```bash
    python -m venv .venv
    source .venv/bin/activate
    ```
 4. Install the required dependencies:
    ```bash
    pip install -r requirements.txt
 ```
 ## Usage
-To run the main application, execute:
+To use application you just issue:
 ```bash 
-python <???>.py
+pilgrim
 ```
-This will start the Python_Pilgrim application. Follow the on-screen instructions to create and manage your travel diaries.
+This will start the Pilgrim application. Follow the on-screen instructions to create and manage your travel diaries.
 ## Changelog
 To see all the changes in the current version, please refer to the [CHANGELOG](CHANGELOG.md)
 ## License
 This project is licensed under the BSD 3-Clause License — see the [LICENSE](LICENSE) file for details.
@@ -2,10 +2,9 @@
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 [project]
-name = "Pilgrim"
+name = "pilgrim"
-version = "0.0.1"
+version = "0.0.4"
 authors = [
  { name="Gustavo Henrique Santos Souza de Miranda", email="gustavohssmiranda@gmail.com" }
 ]
@@ -14,20 +13,20 @@ readme = "README.md"
 requires-python = ">=3.10"
 classifiers = [
    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
+    "License :: OSI Approved :: BSD License",
    "Operating System :: OS Independent",
 ]
 dependencies = [
    "sqlalchemy",
    "textual",
-    "textual-dev"
+    "tomli",
    "tomli_w",
    "unidecode"
 ]
-[template.plugins.default]
+
 src-layout = true
 [project.urls]
-Homepage = "https://git.gustavomiranda.xyz/GHMiranda/Pilgrim"
+Homepage = "https://github.com/gmbrax/Pilgrim/"
-Issues = "https://git.gustavomiranda.xyz/GHMiranda/Pilgrim"
+Issues = "https://github.com/gmbrax/Pilgrim/issues"
-[tool.hatch.build.targets.wheel]
+
 packages = ["src/pilgrim"]
 [project.scripts]
-pilgrim = "pilgrim:main"
+pilgrim = "pilgrim.command:main"
@@ -1,6 +1,6 @@
 greenlet==3.2.3
 SQLAlchemy==2.0.41
-typing_extensions==4.14.0
+typing_extensions==4.14.1
-textual~=3.3.0
+textual~=4.0.0
@@ -1,18 +1,21 @@
 from pilgrim.database import Database
 from pilgrim.service.mocks.service_manager_mock import ServiceManagerMock
 from pilgrim.service.servicemanager import ServiceManager
 from pilgrim.ui.ui import UIApp
 from pilgrim.utils import ConfigManager
 class Application:
    def __init__(self):
-        self.database = Database()
+        self.config_manager = ConfigManager()
        self.config_manager.read_config()  # Chamar antes de criar o Database
        self.database = Database(self.config_manager)
        session = self.database.session()
        session_manager = ServiceManager()
        session_manager.set_session(session)
-        self.ui = UIApp(session_manager)
+        self.ui = UIApp(session_manager, self.config_manager)
    def run(self):
        print(f"URL do banco: {self.config_manager.database_url}")
        self.database.create()
        self.ui.run()
@@ -1,21 +1,38 @@
 from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import declarative_base
 from sqlalchemy.orm import sessionmaker
 from pathlib import Path
 import os
 import shutil
 from pilgrim.utils import ConfigManager
 Base = declarative_base()
 class Database:
-    def __init__(self):
+
    def __init__(self, config_manager: ConfigManager):
        self.db_path = config_manager.database_url
        # Garantir que o diretório existe
        db_dir = os.path.dirname(self.db_path)
        if not os.path.exists(db_dir):
            os.makedirs(db_dir, exist_ok=True)
        self.engine = create_engine(
-            "sqlite:///database.db",
+            f"sqlite:///{self.db_path}",
            echo=False,
            connect_args={"check_same_thread": False},
        )
-        self.session = sessionmaker(bind=self.engine, autoflush=False, autocommit=False)
+        self._session_maker = sessionmaker(bind=self.engine, autoflush=False, autocommit=False)
    def create(self):
        Base.metadata.create_all(self.engine)
    def session(self):
        return self._session_maker()
    def get_db(self):
-        return self.session()
+        return self._session_maker()
@@ -1,23 +1,26 @@
 from typing import Any
-from sqlalchemy import Column, Integer, String, ForeignKey
+from pilgrim.models.photo_in_entry import photo_entry_association
 from sqlalchemy import Column, Integer, String, ForeignKey, DateTime
 from sqlalchemy.orm import relationship
-from pilgrim.models.photo_in_entry import photo_entry_association
+from pilgrim.database import Base
-from ..database import Base
+
 class Entry(Base):
    __tablename__ = "entries"
    id = Column(Integer, primary_key=True)
-    title = Column(String)
+    title = Column(String,nullable=False)
    text = Column(String)
-    date = Column(String)
+    date = Column(DateTime,nullable=False)
    photos = relationship(
        "Photo",
        secondary=photo_entry_association,
        back_populates="entries")
    fk_travel_diary_id = Column(Integer, ForeignKey("travel_diaries.id"), nullable=False)
    travel_diary = relationship("TravelDiary", back_populates="entries")
    def __init__(self, title: str, text: str, date: str, travel_diary_id: int, **kw: Any):
        super().__init__(**kw)
        self.title = title
@@ -1,10 +1,14 @@
 from typing import Any
 from datetime import datetime
 from pathlib import Path
-from sqlalchemy import Column, Integer, String, ForeignKey
+from sqlalchemy import Column, Integer, String, ForeignKey, DateTime
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql.schema import Index
 from pilgrim.models.photo_in_entry import photo_entry_association
-from ..database import Base
+from pilgrim.database import Base
 class Photo(Base):
@@ -12,8 +16,9 @@ class Photo(Base):
    id = Column(Integer, primary_key=True)
    filepath = Column(String)
    name = Column(String)
-    addition_date = Column(String)
+    addition_date = Column(DateTime, default=datetime.now)
    caption = Column(String)
    photo_hash = Column(String,name='hash')
    entries = relationship(
        "Entry",
        secondary=photo_entry_association,
@@ -21,11 +26,22 @@ class Photo(Base):
    )
    fk_travel_diary_id = Column(Integer, ForeignKey("travel_diaries.id"), nullable=False)
    travel_diary = relationship("TravelDiary", back_populates="photos")
    __table_args__ = (
        Index('idx_photo_hash_diary', 'hash', 'fk_travel_diary_id'),
    )
-    def __init__(self, filepath, name, addition_date=None, caption=None, entries=None, **kw: Any):
+    def __init__(self, filepath, name, photo_hash, addition_date=None, caption=None, entries=None, fk_travel_diary_id=None, **kw: Any):
        super().__init__(**kw)
        # Convert Path to string if needed
        if isinstance(filepath, Path):
            self.filepath = str(filepath)
        else:
            self.filepath = filepath
        self.name = name
-        self.addition_date = addition_date
+        self.addition_date = addition_date if addition_date is not None else datetime.now()
        self.caption = caption
-        self.entries = entries
+        self.photo_hash = photo_hash
        self.entries = entries if entries is not None else []
        if fk_travel_diary_id is not None:
            self.fk_travel_diary_id = fk_travel_diary_id
@@ -1,6 +1,6 @@
 from sqlalchemy import Table, Column, Integer, ForeignKey
-from ..database import Base
+from pilgrim.database import Base
 photo_entry_association = Table('photo_entry_association', Base.metadata,
 Column('id', Integer, primary_key=True, autoincrement=True),
@@ -1,14 +1,28 @@
 from typing import Any
-from sqlalchemy import Column, String, Integer
+from sqlalchemy import Column, Integer, String, UniqueConstraint
 from sqlalchemy.orm import relationship
 from pilgrim.database import Base
 from ..database import Base
 class TravelDiary(Base):
    __tablename__ = "travel_diaries"
    id = Column(Integer, primary_key=True)
-    name = Column(String)
+    name = Column(String, nullable=False)
    directory_name = Column(String, nullable=False, unique=True)
    entries = relationship("Entry", back_populates="travel_diary", cascade="all, delete-orphan")
    photos = relationship("Photo", back_populates="travel_diary", cascade="all, delete-orphan")
-    def __init__(self, name: str, **kw: Any):
+    __table_args__ = (
        UniqueConstraint('directory_name', name='uq_travel_diary_directory_name'),
    )
    def __init__(self, name: str, directory_name: str = None, **kw: Any):
        super().__init__(**kw)
        self.name = name
        self.directory_name = directory_name  # Será definido pelo service
    def __repr__(self):
        return f"<TravelDiary(id={self.id}, name='{self.name}', directory_name='{self.directory_name}')>"
@@ -1,17 +1,26 @@
 from datetime import datetime
 from typing import List
-from ..models.entry import Entry
+
-from ..models.travel_diary import TravelDiary
+from pilgrim.models.entry import Entry
 from pilgrim.models.travel_diary import TravelDiary
 from pilgrim.models.photo import Photo  # ✨ Importe o modelo Photo
 class EntryService:
    def __init__(self, session):
        self.session = session
-    def create(self, travel_diary_id:int, title: str, text: str, date: str, ):
+    # ✨ Modifique a assinatura para aceitar a lista de fotos
    def create(self, travel_diary_id: int, title: str, text: str, date: datetime, photos: List[Photo]):
        travel_diary = self.session.query(TravelDiary).filter(TravelDiary.id == travel_diary_id).first()
        if not travel_diary:
            return None
-        new_entry = Entry(title,text,date,travel_diary_id)
+
        new_entry = Entry(title, text, date, travel_diary_id,photos=photos)
        # ✨ Atribua a relação ANTES de adicionar e fazer o commit
        new_entry.photos = photos
        self.session.add(new_entry)
        self.session.commit()
        self.session.refresh(new_entry)
@@ -12,7 +12,14 @@ class PhotoServiceMock(PhotoService):
        self._next_id = 1
    def create(self, filepath: Path, name: str, travel_diary_id, addition_date=None, caption=None) -> Photo | None:
-        new_photo = Photo(filepath, name, addition_date=addition_date, caption=caption)
+        new_photo = Photo(
            filepath=filepath, 
            name=name, 
            addition_date=addition_date, 
            caption=caption,
            fk_travel_diary_id=travel_diary_id
        )
        new_photo.id = self._next_id
        self.mock_data[self._next_id] = new_photo
        self._next_id += 1
        return new_photo
@@ -24,19 +31,18 @@ class PhotoServiceMock(PhotoService):
    def read_all(self) -> List[Photo]:
        return list(self.mock_data.values())
-    def update(self, photo_id: Photo, photo_dst: Photo) -> Photo | None:
+    def update(self, photo_src: Photo, photo_dst: Photo) -> Photo | None:
-        item_to_update:Photo = self.mock_data.get(photo_id)
+        item_to_update: Photo = self.mock_data.get(photo_src.id)
        if item_to_update:
            item_to_update.filepath = photo_dst.filepath if photo_dst.filepath else item_to_update.filepath
            item_to_update.name = photo_dst.name if photo_dst.name else item_to_update.name
            item_to_update.caption = photo_dst.caption if photo_dst.caption else item_to_update.caption
-            item_to_update.addition_date = photo_dst.addition_date if photo_dst.addition_date\
+            item_to_update.addition_date = photo_dst.addition_date if photo_dst.addition_date else item_to_update.addition_date
-                else item_to_update.addition_date
+            item_to_update.fk_travel_diary_id = photo_dst.fk_travel_diary_id if photo_dst.fk_travel_diary_id else item_to_update.fk_travel_diary_id
-            item_to_update.fk_travel_diary_id = photo_dst.fk_travel_diary_id if photo_dst.fk_travel_diary_id \
+            if photo_dst.entries:
-                else item_to_update.fk_travel_diary_id
+                item_to_update.entries = photo_dst.entries
            item_to_update.entries.extend(photo_dst.entries)
            return item_to_update
        return None
-    def delete(self, photo_id: int) -> Photo | None:
+    def delete(self, photo_src: Photo) -> Photo | None:
-        return self.mock_data.pop(photo_id, None)
+        return self.mock_data.pop(photo_src.id, None)
@@ -1,24 +1,108 @@
 import hashlib
 import os
 import shutil
 from datetime import datetime
 from pathlib import Path
 from typing import List
 from pilgrim.models.photo import Photo
 from pilgrim.models.travel_diary import TravelDiary
 from pilgrim.utils import DirectoryManager
 class PhotoService:
    def __init__(self, session):
        self.session = session
-    def create(self, filepath:Path, name:str, travel_diary_id, addition_date=None, caption=None, ) -> Photo | None:
+    @staticmethod
    def hash_file(filepath: Path) -> str:
        """Calculate the hash of a file using SHA3-384."""
        hash_func = hashlib.new('sha3_384')
        with open(filepath, 'rb') as f:
            while chunk := f.read(8192):
                hash_func.update(chunk)
        return hash_func.hexdigest()
    def _ensure_images_directory(self, travel_diary: TravelDiary) -> Path:
        """
        Ensures the images directory exists for the given diary.
        Returns the path to the images directory.
        """
        images_dir = DirectoryManager.get_diary_images_directory(travel_diary.directory_name)
        if not images_dir.exists():
            images_dir.mkdir(parents=True)
            os.chmod(images_dir, 0o700)  # Ensure correct permissions
        return images_dir
    def _copy_photo_to_diary(self, source_path: Path, travel_diary: TravelDiary) -> Path:
        """
        Copies a photo to the diary's images directory.
        Returns the path to the copied file.
        """
        images_dir = self._ensure_images_directory(travel_diary)
        # Get original filename and extension
        original_name = Path(source_path).name
        # Create destination path
        dest_path = images_dir / original_name
        # If file with same name exists, add a number
        counter = 1
        while dest_path.exists():
            name_parts = original_name.rsplit('.', 1)
            if len(name_parts) > 1:
                dest_path = images_dir / f"{name_parts[0]}_{counter}.{name_parts[1]}"
            else:
                dest_path = images_dir / f"{original_name}_{counter}"
            counter += 1
        # Copy the file
        shutil.copy2(source_path, dest_path)
        os.chmod(dest_path, 0o600)  # Read/write for owner only
        return dest_path
    def check_photo_by_hash(self, photohash:str, traveldiaryid:int):
        photo = (self.session.query(Photo).filter(Photo.photo_hash == photohash,Photo.fk_travel_diary_id == traveldiaryid)
                 .first())
        return photo
    def create(self, filepath: Path, name: str, travel_diary_id: int, caption=None, addition_date=None) -> Photo | None:
        travel_diary = self.session.query(TravelDiary).filter(TravelDiary.id == travel_diary_id).first()
        if not travel_diary:
            return None
-        new_photo = Photo(filepath, name, addition_date=addition_date, caption=caption)
+        photo_hash = self.hash_file(filepath)
        if self.check_photo_by_hash(photo_hash, travel_diary_id):
            return None
        # Copy photo to diary's images directory
        copied_path = self._copy_photo_to_diary(filepath, travel_diary)
        # Convert addition_date string to datetime if needed
        if isinstance(addition_date, str):
            try:
                addition_date = datetime.strptime(addition_date, "%Y-%m-%d %H:%M:%S")
            except ValueError:
                addition_date = None
        new_photo = Photo(
            filepath=str(copied_path),  # Store the path to the copied file
            name=name, 
            caption=caption, 
            fk_travel_diary_id=travel_diary_id,
            addition_date=addition_date,
            photo_hash=photo_hash
        )
        self.session.add(new_photo)
        self.session.commit()
        self.session.refresh(new_photo)
        return new_photo
    def read_by_id(self, photo_id:int) -> Photo:
        return self.session.query(Photo).get(photo_id)
@@ -28,11 +112,30 @@ class PhotoService:
    def update(self, photo_src: Photo, photo_dst: Photo) -> Photo | None:
        original: Photo = self.read_by_id(photo_src.id)
        if original:
-            original.filepath = photo_dst.filepath
+            # If filepath changed, need to copy new file
            if str(photo_dst.filepath) != str(original.filepath):
                travel_diary = self.session.query(TravelDiary).filter(
                    TravelDiary.id == original.fk_travel_diary_id).first()
                if travel_diary:
                    # Copy new photo
                    new_path = self._copy_photo_to_diary(Path(photo_dst.filepath), travel_diary)
                    # Delete old photo if it exists in our images directory
                    old_path = Path(original.filepath)
                    if old_path.exists() and str(DirectoryManager.get_diaries_root()) in str(old_path):
                        old_path.unlink()
                    original.filepath = str(new_path)
                    # Update hash based on the new copied file
                    original.photo_hash = self.hash_file(new_path)
            original.name = photo_dst.name
            original.addition_date = photo_dst.addition_date
            original.caption = photo_dst.caption
-            original.entries.extend(photo_dst.entries)
+
            if photo_dst.entries and len(photo_dst.entries) > 0:
                if original.entries is None:
                    original.entries = []
                original.entries = photo_dst.entries  # Replace instead of extend
            self.session.commit()
            self.session.refresh(original)
            return original
@@ -41,8 +144,25 @@ class PhotoService:
    def delete(self, photo_src: Photo) -> Photo | None:
        excluded = self.read_by_id(photo_src.id)
        if excluded:
            # Store photo data before deletion
            deleted_photo = Photo(
                filepath=excluded.filepath,
                name=excluded.name,
                addition_date=excluded.addition_date,
                caption=excluded.caption,
                fk_travel_diary_id=excluded.fk_travel_diary_id,
                id=excluded.id,
                photo_hash=excluded.photo_hash,
                entries=excluded.entries,
            )
            # Delete the physical file if it exists in our images directory
            file_path = Path(excluded.filepath)
            if file_path.exists() and str(DirectoryManager.get_diaries_root()) in str(file_path):
                file_path.unlink()
            self.session.delete(excluded)
            self.session.commit()
-            self.session.refresh(excluded)
+            
-            return excluded
+            return deleted_photo
        return None
@@ -1,4 +1,5 @@
 from pilgrim.service.entry_service import EntryService
 from pilgrim.service.photo_service import PhotoService
 from pilgrim.service.travel_diary_service import TravelDiaryService
@@ -17,3 +18,7 @@ class ServiceManager:
        if self.session is not None:
            return TravelDiaryService(self.session)
        return None
    def get_photo_service(self):
        if self.session is not None:
            return PhotoService(self.session)
        return None
@@ -1,30 +1,134 @@
-from ..models.travel_diary import TravelDiary
+import os
-import asyncio
+import re
 import shutil
 from pathlib import Path
 from pilgrim.utils import DirectoryManager
 from sqlalchemy.exc import IntegrityError
 from pilgrim.models.travel_diary import TravelDiary
 from unidecode import unidecode
 class TravelDiaryService:
    def __init__(self, session):
        self.session = session
    def _sanitize_directory_name(self, name: str) -> str:
        """
        Sanitizes a diary name for use as a directory name.
        - Removes special characters
        - Replaces spaces with underscores
        - Ensures name is unique by adding a suffix if needed
        """
        transliterated_name = unidecode(name)
        # Remove special characters and replace spaces
        safe_name = re.sub(r'[^\w\s-]', '', transliterated_name)
        safe_name = safe_name.strip().replace(' ', '_').lower()
        # Ensure we have a valid name
        if not safe_name:
            safe_name = "unnamed_diary"
        # Check if name is already used in database
        base_name = safe_name
        counter = 1
        while self.session.query(TravelDiary).filter_by(directory_name=safe_name).first() is not None:
            safe_name = f"{base_name}_{counter}"
            counter += 1
        return safe_name
    def _get_diary_directory(self, diary: TravelDiary) -> Path:
        """Returns the directory path for a diary."""
        return DirectoryManager.get_diary_directory(diary.directory_name)
    def _get_diary_data_directory(self, diary: TravelDiary) -> Path:
        """Returns the data directory path for a diary."""
        return DirectoryManager.get_diary_data_directory(diary.directory_name)
    def _ensure_diary_directory(self, diary: TravelDiary) -> Path:
        """
        Creates and returns the directory structure for a diary:
        ~/.pilgrim/diaries/{directory_name}/data/
        """
        # Create diary directory
        diary_dir = self._get_diary_directory(diary)
        diary_dir.mkdir(exist_ok=True)
        os.chmod(diary_dir, 0o700)
        # Create data subdirectory
        data_dir = self._get_diary_data_directory(diary)
        data_dir.mkdir(exist_ok=True)
        os.chmod(data_dir, 0o700)
        return data_dir
    def _cleanup_diary_directory(self, diary: TravelDiary):
        """Removes the diary directory and all its contents."""
        diary_dir = self._get_diary_directory(diary)
        if diary_dir.exists():
            shutil.rmtree(diary_dir)
    async def async_create(self, name: str):
-        new_travel_diary = TravelDiary(name)
+        # Generate safe directory name
        directory_name = self._sanitize_directory_name(name)
        # Create diary with directory name
        new_travel_diary = TravelDiary(name=name, directory_name=directory_name)
        try:
            self.session.add(new_travel_diary)
            self.session.commit()
            self.session.refresh(new_travel_diary)
            # Create directory structure for the new diary
            self._ensure_diary_directory(new_travel_diary)
            return new_travel_diary
        except IntegrityError:
            self.session.rollback()
            raise ValueError(f"Could not create diary: directory name '{directory_name}' already exists")
    def read_by_id(self, travel_id: int):
-        return self.session.query(TravelDiary).get(travel_id)
+        diary = self.session.query(TravelDiary).get(travel_id)
        if diary:
            # Ensure directory exists when reading
            self._ensure_diary_directory(diary)
        return diary
    def read_all(self):
-        return self.session.query(TravelDiary).all()
+        diaries = self.session.query(TravelDiary).all()
        # Ensure directories exist for all diaries
        for diary in diaries:
            self._ensure_diary_directory(diary)
        return diaries
    def update(self, travel_diary_id: int, name: str):
        original = self.read_by_id(travel_diary_id)
        if original is not None:
            try:
                # Generate new directory name
                new_directory_name = self._sanitize_directory_name(name)
                old_directory = self._get_diary_directory(original)
                # Update diary
                original.name = name
                original.directory_name = new_directory_name
                self.session.commit()
                self.session.refresh(original)
                # Rename directory if it exists
                new_directory = self._get_diary_directory(original)
                if old_directory.exists() and old_directory != new_directory:
                    old_directory.rename(new_directory)
                return original
            except IntegrityError:
                self.session.rollback()
                raise ValueError(f"Could not update diary: directory name '{new_directory_name}' already exists")
        return None
    async def async_update(self, travel_diary_id: int, name: str):
        return self.update(travel_diary_id, name)
@@ -32,7 +136,14 @@ class TravelDiaryService:
    def delete(self, travel_diary_id: TravelDiary):
        excluded = self.read_by_id(travel_diary_id.id)
        if excluded is not None:
            try:
                # First delete the directory
                self._cleanup_diary_directory(excluded)
                # Then delete from database
                self.session.delete(travel_diary_id)
                self.session.commit()
                return excluded
            except Exception as e:
                self.session.rollback()
                raise ValueError(f"Could not delete diary: {str(e)}")
        return None
@@ -3,7 +3,7 @@ from textual.binding import Binding
 from textual.screen import Screen
 from textual.widgets import Header, Footer, Button, Label, TextArea
 from textual.containers import Container
-
+from importlib.metadata import version
 class AboutScreen(Screen[bool]):
    """Screen to display application information."""
@@ -20,7 +20,7 @@ class AboutScreen(Screen[bool]):
        self.app_title = Label("Pilgrim", id="AboutScreen_AboutTitle",classes="AboutScreen_AboutTitle")
        self.content = Label("A TUI Based Travel Diary Application", id="AboutScreen_AboutContent",
                             classes="AboutScreen_AboutContent")
-        self.version = Label("Version: 0.0.1", id="AboutScreen_AboutVersion",
+        self.version = Label(f"Version: {version('Pilgrim')}", id="AboutScreen_AboutVersion",
                             classes="AboutScreen_AboutVersion")
        self.developer = Label("Developed By: Gustavo Henrique Miranda ", id="AboutScreen_AboutAuthor")
        self.contact = Label("git.gustavomiranda.xyz", id="AboutScreen_AboutContact",
@@ -37,7 +37,493 @@ Redistribution and use in source and binary forms, with or without modification,
 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."""
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 This Software uses the following third party libraries:
 - SQLAlchemy: https://www.sqlalchemy.org/
                          Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/
   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
   1. Definitions.
      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.
      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.
      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.
      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.
      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.
      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.
      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).
      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.
      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."
      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.
   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.
   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.
   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:
      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and
      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and
      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and
      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.
      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.
   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.
   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.
   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.
   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.
   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.
   END OF TERMS AND CONDITIONS
   APPENDIX: How to apply the Apache License to your work.
      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "{}"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.
   Copyright {yyyy} {name of copyright owner}
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
       http://www.apache.org/licenses/LICENSE-2.0
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 - Textual: https://github.com/Textualize/textual
    MIT License
    Copyright (c) 2021 Will McGugan
    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:
    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.
 - greenlet: https://github.com/python-greenlet/
        The following files are derived from Stackless Python and are subject to the
    same license as Stackless Python:
        src/greenlet/slp_platformselect.h
        files in src/greenlet/platform/ directory
    See LICENSE.PSF and http://www.stackless.com/ for details.
    Unless otherwise noted, the files in greenlet have been released under the
    following MIT license:
    Copyright (c) Armin Rigo, Christian Tismer and contributors
    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    THE SOFTWARE.
 - typing_extensions: https://github.com/python/typing_extensions
        Python software and documentation are licensed under the
    Python Software Foundation License Version 2.
    Starting with Python 3.8.6, examples, recipes, and other code in
    the documentation are dual licensed under the PSF License Version 2
    and the Zero-Clause BSD license.
    Some software incorporated into Python is under different licenses.
    The licenses are listed with code falling under that license.
    PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
    --------------------------------------------
    1. This LICENSE AGREEMENT is between the Python Software Foundation
    ("PSF"), and the Individual or Organization ("Licensee") accessing and
    otherwise using this software ("Python") in source or binary form and
    its associated documentation.
    2. Subject to the terms and conditions of this License Agreement, PSF hereby
    grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
    analyze, test, perform and/or display publicly, prepare derivative works,
    distribute, and otherwise use Python alone or in any derivative version,
    provided, however, that PSF's License Agreement and PSF's notice of copyright,
    i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
    2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation;
    All Rights Reserved" are retained in Python alone or in any derivative version
    prepared by Licensee.
    3. In the event Licensee prepares a derivative work that is based on
    or incorporates Python or any part thereof, and wants to make
    the derivative work available to others as provided herein, then
    Licensee hereby agrees to include in any such work a brief summary of
    the changes made to Python.
    4. PSF is making Python available to Licensee on an "AS IS"
    basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
    IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
    DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
    FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
    INFRINGE ANY THIRD PARTY RIGHTS.
    5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
    FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
    A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
    OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
    6. This License Agreement will automatically terminate upon a material
    breach of its terms and conditions.
    7. Nothing in this License Agreement shall be deemed to create any
    relationship of agency, partnership, or joint venture between PSF and
    Licensee.  This License Agreement does not grant permission to use PSF
    trademarks or trade name in a trademark sense to endorse or promote
    products or services of Licensee, or any third party.
    8. By copying, installing or otherwise using Python, Licensee
    agrees to be bound by the terms and conditions of this License
    Agreement.
    BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
    -------------------------------------------
    BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
    1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
    office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
    Individual or Organization ("Licensee") accessing and otherwise using
    this software in source or binary form and its associated
    documentation ("the Software").
    2. Subject to the terms and conditions of this BeOpen Python License
    Agreement, BeOpen hereby grants Licensee a non-exclusive,
    royalty-free, world-wide license to reproduce, analyze, test, perform
    and/or display publicly, prepare derivative works, distribute, and
    otherwise use the Software alone or in any derivative version,
    provided, however, that the BeOpen Python License is retained in the
    Software, alone or in any derivative version prepared by Licensee.
    3. BeOpen is making the Software available to Licensee on an "AS IS"
    basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
    IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
    DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
    FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
    INFRINGE ANY THIRD PARTY RIGHTS.
    4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
    SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
    AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
    DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
    5. This License Agreement will automatically terminate upon a material
    breach of its terms and conditions.
    6. This License Agreement shall be governed by and interpreted in all
    respects by the law of the State of California, excluding conflict of
    law provisions.  Nothing in this License Agreement shall be deemed to
    create any relationship of agency, partnership, or joint venture
    between BeOpen and Licensee.  This License Agreement does not grant
    permission to use BeOpen trademarks or trade names in a trademark
    sense to endorse or promote products or services of Licensee, or any
    third party.  As an exception, the "BeOpen Python" logos available at
    http://www.pythonlabs.com/logos.html may be used according to the
    permissions granted on that web page.
    7. By copying, installing or otherwise using the software, Licensee
    agrees to be bound by the terms and conditions of this License
    Agreement.
    CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
    ---------------------------------------
    1. This LICENSE AGREEMENT is between the Corporation for National
    Research Initiatives, having an office at 1895 Preston White Drive,
    Reston, VA 20191 ("CNRI"), and the Individual or Organization
    ("Licensee") accessing and otherwise using Python 1.6.1 software in
    source or binary form and its associated documentation.
    2. Subject to the terms and conditions of this License Agreement, CNRI
    hereby grants Licensee a nonexclusive, royalty-free, world-wide
    license to reproduce, analyze, test, perform and/or display publicly,
    prepare derivative works, distribute, and otherwise use Python 1.6.1
    alone or in any derivative version, provided, however, that CNRI's
    License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
    1995-2001 Corporation for National Research Initiatives; All Rights
    Reserved" are retained in Python 1.6.1 alone or in any derivative
    version prepared by Licensee.  Alternately, in lieu of CNRI's License
    Agreement, Licensee may substitute the following text (omitting the
    quotes): "Python 1.6.1 is made available subject to the terms and
    conditions in CNRI's License Agreement.  This Agreement together with
    Python 1.6.1 may be located on the internet using the following
    unique, persistent identifier (known as a handle): 1895.22/1013.  This
    Agreement may also be obtained from a proxy server on the internet
    using the following URL: http://hdl.handle.net/1895.22/1013".
    3. In the event Licensee prepares a derivative work that is based on
    or incorporates Python 1.6.1 or any part thereof, and wants to make
    the derivative work available to others as provided herein, then
    Licensee hereby agrees to include in any such work a brief summary of
    the changes made to Python 1.6.1.
    4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
    basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
    IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
    DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
    FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
    INFRINGE ANY THIRD PARTY RIGHTS.
    5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
    1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
    A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
    OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
    6. This License Agreement will automatically terminate upon a material
    breach of its terms and conditions.
    7. This License Agreement shall be governed by the federal
    intellectual property law of the United States, including without
    limitation the federal copyright law, and, to the extent such
    U.S. federal law does not apply, by the law of the Commonwealth of
    Virginia, excluding Virginia's conflict of law provisions.
    Notwithstanding the foregoing, with regard to derivative works based
    on Python 1.6.1 that incorporate non-separable material that was
    previously distributed under the GNU General Public License (GPL), the
    law of the Commonwealth of Virginia shall govern this License
    Agreement only as to issues arising under or with respect to
    Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
    License Agreement shall be deemed to create any relationship of
    agency, partnership, or joint venture between CNRI and Licensee.  This
    License Agreement does not grant permission to use CNRI trademarks or
    trade name in a trademark sense to endorse or promote products or
    services of Licensee, or any third party.
    8. By clicking on the "ACCEPT" button where indicated, or by copying,
    installing or otherwise using Python 1.6.1, Licensee agrees to be
    bound by the terms and conditions of this License Agreement.
            ACCEPT
    CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
    --------------------------------------------------
    Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
    The Netherlands.  All rights reserved.
    Permission to use, copy, modify, and distribute this software and its
    documentation for any purpose and without fee is hereby granted,
    provided that the above copyright notice appear in all copies and that
    both that copyright notice and this permission notice appear in
    supporting documentation, and that the name of Stichting Mathematisch
    Centrum or CWI not be used in advertising or publicity pertaining to
    distribution of the software without specific, written prior
    permission.
    STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
    THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
    FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
    FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
    OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
    ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION
    ----------------------------------------------------------------------
    Permission to use, copy, modify, and/or distribute this software for any
    purpose with or without fee is hereby granted.
    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
    PERFORMANCE OF THIS SOFTWARE.
    """
        self.license.read_only = True
        self.about_container = Container(self.app_title, self.content, self.version, self.developer,
                                         self.contact, id="AboutScreen_SubContainer",
@@ -207,28 +207,17 @@ class DiaryListScreen(Screen):
        self.app.push_screen(NewDiaryModal(),self._on_new_diary_submitted)
    def _on_new_diary_submitted(self, result):
-        self.notify(str(result))
+        """Callback after diary creation"""
-        if result:
+        if result:  # Se result não é string vazia, o diário foi criado
-            self.notify(f"Creating Diary:{result}'...")
+            self.notify(f"Returning to diary list...")
-            self.call_later(self._async_create_diary,result)
+            # Atualiza a lista de diários
            self.refresh_diaries()
        else:
-            self.notify(f"Canceled...")
+            self.notify(f"Creation canceled...")
    async def _async_create_diary(self,name: str):
        try:
            service = self.app.service_manager.get_travel_diary_service()
            created_diary = await service.async_create(name)
            if created_diary:
                self.diary_id_map[created_diary.id] = created_diary.id
                await self.async_refresh_diaries()
                self.notify(f"Diary: '{name}' created!")
            else:
                self.notify("Error Creating the diary")
        except Exception as e:
            self.notify(f"Exception on creating the diary: {str(e)}")
    def _on_screen_resume(self) -> None:
        super()._on_screen_resume()
        self.refresh_diaries()
    def action_edit_selected_diary(self):
        """Action to edit selected diary"""
@@ -1,4 +1,5 @@
 from textual.app import ComposeResult
 from textual.binding import Binding
 from textual.containers import Vertical, Horizontal
 from textual.screen import ModalScreen
 from textual.widgets import Label, Input, Button
@@ -6,7 +7,8 @@ from textual.widgets import Label, Input, Button
 class EditDiaryModal(ModalScreen[tuple[int,str]]):
    BINDINGS = [
-        ("escape", "cancel", "Cancel"),
+        Binding("escape", "cancel", "Cancel"),
        Binding("enter", "edit_diary", "Save",priority=True),
    ]
    def __init__(self, diary_id: int):
@@ -31,6 +33,15 @@ class EditDiaryModal(ModalScreen[tuple[int,str]]):
    def on_button_pressed(self, event: Button.Pressed) -> None:
        if event.button.id == "save_diary_button":
            self.action_edit_diary()
        elif event.button.id == "cancel_button":
            self.dismiss(None)
    def on_key(self, event):
        if event.key == "enter":
            self.action_edit_diary()
            event.prevent_default()
    def action_edit_diary(self) -> None:
        new_diary_name = self.name_input.value.strip()
        if new_diary_name and new_diary_name != self.current_diary_name:
            self.dismiss((self.diary_id, new_diary_name))
@@ -40,8 +51,10 @@ class EditDiaryModal(ModalScreen[tuple[int,str]]):
        else:
            self.notify("Diary name cannot be empty.", severity="warning")
            self.name_input.focus()
-        elif event.button.id == "cancel_button":
+
-            self.dismiss(None)
+    def on_input_submitted(self, event: Input.Submitted) -> None:
        if event.input.id == "edit_diary_name_input":
            self.action_edit_diary()
    def action_cancel(self) -> None:
        self.dismiss(None)
@@ -1,43 +1,69 @@
-from typing import Optional, List
+import re
 import asyncio
 from datetime import datetime
-
+from pathlib import Path
-from textual.app import ComposeResult
+from typing import Optional, List
 from textual.screen import Screen
 from textual.widgets import Header, Footer, Static, TextArea
 from textual.binding import Binding
 from textual.containers import Container, Horizontal
 from pilgrim.models.entry import Entry
 from pilgrim.models.photo import Photo
 from pilgrim.models.travel_diary import TravelDiary
 from pilgrim.ui.screens.modals.add_photo_modal import AddPhotoModal
 from pilgrim.ui.screens.modals.confirm_delete_modal import ConfirmDeleteModal
 from pilgrim.ui.screens.modals.edit_photo_modal import EditPhotoModal
 from pilgrim.ui.screens.modals.file_picker_modal import FilePickerModal
 from pilgrim.ui.screens.rename_entry_modal import RenameEntryModal
 from textual.app import ComposeResult
 from textual.binding import Binding
 from textual.containers import Container, Horizontal, Vertical
 from textual.screen import Screen
 from textual.widgets import Header, Footer, Static, TextArea, OptionList
 class EditEntryScreen(Screen):
    TITLE = "Pilgrim - Edit"
    BINDINGS = [
        Binding("ctrl+q", "quit", "Quit"),
        Binding("ctrl+s", "save", "Save"),
-        Binding("ctrl+n", "next_entry", "Next/New Entry"),
+        Binding("shift+f5", "new_entry", "New Entry"),
-        Binding("ctrl+b", "prev_entry", "Previous Entry"),
+        Binding("f5", "next_entry", "Next Entry"),
        Binding("f4", "prev_entry", "Previous Entry"),
        Binding("ctrl+r", "rename_entry", "Rename Entry"),
-        Binding("escape", "back_to_list", "Back to List")
+        Binding("f8", "toggle_sidebar", "Toggle Photos"),
        Binding("f9", "toggle_focus", "Toggle Focus"),
        Binding("escape", "back_to_list", "Back to List"),
    ]
-    def __init__(self, diary_id: int = 1):
+    def __init__(self, diary_id: int = 1,create_new: bool = True):
        super().__init__()
-        self.diary_id = diary_id
+
-        self.diary_name = f"Diary {diary_id}"  # Use a better default name
+        if create_new:
-        self.current_entry_index = 0
+            self.current_entry_index = -1
-        self.entries: List[Entry] = []
+            self.is_new_entry = True
            self.next_entry_id = None
        else:
            self.is_new_entry = False
-        self.has_unsaved_changes = False
+            self.current_entry_index = 0
        self.new_entry_content = ""
        self.new_entry_title = "New Entry"
            self.next_entry_id = 1
        self.new_entry_title = ""
        self.new_entry_content = ""
        self.diary_id = diary_id
        self.diary_name = f"Diary {diary_id}"
        self.entries: List[Entry] = []
        self.has_unsaved_changes = False
        self._updating_display = False
        self._original_content = ""
        self.is_refreshing = False
        self.sidebar_visible = False
        self.sidebar_focused = False
        self._sidebar_opened_once = False
        self._active_tooltip = None
        self._last_photo_suggestion_notification = None
        self._last_photo_suggestion_type = None
        self._active_notification = None
        self._notification_timer = None
        self.references = []
        self.cached_photos = []
        # Main header
        self.header = Header(name="Pilgrim v6", classes="EditEntryScreen-header")
@@ -60,6 +86,27 @@ class EditEntryScreen(Screen):
        # Text area
        self.text_entry = TextArea(id="text_entry", classes="EditEntryScreen-text-entry")
        # Sidebar widgets
        self.sidebar_title = Static("Photos", classes="EditEntryScreen-sidebar-title")
        self.photo_list = OptionList(id="photo_list", classes="EditEntryScreen-sidebar-photo-list")
        self.photo_info = Static("", classes="EditEntryScreen-sidebar-photo-info")
        self.help_text = Static("", classes="EditEntryScreen-sidebar-help")
        # Sidebar container: photo list and info in a flexible container, help_text fixed at bottom
        self.sidebar_content = Vertical(
            self.photo_list,
            self.photo_info,
            id="sidebar_content",
            classes="EditEntryScreen-sidebar-content"
        )
        self.sidebar = Vertical(
            self.sidebar_title,
            self.sidebar_content,
            self.help_text,  # Always at the bottom, never scrolls
            id="sidebar",
            classes="EditEntryScreen-sidebar"
        )
        # Main container
        self.main = Container(
            self.sub_header,
@@ -71,17 +118,52 @@ class EditEntryScreen(Screen):
        # Footer
        self.footer = Footer(classes="EditEntryScreen-footer")
    def _update_footer_context(self):
        """Force footer refresh to show updated bindings"""
        self.refresh()
    def _get_cursor_position(self) -> tuple:
        """Get the current cursor position for tooltip placement"""
        try:
            # Get cursor position from text area
            cursor_location = self.text_entry.cursor_location
            if cursor_location:
                # Get the text area region
                text_region = self.text_entry.region
                if text_region:
                    # Calculate position relative to text area
                    # Position tooltip below the current line, not over it
                    x = text_region.x + min(cursor_location[0], text_region.width - 40)  # Keep within bounds
                    y = text_region.y + cursor_location[1] + 2  # 2 lines below cursor
                    return (x, y)
        except:
            pass
        return None
    def compose(self) -> ComposeResult:
        yield self.header
-        yield self.main
+        yield Horizontal(
            self.main,
            self.sidebar,
            id="content_container",
            classes="EditEntryScreen-content-container"
        )
        yield self.footer
    def on_mount(self) -> None:
        """Called when the screen is mounted"""
        self.sidebar.display = False
        self.sidebar_visible = False
        # First update diary info, then refresh entries
        self.update_diary_info()
        self.refresh_entries()
        # Initialize footer with editor context
        self._update_footer_context()
        # self.app.mount(self._photo_suggestion_widget)  # Temporarily disabled
    def update_diary_info(self):
        """Updates diary information"""
        try:
@@ -93,17 +175,14 @@ class EditEntryScreen(Screen):
                self.diary_name = diary.name
                self.diary_info.update(f"Diary: {self.diary_name}")
            else:
                # If diary not found, try to get a default name
                self.diary_name = f"Diary {self.diary_id}"
                self.diary_info.update(f"Diary: {self.diary_name}")
                self.notify(f"Diary {self.diary_id} not found, using default name")
        except Exception as e:
            # If there's an error, use a default name but don't break the app
            self.diary_name = f"Diary {self.diary_id}"
            self.diary_info.update(f"Diary: {self.diary_name}")
            self.notify(f"Error loading diary info: {str(e)}")
        # Always ensure the diary info is updated
        self._ensure_diary_info_updated()
    def _ensure_diary_info_updated(self):
@@ -111,7 +190,6 @@ class EditEntryScreen(Screen):
        try:
            self.diary_info.update(f"Diary: {self.diary_name}")
        except Exception as e:
            # If even this fails, at least try to show something
            self.diary_info.update(f"Diary: {self.diary_id}")
    def refresh_entries(self):
@@ -120,14 +198,10 @@ class EditEntryScreen(Screen):
            service_manager = self.app.service_manager
            entry_service = service_manager.get_entry_service()
            # Get all entries for this diary
            all_entries = entry_service.read_all()
            self.entries = [entry for entry in all_entries if entry.fk_travel_diary_id == self.diary_id]
            # Sort by ID
            self.entries.sort(key=lambda x: x.id)
            # Update next entry ID
            if self.entries:
                self.next_entry_id = max(entry.id for entry in self.entries) + 1
            else:
@@ -139,41 +213,8 @@ class EditEntryScreen(Screen):
        except Exception as e:
            self.notify(f"Error loading entries: {str(e)}")
        # Ensure diary info is updated even if entries fail to load
        self._ensure_diary_info_updated()
    async def async_refresh_entries(self):
        """Asynchronous version of refresh"""
        if self.is_refreshing:
            return
        self.is_refreshing = True
        try:
            service_manager = self.app.service_manager
            entry_service = service_manager.get_entry_service()
            # For now, use synchronous method since mock doesn't have async
            all_entries = entry_service.read_all()
            self.entries = [entry for entry in all_entries if entry.fk_travel_diary_id == self.diary_id]
            # Sort by ID
            self.entries.sort(key=lambda x: x.id)
            # Update next entry ID
            if self.entries:
                self.next_entry_id = max(entry.id for entry in self.entries) + 1
            else:
                self.next_entry_id = 1
            self._update_entry_display()
            self._update_sub_header()
        except Exception as e:
            self.notify(f"Error loading entries: {str(e)}")
        finally:
            self.is_refreshing = False
    def _update_status_indicator(self, text: str, css_class: str):
        """Helper to update status indicator text and class."""
        self.status_indicator.update(text)
@@ -197,6 +238,9 @@ class EditEntryScreen(Screen):
            current_entry = self.entries[self.current_entry_index]
            entry_text = f"Entry: \\[{self.current_entry_index + 1}/{len(self.entries)}] {current_entry.title}"
            self.entry_info.update(entry_text)
            if self.has_unsaved_changes:
                self._update_status_indicator("Not Saved", "not-saved")
            else:
                self._update_status_indicator("Saved", "saved")
    def _save_current_state(self):
@@ -211,6 +255,8 @@ class EditEntryScreen(Screen):
        """Finishes the display update by reactivating change detection"""
        self._updating_display = False
        self._update_sub_header()
        if self.sidebar_visible:
            self._update_sidebar_content()
    def _update_entry_display(self):
        """Updates the display of the current entry"""
@@ -237,11 +283,491 @@ class EditEntryScreen(Screen):
        self.call_after_refresh(self._finish_display_update)
    def _update_sidebar_content(self):
        """Updates the sidebar content with photos for the current diary"""
        try:
            self._load_photos_for_diary(self.diary_id)
            # Clear existing options safely
            self.photo_list.clear_options()
            # Add the 'Ingest Photo' option at the top
            self.photo_list.add_option("➕ Ingest Photo")
            if not self.cached_photos:
                self.photo_info.update("No photos found for this diary")
                self.help_text.update("No photos available\n\nUse Photo Manager to add photos")
                return
            # Add photos to the list with hash
            for photo in self.cached_photos:
                # Show name and hash in the list
                photo_hash = str(photo.photo_hash)[:8]
                self.photo_list.add_option(f"{photo.name} \\[{photo_hash}\]")
            self.photo_info.update(f"{len(self.cached_photos)} photos in diary")
            # Updated help a text with hash information
            help_text = (
                "[b]Sidebar Shortcuts[/b]\n"
                "[b][green]i[/green][/b]: Insert photo into entry\n"
                "[b][green]n[/green][/b]: Add new photo\n"
                "[b][green]d[/green][/b]: Delete selected photo\n"
                "[b][green]e[/green][/b]: Edit selected photo\n"
                "[b][yellow]Tab[/yellow][/b]: Back to editor\n"
                "[b][yellow]F8[/yellow][/b]: Show/hide sidebar\n"
                "[b]📝 Photo References[/b]\n"
                "\\[\\[photo::hash\\]\\]"
            )
            self.help_text.update(help_text)
        except Exception as e:
            self.notify(f"Error updating sidebar: {str(e)}", severity="error")
            # Set fallback content
            self.photo_info.update("Error loading photos")
            self.help_text.update("Error loading sidebar content")
    def _load_photos_for_diary(self, diary_id: int):
        """Loads all photos for the specific diary"""
        try:
            service_manager = self.app.service_manager
            photo_service = service_manager.get_photo_service()
            all_photos = photo_service.read_all()
            self.cached_photos = [photo for photo in all_photos if photo.fk_travel_diary_id == diary_id]
            self.cached_photos.sort(key=lambda x: x.id)
            return self.cached_photos
        except Exception as e:
            self.notify(f"Error loading photos: {str(e)}")
            return []
    def action_toggle_sidebar(self):
        """Toggles the sidebar visibility"""
        try:
            self.sidebar_visible = not self.sidebar_visible
            if self.sidebar_visible:
                self.sidebar.display = True
                self._update_sidebar_content()
                # Automatically focus the sidebar when opening
                self.sidebar_focused = True
                self.photo_list.focus()
                self._sidebar_opened_once = True
            else:
                self.sidebar.display = False
                self.sidebar_focused = False  # Reset focus when hiding
                self.text_entry.focus()  # Return focus to editor
            # Update footer after context change
            self._update_footer_context()
            self.refresh(layout=True)
        except Exception as e:
            self.notify(f"Error toggling sidebar: {str(e)}", severity="error")
            # Reset state on error
            self.sidebar_visible = False
            self.sidebar_focused = False
            self.sidebar.display = False
    def action_toggle_focus(self):
        """Toggles focus between editor and sidebar"""
        if not self.sidebar_visible:
            # If sidebar is not visible, show it and focus it
            self.action_toggle_sidebar()
            return
        self.sidebar_focused = not self.sidebar_focused
        if self.sidebar_focused:
            self.photo_list.focus()
        else:
            self.text_entry.focus()
        # Update footer after focus change
        self._update_footer_context()
    def action_insert_photo(self):
        """Insert selected photo into text"""
        if not self.sidebar_focused or not self.sidebar_visible:
            self.notify("Use F8 to open the sidebar first.", severity="warning")
            return
        # Get a selected photo
        if self.photo_list.highlighted is None:
            self.notify("No photo selected", severity="warning")
            return
        # Adjust index because of 'Ingest Photo' at the top
        photo_index = self.photo_list.highlighted - 1
        self._load_photos_for_diary(self.diary_id)
        if photo_index < 0 or photo_index >= len(self.cached_photos):
            self.notify("No photo selected", severity="warning")
            return
        selected_photo = self.cached_photos[photo_index]
        photo_hash = selected_photo.photo_hash[:8]
        # Insert photo reference using hash format without escaping
        # Using raw string to avoid markup conflicts with [[
        photo_ref = f"[[photo::{photo_hash}]]"
        # Insert at the cursor position
        self.text_entry.insert(photo_ref)
        # Switch focus back to editor
        self.sidebar_focused = False
        self.text_entry.focus()
        # Update footer context
        self._update_footer_context()
        # Show selected photo info
        photo_details = f"📷 {selected_photo.name}\n"
        photo_details += f"🔗 {photo_hash}\n"
        photo_details += f"📅 {selected_photo.addition_date}\n"
        photo_details += f"💬 {selected_photo.caption or 'No caption'}\n"
        photo_details += f"[b]Reference formats:[/b]\n"
        photo_details += f"\\[\\[photo::{photo_hash}\\]\\]"
        self.photo_info.update(photo_details)
        # Show notification without escaping brackets
        self.notify(f"Inserted photo: {selected_photo.name} \\[{photo_hash}\\]", severity="information")
    def action_ingest_new_photo(self):
        """Ingest a new photo using modal"""
        if not self.sidebar_focused or not self.sidebar_visible:
            self.notify("Use F8 to open the sidebar first.", severity="warning")
            return
        # Open add photo modal
        try:
            self.notify("Trying to push the modal screen...")
            self.app.push_screen(
                AddPhotoModal(diary_id=self.diary_id),
                self.handle_add_photo_result
            )
        except Exception as e:
            self.notify(f"Error: {str(e)}", severity="error")
            self.app.notify("Error: {str(e)}", severity="error")
    def handle_add_photo_result(self, result: dict | None) -> None:
        """Callback that processes the add photo modal result."""
        if result is None:
            self.notify("Add photo cancelled")
            return
        # Photo was already created in the modal, just refresh the sidebar
        if self.sidebar_visible:
            self._update_sidebar_content()
        self.notify(f"Photo '{result['name']}' added successfully!")
    async def _async_create_photo(self, photo_data: dict):
        """Creates a new photo asynchronously"""
        try:
            service_manager = self.app.service_manager
            photo_service = service_manager.get_photo_service()
            current_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            new_photo = photo_service.create(
                filepath=Path(photo_data["filepath"]),
                name=photo_data["name"],
                travel_diary_id=self.diary_id,
                addition_date=current_date,
                caption=photo_data["caption"]
            )
            if new_photo:
                self.notify(f"Photo '{new_photo.name}' added successfully!")
                # Refresh sidebar content
                if self.sidebar_visible:
                    self._update_sidebar_content()
            else:
                self.notify("Error creating photo")
        except Exception as e:
            self.notify(f"Error creating photo: {str(e)}")
    def action_delete_photo(self):
        """Delete selected photo"""
        if not self.sidebar_focused or not self.sidebar_visible:
            self.notify("Use F8 to open the sidebar first.", severity="warning")
            return
        if self.photo_list.highlighted is None:
            self.notify("No photo selected", severity="warning")
            return
        # Adjust index because of 'Ingest Photo' at the top
        photo_index = self.photo_list.highlighted - 1
        photos = self._load_photos_for_diary(self.diary_id)
        if photo_index < 0 or photo_index >= len(photos):
            self.notify("No photo selected", severity="warning")
            return
        selected_photo = photos[photo_index]
        # Open confirm delete modal
        self.app.push_screen(
            ConfirmDeleteModal(photo=selected_photo),
            self.handle_delete_photo_result
        )
    def handle_delete_photo_result(self, result: bool) -> None:
        """Callback that processes the delete photo modal result."""
        if result:
            # Get the selected photo with an adjusted index
            photos = self._load_photos_for_diary(self.diary_id)
            photo_index = self.photo_list.highlighted - 1  # Adjust for 'Ingest Photo' at top
            if self.photo_list.highlighted is None or photo_index < 0 or photo_index >= len(photos):
                self.notify("Photo no longer available", severity="error")
                return
            selected_photo = photos[photo_index]
            # Schedule async deletion
            self.call_later(self._async_delete_photo, selected_photo)
        else:
            self.notify("Delete cancelled")
    async def _async_delete_photo(self, photo: Photo):
        """Deletes a photo asynchronously"""
        try:
            service_manager = self.app.service_manager
            photo_service = service_manager.get_photo_service()
            result = photo_service.delete(photo)
            if result:
                self.notify(f"Photo '{photo.name}' deleted successfully!")
                # Refresh sidebar content
                if self.sidebar_visible:
                    self._update_sidebar_content()
            else:
                self.notify("Error deleting photo")
        except Exception as e:
            self.notify(f"Error deleting photo: {str(e)}")
    def action_edit_photo(self):
        """Edit selected photo using modal"""
        if not self.sidebar_focused or not self.sidebar_visible:
            self.notify("Use F8 to open the sidebar first.", severity="warning")
            return
        if self.photo_list.highlighted is None:
            self.notify("No photo selected", severity="warning")
            return
        # Adjust index because of 'Ingest Photo' at the top
        photo_index = self.photo_list.highlighted - 1
        photos = self._load_photos_for_diary(self.diary_id)
        if photo_index < 0 or photo_index >= len(photos):
            self.notify("No photo selected", severity="warning")
            return
        selected_photo = photos[photo_index]
        # Open edit photo modal
        self.app.push_screen(
            EditPhotoModal(photo=selected_photo),
            self.handle_edit_photo_result
        )
    def handle_edit_photo_result(self, result: dict | None) -> None:
        """Callback that processes the edit photo modal result."""
        if result is None:
            self.notify("Edit photo cancelled")
            return
        # Get the selected photo with adjusted index
        photos = self._load_photos_for_diary(self.diary_id)
        photo_index = self.photo_list.highlighted - 1  # Adjust for 'Ingest Photo' at top
        if self.photo_list.highlighted is None or photo_index < 0 or photo_index >= len(photos):
            self.notify("Photo no longer available", severity="error")
            return
        selected_photo = photos[photo_index]
        # Schedule async update
        self.call_later(self._async_update_photo, selected_photo, result)
    async def _async_update_photo(self, original_photo: Photo, photo_data: dict):
        """Updates a photo asynchronously"""
        try:
            service_manager = self.app.service_manager
            photo_service = service_manager.get_photo_service()
            # Create updated photo object
            updated_photo = Photo(
                filepath=photo_data["filepath"],
                name=photo_data["name"],
                addition_date=original_photo.addition_date,
                caption=photo_data["caption"],
                entries=original_photo.entries if original_photo.entries is not None else [],
                id=original_photo.id,
                photo_hash=original_photo.photo_hash,
            )
            result = photo_service.update(original_photo, updated_photo)
            if result:
                self.notify(f"Photo '{updated_photo.name}' updated successfully!")
                # Refresh sidebar content
                if self.sidebar_visible:
                    self._update_sidebar_content()
            else:
                self.notify("Error updating photo")
        except Exception as e:
            self.notify(f"Error updating photo: {str(e)}")
    def _get_linked_photos_from_text(self) -> Optional[List[Photo]]:
        """
        Validates photo references in the text against the memory cache.
        Checks for:
        - Malformed references
        - Incorrect hash length
        - Invalid or ambiguous hashes
        Returns a list of unique photos (no duplicates even if referenced multiple times).
        """
        text = self.text_entry.text
        # First check for malformed references
        malformed_pattern = r"\[\[photo::([^\]]*)\](?!\])"  # Missing ] at the end
        malformed_matches = re.findall(malformed_pattern, text)
        if malformed_matches:
            for match in malformed_matches:
                self.notify(f"❌ Malformed reference: '\\[\\[photo::{match}\\]' - Missing closing '\\]'", severity="error", timeout=10)
            return None
        # Look for incorrect format references
        invalid_format = r"\[\[photo:[^:\]]+\]\]"  # [[photo:something]] without ::
        invalid_matches = re.findall(invalid_format, text)
        if invalid_matches:
            for match in invalid_matches:
                escaped_match = match.replace("[", "\\[").replace("]", "\\]")
                self.notify(f"❌ Invalid format: '{escaped_match}' - Use '\\[\\[photo::hash\\]\\]'", severity="error", timeout=10)
            return None
        # Now look for all references to validate
        pattern = r"\[\[photo::([^\]]+)\]\]"
        # Use set to get unique references only
        all_refs = set(re.findall(pattern, text))
        if not all_refs:
            return []  # No references, valid operation
        self._load_photos_for_diary(self.diary_id)
        linked_photos: List[Photo] = []
        processed_hashes = set()  # Keep track of processed hashes to avoid duplicates
        for ref in all_refs:
            # Skip if we already processed this hash
            if ref in processed_hashes:
                continue
            # Validate hash length
            if len(ref) != 8:
                self.notify(
                    f"❌ Invalid hash: '{ref}' - Must be exactly 8 characters long",
                    severity="error",
                    timeout=10
                )
                return None
            # Validate if contains only valid hexadecimal characters
            if not re.match(r"^[0-9A-Fa-f]{8}$", ref):
                self.notify(
                    f"❌ Invalid hash: '{ref}' - Use only hexadecimal characters (0-9, A-F)",
                    severity="error",
                    timeout=10
                )
                return None
            # Search for photos matching the hash
            found_photos = [p for p in self.cached_photos if p.photo_hash.startswith(ref)]
            if len(found_photos) == 0:
                self.notify(
                    f"❌ Hash not found: '{ref}' - No photo matches this hash",
                    severity="error",
                    timeout=10
                )
                return None
            elif len(found_photos) > 1:
                self.notify(
                    f"❌ Ambiguous hash: '{ref}' - Matches multiple photos",
                    severity="error",
                    timeout=10
                )
                return None
            else:
                linked_photos.append(found_photos[0])
                processed_hashes.add(ref)  # Mark this hash as processed
        # Convert list to set and back to list to ensure uniqueness of photos
        return list(set(linked_photos))
    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
        """Handles photo selection in the sidebar"""
        if not self.sidebar_visible:
            return
        # Handle "Ingest Photo" option
        if event.option_index == 0:  # First option is "Ingest Photo"
            self.action_ingest_new_photo()
            return
        photos = self._load_photos_for_diary(self.diary_id)
        if not photos:
            return
        # Adjust index because of 'Ingest Photo' at the top
        photo_index = event.option_index - 1
        if photo_index >= len(photos):
            return
        selected_photo = photos[photo_index]
        photo_hash = selected_photo.photo_hash[:8]
        self.notify(f"Selected photo: {selected_photo.name} \\[{photo_hash}\\]")
        # Update photo info with details including hash
        photo_details = f"Name: {selected_photo.name}\n"
        photo_details += f"Hash: {photo_hash}\n"
        photo_details += f"Date: {selected_photo.addition_date}\n"
        if selected_photo.caption:
            photo_details += f"Caption: {selected_photo.caption}\n"
        else:
            photo_details += f"Caption: No Caption\n"
        photo_details += f"[b]Reference formats:[/b]\n"
        photo_details += f"\\[\\[photo::{photo_hash}]]"
        self.photo_info.update(photo_details)
    def on_text_area_changed(self, event) -> None:
-        """Detects text changes to mark as unsaved"""
+        """Detects text changes and updates status"""
-        if (hasattr(self, 'text_entry') and not self.text_entry.read_only and
+        # Skip if we're currently updating the display
-                not getattr(self, '_updating_display', False) and hasattr(self, '_original_content')):
+        if getattr(self, '_updating_display', False):
            return
        # Skip if text area is read-only
        if not hasattr(self, 'text_entry') or self.text_entry.read_only:
            return
        # Skip if we don't have original content to compare against
        if not hasattr(self, '_original_content'):
            return
        current_content = self.text_entry.text
        # Check if content has changed
        if current_content != self._original_content:
            if not self.has_unsaved_changes:
                self.has_unsaved_changes = True
@@ -251,6 +777,21 @@ class EditEntryScreen(Screen):
                self.has_unsaved_changes = False
                self._update_sub_header()
    def on_focus(self, event) -> None:
        """Captures focus changes to update footer"""
        # Check if the focus changed to/from sidebar
        if hasattr(event.widget, 'id'):
            if event.widget.id == "photo_list":
                self.sidebar_focused = True
                self._update_footer_context()
            elif event.widget.id == "text_entry":
                self.sidebar_focused = False
                self._update_footer_context()
    def action_back_to_list(self) -> None:
        """Goes back to the diary list"""
        if self.is_new_entry and not self.text_entry.text.strip() and not self.has_unsaved_changes:
@@ -356,40 +897,53 @@ class EditEntryScreen(Screen):
        self._update_sub_header()
    def action_save(self) -> None:
-        """Saves the current entry"""
+        """Salva a entrada após validar e coletar as fotos referenciadas."""
-        if self.is_new_entry:
+        photos_to_link = self._get_linked_photos_from_text()
        if photos_to_link is None:
            self.notify("⚠️ Saving was canceled ", severity="error")
            return
        content = self.text_entry.text.strip()
        if self.is_new_entry:
            if not content:
                self.notify("Empty entry cannot be saved")
                return
-
+            # Passe a lista de fotos para o método de criação
-            # Schedule async creation
+            if self.new_entry_title == "":
-            self.call_later(self._async_create_entry, content)
+               self.app.push_screen(RenameEntryModal(current_name=""), lambda result: self._handle_save_after_rename(result,content,
                                                                                               photos_to_link))
            else:
-            # Schedule async update
+                self.call_later(self._async_create_entry, content, photos_to_link)
-            self.call_later(self._async_update_entry)
+        else:
            # Passe a lista de fotos para o método de atualização
            self.call_later(self._async_update_entry, content, photos_to_link)
-    async def _async_create_entry(self, content: str):
+    def _handle_save_after_rename(self, result: str | None, content: str, photos_to_link: List[Photo]) -> None:
-        """Creates a new entry asynchronously"""
+        if result is None:
            self.notify("Save cancelled")
            return
        self.new_entry_title = result
        self.call_later(self._async_create_entry, content, photos_to_link)
    async def _async_create_entry(self, content: str, photos_to_link: List[Photo]):
        """Creates a new entry and links the referenced photos."""
        try:
            service_manager = self.app.service_manager
            entry_service = service_manager.get_entry_service()
            # Get current date
            current_date = datetime.now().strftime("%d/%m/%Y")
            new_entry = entry_service.create(
                travel_diary_id=self.diary_id,
                title=self.new_entry_title,
                text=content,
-                date=current_date
+                date=datetime.now(),
                photos=photos_to_link
            )
            if new_entry:
                self.entries.append(new_entry)
                self.entries.sort(key=lambda x: x.id)
                # Find the new entry index
                for i, entry in enumerate(self.entries):
                    if entry.id == new_entry.id:
                        self.current_entry_index = i
@@ -398,43 +952,41 @@ class EditEntryScreen(Screen):
                self.is_new_entry = False
                self.has_unsaved_changes = False
                self._original_content = new_entry.text
-                self.new_entry_title = "New Entry"
+                self.new_entry_title = ""
                self.next_entry_id = max(entry.id for entry in self.entries) + 1
                self._update_entry_display()
-                self.notify(f"New entry '{new_entry.title}' saved successfully!")
+                self.notify(f"Entry '{new_entry.title}' saved successfully!")
            else:
                self.notify("Error creating entry")
        except Exception as e:
            self.notify(f"Error creating entry: {str(e)}")
-    async def _async_update_entry(self):
+    async def _async_update_entry(self, updated_content: str, photos_to_link: List[Photo]):
-        """Updates the current entry asynchronously"""
+        """Updates an existing entry and its photo links."""
        try:
            if not self.entries:
                self.notify("No entry to update")
                return
            current_entry = self.entries[self.current_entry_index]
            updated_content = self.text_entry.text
            # Create updated entry object
            updated_entry = Entry(
                title=current_entry.title,
                text=updated_content,
                date=current_entry.date,
                travel_diary_id=current_entry.fk_travel_diary_id,
                id=current_entry.id
            )
            service_manager = self.app.service_manager
            entry_service = service_manager.get_entry_service()
            current_entry = self.entries[self.current_entry_index]
-            result = entry_service.update(current_entry, updated_entry)
+            entry_result = Entry(
                id=current_entry.id,
                title=current_entry.title,
                text=updated_content,
                photos=photos_to_link,
                date=current_entry.date,
                travel_diary_id=self.diary_id,
                fk_travel_diary_id=self.diary_id
            )
            result = entry_service.update(current_entry, entry_result)
            if result:
                current_entry.text = updated_content
                self.has_unsaved_changes = False
                self._original_content = updated_content
                self._update_sub_header()
@@ -445,8 +997,66 @@ class EditEntryScreen(Screen):
        except Exception as e:
            self.notify(f"Error updating entry: {str(e)}")
-    def action_force_refresh(self):
+    def check_key(self, event):
-        """Forces manual refresh"""
+        """Check for custom key handling before bindings are processed"""
-        self.notify("Forcing refresh...")
+
-        self.refresh_entries()
+        # Sidebar shortcuts
-        self.call_later(self.async_refresh_entries) 
+        if self.sidebar_focused and self.sidebar_visible:
            sidebar_keys = ["i", "n", "d", "e"]
            if event.key in sidebar_keys:
                if event.key == "i":
                    self.action_insert_photo()
                elif event.key == "n":
                    self.action_ingest_new_photo()
                elif event.key == "d":
                    self.action_delete_photo()
                elif event.key == "e":
                    self.action_edit_photo()
                return True  # Indica que o evento foi processado
        # Text area shortcuts
        elif self.focused is self.text_entry:
            if event.key in ["tab", "shift+tab"]:
                if event.key == "shift+tab":
                    self._handle_shift_tab()
                elif event.key == "tab":
                    self.text_entry.insert('\t')
                return True  # Indica que o evento foi processado
        return False  # Não foi processado, continuar com bindings
    def _handle_shift_tab(self):
        """Handle shift+tab for removing indentation"""
        textarea = self.text_entry
        row, col = textarea.cursor_location
        lines = textarea.text.splitlines()
        if row < len(lines):
            line = lines[row]
            if line.startswith('\t'):
                lines[row] = line[1:]
                textarea.text = '\n'.join(lines)
                textarea.cursor_location = (row, max(col - 1, 0))
            elif line.startswith('    '):  # 4 spaces
                lines[row] = line[4:]
                textarea.text = '\n'.join(lines)
                textarea.cursor_location = (row, max(col - 4, 0))
            elif line.startswith(' '):
                n = len(line) - len(line.lstrip(' '))
                to_remove = min(n, 4)
                lines[row] = line[to_remove:]
                textarea.text = '\n'.join(lines)
                textarea.cursor_location = (row, max(col - to_remove, 0))
    def on_key(self, event):
        if self.check_key(event):
            event.stop()
            return
    def on_footer_action(self, event) -> None:
        """Handle clicks on footer actions (Textual 3.x)."""
        action = event.action
        method = getattr(self, f"action_{action}", None)
        if method:
            method()
        else:
            self.notify(f"No action found for: {action}", severity="warning")
@@ -0,0 +1,120 @@
 import os
 from pathlib import Path
 from textual.app import ComposeResult
 from textual.screen import Screen
 from textual.widgets import Static, Input, Button
 from textual.containers import Horizontal, Container
 from .file_picker_modal import FilePickerModal
 import hashlib
 class AddPhotoModal(Screen):
    """Modal for adding a new photo"""
    def __init__(self, diary_id: int):
        super().__init__()
        self.diary_id = diary_id
        self.result = None
        self.created_photo = None
    def compose(self) -> ComposeResult:
        yield Container(
            Static("📷 Add New Photo", classes="AddPhotoModal-Title"),
            Static("File path:", classes="AddPhotoModal-Label"),
            Horizontal(
                Input(placeholder="Enter file path...", id="filepath-input", classes="AddPhotoModal-Input"),
                Button("Escolher arquivo...", id="choose-file-button", classes="AddPhotoModal-Button"),
                classes="AddPhotoModal-FileRow"
            ),
            Static("Photo name:", classes="AddPhotoModal-Label"),
            Input(placeholder="Enter photo name...", id="name-input", classes="AddPhotoModal-Input"),
            Static("Caption (optional):", classes="AddPhotoModal-Label"),
            Input(placeholder="Enter caption...", id="caption-input", classes="AddPhotoModal-Input"),
            Horizontal(
                Button("Add Photo", id="add-button", classes="AddPhotoModal-Button"),
                Button("Cancel", id="cancel-button", classes="AddPhotoModal-Button"),
                classes="AddPhotoModal-Buttons"
            ),
            classes="AddPhotoModal-Dialog"
        )
    def on_button_pressed(self, event: Button.Pressed) -> None:
        if event.button.id == "choose-file-button":
            self.app.push_screen(
                FilePickerModal(),
                self.handle_file_picker_result
            )
            return
        if event.button.id == "add-button":
            filepath = self.query_one("#filepath-input", Input).value
            name = self.query_one("#name-input", Input).value
            caption = self.query_one("#caption-input", Input).value
            if not filepath.strip() or not name.strip():
                self.notify("File path and name are required", severity="error")
                return
            # Try to create the photo in the database
            self.call_later(self._async_create_photo, {
                "filepath": filepath.strip(),
                "name": name.strip(),
                "caption": caption.strip() if caption.strip() else None
            })
        elif event.button.id == "cancel-button":
            self.dismiss()
    async def _async_create_photo(self, photo_data: dict):
        """Creates a new photo asynchronously using PhotoService"""
        try:
            service_manager = self.app.service_manager
            photo_service = service_manager.get_photo_service()
            if photo_service.check_photo_by_hash(photo_service.hash_file(photo_data["filepath"]),self.diary_id):
                self.notify("Photo already exists in database", severity="error")
                return
            new_photo = photo_service.create(
                filepath=Path(photo_data["filepath"]),
                name=photo_data["name"],
                travel_diary_id=self.diary_id,
                caption=photo_data["caption"]
            )
            if new_photo:
                self.created_photo = new_photo
                self.notify(f"Photo '{new_photo.name}' added successfully!\nHash: {new_photo.photo_hash[:8]}\nReference: \\[\\[photo:{new_photo.name}:{new_photo.photo_hash[:8]}\\]\\]",
                           severity="information", timeout=5)
                # Return the created photo data to the calling screen
                self.result = {
                    "filepath": photo_data["filepath"],
                    "name": photo_data["name"],
                    "caption": photo_data["caption"],
                    "photo_id": new_photo.id,
                    "hash": new_photo.photo_hash
                }
                self.dismiss(self.result)
            else:
                self.notify("Error creating photo in database", severity="error")
        except Exception as e:
            self.notify(f"Error creating photo: {str(e)}", severity="error")
    def handle_file_picker_result(self, result: str | None) -> None:
        if result:
            # Set the filepath input value
            filepath_input = self.query_one("#filepath-input", Input)
            filepath_input.value = result
            # Trigger the input change event to update the UI
            filepath_input.refresh()
            # Auto-fill the name field with the filename (without extension)
            filename = Path(result).stem
            name_input = self.query_one("#name-input", Input)
            if not name_input.value.strip():
                name_input.value = filename
                name_input.refresh()
        else:
            # User cancelled the file picker
            self.notify("File selection cancelled", severity="information") 
@@ -0,0 +1,32 @@
 from textual.app import ComposeResult
 from textual.screen import Screen
 from textual.widgets import Static, Button
 from textual.containers import Container, Horizontal
 from pilgrim.models.photo import Photo
 class ConfirmDeleteModal(Screen):
    """Modal for confirming photo deletion"""
    def __init__(self, photo: Photo):
        super().__init__()
        self.photo = photo
        self.result = None
    def compose(self) -> ComposeResult:
        yield Container(
            Static("🗑️ Confirm Deletion", classes="ConfirmDeleteModal-Title"),
            Static(f"Are you sure you want to delete the photo '{self.photo.name}'?", classes="ConfirmDeleteModal-Message"),
            Static("This action cannot be undone.", classes="ConfirmDeleteModal-Warning"),
            Horizontal(
                Button("Delete", variant="error", id="delete-button", classes="ConfirmDeleteModal-Button"),
                Button("Cancel", variant="default", id="cancel-button", classes="ConfirmDeleteModal-Button"),
                classes="ConfirmDeleteModal-Buttons"
            ),
            classes="ConfirmDeleteModal-Dialog"
        )
    def on_button_pressed(self, event: Button.Pressed) -> None:
        if event.button.id == "delete-button":
            self.result = True
            self.dismiss(True)
        elif event.button.id == "cancel-button":
            self.dismiss(False) 
@@ -0,0 +1,77 @@
 from textual.app import ComposeResult
 from textual.screen import Screen
 from textual.widgets import Static, Input, Button
 from textual.containers import Container, Horizontal
 from pilgrim.models.photo import Photo
 class EditPhotoModal(Screen):
    """Modal for editing an existing photo (name and caption only)"""
    def __init__(self, photo: Photo):
        super().__init__()
        self.photo = photo
        self.result = None
    def compose(self) -> ComposeResult:
        # Generate hash for this photo
        yield Container(
            Static("✏️ Edit Photo", classes="EditPhotoModal-Title"),
            Static("File path (read-only):", classes="EditPhotoModal-Label"),
            Input(
                value=self.photo.filepath, 
                id="filepath-input", 
                classes="EditPhotoModal-Input",
                disabled=True
            ),
            Static("Photo name:", classes="EditPhotoModal-Label"),
            Input(
                value=self.photo.name, 
                placeholder="Enter photo name...", 
                id="name-input", 
                classes="EditPhotoModal-Input"
            ),
            Static("Caption (optional):", classes="EditPhotoModal-Label"),
            Input(
                value=self.photo.caption or "", 
                placeholder="Enter caption...", 
                id="caption-input", 
                classes="EditPhotoModal-Input"
            ),
            Static(f"🔗 Photo Hash: {self.photo.photo_hash[:8]}", classes="EditPhotoModal-Hash"),
            Static("Reference formats:", classes="EditPhotoModal-Label"),
            Static(f"\\[\\[photo::{self.photo.photo_hash[:8]}\\]\\]", classes="EditPhotoModal-Reference"),
            Horizontal(
                Button("Save Changes", id="save-button", classes="EditPhotoModal-Button"),
                Button("Cancel", id="cancel-button", classes="EditPhotoModal-Button"),
                classes="EditPhotoModal-Buttons"
            ),
            classes="EditPhotoModal-Dialog"
        )
    def on_button_pressed(self, event: Button.Pressed) -> None:
        if event.button.id == "save-button":
            name = self.query_one("#name-input", Input).value
            caption = self.query_one("#caption-input", Input).value
            if not name.strip():
                self.notify("Photo name is required", severity="error")
                return
            # Return the updated photo data
            self.result = {
                "filepath": self.photo.filepath,  # Keep original filepath
                "name": name.strip(),
                "caption": caption.strip() if caption.strip() else None
            }
            self.dismiss(self.result)
        elif event.button.id == "cancel-button":
            self.dismiss()
    def on_mount(self) -> None:
        """Focus on the name input when modal opens"""
        self.query_one("#name-input", Input).focus() 
@@ -0,0 +1,66 @@
 import os
 from pathlib import Path
 from typing import Iterable
 from textual.app import ComposeResult
 from textual.screen import Screen
 from textual.widgets import Static, DirectoryTree, Button
 from textual.containers import Horizontal, Container
 class ImageDirectoryTree(DirectoryTree):
    """DirectoryTree that only shows image files"""
    def filter_paths(self, paths: Iterable[Path]) -> Iterable[Path]:
        """Filter to show only directories and image files"""
        image_extensions = {'.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp'}
        return [
            path for path in paths 
            if path.is_dir() or path.suffix.lower() in image_extensions
        ]
 class FilePickerModal(Screen):
    """Modal for picking an image file using DirectoryTree"""
    def __init__(self, start_path=None):
        super().__init__()
        self.start_path = Path(start_path or os.getcwd())
        # Start one level up to make navigation easier
        self.current_path = self.start_path.parent
    def compose(self) -> ComposeResult:
        yield Container(
            Static(f"Current: {self.current_path}", id="title", classes="FilePickerModal-Title"),
            ImageDirectoryTree(str(self.current_path), id="directory-tree"),
            Horizontal(
                Button("Up", id="up-button", classes="FilePickerModal-Button"),
                Button("Cancel", id="cancel-button", classes="FilePickerModal-Button"),
                classes="FilePickerModal-Buttons"
            ),
            classes="FilePickerModal-Dialog"
        )
    def on_directory_tree_file_selected(self, event: DirectoryTree.FileSelected) -> None:
        """Handle file selection"""
        file_path = event.path
        # Check if it's an image file
        image_extensions = {'.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp'}
        if file_path.suffix.lower() in image_extensions:
            # Return the file path as result
            self.dismiss(str(file_path))
        else:
            self.notify("Please select an image file", severity="warning")
    def on_button_pressed(self, event: Button.Pressed) -> None:
        """Handle button presses"""
        if event.button.id == "up-button":
            # Navigate to parent directory
            parent = self.current_path.parent
            if parent != self.current_path:
                self.current_path = parent
                self.query_one("#title", Static).update(f"Current: {self.current_path}")
                # Reload the directory tree
                tree = self.query_one("#directory-tree", ImageDirectoryTree)
                tree.path = str(self.current_path)
                tree.reload()
        elif event.button.id == "cancel-button":
            # Return None to indicate cancellation
            self.dismiss(None) 
@@ -1,14 +1,20 @@
 from textual.app import ComposeResult
 from textual.binding import Binding
 from textual.containers import Vertical, Horizontal
 from textual.screen import ModalScreen
 from textual.widgets import Label, Input, Button
 from pilgrim.ui.screens.edit_entry_screen import EditEntryScreen
 class NewDiaryModal(ModalScreen[str]):
    BINDINGS = [
-        ("escape", "cancel", "Cancel"),
+        Binding("escape", "cancel", "Cancel"),
        Binding("enter", "create_diary", "Create",priority=True),
    ]
    def __init__(self):
        super().__init__()
        self.auto_open = self.app.config_manager.auto_open_new_diary
        self.name_input = Input(id="NewDiaryModal-NameInput",classes="NewDiaryModal-NameInput") # This ID is fine, it's specific to the input
    def compose(self) -> ComposeResult:
@@ -29,15 +35,46 @@ class NewDiaryModal(ModalScreen[str]):
    def on_button_pressed(self, event: Button.Pressed) -> None:
        """Handles button clicks."""
        if event.button.id == "create_diary_button":
-            diary_name = self.name_input.value.strip()
+            self.action_create_diary()
            if diary_name:
                self.dismiss(diary_name)
            else:
                self.notify("Diary name cannot be empty.", severity="warning")
                self.name_input.focus()
        elif event.button.id == "cancel_button":
-            self.dismiss("")
+            self.dismiss()
    def action_cancel(self) -> None:
        """Action to cancel the modal."""
        self.dismiss("")
    def action_create_diary(self) -> None:
        diary_name = self.name_input.value.strip()
        if diary_name:
            self.call_later(self._async_create_diary, diary_name)
        else:
            self.notify("Diary name cannot be empty.", severity="warning")
            self.name_input.focus()
    def on_input_submitted(self, event: Input.Submitted) -> None:
        if event.input.id == "NewDiaryModal-NameInput":
            self.action_create_diary()
    async def _async_create_diary(self, name: str):
        try:
            service = self.app.service_manager.get_travel_diary_service()
            created_diary = await service.async_create(name)
            if created_diary:
                self.dismiss(name)
                if self.auto_open:
                    self.app.push_screen(EditEntryScreen(diary_id=created_diary.id))
                self.notify(f"Diary: '{name}' created!")
            else:
                self.notify("Error Creating the diary")
        except Exception as e:
            self.notify(f"Exception on creating the diary: {str(e)}")
@@ -1,4 +1,5 @@
 from textual.app import ComposeResult
 from textual.binding import Binding
 from textual.containers import Vertical, Horizontal
 from textual.screen import ModalScreen
 from textual.widgets import Label, Input, Button
@@ -8,7 +9,7 @@ class RenameEntryModal(ModalScreen[str]):
    """A modal screen to rename a diary entry."""
    BINDINGS = [
-        ("escape", "cancel", "Cancel"),
+        Binding("escape", "cancel", "Cancel"),
    ]
    def __init__(self, current_name: str):
@@ -388,3 +388,239 @@ Screen.-modal {
    margin: 0 1;
    width: 1fr;
 }
 .EditEntryScreen-sidebar{
    background: $primary-darken-1;
    width: 45%;
 }
 .EditEntryScreen-sidebar-title {
    text-align: center;
    text-style: bold;
    color: $accent;
    padding: 1;
    border-bottom: solid $accent;
    margin-bottom: 1;
 }
 .EditEntryScreen-sidebar-content {
    height: 1fr;
    layout: vertical;
    margin-left: 1;
    margin-right: 1;
 }
 .EditEntryScreen-sidebar-photo-list {
    height: 2fr; /* Pega o espaço restante disponível */
    min-height: 5; /* Garante altura mínima para não sumir */
    border: solid $accent;
    margin-bottom: 1;
    overflow-y: auto; /* Adiciona scroll vertical se necessário */
 }
 .EditEntryScreen-sidebar-photo-info {
    height: 1fr;
    max-height: 15; /* Limita altura máxima */
    min-height: 13;
    padding: 1;
    border: solid $warning;
    margin-bottom: 1;
    background: $surface-darken-1;
    overflow-y: auto; /* Adiciona scroll se exceder max-height */
 }
 .EditEntryScreen-sidebar-help {
    height: 1fr;
    max-height: 10; /* Altura máxima menor que info */
    min-height: 8; /* Altura mínima menor */
    border: solid $success;
    padding: 1;
    background: $surface-darken-1;
    text-style: italic;
    overflow-y: auto; /* Adiciona scroll se exceder max-height */
 }
 /* Photo Modal Styles */
 .modal-dialog {
    layout: vertical;
    width: 60%;
    height: auto;
    background: $surface;
    border: thick $accent;
    padding: 2 4;
    align: center middle;
 }
 .modal-title {
    text-align: center;
    text-style: bold;
    color: $primary;
    margin-bottom: 1;
 }
 .modal-label {
    margin-bottom: 1;
    color: $text;
 }
 .modal-input {
    width: 1fr;
    margin-bottom: 2;
 }
 .modal-buttons {
    width: 1fr;
    height: auto;
    align: center middle;
    padding-top: 1;
 }
 .modal-button {
    margin: 0 1;
    width: 1fr;
 }
 /* AddPhotoModal styles */
 .AddPhotoModal-Dialog {
    layout: vertical;
    width: 60%;
    height: auto;
    background: $surface;
    border: thick $accent;
    padding: 2 4;
    align: center middle;
 }
 .AddPhotoModal-Title {
    text-align: center;
    text-style: bold;
    color: $primary;
    margin-bottom: 1;
 }
 .AddPhotoModal-Label {
    margin-bottom: 1;
    color: $text;
 }
 .AddPhotoModal-Input {
    width: 1fr;
    margin-bottom: 2;
 }
 .AddPhotoModal-Buttons {
    width: 1fr;
    height: auto;
    align: center middle;
    padding-top: 1;
 }
 .AddPhotoModal-Button {
    margin: 0 1;
    width: 1fr;
 }
 /* EditPhotoModal styles */
 .EditPhotoModal-Dialog {
    layout: vertical;
    width: 60%;
    height: auto;
    background: $surface;
    border: thick $accent;
    padding: 2 4;
    align: center middle;
 }
 .EditPhotoModal-Title {
    text-align: center;
    text-style: bold;
    color: $primary;
    margin-bottom: 1;
 }
 .EditPhotoModal-Label {
    margin-bottom: 1;
    color: $text;
 }
 .EditPhotoModal-Input {
    width: 1fr;
    margin-bottom: 2;
 }
 .EditPhotoModal-Buttons {
    width: 1fr;
    height: auto;
    align: center middle;
    padding-top: 1;
 }
 .EditPhotoModal-Button {
    margin: 0 1;
    width: 1fr;
 }
 /* FilePickerModal styles */
 .FilePickerModal-Dialog {
    layout: vertical;
    width: 80%;
    height: 80%;
    background: $surface;
    border: thick $accent;
    padding: 2 4;
    align: center middle;
 }
 .FilePickerModal-Title {
    text-align: center;
    text-style: bold;
    color: $primary;
    margin-bottom: 1;
 }
 .FilePickerModal-Buttons {
    width: 1fr;
    height: auto;
    align: center middle;
    padding-top: 1;
 }
 .FilePickerModal-Button {
    margin: 0 1;
    width: 1fr;
 }
 /* DirectoryTree specific styles */
 #directory-tree {
    height: 1fr;
    border: solid $accent;
    margin: 1;
 }
 /* ConfirmDeleteModal styles */
 .ConfirmDeleteModal-Dialog {
    layout: vertical;
    width: 60%;
    height: auto;
    background: $surface;
    border: thick $error;
    padding: 2 4;
    align: center middle;
 }
 .ConfirmDeleteModal-Title {
    text-align: center;
    text-style: bold;
    color: $error;
    margin-bottom: 1;
 }
 .ConfirmDeleteModal-Message {
    text-align: center;
    color: $text;
    margin-bottom: 1;
 }
 .ConfirmDeleteModal-Warning {
    text-align: center;
    color: $warning;
    text-style: italic;
    margin-bottom: 2;
 }
 .ConfirmDeleteModal-Buttons {
    width: 1fr;
    height: auto;
    align: center middle;
    padding-top: 1;
 }
 .ConfirmDeleteModal-Button {
    margin: 0 1;
    width: 1fr;
 }
@@ -9,6 +9,7 @@ from pilgrim.service.servicemanager import ServiceManager
 from pilgrim.ui.screens.about_screen import AboutScreen
 from pilgrim.ui.screens.diary_list_screen import DiaryListScreen
 from pilgrim.ui.screens.edit_entry_screen import EditEntryScreen
 from pilgrim.utils import ConfigManager
 CSS_FILE_PATH = Path(__file__).parent / "styles" / "pilgrim.css"
@@ -16,9 +17,10 @@ CSS_FILE_PATH = Path(__file__).parent / "styles" / "pilgrim.css"
 class UIApp(App):
    CSS_PATH = CSS_FILE_PATH
-    def __init__(self,service_manager: ServiceManager, **kwargs):
+    def __init__(self,service_manager: ServiceManager, config_manager: ConfigManager, **kwargs):
        super().__init__(**kwargs)
        self.service_manager = service_manager
        self.config_manager = config_manager
    def on_mount(self) -> None:
@@ -0,0 +1,4 @@
 from .directory_manager import DirectoryManager
 from .config_manager import ConfigManager
 __all__ = ['DirectoryManager', 'ConfigManager']
@@ -0,0 +1,107 @@
 import os.path
 from os import PathLike
 from threading import Lock
 import tomli
 import tomli_w
 from pilgrim.utils import DirectoryManager
 class SingletonMeta(type):
    _instances = {}
    _lock: Lock = Lock()
    def __call__(cls, *args, **kwargs):
        with cls._lock:
            if cls not in cls._instances:
                instance = super().__call__(*args, **kwargs)
                cls._instances[cls] = instance
        return cls._instances[cls]
 class ConfigManager(metaclass=SingletonMeta):
    def __init__(self):
        self.database_url = None
        self.database_type = None
        self.auto_open_diary = None
        self.auto_open_new_diary = None
        self.config_dir = DirectoryManager.get_config_directory()
        self.__data = None
    def read_config(self):
        if os.path.exists(f"{DirectoryManager.get_config_directory()}/config.toml"):
            try:
                with open(f"{DirectoryManager.get_config_directory()}/config.toml", "rb") as f:
                    data = tomli.load(f)
            except tomli.TOMLDecodeError as e:
                raise ValueError(f"Invalid TOML configuration: {e}")
            except Exception as e:
                raise RuntimeError(f"Error reading configuration: {e}")
            self.__data = data
            self.database_url = self.__data["database"]["url"]
            self.database_type = self.__data["database"]["type"]
            if self.__data["settings"]["diary"]["auto_open_diary_on_startup"] == "":
                self.auto_open_diary = None
            self.auto_open_new_diary = self.__data["settings"]["diary"]["auto_open_on_creation"]
        else:
            print("Error: config.toml not found.")
            self.create_config()
            self.read_config()
    def create_config(self, config: dict = None):
        # Garantir que o diretório de configuração existe
        config_dir = DirectoryManager.get_config_directory()
        if not os.path.exists(config_dir):
            os.makedirs(config_dir, exist_ok=True)
        default = {
            "database": {
                "url": f"{config_dir}/database.db",
                "type": "sqlite"
            },
            "settings": {
                "diary": {
                    "auto_open_diary_on_startup": "",
                    "auto_open_on_creation": False
                }
            }
        }
        if config is None:
            config = default
        try:
            with open(f"{config_dir}/config.toml", "wb") as f:
                tomli_w.dump(config, f)
        except Exception as e:
            raise RuntimeError(f"Error creating configuration: {e}")
    def save_config(self):
        if self.__data is None:
            self.read_config()
        if self.__data is None:
            raise RuntimeError("Error reading configuration.")
        self.__data["database"]["url"] = self.database_url
        self.__data["database"]["type"] = self.database_type
        self.__data["settings"]["diary"]["auto_open_diary_on_startup"] = self.auto_open_diary or ""
        self.__data["settings"]["diary"]["auto_open_on_creation"] = self.auto_open_new_diary
        try:
            self.create_config(self.__data)
        except Exception as e:
            raise RuntimeError(f"Error saving configuration: {e}")
    def set_config_dir(self, value):
        self.config_dir = value
    def set_database_url(self, value: str):
        self.database_url = value
    def set_auto_open_diary(self, value: str):
        self.auto_open_diary = value
    def set_auto_open_new_diary(self, value: bool):
        self.auto_open_new_diary = value
@@ -0,0 +1,63 @@
 import os
 import shutil
 from pathlib import Path
 class DirectoryManager:
    @staticmethod
    def get_config_directory() -> Path:
        """
        Get the ~/.pilgrim directory path.
        Creates it if it doesn't exist.
        """
        home = Path.home()
        config_dir = home / ".pilgrim"
        config_dir.mkdir(exist_ok=True)
        os.chmod(config_dir, 0o700)
        return config_dir
    @staticmethod
    def get_diaries_root() -> Path:
        """Returns the path to the diaries directory."""
        diaries_dir = DirectoryManager.get_config_directory() / "diaries"
        diaries_dir.mkdir(exist_ok=True)
        os.chmod(diaries_dir, 0o700)
        return diaries_dir
    @staticmethod
    def get_diary_directory(directory_name: str) -> Path:
        """Returns the directory path for a specific diary."""
        return DirectoryManager.get_diaries_root() / directory_name
    @staticmethod
    def get_diary_data_directory(directory_name: str) -> Path:
        """Returns the data directory path for a specific diary."""
        return DirectoryManager.get_diary_directory(directory_name) / "data"
    @staticmethod
    def get_diary_images_directory(directory_name: str) -> Path:
        """Returns the images directory path for a specific diary."""
        return DirectoryManager.get_diary_data_directory(directory_name) / "images"
    @staticmethod
    def get_database_path() -> Path:
        """
        Get the database file path following XDG Base Directory specification.
        Creates the directory if it doesn't exist.
        """
        pilgrim_dir = DirectoryManager.get_config_directory()
        db_path = pilgrim_dir / "database.db"
        # If database doesn't exist in new location but exists in current directory,
        # migrate it
        if not db_path.exists():
            current_db = Path("database.db")
            if current_db.exists():
                try:
                    shutil.copy2(current_db, db_path)
                    # Consider using logging instead of print
                    print(f"Database migrated from {current_db} to {db_path}")
                except (OSError, shutil.Error) as e:
                    raise RuntimeError(f"Failed to migrate database: {e}")
        return db_path
@@ -0,0 +1,64 @@
 import pytest
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 from pilgrim.database import Base
 from pilgrim.models.travel_diary import TravelDiary
 from pilgrim.models.photo import Photo
 # Todos os imports necessários para as fixtures devem estar aqui
 # ...
@pytest.fixture(scope="function")
 def db_session():
    """Esta fixture agora está disponível para TODOS os testes."""
    engine = create_engine("sqlite:///:memory:")
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()
    yield session
    session.close()
    Base.metadata.drop_all(engine)
@pytest.fixture
 def populated_db_session(db_session):
    """Esta também fica disponível para todos."""
    travel_diary = TravelDiary(name="My Travel Diary", directory_name="viagem-teste")
    db_session.add(travel_diary)
    db_session.commit()
    return db_session
@pytest.fixture
 def session_with_one_diary(db_session):
    diary = TravelDiary(name="Diário de Teste", directory_name="diario_de_teste")
    db_session.add(diary)
    db_session.commit()
    db_session.refresh(diary)
    return db_session, diary
@pytest.fixture
 def session_with_photos(session_with_one_diary):
    session, diary = session_with_one_diary
    # Usamos a mesma raiz de diretório que o mock do teste espera
    diaries_root = "/fake/diaries_root"
    photo1 = Photo(
        # CORREÇÃO: O caminho agora inclui a raiz e a subpasta 'images'
        filepath=f"{diaries_root}/{diary.directory_name}/images/p1.jpg",
        name="Foto 1",
        photo_hash="hash1",
        fk_travel_diary_id=diary.id
    )
    photo2 = Photo(
        filepath=f"{diaries_root}/{diary.directory_name}/images/p2.jpg",
        name="Foto 2",
        photo_hash="hash2",
        fk_travel_diary_id=diary.id
    )
    session.add_all([photo1, photo2])
    session.commit()
    return session, [photo1, photo2]
@@ -0,0 +1,269 @@
 from re import search
 import pytest
 from datetime import datetime
 from unittest.mock import Mock
 from sqlalchemy import create_engine
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import sessionmaker
 from pilgrim.database import Base
 from pilgrim.models.travel_diary import TravelDiary
 from pilgrim.models.entry import Entry
 from pilgrim.models.photo import Photo
 from pilgrim.service.entry_service import EntryService
@pytest.fixture
 def session_with_an_entry(populated_db_session):
    session = populated_db_session
    initial_entry = Entry(
        title="Título Original",
        text="Texto original.",
        date=datetime(2025, 1, 1),
        travel_diary_id=1
    )
    session.add(initial_entry)
    session.commit()
    return session, initial_entry.id
@pytest.fixture
 def session_with_multiple_entries(populated_db_session):
    """Fixture que cria um diário e duas entradas para ele."""
    session = populated_db_session
    entry1 = Entry(title="Entrada 1", text="Texto 1", date=datetime(2025, 1, 1), travel_diary_id=1)
    entry2 = Entry(title="Entrada 2", text="Texto 2", date=datetime(2025, 1, 2), travel_diary_id=1)
    session.add_all([entry1, entry2])
    session.commit()
    return session
 def test_create_entry_successfully(populated_db_session):
    session = populated_db_session
    service = EntryService(session)
    diary_id = 1  # Sabemos que o ID é 1 por causa da nossa fixture
    title = "Primeiro Dia na Praia"
    text = "O dia foi ensolarado e o mar estava ótimo."
    date = datetime(2025, 7, 20)
    photos = [Photo(filepath="/path/to/photo1.jpg",name="Photo 1",photo_hash="hash_12345678",fk_travel_diary_id=diary_id), Photo(filepath="/path/to/photo2.jpg",name="Photo 1",photo_hash="hash_87654321",fk_travel_diary_id=diary_id)]
    created_entry = service.create(
        travel_diary_id=diary_id,
        title=title,
        text=text,
        date=date,
        photos=photos
    )
    assert created_entry is not None
    assert created_entry.id is not None  # Garante que foi salvo no BD e tem um ID
    assert created_entry.title == title
    assert created_entry.text == text
    assert len(created_entry.photos) == 2
    assert created_entry.photos[0].filepath == "/path/to/photo1.jpg"
    entry_in_db = session.query(Entry).filter_by(id=created_entry.id).one()
    assert entry_in_db.title == "Primeiro Dia na Praia"
 def test_create_entry_fails_when_diary_id_is_invalid(db_session):
    session = db_session
    service = EntryService(session)
    invalid_id = 666
    result = service.create(
        travel_diary_id=invalid_id,
        title="Título de Teste",
        text="Texto de Teste",
        date=datetime(2025, 7, 20),
        photos=[]
    )
    assert result is None
 def test_create_entry_successfully_without_photo(populated_db_session):
    session = populated_db_session
    service = EntryService(session)
    diary_id = 1  # Sabemos que o ID é 1 por causa da nossa fixture
    title = "Primeiro Dia na Praia"
    text = "O dia foi ensolarado e o mar estava ótimo."
    date = datetime(2025, 7, 20)
    photos = []
    created_entry = service.create(
        travel_diary_id=diary_id,
        title=title,
        text=text,
        date=date,
        photos=photos
    )
    assert created_entry is not None
    assert created_entry.id is not None  # Garante que foi salvo no BD e tem um ID
    assert created_entry.title == title
    assert created_entry.text == text
    assert len(created_entry.photos) == 0
    entry_in_db = session.query(Entry).filter_by(id=created_entry.id).one()
    assert entry_in_db.title == "Primeiro Dia na Praia"
 def test_create_entry_fails_with_null_title(populated_db_session):
    session = populated_db_session
    service = EntryService(session)
    diary_id = 1
    with pytest.raises(IntegrityError):
        service.create(
            travel_diary_id=diary_id,
            title=None,
            text="Um texto qualquer.",
            date=datetime.now(),
            photos=[]
        )
 def test_create_entry_fails_with_null_date(populated_db_session):
    session = populated_db_session
    service = EntryService(session)
    diary_id = 1
    with pytest.raises(IntegrityError):
        service.create(
            travel_diary_id=diary_id,
            title="Sabado de sol",
            text="Um texto qualquer.",
            date=None,
            photos=[]
        )
 def test_create_entry_fails_with_null_diary_id(populated_db_session):
    session = populated_db_session
    service = EntryService(session)
    diary_id = 1
    result = service.create(
            travel_diary_id=None,
            title="Sabado de sol",
            text="Um texto qualquer.",
            date=datetime.now(),
            photos=[]
        )
    assert result is None
 def test_ready_by_id_successfully(session_with_an_entry):
    session,_ = session_with_an_entry
    service = EntryService(session)
    search_id = 1
    result = service.read_by_id(search_id)
    assert result is not None
 def test_ready_by_id_fails_when_id_is_invalid(db_session):
    session = db_session
    service = EntryService(session)
    invalid_id = 666
    result = service.read_by_id(invalid_id)
    assert result is None
 def test_read_all_returns_all_entries(session_with_multiple_entries):
    session = session_with_multiple_entries
    service = EntryService(session)
    all_entries = service.read_all()
    assert isinstance(all_entries, list)
    assert len(all_entries) == 2
    assert all_entries[0].title == "Entrada 1"
    assert all_entries[1].title == "Entrada 2"
 def test_read_all_returns_empty_list_on_empty_db(db_session):
    session = db_session
    service = EntryService(session)
    all_entries = service.read_all()
    assert isinstance(all_entries, list)
    assert len(all_entries) == 0
 def test_update_entry_successfully(session_with_an_entry):
    session, entry_id = session_with_an_entry
    service = EntryService(session)
    entry_src = session.query(Entry).filter_by(id=entry_id).one()
    new_date = datetime(2025, 1, 2)
    entry_dst = Entry(
        title="Título Atualizado",
        text="Texto atualizado.",
        date=new_date,
        travel_diary_id=1,  # Mantemos o mesmo travel_diary_id
        photos=[]
    )
    updated_entry = service.update(entry_src, entry_dst)
    assert updated_entry is not None
    assert updated_entry.id == entry_id
    assert updated_entry.title == "Título Atualizado"
    assert updated_entry.text == "Texto atualizado."
    entry_in_db = session.query(Entry).filter_by(id=entry_id).one()
    assert entry_in_db.title == "Título Atualizado"
 def test_update_entry_fails_if_entry_does_not_exist(db_session):
    service = EntryService(db_session)
    non_existent_entry = Entry(
        title="dummy",
        text="dummy",
        date=datetime.now(),
        travel_diary_id=1)
    non_existent_entry.id = 999
    entry_with_new_data = Entry(title="Novo Título", text="Novo Texto", date=datetime.now(), travel_diary_id=1)
    result = service.update(non_existent_entry, entry_with_new_data)
    assert result is None
 def test_update_fails_with_null_title(session_with_an_entry):
    session, entry_id = session_with_an_entry
    service = EntryService(session)
    entry_src = session.query(Entry).filter_by(id=entry_id).one()
    entry_dst = Entry(
        title=None,
        text="Texto atualizado.",
        date=datetime.now(),
        travel_diary_id=1,
        photos=[]
    )
    with pytest.raises(IntegrityError):
        service.update(entry_src, entry_dst)
 def test_update_fails_with_null_date(session_with_an_entry):
    session, entry_id = session_with_an_entry
    service = EntryService(session)
    entry_src = session.query(Entry).filter_by(id=entry_id).one()
    entry_dst = Entry(
        title=entry_src.title,
        text="Texto atualizado.",
        date=None,
        travel_diary_id=1,
        photos=[]
    )
    with pytest.raises(IntegrityError):
        service.update(entry_src, entry_dst)
 def test_update_fails_with_null_diary_id(session_with_an_entry):
    session, entry_id = session_with_an_entry
    service = EntryService(session)
    entry_src = session.query(Entry).filter_by(id=entry_id).one()
    entry_dst = Entry(
        title=entry_src.title,
        text="Texto atualizado.",
        date=datetime.now(),
        travel_diary_id=None,
        photos=[]
    )
    with pytest.raises(IntegrityError):
        service.update(entry_src, entry_dst)
 def test_delete_successfully_removes_entry(session_with_an_entry):
    session, entry_id = session_with_an_entry
    service = EntryService(session)
    entry_to_delete = service.read_by_id(entry_id)
    assert entry_to_delete is not None
    deleted_entry = service.delete(entry_to_delete)
    assert deleted_entry is not None
    assert deleted_entry.id == entry_id
    entry_in_db = service.read_by_id(entry_id)
    assert entry_in_db is None
 def test_delete_returns_none_if_entry_does_not_exist(db_session):
    service = EntryService(db_session)
    non_existent_entry = Entry(
        title="dummy",
        text="dummy",
        date=datetime.now(),
        travel_diary_id=1)
    non_existent_entry.id = 999
    result = service.delete(non_existent_entry)
    assert result is None
@@ -0,0 +1,249 @@
 import pytest
 from pathlib import Path
 from pilgrim import TravelDiary
 from pilgrim.service.photo_service import PhotoService
 import hashlib
 from unittest.mock import patch
 from pilgrim.models.photo import Photo
 from pilgrim.utils import DirectoryManager
@patch.object(PhotoService, '_copy_photo_to_diary')
@patch.object(PhotoService, 'hash_file', return_value="fake_hash_123")
 def test_create_photo_successfully(mock_hash, mock_copy, session_with_one_diary):
    session, diary = session_with_one_diary
    service = PhotoService(session)
    fake_source_path = Path("/path/original/imagem.jpg")
    fake_copied_path = Path(f"~/.pilgrim/diaries/{diary.directory_name}/images/imagem.jpg")
    mock_copy.return_value = fake_copied_path
    new_photo = service.create(
        filepath=fake_source_path,
        name="Foto da Praia",
        travel_diary_id=diary.id,
        caption="Pôr do sol")
    mock_hash.assert_called_once_with(fake_source_path)
    mock_copy.assert_called_once_with(fake_source_path, diary)
    assert new_photo is not None
    assert new_photo.name == "Foto da Praia"
    assert new_photo.photo_hash == "fake_hash_123"
    assert new_photo.filepath == str(fake_copied_path)
 def test_hash_file_generates_correct_hash(tmp_path: Path):
    original_content_bytes = b"um conteudo de teste para o hash"
    file_on_disk = tmp_path / "test.jpg"
    file_on_disk.write_bytes(original_content_bytes)
    hash_from_file = PhotoService.hash_file(file_on_disk)
    expected_hash_func = hashlib.new('sha3_384')
    expected_hash_func.update(original_content_bytes)
    hash_from_memory = expected_hash_func.hexdigest()
    assert hash_from_file == hash_from_memory
@patch.object(PhotoService, '_copy_photo_to_diary')
@patch.object(PhotoService, 'hash_file', return_value="hash_ja_existente")
 def test_create_photo_returns_none_if_hash_exists(mock_hash, mock_copy, session_with_one_diary):
    session, diary = session_with_one_diary
    existing_photo = Photo(
        filepath="/path/existente.jpg", name="Foto Antiga",
        photo_hash="hash_ja_existente", fk_travel_diary_id=diary.id
    )
    session.add(existing_photo)
    session.commit()
    service = PhotoService(session)
    new_photo = service.create(
        filepath=Path("/path/novo/arquivo.jpg"),
        name="Foto Nova",
        travel_diary_id=diary.id
    )
    assert new_photo is None
    mock_copy.assert_not_called()
 def test_read_by_id_successfully(session_with_photos):
    session, photos = session_with_photos
    service = PhotoService(session)
    photo_to_find_id = photos[0].id
    found_photo = service.read_by_id(photo_to_find_id)
    assert found_photo is not None
    assert found_photo.id == photo_to_find_id
    assert found_photo.name == "Foto 1"
 def test_read_by_id_returns_none_for_invalid_id(db_session):
    service = PhotoService(db_session)
    result = service.read_by_id(999)
    assert result is None
 def test_read_all_returns_all_photos(session_with_photos):
    session, _ = session_with_photos
    service = PhotoService(session)
    all_photos = service.read_all()
    assert isinstance(all_photos, list)
    assert len(all_photos) == 2
    assert all_photos[0].name == "Foto 1"
    assert all_photos[1].name == "Foto 2"
 def test_read_all_returns_empty_list_for_empty_db(db_session):
    service = PhotoService(db_session)
    all_photos = service.read_all()
    assert isinstance(all_photos, list)
    assert len(all_photos) == 0
 def test_check_photo_by_hash_finds_existing_photo(session_with_photos):
    session, photos = session_with_photos
    service = PhotoService(session)
    existing_photo = photos[0]
    hash_to_find = existing_photo.photo_hash  # "hash1"
    diary_id = existing_photo.fk_travel_diary_id  # 1
    found_photo = service.check_photo_by_hash(hash_to_find, diary_id)
    assert found_photo is not None
    assert found_photo.id == existing_photo.id
    assert found_photo.photo_hash == hash_to_find
 def test_check_photo_by_hash_returns_none_when_not_found(session_with_photos):
    session, photos = session_with_photos
    service = PhotoService(session)
    existing_hash = photos[0].photo_hash  # "hash1"
    existing_diary_id = photos[0].fk_travel_diary_id  # 1
    result1 = service.check_photo_by_hash("hash_inexistente", existing_diary_id)
    assert result1 is None
    invalid_diary_id = 999
    result2 = service.check_photo_by_hash(existing_hash, invalid_diary_id)
    assert result2 is None
 def test_update_photo_metadata_successfully(session_with_photos):
    session, photos = session_with_photos
    service = PhotoService(session)
    photo_to_update = photos[0]
    photo_with_new_data = Photo(
        filepath=photo_to_update.filepath,
        name="Novo Nome da Foto",
        caption="Nova legenda para a foto.",
        photo_hash=photo_to_update.photo_hash,  # O hash não muda
        addition_date=photo_to_update.addition_date,
        fk_travel_diary_id=photo_to_update.fk_travel_diary_id
    )
    updated_photo = service.update(photo_to_update, photo_with_new_data)
    assert updated_photo is not None
    assert updated_photo.name == "Novo Nome da Foto"
    assert updated_photo.caption == "Nova legenda para a foto."
    assert updated_photo.photo_hash == photo_to_update.photo_hash
    photo_in_db = session.query(Photo).get(photo_to_update.id)
    assert photo_in_db.name == "Novo Nome da Foto"
@patch.object(PhotoService, 'hash_file')
@patch('pathlib.Path.unlink')
@patch('pathlib.Path.exists')
@patch.object(PhotoService, '_copy_photo_to_diary')
@patch.object(DirectoryManager, 'get_diaries_root', return_value="/fake/diaries_root")
 def test_update_photo_with_new_file_successfully(
    mock_get_root, mock_copy, mock_exists, mock_unlink, mock_hash, session_with_photos
 ):
    session, photos = session_with_photos
    service = PhotoService(session)
    photo_to_update = photos[0]
    new_source_path = Path("/path/para/nova_imagem.jpg")
    new_copied_path = Path(f"/fake/diaries_root/{photo_to_update.travel_diary.directory_name}/images/nova_imagem.jpg")
    mock_copy.return_value = new_copied_path
    mock_exists.return_value = True
    mock_hash.return_value = "novo_hash_calculado"
    photo_with_new_file = Photo(
        filepath=new_source_path,
        name=photo_to_update.name,
        photo_hash="hash_antigo",
        fk_travel_diary_id=photo_to_update.fk_travel_diary_id
    )
    updated_photo = service.update(photo_to_update, photo_with_new_file)
    mock_copy.assert_called_once_with(new_source_path, photo_to_update.travel_diary)
    mock_unlink.assert_called_once()
    mock_hash.assert_called_once_with(new_copied_path)
    assert updated_photo.filepath == str(new_copied_path)
    assert updated_photo.photo_hash == "novo_hash_calculado"
 def test_update_photo_returns_none_if_photo_does_not_exist(db_session):
    service = PhotoService(db_session)
    non_existent_photo_src = Photo(
        filepath="/fake/path.jpg", name="dummy",
        photo_hash="dummy", fk_travel_diary_id=1
    )
    non_existent_photo_src.id = 999
    photo_with_new_data = Photo(
        filepath="/fake/new.jpg", name="new dummy",
        photo_hash="new_dummy", fk_travel_diary_id=1
    )
    result = service.update(non_existent_photo_src, photo_with_new_data)
    assert result is None
@patch.object(PhotoService, 'hash_file')
@patch('pathlib.Path.unlink')
@patch('pathlib.Path.exists')
@patch.object(PhotoService, '_copy_photo_to_diary')
@patch.object(DirectoryManager, 'get_diaries_root', return_value="/fake/diaries_root")
 def test_update_photo_with_new_file_successfully(
    mock_get_root, mock_copy, mock_exists, mock_unlink, mock_hash, session_with_photos
 ):
    session, photos = session_with_photos
    service = PhotoService(session)
    photo_to_update = photos[0]
    new_source_path = Path("/path/para/nova_imagem.jpg")
    new_copied_path = Path(f"/fake/diaries_root/{photo_to_update.travel_diary.directory_name}/images/nova_imagem.jpg")
    mock_copy.return_value = new_copied_path
    mock_exists.return_value = True
    mock_hash.return_value = "novo_hash_calculado"
    photo_with_new_file = Photo(
        filepath=new_source_path, name=photo_to_update.name,
        photo_hash="hash_antigo", fk_travel_diary_id=photo_to_update.fk_travel_diary_id
    )
    updated_photo = service.update(photo_to_update, photo_with_new_file)
    mock_copy.assert_called_once_with(new_source_path, photo_to_update.travel_diary)
    mock_unlink.assert_called_once()
    mock_hash.assert_called_once_with(new_copied_path)
    assert updated_photo.filepath == str(new_copied_path)
    assert updated_photo.photo_hash == "novo_hash_calculado"
@patch.object(DirectoryManager, 'get_diary_images_directory')
 def test_copy_photo_to_diary_handles_name_collision_with_patch(mock_get_images_dir, db_session, tmp_path: Path):
    images_dir = tmp_path / "images"
    images_dir.mkdir()
    mock_get_images_dir.return_value = images_dir
    source_file = tmp_path / "foto.jpg"
    source_file.touch()
    (images_dir / "foto.jpg").touch()
    service = PhotoService(db_session)
    fake_diary = TravelDiary(name="test",directory_name="fake_diary")
    copied_path = service._copy_photo_to_diary(source_file, fake_diary)
    assert copied_path.name == "foto_1.jpg"
    assert copied_path.exists()
@patch('pathlib.Path.unlink')
@patch('pathlib.Path.exists')
@patch.object(DirectoryManager, 'get_diaries_root', return_value="/fake/diaries_root")
 def test_delete_photo_successfully(mock_get_root, mock_exists, mock_unlink, session_with_photos):
    session, photos = session_with_photos
    service = PhotoService(session)
    photo_to_delete = photos[0]
    photo_id = photo_to_delete.id
    mock_exists.return_value = True
    deleted_photo_data = service.delete(photo_to_delete)
    mock_unlink.assert_called_once()
    assert deleted_photo_data is not None
    assert deleted_photo_data.id == photo_id
    photo_in_db = service.read_by_id(photo_id)
    assert photo_in_db is None
@patch('pathlib.Path.unlink')
 def test_delete_returns_none_for_non_existent_photo(mock_unlink, db_session):
    service = PhotoService(db_session)
    non_existent_photo = Photo(
        filepath="/fake/path.jpg", name="dummy",
        photo_hash="dummy_hash", fk_travel_diary_id=1
    )
    non_existent_photo.id = 999
    result = service.delete(non_existent_photo)
    assert result is None
    mock_unlink.assert_not_called()
@@ -0,0 +1,33 @@
 from pilgrim.service.servicemanager import ServiceManager
 from unittest.mock import patch, MagicMock
 def test_initial_state_is_none():
    manager = ServiceManager()
    assert manager.get_session() is None
    assert manager.get_entry_service() is None
    assert manager.get_photo_service() is None
    assert manager.get_travel_diary_service() is None
@patch('pilgrim.service.servicemanager.TravelDiaryService')
@patch('pilgrim.service.servicemanager.PhotoService')
@patch('pilgrim.service.servicemanager.EntryService')
 def test_get_services_instantiates_with_correct_session(
    mock_entry_service, mock_photo_service, mock_travel_diary_service
 ):
    manager = ServiceManager()
    mock_session = MagicMock()
    manager.set_session(mock_session)
    entry_service_instance = manager.get_entry_service()
    photo_service_instance = manager.get_photo_service()
    travel_diary_service_instance = manager.get_travel_diary_service()
    mock_entry_service.assert_called_once()
    mock_photo_service.assert_called_once()
    mock_travel_diary_service.assert_called_once()
    mock_entry_service.assert_called_once_with(mock_session)
    mock_photo_service.assert_called_once_with(mock_session)
    mock_travel_diary_service.assert_called_once_with(mock_session)
    assert entry_service_instance == mock_entry_service.return_value
    assert photo_service_instance == mock_photo_service.return_value
    assert travel_diary_service_instance == mock_travel_diary_service.return_value
@@ -0,0 +1,143 @@
 from unittest.mock import patch, MagicMock
 from pathlib import Path
 import pytest
 from pilgrim import TravelDiary
 from pilgrim.service.travel_diary_service import TravelDiaryService
@patch.object(TravelDiaryService, '_ensure_diary_directory')
@pytest.mark.asyncio # Marca o teste para rodar código assíncrono
 async def test_create_diary_successfully(mock_ensure_dir, db_session):
    service = TravelDiaryService(db_session)
    new_diary = await service.async_create("Viagem para a Serra")
    assert new_diary is not None
    assert new_diary.id is not None
    assert new_diary.name == "Viagem para a Serra"
    assert new_diary.directory_name == "viagem_para_a_serra"
@patch.object(TravelDiaryService, '_ensure_diary_directory')
@patch.object(TravelDiaryService, '_sanitize_directory_name', return_value="nome_existente")
@pytest.mark.asyncio
 async def test_create_diary_handles_integrity_error(mock_sanitize, mock_ensure_dir, db_session):
    existing_diary = TravelDiary(name="Diário Antigo", directory_name="nome_existente")
    db_session.add(existing_diary)
    db_session.commit()
    service = TravelDiaryService(db_session)
    with pytest.raises(ValueError, match="Could not create diary"):
        await service.async_create("Qualquer Nome Novo")
    mock_ensure_dir.assert_not_called()
@patch.object(TravelDiaryService, '_ensure_diary_directory')
 def test_read_by_id_successfully(mock_ensure_dir, session_with_one_diary):
    session, diary_to_find = session_with_one_diary
    service = TravelDiaryService(session)
    found_diary = service.read_by_id(diary_to_find.id)
    assert found_diary is not None
    assert found_diary.id == diary_to_find.id
    assert found_diary.name == "Diário de Teste"
    mock_ensure_dir.assert_called_once_with(found_diary)
@patch.object(TravelDiaryService, '_ensure_diary_directory')
 def test_read_by_id_returns_none_for_invalid_id(mock_ensure_dir, db_session):
    service = TravelDiaryService(db_session)
    result = service.read_by_id(999)
    assert result is None
    mock_ensure_dir.assert_not_called()
@patch.object(TravelDiaryService, '_ensure_diary_directory')
 def test_read_all_returns_all_diaries(mock_ensure_dir, db_session):
    d1 = TravelDiary(name="Diário 1", directory_name="d1")
    d2 = TravelDiary(name="Diário 2", directory_name="d2")
    db_session.add_all([d1, d2])
    db_session.commit()
    service = TravelDiaryService(db_session)
    diaries = service.read_all()
    assert isinstance(diaries, list)
    assert len(diaries) == 2
    assert mock_ensure_dir.call_count == 2
@patch.object(TravelDiaryService, '_ensure_diary_directory')
 def test_read_all_returns_empty_list_for_empty_db(mock_ensure_dir, db_session):
    service = TravelDiaryService(db_session)
    diaries = service.read_all()
    assert isinstance(diaries, list)
    assert len(diaries) == 0
    mock_ensure_dir.assert_not_called()
@patch.object(TravelDiaryService, '_ensure_diary_directory')
@patch('pathlib.Path.rename')
@patch.object(TravelDiaryService, '_get_diary_directory')
 def test_update_diary_successfully(mock_get_dir, mock_path_rename, mock_ensure, session_with_one_diary):
    session, diary_to_update = session_with_one_diary
    service = TravelDiaryService(session)
    old_path = MagicMock(spec=Path)  # Um mock que se parece com um objeto Path
    old_path.exists.return_value = True  # Dizemos que o diretório antigo "existe"
    new_path = Path("/fake/path/diario_atualizado")
    mock_get_dir.side_effect = [old_path, new_path]
    updated_diary = service.update(diary_to_update.id, "Diário Atualizado")
    assert updated_diary is not None
    assert updated_diary.name == "Diário Atualizado"
    assert updated_diary.directory_name == "diario_atualizado"
    old_path.rename.assert_called_once_with(new_path)
 def test_update_returns_none_for_invalid_id(db_session):
    service = TravelDiaryService(db_session)
    result = service.update(travel_diary_id=999, name="Nome Novo")
    assert result is None
@patch.object(TravelDiaryService, '_cleanup_diary_directory')
 def test_delete_diary_successfully(mock_cleanup, session_with_one_diary):
    session, diary_to_delete = session_with_one_diary
    service = TravelDiaryService(session)
    result = service.delete(diary_to_delete)
    assert result is not None
    assert result.id == diary_to_delete.id
    mock_cleanup.assert_called_once_with(diary_to_delete)
    diary_in_db = service.read_by_id(diary_to_delete.id)
    assert diary_in_db is None
@patch.object(TravelDiaryService, '_cleanup_diary_directory')
 def test_delete_returns_none_for_non_existent_diary(mock_cleanup, db_session):
    service = TravelDiaryService(db_session)
    non_existent_diary = TravelDiary(name="dummy", directory_name="dummy")
    non_existent_diary.id = 999
    result = service.delete(non_existent_diary)
    assert result is None
    mock_cleanup.assert_not_called()
@patch.object(TravelDiaryService, '_sanitize_directory_name')
 def test_update_raises_value_error_on_name_collision(mock_sanitize, db_session):
    d1 = TravelDiary(name="Diário A", directory_name="diario_a")
    d2 = TravelDiary(name="Diário B", directory_name="diario_b")
    db_session.add_all([d1, d2])
    db_session.commit()
    db_session.refresh(d1)
    mock_sanitize.return_value = "diario_b"
    service = TravelDiaryService(db_session)
    with pytest.raises(ValueError, match="Could not update diary"):
        service.update(d1.id, "Diário B")
 def test_sanitize_directory_name_formats_string_correctly(db_session):
    service = TravelDiaryService(db_session)
    name1 = "Minha Primeira Viagem"
    assert service._sanitize_directory_name(name1) == "minha_primeira_viagem"
    name2 = "Viagem para o #Rio de Janeiro! @2025"
    assert service._sanitize_directory_name(name2) == "viagem_para_o_rio_de_janeiro_2025"
    name3 = "  Mochilão na Europa   "
    assert service._sanitize_directory_name(name3) == "mochilao_na_europa"
 def test_sanitize_directory_name_handles_uniqueness(db_session):
    existing_diary = TravelDiary(name="Viagem para a Praia", directory_name="viagem_para_a_praia")
    db_session.add(existing_diary)
    db_session.commit()
    service = TravelDiaryService(db_session)
    new_sanitized_name = service._sanitize_directory_name("Viagem para a Praia")
    assert new_sanitized_name == "viagem_para_a_praia_1"
    another_diary = TravelDiary(name="Outra Viagem", directory_name="viagem_para_a_praia_1")
    db_session.add(another_diary)
    db_session.commit()
    third_sanitized_name = service._sanitize_directory_name("Viagem para a Praia")
    assert third_sanitized_name == "viagem_para_a_praia_2"
@@ -0,0 +1,9 @@
 from unittest.mock import patch
 from pilgrim.command import main
@patch('pilgrim.command.Application')
 def test_main_function_runs_application(MockApplication):
    mock_app_instance = MockApplication.return_value
    main()
    MockApplication.assert_called_once()
    mock_app_instance.run.assert_called_once()
@@ -0,0 +1,40 @@
 import pytest
 from unittest.mock import Mock  # A ferramenta para criar nosso "dublê"
 from pathlib import Path
 from sqlalchemy import inspect, Column, Integer, String
 from sqlalchemy.orm import Session
 from pilgrim.database import Database,Base
 class MockUser(Base):
    __tablename__ = 'mock_users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
@pytest.fixture
 def db_instance(tmp_path: Path):
    fake_db_path = tmp_path / "test_pilgrim.db"
    mock_config_manager = Mock()
    mock_config_manager.database_url = str(fake_db_path)
    db = Database(mock_config_manager)
    return db, fake_db_path
 def test_create_database(db_instance):
    db, fake_db_path = db_instance
    db.create()
    assert fake_db_path.exists()
 def test_table_creation(db_instance):
    db, _ = db_instance
    db.create()
    inspector = inspect(db.engine)
    assert "mock_users" in inspector.get_table_names()
 def test_session_returned_corectly(db_instance):
    db, _ = db_instance
    session = db.session()
    assert isinstance(session, Session)
    session.close()
@@ -0,0 +1,67 @@
 import pytest
 import tomli
 from pathlib import Path
 from unittest.mock import patch
 from pilgrim.utils.config_manager import ConfigManager, SingletonMeta
 from pilgrim.utils.directory_manager import DirectoryManager
@pytest.fixture
 def clean_singleton():
    SingletonMeta._instances = {}
@patch('pilgrim.utils.config_manager.DirectoryManager.get_config_directory')
 def test_create_default_config_if_not_exists_with_decorator(mock_get_config_dir, tmp_path: Path, clean_singleton):
    mock_get_config_dir.return_value = str(tmp_path)
    manager = ConfigManager()
    config_file = tmp_path / "config.toml"
    assert not config_file.exists()
    manager.read_config()
    assert config_file.exists()
    assert manager.database_type == "sqlite"
@patch('pilgrim.utils.config_manager.DirectoryManager.get_config_directory')
 def test_read_existing_config_with_decorator(mock_get_config_dir, tmp_path: Path, clean_singleton):
    mock_get_config_dir.return_value = str(tmp_path)
    custom_config_content = """
    [database]
    url = "/custom/path/to/db.sqlite"
    type = "custom_sqlite"
    [settings.diary]
    auto_open_diary_on_startup = "MyCustomDiary"
    auto_open_on_creation = true
    """
    config_file = tmp_path / "config.toml"
    config_file.write_text(custom_config_content)
    manager = ConfigManager()
    manager.read_config()
    assert manager.database_url == "/custom/path/to/db.sqlite"
    assert manager.database_type == "custom_sqlite"
@patch('pilgrim.utils.config_manager.DirectoryManager.get_config_directory')
 def test_save_config_writes_changes_to_file_with_decorator(mock_get_config_dir, tmp_path: Path, clean_singleton):
    mock_get_config_dir.return_value = str(tmp_path)
    manager = ConfigManager()
    manager.read_config()
    manager.set_database_url("/novo/caminho.db")
    manager.set_auto_open_new_diary(True)
    manager.save_config()
    config_file = tmp_path / "config.toml"
    with open(config_file, "rb") as f:
        data = tomli.load(f)
        assert data["database"]["url"] == "/novo/caminho.db"
        assert data["settings"]["diary"]["auto_open_on_creation"] is True
@patch('pilgrim.utils.config_manager.DirectoryManager.get_config_directory')
 def test_read_config_raises_error_on_malformed_toml(mock_get_config_dir, tmp_path: Path, clean_singleton):
    mock_get_config_dir.return_value = str(tmp_path)
    invalid_toml_content = """
       [database]
       url = /caminho/sem/aspas
       """
    config_file = tmp_path / "config.toml"
    config_file.write_text(invalid_toml_content)
    manager = ConfigManager()
    with pytest.raises(ValueError, match="Invalid TOML configuration"):
        manager.read_config()
@@ -0,0 +1,71 @@
 import shutil
 from pathlib import Path
 from unittest.mock import patch
 import pytest
 from pilgrim.utils.directory_manager import DirectoryManager
@patch('os.chmod')
@patch('pathlib.Path.home')
 def test_get_config_directory_creates_dir_in_fake_home(mock_home, mock_chmod, tmp_path: Path):
    mock_home.return_value = tmp_path
    expected_config_dir = tmp_path / ".pilgrim"
    assert not expected_config_dir.exists()
    result_path = DirectoryManager.get_config_directory()
    assert result_path == expected_config_dir
    assert expected_config_dir.exists()
    mock_chmod.assert_called_once_with(expected_config_dir, 0o700)
@patch('shutil.copy2')
@patch('pathlib.Path.home')
 def test_get_database_path_no_migration(mock_home, mock_copy, tmp_path: Path):
    mock_home.return_value = tmp_path
    expected_db_path = tmp_path / ".pilgrim" / "database.db"
    result_path = DirectoryManager.get_database_path()
    assert result_path == expected_db_path
    mock_copy.assert_not_called()
@patch('shutil.copy2')
@patch('pathlib.Path.home')
 def test_get_database_path_with_migration(mock_home, mock_copy, tmp_path: Path, monkeypatch):
    fake_home_dir = tmp_path / "home"
    fake_project_dir = tmp_path / "project"
    fake_home_dir.mkdir()
    fake_project_dir.mkdir()
    (fake_project_dir / "database.db").touch()
    mock_home.return_value = fake_home_dir
    monkeypatch.chdir(fake_project_dir)
    result_path = DirectoryManager.get_database_path()
    expected_db_path = fake_home_dir / ".pilgrim" / "database.db"
    assert result_path == expected_db_path
    mock_copy.assert_called_once_with(
        Path("database.db"),
        expected_db_path
    )
@patch('os.chmod')
@patch('pathlib.Path.home')
 def test_diary_path_methods_construct_correctly(mock_home, mock_chmod, tmp_path: Path):
    mock_home.return_value = tmp_path
    images_path = DirectoryManager.get_diary_images_directory("minha-viagem")
    expected_path = tmp_path / ".pilgrim" / "diaries" / "minha-viagem" / "data" / "images"
    assert images_path == expected_path
    assert (tmp_path / ".pilgrim" / "diaries").exists()
@patch('shutil.copy2')
@patch('pathlib.Path.home')
 def test_get_database_path_handles_migration_error(mock_home, mock_copy, tmp_path: Path, monkeypatch):
    fake_home_dir = tmp_path / "home"
    fake_project_dir = tmp_path / "project"
    fake_home_dir.mkdir()
    fake_project_dir.mkdir()
    (fake_project_dir / "database.db").touch()
    mock_home.return_value = fake_home_dir
    mock_copy.side_effect = shutil.Error("O disco está cheio!")
    monkeypatch.chdir(fake_project_dir)
    with pytest.raises(RuntimeError, match="Failed to migrate database"):
        DirectoryManager.get_database_path()
    mock_copy.assert_called_once()