🏂 🙏🏿 🦌 प्रति माह KPI के संग्रह को स्वचालित कैसे करें और उपयोगकर्ताओं को लगभग संतुष्ट छोड़ दें 🐗 🗂️ 👎🏾

कई संगठनों में, KPI (मुख्य प्रदर्शन संकेतक) का उपयोग करके इकाई मूल्यांकन किया जाता है। जिस संगठन में मैं काम करता हूं, ऐसी प्रणाली को "प्रदर्शन संकेतकों की प्रणाली" कहा जाता है, और इस लेख में मैं इस बारे में बात करना चाहता हूं कि हम एक महीने के भीतर संकेतक के साथ काम का हिस्सा स्वचालित करने में कैसे कामयाब रहे। इस सब के साथ, हमारी श्रम लागत सबसे बड़ी नहीं थी, लेकिन साथ ही हमने कुछ लंबे समय से चली आ रही विशलिस्ट को लागू करने की कोशिश की। मेरी कहानी में कोई प्रचार तकनीक या रहस्योद्घाटन नहीं होगा (आखिरकार, प्रांतीय विकास कठोर है), लेकिन इस विषय पर कुछ रेखाचित्र होंगे जो यह समझने में मदद करेंगे कि हमने कैसे शुरू किया, हमने क्या किया, और विकास से हमें क्या विचार मिले। यदि आप अभी तक ऊब नहीं हुए हैं, तो मैं एक बिल्ली के लिए पूछता हूं।

प्रागितिहास

2006 में वापस, हमने प्रदर्शन संकेतकों की एक प्रणाली शुरू की: पंद्रह मूल्यांकन मानदंड विकसित किए गए थे, उनकी गणना के लिए एक पद्धति और इन संकेतकों की गणना के लिए एक त्रैमासिक आवृत्ति स्थापित की गई थी। मूल्यांकन हमारे क्षेत्र के सभी क्षेत्रों में स्थित संगठन की बाईस शाखाओं के लिए किया गया था। और संकेतकों को बड़े उत्साह के साथ प्राप्त करने के लिए, उन्हें एक बोनस बांधा गया था - संकेतकों का योग जितना अधिक होगा, रेटिंग में उच्च स्थान, रेटिंग में उच्च स्थान, उच्च प्रीमियम, और हर तिमाही और हर साल इतने पर।

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

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

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

मैं केवल इस बात पर ध्यान देता हूं कि इस अच्छे टैबलेट में, अधिकांश स्पीकर केवल छिपे हुए हैं, लेकिन वास्तव में 2016 की चौथी तिमाही में यह इस तरह दिखता था

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

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

सिस्टम को बदलना होगा

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

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

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

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

कार्यक्षमता बहुत छोटी है, लेकिन ज्यादा समय नहीं है।

विकास शुरू

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

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

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

डेटा भंडारण

अधिकांश अनुप्रयोगों में, हम IBM DB2 DBMS का उपयोग करते हैं। एक छोटा डेटाबेस बनाया गया था जो मानदंड और मापदंड के समूहों की संदर्भ पुस्तकों को संग्रहीत करता है जिसके द्वारा शाखाओं का मूल्यांकन किया जाता है, शाखाओं की निर्देशिका और एक प्लेट जिसमें मापदंड के गणना किए गए मान दर्ज किए जाते हैं। प्रत्येक मानदंड के लिए, एक निश्चित समय पर, एक गुणांक असाइन किया जाता है जिसका उपयोग स्कोरिंग में किया जाएगा। प्रत्येक मानदंड के लिए प्रत्येक शाखा, एक निश्चित तिथि के लिए भी एक मूल्यांकन प्राप्त करती है। मानदंड के मूल्यों पर डेटा ऐतिहासिक रूप से संग्रहीत किया जाता है, अर्थात, किसी भी तारीख के लिए प्रासंगिक डेटा वे होंगे जो अतीत में निकटतम तिथि पर दर्ज किए गए थे। 1C: एंटरप्राइज़ से जानकारी के रजिस्टरों से प्रेरित यह दृष्टिकोण मेरे लिए काफी सुविधाजनक लगता है: एक इतिहास है और संपादन / हटाने के मुद्दे विशेष रूप से बढ़ते नहीं हैं।

डेटाबेस संरचना

