django-hotels 0.1.0__tar.gz

django_hotels-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 The Python Packaging Authority
+
+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.

django_hotels-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include django_hotels/static *

django_hotels-0.1.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: django-hotels
+Version: 0.1.0
+Summary: A Django Rest API for managing hotels, room types, availability, and bookings.
+Home-page: https://github.com/DestinationPak/django-hotels
+Author: Awais Jibran
+Author-email: awaisdar001@gmail.com
+License: MIT
+Keywords: Django hotels
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS
+Requires-Dist: mysqlclient>=2.2.1
+Requires-Dist: setuptools>=80.9.0
+Requires-Dist: django-filter>=23.2
+Requires-Dist: Django<6.0,>=5.2
+Requires-Dist: djangorestframework<3.17,>=3.16
+Provides-Extra: dev
+Requires-Dist: pytest==9.1.1; extra == "dev"
+Requires-Dist: docutils==0.23; extra == "dev"
+Requires-Dist: pylint-plugin-utils==0.9.0; extra == "dev"
+Requires-Dist: Faker==40.31.0; extra == "dev"
+Requires-Dist: pre-commit==4.0.1; extra == "dev"
+Requires-Dist: pytest-django==4.12.0; extra == "dev"
+Requires-Dist: pylint==4.0.6; extra == "dev"
+Requires-Dist: isort==8.0.1; extra == "dev"
+Requires-Dist: factory-boy==3.3.3; extra == "dev"
+Requires-Dist: pytest-cov==7.1.0; extra == "dev"
+Requires-Dist: twine==6.2.0; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: pylint-django==2.8.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Django Hotels API
+
+This is a Django REST API for managing and retrieving hotels, room types, availability, and
+bookings.
+
+This service is a sibling of [django-trips](https://github.com/awaisdar001/django-trips), and
+is a core component of the [DestinationPak](https://destinationpak.com) project — a platform
+designed to make exploring and booking adventures across Pakistan easier and more accessible.
+
+## Installation
+Simply do:
+```bash
+pip install django-hotels
+```
+
+## Usage
+Add the app into your installed apps in your project's settings file.
+```
+INSTALLED_APPS = [
+    ...
+    'django_hotels',
+]
+```
+## Migrate
+```
+python manage.py migrate
+```
+Add the following to your root `urls.py` or to your desired file location.
+```
+urlpatterns = [
+    ...
+    path('hotels/', include('django_hotels.urls')),
+]
+```
+This mounts the whole app under your own chosen namespace (`hotels/` above - replace with
+whatever prefix you like) with the lib's own `v1/` version underneath it, e.g.
+`hotels/v1/hotels/`. The app versions itself independently of your project's own API version.
+
+## Domain model
+
+```
+HotelOwner (the business/brand)
+  └── Hotel (one bookable property)
+        ├── HotelImage
+        └── HotelRoomType (a room category/tier)
+              └── HotelAvailability (a dated, priced, bookable instance)
+                    └── HotelBooking (a guest or logged-in traveller's booking)
+```
+
+`HotelOwner`/`Hotel` deliberately carry no login/auth/permission fields — this package is
+tenancy-oblivious, the same way `django-trips` is. A consuming project owns the membership
+layer (who may manage which `HotelOwner`), not this library.
+
+## Local development
+
+All commands assume Docker (`make dev.up`, `make update_db`, `make test`) — see the Makefile
+for the full command list (`make help`).
+
+## Generate demo data
+
+```
+./manage.py generate_hotels --batch_size=10
+```

django_hotels-0.1.0/README.md

@@ -0,0 +1,63 @@
+# Django Hotels API
+
+This is a Django REST API for managing and retrieving hotels, room types, availability, and
+bookings.
+
+This service is a sibling of [django-trips](https://github.com/awaisdar001/django-trips), and
+is a core component of the [DestinationPak](https://destinationpak.com) project — a platform
+designed to make exploring and booking adventures across Pakistan easier and more accessible.
+
+## Installation
+Simply do:
+```bash
+pip install django-hotels
+```
+
+## Usage
+Add the app into your installed apps in your project's settings file.
+```
+INSTALLED_APPS = [
+    ...
+    'django_hotels',
+]
+```
+## Migrate
+```
+python manage.py migrate
+```
+Add the following to your root `urls.py` or to your desired file location.
+```
+urlpatterns = [
+    ...
+    path('hotels/', include('django_hotels.urls')),
+]
+```
+This mounts the whole app under your own chosen namespace (`hotels/` above - replace with
+whatever prefix you like) with the lib's own `v1/` version underneath it, e.g.
+`hotels/v1/hotels/`. The app versions itself independently of your project's own API version.
+
+## Domain model
+
+```
+HotelOwner (the business/brand)
+  └── Hotel (one bookable property)
+        ├── HotelImage
+        └── HotelRoomType (a room category/tier)
+              └── HotelAvailability (a dated, priced, bookable instance)
+                    └── HotelBooking (a guest or logged-in traveller's booking)
+```
+
+`HotelOwner`/`Hotel` deliberately carry no login/auth/permission fields — this package is
+tenancy-oblivious, the same way `django-trips` is. A consuming project owns the membership
+layer (who may manage which `HotelOwner`), not this library.
+
+## Local development
+
+All commands assume Docker (`make dev.up`, `make update_db`, `make test`) — see the Makefile
+for the full command list (`make help`).
+
+## Generate demo data
+
+```
+./manage.py generate_hotels --batch_size=10
+```

django_hotels-0.1.0/django-hotels/asgi.py

@@ -0,0 +1,11 @@
+"""
+ASGI config for hotels project.
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'settings.common')
+
+application = get_asgi_application()

django_hotels-0.1.0/django-hotels/urls.py

@@ -0,0 +1,9 @@
+"""hotels URL Configuration"""
+from django.conf.urls import include
+from django.contrib import admin
+from django.urls import path
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+    path('', include('django_hotels.urls')),
+]

django_hotels-0.1.0/django-hotels/wsgi.py

@@ -0,0 +1,13 @@
+# pylint:disable=all
+
+"""
+WSGI config for hotels project.
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings.common")
+
+application = get_wsgi_application()

django_hotels-0.1.0/django_hotels/__init__.py

@@ -0,0 +1,3 @@
+# pylint: disable=invalid-name
+
+__version__ = "0.1.0"

django_hotels-0.1.0/django_hotels/admin.py

@@ -0,0 +1,46 @@
+from django.contrib import admin
+
+from django_hotels.models import (
+    Hotel,
+    HotelAvailability,
+    HotelBooking,
+    HotelImage,
+    HotelOwner,
+    HotelRoomType,
+)
+
+
+@admin.register(HotelOwner)
+class HotelOwnerAdmin(admin.ModelAdmin):
+    list_display = ("name", "email", "verified", "is_active")
+    search_fields = ("name", "email")
+
+
+@admin.register(Hotel)
+class HotelAdmin(admin.ModelAdmin):
+    list_display = ("name", "owner", "city", "status", "is_active")
+    list_filter = ("status", "is_active", "city")
+    search_fields = ("name", "city")
+
+
+@admin.register(HotelRoomType)
+class HotelRoomTypeAdmin(admin.ModelAdmin):
+    list_display = ("hotel", "name", "base_price", "max_occupancy", "is_active")
+
+
+@admin.register(HotelAvailability)
+class HotelAvailabilityAdmin(admin.ModelAdmin):
+    list_display = ("room_type", "date", "effective_price", "rooms_available")
+    list_filter = ("date",)
+
+
+@admin.register(HotelImage)
+class HotelImageAdmin(admin.ModelAdmin):
+    list_display = ("hotel", "order")
+
+
+@admin.register(HotelBooking)
+class HotelBookingAdmin(admin.ModelAdmin):
+    list_display = ("number", "full_name", "email", "status", "created_at")
+    list_filter = ("status",)
+    search_fields = ("number", "full_name", "email")

django_hotels-0.1.0/django_hotels/api/serializers.py

@@ -0,0 +1,107 @@
+from rest_framework import serializers
+
+from django_hotels.models import (
+    Hotel,
+    HotelAvailability,
+    HotelBooking,
+    HotelImage,
+    HotelOwner,
+    HotelRoomType,
+)
+
+
+class HotelOwnerSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = HotelOwner
+        fields = (
+            "id",
+            "name",
+            "slug",
+            "description",
+            "email",
+            "mobile",
+            "verified",
+        )
+
+
+class HotelImageSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = HotelImage
+        fields = ("id", "image", "caption", "order")
+
+
+class HotelRoomTypeSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = HotelRoomType
+        fields = ("id", "name", "base_price", "max_occupancy")
+
+
+class HotelListSerializer(serializers.ModelSerializer):
+    owner = HotelOwnerSerializer(read_only=True)
+
+    class Meta:
+        model = Hotel
+        fields = ("id", "name", "slug", "owner", "city", "status")
+
+
+class HotelDetailSerializer(serializers.ModelSerializer):
+    owner = HotelOwnerSerializer(read_only=True)
+    images = HotelImageSerializer(many=True, read_only=True)
+    room_types = HotelRoomTypeSerializer(many=True, read_only=True)
+
+    class Meta:
+        model = Hotel
+        fields = (
+            "id",
+            "name",
+            "slug",
+            "owner",
+            "city",
+            "description",
+            "status",
+            "images",
+            "room_types",
+        )
+
+
+class HotelAvailabilitySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = HotelAvailability
+        fields = ("id", "room_type", "date", "effective_price", "rooms_available")
+
+
+class HotelBookingCreateSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = HotelBooking
+        fields = (
+            "id",
+            "number",
+            "availability",
+            "full_name",
+            "email",
+            "phone_number",
+            "guests",
+            "message",
+            "total_price",
+        )
+        read_only_fields = ("id", "number", "total_price")
+
+    def create(self, validated_data):
+        availability = validated_data["availability"]
+        guests = validated_data.get("guests", 1)
+        validated_data["total_price"] = availability.effective_price * guests
+        return super().create(validated_data)
+
+
+class HotelBookingLookupSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = HotelBooking
+        fields = (
+            "number",
+            "full_name",
+            "email",
+            "guests",
+            "status",
+            "total_price",
+            "created_at",
+        )

django_hotels-0.1.0/django_hotels/api/urls.py

@@ -0,0 +1,30 @@
+from django.urls import path
+from rest_framework.routers import DefaultRouter
+
+from django_hotels.api.views import booking, hotel
+
+app_name = "hotels-api"
+
+router = DefaultRouter()
+router.register(r"hotels", hotel.HotelViewSet, basename="hotel")
+
+app_urlpatterns = [
+    path(
+        "owners/",
+        hotel.ActiveHotelOwnersListAPIView.as_view(),
+        name="owners",
+    ),
+    path(
+        "bookings/create/",
+        booking.HotelBookingCreateView.as_view(),
+        name="bookings-create",
+    ),
+    path(
+        "bookings/lookup/",
+        booking.HotelBookingLookupView.as_view(),
+        name="bookings-lookup",
+    ),
+    *router.urls,
+]
+
+urlpatterns = app_urlpatterns

django_hotels-0.1.0/django_hotels/api/views/booking.py

@@ -0,0 +1,31 @@
+from rest_framework import generics
+from rest_framework.exceptions import NotFound
+from rest_framework.permissions import AllowAny
+
+from django_hotels.api.serializers import (
+    HotelBookingCreateSerializer,
+    HotelBookingLookupSerializer,
+)
+from django_hotels.models import HotelBooking
+
+
+class HotelBookingCreateView(generics.CreateAPIView):
+    """Guest booking - no auth required, mirrors django-trips' TripBookingCreateView."""
+
+    permission_classes = [AllowAny]
+    serializer_class = HotelBookingCreateSerializer
+
+
+class HotelBookingLookupView(generics.RetrieveAPIView):
+    """Anonymous booking lookup by `number` + `email` - never by number alone."""
+
+    permission_classes = [AllowAny]
+    serializer_class = HotelBookingLookupSerializer
+
+    def get_object(self):
+        number = self.request.query_params.get("number")
+        email = self.request.query_params.get("email")
+        booking = HotelBooking.objects.filter(number=number, email=email).first()
+        if not booking:
+            raise NotFound("No booking found for that reference number and email.")
+        return booking

django_hotels-0.1.0/django_hotels/api/views/hotel.py

@@ -0,0 +1,37 @@
+from rest_framework import generics
+from rest_framework.permissions import AllowAny
+from rest_framework.viewsets import ReadOnlyModelViewSet
+
+from django_hotels.api.serializers import (
+    HotelDetailSerializer,
+    HotelListSerializer,
+    HotelOwnerSerializer,
+)
+from django_hotels.models import Hotel, HotelOwner
+
+
+class HotelViewSet(ReadOnlyModelViewSet):
+    """Public, read-only catalog of published hotels - no create/update/destroy.
+
+    Management (create/update/archive) is a consuming project's operator-surface
+    job, the same architectural split django-trips uses for TripViewSet.
+    """
+
+    permission_classes = [AllowAny]
+    lookup_field = "slug"
+
+    def get_queryset(self):
+        return Hotel.objects.active().select_related("owner")
+
+    def get_serializer_class(self):
+        if self.action == "retrieve":
+            return HotelDetailSerializer
+        return HotelListSerializer
+
+
+class ActiveHotelOwnersListAPIView(generics.ListAPIView):
+    permission_classes = [AllowAny]
+    serializer_class = HotelOwnerSerializer
+
+    def get_queryset(self):
+        return HotelOwner.objects.active()

django_hotels-0.1.0/django_hotels/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class DjangoHotelsConfig(AppConfig):
+    name = "django_hotels"
+    verbose_name = "Django Hotels"
+    # Pinned per-app so this package's models always get BigAutoField
+    # regardless of the consuming project's own DEFAULT_AUTO_FIELD.
+    default_auto_field = "django.db.models.BigAutoField"

django_hotels-0.1.0/django_hotels/choices.py

@@ -0,0 +1,30 @@
+from django.db import models
+
+
+class HotelStatus(models.TextChoices):
+    """
+    Editorial state of a Hotel, independent of `is_active` (which is
+    soft-delete/visibility, not workflow).
+    """
+
+    DRAFT = "DRAFT", "Draft"
+    PUBLISHED = "PUBLISHED", "Published"
+
+
+class HotelBookingStatus(models.TextChoices):
+    """Lifecycle states of a booking - mirrors django_trips.choices.BookingStatus."""
+
+    PENDING = "PENDING", "Pending"
+    WAITING_PAYMENT = "WAITING_PAYMENT", "Awaiting Payment"
+    CONFIRMED = "CONFIRMED", "Confirmed"
+    PARTIAL_PAYMENT = "PARTIAL_PAYMENT", "Partial Payment"
+    COMPLETED = "COMPLETED", "Completed"
+    CANCELLED = "CANCELLED", "Cancelled"
+
+    @classmethod
+    def is_cancelled(cls, status):
+        return status == cls.CANCELLED
+
+    @classmethod
+    def can_be_cancelled(cls, status):
+        return status in (cls.PENDING, cls.WAITING_PAYMENT)

django_hotels-0.1.0/django_hotels/management/commands/generate_hotels.py

@@ -0,0 +1,69 @@
+import random
+from datetime import timedelta
+
+from django.contrib.auth import get_user_model
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+from django.utils.text import slugify
+from faker import Faker
+
+from django_hotels.models import Hotel, HotelAvailability, HotelOwner, HotelRoomType
+
+fake = Faker()
+User = get_user_model()
+
+CITIES = ("Hunza", "Skardu", "Naran", "Murree", "Fairy Meadows")
+ROOM_TYPES = (("Standard Double", 8000, 2), ("Deluxe Suite", 15000, 4))
+
+
+class Command(BaseCommand):
+    """
+    Generate a batch of hotels with random demo data.
+
+    EXAMPLE USAGE:
+        ./manage.py generate_hotels --batch_size=10
+    """
+
+    help = "Generate batches of hotels with pre-populated random data"
+
+    def add_arguments(self, parser):
+        parser.add_argument("--batch_size", type=int, default=10, dest="batch_size")
+
+    def handle(self, *args, **options):
+        batch_size = options["batch_size"]
+        user, _ = User.objects.get_or_create(
+            username="hotels-seed-bot", defaults={"email": "seed@example.com"}
+        )
+
+        for _ in range(batch_size):
+            owner_name = fake.company()
+            owner = HotelOwner.objects.create(
+                name=owner_name,
+                slug=f"{slugify(owner_name)}-{random.randint(1000, 9999)}",
+                email=fake.company_email(),
+                verified=True,
+            )
+            hotel_name = f"{fake.city()} {random.choice(['Inn', 'Resort', 'Lodge'])}"
+            hotel = Hotel.objects.create(
+                name=hotel_name,
+                slug=f"{slugify(hotel_name)}-{random.randint(1000, 9999)}",
+                owner=owner,
+                city=random.choice(CITIES),
+                description=fake.paragraph(),
+                created_by=user,
+            )
+            for room_name, price, occupancy in ROOM_TYPES:
+                room_type = HotelRoomType.objects.create(
+                    hotel=hotel,
+                    name=room_name,
+                    base_price=price,
+                    max_occupancy=occupancy,
+                )
+                for day in range(7):
+                    HotelAvailability.objects.create(
+                        room_type=room_type,
+                        date=timezone.now().date() + timedelta(days=day),
+                        rooms_available=random.randint(1, 5),
+                    )
+
+        self.stdout.write(self.style.SUCCESS(f"Generated {batch_size} hotels"))

django_hotels-0.1.0/django_hotels/managers.py

@@ -0,0 +1,16 @@
+from django.db import models
+
+
+class ActiveQuerySet(models.QuerySet):
+    def active(self):
+        return self.filter(is_active=True)
+
+
+class HotelOwnerQuerySet(ActiveQuerySet):
+    def active(self):
+        return super().active().filter(verified=True)
+
+
+class HotelQuerySet(ActiveQuerySet):
+    def active(self):
+        return super().active().filter(owner__verified=True)