Om du har jobbat med Odoo har du säkert sett uttryck som ser ut som små filterformler överallt. De där hakparenteserna med fältvillkor syns i knappar, automationsregler, åtkomstregler och e-postmallar. Mindre känt är att Odoo också har en speciell fälttyp i sitt ORM — ett domänfält — byggt för att lagra just dessa filteruttryck som strukturerad data, med validering och ett användarvänligt redigeringsgränssnitt.
Att förstå domänfält spelar roll både för utvecklare som bygger moduler och för administratörer som sätter upp automatiseringar. Den här guiden förklarar vad ett domänfält egentligen innehåller, visar konkreta användningsfall, ger tips för utveckling och varnar för vanliga misstag.
Vad är fältet för domäner i Odoo
I Odoo är en domän i praktiken en lista med filtervillkor som ORM använder för att söka poster. Den följer en specifik syntax med tupler och logiska operatorer och blir i slutändan en WHERE-sats när databasen frågas.
Ett typiskt domänuttryck kan se ut ungefär så här:
[('customer_rank', '>', 0), ('active', '=', True)]I klartext betyder det: hitta alla poster där customer_rank är större än 0 OCH active är sant.
Fältet Domain (fields.Domain) är en specialiserad fälttyp i Odoo som sparar sådana filteruttryck i posten. Till skillnad från ett vanligt textfält får du här inbyggd validering och en visuell widget som låter slutanvändare bygga filter utan att skriva kod.
Hur det visas i gränssnittet
I Odoo visas ett domänfält normalt med en domänredigerare som en visuell byggare. Den visar tillgängliga fält från modellen, låter dig välja operator (lika med, innehåller, större än osv.) och ange värden — samma verktyg du möter när du konfigurerar åtkomsträttigheter eller automationskriterier.
I databasen sparas domänvärdet som text — närmare bestämt som en sträng som representerar en Python-lista. Fälttypen ansvarar för serialisering och kontroll, så i Python-koden arbetar du med rena domänsträngar medan lagret sköter omvandlingen.
Detta är typiskt för Odoos datamodell: ett fält är mer än bara lagring — det beskriver även beteende i UI och innehåller valideringslogik i sin definition.
Så fungerar fältet
Domänfältet är tätt integrerat med ORM och filtreringssystemet. Så här går det till bakom kulisserna när en domän sparas och används.
Lagring och representation
När en domän sparas lagras den som en serialiserad sträng. Domänen kan innehålla dynamiska variabler — till exempel uid som ersätts med aktuell användar-id vid körning — vilket gör att filter kan vara kontextkänsliga utan hårdkodade värden.
Odoo utvärderar strängen med en kontrollerad evaluator (t.ex. safe_eval) och översätter resultatet till en SQL WHERE-sats. Utvärderingen tillåter en begränsad mängd Python-uttryck och Odoo-specifika kontextvariabler på ett säkert sätt.
Domänwidgeten
I gränssnittet använder fields.Domain-fält domänwidgeten. Den visar samma filterbyggare som återfinns i många delar av Odoo, där användare kan lägga till villkor, kombinera med OCH/ELLER-logik och se vilka poster som matchar utan att röra kod.
Det är widgeten som gör domänfälten användarvänliga: en affärsanvändare behöver inte kunna domänsyntaxen för att skapa korrekta filter — byggaren sköter översättningen åt dem.
Modellkontext
Ett domänfält kan kopplas till en specifik modell så att byggaren vet vilka fält som ska erbjudas. Detta görs via attributet model_field i fältdefinitionen. Utan modellkontext faller widgeten tillbaka till en vanlig textinmatning, vilket ger sämre användarupplevelse.
Denna koppling är central för hur Odoo binder fältspecifikationer till UI-beteende: fältet vet vilken modell det gäller och gränssnittet anpassar sig därefter.
Interaktion med andra poster
Domänfält används ofta tillsammans med relationsfält för att kontrollera vilka poster som visas i en Many2one-lista, vilka poster en automatisk åtgärd ska rikta mot, eller vilken data som ingår i en rapport. Eftersom filter appliceras på ORM-nivå respekteras Odoos säkerhetsregler och fälttillstånd automatiskt.
Affärsscenarier där det används
Domänfält finns i praktiskt taget alla Odoo-moduler. Nedan följer fem konkreta exempel på hur de används i verkliga arbetsflöden.
1. Automatiska åtgärder och mejl
När du skapar en automatisk åtgärd definierar du en domän som avgör vilka poster som triggar åtgärden. Ett exempel är ett mejl för förfallna fakturor som bara ska gå för bokförda, obetalda fakturor som passerat förfallodatum. Domänen sparas på modellen för automation (t.ex. base.automation) och åtgärden körs bara för poster som matchar den.
2. Åtkomstregler och record rules
Säkerhetsregler i Odoo använder domäner för att begränsa vilka rader en användargrupp kan se eller ändra. En säljteampolicy kan exempelvis begränsa vyerna till poster som tillhör användarens team — detta utvärderas dynamiskt vid varje fråga och ger radnivå-säkerhet utan extra kod.
3. Lager- och operativa filter
I lagerhantering använder schemalagda åtgärder och påfyllningsregler domäner för att rikta in sig på specifika produktkategorier, lokationer eller lagersaldon. Ett återbeställningsjobb kan t.ex. begränsas till ständigt lagrade produkter som ligger under beställningsnivån, vilket undviker onödigt jobb på hela produktkatalogen.
4. CRM-pipeline och lead-kvalificering
I CRM används domäner för att automatisera pipeline-steg, aktiviteter och leadfördelning. Anpassade regler kan matcha leads till säljare utifrån land, bransch eller affärsstorlek — domänen gör det möjligt att justera logiken i UI istället för att ändra kod varje gång kriterierna ändras.
5. Dynamiska Many2one-dropdowns
I formulär kan ett domän på en Many2one styra vilka val som erbjuds i listrutan. Att begränsa leverantörsfältet till aktiva leverantörer med viss leverantörsstatus ger användaren färre, mer relevanta val och minskar felinmatningar. Domänen kan även referera andra fält i samma form så att alternativen ändras beroende på tidigare val.
Skapa eller anpassa fältet
Det finns två huvudvägar att jobba med domänfält: använda Odoo Studio för no-code-lösningar eller göra tekniska anpassningar med Python och XML i en modul.
Använda Odoo Studio
Odoo Studio visar inte alltid en separat val för domänfält i det visuella fältskapandet — men för många affärsbehov behöver du inte det. De inbyggda domänredigerarna i automations- och regelgränssnittet täcker ofta behoven utan att skapa ett nytt fält i modellen.
Vill du lägga en domän på en Many2one i Studio gör du det via fältets egenskaper och skriver in domänen där. Studio validerar syntaxen och sparar det i vydefinitionen.
Teknisk anpassning i Python
I en egen modul är det enkelt att lägga till ett Domain-fält enligt Odoos utvecklarpraxis. Här är ett förenklat exempel som visar idén:
from odoo import models, fields
class MyModel(models.Model):
_name = 'my.model'
model_name = fields.Char(default='res.partner')
filter_domain = fields.Domain(
string='Filter Domain',
model_field='model_name',
help='Domain expression to filter partner records'
)Attributet model_field kopplar domänfältet till en annan fältvärde som innehåller modellnamnet. Det talar om för widgeten vilka fält som ska erbjudas i den visuella byggaren. Genom att ha modellnamnet i ett eget fält möjliggör du dessutom dynamiska scenarier där modellen kan varieras.
Visa widgeten i en formvy
För att få domänbyggaren i en formulärvy måste du både ha modellfältet och domänfältet i vyn och ange widget-alternativet i XML:
<field name="model_name" invisible="1"/>
<field name="filter_domain" widget="domain"
options="{'model': 'model_name'}"/>Utan widget="domain" och modellalternativet renderas fältet som vanlig text. Ta alltid med båda när du exponerar domänkonstruktion för slutanvändare.
Skriva domänvärden via XML-RPC API
När du sätter domänfält programmässigt via API:t måste du sända värdet som en sträng.
models.execute_kw(db, uid, api_key, 'my.model', 'write',
[[record_id], {
'filter_domain': "[('active', '=', True)]"
}]
)Att skicka en faktisk Python-lista istället för en sträng är ett vanligt fel som ger typfel eller tysta misslyckanden beroende på Odoo-version. Serialisera alltid domänen till en sträng innan du skriver via API:t.
Rekommenderade arbetssätt
God vana sparar tid och huvudvärk — följ dessa råd när du arbetar med domänfält.
Validera domänsyntaxen innan driftsättning
Ett ogiltigt domänuttryck ger fel så fort Odoo försöker utvärdera det. Testa gärna i sökfältet eller i utvecklarläge innan du sparar uttrycket i automationsregler eller åtkomstregler. Ett snabbt search_count via API kan bekräfta att domänen returnerar det antal poster du förväntar dig.
Använd dynamiska variabler där det går
Undvik att hårdkoda användar- eller företags-id:n eller fasta datum i domäner. Använd istället dynamiska funktioner och variabler som uid, context_today() och current_company_id. Det gör dina filter mer portabla och minskar risken för tyst fel när miljöer skiljer sig åt.
Bind alltid modellkontexten
När du lägger ett Domain-fält i en egen modell — ange model_field och inkludera det i vyn. Utan detta ser användaren bara en textruta istället för den visuella byggaren, vilket ökar risken för ogiltiga domäner och sämre användbarhet.
Håll domäner läsbara
Mycket komplexa, nästlade domäner med | och & blir svåra att förstå och underhålla. Kommentera gärna syftet i koden eller överväg om en serveraction eller beräknat fält vore ett tydligare och mer testbart alternativ.
Använd safe_eval för programmatisk utvärdering
När du i kod behöver utvärdera domänsträngar, använd Odoos safe_eval istället för Pythons inbyggda eval. Det är säkrare, hanterar Odoo-specifika kontextvariabler och överensstämmer med hur plattformen själv utvärderar domäner.
Testa med realistisk data
Verifiera alltid att domänen matchar de förväntade posterna innan du går live. Det är särskilt viktigt för automationsregler och record rules — ett felaktigt filter kan leda till felaktiga åtgärder eller att användare blir oförklarligt blockerade.
Vanliga fallgropar
Här är de vanligaste misstagen när man jobbar med domänfält — och hur du undviker dem.
Att blanda ihop fälttyp med domänsyntax
Begreppet "domän" betyder två saker i Odoo: själva filtersyntaxen och fälttypen fields.Domain. Nya användare blandar ofta ihop lagringen (fältet) med logiken (uttrycket). Ett Domain-fält är bara behållaren; domänen är innehållet som beskriver filtreringen.
Skicka en lista istället för en sträng via API
När du skriver till ett Domain-fält via XML-RPC måste värdet vara en sträng. Att skicka en rå Python-lista leder till fel eller tysta avvikelser beroende på version. Serialisera alltid till sträng först.
Saknad modellkontext i widgeten
Om du lägger ett domänfält i en vy men inte anger modellkontext i widgetens options får användaren en textruta istället för den visuella byggaren. Domänbyggaren syns bara när widgeten vet vilken modell den ska använda — inkludera alltid model_field i vydefinitionen.
Hårdkodade post-id:n i domäner
Domäner som pekar på specifika post-id:n går sönder när poster tas bort eller när du flyttar konfiguration till en annan databas. Använd dynamiska referenser som uid eller relationer där möjligt för att göra domäner portabla.
För vida eller för snäva record rule-domäner
En alltför vid record rule kan exponera skyddade poster, en alltför snäv kan dölja data utan förklaring. Testa alltid record rules ur perspektivet för den användargrupp som påverkas, inte som admin som ofta undantas från reglerna.
Glöm inte arkiverade poster
Odoo exkluderar som standard arkiverade poster (active = False) från sökningar. Om din domän inte tar hänsyn till det kan du få oväntade luckor i datan. Lägg till ('active', 'in', [True, False]) om du vill inkludera arkiverade poster.
Sammanfattning
Domänfält är en osynlig grundpelare i Odoo som driver mycket av plattformens funktionalitet. Från åtkomstkontroll och automationsregler till dynamiska drop-downs och dashboardfilter — domänuttryck är ryggraden i hur poster filtreras, och fields.Domain ger utvecklare ett tydligt, validerat sätt att lagra och visa den logiken i datamodellen.
För slutanvändaren gör domänwidgeten det möjligt att skapa filter utan kod. För utvecklaren ger Domain-fälten klarhet jämfört med att använda generiska Char-fält med widget-override. Oavsett om du jobbar i Odoo Studio, skriver en modul i Python eller sätter upp arbetsflöden i gränssnittet — förståelsen för domänfält öppnar många möjligheter.
De här principerna gäller i stort sett över Odoo-versioner och moduler. Att investera tid i att förstå domänfält lönar sig — de finns bokstavligen överallt i Odoo.
Behöver ni hjälp med er Odoo-implementation?
Dasolo hjälper företag att implementera, anpassa och optimera Odoo efter sina affärsbehov. Oavsett om ni bygger automationer, skapar skräddarsydda moduler eller vill få mer ut av er befintliga installation kan vårt team bidra med erfarenhet och teknisk kompetens för att ta projektet framåt.
Har du frågor om domänfält eller någon annan del av er Odoo-lösning, kontakta oss gärna— vi tittar gärna på er setup och ger rekommendationer för nästa steg.