Breeze.js टाइप की गई इकाइयां

Question

क्या ब्रीज़ का उपयोग करके टाइप की गई इकाइयों को बनाने का कोई तरीका है, जिस तरह से जेएसवीसीयूटी जयदाता के लिए काम करता है? क्या इसमें टाइपस्क्रिप्ट समर्थन शामिल है - क्या ब्रीज़ फ्रेमवर्क के भीतर सामान्य टाइपस्क्रिप्ट समर्थन भी है?

Answer 1

हमारे पास टाइपस्क्रिप्ट के साथ और अधिक करने की योजना है, लेकिन अभी तक एक विशिष्ट समय सीमा के लिए प्रतिबद्ध नहीं है। (जॉन की पोस्ट में उल्लिखित बोरिस का काम निश्चित रूप से एक महान शुरुआत है)।

अद्यतन: वी 0.84.4 के रूप में, ब्रीज़ पूर्ण टाइपस्क्रिप्ट समर्थन प्रदान करता है।

जहां तक ​​स्वचालित रूप से प्रत्येक इकाई के लिए डिज़ाइन समय जावास्क्रिप्ट कक्षाएं उत्पन्न होती हैं; हमने इस पर कई आंतरिक चर्चाएं की हैं, लेकिन वास्तव में यह देखने का इंतजार कर रहे हैं कि समुदाय क्या वोट देता है। हम लगभग निश्चित रूप से इस बिंदु पर पहुंच जाएंगे, लेकिन
UserVoice पर आपके वोट निश्चित रूप से प्रक्रिया को तेज कर सकते हैं।

Answer 2

टाइपस्क्रिप्ट के संबंध में, यह निश्चित रूप से हमारे रडार पर है। कम से कम हम एक टाइपस्क्रिप्ट 'घोषणा' फ़ाइल तैयार करेंगे जो ब्रीज़ का उपयोग करते समय बेहतर इंटेलिजेंस की अनुमति देगा।

आप इसे UserVoice पर वोट कर सकते हैं।

तब तक आप बोरीस यंकोव के DefinitelyTyped का उपयोग करना चाहेंगे जो ब्रीज़ का समर्थन करता है।

Answer 3

मेरे दो सेंट ...

मैं हवा के लिए definatelytyped परिभाषा फ़ाइल का उपयोग किया गया है और यह अच्छी तरह से काम करने लगता है।

एक .edmx में सभी इकाइयों के लिए .d.ts फ़ाइलों को उत्पन्न करने के लिए टी 4 स्क्रिप्ट बनाने के लिए यह काफी सरल है और फिर आपको इच्छित इंटेलिजेंस मिलता है। अगर वार्ड पसंद करते हैं, तो मैं कहीं नमूना टी 4 स्क्रिप्ट पोस्ट कर सकता हूं।

Answer 4

इस गिस्ट में टी 4 टीएस का एक संशोधित संस्करण है जिसमें "प्रत्येक इकाई के लिए डिज़ाइन टाइम जावास्क्रिप्ट कक्षाएं" उत्पन्न करने के लिए कुछ प्रारंभिक समर्थन शामिल है।

https://gist.github.com/alexdresko/5393155

अब तक, यह मेरी जरूरतों सूट। मुझे यकीन है कि इस समाधान के लिए आपको अपने समाधान में निश्चित रूप से परिभाषित ब्रीफ परिभाषा की आवश्यकता है।

शायद यह ऐसा कुछ है जिसे टी 4 टीएस में स्थायी रूप से जोड़ा जा सकता है? शायद यह ब्रीज़ टीम के लिए विचार करने के लिए कुछ है? या शायद यह सिर्फ बेवकूफ है और वास्तव में मेरे लिए किसी के लिए काम नहीं करता है। :)

मेरी dataservice में, मैं की तरह कुछ कर सकते हैं:

createOrganization() : T4TS.Organization { 
     return <T4TS.Organization>this.manager.createEntity("Organization"); 
    } 

तब मेरे वीएम में इस कोड के सभी अच्छी तरह से है, typesafe ..

