AIPostify – નવા શીખનાર માટે સંપૂર્ણ ગાઇડ
પ્રોગ્રામિંગ ન આવડતું હોય તો પણ Python માં વેબ એપ બનાવો
🎯 આ ડોક્યુમેન્ટ કોના માટે છે? જેને પ્રોગ્રામિંગનો અનુભવ નથી અથવા ઓછો છે. દરેક ફીચર "શું છે → ક્યારે વાપરવું → કેવી રીતે → ઉદાહરણ → સામાન્ય ભૂલ" એ ક્રમમાં સમજાવ્યું છે.
💡 ખાસ નોંધ: આ ગાઇડના બધા ઉદાહરણ મેં ખરેખર ચલાવીને ચકાસ્યા છે. જે ફીચર હાલ બરાબર કામ નથી કરતાં તેને ⚠️ ચિહ્નથી અલગ બતાવ્યા છે (વિભાગ 12), જેથી તમે અટકો નહીં.
શબ્દોનો સરળ અર્થ (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 | એકવાર બતાવીને અદૃશ્ય થતો સંદેશ ("સેવ થઈ ગયું!"). |
AIPostify શું છે? (રેસ્ટોરન્ટનું ઉદાહરણ)
AIPostify એટલે Python (Django ના એન્જિન પર) બનેલું તૈયાર ફ્રેમવર્ક, જેમાં PHP ના
Laravel જેવી સરળતા મળે છે. તમારે જટિલ સેટિંગ્સ (settings.py, urls.py)
કરવી પડતી નથી; ફક્ત કમાન્ડ ચલાવો, થોડું લખો અને વેબસાઇટ તૈયાર.
🍽️ રેસ્ટોરન્ટનું ઉદાહરણ (MVC સમજો)
જ્યારે તમે બ્રાઉઝરમાં http://127.0.0.1:8000/posts ખોલો ત્યારે:
ગ્રાહક (તમે/બ્રાઉઝર)
│ "મને પોસ્ટની યાદી જોઈએ"
▼
┌─────────────┐
│ ROUTE │ રિસેપ્શન: "આ ઓર્ડર PostController ને આપો"
└─────┬───────┘
▼
┌─────────────┐
│ CONTROLLER │ વેઇટર/મેનેજર: રસોડામાંથી સામગ્રી લાવે
└─────┬───────┘
▼
┌─────────────┐
│ MODEL │ રસોડું/ભંડાર: ડેટાબેઝમાંથી પોસ્ટ કાઢી આપે
└─────┬───────┘
▼
┌─────────────┐
│ VIEW │ પ્લેટ: સજાવીને પેજ તૈયાર (.ptl ફાઇલ)
└─────┬───────┘
▼
ગ્રાહકને પેજ મળે ✅
AIPostify માં શું શું મળે છે:
artisanકમાન્ડ (ફાઇલો જાતે બનાવે)- Routes (રસ્તા), Controllers, Models, Views (PTL)
- ડેટાબેઝ (SQLite અથવા MySQL) + Migration + Seeder
- ફોર્મ Validation, CSRF સુરક્ષા
- Queue (પાછળનાં કામ) અને Scheduler (સમયસર કામ)
- Tinker (ડેટા સાથે રમવા માટે શેલ), Test, Components, Layouts
શરૂ કરતા પહેલાં શું જોઈએ
| વસ્તુ | કેવી રીતે મેળવવું |
|---|---|
| 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 ચાલે છે કે નહીં તે ચકાસો
python --version
Python 3.x.x દેખાય તો બરાબર. ન દેખાય તો py --version અથવા
python3 --version અજમાવો. (પછીના બધા કમાન્ડમાં python ની જગ્યાએ તે જ
વાપરો.)
ઇન્સ્ટોલ અને પહેલી વાર ચલાવવું
પ્રોજેક્ટ ફોલ્ડર (જ્યાં artisan ફાઇલ છે) માં Terminal ખોલીને ક્રમશઃ ચલાવો:
સ્ટેપ 1: જરૂરી પેકેજ ઇન્સ્ટોલ
pip install -r requirements.txt
અર્થ: Django, rich, pytest વગેરે જરૂરી સાધનો ડાઉનલોડ કરે છે.
સ્ટેપ 2: .env ફાઇલ બનાવો
cp .env.example .env
(Windows માં: copy .env.example .env)
સ્ટેપ 3: ⚠️ .env ફાઇલ ખોલીને એક ભૂલ સુધારો (ખૂબ જરૂરી)
.env માં DB_DATABASE= બે વાર લખેલું હોય તો બીજી લાઇન
(DB_DATABASE=aipostify) પહેલીને દબાવી દે છે અને ડેટાબેઝ ફાઇલ ખોટી જગ્યાએ બને છે.
SQLite વાપરતા હો તો ફક્ત આ લાઇન રાખો અને MySQL વાળી
DB_DATABASE=aipostify લાઇન કાઢી નાખો (અથવા આગળ # લગાવો):
DB_CONNECTION=sqlite
DB_DATABASE=database/database.sqlite
# MySQL વાપરવું હોય ત્યારે જ આ લાઇન ખોલો:
# DB_DATABASE=aipostify
સ્ટેપ 4: સુરક્ષા કી બનાવો
python artisan key:generate
.env માં APP_KEY= નવી ગુપ્ત કી સાથે ભરાઈ જશે. (ફરી ચલાવશો તો જૂની કી
બદલાઈ જશે અને બધા લોગિન સેશન રદ થશે, તેથી એક જ વાર.)
સ્ટેપ 5: ડેટાબેઝ ટેબલ બનાવો
python artisan migrate
અંતે SUCCESS Database migrations applied successfully. દેખાવું જોઈએ.
સ્ટેપ 6: ડેમો ડેટા (વૈકલ્પિક)
python artisan db:seed
admin, demo). ⚠️ આ સરળ
પાસવર્ડવાળા છે, ફક્ત શીખવા માટે; વેબસાઇટ ઓનલાઇન મૂકતાં પહેલાં કાઢી નાખો.સ્ટેપ 7: સર્વર ચાલુ કરો
python artisan serve
બ્રાઉઝરમાં ખોલો: http://127.0.0.1:8000 → AIPostify નું Welcome પેજ દેખાશે 🎉
સર્વર બંધ કરવા: Terminal માં Ctrl + C.
artisan
કમાન્ડ ચલાવો. ફાઇલમાં ફેરફાર સેવ કરશો તો સર્વર જાતે રીલોડ થશે.✅ ચકાસો: બધું બરાબર છે?
python artisan db:check
python artisan route:list
route:list તમારા બધા વેબ-એડ્રેસનું ટેબલ બતાવે છે.
ફોલ્ડર નકશો – કઈ ફાઇલ ક્યાં મૂકવી
તમારો-પ્રોજેક્ટ/
├── 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/ માં કામ કરો. બાકીનું છોડી દો.
⭐ પહેલી પૂર્ણ વેબ એપ બનાવો: "પોસ્ટ બોર્ડ"
આપણે શું બનાવીશું: એવી વેબસાઇટ જેમાં યુઝર ✅ પોસ્ટ ઉમેરી શકે, ✅ યાદી જોઈ શકે, ✅ એક પોસ્ટ ખોલી શકે, ✅ પોસ્ટ ડિલીટ કરી શકે, અને ❌ ખાલી/ખૂબ ટૂંકું લખે તો ભૂલનો સંદેશ મળે.
પૂર્વશરત: વિભાગ 3 પૂરો કરેલો હોવો જોઈએ અને વિભાગ 12 નો પેચ A (flash/error સંદેશ માટે) લગાવેલો હોવો જોઈએ.
સ્ટેપ 1: Model બનાવો – ડેટાનું ટેબલ
ફાઇલ બનાવો: app/models/post.py
(python artisan make:model Post થી ફાઇલ બને છે, પછી તેની અંદર નીચે મુજબ
બદલો):
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: ટેબલ ડેટાબેઝમાં બનાવો
python artisan migrate
આ કમાન્ડ નવું મોડેલ જોઈને Migration ફાઇલ
(database/migrations/0002_post.py) જાતે બનાવી ડેટાબેઝમાં ટેબલ બનાવી દે
છે. ❗ Migration ફાઇલો ક્યારેય જાતે ડિલીટ ન કરશો.
સ્ટેપ 3: Controller બનાવો – મેનેજર
python artisan make:controller PostController પછી
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: Routes લખો – રસ્તા
ફાઇલ: 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: Views બનાવો – પેજની ડિઝાઇન
ફોલ્ડર resources/views/posts/ બનાવો અને તેમાં 3 ફાઇલો:
1) 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 – નવું ફોર્મ:
@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 – વિગત અને ડિલીટ:
@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: ચલાવો
python artisan serve
ખોલો http://127.0.0.1:8000/posts → "નવી પોસ્ટ" દબાવો → 2 અક્ષર લખીને સેવ કરો (ભૂલનો સંદેશ આવશે) → પછી સાચું લખો (યાદીમાં દેખાશે).
આ જ રીતે કોઈપણ એપ બને છે: Model → migrate → Controller → Route → View.
બીજા વિચારો: નોંધ-પુસ્તિકા, ટૂ-ડુ લિસ્ટ, ગ્રાહક યાદી, ઉત્પાદન કેટલોગ, હાજરી રજિસ્ટર.
ફીચર-બાય-ફીચર માર્ગદર્શિકા (1 થી 18)
1 Artisan – કમાન્ડથી ફાઇલો બનાવો
શું છે: હાથે ફાઇલ બનાવવાને બદલે કમાન્ડ લખો.
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
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 વગર સીધું લખવું (ટૂંકા કામ માટે):
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 માં છે. મુખ્ય ત્રણ:
{{ નામ }} ← કિંમત છાપો (સુરક્ષિત, આપમેળે HTML escape)
@if(શરત) ... @endif ← શરત
@foreach(x in યાદી) ... @endforeach ← લૂપ
Layout (સામાન્ય ઢાંચું): resources/views/layouts/app.ptl માં
મેનુ/ફૂટર લખો અને @yield('content') જ્યાં દરેક પેજનો ભાગ આવશે. દરેક પેજમાં:
@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 – ટેબલ બનાવવા/બદલવા
શું છે: મોડેલમાં ફેરફાર કર્યા પછી ડેટાબેઝને તે જણાવવાની રીત.
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 – ડેમો ડેટા
python artisan make:seeder PostSeeder
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 – ફોર્મ ચકાસણી
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 વગેરે નિયમો હજી બન્યા નથી.
સંદેશ ગુજરાતીમાં આપવા:
self.validate(request,
{"title": "required|min:3"},
{"title.required": "શીર્ષક લખવું જરૂરી છે.", "title.min": "ઓછામાં ઓછા 3 અક્ષર લખો."})
⚠️ યાદ રાખો: validate() ને હંમેશા
try/except ValidationError માં રાખો (ઉદાહરણ વિભાગ 5 માં).
10 Form Request – મોટા ફોર્મ માટે અલગ ફાઇલ
python artisan make:request StorePostRequest
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 માં:
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 લોગિન અને 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
@props(type='info')
<div class="alert alert-{{ type }}">{{ slot }}</div>
વાપરો (કોઈપણ પેજમાં):
<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 – પાછળ ચાલતું કામ
ક્યારે: ઇમેઇલ મોકલવો, રિપોર્ટ બનાવવો જેવા ધીમા કામ યુઝરને રાહ જોવડાવ્યા વગર કરવા.
- બનાવો:
python artisan make:job SendEmailJob app/jobs/send_email_job.pyમાંhandleની અંદર કામ લખો:
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 માંથી કામ લાઇનમાં મૂકો:
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
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 (મોટું લોજિક અલગ રાખવા):
python artisan make:service PaymentService
app/services/payment_service.py માં method લખો અને Controller માં ઉપયોગ કરો:
from app.services.payment_service import PaymentService
PaymentService().execute(amount=500)
પોતાનો artisan કમાન્ડ:
python artisan make:command SendWeeklySummary
બનેલી ફાઇલ: app/console/commands/send_weekly_summary_command.py. કમાન્ડનું નામ
ફાઇલની અંદર signature માં હોય છે, અને હાલ તે send:weekly:summary
(કોલન ત્રણ વાર) બને છે:
python artisan send:weekly:summary
તમે signature = "report:weekly" જેવું બદલી શકો છો. handle() માં કામ
લખો અને self.info("સંદેશ"), self.success(...),
self.error(...) વાપરો.
17 Tinker – ડેટા સાથે રમવાનું શેલ
python artisan tinker
>>> Post.create(title="ટેસ્ટ")
>>> Post.all().count()
>>> Post.find(1).delete()
બધા મોડેલ આપમેળે મળે છે. બહાર નીકળવા: exit().
18 Tests – ખાતરી કરવી કે બધું ચાલે છે
python artisan test
પોતાનો ટેસ્ટ 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) |
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-vscodetools/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 ફાઇલ.
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)
વારંવાર વપરાતા હેડર, ફૂટર અને નેવિગેશન માટે એક માસ્ટર લેઆઉટ બનાવો અને બાકીના પેજ તેમાં ઇન્જેક્ટ કરો.
<!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>
@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)
{{-- 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 ઓબ્જેક્ટ પૂરો પાડે છે જે ટેબલ, લિસ્ટ
અને અલ્ગોરિધમ્સ માટે અતિ ઉપયોગી છે.
{{-- 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)
{{-- ૧. ફક્ત લોગિન થયેલા વપરાશકર્તા માટે --}}
@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/ ફોલ્ડરમાં મૂકવામાં આવે છે.
@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>
@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)
{{-- ૧. ટેમ્પ્લેટમાં પ્યોર પાયથોન કોડ ચલાવવા માટે --}}
@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)
import,open,eval,exec,os,sysટેમ્પ્લેટમાં બ્લોક છે.__class__,__subclasses__જેવા અંડરસ્કોર એટ્રિબ્યુટ્સ અટકાવેલા છે.- ટેમ્પ્લેટમાં સીધું
env()ન વાપરશો, હંમેશાconfig()મારફતે સુરક્ષિત રીતે વેલ્યુ વાંચો. - મોટું બિઝનેસ લોજિક ક્યારેય ટેમ્પ્લેટમાં ન લખો — તે હંમેશા Controller કે Service માં જ હોવું જોઈએ.
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 | ❌ હાલ કામ કરતું નથી |
ડેટાબેઝ
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
સર્વર અને સાધનો
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
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
ડેટાબેઝ: SQLite ↔ MySQL
A. SQLite (શરૂઆત માટે સૌથી સરળ, કંઈ ઇન્સ્ટોલ નહીં)
.env:
DB_CONNECTION=sqlite
DB_DATABASE=database/database.sqlite
B. MySQL (XAMPP / સર્વર)
- XAMPP માં MySQL ચાલુ કરો.
.envમાં:
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=aipostify
DB_USERNAME=root
DB_PASSWORD=
DB_DATABASE લાઇન સાથે બેવડી ન રહે; એક જ
DB_DATABASE રાખો.
3. કમાન્ડ ચલાવો:
python artisan db:create # ડેટાબેઝ બનાવે
python artisan db:check # જોડાણ ચકાસે
python artisan migrate # ટેબલ બનાવે
પાછા SQLite પર આવવા: .env માં DB_CONNECTION=sqlite.
સામાન્ય ભૂલો અને ઉકેલ
| ભૂલ / લક્ષણ | કારણ | ઉકેલ |
|---|---|---|
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 વાપરો |
વેબસાઇટ ઓનલાઇન મૂકતાં પહેલાં (સુરક્ષા ચેકલિસ્ટ)
ઓનલાઇન મૂકતાં પહેલાં દરેકને ટિક કરો (તમારી પ્રગતિ આપમેળે બ્રાઉઝરમાં સચવાય છે):
⚠️ હાલ કામ ન કરતી બાબતો અને તેના ઉપાય
પ્રામાણિક યાદી જેથી તમે અટકો નહીં. આ બાબતો કોડ ચલાવીને ચકાસેલી છે:
| ફીચર | સ્થિતિ | ઉકેલ / વિકલ્પ |
|---|---|---|
| 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
સેવ કર્યા પછી સર્વર ફરી શરૂ કરો.
એક પાનાની ચીટશીટ
નવી એપ બનાવવાના 6 પગલાં (હંમેશા આ જ ક્રમ)
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 → બ્રાઉઝરમાં ખોલો
રોજના કમાન્ડ
python artisan serve # સર્વર ચાલુ
python artisan migrate # ડેટાબેઝ અપડેટ
python artisan route:list # બધા એડ્રેસ
python artisan tinker # ડેટા સાથે રમો
python artisan view:check # ટેમ્પ્લેટ ભૂલ શોધો
python artisan test # ટેસ્ટ ચલાવો
Controller સૂત્રો
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 સૂત્રો
{{ 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>
HTML ડોક્યુમેન્ટ ડિઝાઇન & ચકાસણી યાદી
(આ ભાગ HTML બનાવનાર માટે છે. આ ગાઇડનું લખાણ અક્ષરશઃ વાપરવામાં આવ્યું છે, સામગ્રી ઘટાડી નથી.)
ધ્યેય: પ્રોગ્રામિંગ ન જાણનાર પણ સમજે તેવી એક જ HTML ફાઇલ
(documentation.html), કોઈ બાહ્ય ઇન્ટરનેટ પર નિર્ભર નહીં (Google Fonts સિવાય).
ચકાસણી યાદી (Audit Checklist)
{{ }}, @if, @csrf જેવા PTL ચિહ્નો કોડ
બ્લોકમાં સુરક્ષિત HTML entities સાથે યોગ્ય દેખાય છે
localStorage માં સચવાય છે