Upload 10 files

.gitignore

@@ -0,0 +1,52 @@
+# Secrets - VIKTIGT: Lägg aldrig till secrets i Git!
+.streamlit/secrets.toml
+*.json
+secrets/
+credentials/
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Logs
+*.log
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Streamlit
+.streamlit/config.toml

GITHUB_FILER.md

@@ -0,0 +1,71 @@
+# 📦 FILER FÖR GITHUB REPO
+
+## ✅ Dessa 8 filer ska läggas i ditt GitHub repo:
+
+1. **app.py** - Huvudapplikationen (11 KB)
+2. **requirements.txt** - Python dependencies (68 bytes)
+3. **.gitignore** - Skyddar dina secrets (476 bytes)
+4. **README.md** - Fullständig dokumentation (6.6 KB)
+5. **HUGGINGFACE_SETUP.md** - Guide för Hugging Face (5.8 KB)
+6. **PROJEKTSTRUKTUR.md** - Översikt (2.3 KB)
+7. **START_HÄR.md** - Snabbstart (4.5 KB)
+8. **secrets.toml.template** - Mall för secrets (757 bytes)
+
+**Total storlek:** ~31 KB
+
+---
+
+## 🚀 Snabbkommando för Git:
+
+```bash
+# I din projektmapp:
+git init
+git add app.py requirements.txt .gitignore README.md HUGGINGFACE_SETUP.md PROJEKTSTRUKTUR.md START_HÄR.md secrets.toml.template
+git commit -m "Initial commit: Områdesdata Manager"
+git remote add origin https://github.com/DITT-ANVÄNDARNAMN/omradesdata-manager.git
+git branch -M main
+git push -u origin main
+```
+
+---
+
+## ❌ Lägg ALDRIG till dessa:
+
+- `.streamlit/secrets.toml` (dina riktiga secrets)
+- `*.json` (Service Account nycklar)
+- `venv/` (virtuell miljö)
+- `__pycache__/` (Python cache)
+
+**.gitignore skyddar dig automatiskt!**
+
+---
+
+## 📋 Verifiering:
+
+Efter push till GitHub, kontrollera att:
+
+✅ Alla 8 filer är synliga i ditt repo
+✅ .gitignore fungerar (inga secrets synliga)
+✅ README.md visas på repots startsida
+
+---
+
+## 🔗 Nästa steg efter GitHub push:
+
+1. **Streamlit Cloud:** share.streamlit.io
+   - Välj ditt repo
+   - Lägg till secrets i web-interfacet
+
+2. **Hugging Face:** huggingface.co/spaces
+   - Skapa Space med Streamlit SDK
+   - Lägg till GOOGLE_CREDENTIALS och SHEET_ID i secrets
+
+---
+
+## 💡 Tips:
+
+- Gör repot **Private** om data är känslig
+- Lägg till en LICENSE-fil om du vill
+- Uppdatera README.md med dina egna anteckningar
+
+Lycka till! 🎉

HUGGINGFACE_SETUP.md

