Md. Mostasim Mahmud

Gross Module:

• Automates the documentation of tissue sample examinations.
• Allows lab technicians to record size, shape, and other characteristics with image integration.
• Ensures data is accurately captured and linked to patient records.

Transcription Module:

• Integrates voice recognition to transcribe verbal findings from lab technicians and doctors.
• Minimizes errors and speeds up documentation.

Doctor Module:

• Provides doctors with streamlined access to lab results, patient records, and diagnostic tools.
• Enables efficient collaboration with lab personnel and allows requesting additional tests through the system.

Automated Report Generation Module:

• Compiles data from other modules (e.g., gross examinations, transcription) into cohesive reports.
• Uses predefined templates to reduce manual reporting efforts and ensure consistency.

Histopath Lab Module:

• Manages the examination of tissue samples under a microscope.
• Integrates with other modules to streamline the diagnostic process for diseases like cancer.
• Allows image attachments for more comprehensive reporting.

Cytopath Lab Module:

• Focuses on cell-level analysis for diagnosing diseases such as cancers and infections.
• Integrates with patient records and allows high-resolution image storage for accurate cell analysis.

Technologies Used:

• Backend: Django REST API for scalable and secure server-side operations.
• Frontend: Next.js for dynamic and responsive user interfaces.
• Database: PostgreSQL for reliable and efficient data storage.
• Recommendation System: Collaborative filtering and machine learning algorithms for personalized product recommendations.

Key Features:

• Product Catalog: Browse and search products with filters and categories.
• User Authentication: Secure login and registration with JWT (JSON Web Tokens).
• Shopping Cart: Add, remove, and manage items in the cart.
• Payment Integration: Secure payment gateway integration for seamless transactions.
• Order Management: Track orders, view order history, and manage returns.
• Recommendation System: Personalized product recommendations based on user behavior and preferences.
• Admin Panel: Manage products, orders, and users with an intuitive admin interface.
• Responsive Design: Fully responsive UI for seamless browsing on all devices.

Recommendation System:

• Uses collaborative filtering to recommend products based on user behavior and purchase history.
• Implements machine learning algorithms to improve recommendation accuracy over time.
• Provides personalized product suggestions on the homepage, product pages, and checkout.

Technologies Used:

• Backend: Django REST API for robust and scalable server-side operations.
• Frontend: Next.js for a dynamic and responsive user interface.
• Database: PostgreSQL for secure and efficient data storage.
• Admin Panel: Jasmin Admin Panel for easy management of yearbook content and users.

Key Features:

• Yearbook Creation: Schools can create and customize digital yearbooks with ease.
• Photo Uploads: Students and teachers can upload photos and memories to the yearbook.
• User Roles: Different roles for admins, teachers, and students with appropriate permissions.
• Search and Filters: Easily search and filter yearbook content by name, year, or event.
• Responsive Design: Fully responsive UI for seamless access on all devices.
• Export Options: Export yearbooks as PDFs or share them digitally via links.
• Admin Panel: Jasmin Admin Panel for managing users, content, and yearbook settings.

Project Highlights:

• Collaborated with an Upwork client to deliver a tailored solution for digital yearbooks.
• Implemented a user-friendly interface for schools to manage yearbooks effortlessly.
• Integrated Jasmin Admin Panel for efficient content and user management.
• Enabled seamless photo uploads and sharing for students and teachers.

Primary Server Setup:

                # Create archive & backup directories
                sudo mkdir -p /mnt/server/archivedir
                sudo mkdir -p /mnt/pg_backup

                # Set permissions
                sudo chown -R postgres:postgres /mnt/server/archivedir
                sudo chmod -R 700 /mnt/server/archivedir
                sudo chown -R postgres:postgres /mnt/pg_backup
                sudo chmod -R 700 /mnt/pg_backup

                # Enable WAL archiving in postgresql.conf
                archive_mode = on
                archive_command = 'cp %p /mnt/server/archivedir/%f'
                wal_level = replica
                max_wal_senders = 3
                wal_keep_size = 64

                # Reload configuration
                sudo -u postgres pg_ctl reload -D /var/lib/postgresql/14/main
                        

Backup Process:

                # Take base backup with WAL streaming
                sudo -u postgres pg_basebackup -D /mnt/pg_backup -Ft -z -P -X stream

                # Optional manual backup start/stop
                SELECT pg_start_backup('backup_label', false, false);
                -- perform backup --
                SELECT * FROM pg_stop_backup(false, true);
                        

Restore Process:

                # Restore WAL files
                restore_command = 'cp /mnt/server/archivedir/%f %p'

                # Create recovery signal file
                sudo touch /var/lib/postgresql/14/main/recovery.signal
                        

Standby Server Configuration:

                # Set permissions on standby data directory
                sudo chown -R postgres:postgres /var/lib/postgresql/14/main
                sudo chmod -R 700 /var/lib/postgresql/14/main

                # Start standby in recovery mode
                sudo -u postgres /usr/lib/postgresql/14/bin/pg_ctl -D /var/lib/postgresql/14/main -l /var/log/postgresql/postgresql-14-main.log start -m immediate
                        

