Docs v2.0 • શિખાઉ માણસો માટે ખાસ

AIPostify – નવા શીખનાર માટે સંપૂર્ણ ગાઇડ

પ્રોગ્રામિંગ ન આવડતું હોય તો પણ Python માં વેબ એપ બનાવો

🎯 આ ડોક્યુમેન્ટ કોના માટે છે? જેને પ્રોગ્રામિંગનો અનુભવ નથી અથવા ઓછો છે. દરેક ફીચર "શું છે → ક્યારે વાપરવું → કેવી રીતે → ઉદાહરણ → સામાન્ય ભૂલ" એ ક્રમમાં સમજાવ્યું છે.

💡 ખાસ નોંધ: આ ગાઇડના બધા ઉદાહરણ મેં ખરેખર ચલાવીને ચકાસ્યા છે. જે ફીચર હાલ બરાબર કામ નથી કરતાં તેને ⚠️ ચિહ્નથી અલગ બતાવ્યા છે (વિભાગ 12), જેથી તમે અટકો નહીં.

0

શબ્દોનો સરળ અર્થ (Glossary)

ઉપર જાઓ

વેબ ડેવલપમેન્ટમાં વપરાતા મહત્વના શબ્દો અને તેનો સરળ રોજિંદી ભાષામાં અર્થ:

શબ્દ સરળ અર્થ
Framework તૈયાર પાયો. ઘર બનાવતી વખતે પાયો, દીવાલ તૈયાર મળે અને તમે ફક્ત રૂમ સજાવો, એવું.
Python પ્રોગ્રામિંગ ભાષા જેમાં આપણે કોડ લખીએ છીએ.
Terminal / Command Prompt કાળી સ્ક્રીન જેમાં લખીને કમ્પ્યુટરને આદેશ આપાય છે.
Artisan AIPostify નો "કારીગર". python artisan ... લખો તો ફાઇલો જાતે બનાવી આપે.
Route (રાઉટ) વેબ એડ્રેસનો નકશો. દા.ત. /posts ખોલો તો કયું પેજ બતાવવું.
Controller (કંટ્રોલર) "મેનેજર". યુઝરની માંગ સમજી ડેટા લાવે અને પેજ બતાવે.
Model (મોડેલ) ડેટાનું ટેબલ. દા.ત. Post = બધી પોસ્ટની યાદી.
View (વ્યૂ) યુઝર જે પેજ જુએ છે (HTML). AIPostify માં તેની ફાઇલ .ptl હોય છે.
PTL Postify Template Language. HTML માં @if, @foreach, {{ નામ }} લખવાની સરળ રીત.
Migration (માઇગ્રેશન) ડેટાબેઝમાં ટેબલ બનાવવા/બદલવાની સૂચના.
Seeder (સીડર) ડેટાબેઝમાં ડેમો/શરૂઆતનો ડેટા ભરનાર.
Validation ફોર્મ ભરનારે સાચું ભર્યું છે કે નહીં તેની ચકાસણી.
CSRF ફોર્મ સુરક્ષિત રાખવા માટેની ગુપ્ત નિશાની. દરેક ફોર્મમાં @csrf લખવું ફરજિયાત.
Middleware દરવાજે ઊભો ચોકીદાર. દા.ત. લોગિન વગર અંદર ન જવા દે.
Queue / Job લાંબું કામ (ઇમેઇલ મોકલવો) પાછળ ચુપચાપ કરાવવાની લાઇન.
Scheduler ઘડિયાળ મુજબ આપમેળે કામ ચલાવનાર (દા.ત. રોજ સવારે 9 વાગ્યે).
.env ફાઇલ 🔒 ગુપ્ત સેટિંગ્સ (પાસવર્ડ, ડેટાબેઝ નામ) રાખવાની ફાઇલ. કોઈને શેર ન કરવી.
Session વેબસાઇટ યુઝરને યાદ રાખે તે જગ્યા (લોગિન, સંદેશ).
Flash message એકવાર બતાવીને અદૃશ્ય થતો સંદેશ ("સેવ થઈ ગયું!").
1

AIPostify શું છે? (રેસ્ટોરન્ટનું ઉદાહરણ)

ઉપર જાઓ

AIPostify એટલે Python (Django ના એન્જિન પર) બનેલું તૈયાર ફ્રેમવર્ક, જેમાં PHP ના Laravel જેવી સરળતા મળે છે. તમારે જટિલ સેટિંગ્સ (settings.py, urls.py) કરવી પડતી નથી; ફક્ત કમાન્ડ ચલાવો, થોડું લખો અને વેબસાઇટ તૈયાર.

🍽️ રેસ્ટોરન્ટનું ઉદાહરણ (MVC સમજો)

જ્યારે તમે બ્રાઉઝરમાં http://127.0.0.1:8000/posts ખોલો ત્યારે:

MVC ફ્લો ડાયાગ્રામ
ગ્રાહક (તમે/બ્રાઉઝર)
      │  "મને પોસ્ટની યાદી જોઈએ"
      ▼
 ┌─────────────┐
 │  ROUTE      │  રિસેપ્શન: "આ ઓર્ડર PostController ને આપો"
 └─────┬───────┘
       ▼
 ┌─────────────┐
 │ CONTROLLER  │  વેઇટર/મેનેજર: રસોડામાંથી સામગ્રી લાવે
 └─────┬───────┘
       ▼
 ┌─────────────┐
 │   MODEL     │  રસોડું/ભંડાર: ડેટાબેઝમાંથી પોસ્ટ કાઢી આપે
 └─────┬───────┘
       ▼
 ┌─────────────┐
 │    VIEW     │  પ્લેટ: સજાવીને પેજ તૈયાર (.ptl ફાઇલ)
 └─────┬───────┘
       ▼
  ગ્રાહકને પેજ મળે ✅
યાદ રાખો: Route → Controller → Model → View. આખી વેબ એપ આ 4 ટુકડાની બને છે.

AIPostify માં શું શું મળે છે:

  1. artisan કમાન્ડ (ફાઇલો જાતે બનાવે)
  2. Routes (રસ્તા), Controllers, Models, Views (PTL)
  3. ડેટાબેઝ (SQLite અથવા MySQL) + Migration + Seeder
  4. ફોર્મ Validation, CSRF સુરક્ષા
  5. Queue (પાછળનાં કામ) અને Scheduler (સમયસર કામ)
  6. Tinker (ડેટા સાથે રમવા માટે શેલ), Test, Components, Layouts
2

શરૂ કરતા પહેલાં શું જોઈએ

ઉપર જાઓ
વસ્તુ કેવી રીતે મેળવવું
Python 3.10 કે નવું python.org પરથી ડાઉનલોડ કરો. ઇન્સ્ટોલ વખતે ✅ "Add Python to PATH" ચોક્કસ ટિક કરો.
ટેક્સ્ટ એડિટર VS Code (મફત). PTL ફાઇલોમાં IntelliSense, ઓટોકમ્પ્લીટ અને રંગીન હાઇલાઇટિંગ માટે python artisan ptl:install-vscode ચલાવી શકાય.
ઇન્ટરનેટ પહેલી વાર પેકેજ ઇન્સ્ટોલ કરવા માટે.

Terminal કેવી રીતે ખોલવું

  • Windows: પ્રોજેક્ટ ફોલ્ડર ખોલો → ઉપરના એડ્રેસ બારમાં cmd લખી Enter દબાવો.
  • Mac: ફોલ્ડર પર Right-click → "New Terminal at Folder".
  • VS Code: ઉપર મેનુ Terminal → New Terminal (પ્રોજેક્ટ ફોલ્ડરમાં જ ખુલે છે).

Python ચાલે છે કે નહીં તે ચકાસો

Terminal
python --version

Python 3.x.x દેખાય તો બરાબર. ન દેખાય તો py --version અથવા python3 --version અજમાવો. (પછીના બધા કમાન્ડમાં python ની જગ્યાએ તે જ વાપરો.)

3

ઇન્સ્ટોલ અને પહેલી વાર ચલાવવું

ઉપર જાઓ

પ્રોજેક્ટ ફોલ્ડર (જ્યાં artisan ફાઇલ છે) માં Terminal ખોલીને ક્રમશઃ ચલાવો:

સ્ટેપ 1: જરૂરી પેકેજ ઇન્સ્ટોલ

Terminal
pip install -r requirements.txt

અર્થ: Django, rich, pytest વગેરે જરૂરી સાધનો ડાઉનલોડ કરે છે.

સ્ટેપ 2: .env ફાઇલ બનાવો

Terminal
cp .env.example .env

(Windows માં: copy .env.example .env)

સ્ટેપ 3: ⚠️ .env ફાઇલ ખોલીને એક ભૂલ સુધારો (ખૂબ જરૂરી)

.env માં DB_DATABASE= બે વાર લખેલું હોય તો બીજી લાઇન (DB_DATABASE=aipostify) પહેલીને દબાવી દે છે અને ડેટાબેઝ ફાઇલ ખોટી જગ્યાએ બને છે.

