एक्सप्रेस और हाईपी एक दूसरे से तुलना कैसे करते हैं?


133

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

उदाहरण के लिए, जहां तक ​​मैंने सीखा है, हापी एक अलग मार्ग तंत्र का उपयोग करता है जो पंजीकरण आदेश को ध्यान में नहीं रखता है, तेजी से लुकअप कर सकता है, लेकिन एक्सप्रेस की तुलना में सीमित है। क्या अन्य महत्वपूर्ण अंतर हैं?

नई npmjs.com वेबसाइट को विकसित करने के लिए हापी (ओवर एक्सप्रेस) चुनने के बारे में एक लेख भी है , इस लेख में कहा गया है कि "हापी के प्लगइन सिस्टम का मतलब है कि हम आवेदन के विभिन्न पहलुओं और सेवाओं को अलग-अलग तरीके से अलग कर सकते हैं जो कि माइक्रोसोर्विस में अनुमति देगा। भविष्य।, दूसरी ओर, उसी कार्यक्षमता को प्राप्त करने के लिए थोड़ा और कॉन्फ़िगरेशन की आवश्यकता है ", इसका वास्तव में क्या मतलब है?

जवाबों:


231

यह एक बड़ा सवाल है और इसे पूरा करने के लिए एक लंबे उत्तर की आवश्यकता है, इसलिए मैं सबसे महत्वपूर्ण अंतरों के सबसेट को संबोधित करूंगा। माफी कि यह अभी भी एक लंबा जवाब है।

वे समान कैसे हैं?

आपके कहने पर आप बिल्कुल सही हैं:

बुनियादी उदाहरणों के लिए वे समान लगते हैं

दोनों चौखटे एक ही मूल समस्या को हल कर रहे हैं: नोड में HTTP सर्वर के निर्माण के लिए एक सुविधाजनक एपीआई प्रदान करना। यह कहना है, httpअकेले निचले स्तर के देशी मॉड्यूल का उपयोग करने की तुलना में अधिक सुविधाजनक है । httpमॉड्यूल सब कुछ हम चाहते हैं कर सकते हैं, लेकिन यह साथ आवेदन पत्र लिखने के लिए कठिन है।

इसे प्राप्त करने के लिए, वे दोनों उन अवधारणाओं का उपयोग करते हैं जो लंबे समय से उच्च स्तरीय वेब फ्रेमवर्क में हैं: रूटिंग, हैंडलर, प्लगइन्स, प्रमाणीकरण मॉड्यूल। वे हमेशा एक ही नाम नहीं हो सकता था, लेकिन वे लगभग बराबर हैं।

अधिकांश मूल उदाहरण कुछ इस तरह दिखते हैं:

  • एक मार्ग बनाएँ
  • जब फ़ंक्शन का अनुरोध किया जाता है, तो प्रतिक्रिया तैयार करते हुए एक फ़ंक्शन चलाएँ
  • अनुरोध का जवाब दें

एक्सप्रेस:

app.get('/', function (req, res) {

    getSomeValue(function (obj) {

        res.json({an: 'object'});
    });
});

HAPI:

server.route({
    method: 'GET',
    path: '/',
    handler: function (request, reply) {

        getSomeValue(function (obj) {

            reply(obj);
        });
    }
});

अंतर बिल्कुल ठीक नहीं है? तो क्यों एक दूसरे पर चुनते हैं?

वे कैसे अलग हैं?

इसका सरल जवाब है ओपीआई बहुत अधिक है और यह बहुत अधिक आउट-ऑफ-द-बॉक्स करता है। यह स्पष्ट नहीं हो सकता है जब आप बस ऊपर से सरल उदाहरण को देखते हैं। वास्तव में, यह जानबूझकर है। साधारण मामलों को सरल रखा जाता है। तो चलिए कुछ बड़े अंतरों की जाँच करते हैं:

दर्शन