CREATE TABLE SUMMAR.CLS_DEPART ( ID BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY, PARENT_ID BIGINT NOT NULL DEFAULT 0, IS_DELETED INT DEFAULT 0, NAME CLOB, CODE VARCHAR(255), PRIMARY KEY (ID) ); CREATE TABLE SUMMAR.CLS_CRITERIA ( ID BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY, IS_DELETED INT DEFAULT 0, NAME CLOB, CODE VARCHAR(255), PRIMARY KEY (ID) ); CREATE TABLE SUMMAR.CLS_GROUP_CRITERIA ( ID BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY, IS_DELETED INT DEFAULT 0, NAME CLOB, CODE VARCHAR(255), PRIMARY KEY (ID) ); CREATE TABLE SUMMAR.REG_STATE_CRITERIA ( ID BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY, ID_CRITERIA BIGINT NOT NULL, ID_GROUP_CRITERIA BIGINT NOT NULL, TIME_BEGIN TIMESTAMP NOT NULL DEFAULT CURRENT TIMESTAMP, TIME_END TIMESTAMP NOT NULL DEFAULT '9999-12-31-23.59.59.000000000000', TIME_CREATE TIMESTAMP NOT NULL DEFAULT CURRENT TIMESTAMP, KOEFFICIENT DECIMAL(15, 2), PRIMARY KEY (ID), CONSTRAINT FK_CRITERIA FOREIGN KEY (ID_CRITERIA) REFERENCES SUMMAR.CLS_CRITERIA(ID) ON DELETE NO ACTION ON UPDATE RESTRICT, CONSTRAINT FK_GROUP_CRITERIA FOREIGN KEY (ID_GROUP_CRITERIA) REFERENCES SUMMAR.CLS_GROUP_CRITERIA(ID) ON DELETE NO ACTION ON UPDATE RESTRICT ); CREATE TABLE SUMMAR.REG_VALUE_CRITERIA ( ID BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY, ID_CRITERIA BIGINT NOT NULL, ID_GROUP_CRITERIA BIGINT NOT NULL, ID_DEPART BIGINT NOT NULL, DATE_REG TIMESTAMP(12) NOT NULL DEFAULT CURRENT TIMESTAMP, TIME_END TIMESTAMP NOT NULL DEFAULT '9999-12-31-23.59.59.000000000000', TIME_BEGIN TIMESTAMP NOT NULL DEFAULT CURRENT TIMESTAMP, PERCENT DECIMAL(15, 5), VAL DECIMAL(15, 5), PRIMARY KEY (ID), CONSTRAINT FK_CRITERIA FOREIGN KEY (ID_CRITERIA) REFERENCES SUMMAR.CLS_CRITERIA(ID) ON DELETE NO ACTION ON UPDATE RESTRICT, CONSTRAINT FK_DEPART FOREIGN KEY (ID_DEPART) REFERENCES SUMMAR.CLS_DEPART(ID) ON DELETE NO ACTION ON UPDATE RESTRICT, CONSTRAINT FK_GROUP_CRITERIA FOREIGN KEY (ID_GROUP_CRITERIA) REFERENCES SUMMAR.CLS_GROUP_CRITERIA(ID) ON DELETE NO ACTION ON UPDATE RESTRICT );

डेटाबेस से शाखाओं के प्रदर्शन पर प्रतिष्ठित रिपोर्ट प्राप्त करने के लिए, संग्रहीत कार्य बनाए गए थे, जिसके परिणाम पहले से ही जावा वर्ग के लिए मैप किए गए हैं। फ़ंक्शंस कुछ इस तरह दिखते हैं।

पहले हमें तिथि के लिए सभी मानदंड मान्य हैं, साथ ही उस तिथि के लिए प्रासंगिक मानदंड गुणांक हैं

 CREATE OR REPLACE FUNCTION SUMMAR.SLICE_STATE_ALL_CRITERIA ( PMAX_TIME TIMESTAMP ) RETURNS TABLE ( ID_CRITERIA BIGINT, ID_GROUP_CRITERIA BIGINT, TIME_BEGIN TIMESTAMP, TIME_END TIMESTAMP, TIME_CREATE TIMESTAMP, KOEFFICIENT DECIMAL(15, 2) ) LANGUAGE SQL RETURN SELECT RSC.ID_CRITERIA, RSC.ID_GROUP_CRITERIA, RSC.TIME_BEGIN, RSC.TIME_END, RSC.TIME_CREATE, RSC.KOEFFICIENT FROM SUMMAR.REG_STATE_CRITERIA AS RSC INNER JOIN ( SELECT ID_CRITERIA, MAX(TIME_BEGIN) AS TIME_BEGIN FROM ( SELECT DISTINCT ID_CRITERIA, TIME_BEGIN FROM SUMMAR.REG_STATE_CRITERIA WHERE TIME_BEGIN < PMAX_TIME AND TIME_END > PMAX_TIME ) AS SL GROUP BY ID_CRITERIA ) AS MAX_SLICE ON RSC.ID_CRITERIA = MAX_SLICE.ID_CRITERIA AND RSC.TIME_BEGIN = MAX_SLICE.TIME_BEGIN ;