SQLite વાપરતા હો તો ફક્ત આ લાઇન રાખો અને MySQL વાળી DB_DATABASE=aipostify લાઇન કાઢી નાખો (અથવા આગળ # લગાવો):

.env
DB_CONNECTION=sqlite
DB_DATABASE=database/database.sqlite

# MySQL વાપરવું હોય ત્યારે જ આ લાઇન ખોલો:
# DB_DATABASE=aipostify

સ્ટેપ 4: સુરક્ષા કી બનાવો

Terminal
python artisan key:generate

.env માં APP_KEY= નવી ગુપ્ત કી સાથે ભરાઈ જશે. (ફરી ચલાવશો તો જૂની કી બદલાઈ જશે અને બધા લોગિન સેશન રદ થશે, તેથી એક જ વાર.)

સ્ટેપ 5: ડેટાબેઝ ટેબલ બનાવો

Terminal
python artisan migrate

અંતે SUCCESS Database migrations applied successfully. દેખાવું જોઈએ.

સ્ટેપ 6: ડેમો ડેટા (વૈકલ્પિક)

Terminal
python artisan db:seed
આ Django નાં બે ડેમો યુઝર બનાવે છે (admin, demo). ⚠️ આ સરળ પાસવર્ડવાળા છે, ફક્ત શીખવા માટે; વેબસાઇટ ઓનલાઇન મૂકતાં પહેલાં કાઢી નાખો.

સ્ટેપ 7: સર્વર ચાલુ કરો

Terminal
python artisan serve

બ્રાઉઝરમાં ખોલો: http://127.0.0.1:8000 → AIPostify નું Welcome પેજ દેખાશે 🎉

સર્વર બંધ કરવા: Terminal માં Ctrl + C.

નોંધ: સર્વર ચાલુ હોય ત્યારે નવું Terminal ખોલીને બીજા artisan કમાન્ડ ચલાવો. ફાઇલમાં ફેરફાર સેવ કરશો તો સર્વર જાતે રીલોડ થશે.

✅ ચકાસો: બધું બરાબર છે?

Terminal
python artisan db:check
python artisan route:list

route:list તમારા બધા વેબ-એડ્રેસનું ટેબલ બતાવે છે.

4

ફોલ્ડર નકશો – કઈ ફાઇલ ક્યાં મૂકવી

ઉપર જાઓ
પ્રોજેક્ટ ફોલ્ડર માળખું
તમારો-પ્રોજેક્ટ/
├── artisan                  ← કમાન્ડ ચલાવવા માટે (ખોલવી નહીં)
├── .env                     ← 🔒 ગુપ્ત સેટિંગ્સ (શેર ન કરવી)
├── requirements.txt         ← જરૂરી પેકેજની યાદી
│
├── routes/                  ← 🗺️ વેબ એડ્રેસનો નકશો
│   ├── web.py               ← સામાન્ય પેજના એડ્રેસ  ✏️ તમે બદલશો
│   ├── api.py               ← API એડ્રેસ (આપમેળે /api થી શરૂ)
│   └── console.py           ← સમયસર ચાલતાં કામ (Scheduler)
│
├── app/                     ← 🧠 તમારો પોતાનો કોડ  ✏️ મુખ્ય કામ અહીં
│   ├── http/controllers/    ← Controllers (મેનેજર)
│   ├── http/requests/       ← ફોર્મ Validation ક્લાસ
│   ├── http/middleware/     ← ચોકીદાર (પ્રથમ make પછી બને)
│   ├── models/              ← Models (ડેટાનાં ટેબલ)
│   ├── services/            ← મોટું લોજિક (સર્વિસ)
│   ├── jobs/                ← Queue જોબ
│   └── console/commands/    ← તમારા પોતાના artisan કમાન્ડ
│
├── resources/
│   ├── views/               ← 🎨 પેજની ડિઝાઇન (.ptl ફાઇલો)  ✏️ તમે બદલશો
│   │   ├── layouts/app.ptl  ← બધા પેજનું સામાન્ય ઢાંચું (મેનુ, ફૂટર)
│   │   ├── components/      ← ફરી ફરી વાપરવાના ટુકડા (alert.ptl)
│   │   └── welcome.ptl      ← પહેલું પેજ
│   └── lang/                ← ભાષા ફાઇલો (en, gu, hi)
│
├── database/
│   ├── migrations/          ← ટેબલ બનાવવાની સૂચનાઓ (જાતે બને)
│   ├── seeders/             ← ડેમો ડેટા
│   └── database.sqlite      ← SQLite ડેટાબેઝ ફાઇલ
│
├── config/                  ← app.py, database.py, mail.py, queue.py
├── public/                  ← CSS, JS, ફોટા (સીધા બ્રાઉઝરને મળે)
├── storage/                 ← લોગ, સેશન, કેશ (જાતે ભરાય, અડવું નહીં)
├── tests/                   ← ટેસ્ટ
└── framework/               ← ⛔ એન્જિન. આને બદલવું નહીં
સરળ નિયમ: routes/, app/, resources/views/, database/ માં કામ કરો. બાકીનું છોડી દો.
5

⭐ પહેલી પૂર્ણ વેબ એપ બનાવો: "પોસ્ટ બોર્ડ"

ઉપર જાઓ

આપણે શું બનાવીશું: એવી વેબસાઇટ જેમાં યુઝર ✅ પોસ્ટ ઉમેરી શકે, ✅ યાદી જોઈ શકે, ✅ એક પોસ્ટ ખોલી શકે, ✅ પોસ્ટ ડિલીટ કરી શકે, અને ❌ ખાલી/ખૂબ ટૂંકું લખે તો ભૂલનો સંદેશ મળે.

આ આખું ઉદાહરણ મેં સ્વચ્છ કોપીમાં ચલાવી ચકાસ્યું છે (લિસ્ટ, ઉમેરવું, ભૂલ-સંદેશ, ડિલીટ બધું કામ કરે છે).
પૂર્વશરત: વિભાગ 3 પૂરો કરેલો હોવો જોઈએ અને વિભાગ 12 નો પેચ A (flash/error સંદેશ માટે) લગાવેલો હોવો જોઈએ.
1

સ્ટેપ 1: Model બનાવો – ડેટાનું ટેબલ

ફાઇલ બનાવો: app/models/post.py (python artisan make:model Post થી ફાઇલ બને છે, પછી તેની અંદર નીચે મુજબ બદલો):

app/models/post.py
from framework.database import Model, fields

class Post(Model):
    title = fields.String(200)                      # શીર્ષક (200 અક્ષર સુધી)
    body = fields.Text(blank=True, null=True)       # લખાણ (વૈકલ્પિક)
    created_at = fields.DateTime(auto_now_add=True) # બન્યાનો સમય (જાતે ભરાય)

    def __str__(self):
        return self.title
2

સ્ટેપ 2: ટેબલ ડેટાબેઝમાં બનાવો

Terminal
python artisan migrate

આ કમાન્ડ નવું મોડેલ જોઈને Migration ફાઇલ (database/migrations/0002_post.py) જાતે બનાવી ડેટાબેઝમાં ટેબલ બનાવી દે છે. ❗ Migration ફાઇલો ક્યારેય જાતે ડિલીટ ન કરશો.

3

સ્ટેપ 3: Controller બનાવો – મેનેજર

python artisan make:controller PostController પછી app/http/controllers/post_controller.py ની અંદર આ લખો:

app/http/controllers/post_controller.py
from framework.http import Controller, ValidationError
from app.models.post import Post


class PostController(Controller):

    # બધી પોસ્ટની યાદી બતાવો
    def index(self, request):
        return self.render(request, "posts.index", {"posts": Post.all()})

    # નવી પોસ્ટનું ફોર્મ બતાવો
    def create(self, request):
        return self.render(request, "posts.create")

    # ફોર્મ સબમિટ થાય ત્યારે સેવ કરો
    def store(self, request):
        try:
            data = self.validate(request, {
                "title": "required|min:3|max:200",
                "body": "max:2000",
            })
        except ValidationError:
            # ભૂલ હોય તો ફોર્મ પર પાછા મોકલો (ભૂલ અને જૂનું લખાણ સાથે)
            return self.back(request, "/posts/create")

        Post.create(**data)
        request.session["flash"] = {"message": "પોસ્ટ સેવ થઈ ગઈ!", "level": "success"}
        return self.redirect("posts.index")

    # એક પોસ્ટ વિગતવાર
    def show(self, request, id):
        return self.render(request, "posts.show", {"post": Post.find_or_fail(id)})

    # ડિલીટ
    def destroy(self, request, id):
        Post.find_or_fail(id).delete()
        return self.redirect("posts.index")

સમજૂતી:

  • self.render(request, "posts.index", {...}) → resources/views/posts/index.ptl પેજ બતાવે, અને {"posts": ...} પેજને ડેટા આપે.
  • self.validate(...) → નિયમો ચકાસે. ખોટું હોય તો ValidationError આવે છે, જેને try/except થી પકડીને ફોર્મ પર પાછા મોકલીએ છીએ. આ try/except ન લખો તો ભૂલ-પેજ (500) આવશે.
  • request.session["flash"] = ... → એકવાર દેખાતો સંદેશ.
4

સ્ટેપ 4: Routes લખો – રસ્તા

ફાઇલ: routes/web.py:

routes/web.py
from framework.routing import Route

Route.get("/", "WelcomeController@index").name("welcome")

# એક લાઇનથી 7 રસ્તા બને (index, create, store, show, edit, update, destroy)
Route.resource("posts", "PostController")

python artisan route:list ચલાવીને જુઓ કે /posts, /posts/create વગેરે બન્યા કે નહીં.

5

સ્ટેપ 5: Views બનાવો – પેજની ડિઝાઇન

ફોલ્ડર resources/views/posts/ બનાવો અને તેમાં 3 ફાઇલો:

1) index.ptl – યાદી:

resources/views/posts/index.ptl
@extends('layouts.app')
@section('title', 'બધી પોસ્ટ')

@section('content')

બધી પોસ્ટ

@session('flash') <div class="alert alert-success">{{ message }}</div> @endsession <a href="{{ route('posts.create') }}" class="btn btn-primary mb-3">+ નવી પોસ્ટ</a> @forelse(post in posts) <div class="card p-3 mb-2"> <h5>{{ loop.index }}. <a href="{{ route('posts.show', id=post.id) }}">{{ post.title }}</a></h5> <small class="text-muted">{{ post.created_at | date('d M Y') }}</small> </div> @empty <p>હજી કોઈ પોસ્ટ નથી.</p> @endforelse @endsection

2) create.ptl – નવું ફોર્મ:

resources/views/posts/create.ptl
@extends('layouts.app')
@section('title', 'નવી પોસ્ટ')

@section('content')

નવી પોસ્ટ

<form method="POST" action="{{ route('posts.store') }}"> @csrf <div class="mb-3"> <label>શીર્ષક</label> <input name="title" class="form-control" value="{{ old('title') }}"> @error('title') <div class="text-danger">{{ message }}</div> @enderror </div> <div class="mb-3"> <label>લખાણ</label> <textarea name="body" class="form-control">{{ old('body') }}</textarea> </div> <button class="btn btn-success">સેવ કરો</button> </form> @endsection

3) show.ptl – વિગત અને ડિલીટ:

resources/views/posts/show.ptl
@extends('layouts.app')
@section('title', post.title)

@section('content')

{{ post.title }}