एक्सप्रेस को बहुत कम करने का इरादा है। आपको केवल एक छोटी सी एपीआई के साथ एक पतली डस्टिंग दे कर http, आप अतिरिक्त कार्यक्षमता जोड़ने के मामले में अपने दम पर बहुत आगे हैं। यदि आप आने वाले अनुरोध (काफी सामान्य कार्य) के शरीर को पढ़ना चाहते हैं, तो आपको एक अलग मॉड्यूल स्थापित करने की आवश्यकता है । यदि आप उस मार्ग पर भेजे जाने वाले विभिन्न सामग्री-प्रकारों की अपेक्षा कर रहे हैं, तो आपको यह देखने के Content-typeलिए कि यह कौन सा है और किसके अनुसार पार्स किया गया है , हेडर को जांचना होगा (उदाहरण के लिए फॉर्म-डेटा बनाम JSON बनाम बहु-भाग), अक्सर अलग-अलग मॉड्यूल का उपयोग करके ।

hapi में एक समृद्ध सुविधा सेट है, जिसे अक्सर कॉन्फ़िगरेशन विकल्पों के माध्यम से उजागर किया जाता है, बजाय कोड लिखे जाने की आवश्यकता होती है। उदाहरण के लिए, यदि हम यह सुनिश्चित करना चाहते हैं कि हैंडलर के चलने से पहले एक अनुरोध निकाय (पेलोड) पूरी तरह से मेमोरी और उचित रूप से पार्स (स्वचालित रूप से सामग्री-प्रकार पर आधारित) में पढ़ा जाए, तो यह एक सरल विकल्प है :

server.route({
    config: {
        payload: {
            output: 'data',
            parse: true
        }
    },
    method: 'GET',
    path: '/',
    handler: function (request, reply) {

        reply(request.payload);
    }
});

विशेषताएं

आपको केवल यह देखने के लिए दोनों परियोजनाओं पर एपीआई प्रलेखन की तुलना करने की आवश्यकता है कि एचपीआई एक बड़ी सुविधा सेट प्रदान करता है।

हापी में निम्नलिखित कुछ विशेषताएं शामिल हैं, जो उस एक्सप्रेस में निर्मित नहीं हैं (जहाँ तक मुझे पता है):

व्यापकता और प्रतिरूपकता

हैपी और एक्सप्रेस काफी अलग तरीके से एक्स्टेंसिबिलिटी के बारे में बताते हैं। एक्सप्रेस के साथ, आपके पास मिडलवेयर फ़ंक्शंस हैं। मिडलवेयर फ़ंक्शंस एक तरह के फ़िल्टर होते हैं, जिन्हें आप स्टैक करते हैं और आपके हैंडलर को मारने से पहले सभी अनुरोध उनके माध्यम से चलते हैं।

hapi में अनुरोध जीवनचक्र है और विस्तार बिंदु प्रदान करता है , जो कि मिडलवेयर फ़ंक्शंस के लिए तुलनीय है, लेकिन अनुरोध जीवनचक्र में कई परिभाषित बिंदु मौजूद हैं।

वॉलमार्ट ने हपी का निर्माण किया और एक्सप्रेस का उपयोग करना बंद कर दिया, इसका एक कारण यह था कि एक्सप्रेस ऐप को अलग-अलग हिस्सों में विभाजित करना कितना मुश्किल था, और टीम के अलग-अलग सदस्यों को सुरक्षित रूप से काम करना। इस कारण से उन्होंने hapi में प्लगइन सिस्टम बनाया ।

एक प्लगइन एक उप-अनुप्रयोग की तरह है, आप एक हैपी ऐप में सब कुछ कर सकते हैं, मार्गों, एक्सटेंशन बिंदुओं आदि को जोड़ सकते हैं। एक प्लगइन में आप यह सुनिश्चित कर सकते हैं कि आप आवेदन के दूसरे हिस्से को नहीं तोड़ रहे हैं, क्योंकि मार्गों के लिए पंजीकरण मायने नहीं रखता है और आप परस्पर विरोधी मार्ग नहीं बना सकते हैं। फिर आप इस प्लगइन्स को सर्वर में जोड़ सकते हैं और इसे तैनात कर सकते हैं।