organizationSubmit() { 
     this.editingOrganization(false); 
     var newOrganization = this.dataservice.createOrganization(); 

     newOrganization.Name(this.organizationNameInput()); 
     if (newOrganization.entityAspect.validateEntity()) { 
      this.extendOrganization(newOrganization); 
      this.organizations.push(newOrganization); 
      this.dataservice.saveChanges(); 
      this.organizationNameInput(""); 
     } else { 
      this.handleItemErrors(newOrganization); 

     } 
    }; 

मैं वास्तव में नहीं है पता है कि यहां से कहां जाना है। मैंने टी 4 टीएस को तोड़ने की कोशिश की, लेकिन उसके निर्माण प्रणाली को समझने के लिए समय नहीं था। इसलिए जिस्ट। राय निश्चित रूप से स्वागत है।

Answer 5

नीचे एक पृष्ठ है जिसे आप अपनी साइट में टाइपस्क्रिप्ट इंटरफ़ेस परिभाषाएं उत्पन्न करने के लिए छोड़ सकते हैं। पृष्ठ हवा मेटाडाटा लाता है फिर सभी प्रकार के माध्यम से पुनरावृत्त करता है और प्रत्येक प्रकार के लिए एक टाइपस्क्रिप्ट इंटरफ़ेस घोषणा को आउटपुट करता है।इस पृष्ठ के आउटपुट को किसी भी प्रकार की प्रतिलिपि फ़ाइल (* .ts) या टाइपस्क्रिप्ट परिभाषा फ़ाइल (* .d.ts) में चिपकाया जा सकता है। यदि आप इंटरफेस को नामस्थान बनाना चाहते हैं तो परिणामों को मॉड्यूल घोषणा में संलग्न करें: declare module northwind { ... paste interfaces here... }।

पृष्ठ का उपयोग करने से पहले आपको एक संपादन करने की आवश्यकता होगी: "एपीआई/नॉर्थविंड" से इकाई प्रबंधक के नियंत्रक यूआरएल को बदलें जो भी आपके एयर कंट्रोलर यूआरएल है।

उत्पन्न इंटरफेस Knockout.js टाइपप्रति परिभाषाएँ जो आप यहां प्राप्त कर सकते पर निर्भरता है: https://github.com/borisyankov/DefinitelyTyped/tree/master/knockout/

learn.breezejs.com से northwind उदाहरण का उपयोग करना, इस परिभाषा के जनरेटर पेज के उत्पादन में कुछ इस तरह होगा:

export interface Employee extends breeze.Entity { 
    FirstName: KnockoutObservable<string>; 
    LastName: KnockoutObservable<string>; 
} 

आप तो हवा का उपयोग कर एक प्रश्न निष्पादित और इस तरह के कर्मचारियों की एक सरणी के लिए परिणाम डाली सकता है:

var manager = new breeze.EntityManager('api/northwind'); 

var query = new breeze.EntityQuery() 
    .from("Employees"); 

manager.executeQuery(query).then(data => { 
    // ***cast the results to a strongly typed array of Employee*** 
    var employees = <Employee[]>data.results; 
}).fail(e => { 
    alert(e); 
}); 

नीचे परिभाषा जनरेटर पृष्ठ है- "परिभाषा.html" नामक अपनी परियोजना में एक नई HTML फ़ाइल जोड़ें, प्रोजेक्ट चलाएं और पृष्ठ पर नेविगेट करें।