अब हम उसी तिथि को सभी शाखाओं के लिए सभी मानदंडों के मान प्राप्त करेंगे

 CREATE OR REPLACE FUNCTION SUMMAR.SLICE_VALUE_ACTUAL_ALL_CRITERIA_ALL_DEPART_WITH_NAMES ( PMAX_TIME TIMESTAMP ) RETURNS TABLE ( ID_CRITERIA BIGINT, ID_GROUP_CRITERIA BIGINT, ID_DEPART BIGINT, DATE_REG TIMESTAMP, PERCENT DECIMAL(15, 2), VAL DECIMAL(15, 2), KOEFFICIENT DECIMAL(15, 2), CRITERIA_NAME CLOB, CRITERIA_CODE VARCHAR(255), GROUP_CRITERIA_NAME CLOB, GROUP_CRITERIA_CODE VARCHAR(255), DEPART_NAME CLOB, DEPART_CODE VARCHAR(255), DEPART_CODE_INT INT ) LANGUAGE SQL RETURN SELECT CDEP.ID_CRITERIA, COALESCE(VALS.ID_GROUP_CRITERIA, 0) AS ID_GROUP_CRITERIA, CDEP.ID_DEPART, VALS.DATE_REG, COALESCE(VALS.PERCENT, 0.0) AS PERCENT, COALESCE(VALS.VAL, 0.0) AS VAL, COALESCE(VALS.KOEFFICIENT, 0.0) AS KOEFFICIENT, CDEP.CRITERIA_NAME, CDEP.CRITERIA_CODE, COALESCE(VALS.GROUP_CRITERIA_NAME, '') AS GROUP_CRITERIA_NAME, COALESCE(VALS.GROUP_CRITERIA_CODE, '') AS GROUP_CRITERIA_CODE, CDEP.DEPART_NAME, CDEP.DEPART_CODE, CDEP.DEPART_CODE_INT FROM ( SELECT CCRT.ID AS ID_CRITERIA, CCRT."NAME" AS CRITERIA_NAME, CCRT.CODE AS CRITERIA_CODE, CDEP.ID AS ID_DEPART, CDEP."NAME" AS DEPART_NAME, CDEP.CODE AS DEPART_CODE, CAST (CDEP.CODE AS INT) AS DEPART_CODE_INT FROM SUMMAR.CLS_DEPART AS CDEP, ( SELECT * FROM SUMMAR.CLS_CRITERIA AS CC INNER JOIN TABLE(SUMMAR.SLICE_STATE_ALL_CRITERIA (PMAX_TIME)) AS ACTC ON CC.ID = ACTC.ID_CRITERIA WHERE CC.IS_DELETED = 0 ) AS CCRT WHERE CDEP.IS_DELETED = 0 ) AS CDEP LEFT JOIN ( SELECT VALS.ID_CRITERIA, VALS.ID_GROUP_CRITERIA, VALS.ID_DEPART, VALS.DATE_REG, VALS.PERCENT, VALS.VAL, VALS.KOEFFICIENT, CGRT."NAME" AS GROUP_CRITERIA_NAME, CGRT.CODE AS GROUP_CRITERIA_CODE FROM TABLE(SUMMAR.SLICE_VALUE_ACTUAL_ALL_CRITERIA (PMAX_TIME)) AS VALS INNER JOIN SUMMAR.CLS_GROUP_CRITERIA AS CGRT ON VALS.ID_GROUP_CRITERIA = CGRT.ID ) as VALS ON CDEP.ID_DEPART = VALS.ID_DEPART AND CDEP.ID_CRITERIA = VALS.ID_CRITERIA ;

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

 SELECT ROW_NUMBER() OVER() AS ID_NUM, RANK() OVER( PARTITION BY ID_CRITERIA ORDER BY VAL DESC ) AS RATING, CASE WHEN MAX(RANK() OVER( PARTITION BY ID_CRITERIA ORDER BY VAL DESC ) ) OVER() = RANK() OVER( PARTITION BY ID_CRITERIA ORDER BY VAL DESC ) THEN 1 ELSE 0 END AS MAX_RATING, CASE WHEN MIN(RANK() OVER( PARTITION BY ID_CRITERIA ORDER BY VAL DESC ) ) OVER() = RANK() OVER( PARTITION BY ID_CRITERIA ORDER BY VAL DESC ) THEN 1 ELSE 0 END AS MIN_RATING, VALS.* FROM TABLE(SUMMAR.SLICE_VALUE_ACTUAL_ALL_CRITERIA_ALL_DEPART_WITH_NAMES (?)) AS VALS ORDER BY GROUP_CRITERIA_CODE, CRITERIA_CODE, DEPART_CODE_INT

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