पारिस्थितिकी तंत्र

क्योंकि एक्सप्रेस आपको बॉक्स से बहुत कम बाहर देता है, आपको अपने प्रोजेक्ट में कुछ भी जोड़ने की आवश्यकता होने पर बाहर देखना होगा। बहुत बार जब हापी के साथ काम करते हैं, तो आपको जिस सुविधा की आवश्यकता होती है, वह या तो अंतर्निहित होती है या कोर टीम द्वारा बनाया गया एक मॉड्यूल होता है।

मिनिमल बहुत अच्छा लगता है। लेकिन अगर आप एक गंभीर प्रोडक्शन ऐप बना रहे हैं, तो संभावना है कि आपको अंततः इस सामान की ज़रूरत होगी।

सुरक्षा

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

सारांश

इनका मूल्यांकन स्वयं दोनों करें। अपनी जरूरतों के बारे में सोचें और दोनों में से कौन सी आपकी सबसे बड़ी चिंता है। दो समुदायों (IRC, Gitter, Github) में डुबकी लगाएं, देखें कि आप किसे पसंद करते हैं। बस मेरे शब्द मत लो। और खुश हैकिंग!


अस्वीकरण: मैं hapi पर एक पुस्तक के लेखक के रूप में पक्षपाती हूं और उपरोक्त बड़े पैमाने पर मेरी व्यक्तिगत राय है।


7
मैट, व्यापक पोस्ट के लिए धन्यवाद, "तानाना और प्रतिरूपकता" और "सुरक्षा" अनुभाग मेरे लिए सबसे सहायक अनुभाग थे। मुझे लगता है कि यह ध्यान देने योग्य है कि एक्सप्रेस 4 में नया रूटिंग सिस्टम उप-अनुप्रयोगों के लिए बेहतर मॉड्यूलरता प्रदान करता है।
अली शकीबा

1
शानदार जवाब मैट। हम बी / डब्ल्यू हापी और एक्सप्रेस में भी भ्रमित हैं, हापी के साथ हम जो एक कमी देख रहे हैं वह यह है कि इसमें एक्सप्रेस के रूप में व्यापक रूप से समुदाय का समर्थन नहीं है और अगर हम कहीं फंस जाते हैं तो यह एक बड़ी समस्या हो सकती है। उसी के संबंध में आपकी राय चाहिए।
अमन गुप्ता

1
एक्सप्रेस जेनेरिक है, जबकि हपी थोड़ा अधिक उद्यम है।
हवामहमाओ

1
@MattHarrison का शानदार जवाब, अभी मैं आपकी किताब हापी पर पढ़ रहा हूं, यह बहुत अच्छा है। मैं बैकएंड पर हापी का उपयोग करके पुस्तकों के लिए एक नया बाज़ार विकसित करने जा रहा हूं और फ्रंट पर vue.js का उपयोग कर रहा हूं, हापी के लिए इस्तेमाल होने के बाद मैं हापी परियोजना में सक्रिय रूप से भाग लेना चाहूंगा।
हुमायूँ अहमद

1
@ हुमायूँ महान! हालांकि इस बात से अवगत रहें कि <= v16.0.0 के बाद से कुछ महत्वपूर्ण परिवर्तनों के साथ हापी का एक नया प्रमुख संस्करण है। मैं वर्तमान में v17 सीखने के लिए लोगों के लिए डिज़ाइन की गई एक स्क्रेंकास्ट श्रृंखला का निर्माण कर रहा हूं: youtube.com/playlist?list=PLi303AVTbxaxqjaSWPg94nccYIfqNoCHz
मैट हैरिसन

54

मेरा संगठन हापी के साथ जा रहा है। यही कारण है कि हम इसे पसंद करते हैं।

