Introduktion
Many2One-fältet är en av de mest centrala byggstenarna i Odoos datamodell. När du kopplar en offert till en kund, sätter en produkt i en kategori eller knyter en uppgift till ett projekt, använder du i praktiken en Many2One-relation. För den som bygger eller anpassar Odoo är förståelsen för detta fälts beteende helt avgörande.
Ur ett verksamhetsperspektiv är Many2One det som binder ihop modulerna till ett sammanhängande system. Utan sådana länkar skulle varje modul vara en separat ö, med dem flyter informationen fritt och användarna kan hoppa mellan relaterade dokument utan att behöva tänka på databasen bakom kulisserna.
Denna guide förklarar vad ett Many2One-fält lagrar och hur det beter sig i Odoos ORM och i användargränssnittet. Du får också veta hur du skapar och konfigurerar fältet med Odoo Studio, Python eller API, samt konkreta affärsexempel från CRM, försäljning, lager och redovisning.
Vad är Many2One-fältet i Odoo?
I Odoos ORM representerar Many2One en pekning från ett register till exakt ett annat register i ett målmodel. Namnet speglar relationens riktning: många poster här kan peka på en post där. Några typiska exempel är flera order som pekar på samma kund, eller många produkter som delar en produktkategori.
I databasen sparas en Many2One som en främmande nyckel på den aktuella tabellen. Om en order pekar på partner med ID 42, så innehåller kolumnen partner_id värdet 42. Odoos ramverk tar hand om att hämta och visa det relaterade objektets namn åt dig.
I användargränssnittet visas Many2One vanligtvis som en sökbar dropdown eller ett fält med automatisk filtrering. Användaren börjar skriva och träffar visas i realtid; välja en post sätter länken och fältet visar det mänskliga namnet, inte det interna ID:t — vilket gör det mycket användarvänligt.
Exempel i Python-modell
from odoo import fields, models
class SaleOrder(models.Model):
_inherit = 'sale.order'
x_account_manager_id = fields.Many2one(
comodel_name='res.users',
string='Account Manager',
ondelete='set null',
)
Parametern comodel_name anger vilket modellnamn som fältet pekar på. ondelete bestämmer vad som händer om det länkade objektet raderas: cascade tar med sig pekande poster, set null nollställer referensen och restrict blockerar borttagningen om något pekar på posten.
I Odoo Studio heter fälttypen "Many2One" i fältväljaren. När du lägger till den via Studio väljer du målmodell i en lista och Studio skapar fältet åt dig. Det är ett snabbt och kodfritt sätt att bygga relationer i gränssnitten.
Hur fältet fungerar
När du läser ett Many2One i ORM får du ett recordset med den relaterade posten, eller ett tomt recordset om fältet är osett. I Python kan du nå relaterade fält direkt via punktnotation:
order = self.env['sale.order'].browse(1) customer_name = order.partner_id.name customer_city = order.partner_id.city
Den här kedjeåtkomsten sparar dig från att skriva SQL-joins manuellt — ORM tar hand om frågorna åt dig och ger ett enkelt sätt att nå data över modeller.
Via XML-RPC skickas Many2One-fält som en tvåelementlista: [id, visningsnamn], till exempel [42, "Acme Corp"]. Om fältet saknar värde returneras False. Detta är viktigt att känna till när du skriver integrationsskript.
Viktiga fältattribut
Följande egenskaper är de mest användbara att ställa in på ett Many2One-fält i Odoo:
- comodel_name: Det tekniska namnet på målmodellen. Detta är det enda obligatoriska argumentet.
- ondelete: Bestämmer vad som händer när målposten raderas — 'cascade', 'set null' eller 'restrict'. Standard är ofta 'set null'.
- domain: Ett filter som begränsar vilka poster som går att välja i dropdownen, till exempel domain=[('customer_rank', '>', 0)] för att bara visa kunder.
- context: Extra kontext som skickas när dropdownen öppnas eller en ny relaterad post skapas. Användbart för att förifylla fält.
- required: Sätter fältet som obligatoriskt — posten kan inte sparas utan ett värde.
- readonly: Gör fältet skrivskyddat i gränssnittet, användbart när länken ska kontrolleras av kod och inte ändras manuellt.
- delegate: Om True exponeras målmodellens fält direkt på den aktuella modellen — används för arv, inte för vanliga relationer.
Visning i vyer
I formulärvyer renderas Many2One som en sökbar dropdown där du kan skriva för att filtrera resultat. Det finns också en länkikon för att öppna den länkade posten direkt, vilket underlättar navigering mellan relaterade dokument.
I listvyer visas Many2One som det länkade objektets namn och det går att gruppera vyer efter fältet — till exempel gruppera order per kund, något som ofta används i rapportering.
I sök-/filtervyer fungerar Many2One både som filter- och grupperingsterm. När du filtrerar CRM-pipelinen på kundsidan är det i själva verket ett Many2One-fält du söker på.
Den omvända One2Many
Every Many2One-relation har en naturlig motsvarighet: One2Many. Om flera order pekar på en kund via Many2One kan kunden visa alla dessa order med ett One2Many-fält. Det är god praxis att definiera båda sidorna för bättre navigering; One2Many skapar ingen extra kolumn i databasen utan räknas fram utifrån Many2One-kolumnen.
Affärsscenarier
Many2One i vardagen — fem praktiska exempel
CRM: Koppla leads till säljare
I CRM används ofta ett user_id Many2One som pekar på res.users för att ange ansvarig säljare. Det gör det enkelt för chefer att filtrera pipeline per säljare, följa konverteringsgrad och distribuera leads i bulk. Vill du ha flera ansvariga skapar du bara ytterligare Many2One-fält mot samma modell.
Försäljning: Order, kund och prislista
En försäljningsorder har normalt partner_id (kund) och pricelist_id (prislista) som Many2One. När kund väljs kan Odoo via onchange-logik fylla i prislista, betalningsvillkor och leveransadress automatiskt — en stor fördel av ett konsekvent relationsläge i datamodellen.
Lager: Produkter och kategorier
Varje produkt pekar på en produktkategori via Many2One (categ_id). Kategorin styr bland annat konton vid kostnad och intäkt, värderingsmetod och lagerstrategier. Korrekt kategorisering är viktigt för rätt bokföring — Many2One gör det enkelt att välja en delad kategori för många produkter.
Redovisning: Bokföringsposter och journaler
Varje verifikation (account.move) har en journal_id Many2One som anger vilken journal som används. Journalvalet påverkar nummerserie, typ (sälj, inköp, bank med mera) och ibland standardkonton. Fel journal ger felplacering i huvudboken, så detta Many2One är ett viktigt styrinstrument.
Projekt: Uppgifter och projekt
I projektmodulen anger project_id på task vilken projektuppsättning uppgiften tillhör. Den länken styr vilka faser som gäller, åtkomst för teammedlemmar och hur tidrapportering kopplas till fakturering — avgörande för konsultbolag som fakturerar per projekt.
Skapa eller anpassa Many2One-fältet
Tre sätt att lägga till Many2One beroende på teknisk nivå
Via Odoo Studio (utan kod)
Odoo Studio är verktyget för snabba ändringar utan kod. För att lägga till ett Many2One via Studio:
- Öppna Studio från huvudmenyn.
- Gå till det formulär där fältet ska finnas.
- Dra in ett Many2One-fält från fältväljaren till formen.
- I egenskapsrutan välj målmodellen.
- Sätt etikett och eventuellt domain-filter för att begränsa val.
- Spara och stäng Studio.
Studio skapar fältet med prefix x_studio_ och lägger in det i vyn direkt. Fältet fungerar omgående — ett snabbt sätt att lägga till relationsfält utan teknisk kompetens.
Via Python i en modul
För mer kontrollerad utveckling i versionshantering definieras Many2One i Python i din modul. Detta är rekommenderat för produktionskod och deployment över flera miljöer:
from odoo import fields, models
class ProjectTask(models.Model):
_inherit = 'project.task'
x_client_contact_id = fields.Many2one(
comodel_name='res.partner',
string='Client Contact',
domain=[('type', '=', 'contact')],
ondelete='set null',
help='The main contact at the client for this task.',
)
Efter att ha definierat fältet lägger du in det i vyernas XML och kör en uppgradering för att applicera databasändringarna. Metoden ger full kontroll över domäner, ondelete-beteende och integration med compute-metoder och constraints — standardvägen för produktionsmoduler.
Det är även god praxis att skapa motsvarande One2Many på målmodellen så att användare kan navigera båda hållen:
class ResPartner(models.Model):
_inherit = 'res.partner'
x_task_ids = fields.One2many(
comodel_name='project.task',
inverse_name='x_client_contact_id',
string='Related Tasks',
)
Via XML-RPC API
När du automatiserar konfigurationer externt, till exempel genom ett skript eller infrastrukturom, kan Many2One-fält skapas via XML-RPC:
field_id = models.execute_kw(
ODOO_DB, uid, ODOO_API_KEY,
'ir.model.fields', 'create',
[{
'name': 'x_client_segment_id',
'field_description': 'Client Segment',
'model_id': model_id,
'ttype': 'many2one',
'relation': 'res.partner.category',
'on_delete': 'set null',
'state': 'manual',
}]
)
Nyckeln relation anger målmodellen och on_delete sätter raderingsbeteendet. Skapar du fält via API, skapa även den omvända One2Many så att navigeringen fungerar från båda håll — ett krav i flertalet automatiserade konfigurationer.
Rekommenderade arbetsmetoder
1. Skapa alltid motsvarande One2Many
När du lägger till ett Many2One, skapa också One2Many på målmodellen. Det kostar inte en extra databas-kolumn men ger mycket bättre användarnavigering; utan den omvända länken kan användare inte se vilka poster som pekar tillbaka.
2. Använd domain-filter för att styra val
Ett Many2One mot res.partner visar alla partnertyper som standard. Om fältet ska användas för kunder endast, lägg en domain såsom [('customer_rank', '>', 0)] för att minska brus och undvika felaktiga val.
3. Välj ondelete med omsorg
ondelete påverkar data i större utsträckning än man tror. cascade kan orsaka massraderingar vid ett misstag. I de flesta fall är set null säkrare eftersom referensen bara nollställs. Använd restrict när målposten aldrig bör tas bort medan pekande poster finns.
4. Undvik att duplicera data som bör vara Many2One
Ett vanligt misstag är att lägga in ett char-fält för exempelvis företagsnamn istället för en Many2One mot res.partner. Det skapar duplicerad information, gör filtrering och gruppering opålitligt och leder till inkonsekvenser när namn ändras. Använd relationen där data redan finns i en modell.
5. Utnyttja context för förifyllning
Context på Many2One låter dig skicka förifyllda värden när användaren skapar en relaterad post från dropdownen. Exempelvis kan du automatiskt sätta projektet på en ny kontakt som skapas från en projektkontext — minskar manuell inmatning och ökar datakvaliteten.
Vanliga fallgropar
Att glömma den omvända One2Many
Den vanligaste missen är att skapa Many2One utan motsvarande One2Many. Resultatet blir envägsnavigering: du kan se länken från källan men från målposten finns ingen samling av pekande poster, vilket ofta leder till att användarna efterfrågar specialrapporter eller manuella sökningar.
Att använda cascade utan eftertanke
Att sätta ondelete='cascade' kan i värsta fall radera stora mängder data om en masterpost tas bort eller arkiveras. Exempelvis kan en raderad produktkategori med cascade göra att alla produkter i kategorin försvinner — i de flesta affärssituationer är set null eller restrict bättre alternativ.
Att inte hantera False i Python-navigering
När ett Many2One är tomt returnerar ORM ett tomt recordset som är falskt. Om koden gör order.partner_id.name utan kontroll kan du få tom sträng eller tyst fel längre ner i kedjan, särskilt om du går flera nivåer djupare (order.partner_id.country_id.name). Kontrollera alltid att relationen finns när fältet inte är obligatoriskt.
Peka mot fel modell
res.partner används för kunder, leverantörer, kontakter och företag. Ett Many2One mot denna modell utan domain ger tillgång till alla typer — vilket kan förvilla användare om fältet är avsett för exempelvis enbart kunder. Definiera en domain som matchar affärsbehoven.
Överanvända Many2One när en Selection räcker
Om värdena är en liten, statisk uppsättning så är ett Selection-fält ofta enklare och snabbare än Many2One. Relationsfält kräver en egen modell och medför joins i frågor. För statusfält med få alternativ är Selection ofta ett bättre val; Many2One passar när värdena är många, användardrivna eller återanvänds i flera modeller.
Avslutning
Many2One är själva ryggraden i hur Odoo länkar data över moduler. Förståelsen är inte bara för utvecklare — även business analysts, konsulter och power users som arbetar i Studio vinner mycket på att veta när och hur relationen bör användas.
Sammanfattning: skapa alltid den omvända One2Many för tvåvägsnavigering, använd domain för relevanta val, välj ondelete med omsorg och låt inte Many2One ersätta enkla Selection-fält när det inte behövs.
Oavsett om du konfigurerar i Studio, skriver en modul i Python eller hanterar modellen via XML-RPC, så gör rätt relationsdesign från början din Odoo-implementation stabilare och lättare att underhålla över tid.
Om ni behöver hjälp med Odoo Kontakta oss gärna så tar vi ett samtal om ert Odoo-projekt.