आवेदन

जैसा कि मैंने कहा, OpenXava का उपयोग एप्लिकेशन को लागू करने के लिए किया गया था। एक विशिष्ट इंटरफ़ेस और CRUD को बॉक्स से बाहर निकालने के लिए, आपको कुछ क्रियाएं करने की आवश्यकता है।
के साथ शुरू करने के लिए, web.xml में आपको एप्लिकेशन को नेविगेट करने वाले एडऑन से फ़िल्टर और सर्वलेट का वर्णन करना होगा:

web.xml

 <web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"> <filter> <filter-name>naviox</filter-name> <filter-class>com.openxava.naviox.web.NaviOXFilter</filter-class> </filter> <filter-mapping> <filter-name>naviox</filter-name> <url-pattern>*.jsp</url-pattern> </filter-mapping> <filter-mapping> <filter-name>naviox</filter-name> <url-pattern>/modules/*</url-pattern> <dispatcher>REQUEST</dispatcher> <dispatcher>FORWARD</dispatcher> </filter-mapping> <filter-mapping> <filter-name>naviox</filter-name> <servlet-name>naviox</servlet-name> </filter-mapping> <filter-mapping> <filter-name>naviox</filter-name> <servlet-name>module</servlet-name> </filter-mapping> <servlet> <servlet-name>naviox</servlet-name> <servlet-class>com.openxava.naviox.web.NaviOXServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>naviox</servlet-name> <url-pattern>/m/*</url-pattern> </servlet-mapping> </web-app>

इसके बाद, नियंत्रकों। Xml फ़ाइल में, हम एप्लिकेशन में उपयोग किए जाने वाले नियंत्रकों को परिभाषित करते हैं। हमारे मामले में, सबसे सरल पर्याप्त है:

controllers.xml

 <controllers> <controller name="Typical_View"> <extends controller="Navigation"/> <extends controller="CRUD"/> <extends controller="ExtendedPrint"/> </controller> </controllers>

उपरोक्त नियंत्रक डिफ़ॉल्ट रूप से OpenXava में शामिल नियंत्रकों के कार्यों को जोड़ता है, जिनमें से कार्यों को नामों से अनुमान लगाना आसान है।

और अंत में, application.xml फ़ाइल में हम निर्मित नियंत्रक और मॉडल को कनेक्ट करेंगे। कुछ इस तरह:

application.xml

 <application name="summar"> <module name="RegValueCriteria"> <model name="RegValueCriteria"/> <controller name="Typical_View"/> </module> </application>

जैसा कि ऊपर उल्लेख किया गया है, एप्लिकेशन उन व्यावसायिक घटकों पर आधारित है जो एप्लिकेशन मॉडल बनाते हैं। उदाहरण के लिए, Reg.alueCriteria घटक को application.xml में नियंत्रक के साथ संबद्ध मानें। यह घटक शाखा के लिए कसौटी के मान का वर्णन करता है (संक्षिप्तता के लिए, केवल वर्ग फ़ील्ड का विवरण बचा है, और मैं गेटर्स और सेटर जैसे तरीकों को छोड़ दूँगा):

