ספרינט 1

שלבי ביצוע

cd backend

# שלב 1: אתחול Alembic
alembic init migrations

# שלב 2: עדכון migrations/env.py
# מצאו את השורה: target_metadata = None
# החליפו ב:
from app.db.base import Base
target_metadata = Base.metadata

# שלב 3: עדכון alembic.ini
# מצאו: sqlalchemy.url = driver://user:pass@localhost/dbname
# החליפו ב:
sqlalchemy.url = sqlite:///./app.db

# שלב 4: יצירת migration
alembic revision --autogenerate -m "initial"

# שלב 5: הרצה
alembic upgrade head

✅ Definition of Done

• alembic upgrade head רץ ללא שגיאות
• קובץ migration קיים ב-migrations/versions/
• GET /api/v1/health מחזיר 200
• PR עבר review של מפתחת שנייה + מוזג

קובץ לעריכה: backend/app/services/auth_service.py

מחפשות raise NotImplementedError ומחליפות ב-לוגיקה האמיתית.

register(db, data) — יצירת משתמש חדש

def register(db: Session, data: RegisterRequest) -> dict:
    # 1. בדוק שהמייל לא קיים
    if db.query(User).filter(User.email == data.email).first():
        raise HTTPException(400, "Email already registered")

    # 2. צור OTP
    otp = _generate_otp()
    otp_expires = datetime.utcnow() + timedelta(minutes=settings.OTP_EXPIRE_MINUTES)

    # 3. שמור משתמש
    user = User(
        email=data.email,
        password_hash=get_password_hash(data.password),
        display_name=data.display_name,
        otp_code=otp,
        otp_expires_at=otp_expires,
        account_status=AccountStatus.PENDING_OTP,
    )
    db.add(user)
    db.commit()

    # 4. שלח OTP במייל
    email_service.send_otp(user.email, otp)

    return {"message": "OTP sent", "email": user.email}

verify_otp(db, data) — אימות OTP

def verify_otp(db: Session, data: OtpVerifyRequest) -> dict:
    user = db.query(User).filter(User.email == data.email).first()
    if not user:
        raise HTTPException(404, "User not found")
    if user.otp_code != data.otp_code:
        raise HTTPException(400, "Invalid OTP")
    if user.otp_expires_at < datetime.utcnow():
        raise HTTPException(400, "OTP expired")

    user.account_status = AccountStatus.PENDING_APPROVAL
    user.otp_code = None
    db.commit()
    return {"message": "Email verified"}

✅ Definition of Done (בדיקה ב-Swagger: localhost:8000/docs)

• POST /api/v1/auth/register — משתמש נוצר ב-DB עם otp_code
• POST /api/v1/auth/verify-otp — סטטוס משתנה ל-PENDING_APPROVAL
• POST /api/v1/auth/resend-otp — OTP חדש נוצר
• מייל שגוי → 400, OTP פג → 400, הכל ברור

login(db, data) — כניסה + הנפקת tokens

def login(db: Session, data: LoginRequest) -> TokenResponse:
    user = db.query(User).filter(User.email == data.email).first()
    if not user or not verify_password(data.password, user.password_hash):
        raise HTTPException(401, "Invalid credentials")
    if user.account_status == AccountStatus.PENDING_OTP:
        raise HTTPException(403, "Please verify your email first")

    access  = _create_token(str(user.id), "access",  minutes=15)
    refresh = _create_token(str(user.id), "refresh", days=7)
    return TokenResponse(access_token=access, refresh_token=refresh)

✅ Definition of Done

• POST /api/v1/auth/login → מחזיר access_token + refresh_token
• סיסמה שגויה → 401
• משתמש שלא אימת OTP → 403 עם הסבר
• POST /api/v1/auth/refresh → access_token חדש

קובץ לעריכה: backend/app/api/v1/endpoints/auth.py

כל endpoint מחזיר כרגע raise HTTPException(status_code=501). מחברות ל-service:

@router.post("/register")
def register(data: RegisterRequest, db: Session = Depends(get_db)):
    return auth_service.register(db=db, data=data)

@router.post("/verify-otp")
def verify_otp(data: OtpVerifyRequest, db: Session = Depends(get_db)):
    return auth_service.verify_otp(db=db, data=data)

@router.post("/login", response_model=TokenResponse)
def login(data: LoginRequest, db: Session = Depends(get_db)):
    return auth_service.login(db=db, data=data)

# + resend-otp, refresh

✅ Definition of Done

