refactor(docs): update project documentation and remove outdated files

Author: Yuval

01-Database/ResetData.sql

@@ -44,5 +44,5 @@ DBCC CHECKIDENT ('city', RESEED, 0);
 
 PRINT 'All user data cleared. Identity columns reset.';
 PRINT 'event_type rows preserved.';
-PRINT 'Run SeedDemoData.sql to re-populate demo data if needed.';
+PRINT 'Register a new user through the app to re-populate.';
 GO

03-Client/ATTRIBUTIONS.md

@@ -4,15 +4,28 @@
 
 GroundShare is a Hebrew (RTL), mobile-first web app for urban planning transparency. Users view a map of their neighborhood, see official planning data (construction permits, road work, city plans from Tel Aviv GIS / iplan / mavat), and crowdsource community reports (noise, blockages, etc.). Features include address comparison, favorites, reviews, voting, and a gamification system (XP/streaks).
 
+## Deployment
+
+Production is live on Azure (Israel Central):
+- Backend API: `https://app-groundshare-api.azurewebsites.net`
+- Frontend: Azure App Service (Node host serving the Vite `dist/` bundle)
+- Database: Azure SQL (`sql-groundshare-il.database.windows.net`)
+- Secrets: Azure Key Vault via Managed Identity — no secrets in env vars
+
 ## Project structure
 
 ```
-01-Database/        SQL Server schema + seed data (GroundShareDB.sql, SeedDemoData.sql)
+01-Database/        SQL Server schema + stored procedures (GroundShareDB.sql)
+                    ResetData.sql — wipes user data while keeping schema + lookups
 02-Server/          C# ASP.NET Core 8 Web API
-  Controllers/      14 controllers (Auth, Users, Events, Geo, Locations, Favorites, etc.)
+  Controllers/      18 controllers (Auth, Users, Events, Geo, Locations, Favorites,
+                    Ai, Comments, Comparisons, Files, Health, Notifications, etc.)
   DAL/              Data access — pure ADO.NET, NO Entity Framework. All DB calls use
                     SqlConnection + SqlCommand, mostly via stored procedures (sp_*)
   BL/               Request/response DTOs (LoginRequest, CreateEventRequest, User, etc.)
+  Services/         Business logic (auth, storage, AI, rate limiting)
+  Middleware/       Exception handling, security headers, request logging
+  Validators/       FluentValidation rules for request DTOs
 03-Client/          React 18 + TypeScript + Vite
   src/app/
     components/     Screen components (MainScreen, CreateEventScreen, etc.)
@@ -31,8 +44,9 @@ reference/          Design specs: screen mockups (screens.pdf), workflow diagram
 ## Running locally
 
 ```bash
-# Database: Run 01-Database/GroundShareDB.sql then SeedDemoData.sql in SSMS
-# Demo account: demo@groundshare.co.il / Demo1234!
+# Database: Run 01-Database/GroundShareDB.sql in SSMS against local SQL Express.
+# DB starts empty — register your first user through the app's Register screen.
+# To reset between tests: run 01-Database/ResetData.sql
 
 # Backend (port 5227)
 cd 02-Server

03-Client/README.md

@@ -1,112 +1,70 @@
-GroundShare - Master AI Development Prompt & README.md
-🎯 Project Overview
-GroundShare is a mobile application designed to bridge the gap between complex official urban planning data and local community knowledge. It provides a transparent, map-based interface that aggregates municipal data (GIS, planning documents, infrastructure work) and crowdsourced community reports. The app empowers renters, homeowners, and real estate investors to make informed decisions and track real-time changes in their neighborhoods.
+# GroundShare
 
-Target Language & UI: Strictly Hebrew (RTL - Right to Left).
-Target Device: Google Pixel 7 (Android), strictly Mobile.
+Hebrew (RTL), mobile-first web app for urban planning transparency in Israel.
+Users view a map of their neighborhood, see official municipal planning data
+(construction permits, road work, city plans from Tel Aviv GIS, iplan, and
+mavat), and crowdsource community reports (noise, blockages, etc.).
 