घटक वर्ग

 @Entity @Table(name = "REG_VALUE_CRITERIA", catalog = "", schema = "SUMMAR") @XmlRootElement @Views({ @View(members = "idCriteria [idCriteria];" + "idGroupCriteria [idGroupCriteria];" + "idDepart [idDepart];" + "data [dateReg, percent, val]"), @View(name="massReg", members = "idDepart.name, percent, val") }) @Tab(properties= "idDepart.name, idCriteria.name, idGroupCriteria.name, dateReg, percent, val" ) public class RegValueCriteria implements Serializable { private static final long serialVersionUID = 1L; @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Basic(optional = false) @Column(name = "ID") private Long id; @Basic(optional = false) @NotNull @Column(name = "DATE_REG") @Temporal(TemporalType.TIMESTAMP) @DefaultValueCalculator(CurrentDateCalculator.class) @Stereotype("DATETIME") private Date dateReg; @Column(name = "PERCENT") @OnChange(OnChangePercentAction.class) private BigDecimal percent; @Column(name = "VAL") private BigDecimal val; @JoinColumn(name = "ID_CRITERIA", referencedColumnName = "ID") @ManyToOne(optional = false) @DescriptionsList( descriptionProperties="name" ) @OnChange(OnChangeClsCriteriaAction.class) private ClsCriteria idCriteria; @JoinColumn(name = "ID_GROUP_CRITERIA", referencedColumnName = "ID") @ManyToOne(optional = false) @DescriptionsList( descriptionProperties="name" ) private ClsGroupCriteria idGroupCriteria; @JoinColumn(name = "ID_DEPART", referencedColumnName = "ID") @ManyToOne(optional = false) @DescriptionsList( descriptionProperties="name" ) private ClsDepart idDepart; }

सामान्य जेपीए एनोटेशन के अलावा। आप OpenXava एनोटेशन को भी नोटिस कर सकते हैं। उन्हें और अधिक विस्तार से माना जाना चाहिए।

@View वर्ग फ़ील्ड के प्रस्तुति प्रारूप को नियंत्रित करने की अनुमति देता है, और वर्ग कोष्ठक के रूप में विशेष सिंटैक्स की सहायता से, फ़ील्ड को समूहों में जोड़ा जा सकता है और प्रतीकों का उपयोग करके क्षैतिज और लंबवत रूप से व्यवस्थित किया जा सकता है , और ; । यदि एकल घटक के लिए कई मैपिंग निर्दिष्ट करने की आवश्यकता होती है, तो @View एनोटेशन का उपयोग करके @View एनोटेशन को समूहीकृत किया जाता है। हमारे उदाहरण में, गुणों को निम्नानुसार व्यवस्थित किया गया था:

 @View(members = "idCriteria [idCriteria];" + "idGroupCriteria [idGroupCriteria];" + "idDepart [idDepart];" + "data [dateReg, percent, val]")

और यह इस तरह दिखता है:

व्याख्यात्मक, लेकिन न्यूनतम प्रयास के साथ। हालांकि, फॉर्म को थोड़ा "पुनर्जीवित" करने के तरीके हैं।
घटक बनाते समय भरी जाने वाली पंजीकरण तिथि के लिए, @DefaultValueCalculator एनोटेशन का @DefaultValueCalculator , जो एक विशेष कैलकुलेटर ऑब्जेक्ट को कॉल करता है। यहां, OpenXava के एक कैलकुलेटर का उपयोग किया जाता है, लेकिन आप एक कस्टम भी बना सकते हैं। उपयुक्त नियंत्रण का उपयोग करके दिनांक प्रदर्शित करने के लिए @Stereotype एनोटेशन का उपयोग किया जाता है।

संबंधित ऑब्जेक्ट वाली ड्रॉप-डाउन सूचियों को कॉन्फ़िगर करने के लिए, @DescriptionsList एनोटेशन का @DescriptionsList , जिसमें आप यह निर्दिष्ट कर सकते हैं कि कौन सी संपत्ति सूची में प्रदर्शित होगी।

एनोटेशन का उपयोग करके, आप फॉर्म के कुछ व्यावसायिक तर्क को लागू कर सकते हैं। उदाहरण के लिए, ताकि जब प्रतिशत बदलता है, तो मान की गणना स्वचालित रूप से मानदंड के गुणांक को ध्यान में रखते हुए की जाती है, आप BigDecimal val @OnChange क्षेत्र के लिए @OnChange एनोटेशन लागू कर सकते हैं। काम @OnChange के लिए @OnChange एनोटेशन के @OnChange , उसे OnChangePropertyBaseAction इंटरफ़ेस को लागू करने वाले वर्ग को इंगित करना होगा। एक एकल execute() पद्धति को कक्षा में लागू किया जाना चाहिए, जिसमें दृश्य से इनपुट डेटा लिया जाता है, गणना की जाती है और गणना मूल्य को दृश्य में वापस लिखा जाता है:

बाल वर्ग OnChangePropertyBaseAction

 public class OnChangePercentAction extends OnChangePropertyBaseAction{ @Override public void execute() throws Exception { BigDecimal percent = (BigDecimal)getNewValue(); if (percent != null){ Map value = (Map)getView().getValue("idCriteria"); if (value != null){ Long idCriteria = (Long)value.get("id"); Query query = XPersistence.getManager().createNativeQuery( "SELECT KOEFFICIENT FROM SUMMAR.SLCLA_STATE_CRITERIA WHERE ID_CRITERIA = ?"); query.setParameter(1, idCriteria); List<?> list = query.getResultList(); if (list != null && !list.isEmpty()){ BigDecimal koef = (BigDecimal) list.get(0); BigDecimal vl = koef.multiply(percent); getView().setValue("val", vl); } } } } }

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

 @Tab(properties= "idDepart.name, idCriteria.name, idGroupCriteria.name, dateReg, percent, val" )

यह इस प्रकार दिखेगा

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

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

यह सब क्या था

याद रखें कि ऐप किस लिए था? हां, ताकि एक्सेल में संकेतक के साथ प्लेट वीरता से कम न हो, लेकिन दर्ज किए गए डेटा के आधार पर स्वचालित रूप से बनाई गई है। ब्राउज़र विंडो में, पिवट टेबल इस तरह दिखना शुरू हुई:

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

हालांकि, मैं एक दिलचस्प विवरण पर ध्यान देना चाहता हूं। जब आवेदन के लिए आवश्यकताओं को एकत्र किया गया था, तो प्रबंधन वास्तव में चाहता था कि, सारांश रिपोर्ट के अलावा, एक व्यक्तिगत संकेतक के मूल्यों को क्षेत्र के नक्शे के रूप में प्रदर्शित किया जा सकता है, जो स्थान और संबंधित शाखा के स्कोर के संकेत के साथ क्षेत्रों में विभाजित है। मानचित्र पर क्षेत्र को किसने पहचाना - अच्छी तरह से =)

एक ओर, आवश्यकता वैकल्पिक थी, लेकिन दूसरी ओर, चित्र दृश्य होने का वादा किया था, और कार्यान्वयन के दृष्टिकोण से यह प्रयास करना दिलचस्प था। कुछ विचार के बाद, एसवीजी प्रारूप में क्षेत्र की छवि को खोजने और इसके बाहर एक एक्सएसएलटी टेम्पलेट बनाने के लिए विचार आया।

परिणामी टेम्पलेट आसानी से डेटा से भर जाता है, और उसके बाद इसे पीएनजी में बदल दिया जाता है।
सबसे पहले, ऊपर वर्णित क्वेरी का उपयोग करते हुए, डेटा का नमूना लिया जाता है, प्राप्त डेटा को इस वर्ग के ऑब्जेक्ट में बदल दिया जाता है:

मानचित्र में डेटा आउटपुट के लिए कक्षाएं

 @XmlRootElement @XmlAccessorType(XmlAccessType.FIELD) @XmlType(name = "VisualisedValuesCriteria") public class VisualisedValuesCriteria { private XMLGregorianCalendar date; private String criteriaName; private String koefficient; private List<VisualizedValueCriteria> departValues; public XMLGregorianCalendar getDate() { return date; } public void setDate(XMLGregorianCalendar date) { this.date = date; } public String getCriteriaName() { return criteriaName; } public void setCriteriaName(String criteriaName) { this.criteriaName = criteriaName; } public String getKoefficient() { return koefficient; } public void setKoefficient(String koefficient) { this.koefficient = koefficient; } public List<VisualizedValueCriteria> getDepartValues() { if (departValues == null){ departValues = new ArrayList<>(); } return departValues; } public void setDepartValues(List<VisualizedValueCriteria> departValues) { this.departValues = departValues; } } @XmlRootElement @XmlAccessorType(XmlAccessType.FIELD) public class VisualizedValueCriteria { private String departName; private String departCode; private String value; private String percent; private String colorCode; public String getDepartName() { return departName; } public void setDepartName(String departName) { this.departName = departName; } public String getDepartCode() { return departCode; } public void setDepartCode(String departCode) { this.departCode = departCode; } public String getValue() { return value; } public void setValue(String value) { this.value = value; } public String getPercent() { return percent; } public void setPercent(String percent) { this.percent = percent; } public String getColorCode() { return colorCode; } public void setColorCode(String colorCode) { this.colorCode = colorCode; } } }