• זרימה שלמה ב-Swagger: register → verify-otp → login → GET /users/me
• אף endpoint לא מחזיר 501

הגדרת Mailtrap

# backend/.env
SMTP_HOST=sandbox.smtp.mailtrap.io
SMTP_PORT=2525
SMTP_USER=<מ-Mailtrap>
SMTP_PASSWORD=<מ-Mailtrap>
SMTP_FROM=noreply@anu-banecha.local

קובץ לעריכה: backend/app/services/email_service.py

def send_otp(to_email: str, otp: str) -> None:
    if not settings.SMTP_HOST:
        # dev fallback — intentional
        logger.info(f"[DEV EMAIL] OTP for {to_email}: {otp}")
        return

    msg = MIMEMultipart()
    msg["From"]    = settings.SMTP_FROM
    msg["To"]      = to_email
    msg["Subject"] = "קוד האימות שלך — אנו בניך"
    msg.attach(MIMEText(f"קוד האימות שלך: {otp}\nתוקף: 10 דקות.", "plain"))

    with smtplib.SMTP(settings.SMTP_HOST, settings.SMTP_PORT) as server:
        server.login(settings.SMTP_USER, settings.SMTP_PASSWORD)
        server.sendmail(settings.SMTP_FROM, to_email, msg.as_string())

✅ Definition of Done

• OTP מגיע ל-inbox ב-Mailtrap (לא רק ב-console)
• ללא SMTP_HOST — ממשיך לעבוד (מדפיס לconsole)

1. error-display (חדש לגמרי)

// frontend/src/app/shared/components/error-display/error-display.component.ts
@Component({
  standalone: true,
  selector: 'app-error-display',
  template: `
    @if (message()) {
      <div class="error-box">⚠️ {{ message() }}</div>
    }
  `,
  styles: [`
    .error-box {
      background: #fff5f5; border: 1px solid #fc8181;
      color: #c53030; border-radius: 8px;
      padding: 12px 16px; font-size: 14px;
    }
  `]
})
export class ErrorDisplayComponent {
  message = input<string>('');
}

2. loading-spinner (עריכה — הוספת message)

// frontend/src/app/shared/components/loading-spinner/loading-spinner.component.ts
// הוסיפו ל-class הקיים — אל תמחקו את size:
message = input<string>('');

/* בtemplate — הוסיפו מתחת לאייקון הספינר: */
@if (message()) {
  <p class="spinner-message">{{ message() }}</p>
}

✅ Definition of Done

• error-display קיים, standalone, מקבל message signal input
• loading-spinner מקבל גם size וגם message
• אין @Input() בשום מקום — רק input()
• אין *ngIf — רק @if

API שנדרש

title        = input<string>('האם אתה בטוחה?');
message      = input<string>('');
confirmLabel = input<string>('אישור');
cancelLabel  = input<string>('ביטול');
confirmed    = output<void>();
cancelled    = output<void>();

✅ Definition of Done

• מוצג מעל שאר התוכן (overlay כהה)
• "אישור" → event confirmed
• "ביטול" / לחיצה מחוץ → event cancelled
• standalone, signals, @if

API שנדרש

acceptedTypes = input<string>('image/*,.pdf');
maxSizeMB     = input<number>(5);
label         = input<string>('בחרי קובץ');
fileSelected  = output<File>();
uploadError   = output<string>();

תכונות חובה

• לחיצה לבחירת קובץ
• Preview לתמונות / שם קובץ ל-PDF
• ולידציה: קובץ גדול מדי → uploadError.emit("הקובץ גדול מ-5MB")
• ולידציה: סוג לא מותר → uploadError.emit("סוג קובץ לא נתמך")
• כפתור "הסר" לאחר בחירה

✅ Definition of Done

• בחירת תמונה → preview מוצג
• בחירת PDF → שם הקובץ מוצג
• קובץ גדול / סוג שגוי → הודעת שגיאה ברורה
• standalone, signals

קובץ לעריכה: frontend/src/app/core/services/auth.service.ts

תבנית

login(data: LoginRequest): Observable<TokenResponse> {
  return this.apiService.post<TokenResponse>('/api/v1/auth/login', data).pipe(
    tap(tokens => this.saveTokens(tokens))
  );
}

logout(): void {
  this.clearTokens();
  this.router.navigate(['/login']);
}

✅ Definition of Done

• כל 5 פונקציות מממשות HTTP אמיתי (לא throw)
• login() שומר tokens → getAccessToken() מחזיר אותם
• logout() מנקה + מנתב ל-/login