-🏗️ System Architecture & Tech Stack
-The project follows a strict 3-tier architecture.
+Features: address comparison, favorites, reviews, voting, notifications, and a
+gamification system (XP / streaks).
 
-1. Client-Side (Frontend)
-Framework: React Native (Expo recommended for rapid development, or bare CLI if native modules demand it).
+## Live
 
-State Management: Zustand or Redux Toolkit.
+- **Frontend**: hosted on Azure App Service (Israel Central)
+- **Backend API**: `https://app-groundshare-api.azurewebsites.net`
+- **Database**: Azure SQL Database (`sql-groundshare-il.database.windows.net`)
 
-Navigation: React Navigation (Stack and Bottom Tabs).
+## Tech stack
 
-Maps: react-native-maps (with custom markers and clustering).
+| Layer | Stack |
+|---|---|
+| Frontend | React 18, TypeScript, Vite, Tailwind CSS, React Router 7, `@vis.gl/react-google-maps` |
+| Mobile shell | Capacitor (iOS + Android) wrapping the Vite build |
+| Backend | ASP.NET Core 8 Web API (C#), pure ADO.NET (no EF Core), FluentValidation |
+| Database | Microsoft SQL Server with stored procedures |
+| Cloud | Azure App Service, Azure SQL, Azure Blob Storage, Azure Key Vault |
+| Auth | JWT (access 15min / refresh 14d with rotation), Google OAuth, BCrypt |
 
-Styling: StyleSheet, styled-components, or NativeWind (Tailwind). Must strictly enforce RTL layout.
+## Project layout
 
-2. Server-Side (Backend)
-Framework: C# with ASP.NET Core Web API (.NET 8+).
+```
+01-Database/   SQL schema + stored procedures (GroundShareDB.sql)
+02-Server/     ASP.NET Core 8 Web API (Controllers / DAL / BL / Services)
+03-Client/     React + Vite frontend + Capacitor native shell
+reference/     Design specs, screen mockups, Hebrew spec docs
+scripts/       Git hooks (gitleaks pre-commit)
+.github/       CI/CD workflows
+```
 
-Architecture: Clean Architecture or N-Tier (Controllers, Services, Repositories).
+## Documentation
 
-ORM: Entity Framework Core (for basic CRUD) & Dapper (for executing complex Stored Procedures).
+- [SETUP.md](SETUP.md) — local development environment setup
+- [DEPLOY.md](DEPLOY.md) — Azure deployment guide
+- [SECURITY.md](SECURITY.md) — security architecture and policy
+- [CLAUDE.md](CLAUDE.md) — AI assistant context (architecture patterns, conventions)
 
-Scraping/Integration: HtmlAgilityPack or PuppeteerSharp for scraping external governmental sites.
+## Quick start
 
-AI Integration: Integration with an LLM API (OpenAI/Gemini) for the "Smart Comparison" text generation.
+```bash
+# Database: run 01-Database/GroundShareDB.sql in SSMS against local SQL Express
 
-3. Database
-Engine: Microsoft SQL Server. or firebase more likly to the active app
+# Backend (port 5227)
+cd 02-Server && dotnet run
 
-Structure: Relational tables based on the provided ERD, utilizing explicit Primary/Foreign Keys.
+# Frontend (port 5173)
+cd 03-Client && npm install && npm run dev
+```
 
-Logic: Heavy use of Stored Procedures for complex queries (e.g., calculating the GroundShareScore, geospatial proximity searches).
+Backend requires `02-Server/appsettings.Development.json` (gitignored) with local
+SQL connection string, JWT key, and Google Maps API key. See
+[SETUP.md](SETUP.md) for the full config template.
 
-📂 Directory Structure
-The workspace must be organized exactly into these three root folders:
+## Security
 
-Plaintext
-/GroundShare_Project
-│
-├── /Client          # React Native application
-│   ├── /src
-│   │   ├── /assets        # Images, fonts
-│   │   ├── /components    # Reusable UI components (Buttons, Inputs, Modals)
-│   │   ├── /screens       # Page-level components (Login, Map, Report, Compare)
-│   │   ├── /navigation    # React Navigation setup
-│   │   ├── /services      # Axios API calls
-│   │   ├── /store         # State management
-│   │   └── /utils         # Helpers, constants, RTL config
-│
-├── /Server          # C# .NET Web API
-│   ├── /Controllers
-│   ├── /Models            # DTOs and Entities
-│   ├── /Services          # Business Logic, Scraping Services
-│   ├── /Data              # DbContext, Repositories
-│   └── /Integrations      # External API handlers (LLM, Gov APIs)
-│
-└── /Database        # SQL Scripts
-    ├── /Tables            # CREATE TABLE scripts
-    ├── /Procedures        # CREATE PROCEDURE scripts (e.g., CalculateScore)
-    └── /SeedData          # Mock data for testing
-⚙️ Core Business Logic & Features
-1. Map & Data Aggregation
-Official Data Integration:
+- All secrets live in Azure Key Vault in production (Managed Identity, no env vars)
+- Pre-commit hook runs `gitleaks protect --staged` to block accidental commits
+- Dependabot + CI scan every PR for vulnerable dependencies
 
-Tel Aviv GIS: Scrape/pull data regarding infrastructure work. [Reference URL provided in prompt].
+## License
 
-Mavat (מנהל התכנון): Scrape Israeli planning documents. Use the Meirim open-source project as an architectural reference for parsing this complex data.
-
-GovMap/Gov API: Use Israeli government APIs for address autocomplete.
-
-Community Reports (Crowdsourcing): Users can report issues (noise, blockages) with images and coordinates.
-
-2. The Smart Element: "GroundShareScore" (AI Comparison)
-Users can compare up to 3 addresses.
-
-The system calculates a score (0-100) based on 3 vectors: Official Planning (GIS/Mavat), Community Reports, and User Reviews.
-
-AI LLM Integration: The backend must send these raw calculated metrics to an LLM to generate a natural, conversational Hebrew summary explaining the pros, cons, and warnings for each address.
-
-3. Specific Business Rules (Strict Constraints)
-Report Lifecycle: A community event expires after 3 days. The system must prompt the creator to verify if it's still active; otherwise, status changes to "Expired".
-
-Verification: An event receives a "Verified" badge (Blue Tick) only after 5 different users confirm it.
-
-Security: Passwords must be hashed. The frontend MUST NOT hold any external API keys (Mavat, OpenAI, GIS). All 3rd party integrations must route through the C# Server. Use JWT for authentication.
-
-🚀 Execution Instructions for the AI
-Phase 1 Focus: The React Native Client
-As per the human developer's request, initiate development with the Client folder.
-
-Initialize: Set up the React Native project with RTL (Hebrew) support enabled.
-
-Navigation: Scaffold the navigation map based on A4 Screens WorkFlow.jpg (Auth Stack -> Main Bottom Tabs: Search/Map, Favorites, Add Report, Comparison, Personal Area).
-
-Screens Development: Begin drafting the UI components exactly as shown in screens.pdf (Login/Registration, Map View with bottom sheets, Event Creation Form, AI Comparison Dashboard).
-
-Mocking: Create a mockData.ts file to simulate backend responses so the UI can be built and tested completely independently of the server.
-
-Implied Modern Best Practices to Enforce:
-Frontend Security: Use .env variables for the internal API base URL. Do not expose sensitive endpoints.
-
-Error Handling: Implement global error boundaries in React Native and a global exception middleware in the .NET API.
-
-Geospatial Data: Ensure the map uses standard lat/lng coordinates and standardizes them before sending them to the backend. The SQL Server should eventually use geography spatial data types for radius-based queries.
-
-Performance: Optimize map rendering so clustering is used when hundreds of community reports or GIS points are loaded.
+Private project. All rights reserved.