<html> 
<head> 
    <title>Typescript Definition Generator</title> 
    <style> 
     code { 
      white-space: pre; 
     } 
    </style> 
    <script src="//code.jquery.com/jquery-2.1.0.min.js"></script> 
    <script src="//ajax.aspnetcdn.com/ajax/knockout/knockout-3.0.0.js"></script> 
    <script src="//cdnjs.cloudflare.com/ajax/libs/q.js/1.0.0/q.min.js"></script> 
    <script src="//cdnjs.cloudflare.com/ajax/libs/breezejs/1.4.4/breeze.min.js"></script> 
    <script type="text/javascript"> 
     $(document).ready(function() { 
      var entityManager = new breeze.EntityManager('api/northwind'); 
      entityManager.fetchMetadata() 
       .then(function() { 
        var html = '', 
         types = entityManager.metadataStore.getEntityTypes(), 
         type, 
         i, 
         j, 
         property, 
         crlf = String.fromCharCode(13), 
         code = document.createElement('code'), 
         script = document.createElement('script'); 

        function getJSType(metadataType) { 
         if (/(Int64)|(Int32)|(Int16)|(Byte)|(Decimal)|(Double)|(Single)|(number)/.test(metadataType)) 
          return 'number'; 
         else if (/(DateTime)|(DateTimeOffset)|(Time)|(Date)/.test(metadataType)) 
          return 'Date'; 
         else if (/(Boolean)/i.test(metadataType)) 
          return 'boolean'; 
         return 'string'; 
        } 

        for (i = 0; i < types.length; i++) { 
         // type declaration 
         var type = types[i]; 
         html += 'export interface ' + type.shortName; 

         // base type 
         html += ' extends '; 
         if (type.hasOwnProperty('baseEntityType')) { 
          html += type.baseEntityType.shortName; 
         } else { 
          html += 'breeze.Entity'; 
         } 
         html += ' {' + crlf; 

         // data properties 
         for (j = 0; j < type.dataProperties.length; j++) { 
          property = type.dataProperties[j]; 
          if (type.baseEntityType && type.baseEntityType.dataProperties.filter(function (p) { return p.name === property.name; }).length > 0) 
           continue; 
          html += ' ' + property.name; 
          //if (property.isNullable) 
          // html += '?'; 
          html += ': KnockoutObservable&lt;'; 
          html += getJSType(property.dataType.name); 
          html += '&gt;; //' + property.dataType.name + crlf; 
         } 

         // navigation properties 
         for (j = 0; j < type.navigationProperties.length; j++) { 
          property = type.navigationProperties[j]; 
          if (type.baseEntityType && type.baseEntityType.navigationProperties.filter(function (p) { return p.name === property.name; }).length > 0) 
           continue; 
          html += ' ' + property.name; 
          //if (property.isNullable) 
          // html += '?'; 
          if (property.isScalar) 
           html += ': KnockoutObservable&lt;'; 
          else 
           html += ': KnockoutObservableArray&lt;'; 
          html += property.entityType.shortName; 
          html += '&gt;;' + crlf; 
         } 

         html += '}' + crlf + crlf; 
        } 

        code.innerHTML = html; 

        $(code).addClass('prettyprint'); 

        document.body.appendChild(code); 

        script.setAttribute('src', '//google-code-prettify.googlecode.com/svn/loader/run_prettify.js'); 
        document.body.appendChild(script); 
       }) 
       .fail(function (reason) { 
        alert(reason); 
       }); 
     }); 
    </script> 
</head> 
<body> 
</body> 
</html> 

Answer 6

हवा टाइपप्रति defiintions के लिए, NuGet पैकेज breeze.TypeScript.DefinitelyTyped का उपयोग करें। अपनी संस्थाओं के लिए परिभाषाएं बनाने के लिए, आप TypeLITE का उपयोग कर सकते हैं। यह इस तरह इंटरफेस के साथ एक .d.ts फ़ाइल बनाने जाएगा:

declare module MyProject.Models { 
interface Customer { 
    Id: number; 
    AccountNumber: string; 
    ... 

इन इंटरफेस पूरी तरह से अपने संस्थाओं का वर्णन है, वे breeze.Entity का विस्तार नहीं है। हवा एपीआई प्रकार परिभाषा के साथ अच्छी तरह से खेलने के लिए,, इन से अपना खुद का इंटरफेस निकाले जाते हैं इस तरह:

import Models = MyProject.Models; 
interface Customer extends Models.Customer, breeze.Entity { } 
... 

यह अभी भी कुछ मैनुअल कोडिंग शामिल है, लेकिन कम से कम यह केवल प्रकार के अनुसार है संपत्ति प्रति नहीं।