Come definire gli attributi variabili per un sistema di prodotto in mangusta (node.js)

Question

Sto costruendo un'app per negozio personale in cui gli utenti possono vendere gli articoli a vicenda, ma sto avendo difficoltà a capire come gestire il prodotti. Ad esempio, se vuoi vendere una maglietta dovresti essere in grado di scegliere una taglia e un colore ecc. Ma se vendi un computer devi specificare l'anno, la potenza della cpu, ecc. Tutti i prodotti hanno un titolo, un prezzo, immagini e così su, ma come faresti a cavartela con i vari attributi? Sto usando mongodb per gli oggetti.

Stavo pensando di avere un campo attributes che dovrebbe essere un oggetto con i diversi dettagli, e quindi un campo type che definirebbe quali proprietà esistono. Se type = 'Computer allora vorrei sapere che attributes sarebbe simile a questo.

attributes: { 
    capacity: 1000 // gb 
    ram: 4096 // MB 
} 

ecc

In un oggetto di design orientato normale avrei fatto ciò attraverso ereditarietà/interfacce. Se avete qualche idea sull'approccio migliore per questo in mangusta/node.js sarei felice di sentirlo.

Se io non sto facendo abbastanza chiaro nella questione prego di dirmi che cosa è vaga e ciò che dovrebbe essere chiarito

Edit:

Il seguente articolo descrive uno soluzione al problema http://learnmongodbthehardway.com/schema/chapter8/

Tuttavia non indica dove posizionare gli attributi. Una soluzione potrebbe essere quella di archiviarla nella categoria stessa, ma non sono sicuro delle migliori pratiche qui.

Answer 1

Un modo semplice per aggiungere alla vostra eredità Mongoose schemi è quello di utilizzare Discriminators. Ciò ti consentirà di creare uno schema principale in grado di memorizzare gli attributi che si trovano su tutti i tuoi prodotti come titolo, prezzo e immagini. È quindi possibile creare schemi figlio che conterranno attributi specifici per un tipo di prodotto come Elettronica e Abbigliamento. Ad esempio, nello schema elettronico è possibile aggiungere attributi per cpu e ram che non saranno presenti nello schema di abbigliamento.

Ecco un esempio di base di come è stato impostato utilizzando Nodo e Mangusta.

Nodo/Javascript

var mongoose = require('mongoose'); 
mongoose.connect('mongodb://localhost/test'); 

// When you create a Electronic Product, it will set the type to Eletronic. 
var options = { discriminatorKey: 'type' }; 

// parent Product schema. 
var productSchema = new mongoose.Schema({ name: String, price: Number }, options); 
var Product = mongoose.model('Product', productSchema); 

// child Electronic schema. 
var ElectronicProduct = Product.discriminator('Electronic', new mongoose.Schema({ cpu: Number }, options)); 
var computer = new ElectronicProduct({ name: 'computer', price: 100, cpu: 5 }); 
computer.save(); 

// child Clothing schema. 
var ClothingProduct = Product.discriminator('Clothing', new mongoose.Schema({ size: String }, options)); 
var shirt = new ClothingProduct({ name: 'shirt', price: 50, size: 'Small' }); 
shirt.save(); 

Se si accede agli oggetti che vengono salvati che dovrebbe essere simile

{ _id: 564b55983e5eec1ce2a44038, 
    type: 'Electronic', 
    cpu: 5, 
    price: 100, 
    name: 'computer' } 
{ _id: 564b55983e5eec1ce2a44039, 
    type: 'Clothing', 
    size: 'Small', 
    price: 50, 
    name: 'shirt' } 

Quando si tenta di accedere agli attributi che non sono nello schema del prodotto, si sarebbe una buona pratica controllare se l'attributo esiste prima di tentare di accedervi.

Answer 2

Se quello che stai chiedendo è come affrontare lo schema direi rendere il vostro modello di attributi un array di oggetti o di tipo misto

http://mongoosejs.com/docs/schematypes.html

Poiché è possibile avere molte opzioni possibili per gli attributi è impossibile per conoscerli tutti in anticipo. Forse vuoi che l'utente definisca il nome dell'attributo (la chiave) e anche il valore. Quindi, una volta ottenuto un oggetto, è possibile utilizzare un ciclo for in per utilizzare la chiave come etichetta e il valore.

esempio:

var attributes = []; 

for (attr in item.attributes) { 
    //do something with the key=>value pair 
    attributes.push({ 
     label: attr, 
     value: item.attributes[attr] 
    }); 
} 

//iterate through the new array to display your item attributes 

Answer 3

Per questo scenario di dati dinamici preferisco mantenere gli attributi come oggetto vuoto nel modello Mongoose, in modo da poter utilizzare vari attributi per ciascun documento.

Modello

var mongoose = require('mongoose'); 
Schema = mongoose.Schema; 

var productSchema = new mongoose.Schema({ 
    title:{type:String,required}, // Common Attributes 
    price:{type:Number,required}, // Common Attributes 
    images:[buffer], // Common Attributes 
    //Other Common Attributes goes here 
    attributes:{} // Empty attributes object which can vary for each product. 
}); 

var Product = mongoose.model('Product', productSchema); 

È possibile utilizzare gli attributi oggetto per specificare gli attributi variabili per il prodotto specifico.

controller

var computer = new Product({ 
title: 'Computer', 
price: 1000, 
attributes:{ 
    year:2000, 
    cpu:'test', 
    power:'75 RMS' 
    // Other Attributes goes here. 
} 
}); 


var shirt = new Product({ 
title: 'T-Shirt', 
price: 999, 
attributes:{ 
    size:30, 
    color:'black' 
    // Other Attributes goes here. 
} 
}); 

Riferimento:

http://mongoosejs.com/docs/schematypes.html (Cercare il tipo di dati misti)

Nota:

Ci sono altri modi per creare questo schema, un modo è quello di avere attributi come documento incorporato con tutte le combinazioni di attributi e può mantenere il valore come null se non è applicabile.

Spero che questo aiuti.