हपी है:

  • प्रमुख कोर द्वारा समर्थित। इसका मतलब यह है कि सामुदायिक समर्थन मजबूत होगा, और भविष्य में रिलीज के दौरान आपके लिए होगा। भावुक हापी लोगों को ढूंढना आसान है, और वहाँ से बाहर अच्छे ट्यूटोरियल हैं (हालांकि कई नहीं हैं और एक्सप्रैस ट्यूटोरियल के रूप में नहीं हैं)। इस पोस्ट की तारीख के अनुसार npm और वॉलमार्ट Hapi का उपयोग करते हैं।
  • यह बैकएंड सेवाओं के विभिन्न हिस्सों पर काम करने वाली वितरित टीमों के काम की सुविधा प्रदान कर सकता है, जिनके पास बाकी एपीआई सतह (हापी के प्लगइन्स आर्किटेक्चर इस गुणवत्ता का प्रतीक है) का व्यापक ज्ञान नहीं है।
  • फ़्रेमवर्क को वह कार्य करने दें जो कि माना जाता है: चीजों को कॉन्फ़िगर करें। उसके बाद रूपरेखा अदृश्य होनी चाहिए और व्यावसायिक तर्क के निर्माण के लिए देवों को अपनी वास्तविक रचनात्मक ऊर्जा पर ध्यान केंद्रित करने की अनुमति देनी चाहिए। एक साल के लिए हापी का उपयोग करने के बाद, मुझे निश्चित रूप से महसूस होता है कि हापी इसे पूरा करता है। मुझे खुशी महसूस हो रही है!

अगर आप सीधे एरण हैमर (हापी की लीड) से सुनना चाहते हैं

पिछले चार वर्षों में hapi कई परियोजनाओं के लिए पसंद की रूपरेखा बन गया, बड़ी या छोटी। जो बात हपी को विशिष्ट बनाती है, वह बड़ी तैनाती और बड़ी टीमों के पैमाने की क्षमता है। जैसा कि एक परियोजना बढ़ती है, इसलिए इसकी जटिलता - इंजीनियरिंग जटिलता और प्रक्रिया जटिलता है। हैपी की वास्तुकला और दर्शन लगातार कोड को फिर से पढ़ने के लिए [और अधिक पढ़ें] की आवश्यकता के बिना बढ़ी हुई जटिलता को संभालती है।

Hapi के साथ शुरू करना ExpressJs जितना आसान नहीं होगा क्योंकि Hapi में "स्टार पावर" समान नहीं है ... लेकिन एक बार जब आप सहज महसूस करते हैं तो आपको ए लॉट ऑफ माइलेज मिलेगा। मुझे एक नए हैकर के रूप में ~ 2 महीने के बारे में ले लिया, जिसने कुछ वर्षों के लिए ExpressJs का गैर-जिम्मेदाराना इस्तेमाल किया। यदि आप एक अनुभवी बैकएंड डेवलपर हैं, तो आपको पता होगा कि डॉक्स कैसे पढ़ें, और आप शायद इसे नोटिस भी नहीं करेंगे।

हापी क्षेत्रों में सुधार हो सकता है:

  1. उपयोगकर्ताओं को प्रमाणित करने और सत्र बनाने के लिए कैसे
  2. क्रॉस-ऑरिजिन-रिक्वेस्ट (CORS) को हैंडल करना
  3. फ़ाइलें अपलोड करना (मल्टीपार्ट, chunked)

मुझे लगता है कि प्रमाणीकरण इसका सबसे चुनौतीपूर्ण हिस्सा होगा क्योंकि आपको यह तय करना होगा कि किस तरह की रणनीति का उपयोग करना है (बेसिक प्रमाणीकरण, कुकीज़, जेडब्ल्यूटी टोकन, ओएथ)। हालांकि यह तकनीकी रूप से हापी की समस्या नहीं है कि सत्र / प्रमाणीकरण परिदृश्य बहुत खंडित है ... लेकिन मैं चाहता हूं कि वे इसके लिए कुछ हस्त-पकड़ प्रदान करें। यह डेवलपर खुशी को बहुत बढ़ाएगा।

