data-modeling - ExtJS 4:संघों और दुकानों के साथ मॉडल




store model-associations (5)

परिचय

मुझे ExtJS में Ext.data.Model क्लास के साथ एक एप्लिकेशन डिज़ाइन समस्या का सामना करना पड़ रहा है। मैं अपने विचारों को यहां एक बहुत ही आम ऑनलाइन स्टोर परिदृश्य में विकसित करने की कोशिश करूंगा, ताकि आप मेरा अनुसरण कर सकें। मैं वास्तव में अपने विचारों और निष्कर्षों पर किसी भी टिप्पणी की सराहना करता हूं!

मॉडल के

मान लें कि आप इस तथ्य को मैप करना चाहते हैं कि " प्रत्येक ग्राहक कई उत्पादों को ऑर्डर कर सकता है " ExtJS को। नंगे शब्दों से कोई इन तीन मॉडलों को शामिल कर सकता है: Customer , Order , और Product । इस मामले में Order Customer और Product एस को जोड़ता है।

संघों

मैंने पाया कि ExtJS वास्तव में आपको Ext.data.HasManyAssociation और Ext.data.BelongsToAssociation कक्षाओं का उपयोग करके इस (Customer)1-n(Order)1-n(Product) संबंध निर्दिष्ट करने की अनुमति देता है। लेकिन क्या यह एक चाहता है? क्या आप चाहते हैं कि एक Product हमेशा एक Order ? क्या होगा यदि आप किसी भी कनेक्शन के बिना किसी भी कनेक्शन के Product की एक सूची चाहते हैं?

स्टोर

यह वह जगह है जहां इसे अधिक एक्स्टजेस विशिष्ट मिलता है। ExtJS में आपके पास अपने सभी डेटा को रखने के लिए Ext.data.Store । मेरे डेटा को व्यवस्थित करने का एक प्राकृतिक तरीका मेरे प्रत्येक मॉडल के लिए Ext.data.Store :

  1. CustomerStore
  2. OrderStore
  3. ProductStore

तीन Ext.grid.Panel साथ-साथ होने पर विचार करें; प्रत्येक दुकान के लिए एक। एक ग्रिड में एक ग्राहक का चयन करते समय, उसके आदेश स्वचालित रूप से दूसरे ग्रिड में दिखाई देते हैं। दूसरे ग्रिड में ऑर्डर चुनते समय संबंधित उत्पाद तीसरे ग्रिड में दिखाई देते हैं।

क्या यह आपके लिए स्वाभाविक है? यदि नहीं, तो कृपया टिप्पणी करें!

इसे सब एक साथ लाओ

तो अब हमारे पास तीन चीजें हैं जिन्हें हमें एक साथ लाने की जरूरत है:

  1. मॉडल और उनके
  2. संघ (है belongsTo , belongsTo ) और
  3. डेटा ( Store एस)

क्या मॉडल-मॉडल संबंध के केवल एक तरफ से एक एसोसिएशन को परिभाषित करना संभव है? उदाहरण के लिए, क्या मैं निर्दिष्ट कर सकता हूं कि Order कई Product लेकिन छोड़ दें कि एक Product Order ? क्योंकि एक Product वास्तव में एक से अधिक Order से संबंधित हो सकता है। इसलिए मैं निर्दिष्ट करता हूं कि Product मॉडल में बहुत से Order हैं।

ExtJS में मॉडल यहां दिए गए हैं:

ग्राहक

Ext.define('Customer', {
    extend   : 'Ext.data.Model',
    requires : [
        'Order',
    ],
    fields   : [
           {name : 'id',          type : 'int'},
           {name : 'lastname',    type : 'string'}
           {name : 'firstname',   type : 'string'}
    ],
    hasMany: 'Order' /* Generates a orders() method on every Customer instance */
});

क्रम