अगला, ऑब्जेक्ट को XML में कनवर्ट करें;

परिवर्तन

 Private String marshal (VisualisedValuesCriteria obj){ final Marshaller marshaller = JAXBContext.newInstance(VisualisedValuesCriteria.class).createMarshaller(); marshaller.setEventHandler(new DefaultValidationEventHandler()); marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); StringWriter writer = new StringWriter(); marshaller.marshal(obj, writer); return writer.toString(); }

अब, परिणामी XML, तैयार XSLT टेम्प्लेट लें, रूपांतरण लागू करें और आउटपुट में svg प्राप्त करें:

Svg ले आओ

  String xml = marshal(obj); TransformerFactory factory = TransformerFactory.newInstance(); FileInputStream xsltFis = new FileInputStream("C:\\TEMP\\map_xsl.svg"); InputStreamReader xsltIn = new InputStreamReader(xsltFis, "UTF-8"); Source xslt = new StreamSource(xsltIn); Transformer transformer = factory.newTransformer(xslt); InputStream xmlIn = new ByteArrayInputStream( xml.getBytes( "UTF-8" ) ); Source text = new StreamSource(xmlIn); String filename = "map" + System.currentTimeMillis() + ".svg"; String filePath = "C:\\TEMP\\" + filename; transformer.transform(text, new StreamResult(new File(filePath)));

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

पीएनजी में परिवर्तित करें

 private String convertToPNG(final String svg, final String filename, final String filePath){ String png = filePath + filename + ".png"; try { PNGTranscoder trancoder = new PNGTranscoder(); String svgURI = new File(svg).toURL().toString(); TranscoderInput input = new TranscoderInput(svgURI); OutputStream ostream = new FileOutputStream(png); TranscoderOutput output = new TranscoderOutput(ostream); trancoder.transcode(input, output); ostream.flush(); ostream.close(); return filename + ".png"; } catch (MalformedURLException ex) { Logger.getLogger(ActualCriteriaValueGraphicServlet.class.getName()).log(Level.SEVERE, null, ex); } catch (FileNotFoundException | TranscoderException ex) { Logger.getLogger(ActualCriteriaValueGraphicServlet.class.getName()).log(Level.SEVERE, null, ex); } catch (IOException ex) { Logger.getLogger(ActualCriteriaValueGraphicServlet.class.getName()).log(Level.SEVERE, null, ex); } return null; }

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

निष्कर्ष

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

यह कहना असंभव नहीं है कि ओपन Xav पर इंटरफ़ेस उपयोगकर्ताओं के लिए बहुत खुश नहीं था। सबसे पहले, इसकी विशेषताओं पर कई सवाल थे। कुछ बिंदु पर, उपयोगकर्ताओं ने शिकायत करना शुरू कर दिया कि डेटा दर्ज करने में बहुत अधिक समय लगा और सामान्य तौर पर, "हम चाहते हैं, जैसे एक्सेल में, केवल एक कार्यक्रम।" मुझे रिकॉर्ड्स के निर्माण के समय डेटा के आधार पर इनपुट गति की निगरानी भी करनी थी। इस निगरानी से पता चला कि सबसे गंभीर मामलों में भी, उपयोगकर्ताओं ने इनपुट पर 15 मिनट से अधिक नहीं बिताए, लेकिन आमतौर पर 5-7 में फिट होते हैं, इस तथ्य के बावजूद कि उन्हें 22 शाखाओं पर डेटा दर्ज करने की आवश्यकता थी। ऐसे संकेतक काफी स्वीकार्य लगते हैं।

हालाँकि, मैं दो बातें नोट करना चाहता हूं:

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

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

वह सब है। मैं रचनात्मक प्रतिक्रिया के लिए आभारी रहूंगा!

प्रति माह KPI के संग्रह को स्वचालित कैसे करें और उपयोगकर्ताओं को लगभग संतुष्ट छोड़ दें