<p>{{ post.body | nl2br }}</p> <form method="POST" action="{{ route('posts.destroy', id=post.id) }}"> @csrf @method('DELETE') <button class="btn btn-danger">ડિલીટ</button> </form> @endsection
6

સ્ટેપ 6: ચલાવો

Terminal
python artisan serve

ખોલો http://127.0.0.1:8000/posts → "નવી પોસ્ટ" દબાવો → 2 અક્ષર લખીને સેવ કરો (ભૂલનો સંદેશ આવશે) → પછી સાચું લખો (યાદીમાં દેખાશે).

🎉 અભિનંદન! તમે પૂરી વેબ એપ બનાવી.
આ જ રીતે કોઈપણ એપ બને છે: Model → migrate → Controller → Route → View.
બીજા વિચારો: નોંધ-પુસ્તિકા, ટૂ-ડુ લિસ્ટ, ગ્રાહક યાદી, ઉત્પાદન કેટલોગ, હાજરી રજિસ્ટર.
6

ફીચર-બાય-ફીચર માર્ગદર્શિકા (1 થી 18)

ઉપર જાઓ

1 Artisan – કમાન્ડથી ફાઇલો બનાવો

શું છે: હાથે ફાઇલ બનાવવાને બદલે કમાન્ડ લખો.

Terminal
python artisan list                    # બધા કમાન્ડ જુઓ
python artisan make:controller PostController
python artisan make:model Product
python artisan make:view posts.index   # resources/views/posts/index.ptl બને

નિયમ: નામ હંમેશા અંગ્રેજી, શબ્દ ચોંટાડીને, દરેક શબ્દનો પ્રથમ અક્ષર મોટો (PostController). ✔ ઉદાહરણ: make:model Product → app/models/product.py.

2 .env સેટિંગ્સ

શું છે: ગુપ્ત અને બદલાતા સેટિંગ્સ એક જગ્યાએ.

કી અર્થ ઉદાહરણ
APP_NAME વેબસાઇટનું નામ MyShop
APP_ENV local (શીખવા) કે production (ઓનલાઇન) local
APP_DEBUG true = ભૂલની વિગત બતાવે. ઓનલાઇન માટે false true
APP_KEY ગુપ્ત કી (key:generate બનાવે) —
APP_LOCALE ભાષા en
DB_CONNECTION sqlite કે mysql sqlite
QUEUE_CONNECTION database (લાઇનમાં) કે sync (તરત) sync

.env બદલ્યા પછી સર્વર ફરી શરૂ કરો (Ctrl+C પછી serve).

3 Routes – વેબ એડ્રેસ

ફાઇલ: routes/web.py

routes/web.py
from framework.routing import Route

# સાદા રસ્તા  →  "Controller@method"
Route.get("/", "WelcomeController@index").name("home")
Route.get("about", "PageController@about").name("about")
Route.post("contact", "ContactController@send").name("contact.send")

# એડ્રેસમાં બદલાતો ભાગ:  /hello/Raj
Route.get("hello/{name}", "PageController@hello")

# લોગિન ફરજિયાત
Route.get("dashboard", "DashboardController@index").name("dashboard").middleware("auth")

# એક લાઇનથી આખું CRUD (7 રસ્તા)
Route.resource("posts", "PostController")

# જૂથ: બધા એડ્રેસ /admin/... થી શરૂ અને લોગિન જરૂરી
Route.group(prefix="admin", middleware="auth", callback=lambda: [
    Route.get("home", "AdminController@home").name("admin.home"),
    Route.get("users", "AdminController@users").name("admin.users"),
])

Controller વગર સીધું લખવું (ટૂંકા કામ માટે):

routes/web.py
from framework.http import json_response
Route.get("ping", lambda request: json_response({"ok": True}))

name() નું મહત્વ: નામ આપ્યા પછી પેજમાં {{ route('about') }} લખો. પછી એડ્રેસ બદલાય તો પેજો તૂટતા નથી.
ઉપલબ્ધ પ્રકારો: Route.get, post, put, patch, delete, any.
નોંધ: auth સિવાયના middleware નામ હાલ લાગુ થતા નથી (વિભાગ 12 જુઓ).

4 Controllers

ફોલ્ડર: app/http/controllers/. દરેક method ને પહેલો ઇનપુટ request મળે.

તમે શું કરવું માંગો છો કોડ
પેજ બતાવો return self.render(request, "posts.index", {"posts": posts})
બીજા રાઉટ પર મોકલો return self.redirect("posts.index")
પાછલા પેજ પર મોકલો return self.back(request, "/")
JSON આપો (API) return self.json({"status": "ok"}, status=200)
ફોર્મ ચકાસો data = self.validate(request, {...})
ફોર્મમાંથી એક કિંમત request.POST.get("title")
URL માંથી કિંમત method નું નામ def show(self, request, id)
લૉગિન થયેલ યુઝર request.user
ફાઇલ અપલોડ request.FILES.get("photo")

નામ આપવાની રીત: make:controller PostController --resource બધા 7 method (index, create, store, show, edit, update, destroy) સાથે ફાઇલ બનાવે.

5 Views અને PTL ટેમ્પ્લેટ

PTL એટલે HTML ની અંદર થોડી ખાસ સુવિધાઓ. સંપૂર્ણ યાદી વિભાગ 7 માં છે. મુખ્ય ત્રણ:

PTL
{{ નામ }}                  ← કિંમત છાપો (સુરક્ષિત, આપમેળે HTML escape)
@if(શરત) ... @endif       ← શરત
@foreach(x in યાદી) ... @endforeach   ← લૂપ

Layout (સામાન્ય ઢાંચું): resources/views/layouts/app.ptl માં મેનુ/ફૂટર લખો અને @yield('content') જ્યાં દરેક પેજનો ભાગ આવશે. દરેક પેજમાં:

PTL
@extends('layouts.app')
@section('content')
   ...તમારું પેજ...
@endsection

ફાઇલ નામ અને ડોટ: "posts.index" એટલે resources/views/posts/index.ptl.

6 Models – ડેટા સાથે કામ

ફીલ્ડના પ્રકાર (fields.):

પ્રકાર શેના માટે ઉદાહરણ
String(255) ટૂંકું લખાણ name = fields.String(100)
Text() લાંબું લખાણ body = fields.Text(blank=True, null=True)
Integer() / BigInteger() પૂર્ણ સંખ્યા qty = fields.Integer(default=0)
Decimal(max_digits=10, decimal_places=2) ભાવ price = fields.Decimal()
Float() દશાંશ rating = fields.Float()
Boolean(default=False) હા/ના is_active = fields.Boolean(default=True)
Date() / DateTime() તારીખ/સમય created_at = fields.DateTime(auto_now_add=True)
Email() ઇમેઇલ email = fields.Email(unique=True)
JSON() લવચીક ડેટા meta = fields.JSON()
File() / Image() અપલોડ ફાઇલ/ફોટો photo = fields.Image(upload_to="photos/")
BelongsTo("Category") સંબંધ: આ પોસ્ટ એક Category ની category = fields.BelongsTo("Category")
ManyToMany("Tag") અનેક-અનેક સંબંધ tags = fields.ManyToMany("Tag")

ડેટા વાંચવા/લખવાના આદેશ:

શું કરવું કોડ
બધા Post.all()
ID થી શોધો (ન મળે તો None) Post.find(1)
ID થી શોધો (ન મળે તો ભૂલ/404 જેવું) Post.find_or_fail(1)
નવો બનાવો Post.create(title="નવું")
શરત મુજબ Post.where(is_active=True)
પ્રથમ રેકોર્ડ Post.first() અથવા Post.first(title="abc")
અપડેટ post.update(title="નવું નામ")
ડિલીટ post.delete()
પેજિંગ Post.paginate(page=1, per_page=15)
ડિક્શનરીમાં post.to_dict()
ગણતરી Post.all().count()
ક્રમમાં Post.all().order_by("-created_at") (નવું પહેલાં)
અક્ષર શોધ Post.where(title__contains="ગુજ")
સંખ્યાથી મોટું Product.where(price__gt=100)

નવું ફીલ્ડ ઉમેર્યા પછી હંમેશા: python artisan migrate.

નોંધ: where() માં ફક્ત સરખામણી આપી શકાય છે (કીવર્ડ સ્વરૂપે). where("price", ">", 100) ન ચાલે; તેની જગ્યાએ price__gt=100.

7 Migrations – ટેબલ બનાવવા/બદલવા

શું છે: મોડેલમાં ફેરફાર કર્યા પછી ડેટાબેઝને તે જણાવવાની રીત.

Terminal
python artisan migrate           # ફેરફાર લાગુ કરો (migration ફાઇલ જાતે બને)
python artisan make:migration    # ફક્ત migration ફાઇલ બનાવો
python artisan migrate:status    # કઈ migration ચાલી ગઈ તે જુઓ
python artisan migrate:fresh     # ⚠️ બધા ટેબલ ડિલીટ કરી ફરી બનાવે (ડેટા જશે!)
python artisan migrate:fresh --seed   # ઉપરનું + ડેમો ડેટા
સલામતી: migrate:fresh ઓનલાઇન ડેટાબેઝ પર ક્યારેય ન ચલાવશો. migrate:rollback નામ ભ્રામક છે: તે છેલ્લું નહીં, પણ તમારી એપની બધી migration પાછી ખેંચે છે.

8 Seeders – ડેમો ડેટા

Terminal
python artisan make:seeder PostSeeder

database/seeders/post_seeder.py માં:

database/seeders/post_seeder.py
from framework.database import Seeder
from app.models.post import Post

class PostSeeder(Seeder):
    def run(self):
        Post.create(title="પહેલી પોસ્ટ", body="નમસ્તે!")
        Post.create(title="બીજી પોસ્ટ", body="આભાર!")

ચલાવો: python artisan db:seed --class=PostSeeder
બધા એક સાથે ચલાવવા માટે database/seeders/database_seeder.py માં self.call(PostSeeder) લખો, પછી python artisan db:seed.

9 Validation – ફોર્મ ચકાસણી

Python
data = self.validate(request, {
    "name":     "required|min:3|max:50",
    "email":    "required|email",
    "age":      "numeric",
    "status":   "required|in:draft,published",
    "password": "required|min:6|confirmed",
})

ઉપલબ્ધ નિયમો (ચકાસેલા):