Ext.define('Order', {
    extend   : 'Ext.data.Model',
    fields   : [
            {name : 'id',          type : 'int'},
            {name : 'customer_id', type : 'int'}, /* refers to the customer that this order belongs to*/
            {name : 'date',        type : 'date'}
    ],
    belongsTo: 'Customer', /* Generates a getCustomer method on every Order instance */
    hasMany: 'Product' /* Generates a products() method on every Order instance */
});

उत्पाद

Ext.define('Product', {
    extend   : 'Ext.data.Model',
    fields   : [
            {name : 'id',          type : 'int'},
            {name : 'name',        type : 'string'},
            {name : 'description', type : 'string'},
            {name : 'price',       type : 'float'}
    ],
    /*
        I don't specify the relation to the "Order" model here
        because it simply doesn't belong here.

        Will it still work?
    */
    hasMany: 'Order'
});

और यहां स्टोर हैं:

CustomerStore

Ext.define('CustomerStore', {
    extend      : 'Ext.data.Store',
    storeId     : 'CustomerStore',
    model       : 'Customer',
    proxy   : {
        type   : 'ajax',
        url    : 'data/customers.json',
        reader : {
            type           : 'json',
            root           : 'items',
            totalProperty  : 'total'
        }
    }
});

OrderStore

Ext.define('OrderStore', {
    extend      : 'Ext.data.Store',
    storeId     : 'OrderStore',
    model       : 'Order',
    proxy   : {
        type   : 'ajax',
        url    : 'data/orders.json',
        reader : {
            type           : 'json',
            root           : 'items',
            totalProperty  : 'total'
        }
    }
});

ProductStore

Ext.define('ProductStore', {
    extend      : 'Ext.data.Store',
    storeId     : 'ProductStore',
    model       : 'Product',
    proxy   : {
        type   : 'ajax',
        url    : 'data/products.json',
        reader : {
            type           : 'json',
            root           : 'items',
            totalProperty  : 'total'
        }
    }
});

यहां कंपनियों और उनके उत्पादों के साथ एक उदाहरण (मेरे द्वारा नहीं) है http://superdit.com/2011/05/23/extjs-load-grid-from-another-grid/ । यह दो मॉडल और दो स्टोर का उपयोग करता है लेकिन कोई संघ परिभाषित नहीं होता है।

पहले ही, आपका बहुत धन्यवाद

-Konrad


Answers

यह सब एक्स्टजेएस 4 में ठीक काम करता है, पहली बार सही होना मुश्किल है। खैर, पहले कुछ बार।

हां, आप बच्चे के एसोसिएशन के संबंध में निर्दिष्ट करने से बच सकते हैं, और अभी भी इसका उपयोग कई रिश्ते में कर सकते हैं।

मेरी परियोजना में, हमारे पास दर्जनों मॉडल हैं, जिनमें से कई गहरे संबंध हैं, और यह बहुत अच्छा काम करता है।

कई-रिश्तों के संबंध में, आपके पास होना चाहिए

ग्राहक - <ग्राहक ऑर्डर> - ऑर्डर

तीन मॉडल कौन सा है,

या आप सर्वर पर काम करने का एक गुच्छा करके इसे "नकली" कर सकते हैं ताकि यह दिखाया जा सके कि एक ग्राहक हैसनी ऑर्डर। नेस्टेड जेसन यहां मदद कर सकते हैं।


कृपया ध्यान दें कि आपकी धारणा:

(ग्राहक) 1-एन (ऑर्डर) 1-एन (उत्पाद)

गलत है। आपका वास्तविक मॉडल होना चाहिए:

(ग्राहक) 1-एन (ऑर्डर) एन -एन (उत्पाद)

यही कारण है कि आपको इसके साथ मॉडलिंग में कठिनाइयों का सामना करना पड़ा है


कोनराड। मुझे हाल ही में Models+Associations+Stores निपटने का सामना करना पड़ा। यह बहुत सुखद अनुभव नहीं था। मैंने जो सीखा है वह यहां है:

मान लीजिए कि हमारे पास स्टोर 1, स्टोर 2, मॉडल 1, मॉडल 2, ग्रिड 1, ग्रिड 2 है। ग्रिड 1 स्टोर 1 का उपयोग करता है, स्टोर 1 मॉडल 1 का उपयोग करता है और इसी प्रकार ग्रिड 2 स्टोर 2 का उपयोग करता है, स्टोर 2 मॉडल 2 का उपयोग करता है।

अब तक सभी काम कर रहे हैं, डेटा लोड हो रहा है और इसी तरह।

लेकिन अब हम hasMany सहयोग जोड़ना चाहते हैं। ठीक है, हम Model1 की कॉन्फ़िगरेशन में जोड़ रहे हैं:

hasMany: {model: 'Model2', name: 'model2'}

इसके बाद आपको लगता है कि आप स्टोर 2 को ग्रिड 1 के itemclick पर डेटा के साथ कुछ ऐसा करने के द्वारा पॉप्युलेट कर सकते हैं:

Grid1.on('itemclick', function(view, item_which_uses_model1){
  //item_which_uses_model1.model2() supposed to return Model2's store
  item_which_uses_model1.model2().load();
}

आप उम्मीद कर रहे हैं कि ग्रिड 2 ग्रिड 1 के itemclick पर डेटा के साथ आबादी है। लेकिन कुछ भी नहीं होता है। वास्तविक अनुरोध पोस्ट किए जा रहे हैं, प्रतिक्रियाएं प्राप्त की गई हैं। लेकिन ग्रिड 2 डेटा के साथ पॉप्युलेट नहीं है।
और कुछ समय बाद आप यह महसूस कर रहे हैं कि item_which_uses_model1.model2() Store2 नहीं है

जब मॉडल 2 "देखता है" कि यह मॉडल 1 के साथ सहयोग करता है तो यह मॉडल 1 की अपनी दुकान बनाता है जो स्टोर 2 के बराबर नहीं है।

यह अच्छा नहीं है, क्योंकि ग्रिड 2 स्टोर 2 का उपयोग कर रहा है।

असल में आप इसे हैक कर सकते हैं, उदाहरण के लिए, ग्रिड 2 की कॉन्फ़िगरेशन में जोड़ना:

store: new Model1().model2(),

लेकिन अगर आप ExtJS एमवीसी पैटर्न का उपयोग कर रहे हैं तो क्या होगा। ग्रिड 2 को मॉडल 1 के बारे में कुछ भी पता नहीं है।

मैं वास्तविक दुनिया परियोजनाओं में associations का उपयोग करने की सिफारिश नहीं करता हूं। कम से कम अब। इसके बजाय दृष्टिकोण का उपयोग करें जो आपके उदाहरण में दिखाया गया है: मॉडल + स्टोर + फ़िल्टरिंग।


मैं आण्विक आदमी से पूरी तरह से सहमत हूं। ExtJS दस्तावेज को पढ़कर यह सबूत के रूप में दिखाई दिया कि यह एक अच्छा मार्ग है जब आप विभिन्न दुकानों में वितरित वृक्ष सेट संरचना का उपयोग कर रहे हैं। वाकई, यह सब केवल तभी सच हो सकता है जब इस तरह के एसोसिएशन किसी भी तरह से कॉल करने के लिए दुकानों का संदर्भ था। मैंने जो परीक्षण किया है उससे वह मामला नहीं है। मॉडल संघों के पास ऐसा रिश्ता नहीं है। फ़िल्टरिंग उन अन्य ग्रिड को अनुक्रमिक रूप से अपडेट करने का सबसे अच्छा तरीका है जिनके मॉडल दूसरों पर निर्भर करते हैं।


मैं एक सेन्चा टच शिक्षार्थी भी हूं, मुझे सिर्फ सेन्चा आधिकारिक वेबसाइट से कुल मिलाकर मिलता है। हो सकता है कि आप इस लिंक को देख सकें: http://www.sencha.com/learn/my-first-sencha-touch-experience यह सेन्चा वेबसाइट से है।