शेष दो वास्तव में उतना मुश्किल नहीं हैं, डॉक्स को बस थोड़ा बेहतर लिखा जा सकता है।


3

हापी या हापी जेएस के बारे में त्वरित तथ्य?

हापी कॉन्फ़िगरेशन-केंद्रित है इसमें प्रमाणीकरण और प्राधिकरण है जो ढांचे में बनाया गया है यह एक युद्ध-परीक्षण वाले वातावरण में जारी किया गया था और वास्तव में इसकी कीमत साबित हुई है सभी मॉड्यूल में 100% परीक्षण कवरेज है यह मुख्य HTTP से दूर अमूर्त के उच्चतम स्तर को आसानी से दर्ज करता है प्लगइन वास्तुकला के माध्यम से

हपी एक बेहतर विकल्प है प्रदर्शन वार हापी एक अलग मार्ग तंत्र का उपयोग करता है, जो तेजी से लुकअप कर सकता है, और पंजीकरण आदेश को ध्यान में रख सकता है। फिर भी, एक्सप्रेस की तुलना में यह काफी सीमित है। और हापी प्लगइन सिस्टम के लिए धन्यवाद, विभिन्न पहलुओं और सेवाओं को अलग करना संभव है जो भविष्य में कई तरीकों से एप्लिकेशन को मदद करेंगे।

प्रयोग

एक्सप्रेस की तुलना में हापी सबसे पसंदीदा ढांचा है। हापी का उपयोग मुख्य रूप से बड़े पैमाने पर उद्यम अनुप्रयोगों के लिए किया जाता है।

डेवलपर्स द्वारा एक्सप्रेस बनाने के कुछ कारण क्यों नहीं हैं जब एंटरप्राइज़ एप्लिकेशन बनाते हैं:

एक्सप्रेस में रचना के लिए रूट कठिन हैं

मिडलवेयर ज्यादातर समय रास्ते में मिलता है; हर बार जब आप मार्गों को परिभाषित कर रहे हैं, तो आपको कई कोड लिखने होंगे।

रेस्टफुल एपीआई बनाने वाले डेवलपर के लिए हापी सबसे अच्छा विकल्प होगा। हापी में सूक्ष्म सेवा वास्तुकला है और कुछ मापदंडों के आधार पर नियंत्रण को एक हैंडलर से दूसरे में स्थानांतरित करना भी संभव है। हापी प्लगइन के साथ, आप HTTP के आसपास अमूर्त स्तर का अधिक आनंद ले सकते हैं क्योंकि आप व्यापार तर्क को आसानी से प्रबंधनीय टुकड़ों में विभाजित कर सकते हैं।

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

  1. एक्सप्रेस का उपयोग करके आप जो कुछ भी प्राप्त कर सकते हैं वह आसानी से hapi.js. का उपयोग करके भी प्राप्त किया जा सकता है।

  2. Hapi.js बहुत स्टाइलिश है और कोड को बहुत अच्छी तरह से व्यवस्थित करता है। यदि आप देखते हैं कि यह कैसे रूटिंग करता है और नियंत्रकों में मुख्य तर्क डालता है, तो आप इसे प्यार से करेंगे।

  3. Hapi.js आधिकारिक तौर पर hapi.js के लिए विशेष रूप से टोकन आधारित आधार से सत्र प्रबंधन और कई और अधिक के लिए कई प्लगइन्स प्रदान करता है, जो एक विज्ञापन है। इसका मतलब यह नहीं है कि पारंपरिक npm का इस्तेमाल नहीं किया जा सकता है, ये सभी hapi.js द्वारा समर्थित हैं

  4. यदि आप hapi.js में कोड करते हैं, तो एक कोड बहुत ही रखरखाव योग्य होगा।