@@ -0,0 +1,211 @@
+# 🚀 Snabbstart: Hugging Face Spaces
+
+## Steg-för-steg guide för att deploya på Hugging Face
+
+### 1. Förbered Google Cloud (om inte redan gjort)
+
+Se huvudinstruktioner i README.md för att:
+- Skapa Google Cloud project
+- Aktivera Google Sheets API och Google Drive API  
+- Skapa Service Account och ladda ner JSON-nyckel
+- Dela ditt Google Sheet med service account-emailen
+
+### 2. Skapa Hugging Face Space
+
+1. Gå till [huggingface.co/spaces](https://huggingface.co/spaces)
+2. Klicka **"Create new Space"**
+3. Fyll i:
+   - **Owner**: Ditt användarnamn
+   - **Space name**: `omradesdata-manager` (eller valfritt namn)
+   - **License**: Apache 2.0 (eller valfri)
+   - **Select the Space SDK**: **Streamlit**
+   - **Space hardware**: CPU basic (gratis)
+4. Klicka **"Create Space"**
+
+### 3. Ladda upp filer
+
+Du har två alternativ:
+
+#### Alternativ A: Via Web Interface
+
+1. I ditt nya Space, klicka **"Files"**
+2. Klicka **"Add file"** → **"Upload files"**
+3. Ladda upp:
+   - `app.py`
+   - `requirements.txt`
+4. Klicka **"Commit changes"**
+
+#### Alternativ B: Via Git (rekommenderas för framtida uppdateringar)
+
+```bash
+# Klona ditt Space
+git clone https://huggingface.co/spaces/DITT-ANVÄNDARNAMN/omradesdata-manager
+cd omradesdata-manager
+
+# Kopiera filer
+cp /sökväg/till/app.py .
+cp /sökväg/till/requirements.txt .
+
+# Commit och push
+git add app.py requirements.txt
+git commit -m "Initial commit"
+git push
+```
+
+### 4. Konfigurera Secrets
+
+Detta är det **viktigaste steget**!
+
+1. Gå till ditt Space
+2. Klicka **"Settings"** (kugghjulsikonen)
+3. Scrolla ner till **"Repository secrets"**
+4. Klicka **"New secret"**
+
+#### Lägg till Sheet ID:
+
+- **Name**: `SHEET_ID`
+- **Value**: `DIN_GOOGLE_SHEET_ID` (från URL:en)
+- Klicka **"Save"**
+
+#### Lägg till Google Credentials:
+
+- **Name**: `GOOGLE_CREDENTIALS`
+- **Value**: Hela innehållet från din JSON-nyckel (kopiera allt!)
+- Klicka **"Save"**
+
+### 5. Uppdatera app.py för Hugging Face
+
+Lägg till dessa rader i början av `app.py` (efter imports):
+
+```python
+import json
+import os
+
+# För Hugging Face Spaces - läs secrets från environment
+if 'GOOGLE_CREDENTIALS' in os.environ:
+    # Vi är på Hugging Face
+    google_creds = json.loads(os.environ['GOOGLE_CREDENTIALS'])
+    sheet_id = os.environ['SHEET_ID']
+    
+    # Skapa fake secrets-struktur för kompatibilitet
+    if 'secrets' not in st.__dict__ or not hasattr(st, 'secrets'):
+        class Secrets:
+            def __init__(self):
+                self.data = {
+                    'gcp_service_account': google_creds,
+                    'sheet_id': sheet_id
+                }
+            def __getitem__(self, key):
+                return self.data[key]
+        
+        st.secrets = Secrets()
+```
+
+**ELLER** använd denna uppdaterade `get_google_sheet()` funktion:
+
+```python
+@st.cache_resource
+def get_google_sheet():
+    """Anslut till Google Sheets"""
+    try:
+        # Försök först med Streamlit secrets (lokal utveckling)
+        if hasattr(st, 'secrets') and 'gcp_service_account' in st.secrets:
+            creds = Credentials.from_service_account_info(
+                st.secrets["gcp_service_account"],
+                scopes=SCOPES
+            )
+            sheet_id = st.secrets["sheet_id"]
+        # Annars använd environment variables (Hugging Face)
+        elif 'GOOGLE_CREDENTIALS' in os.environ:
+            google_creds = json.loads(os.environ['GOOGLE_CREDENTIALS'])
+            creds = Credentials.from_service_account_info(
+                google_creds,
+                scopes=SCOPES
+            )
+            sheet_id = os.environ['SHEET_ID']
+        else:
+            st.error("❌ Inga credentials hittades!")
+            return None
+            
+        client = gspread.authorize(creds)
+        sheet = client.open_by_key(sheet_id).sheet1
+        return sheet
+    except Exception as e:
+        st.error(f"❌ Kunde inte ansluta till Google Sheets: {e}")
+        return None
+```
+
+### 6. Testa deployment
+
+1. Space kommer automatiskt att bygga och deploya
+2. Vänta 1-2 minuter
+3. När status visar **"Running"**, klicka på din Space-URL
+4. Testa att logga in med ett lösenord från ditt sheet!
+
+### 7. Felsökning
+
+#### "Kunde inte ansluta till Google Sheets"
+
+**Kontrollera:**
+- [ ] GOOGLE_CREDENTIALS är korrekt JSON (hela filen)
+- [ ] SHEET_ID är rätt (från Google Sheets URL)
+- [ ] Service account har tillgång till sheetet
+- [ ] API:erna är aktiverade i Google Cloud
+
+#### "No module named 'gspread'"
+
+**Lösning:**
+- Kontrollera att `requirements.txt` är uppladdad
+- Rebuild Space (Settings → Factory reboot)
+
+#### Space kraschar
+
+**Kontrollera:**
+- Logs i Space (klicka på "Logs")
+- Syntax-fel i app.py
+- Secrets är korrekt formaterade
+
+### 8. Gör din Space privat (valfritt)
+
+Om du vill ha en privat app:
+
+1. Gå till **Settings**
+2. Under **"Space visibility"**
+3. Välj **"Private"**
+4. Klicka **"Save"**
+
+Nu kan bara du (och personer du delar länken med) se appen!
+
+### 9. Uppdatera din app
+
+För att göra ändringar i framtiden:
+
+```bash
+cd omradesdata-manager
+# Gör dina ändringar i app.py
+git add app.py
+git commit -m "Uppdaterad funktion X"
+git push
+```
+
+Space kommer automatiskt att rebuilda!
+
+## 🎉 Klart!
+
+Din app körs nu på Hugging Face Spaces! Dela länken med dina användare:
+
+```
+https://huggingface.co/spaces/DITT-ANVÄNDARNAMN/omradesdata-manager
+```
+
+## 💡 Pro Tips
+
+1. **Snabbare builds**: Pin exakta versioner i requirements.txt
+2. **Bättre prestanda**: Använd st.cache_resource för datahämtning
+3. **Monitoring**: Kolla Logs regelbundet för fel
+4. **Backups**: Gör regelbundna backups av ditt Google Sheet
+
+## 📞 Behöver du hjälp?
+
+- Hugging Face Community: [huggingface.co/discussions](https://huggingface.co/discussions)
+- Streamlit Forum: [discuss.streamlit.io](https://discuss.streamlit.io)

MAPPSTRUKTUR.md

@@ -0,0 +1,41 @@
+# 📂 Mappstruktur för ditt projekt
+
+```
+omradesdata-manager/
+│
+├── 📄 app.py                      # Huvudapplikationen
+├── 📄 requirements.txt            # Python dependencies  
+├── 📄 .gitignore                  # Skyddar secrets från Git
+├── 📄 README.md                   # Fullständig dokumentation
+├── 📄 HUGGINGFACE_SETUP.md       # Guide för Hugging Face
+├── 📄 PROJEKTSTRUKTUR.md         # Översikt över projektet
+├── 📄 START_HÄR.md               # Snabbstartguide
+├── 📄 secrets.toml.template      # Mall för secrets (utan riktiga värden)
+│
+└── 📁 .streamlit/                 # ⚠️ SKAPA DENNA LOKALT (lägg INTE i Git!)
+    └── 📄 secrets.toml            # Dina riktiga secrets (endast lokalt)
+```
+
+## 📦 Vad som ska i GitHub:
+
+Allt UTOM `.streamlit/` mappen!
+
+## 🏠 Vad som ska finnas lokalt:
+
+Allt ovan + `.streamlit/secrets.toml` (för lokal testning)
+
+## ☁️ Deployment-secrets:
+
+- **Streamlit Cloud**: Lägg in manuellt i web-interfacet
+- **Hugging Face**: Lägg in i Repository secrets
+
+---
+
+## 🎯 Snabb setup:
+
+1. **Ladda ner** alla filer från ZIP-filen
+2. **Packa upp** i en mapp (t.ex. `omradesdata-manager`)
+3. **Skapa** `.streamlit/secrets.toml` lokalt (kopiera från template)
+4. **Testa** lokalt: `streamlit run app.py`
+5. **Pusha** till GitHub (utan .streamlit/)
+6. **Deploya** på Streamlit Cloud eller Hugging Face

PROJEKTSTRUKTUR.md

@@ -0,0 +1,96 @@
+# 📁 Projektstruktur
+
+```
+omradesdata-manager/
+│
+├── app.py                      # Huvudapplikationen
+├── requirements.txt            # Python-dependencies
+├── .gitignore                  # Git ignore-fil
+├── README.md                   # Huvuddokumentation
+├── HUGGINGFACE_SETUP.md       # Guide för Hugging Face deployment
+├── secrets.toml.template       # Mall för secrets-fil
+│
+└── .streamlit/                 # Skapas av dig
+    └── secrets.toml            # Dina secrets (lägg INTE i Git!)
+```
+
+## 📝 Filbeskrivningar
+
+### app.py
+Huvudapplikationen med all funktionalitet:
+- Lösenordsautentisering
+- Visa områdesdata
+- Editera tillåtna fält
+- Spara ändringar till Google Sheets
+
+### requirements.txt
+Lista över Python-paket som behövs:
+- streamlit
+- gspread
+- google-auth
+- pandas
+
+### .gitignore
+Skyddar känsliga filer från att hamna i Git:
+- Secrets och credentials
+- Virtuella miljöer
+- Cache-filer
+
+### README.md
+Komplett dokumentation:
+- Installation
+- Google Cloud setup
+- Deployment-instruktioner
+- Felsökning
+
+### HUGGINGFACE_SETUP.md
+Specifik guide för deployment på Hugging Face Spaces
+
+### secrets.toml.template
+Mall för att skapa din egen secrets-fil
+
+## 🚀 Snabbstart
+
+1. **Lokalt:**
+   ```bash
+   pip install -r requirements.txt
+   # Skapa .streamlit/secrets.toml enligt mall
+   streamlit run app.py
+   ```
+
+2. **Hugging Face Spaces:**
+   - Ladda upp app.py och requirements.txt
+   - Konfigurera secrets enligt HUGGINGFACE_SETUP.md
+
+## 🔑 Secrets-konfiguration
+
+### Lokal utveckling (.streamlit/secrets.toml)
+```toml
+sheet_id = "DIN_GOOGLE_SHEET_ID"
+
+[gcp_service_account]
+# Din Google Service Account JSON-data här
+```
+
+### Hugging Face Spaces (Environment Variables)
+```
+SHEET_ID = "DIN_GOOGLE_SHEET_ID"
+GOOGLE_CREDENTIALS = {hela JSON-objektet}
+```
+
+## 💡 Nästa steg
+
+1. Läs README.md för fullständig setup-guide
+2. Sätt upp Google Cloud och Service Account
+3. Konfigurera secrets
+4. Testa lokalt först
+5. Deploya till Hugging Face Spaces
+
+## 🔒 Säkerhet
+
+**VIKTIGT:** Lägg ALDRIG till dessa filer i Git:
+- `.streamlit/secrets.toml`
+- `*.json` (Service Account-nycklar)
+- Virtuella miljöer (`venv/`, `env/`)
+
+Använd alltid `.gitignore`!

README.md

@@ -1,13 +1,251 @@
----
-title: Area Updater
-emoji: 😻
-colorFrom: blue
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-short_description: Områdes uppdaterare för ChargeNode
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🏢 Områdesdata Manager
+
+En säker Streamlit-applikation för att hantera områdesdata från Google Sheets med lösenordsskydd.
+
+## ✨ Funktioner
+
+- 🔐 **Lösenordsskydd per område** - Varje område har sitt eget unika lösenord
+- 🏢 **Företagsvy** - Se alla områden för ditt företag efter inloggning
+- ✏️ **Selektiv redigering** - Vissa fält är skrivskyddade (org.nr, företagsnamn, etc.)
+- 💾 **Direkt synkronisering** - Ändringar sparas direkt till Google Sheets
+- 🔄 **Realtidsuppdatering** - Hämta senaste data från arket
+- 📱 **Responsiv design** - Fungerar på desktop och mobil
+
+## 📋 Förutsättningar
+
+- Python 3.8 eller senare
+- Ett Google Cloud-konto
+- Google Sheets med data
+
+## 🚀 Installation och Setup
+
+### Steg 1: Klona eller ladda ner projektet
+
+```bash
+# Skapa en ny mapp för projektet
+mkdir omradesdata-manager
+cd omradesdata-manager
+
+# Lägg till filerna (app.py, requirements.txt)
+```
+
+### Steg 2: Skapa virtuell miljö (rekommenderas)
+
+```bash
+# Skapa virtuell miljö
+python -m venv venv
+
+# Aktivera virtuell miljö
+# På Windows:
+venv\Scripts\activate
+# På Mac/Linux:
+source venv/bin/activate
+```
+
+### Steg 3: Installera dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### Steg 4: Google Cloud Setup
+
+#### 4.1 Skapa Google Cloud Project
+
+1. Gå till [Google Cloud Console](https://console.cloud.google.com/)
+2. Klicka på "Select a project" → "New Project"
+3. Namnge projektet (t.ex. "omradesdata-manager")
+4. Klicka "Create"
+
+#### 4.2 Aktivera API:er
+
+1. I menyn, gå till "APIs & Services" → "Library"
+2. Sök och aktivera:
+   - **Google Sheets API**
+   - **Google Drive API**
+
+#### 4.3 Skapa Service Account
+
+1. Gå till "APIs & Services" → "Credentials"
+2. Klicka "Create Credentials" → "Service Account"
+3. Namnge service account (t.ex. "sheets-manager")
+4. Klicka "Create and Continue"
+5. Välj roll: **Editor** (eller "Basic" → "Editor")
+6. Klicka "Done"
+
+#### 4.4 Generera JSON-nyckel
+
+1. I listan över service accounts, klicka på den du nyss skapade
+2. Gå till fliken "Keys"
+3. Klicka "Add Key" → "Create new key"
+4. Välj **JSON**
+5. Klicka "Create"
+6. En JSON-fil laddas ner automatiskt - **spara den säkert!**
+
+#### 4.5 Dela Google Sheet med Service Account
+
+1. Öppna din JSON-nyckel och hitta värdet för `client_email`
+   - Det ser ut som: `sheets-manager@ditt-project.iam.gserviceaccount.com`
+2. Öppna ditt Google Sheet
+3. Klicka "Share" (Dela)
+4. Lägg till service account-emailen
+5. Ge den **Editor**-behörighet
+6. Klicka "Send"
+
+### Steg 5: Konfigurera Secrets
+
+#### 5.1 Hitta ditt Sheet ID
+
+Öppna ditt Google Sheet och titta på URL:en:
+```
+https://docs.google.com/spreadsheets/d/DETTA_ÄR_DITT_SHEET_ID/edit
+```
+
+#### 5.2 Skapa secrets-fil
+
+```bash
+# Skapa .streamlit-mapp
+mkdir .streamlit
+
+# Kopiera mall
+cp secrets.toml.template .streamlit/secrets.toml
+```
+
+#### 5.3 Fyll i secrets.toml
+
+Öppna `.streamlit/secrets.toml` och:
+
+1. Ersätt `DIN_GOOGLE_SHEET_ID_HÄR` med ditt Sheet ID
+2. Öppna din JSON-nyckel och kopiera alla värden till motsvarande fält
+
+Exempel:
+```toml
+sheet_id = "1ABC123xyz789..."
+
+[gcp_service_account]
+type = "service_account"
+project_id = "omradesdata-manager-123"
+private_key_id = "abc123..."
+private_key = "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----\n"
+client_email = "sheets-manager@omradesdata-manager-123.iam.gserviceaccount.com"
+# ... etc
+```
+
+**VIKTIGT:** Lägg till `.streamlit/secrets.toml` i `.gitignore`!
+
+### Steg 6: Kör applikationen lokalt
+
+```bash
+streamlit run app.py
+```
+
+Appen öppnas automatiskt i din webbläsare på `http://localhost:8501`
+
+## 🌐 Deployment
+
+### Alternativ 1: Streamlit Community Cloud (Gratis)
+
+1. Pusha din kod till GitHub (utan secrets!)
+2. Gå till [share.streamlit.io](https://share.streamlit.io)
+3. Klicka "New app"
+4. Välj ditt repository
+5. I "Advanced settings" → "Secrets", klistra in innehållet från din `secrets.toml`
+6. Klicka "Deploy"
+
+### Alternativ 2: Hugging Face Spaces
+
+1. Skapa ett nytt Space på [Hugging Face](https://huggingface.co/spaces)
+2. Välj **Streamlit** som SDK
+3. Ladda upp `app.py` och `requirements.txt`
+4. I Space Settings → Repository secrets:
+   - Lägg till variabel `STREAMLIT_SECRETS`
+   - Klistra in hela innehållet från din `secrets.toml`
+5. Space kommer automatiskt att deploya
+
+## 🔧 Anpassning
+
+### Ändra skrivskyddade kolumner
+
+I `app.py`, hitta variabeln `READONLY_COLUMNS` och ändra efter behov:
+
+```python
+READONLY_COLUMNS = [
+    'Tidstämpel',
+    'Organisationsnummer', 
+    'Lösenord',
+    'Account',
+    # Lägg till fler kolumner här...
+]
+```
+
+### Ändra layout
+
+Koden använder Streamlit's `st.columns()` för layout. Justera kolumnbredder:
+
+```python
+# Exempel: Ändra från [1, 2, 1] till [1, 3, 1]
+col1, col2, col3 = st.columns([1, 3, 1])
+```
+
+## 📊 Datastruktur
+
+Appen förväntar sig följande kolumner i Google Sheet:
+
+| Kolumn | Beskrivning | Editerbar |
+|--------|-------------|-----------|
+| Tidstämpel | När området skapades | Nej |
+| Organisationsnummer | Företagets org.nr | Nej |
+| Lösenord | Unikt lösenord per område | Nej |
+| Områdeskod | Identifierare för området | Nej |
+| För- och efternamn | Kontaktperson | Ja |
+| Telefonnummer | Kontakt telefon | Ja |
+| Adress | Leveransadress | Ja |
+| ... | Övriga fält | Ja |
+
+## 🔒 Säkerhet
+
+- ✅ Lösenord visas aldrig i klartext
+- ✅ Secrets lagras säkert (inte i kod)
+- ✅ Ingen data cachas på klientsidan
+- ✅ Direktkommunikation med Google Sheets API
+
+### Rekommenderade förbättringar:
+
+1. **Rate limiting** - Begränsa antal inloggningsförsök
+2. **Session timeout** - Automatisk utloggning efter inaktivitet
+3. **Audit log** - Logga alla ändringar
+4. **HTTPS** - Använd alltid HTTPS i produktion
+
+## ❓ Felsökning
+
+### Problem: "Kunde inte ansluta till Google Sheets"
+
+**Lösning:**
+1. Kontrollera att Sheet ID är korrekt
+2. Verifiera att service account-emailen har tillgång till sheetet
+3. Dubbelkolla att API:erna är aktiverade
+
+### Problem: "Ogiltigt lösenord"
+
+**Lösning:**
+1. Kontrollera att lösenordet i sheetet matchar exakt (inga extra mellanslag)
+2. Lösenord är case-sensitive
+3. Uppdatera data med 🔄-knappen
+
+### Problem: "Kan inte uppdatera celler"
+
+**Lösning:**
+1. Service account behöver **Editor**-behörighet, inte bara Viewer
+2. Kontrollera att sheetet inte är skrivskyddat
+
+## 📝 Licens
+
+Detta projekt är öppen källkod och fritt att använda och modifiera.
+
+## 🤝 Bidrag
+
+Förslag och förbättringar är välkomna!
+
+## 📧 Support
+
+För frågor eller problem, kontakta utvecklaren.

START_HÄR.md

@@ -0,0 +1,154 @@
+# 🚀 START HÄR!
+
+Tack för att du använder Områdesdata Manager! Här är en snabb guide för att komma igång.
+
+## 📦 Vad har du fått?
+
+Du har nu alla filer du behöver för att skapa en säker webbapp för att hantera ditt Google Sheet:
+
+✅ **app.py** - Huvudapplikationen  
+✅ **requirements.txt** - Dependencies  
+✅ **README.md** - Fullständig dokumentation  
+✅ **HUGGINGFACE_SETUP.md** - Guide för Hugging Face  
+✅ **.gitignore** - Skyddar dina secrets  
+✅ **secrets.toml.template** - Mall för konfiguration  
+✅ **PROJEKTSTRUKTUR.md** - Översikt över projektet  
+
+## 🎯 Vad gör appen?
+
+1. **Lösenordsskydd** - Varje område har sitt eget lösenord (kolumn C i ditt sheet)
+2. **Visa alla områden** - När användaren loggar in ser de alla områden för sitt företag
+3. **Editera data** - Vissa kolumner kan editeras, andra är skrivskyddade
+4. **Spara direkt** - Ändringar sparas direkt till Google Sheets
+5. **Säker** - Data visas bara efter korrekt lösenord
+
+## 🏃 Snabbstart (3 enkla val)
+
+### Alternativ 1: Testa lokalt (Rekommenderas först!)
+
+```bash
+# 1. Installera dependencies
+pip install -r requirements.txt
+
+# 2. Skapa .streamlit-mapp
+mkdir .streamlit
+
+# 3. Kopiera och fyll i secrets
+cp secrets.toml.template .streamlit/secrets.toml
+# Redigera .streamlit/secrets.toml med dina credentials
+
+# 4. Kör appen
+streamlit run app.py
+```
+
+**För lokal körning behöver du:**
+- Google Cloud Service Account (se README.md för guide)
+- Dela ditt Google Sheet med service account-emailen
+- Fyll i `.streamlit/secrets.toml` med dina credentials
+
+### Alternativ 2: Hugging Face Spaces (Gratis hosting!)
+
+1. Gå till [huggingface.co/spaces](https://huggingface.co/spaces)
+2. Skapa nytt Space med Streamlit SDK
+3. Ladda upp `app.py` och `requirements.txt`
+4. Lägg till secrets (se HUGGINGFACE_SETUP.md)
+
+**Secrets att lägga till på Hugging Face:**
+- `SHEET_ID` - Ditt Google Sheet ID
+- `GOOGLE_CREDENTIALS` - Hela JSON-nyckeln från Google Cloud
+
+### Alternativ 3: Streamlit Community Cloud
+
+1. Pusha kod till GitHub (utan secrets!)
+2. Gå till [share.streamlit.io](https://share.streamlit.io)
+3. Välj ditt repo och deploya
+4. Lägg till secrets i Advanced Settings
+
+## 📚 Detaljerade guider
+
+- **Fullständig setup-guide**: Läs `README.md`
+- **Hugging Face deployment**: Läs `HUGGINGFACE_SETUP.md`
+- **Projektöversikt**: Läs `PROJEKTSTRUKTUR.md`
+
+## 🔧 Google Cloud Setup (Måste göras först!)
+
+Innan du kan köra appen behöver du:
+
+1. **Skapa Google Cloud Project**
+   - Gå till [console.cloud.google.com](https://console.cloud.google.com)
+   - Skapa nytt projekt
+
+2. **Aktivera API:er**
+   - Google Sheets API
+   - Google Drive API
+
+3. **Skapa Service Account**
+   - Gå till "APIs & Services" → "Credentials"
+   - Skapa Service Account
+   - Ladda ner JSON-nyckel
+
+4. **Dela Google Sheet**
+   - Kopiera service account-emailen från JSON-filen
+   - Dela ditt Google Sheet med denna email (ge Editor-behörighet)
+
+**Fullständig guide finns i README.md!**
+
+## 🎨 Anpassa appen
+
+### Ändra vilka kolumner som får editeras
+
+I `app.py`, hitta `READONLY_COLUMNS` och ändra:
+
+```python
+READONLY_COLUMNS = [
+    'Tidstämpel',
+    'Organisationsnummer', 
+    'Lösenord',
+    'Account',
+    # Lägg till fler här...
+]
+```
+
+### Ändra styling
+
+Koden använder Streamlit och kan anpassas efter dina behov. Se dokumentationen i app.py.
+
+## ❓ Behöver du hjälp?
+
+### Vanliga problem:
+
+**"Kunde inte ansluta till Google Sheets"**
+→ Kontrollera att Sheet ID är korrekt och att API:erna är aktiverade
+
+**"Ogiltigt lösenord"**
+→ Lösenord är case-sensitive och får inte ha extra mellanslag
+
+**"Kan inte uppdatera celler"**
+→ Service account behöver Editor-behörighet (inte bara Viewer)
+
+### Mer hjälp:
+
+- Läs felsökningsavsnittet i README.md
+- Kolla logs om du kör på Hugging Face
+- Testa lokalt först för enklare debugging
+
+## 🔒 Säkerhetsregler
+
+**VIKTIGT! Lägg ALDRIG till dessa filer i Git:**
+- `.streamlit/secrets.toml`
+- `*.json` (Service Account-nycklar)
+- Din Google Sheet ID (om den är känslig)
+
+`.gitignore` är redan konfigurerad för att skydda dig!
+
+## 🎉 Lycka till!
+
+Du har nu allt du behöver för att skapa en säker webbapp för att hantera ditt Google Sheet!
+
+**Rekommenderad ordning:**
+1. Läs README.md för fullständig förståelse
+2. Sätt upp Google Cloud (se guide i README.md)
+3. Testa lokalt först
+4. Deploya till Hugging Face eller Streamlit Cloud
+
+**Frågor?** All dokumentation finns i filerna! ✨

app.py

@@ -0,0 +1,311 @@
+import streamlit as st
+import gspread
+from google.oauth2.service_account import Credentials
+import pandas as pd
+from datetime import datetime
+import json
+import os
+
+# Konfigurera sidan
+st.set_page_config(
+    page_title="Områdesdata Manager", 
+    layout="wide",
+    initial_sidebar_state="collapsed"
+)
+
+# Google Sheets setup
+SCOPES = [
+    'https://www.googleapis.com/auth/spreadsheets',
+    'https://www.googleapis.com/auth/drive'
+]
+
+# Definiera vilka kolumner som INTE får editeras (0-indexerade)
+READONLY_COLUMNS = [
+    'Tidstämpel',
+    'Organisationsnummer', 
+    'Lösenord',
+    'Account',  # Företagsnamn
+    'Location Name',
+    'Location - Address',
+    'Long',
+    'Lat',
+    'Location - City'
+]
+
+@st.cache_resource
+def get_google_sheet():
+    """Anslut till Google Sheets - fungerar både lokalt och på Hugging Face"""
+    try:
+        # Försök först med Streamlit secrets (lokal utveckling)
+        if hasattr(st, 'secrets') and 'gcp_service_account' in st.secrets:
+            creds = Credentials.from_service_account_info(
+                st.secrets["gcp_service_account"],
+                scopes=SCOPES
+            )
+            sheet_id = st.secrets["sheet_id"]
+        # Annars använd environment variables (Hugging Face Spaces)
+        elif 'GOOGLE_CREDENTIALS' in os.environ and 'SHEET_ID' in os.environ:
+            google_creds = json.loads(os.environ['GOOGLE_CREDENTIALS'])
+            creds = Credentials.from_service_account_info(
+                google_creds,
+                scopes=SCOPES
+            )
+            sheet_id = os.environ['SHEET_ID']
+        else:
+            st.error("❌ Inga credentials hittades! Kontrollera att secrets är konfigurerade.")
+            st.info("💡 Lokal utveckling: Skapa .streamlit/secrets.toml\n\n💡 Hugging Face: Lägg till GOOGLE_CREDENTIALS och SHEET_ID i Repository secrets")
+            return None
+            
+        client = gspread.authorize(creds)
+        sheet = client.open_by_key(sheet_id).sheet1
+        return sheet
+    except Exception as e:
+        st.error(f"❌ Kunde inte ansluta till Google Sheets: {e}")
+        return None
+
+def get_sheet_data(sheet):
+    """Hämta all data från sheet"""
+    try:
+        data = sheet.get_all_records()
+        df = pd.DataFrame(data)
+        return df
+    except Exception as e:
+        st.error(f"❌ Fel vid hämtning av data: {e}")
+        return None
+
+def validate_password(df, password):
+    """Validera lösenord och returnera organisationsnummer"""
+    # Hitta rad där lösenord matchar
+    match = df[df['Lösenord'].astype(str) == password]
+    
+    if not match.empty:
+        org_nr = match.iloc[0]['Organisationsnummer']
+        return org_nr
+    return None
+
+def get_company_areas(df, org_nr):
+    """Hämta alla områden för ett organisationsnummer"""
+    return df[df['Organisationsnummer'] == org_nr]
+
+def update_cell(sheet, row_num, col_name, new_value, df):
+    """Uppdatera en specifik cell i Google Sheets"""
+    try:
+        # Hitta kolumnindex (1-baserad för gspread)
+        col_idx = df.columns.get_loc(col_name) + 1
+        # row_num är 0-baserad, lägg till 2 för header och 1-basering
+        cell_row = row_num + 2
+        
+        sheet.update_cell(cell_row, col_idx, new_value)
+        return True
+    except Exception as e:
+        st.error(f"❌ Kunde inte uppdatera {col_name}: {e}")
+        return False
+
+def get_editable_columns(df):
+    """Returnera lista med editerbara kolumner"""
+    return [col for col in df.columns if col not in READONLY_COLUMNS]
+
+# CSS för bättre styling
+st.markdown("""
+<style>
+    .stButton button {
+        width: 100%;
+    }
+    .area-card {
+        padding: 20px;
+        border-radius: 10px;
+        background-color: #f0f2f6;
+        margin-bottom: 20px;
+    }
+    .success-msg {
+        padding: 10px;
+        border-radius: 5px;
+        background-color: #d4edda;
+        color: #155724;
+        margin: 10px 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Huvudapp
+st.title("🏢 Områdesdata Manager")
+
+# Session state
+if 'authenticated' not in st.session_state:
+    st.session_state.authenticated = False
+    st.session_state.org_nr = None
+    st.session_state.df = None
+    st.session_state.company_name = None
+
+# Anslut till Google Sheets
+sheet = get_google_sheet()
+
+if sheet is None:
+    st.stop()
+
+# Inloggning
+if not st.session_state.authenticated:
+    st.markdown("### 🔐 Logga in med ditt områdeslösenord")
+    
+    col1, col2, col3 = st.columns([1, 2, 1])
+    
+    with col2:
+        password = st.text_input(
+            "Ange lösenord för ditt område:", 
+            type="password", 
+            key="password_input",
+            placeholder="Ange lösenord..."
+        )
+        
+        if st.button("🔓 Logga in", type="primary", use_container_width=True):
+            if password:
+                with st.spinner("Validerar lösenord..."):
+                    df = get_sheet_data(sheet)
+                    
+                    if df is not None:
+                        org_nr = validate_password(df, password)
+                        
+                        if org_nr is not None:
+                            company_areas = get_company_areas(df, org_nr)
+                            company_name = company_areas.iloc[0]['Account']
+                            
+                            st.session_state.authenticated = True
+                            st.session_state.org_nr = org_nr
+                            st.session_state.df = df
+                            st.session_state.company_name = company_name
+                            st.success("✅ Inloggning lyckades!")
+                            st.reflow()
+                        else:
+                            st.error("❌ Ogiltigt lösenord")
+            else:
+                st.warning("⚠️ Ange ett lösenord")
+    
+    st.divider()
+    st.info("💡 **Information:** Detta system låter dig hantera områdesinformation. Ange ditt områdeslösenord för att se och editera tillhörande data.")
+
+else:
+    # Användaren är inloggad
+    org_nr = st.session_state.org_nr
+    df = st.session_state.df
+    company_name = st.session_state.company_name
+    
+    # Header med företagsinfo
+    col1, col2, col3 = st.columns([2, 1, 1])
+    
+    with col1:
+        st.markdown(f"## 🏢 {company_name}")
+        st.caption(f"Org.nr: {org_nr}")
+    
+    with col2:
+        if st.button("🔄 Uppdatera data", use_container_width=True):
+            st.cache_resource.clear()
+            st.session_state.df = get_sheet_data(sheet)
+            st.success("✅ Data uppdaterad!")
+            st.reflow()
+    
+    with col3:
+        if st.button("🚪 Logga ut", use_container_width=True):
+            st.session_state.authenticated = False
+            st.session_state.org_nr = None
+            st.session_state.df = None
+            st.session_state.company_name = None
+            st.reflow()
+    
+    st.divider()
+    
+    # Hämta alla områden för detta företag
+    company_areas = get_company_areas(df, org_nr)
+    
+    st.markdown(f"### 📍 Dina områden ({len(company_areas)} st)")
+    
+    # Editerbara kolumner
+    editable_cols = get_editable_columns(df)
+    
+    # Visa varje område i en expanderbar sektion
+    for idx, (row_idx, area) in enumerate(company_areas.iterrows(), 1):
+        with st.expander(f"🗺️ Område {idx}: {area['Områdeskod']} - {area['Location Name']}", expanded=(idx == 1)):
+            
+            # Visa fast information
+            st.markdown("#### 📋 Fast information")
+            info_cols = st.columns(3)
+            
+            with info_cols[0]:
+                st.text_input("Områdeskod", value=area['Områdeskod'], disabled=True, key=f"area_{row_idx}_kod")
+                st.text_input("Location Name", value=area['Location Name'], disabled=True, key=f"area_{row_idx}_locname")
+            
+            with info_cols[1]:
+                st.text_input("Location Address", value=area['Location - Address'], disabled=True, key=f"area_{row_idx}_addr")
+                st.text_input("Location City", value=area['Location - City'], disabled=True, key=f"area_{row_idx}_city")
+            
+            with info_cols[2]:
+                st.text_input("Long", value=area['Long'], disabled=True, key=f"area_{row_idx}_long")
+                st.text_input("Lat", value=area['Lat'], disabled=True, key=f"area_{row_idx}_lat")
+            
+            st.divider()
+            
+            # Editerbara fält
+            st.markdown("#### ✏️ Editerbar information")
+            
+            # Gruppera editerbara fält
+            edit_col1, edit_col2 = st.columns(2)
+            
+            changes = {}  # Spara ändringar
+            
+            with edit_col1:
+                # Första halvan av editerbara kolumner
+                mid = len(editable_cols) // 2
+                for col in editable_cols[:mid]:
+                    current_value = str(area[col]) if pd.notna(area[col]) else ""
+                    
+                    new_value = st.text_input(
+                        col,
+                        value=current_value,
+                        key=f"edit_{row_idx}_{col}"
+                    )
+                    
+                    if new_value != current_value:
+                        changes[col] = new_value
+            
+            with edit_col2:
+                # Andra halvan av editerbara kolumner
+                for col in editable_cols[mid:]:
+                    current_value = str(area[col]) if pd.notna(area[col]) else ""
+                    
+                    new_value = st.text_input(
+                        col,
+                        value=current_value,
+                        key=f"edit_{row_idx}_{col}"
+                    )
+                    
+                    if new_value != current_value:
+                        changes[col] = new_value
+            
+            # Om det finns ändringar, visa uppdateringsknapp
+            if changes:
+                st.warning(f"⚠️ {len(changes)} fält har ändrats")
+                
+                cols = st.columns([1, 1, 2])
+                with cols[0]:
+                    if st.button(f"💾 Spara alla ändringar", key=f"save_all_{row_idx}", type="primary", use_container_width=True):
+                        success_count = 0
+                        
+                        with st.spinner("Sparar ändringar..."):
+                            for col, new_value in changes.items():
+                                if update_cell(sheet, row_idx, col, new_value, df):
+                                    success_count += 1
+                        
+                        if success_count == len(changes):
+                            st.success(f"✅ Alla {success_count} ändringar sparade!")
+                            st.cache_resource.clear()
+                            st.session_state.df = get_sheet_data(sheet)
+                            st.reflow()
+                        else:
+                            st.error(f"⚠️ Kunde bara spara {success_count} av {len(changes)} ändringar")
+                
+                with cols[1]:
+                    if st.button(f"↩️ Ångra ändringar", key=f"reset_{row_idx}", use_container_width=True):
+                        st.reflow()
+
+    # Footer
+    st.divider()
+    st.caption(f"🔒 Säker åtkomst • Inloggad som {company_name} • {len(company_areas)} områden")

requirements.txt

@@ -0,0 +1,4 @@
+streamlit>=1.28.0
+gspread>=5.11.0
+google-auth>=2.23.0
+pandas>=2.0.0

secrets.toml.template

@@ -0,0 +1,17 @@
+# .streamlit/secrets.toml
+# LÄGG INTE TILL DENNA FIL I GIT!
+
+sheet_id = "DIN_GOOGLE_SHEET_ID_HÄR"
+
+[gcp_service_account]
+type = "service_account"
+project_id = "ditt-project-id"
+private_key_id = "xxxxxxxxxxxx"
+private_key = "-----BEGIN PRIVATE KEY-----\nDIN_PRIVATE_KEY_HÄR\n-----END PRIVATE KEY-----\n"
+client_email = "din-service-account@ditt-project.iam.gserviceaccount.com"
+client_id = "xxxxxxxxxxxxx"
+auth_uri = "https://accounts.google.com/o/oauth2/auth"
+token_uri = "https://oauth2.googleapis.com/token"
+auth_provider_x509_cert_url = "https://www.googleapis.com/oauth2/v1/certs"
+client_x509_cert_url = "https://www.googleapis.com/robot/v1/metadata/x509/din-service-account%40ditt-project.iam.gserviceaccount.com"
+universe_domain = "googleapis.com"