תיקון 1 — auth.guard.ts (שורה 10)

// ❌ לפני:
return this.router.createUrlTree(['/home']);

// ✅ אחרי:
return this.router.createUrlTree(['/login']);

תיקון 2 — auth.interceptor.ts (הוספת 401)

export const authInterceptor: HttpInterceptorFn = (req, next) => {
  const auth = inject(AuthService);  // ← inject בתוך הפונקציה!

  const token = auth.getAccessToken();
  const authReq = token
    ? req.clone({ setHeaders: { Authorization: `Bearer ${token}` } })
    : req;

  return next(authReq).pipe(
    catchError((err: HttpErrorResponse) => {
      if (err.status === 401) {
        return auth.refreshToken().pipe(
          switchMap(() => next(req.clone({
            setHeaders: { Authorization: `Bearer ${auth.getAccessToken()}` }
          })))
        );
      }
      return throwError(() => err);
    })
  );
};

✅ Definition of Done

• כניסה ל-/forum ללא token → redirect ל-/login (לא /home)
• access token פג → מתרענן אוטומטית ומנסה שוב
• inject() נמצא בתוך הפונקציה — לא ברמת המודול

onSubmit() — מה להוסיף

onSubmit(): void {
  if (this.form.invalid) return;
  this.isLoading.set(true);
  this.errorMessage.set('');

  this.authService.login(this.form.value as LoginRequest).subscribe({
    next: () => this.router.navigate(['/home']),
    error: (e: HttpErrorResponse) => {
      this.errorMessage.set(e.error?.detail ?? 'שגיאה בהתחברות');
      this.isLoading.set(false);
    }
  });
}

Template HTML (login.component.html)

<form [formGroup]="form" (ngSubmit)="onSubmit()">
  <h1>כניסה</h1>

  <input formControlName="email"    type="email"    placeholder="אימייל" />
  <input formControlName="password" type="password" placeholder="סיסמה" />

  <app-error-display [message]="errorMessage()" />

  @if (isLoading()) {
    <app-loading-spinner message="מתחברת..." />
  } @else {
    <button type="submit" [disabled]="form.invalid">כניסה</button>
  }

  <a routerLink="/register">אין לך חשבון? הירשמי</a>
</form>

✅ Definition of Done

• פרטים נכונים → navigate ל-/home
• פרטים שגויים → app-error-display מציג שגיאה
• loading → spinner מוצג, כפתור מסתתר
• Enter → שולח טופס

3 שלבים + OTP

onStep2Submit() — הלוגיקה הכי חשובה

onStep2Submit(): void {
  this.isLoading.set(true);
  this.authService.register(this.buildPayload()).subscribe({
    next: () => this.currentStep.set('otp'),   // → מסך OTP
    error: (e) => {
      this.errorMessage.set(e.error?.detail ?? 'שגיאה');
      this.isLoading.set(false);
    }
  });
}

✅ Definition of Done

• שלב 1 — ולידציה: שדות חובה לא ריקים
• שלב 2 — POST register עובד → OTP נשלח
• מסך OTP → verifyOtp() → מגיע לשלב 3
• שלב 3 — 3 קבצים נבחרים ומוצגים (app-file-upload)
• כפתור "חזור" עובד בין שלבים

דף הבית — stub עם ניווט לפי תפקיד

ניווט לפי תפקיד — בtemplate

user = this.authService.currentUser();

@if (user()?.role === 'Admin') {
  <button routerLink="/admin">לוח ניהול</button>
} @else if (user()?.role === 'Moderator') {
  <button routerLink="/moderator">דיווחים ממתינים</button>
} @else {
  <button routerLink="/forum">לפורום</button>
}

Header — שם משתמש + כפתור יציאה

<header>
  <span class="logo">אנו בניך</span>
  <span class="username">{{ user()?.display_name }}</span>
  <button (click)="authService.logout()">יציאה</button>
</header>

✅ Definition of Done

• Header: שם משתמש + יציאה → מנקה session + /login
• דף הבית: תוכן שונה לפי תפקיד
• currentUser() קרוא מ-authService (signal)

שלב 4 של ההרשמה: שלושה checkboxes:

• קראתי ואני מסכימה לתנאי השימוש
• אני מסכימה לעיבוד מידע אישי
• אני מצהירה שהמסמכים שהעלאתי אמיתיים

כפתור "סיום" פעיל רק כשכל שלושה מסומנים.