"यदि आप देखते हैं कि यह कैसे राउटिंग करता है और नियंत्रकों में मुख्य तर्क रखता है ..."। मुझे दस्तावेज़ीकरण में कोई उदाहरण नहीं दिखता है जो नियंत्रकों के उपयोग को दर्शाता है। सभी रूटिंग उदाहरण हैंडलर प्रॉपर्टी का उपयोग करते हैं जो एक फ़ंक्शन है। मैं इस तरह से तुलना करता हूं कि लारवेल (PHP फ्रेमवर्क) और AdonisJs (Node.js फ्रेमवर्क) राउटिंग के लिए करते हैं जिसमें हम राउटरिंग के लिए नियंत्रकों का उपयोग कर सकते हैं। मैं शायद HAPI डॉक्टर के कुछ हिस्सों को याद करता हूं जो रूटिंग के लिए नियंत्रकों का उपयोग दिखाते हैं। इसलिए यदि यह सुविधा मौजूद है, तो यह मेरे लिए अच्छा होगा, क्योंकि मैं लारवेल में रूटिंग के लिए नियंत्रकों का उपयोग करने का आदी हूं।
लेक्स सॉफ्ट

1

मैंने हाल ही में हापी का उपयोग शुरू किया है और मैं इससे काफी खुश हूं। मेरे कारण हैं

  1. परीक्षण करने में आसान। उदाहरण के लिए:

    • server.inject आप एप्लिकेशन को चलाने और सुनने और सुनने के बिना प्रतिक्रिया प्राप्त करने की अनुमति देता है।
    • server.info वर्तमान uri, port आदि देता है।
    • server.settingsकॉन्फ़िगरेशन को एक्सेस करता है जैसे server.settings.cacheवर्तमान कैश प्रदाता प्राप्त करता है
    • जब संदेह /testहो तो एप्लिकेशन के किसी भी भाग के लिए फ़ोल्डरों को देखें या मॉक / टेस्ट / स्टब आदि के बारे में सुझाव देखने के लिए प्लग इन का समर्थन करें।
    • मेरी समझ में यह है कि हापी का वास्तुशिल्प मॉडल आपको विश्वास करने की अनुमति देता है, लेकिन सत्यापित करें कि क्या मेरे प्लगइन्स पंजीकृत हैं ? मैं मॉड्यूल निर्भरता कैसे घोषित कर सकता हूं ?
  2. यह बॉक्स से बाहर काम करता है जैसे फ़ाइल अपलोड , एंडपॉइंट्स से रिटर्न स्ट्रीम आदि।

  3. आवश्यक प्लगइन्स को मुख्य पुस्तकालय के साथ बनाए रखा जाता है। जैसे टेम्प्लेट पार्सिंग , कैशिंग आदि। अतिरिक्त लाभ समान कोडिंग मानकों को आवश्यक चीजों पर लागू किया जाता है।

  4. साने त्रुटियों और त्रुटि से निपटने। हापी विन्यास विकल्पों को मान्य करता है और डुप्लिकेट मार्गों को रोकने के लिए एक आंतरिक मार्ग तालिका रखता है। यह सीखने के दौरान काफी उपयोगी है क्योंकि त्रुटियों को अप्रत्याशित व्यवहारों के बजाय जल्दी फेंक दिया जाता है, जिसमें डीबगिंग की आवश्यकता होती है।


-1

जोड़ने के लिए बस एक और बिंदु, हापी ने संस्करण 16 से 'http2' कॉल का समर्थन शुरू कर दिया है (यदि मैं गलत नहीं हूं)। हालाँकि, एक्सप्रेस 4 तक सीधे 'http2' मॉड्यूल का समर्थन करना बाकी है। हालाँकि उन्होंने फ़ीचर को एक्सप्रेस 5 के अल्फा संस्करण में जारी किया है।