નિયમ અર્થ
required ખાલી ન ચાલે
email સાચો ઇમેઇલ
min:N ઓછામાં ઓછા N અક્ષર
max:N વધુમાં વધુ N અક્ષર
numeric સંખ્યા હોવી જોઈએ
in:a,b,c આ વિકલ્પોમાંથી જ એક
confirmed password અને password_confirmation સરખા

નિયમો | થી જોડાય છે. કોઈ ફીલ્ડ required ન હોય અને ખાલી હોય તો બીજા નિયમ ચકાસાતા નથી.

⚠️ min/max સંખ્યા માટે પણ અક્ષર ગણે છે (દા.ત. age: numeric|min:18 માં "5" ને "અક્ષર" ગણી ભૂલ આપશે). ઉંમર જેવા કિસ્સામાં in: અથવા જાતે if int(age) < 18: લખો.
⚠️ boolean, string, unique, date, url વગેરે નિયમો હજી બન્યા નથી.

સંદેશ ગુજરાતીમાં આપવા:

Python
self.validate(request,
    {"title": "required|min:3"},
    {"title.required": "શીર્ષક લખવું જરૂરી છે.", "title.min": "ઓછામાં ઓછા 3 અક્ષર લખો."})

⚠️ યાદ રાખો: validate() ને હંમેશા try/except ValidationError માં રાખો (ઉદાહરણ વિભાગ 5 માં).

10 Form Request – મોટા ફોર્મ માટે અલગ ફાઇલ

Terminal
python artisan make:request StorePostRequest

app/http/requests/store_post_request.py:

app/http/requests/store_post_request.py
from framework.http import FormRequest

class StorePostRequest(FormRequest):
    def rules(self):
        return {"title": "required|min:3|max:200"}

    def messages(self):
        return {"title.required": "શીર્ષક જરૂરી છે."}

Controller માં:

Controller
from app.http.requests.store_post_request import StorePostRequest

def store(self, request):
    form = StorePostRequest(request)
    try:
        data = form.validate()
    except ValidationError:
        return self.back(request, "/posts/create")
    Post.create(**data)

11 Flash સંદેશ, જૂનું લખાણ (old) અને ભૂલ (error)

શું કેવી રીતે
સંદેશ મૂકવો (controller માં) request.session["flash"] = {"message": "સેવ થયું", "level": "success"}
સંદેશ બતાવવો (view માં) @session('flash') <div>{{ message }}</div> @endsession
ફીલ્ડની ભૂલ બતાવવી @error('title') <span>{{ message }}</span> @enderror
ભૂલ પછી જૂનું લખાણ ભરેલું રાખવું <input name="title" value="{{ old('title') }}">

level: success, danger, warning, info. (પાસવર્ડ ફીલ્ડ સુરક્ષા માટે જૂના લખાણમાં સચવાતા નથી.)

⚠️ આ ત્રણે સુવિધા ચલાવવા માટે વિભાગ 12 નો પેચ A જરૂરી છે.

12 લોગિન અને auth ચોકીદાર

  • રાઉટ પર .middleware("auth") લગાડો → લોગિન ન હોય તો /login પર મોકલી દે (/login?next=...).
  • પેજમાં: @auth ... @endauth (લોગિન થયેલા માટે), @guest ... @endguest (લોગિન વગરના માટે).
  • Controller માં: request.user.is_authenticated.
⚠️ તૈયાર લોગિન પેજ (make:auth) હાલ કામ કરતું નથી (વિભાગ 12). લોગિન જોઈતું હોય તો Django નું login વાપરી જાતે લોગિન પેજ બનાવવું પડશે, અથવા નવી સુવિધા ઉમેરાય ત્યાં સુધી રાહ જુઓ.

13 Components – ફરી ફરી વાપરવાના ટુકડા

બનાવો: resources/views/components/alert.ptl

resources/views/components/alert.ptl
@props(type='info')
<div class="alert alert-{{ type }}">{{ slot }}</div>

વાપરો (કોઈપણ પેજમાં):

PTL
<x-alert type="danger">કંઈક ખોટું થયું!</x-alert>
<x-alert>સામાન્ય સંદેશ</x-alert>
  • @props(type='info') = ડિફોલ્ટ કિંમત.
  • {{ slot }} = ટેગની અંદર લખેલું લખાણ.
  • ફાઇલ નામ box.ptl → ટેગ <x-box>.

અન્ય ટુકડા (Include): @include('partials.menu') અને ડેટા સાથે @include('partials.hello', {'who': 'Raj'}).

14 Queue અને Jobs – પાછળ ચાલતું કામ

ક્યારે: ઇમેઇલ મોકલવો, રિપોર્ટ બનાવવો જેવા ધીમા કામ યુઝરને રાહ જોવડાવ્યા વગર કરવા.

  1. બનાવો: python artisan make:job SendEmailJob
  2. app/jobs/send_email_job.py માં handle ની અંદર કામ લખો:
app/jobs/send_email_job.py
from framework.queue import Job

class SendEmailJob(Job):
    queue = "default"
    max_tries = 3

    def __init__(self, **kwargs):
        self.kwargs = kwargs

    def handle(self):
        print("ઇમેઇલ મોકલ્યો:", self.kwargs.get("to"))

3. Controller માંથી કામ લાઇનમાં મૂકો:

Controller
from app.jobs.send_email_job import SendEmailJob
SendEmailJob.dispatch(to="raj@example.com")

4. બીજા Terminal માં વર્કર ચલાવો: python artisan queue:work (ફક્ત એક જ વાર ચલાવવા: python artisan queue:work --once).

ઝડપી ટેસ્ટ માટે: .env માં QUEUE_CONNECTION=sync કરો, તો કામ તરત જ ચાલી જશે (વર્કર વગર).
ધ્યાન: dispatch() માં ફક્ત લખાણ/નંબર જેવી સાદી કિંમતો (કીવર્ડ સ્વરૂપે) મોકલો. આખું મોડેલ નહીં, ફક્ત id મોકલીને job માં શોધો. વર્કર એક જ ચલાવો.

15 Scheduler – સમયસર ચાલતા કામ

ફાઇલ: routes/console.py

routes/console.py
schedule.command("send:report").daily(at="09:00")   # રોજ 9:00
schedule.command("queue:work --once").every_minute()
schedule.command("cleanup").hourly()
schedule.command("weekly:job").cron("0 8 * * 1")    # દર સોમવારે 8:00

દર મિનિટે ચલાવવાની આ એક લાઇન (કમ્પ્યુટર/સર્વરના ઘડિયાળ-શેડ્યૂલરમાં) મૂકો: python artisan schedule:run

  • Windows: Task Scheduler દ્વારા દર મિનિટે.
  • Linux/Mac: crontab -e માં * * * * * cd /પ્રોજેક્ટ-નો-પાથ && python artisan schedule:run.
⚠️ daily(at="13:30") જેવા મિનિટવાળા સમય હાલ ખોટા ચાલે છે; પૂરા કલાક ("09:00") જ સુરક્ષિત છે. વચ્ચેનો સમય જોઈએ તો cron("30 13 * * *") વાપરો. ચલાવવા માટે Command નું નામ ઓળખાવું જોઈએ.

16 Services અને પોતાના Commands

Service (મોટું લોજિક અલગ રાખવા):

Terminal
python artisan make:service PaymentService

app/services/payment_service.py માં method લખો અને Controller માં ઉપયોગ કરો:

Controller
from app.services.payment_service import PaymentService
PaymentService().execute(amount=500)

પોતાનો artisan કમાન્ડ:

Terminal
python artisan make:command SendWeeklySummary

બનેલી ફાઇલ: app/console/commands/send_weekly_summary_command.py. કમાન્ડનું નામ ફાઇલની અંદર signature માં હોય છે, અને હાલ તે send:weekly:summary (કોલન ત્રણ વાર) બને છે:

Terminal
python artisan send:weekly:summary

તમે signature = "report:weekly" જેવું બદલી શકો છો. handle() માં કામ લખો અને self.info("સંદેશ"), self.success(...), self.error(...) વાપરો.

17 Tinker – ડેટા સાથે રમવાનું શેલ

Terminal
python artisan tinker
Tinker Console
>>> Post.create(title="ટેસ્ટ")
>>> Post.all().count()
>>> Post.find(1).delete()

બધા મોડેલ આપમેળે મળે છે. બહાર નીકળવા: exit().

18 Tests – ખાતરી કરવી કે બધું ચાલે છે

Terminal
python artisan test

પોતાનો ટેસ્ટ tests/test_post.py માં:

tests/test_post.py
from django.test import Client

def test_posts_page_opens():
    response = Client().get("/posts/")
    assert response.status_code == 200

વધારાના ઉપયોગી કમાન્ડ્સ

ફીચર કમાન્ડ / રીત
સ્ટેટિક ફાઇલ (CSS/JS/ફોટો) public/css/app.css મૂકો → પેજમાં {{ asset('css/app.css') }}
અપલોડ ફાઇલ જાહેર કરવી python artisan storage:link
બધા રાઉટ જોવા python artisan route:list
ડેટાબેઝ ચકાસવા python artisan db:check, db:show
PTL ભૂલ શોધવી python artisan view:check
VS Code માં PTL IntelliSense & રંગ સેટઅપ python artisan ptl:install-vscode (Autocomplete + Hover Docs)
PTL ફાઇલો ફોર્મેટ કરવી python artisan ptl:format (Right-Click: Format Document)
7

PTL ટેમ્પ્લેટ એન્જિન – સંપૂર્ણ માર્ગદર્શિકા & VS Code IntelliSense

ઉપર જાઓ

PTL (Postify Template Language) એ AIPostify ફ્રેમવર્કનું મૂળભૂત અને અત્યંત ઝડપી ટેમ્પ્લેટ એન્જિન છે. તે Laravel Blade જેવું સરળ, સુંદર સિન્ટેક્સ અને Python ની હાઇ-પરફોર્મન્સ સ્પીડ આપે છે. બધી ટેમ્પ્લેટ ફાઇલો resources/views/ ફોલ્ડરમાં .ptl એક્સટેન્શન સાથે સંગ્રહાય છે.

PTL VS Code Extension & IntelliSense ટૂલ – ઝડપી સેટઅપ