Start & Stop PostgreSQL:

                # Start PostgreSQL
                sudo -u postgres /usr/lib/postgresql/14/bin/pg_ctl -D /var/lib/postgresql/14/main start

                # Stop PostgreSQL
                sudo -u postgres /usr/lib/postgresql/14/bin/pg_ctl -D /var/lib/postgresql/14/main stop

                # Restart PostgreSQL using systemctl
                sudo systemctl restart postgresql
                        

User & Role Management:

                # Log in to PostgreSQL
                sudo -u postgres psql

                # Create superuser role
                CREATE ROLE postgres WITH LOGIN SUPERUSER PASSWORD 'root';
                        

Key Concepts Covered:

• WAL Archiving for continuous transaction log backups
• Base backup using pg_basebackup
• Point-in-time recovery (PITR) setup
• Standby server replication and recovery
• Permissions, ownership, and operational security

Step 1: Verify Current Docker Root Directory

                docker info | grep 'Docker Root Dir'
                        

Step 2: Stop Docker Service

                sudo systemctl stop docker
                        

Step 3: Create New Docker Directory

                sudo mkdir -p /mnt/docker-data
                sudo chown -R root:root /mnt/docker-data
                sudo chmod -R 755 /mnt/docker-data
                        

Step 4: Move Docker Data

                sudo rsync -aP /var/lib/docker/ /mnt/docker-data/
                sudo mv /var/lib/docker /var/lib/docker.old
                        

Step 5: Update Docker Configuration

                sudo nano /etc/docker/daemon.json

                # Add or update the following:
                {
                "data-root": "/mnt/docker-data"
                }
                        

Step 6: Restart Docker & Verify

                sudo systemctl start docker
                docker info | grep 'Docker Root Dir'
                docker ps
                        

Step 7: Optional Disk Check

                df -h /mnt/docker-data
                        

Reference:

linuxconfig.org - Move Docker Root Directory

Step 1: Dump PostgreSQL Data

                # Create a dump file using custom format
                pg_dump -U postgres -h localhost -p 5432 -d mydatabase -F c -b -v -f mydatabase.dump
                        

Step 2: Restore PostgreSQL Data

                # Create target database if it doesn't exist
                psql -U postgres -h localhost -p 5432 -c "CREATE DATABASE restored_database;"

                # Restore data from dump
                pg_restore -U postgres -h localhost -p 5432 -d restored_database -v mydatabase.dump

                # Optional: Drop existing objects before restore to avoid conflicts
                pg_restore --clean -U postgres -h localhost -p 5432 -d restored_database -v mydatabase.dump
                        

Step 3: Verify in pgAdmin

• Connect to PostgreSQL server using pgAdmin.
• Locate restored database and expand tables.
• Right-click a table → View/Edit Data → All Rows to confirm restoration.

Important Notes:

• Dump options: Use -F c for custom format (recommended).
• Ensure user restoring the data has proper privileges.
• Adjust ownership if required:

                  ALTER DATABASE restored_database OWNER TO new_owner;
                                  

Environment Overview:

• From: Dolibarr 15.0.3, PostgreSQL 14.5, PHP 7.x / 8.0
• To: Dolibarr 21.0.0, PostgreSQL 17, PHP 8.2
• Stack: Ubuntu 22.04+, Docker, Apache2, pgAdmin

Step 1: Database Backup (Docker):

                docker exec -t dolibarr-psql_postgres_1 pg_dump -U root dolibarr \
                > dolibarr_backup_$(date +%Y-%m-%d).sql

                docker exec dolibarr-postgres pg_dumpall -U root \
                > dolibarr_full_backup_$(date +%Y-%m-%d).sql
                        

Step 2: PostgreSQL Upgrade (14 → 17):

                sudo apt update
                sudo apt install postgresql-17

                sudo systemctl stop postgresql@14-main
                sudo -u postgres pg_dumpall > all_pg14_backup.sql

                sudo systemctl start postgresql@17-main
                psql -U postgres -d dolibarr < all_pg14_backup.sql
                        

Step 3: PHP 8.2 Installation:

                sudo add-apt-repository ppa:ondrej/php -y
                sudo apt update
                sudo apt install php8.2 libapache2-mod-php8.2 php8.2-pgsql \
                php8.2-curl php8.2-xml php8.2-mbstring php8.2-zip \
                php8.2-gd php8.2-soap php8.2-intl php8.2-imap -y

                sudo a2enmod php8.2
                sudo systemctl restart apache2
                        

Step 4: Dolibarr Upgrade:

• Replaced Dolibarr source with version 21 (kept documents & conf.php).
• Executed web-based upgrade via /install/ in upgrade mode.

Common PostgreSQL Fixes Applied:

                DROP VIEW IF EXISTS llx_view_invoicefields;
                DROP VIEW IF EXISTS llx_view_payments;

                UPDATE llx_category_bankline AS bl
                SET fk_categ = c.rowid
                FROM llx_category_bank AS b
                JOIN llx_categorie AS c
                ON b.label = c.label
                WHERE bl.fk_categ = b.rowid;
                        

Step 5: Permissions & Finalization:

                sudo chown -R www-data:www-data /var/www/html/dolibarr
                chmod -R 755 /var/www/html/dolibarr/documents
                touch /var/www/html/dolibarr/documents/install.lock