-2
'use strict';
const Hapi = require('hapi');
const Basic = require('hapi-auth-basic');
const server = new Hapi.Server();
server.connection({
    port: 2090,
    host: 'localhost'
});


var vorpal = require('vorpal')();
const chalk = vorpal.chalk;
var fs = require("fs");

var utenti = [{
        name: 'a',
        pass: 'b'
    },
    {
        name: 'c',
        pass: 'd'
    }
];

const users = {
    john: {
        username: 'john',
        password: 'secret',
        name: 'John Doe',
        id: '2133d32a'
    },
    paul: {
        username: 'paul',
        password: 'password',
        name: 'Paul Newman',
        id: '2133d32b'
    }
};

var messaggi = [{
        destinazione: 'a',
        sorgente: 'c',
        messsaggio: 'ciao'
    },
    {
        destinazione: 'a',
        sorgente: 'c',
        messsaggio: 'addio'
    },
    {
        destinazione: 'c',
        sorgente: 'a',
        messsaggio: 'arrivederci'
    }
];

var login = '';
var loggato = false;

vorpal
    .command('login <name> <pass>')
    .description('Effettua il login al sistema')
    .action(function (args, callback) {
        loggato = false;
        utenti.forEach(element => {
            if ((element.name == args.name) && (element.pass == args.pass)) {
                loggato = true;
                login = args.name;
                console.log("Accesso effettuato");
            }
        });
        if (!loggato)
            console.log("Login e Password errati");
        callback();
    });

vorpal
    .command('leggi')
    .description('Leggi i messaggi ricevuti')
    .action(function (args, callback) {
        if (loggato) {
            var estratti = messaggi.filter(function (element) {
                return element.destinazione == login;
            });

            estratti.forEach(element => {
                console.log("mittente : " + element.sorgente);
                console.log(chalk.red(element.messsaggio));
            });
        } else {
            console.log("Devi prima loggarti");
        }
        callback();
    });

vorpal
    .command('invia <dest> "<messaggio>"')
    .description('Invia un messaggio ad un altro utente')
    .action(function (args, callback) {
        if (loggato) {
            var trovato = utenti.find(function (element) {
                return element.name == args.dest;
            });
            if (trovato != undefined) {
                messaggi.push({
                    destinazione: args.dest,
                    sorgente: login,
                    messsaggio: args.messaggio
                });
                console.log(messaggi);
            }
        } else {
            console.log("Devi prima loggarti");
        }
        callback();
    });

vorpal
    .command('crea <login> <pass>')
    .description('Crea un nuovo utente')
    .action(function (args, callback) {
        var trovato = utenti.find(function (element) {
            return element.name == args.login;
        });
        if (trovato == undefined) {
            utenti.push({
                name: args.login,
                pass: args.pass
            });
            console.log(utenti);
        }
        callback();
    });

vorpal
    .command('file leggi utenti')
    .description('Legge il file utenti')
    .action(function (args, callback) {
        var contents = fs.readFileSync("utenti.json");
        utenti = JSON.parse(contents);
        callback();
    });

vorpal
    .command('file scrivi utenti')
    .description('Scrive il file utenti')
    .action(function (args, callback) {
        var jsontostring = JSON.stringify(utenti);
        fs.writeFile('utenti.json', jsontostring, function (err) {
            if (err) {
                return console.error(err);
            }
        });
        callback();
    });

vorpal
    .command('file leggi messaggi')
    .description('Legge il file messaggi')
    .action(function (args, callback) {
        var contents = fs.readFileSync("messaggi.json");
        messaggi = JSON.parse(contents);
        callback();
    });

vorpal
    .command('file scrivi messaggi')
    .description('Scrive il file messaggi')
    .action(function (args, callback) {
        var jsontostring = JSON.stringify(messaggi);
        fs.writeFile('messaggi.json', jsontostring, function (err) {
            if (err) {
                return console.error(err);
            }
        });
        callback();
    });

// leggi file , scrivi file