tools/vscode-postify/extension.js દ્વારા સંચાલિત: ઓટોકમ્પ્લીશન, હોવર ગાઇડ અને ફોર્મેટિંગ

૧-ક્લિક ઇન્સ્ટોલેશન કમાન્ડ:
ટર્મિનલમાં માત્ર આ એક કમાન્ડ ચલાવો:
python artisan ptl:install-vscode
આ કમાન્ડ tools/vscode-postify/ એક્સટેન્શનને તમારા સિસ્ટમના ~/.vscode/extensions/ માં આપોઆપ ઇન્સ્ટોલ કરશે અને પ્રોજેક્ટના .vscode/settings.json માં *.ptl માટે IntelliSense સક્રિય કરી દેશે. તે પછી VS Code માં Ctrl + Shift + P દબાવી Developer: Reload Window કરો.

VS Code માં PTL કોડિંગ સુવિધાઓ:

તમે શું ટાઇપ કરશો IntelliSense સજેશન (ઓટોકમ્પ્લીટ) પરિણામ / આપમેળે ઉમેરાતો કોડ
ડાયરેક્ટિવ્સ:
@ લખતાં (દા.ત. @for, @if)
@foreach, @forelse, @if, @unless, @csrf, @method, @auth, @error, @extends વગેરે 50+ ડાયરેક્ટિવ્સ Enter દબાવતાં જ Opening & Closing સાથે આખો બ્લોક લખાઈ જશે:
@foreach(item in items) ... @endforeach
ફિલ્ટર્સ:
| લખતાં (દા.ત. {{ title | up)
upper, lower, title, truncate, date, number, default, json, slug વગેરે 16 ફિલ્ટર્સ ફિલ્ટર સિલેક્ટ કરતાં જ પેરામીટર્સ સાથે પૂરો થશે:
{{ post.title | upper }} અથવા truncate(100, '...')
લૂપ વેરીએબલ્સ:
loop. લખતાં
loop.index, loop.first, loop.last, loop.even, loop.odd, loop.count, loop.parent લૂપનો વર્તમાન ક્રમ (1, 2, 3..), પહેલી કે છેલ્લી રો, સમ કે વિષમ લાઇનનું સચોટ લોજિક તરત મળી જશે.
કમ્પોનન્ટ્સ:
<x- લખતાં
resources/views/components/ માંથી તમારી કસ્ટમ .ptl ફાઇલો (જેમ કે <x-alert>) શોધી લાવશે કમ્પોનન્ટના @props ના એટ્રિબ્યુટ્સ સાથે ટેગ લખાશે, તેમજ <x-slot name="title"> પણ પૂરો કરશે.
માઉસ હોવર (Hover):
કોઈપણ ટેગ પર માઉસ રાખો
Hover Documentation:
કોઈપણ @directive, |filter કે હેલ્પર પર માઉસ રાખો
ટૂલટિપ વિન્ડોમાં તે ડાયરેક્ટિવ શું કામ કરે છે, તેની સિન્ટેક્સ અને સાચું ઉદાહરણ તરત જ દેખાશે.
ફોર્મેટિંગ:
Shift + Alt + F
રાઇટ-ક્લિક કરીને Format Document પસંદ કરો આખી .ptl ફાઇલના HTML ટેગ્સ અને PTL બ્લોક્સ સુઘડ ઇન્ડેન્ટેશન સાથે આપમેળે ફોર્મેટ થઈ જશે.

1. PTL કેવી રીતે કામ કરે છે? (Controller → View પ્રવાહ)

Controller ફાઇલમાંથી ડેટા તૈયાર કરીને view('view.name', context_dict) ફંક્શન દ્વારા PTL ટેમ્પ્લેટમાં મોકલવામાં આવે છે. ડોટ નોટેશન (દા.ત. posts.index) નો અર્થ થાય છે resources/views/posts/index.ptl ફાઇલ.

app/http/controllers/post_controller.py
from framework.http import Request, Response
from app.models.post import Post

class PostController:
    def index(self, request: Request):
        posts = Post.all()
        # view() ફંક્શનમાં પહેલો પેરામીટર ટેમ્પ્લેટ પાથ અને બીજો ડેટા ડિક્શનરી
        return view('posts.index', {
            'page_title': 'તાજા સમાચાર અને લેખો',
            'posts': posts,
            'user': request.user
        })

2. કિંમત છાપવી અને સુરક્ષા (Variables & Escaping)

સિન્ટેક્સ ઉદાહરણ સમજૂતી & સુરક્ષા
{{ variable }} {{ user.name }} HTML Escaped (સુરક્ષિત): XSS હુમલા રોકવા માટે <, >, & આપોઆપ સુરક્ષિત અક્ષરોમાં ફેરવાશે.
{!! raw_html !!} {!! post.content !!} Raw HTML: HTML ટેગ્સ જેમ છે તેમ પ્રિન્ટ થશે. ⚠️ ફક્ત વિશ્વાસુ એડમિન ડેટા માટે જ વાપરો.
{{-- ટિપ્પણી --}} {{-- આ કોડ છૂપો રહેશે --}} PTL Comment: બ્રાઉઝરના 'View Source' માં પણ દેખાશે નહીં. સર્વર સાઇડે જ કાઢી નંખાય છે.
@@directive @@if(show) Escape Directive: અક્ષરશઃ @if(show) પ્રિન્ટ કરવા માટે (Vue.js કે Alpine.js સાથે સંઘર્ષ ટાળવા).
{{ post.title }} {{ post.author.name }} ડોટ નોટેશનથી ઓબ્જેક્ટ એટ્રિબ્યુટ્સ અથવા ડિક્શનરી કી સરળતાથી એક્સેસ થાય છે.
{{ items[0] }} {{ tags[0] }} લિસ્ટ કે એરેની ઇન્ડેક્સ એક્સેસ કરવા માટે.

3. લેઆઉટ ઇનહેરિટન્સ અને માસ્ટર ટેમ્પ્લેટ (@extends & @yield)

વારંવાર વપરાતા હેડર, ફૂટર અને નેવિગેશન માટે એક માસ્ટર લેઆઉટ બનાવો અને બાકીના પેજ તેમાં ઇન્જેક્ટ કરો.

resources/views/layouts/app.ptl
<!DOCTYPE html>
<html lang="gu">
<head>
    <title>@yield('title', 'AIPostify App')</title>
    <link rel="stylesheet" href="{{ asset('css/app.css') }}">
    @stack('styles')
</head>
<body>
    @include('partials.navbar')

    <main class="container py-4">
        @yield('content')
    </main>

    @include('partials.footer')
    @stack('scripts')
</body>
</html>
resources/views/posts/index.ptl
@extends('layouts.app')

@section('title', 'બધી પોસ્ટ્સ')

@section('content')
    <h1>તાજી બ્લોગ પોસ્ટ્સ</h1>
    <div class="row">
        @foreach(post in posts)
            <div class="card mb-3">
                <h3>{{ post.title }}</h3>
                <p>{{ post.body | truncate(120) }}</p>
            </div>
        @endforeach
    </div>
@endsection

@push('scripts')
    <script src="{{ asset('js/posts.js') }}"></script>
@endpush
ડાયરેક્ટિવ ક્યાં વપરાય ઉપયોગ અને સમજૂતી
@extends('layouts.app') ચાઇલ્ડ પેજમાં (સૌથી ઉપર) આ પેજ કયા પેરન્ટ માસ્ટર લેઆઉટમાં ફિટ થશે તે નક્કી કરે છે.
@yield('content') માસ્ટર લેઆઉટમાં ચાઇલ્ડ પેજનો જે-તે સેક્શન અહીં રેન્ડર થશે. બીજો પેરામીટર ડિફોલ્ટ વેલ્યુ છે: @yield('title', 'Default Title').
@section('name') ... @endsection ચાઇલ્ડ પેજમાં લેઆઉટના @yield('name') ભાગમાં મોકલવાની સામગ્રી.
@section('title', 'મૂલ્ય') ચાઇલ્ડ પેજમાં ટૂંકી ૧-લાઇનની સેક્શન વેલ્યુ સેટ કરવા માટે (ક્લોઝિંગ ટેગની જરૂર નથી).
@stack('name') & @push('name') લેઆઉટ અને પેજમાં પેજ પ્રમાણે વધારાની CSS કે JS સ્ક્રિપ્ટ્સ સ્ટેકના છેડે ઉમેરવા માટે.
@prepend('name') ચાઇલ્ડ પેજમાં સ્ટેકની શરૂઆતમાં આગળ કોડ ઉમેરવા માટે.
@include('partials.nav') ગમે ત્યાં નાના પુનઃઉપયોગી ટુકડા (દા.ત. navbar, sidebar) ને ઇન્ક્લુડ કરવા માટે. ડેટા પણ આપી શકાય: @include('nav', {'active': 'home'}).
@includeIf('view') ગમે ત્યાં જો ફાઇલ હયાત હોય તો જ ઇન્ક્લુડ કરે, ભૂલ ન ફેંકે.
@includeWhen(cond, 'view') ગમે ત્યાં શરત True હોય ત્યારે જ ઇન્ક્લુડ કરે.
@includeUnless(cond, 'view') ગમે ત્યાં શરત False હોય ત્યારે જ ઇન્ક્લુડ કરે.

4. શરતો અને કંટ્રોલ ફ્લો (Conditionals)

PTL શરતોનું ઉદાહરણ
{{-- 1. સ્ટાન્ડર્ડ if-elif-else --}}
@if(user.role == 'admin')
    <span class="badge bg-danger">એડમિનિસ્ટ્રેટર</span>
@elif(user.role == 'editor')
    <span class="badge bg-warning">સંપાદક</span>
@else
    <span class="badge bg-secondary">સામાન્ય સભ્ય</span>
@endif

{{-- 2. Unless (શરત ખોટી/False હોય ત્યારે જ ચાલે) --}}
@unless(user.is_verified)
    <div class="alert alert-warning">કૃપા કરીને તમારું ઇમેઇલ વેરીફાય કરો.</div>
@endunless

{{-- 3. Switch-Case મલ્ટી-બ્રાન્ચ --}}
@switch(order.status)
    @case('pending')
        <span class="text-warning">પ્રતીક્ષા હેઠળ</span>
        @break
    @case('shipped')
        <span class="text-primary">મોકલાઈ ગયેલ</span>
        @break
    @case('delivered')
        <span class="text-success">પહોંચી ગયેલ</span>
        @break
    @default
        <span class="text-muted">અજાણી સ્થિતિ</span>
@endswitch

5. લૂપ્સ અને અદ્યતન $loop ઓબ્જેક્ટ

PTL માં @foreach, @forelse, @for અને @while લૂપ્સ છે. લૂપ ચાલતી વખતે PTL આપમેળે એક loop ઓબ્જેક્ટ પૂરો પાડે છે જે ટેબલ, લિસ્ટ અને અલ્ગોરિધમ્સ માટે અતિ ઉપયોગી છે.

PTL લૂપ અને loop વેરીએબલ્સ
{{-- Forelse: જો લિસ્ટ ખાલી હોય તો @empty બ્લોક ચાલશે --}}
<table class="table">
    <tbody>
        @forelse(user in users)
            <tr class="{{ 'bg-light' if loop.even else '' }}">
                <td>{{ loop.index }}</td>
                <td>{{ user.name }}</td>
                <td>
                    @if(loop.first) <span class="badge">નવો</span> @endif
                    @if(loop.last) <span class="badge">છેલ્લો</span> @endif
                </td>
            </tr>
        @empty
            <tr><td colspan="3" class="text-center">કોઈ વપરાશકર્તા મળ્યા નથી.</td></tr>
        @endforelse
    </tbody>
</table>

{{-- સાદું રેન્જ આધારિત લૂપ --}}
@for(i in range(1, 6))
    <span class="page-link">પેજ {{ i }}</span>
@endfor
લૂપ વેરીએબલ પ્રકાર સમજૂતી અને ઉપયોગ
loop.index Integer ૧ થી શરૂ થતો ક્રમાંક (1, 2, 3...) ટેબલ સીરીયલ નંબર માટે શ્રેષ્ઠ.
loop.index0 Integer ૦ થી શરૂ થતો ઇન્ડેક્સ (0, 1, 2...).
loop.revindex Integer છેલ્લે પહોંચવા માટે કેટલા બાકી છે તેની ઉલટી ગણતરી (1 પર પૂર્ણ).
loop.revindex0 Integer ઉલટી ગણતરી (0 પર પૂર્ણ).
loop.first Boolean જો વર્તમાન આઇટમ પ્રથમ આઇટમ હોય તો True.
loop.last Boolean જો વર્તમાન આઇટમ છેલ્લી આઇટમ હોય તો True.
loop.even Boolean જો બેકી લાઇન (2, 4, 6...) હોય તો True (ઝીબ્રા ટેબલ કલરિંગ માટે).
loop.odd Boolean જો એકી લાઇન (1, 3, 5...) હોય તો True.
loop.count / loop.length Integer કુલ આઇટમ્સની સંખ્યા.
loop.depth Integer લૂપનું નેસ્ટિંગ લેવલ (બહારનું લૂપ = 1, અંદરનું = 2).
loop.parent Object નેસ્ટેડ લૂપમાં બહારના પેરન્ટ લૂપનો સંદર્ભ (દા.ત. loop.parent.index).

6. ફોર્મ્સ, CSRF અને વેલિડેશન હેન્ડલિંગ

PTL માં વેબ ફોર્મ્સ બનાવતી વખતે CSRF સુરક્ષા, HTTP મેથડ સ્પૂફિંગ (PUT/DELETE), અને જૂનો ઇનપુટ ડેટા પાછો મેળવવા માટે ખાસ ડાયરેક્ટિવ્સ ઉપલબ્ધ છે.

સુરક્ષિત ફોર્મનું ઉદાહરણ
{{-- ફ્લેશ સક્સેસ મેસેજ દર્શાવવો --}}
@session('success')
    <div class="alert alert-success">{{ message }}</div>
@endsession

<form method="POST" action="{{ route('posts.update', id=post.id) }}">
    @csrf                  {{-- ગુપ્ત CSRF સુરક્ષા ટોકન ઇનપુટ ઉમેરે છે --}}
    @method('PUT')          {{-- POST ફોર્મને PUT/PATCH/DELETE મેથડ બનાવે છે --}}

    <div class="mb-3">
        <label>શીર્ષક</label>
        <input type="text" name="title" value="{{ old('title', post.title) }}" class="form-control">
        @error('title')
            <span class="text-danger">{{ message }}</span>
        @enderror
    </div>

    <div class="mb-3">
        <label>વિગત</label>
        <textarea name="body" class="form-control">{{ old('body', post.body) }}</textarea>
        @error('body')
            <span class="text-danger">{{ message }}</span>
        @enderror
    </div>

    <button type="submit" class="btn btn-primary">સેવ કરો</button>
</form>

7. ઓથેન્ટિકેશન અને પરવાનગીઓ (@auth, @guest, @can)

PTL Auth ડાયરેક્ટિવ્સ
{{-- ૧. ફક્ત લોગિન થયેલા વપરાશકર્તા માટે --}}
@auth
    <div class="user-profile">
        <p>સ્વાગત છે, <strong>{{ auth().username }}</strong>!</p>
        <a href="{{ route('logout') }}">લોગઆઉટ</a>
    </div>
@endauth

{{-- ૨. ફક્ત મહેમાન (લોગિન ન કર્યું હોય તેવા) માટે --}}
@guest
    <a href="{{ route('login') }}" class="btn btn-outline">લોગિન કરો</a>
    <a href="{{ route('register') }}" class="btn btn-primary">નોંધણી કરો</a>
@endguest

{{-- ૩. ચોક્કસ પરવાનગી હોય તો જ બટન દેખાય --}}
@can('delete', post)
    <form action="{{ route('posts.destroy', id=post.id) }}" method="POST">
        @csrf
        @method('DELETE')
        <button type="submit" class="btn btn-danger btn-sm">કાઢી નાખો</button>
    </form>
@endcan

8. કસ્ટમ PTL કમ્પોનન્ટ્સ સિસ્ટમ (<x-component>)

વારંવાર વપરાતા UI બ્લોક્સ (જેમ કે Alert બોક્સ, Modal, Product Card) માટે કમ્પોનન્ટ્સ બનાવો. કમ્પોનન્ટ ફાઇલો resources/views/components/ ફોલ્ડરમાં મૂકવામાં આવે છે.

કમ્પોનન્ટ વ્યાખ્યા: resources/views/components/alert.ptl
@props(type='info', title=None, dismissible=False)

<div class="alert alert-{{ type }} {{ 'alert-dismissible' if dismissible else '' }}">
    @if(title)
        <h4 class="alert-heading">{{ title }}</h4>
    @endif

    {{-- ડિફોલ્ટ સામગ્રી {{ slot }} માં આવશે --}}
    {{ slot }}

    @if(dismissible)
        <button type="button" class="btn-close"></button>
    @endif
</div>
પેજમાં ઉપયોગ: resources/views/home.ptl
@extends('layouts.app')

@section('content')
    {{-- ૧. સાદો Alert કમ્પોનન્ટ --}}
    <x-alert type="danger" title="ધ્યાન આપો">
        તમારું એકાઉન્ટ વેરિફિકેશન બાકી છે.
    </x-alert>

    {{-- ૨. સેલ્ફ ક્લોઝિંગ કમ્પોનન્ટ --}}
    <x-card title="પ્રોફાઇલ સારાંશ" />

    {{-- ૩. Named Slots નો ઉપયોગ --}}
    <x-modal id="deleteModal">
        <x-slot name="header">પુષ્ટિકરણ</x-slot>
        શું તમે ખરેખર આ ફાઇલ કાઢી નાખવા માંગો છો?
        <x-slot name="footer">
            <button class="btn btn-danger">હા, કાઢો</button>
        </x-slot>
    </x-modal>
@endsection

9. તમામ ૧૬ બિલ્ટ-ઇન ફિલ્ટર્સ (Pipe | ઓપરેટર)

PTL ફિલ્ટર્સ દ્વારા કોઈપણ લખાણ કે ડેટાનું ફોર્મેટિંગ તુરંત કરી શકાય છે:

ફિલ્ટર નામ PTL કોડ ઉદાહરણ પરિણામ / સમજૂતી
upper {{ 'hello world' | upper }} HELLO WORLD (બધા મોટા અક્ષરો)
lower {{ user.email | lower }} બધા નાના અક્ષરોમાં ફેરવે છે
title {{ 'aipostify python mvc' | title }} Aipostify Python Mvc (દરેક શબ્દનો પહેલો અક્ષર મોટો)
capitalize {{ 'hello there' | capitalize }} Hello there (ફક્ત વાક્યનો પહેલો અક્ષર મોટો)
trim {{ ' abc ' | trim }} abc (આગળ-પાછળની વધારાની ખાલી જગ્યાઓ દૂર કરે છે)
truncate(length, end) {{ post.body | truncate(100, '...') }} લખાણને ૧૦૦ અક્ષરે કાપીને છેડે "..." જોડે છે
date(format) {{ post.created_at | date('d M Y') }} 25 Oct 2026 (તારીખ ફોર્મેટ: d=દિવસ, m=મહિનો, Y=વર્ષ, H:i=કલાક-મિનિટ)
number(decimals) {{ 1250000.5 | number(2) }} 1,250,000.50 (ચલણ અને અલ્પવિરામ સાથે અંક ફોર્મેટિંગ)
default('fallback') {{ user.bio | default('બાયો લખેલ નથી.') }} જો કિંમત ખાલી (None/Empty) હોય તો ડિફોલ્ટ વેલ્યુ દર્શાવે છે
json <script>const conf = {{ settings | json }};</script> Python ડિક્શનરી/લિસ્ટને માન્ય JavaScript JSON માં રૂપાંતરિત કરે છે
nl2br {{ comment.text | nl2br }} નવી લાઇન (\n) ને આપમેળે HTML <br> ટેગમાં ફેરવે છે
slug {{ 'My First Blog Post!' | slug }} my-first-blog-post (URL-ફ્રેન્ડલી સ્લગ બનાવે છે)
escape {{ user_input | escape }} HTML સ્પેશિયલ કેરેક્ટર્સને એન્કોડ કરે છે
striptags {{ raw_html | striptags }} લખાણમાંથી તમામ HTML ટેગ્સ કાઢી નાખી સાદું ટેક્સ્ટ રાખે છે
length / count {{ posts | length }} કલેક્શન કે શબ્દમાળાની કુલ લંબાઈ / સભ્યોની સંખ્યા

10. ઉપલબ્ધ ગ્લોબલ હેલ્પર્સ (Global Template Helpers)

હેલ્પર ફંક્શન ઉદાહરણ પરિણામ / ઉપયોગ
route(name, **kwargs) {{ route('posts.show', id=post.id) }} routes/web.py માં રજીસ્ટર કરેલ રૂટના નામ પરથી URL બનાવે છે
url(path) {{ url('/about') }} એપ્લિકેશનનું સંપૂર્ણ URL પાથ બનાવે છે (/about)
asset(path) {{ asset('css/style.css') }} /static/css/style.css નું સ્ટેટિક પાથ બનાવે છે
csrf_token() {{ csrf_token() }} વર્તમાન સેશનનો સુરક્ષા ટોકન આપે છે (AJAX માટે ઉપયોગી)
old(field, default) {{ old('email', '') }} વેલિડેશન નિષ્ફળતા પછી અગાઉ સબમિટ થયેલ ઇનપુટ મૂલ્ય પાછું લાવે છે
auth() {{ auth().username }} લૉગિન થયેલ વપરાશકર્તા ઑબ્જેક્ટ આપે છે (જો લૉગિન ન હોય તો None)
config(key) {{ config('app.name') }} config/app.py માંથી કન્ફિગરેશન કિંમત વાંચે છે
now() © {{ now().year }} Postify હાલની તારીખ અને સમયનો Python datetime ઓબ્જેક્ટ આપે છે
session(key) {{ session('status') }} સેશન વેલ્યુ કે ફ્લેશ સંદેશ મેળવે છે
errors(field) {{ errors('email') }} ફોર્મ વેલિડેશન એરર ડિક્શનરી આપે છે

11. અદ્યતન ડિરેક્ટિવ્સ (@php અને @verbatim)

PTL Raw Python & Verbatim Blocks
{{-- ૧. ટેમ્પ્લેટમાં પ્યોર પાયથોન કોડ ચલાવવા માટે --}}
@php
    tax_rate = 0.18
    discount = 0.05
    final_total = subtotal * (1 - discount) * (1 + tax_rate)
@endphp
<p>કુલ ચુકવણી: ₹{{ final_total | number(2) }}</p>

{{-- ૨. @verbatim: Vue.js કે Alpine.js વાપરતી વખતે PTL ને પાર્સિંગ કરતાં રોકવા --}}
@verbatim
    <div id="app">
        {{-- આ PTL દ્વારા નહીં પરંતુ ફ્રન્ટએન્ડ Vue/Alpine દ્વારા રેન્ડર થશે --}}
        <h1>{{ vue_variable }}</h1>
    </div>
@endverbatim

12. PTL મેનેજમેન્ટ Artisan કમાન્ડ્સ

કમાન્ડ શું કાર્ય કરે છે ક્યારે વાપરવો
python artisan ptl:install-vscode VS Code માં PTL IntelliSense અને Formatter આપમેળે સેટ કરે છે પહેલીવાર પ્રોજેક્ટ સેટ કરતી વખતે
python artisan ptl:format બધા .ptl ટેમ્પ્લેટ્સનું ઇન્ડેન્ટેશન સુઘડ રીતે ફોર્મેટ કરે છે કોડ ક્લીનઅપ વખતે (દા.ત. --indent 4)
python artisan ptl:format --check કોઈ ફાઇલમાં ફોર્મેટિંગ ખામી છે કે નહીં તે ચકાસે છે Git commit કે CI/CD પાઇપલાઇનમાં
python artisan make:view posts.create નવું resources/views/posts/create.ptl ટેમ્પ્લેટ બનાવે છે નવું વેબ પેજ બનાવતી વખતે
python artisan view:cache બધા PTL ટેમ્પ્લેટ્સ અગાઉથી કમ્પાઇલ કરી કેશ કરે છે પ્રોડક્શન સર્વર પર હાઇ-સ્પીડ પર્ફોર્મન્સ માટે
python artisan view:clear કમ્પાઇલ થયેલી વ્યુ કેશ ફાઇલો સાફ કરે છે જ્યારે ટેમ્પ્લેટ ફેરફારો તરત ન દેખાય ત્યારે
python artisan view:check તમામ PTL ટેમ્પ્લેટ્સમાં કોઈ સિન્ટેક્સ એરર છે કે નહીં તે ચકાસે છે પ્રોડક્શન ડિપ્લોય કરતાં પહેલાં

13. PTL સુરક્ષા સેન્ડબોક્સ (Security Sandbox Rules)

સુરક્ષા નિયમો: PTL એન્જિન હેકિંગ અને અનઅધિકૃત એક્સેસ રોકવા માટે બિલ્ટ-ઇન સેન્ડબોક્સ ધરાવે છે:
  • import, open, eval, exec, os, sys ટેમ્પ્લેટમાં બ્લોક છે.
  • __class__, __subclasses__ જેવા અંડરસ્કોર એટ્રિબ્યુટ્સ અટકાવેલા છે.
  • ટેમ્પ્લેટમાં સીધું env() ન વાપરશો, હંમેશા config() મારફતે સુરક્ષિત રીતે વેલ્યુ વાંચો.
  • મોટું બિઝનેસ લોજિક ક્યારેય ટેમ્પ્લેટમાં ન લખો — તે હંમેશા Controller કે Service માં જ હોવું જોઈએ.
8

Artisan કમાન્ડ્સની યાદી

ઉપર જાઓ

બનાવો (make:)

કમાન્ડ શું બને ક્યાં
make:controller NameController [--resource] Controller app/http/controllers/
make:model Name [-m] Model (+ Migration) app/models/
make:migration [નામ] Migration database/migrations/
make:view posts.index PTL વ્યૂ resources/views/posts/index.ptl
make:layout નામ Layout resources/views/layouts/
make:component નામ Component resources/views/components/
make:request NameRequest Form Request app/http/requests/
make:middleware નામ Middleware ક્લાસ (હાલ આપમેળે લાગુ ન થાય) app/http/middleware/
make:seeder NameSeeder Seeder database/seeders/
make:job NameJob Job app/jobs/
make:service NameService Service app/services/
make:command નામ Artisan કમાન્ડ app/console/commands/
make:auth ⚠️ લોગિન સ્કેફોલ્ડ ❌ હાલ કામ કરતું નથી
make:crud નામ ⚠️ આખું CRUD ❌ હાલ કામ કરતું નથી

ડેટાબેઝ

Database Commands
python artisan migrate
python artisan migrate:status
python artisan migrate:fresh [--seed]
python artisan migrate:refresh
python artisan migrate:rollback
python artisan db:seed [--class=નામ]
python artisan db:show
python artisan db:check
python artisan db:create      # MySQL માટે
python artisan db:transfer

સર્વર અને સાધનો

Tools
python artisan serve [--host=127.0.0.1] [--port=8000]
python artisan route:list
python artisan tinker
python artisan test
python artisan key:generate
python artisan storage:link

Queue / Schedule / Cache

Worker & Cache
python artisan queue:work [--once] [--queue=default] [--sleep=3]
python artisan schedule:run
python artisan ptl:format             # PTL ફાઇલો સુઘડ ફોર્મેટ કરો
python artisan view:check
python artisan view:cache
python artisan view:clear
python artisan cache:clear
python artisan config:cache
python artisan config:clear
9

ડેટાબેઝ: SQLite ↔ MySQL

ઉપર જાઓ

A. SQLite (શરૂઆત માટે સૌથી સરળ, કંઈ ઇન્સ્ટોલ નહીં)

.env:

.env
DB_CONNECTION=sqlite
DB_DATABASE=database/database.sqlite

B. MySQL (XAMPP / સર્વર)

  1. XAMPP માં MySQL ચાલુ કરો.
  2. .env માં:
.env
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=aipostify
DB_USERNAME=root
DB_PASSWORD=
⚠️ ફરી યાદ: SQLite વાળી DB_DATABASE લાઇન સાથે બેવડી ન રહે; એક જ DB_DATABASE રાખો.

3. કમાન્ડ ચલાવો:

Terminal
python artisan db:create      # ડેટાબેઝ બનાવે
python artisan db:check       # જોડાણ ચકાસે
python artisan migrate        # ટેબલ બનાવે

પાછા SQLite પર આવવા: .env માં DB_CONNECTION=sqlite.

10

સામાન્ય ભૂલો અને ઉકેલ

ઉપર જાઓ
ભૂલ / લક્ષણ કારણ ઉકેલ
python ઓળખાતું નથી Python PATH માં નથી py અથવા python3 વાપરો, અથવા Python ફરી ઇન્સ્ટોલ (Add to PATH ✅)
No module named django પેકેજ ઇન્સ્ટોલ નથી pip install -r requirements.txt
no such table / no such column: app_post.title ટેબલ/ફીલ્ડ ડેટાબેઝમાં નથી python artisan migrate
Migration ... dependencies reference nonexistent parent node કોઈ migration ફાઇલ જાતે ડિલીટ કરી ગુમ થયેલી ફાઇલ પાછી લાવો; શીખવાના પ્રોજેક્ટમાં database.sqlite અને 0002_* થી આગળની migration ડિલીટ કરી ફરી migrate
View [posts.index] not found ફાઇલ નામ/ફોલ્ડર ખોટું resources/views/posts/index.ptl છે કે તે તપાસો; view:check ચલાવો
ફોર્મ સબમિટ કરતાં 403 CSRF @csrf ભૂલી ગયા ફોર્મમાં @csrf ઉમેરો
ફોર્મ ખોટું ભર્યા પછી 500 error validate() ને try/except ValidationError માં રાખ્યું નથી ઉદાહરણ મુજબ try/except લખો
ભૂલનો સંદેશ/ફ્લેશ/જૂનું લખાણ દેખાતું નથી જાણીતો બગ વિભાગ 12 નો પેચ A લગાવો
ડિલીટ/અપડેટ બટન ખોટા હેન્ડલર પર જાય @method('DELETE') ગુમ ફોર્મમાં @method('DELETE') ઉમેરો
Route.get("hello/{name}") જેવા રાઉટમાં કિંમત હંમેશા લખાણ (string) આવે {નામ} વાળો ભાગ લખાણ ગણાય સંખ્યા જોઈએ તો int(id) કરો. (Route.resource માં id આપમેળે સંખ્યા હોય છે.)
404 Not Found રાઉટ નથી route:list માં તપાસો; routes/web.py સેવ કર્યું?
એડ્રેસના છેડે / Django આપમેળે / ઉમેરે છે /posts ખોલો તો /posts/ પર જશે, સામાન્ય છે
Controller 'X' could not be resolved નામ/ફોલ્ડર ખોટું ફાઇલ app/http/controllers/x_controller.py અને ક્લાસ XController
make:crud ક્રેશ થાય જાણીતો બગ વિભાગ 12; ઉપયોગ ન કરવો
closing tag '[/...]' doesn't match any open tag કમાન્ડના સંદેશમાં [ ] ફક્ત સંદેશ છાપવામાં ભૂલ; ફાઇલ સામાન્ય રીતે બની ગઈ હોય છે. સ્ટેટસ જાતે ચકાસો
Command "xyz" is not defined કમાન્ડ નામ ખોટું python artisan list; custom કમાન્ડ માટે ફાઇલમાં signature જુઓ
ફેરફાર દેખાતો નથી કેશ/સર્વર python artisan view:clear, સર્વર ફરી શરૂ, બ્રાઉઝર Ctrl+F5
Address already in use (પોર્ટ 8000) બીજું સર્વર ચાલે છે serve --port=8001
Windows: UnicodeEncodeError ગુજરાતી/ઇમોજી Terminal માં chcp 65001 ચલાવો અથવા VS Code Terminal વાપરો
ભૂલ સમજવાની ટિપ: લાંબા લાલ લખાણમાં સૌથી છેલ્લી લાઇન વાંચો, ત્યાં વાસ્તવિક કારણ લખાયેલું હોય છે.
11

વેબસાઇટ ઓનલાઇન મૂકતાં પહેલાં (સુરક્ષા ચેકલિસ્ટ)

ઉપર જાઓ

ઓનલાઇન મૂકતાં પહેલાં દરેકને ટિક કરો (તમારી પ્રગતિ આપમેળે બ્રાઉઝરમાં સચવાય છે):

12

⚠️ હાલ કામ ન કરતી બાબતો અને તેના ઉપાય

ઉપર જાઓ

પ્રામાણિક યાદી જેથી તમે અટકો નહીં. આ બાબતો કોડ ચલાવીને ચકાસેલી છે:

ફીચર સ્થિતિ ઉકેલ / વિકલ્પ
Flash સંદેશ, ભૂલ-સંદેશ, જૂનું લખાણ (old) ❌ બગ: દેખાતા નથી પેચ A (નીચે)
make:crud ❌ ક્રેશ થાય અને Django ટેગવાળા ખોટા .html વ્યૂ બનાવે વિભાગ 5 મુજબ હાથે બનાવો
make:auth (લોગિન/રજિસ્ટર) ❌ Django ટેગવાળા વ્યૂ; PTL માં ચાલતા નથી જાતે બનાવેલ ફોર્મ + Django authenticate/login
Built-in AI Engine (જૂના ડોક્યુમેન્ટમાં framework.ai) ❌ કોડમાં છે જ નહીં વાપરશો નહીં; પોતાનું Service બનાવી API કોલ કરો
@php ... @endphp ❌ અંદરનો કોડ પેજ પર છપાય છે વાપરશો નહીં; લોજિક Controller માં
auth સિવાયના middleware ❌ ચૂપચાપ અવગણાય છે રાઉટ પર ફક્ત auth વાપરો; બીજા માટે Controller માં શરત
ભાષા ફાઇલો (__(), trans()) ❌ ફક્ત કી પાછી આપે છે ટેક્સ્ટ સીધું લખો
config/mail.py / ઇમેઇલ મોકલવું ❌ સુવિધા નથી Django send_mail જાતે
daily(at="13:30") ❌ મિનિટ ≠ 0 હોય તો ખોટું cron("30 13 * * *")
Validation: boolean/string/unique/date/url ❌ નથી જાતે if થી ચકાસો
min/max સંખ્યા માટે ⚠️ અક્ષર ગણે છે જાતે ચકાસો
ડેટાબેઝ ફાઇલ ખોટી જગ્યાએ (aipostify મુખ્ય ફોલ્ડરમાં) ⚠️ .env ની બેવડી DB_DATABASE સ્ટેપ 3 માં સુધાર્યું
migrate:rollback ⚠️ બધી migration પાછી ખેંચે ફક્ત શીખવા માટે
Queue માં 2+ worker ⚠️ એક જ કામ બે વાર એક જ worker
db:check, storage:link વગેરેના લીલા સંદેશમાં [...] ⚠️ Linux/Mac પર ક્રેશ થઈ શકે સંદેશની ભૂલ; કામ સામાન્ય રીતે થઈ ગયું હોય
તૈયાર /admin પેજ ❌ URL જોડેલું નથી નથી

🩹 પેચ A – Flash / Error / Old સંદેશ ચાલુ કરો (3 નાના ફેરફાર)

ફાઇલ: framework/view/helpers.py ખોલો અને નીચે મુજબ 3 જગ્યાએ ફેરફાર કરો. (કારણ: middleware આ કિંમતો session માંથી કાઢીને request માં મૂકે છે, પરંતુ helper હજી session માં શોધે છે.) આ ફેરફાર મેં ચલાવી ચકાસ્યો છે: ભૂલ-સંદેશ, જૂનું લખાણ અને ફ્લેશ ત્રણે દેખાય છે.

1) helper_old માં: આ લાઇન:

જૂની લાઇન
old_data = request.session.get("old", {})

ની જગ્યાએ આ લાઇન મૂકો:

નવી લાઇન (પેચ)
old_data = getattr(request, "old", None) or request.session.get("old", {})

2) helper_errors માં: આ લાઇન:

જૂની લાઇન
errs = request.session.get("errors", {})

ની જગ્યાએ આ લાઇન મૂકો:

નવી લાઇન (પેચ)
errs = getattr(request, "errors", None) or request.session.get("errors", {})

3) helper_session માં: return request.session.get(key, default) ની પહેલાં આ ઉમેરો:

નવો ઉમેરો (પેચ)
if key == "flash" and getattr(request, "flash", None):
    return request.flash

સેવ કર્યા પછી સર્વર ફરી શરૂ કરો.

13

એક પાનાની ચીટશીટ

ઉપર જાઓ

નવી એપ બનાવવાના 6 પગલાં (હંમેશા આ જ ક્રમ)

6 Steps
1. app/models/xyz.py            → ડેટાનાં ફીલ્ડ લખો
2. python artisan migrate       → ટેબલ બને
3. python artisan make:controller XyzController
4. routes/web.py                → Route.resource("xyz", "XyzController")
5. resources/views/xyz/*.ptl    → index, create, show
6. python artisan serve         → બ્રાઉઝરમાં ખોલો

રોજના કમાન્ડ

Daily Commands
python artisan serve                  # સર્વર ચાલુ
python artisan migrate                # ડેટાબેઝ અપડેટ
python artisan route:list             # બધા એડ્રેસ
python artisan tinker                 # ડેટા સાથે રમો
python artisan view:check             # ટેમ્પ્લેટ ભૂલ શોધો
python artisan test                   # ટેસ્ટ ચલાવો

Controller સૂત્રો

Controller Cheats
self.render(request, "posts.index", {"posts": Post.all()})
self.redirect("posts.index")
self.back(request, "/")
self.json({"ok": True})
data = self.validate(request, {"title": "required|min:3"})
request.session["flash"] = {"message": "સેવ!", "level": "success"}

View સૂત્રો

View Cheats
{{ x }}   @if(x) @endif   @foreach(a in b) @endforeach
@extends('layouts.app')   @section('content') @endsection
@csrf   @method('DELETE')   {{ old('x') }}   @error('x') {{ message }} @enderror
{{ route('name', id=1) }}   {{ asset('css/app.css') }}   <x-alert type="info">..</x-alert>
14

HTML ડોક્યુમેન્ટ ડિઝાઇન & ચકાસણી યાદી

ઉપર જાઓ

(આ ભાગ HTML બનાવનાર માટે છે. આ ગાઇડનું લખાણ અક્ષરશઃ વાપરવામાં આવ્યું છે, સામગ્રી ઘટાડી નથી.)

ધ્યેય: પ્રોગ્રામિંગ ન જાણનાર પણ સમજે તેવી એક જ HTML ફાઇલ (documentation.html), કોઈ બાહ્ય ઇન્ટરનેટ પર નિર્ભર નહીં (Google Fonts સિવાય).

ચકાસણી યાદી (Audit Checklist)

✅ બધા કોડ બ્લોકનું "કોપી" બટન કાર્યરત છે (ક્લિક પર "કોપી થયું ✓" ફીડબેક સાથે)
✅ સર્ચ બોક્સ ગુજરાતી શબ્દો (દા.ત. "ડિલીટ", "ભૂલ") અને અંગ્રેજી બંને ફિલ્ટર કરે છે
✅ મોબાઇલ (360px) પર હેમ્બર્ગર મેનુ, સંપૂર્ણ રિસ્પોન્સિવ ટેબલ અને સાઇડબાર
✅ ડાર્ક અને લાઇટ બંને મોડમાં આઇકોન્સ, બેકગ્રાઉન્ડ અને સ્પષ્ટ કોન્ટ્રાસ્ટ સેટિંગ
✅ {{ }}, @if, @csrf જેવા PTL ચિહ્નો કોડ બ્લોકમાં સુરક્ષિત HTML entities સાથે યોગ્ય દેખાય છે
✅ વિભાગ 5 માં પૂર્ણ થતા સ્ટેપ્સ localStorage માં સચવાય છે
*આ ગાઇડ AIPostify v1.1 ના કોડ સામે ચકાસેલી છે. ફ્રેમવર્કમાં સુધારા થાય ત્યારે આ ગાઇડના સંબંધિત ભાગો અપડેટ કરો.*