vorpal
    .delimiter(chalk.yellow('messaggi$'))
    .show();




const validate = function (request, username, password, callback) {
    loggato = false;


    utenti.forEach(element => {
        if ((element.name == username) && (element.pass == password)) {
            loggato = true;
            console.log("Accesso effettuato");
            return callback(null, true, {
                name: username
            })
        }
    });
    if (!loggato)
        return callback(null, false);
};

server.register(Basic, function (err) {
    if (err) {
        throw err;
    }
});

server.auth.strategy('simple', 'basic', {
    validateFunc: validate
});



server.route({
    method: 'GET',
    path: '/',
    config: {
        auth: 'simple',
        handler: function (request, reply) {
            reply('hello, ' + request.auth.credentials.name);
        }
    }
});

//route scrivere
server.route({
    method: 'POST',
    path: '/invia',
    config: {
        auth: 'simple',
        handler: function (request, reply) {
            //console.log("Received POST from " + request.payload.name + "; id=" + (request.payload.id || 'anon'));
            var payload = encodeURIComponent(request.payload)
            console.log(request.payload);
            console.log(request.payload.dest);
            console.log(request.payload.messaggio);
            messaggi.push({
                destinazione: request.payload.dest,
                sorgente: request.auth.credentials.name,
                messsaggio: request.payload.messaggio
            });
            var jsontostring = JSON.stringify(messaggi);
            fs.writeFile('messaggi.json', jsontostring, function (err) {
                if (err) {
                    return console.error(err);
                }
            });
            console.log(messaggi);
            reply(messaggi[messaggi.length - 1]);

        }
    }
});


//route leggere (json)
server.route({
    method: 'GET',
    path: '/messaggi',
    config: {
        auth: 'simple',
        handler: function (request, reply) {
            messaggi = fs.readFileSync("messaggi.json");
            var estratti = messaggi.filter(function (element) {
                return element.destinazione == request.auth.credentials.name;
            });
            var s = [];

            console.log(request.auth.credentials.name);
            console.log(estratti.length);
            estratti.forEach(element => {

                s.push(element);

                //fare l'array con stringify
                //s+="mittente : "+element.sorgente+": "+element.messsaggio+"\n";

            });
            var a = JSON.stringify(s);
            console.log(a);
            console.log(s);
            reply(a);
        }
    }
});



server.start(function () {
    console.log('Hapi is listening to ' + server.info.uri);
});

function EseguiSql(connection, sql, reply) {
    var rows = [];
    request = new Request(sql, function (err, rowCount) {
        if (err) {
            console.log(err);
        } else {
            console.log(rowCount + ' rows');
            console.log("Invio Reply")
            reply(rows);
        }
    });

    request.on('row', function (columns) {
        var row = {};
        columns.forEach(function (column) {
            row[column.metadata.colName] = column.value;
        });
        rows.push(row);
    });

    connection.execSql(request);
}

server.route({
    method: 'POST',
    path: '/query',
    handler: function (request, reply) {
        // Qui dovrebbe cercare i dati nel body e rispondere con la query eseguita
        var connection = new Connection(config);

        // Attempt to connect and execute queries if connection goes through
        connection.on('connect', function (err) {
            if (err) {
                console.log(err);
            } else {

                console.log('Connected');
                console.log(request.payload.sql);
                EseguiSql(connection, request.payload.sql, reply);
            }
        });

    }
});

server.connection({
    host: process.env.HOST || 'localhost',
    port: process.env.PORT || 8080
});

var config = {
    userName: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    server: process.env.DB_SERVER,
    options: {
        database: process.env.DB_NAME,
        encrypt: true
    }
}

StackOverflow में आपका स्वागत है। क्या आप अपनी प्रतिक्रिया पर अधिक विस्तार कर सकते हैं और यह ओपी द्वारा पोस्ट किए गए प्रश्न से कैसे संबंधित है?
सिग्मन मस्ज़के
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.