make_methodp - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

make_method - RPC::XML::Server-നുള്ള ഒരു XML വിവരണമാക്കി Perl കോഡ് മാറ്റുക

സിനോപ്സിസ്

make_method --name=system.identification --helptext='സിസ്റ്റം ഐഡി സ്ട്രിംഗ്'
--signature=string --code=ident.pl --output=ident.xpl

make_method --ബേസ്=രീതികൾ/തിരിച്ചറിയൽ

വിവരണം

രീതികൾ വ്യക്തമാക്കുന്നതിന് XML വിവരണാത്മക ഫയലുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ലളിതമായ ഉപകരണമാണിത്
ഒരു പ്രസിദ്ധീകരിച്ചത് RPC::XML::സെർവർഅടിസ്ഥാന സെർവർ.

ഒരു സെർവർ അത് കയറ്റുമതി ചെയ്യുന്ന രീതികൾ എഴുതിയിട്ടുണ്ടെങ്കിൽ (അല്ലെങ്കിൽ പ്രസിദ്ധീകരിക്കുന്നു) യുടെ ഭാഗമാണ്
കോഡ് പ്രവർത്തിക്കുന്നു, അപ്പോൾ ഈ ഉപകരണത്തിന്റെ ആവശ്യമില്ല. എന്നിരുന്നാലും, സെർവർ സാധ്യമാകുന്ന സന്ദർഭങ്ങളിൽ
കോഡിൽ നിന്ന് (അപ്പാച്ചെ അടിസ്ഥാനമാക്കിയുള്ള RPC സെർവർ പോലുള്ളവ) വേറിട്ടതും വ്യതിരിക്തവുമായിരിക്കുക
ദിനചര്യകളും പിന്തുണയ്ക്കുന്ന വിവരങ്ങൾ പൂരിപ്പിക്കുന്നതും ബുദ്ധിമുട്ടുള്ള കാര്യമാണ്.

ഒരു പരിഹാരം RPC::XML::സെർവർ പബ്ലിഷ് ചെയ്യാവുന്ന ലോഡിനുള്ള മാർഗമാണ് പാക്കേജ് ഓഫറുകൾ
ഒരു ബാഹ്യ ഫയലിൽ നിന്നുള്ള കോഡ്. ഫയൽ വ്യക്തമായി നിർവചിക്കുന്ന ലളിതമായ XML ഭാഷയിലാണ്
ബാഹ്യമായി ദൃശ്യമാകുന്ന പേര്, രീതി ഒപ്പുകൾ, സഹായ വാചകം, കോഡ് എന്നിവയും. ഇവ
ഫയലുകൾ സ്വമേധയാ സൃഷ്ടിക്കപ്പെടാം, അല്ലെങ്കിൽ ഈ ഉപകരണം ഒരു സഹായിയായി ഉപയോഗിക്കാം.

ആവശ്യമാണ് വാദങ്ങൾ

ആവശ്യമായ ആർഗ്യുമെന്റുകളൊന്നുമില്ല, എന്നാൽ മതിയായ ഓപ്‌ഷനുകൾ പാസ്സാക്കിയില്ലെങ്കിൽ നിങ്ങൾ ചെയ്യും
ഒരു പിശക് സന്ദേശത്തിലൂടെ പറയണം.

ഓപ്ഷനുകൾ

ഉപകരണം ഇനിപ്പറയുന്ന ഓപ്ഷനുകൾ തിരിച്ചറിയുന്നു:

--സഹായിക്കൂ
ഓപ്ഷനുകളുടെ ഒരു ഹ്രസ്വ സംഗ്രഹം പ്രിന്റ് ചെയ്യുന്നു.

--പേര്=STRING
എൻകോഡ് ചെയ്യുന്ന രീതിയുടെ പ്രസിദ്ധീകരിച്ച പേര് വ്യക്തമാക്കുന്നു. ഇതാണ് അതിന്റെ പേര്
സെർവറിന്റെ ക്ലയന്റുകൾക്ക് ദൃശ്യമാകും.

--namespace=STRING
XPL ആകുമ്പോൾ, രീതിയുടെ കോഡ് വിലയിരുത്തപ്പെടുന്ന ഒരു നെയിംസ്പേസ് വ്യക്തമാക്കുന്നു
ഫയൽ ലോഡ് ചെയ്തിരിക്കുന്നത് ഒരു സെർവർ ഉദാഹരണത്തിലൂടെയാണ്.

--തരം=STRING
തത്ഫലമായുണ്ടാകുന്ന ഫയലിന്റെ തരം വ്യക്തമാക്കുക. ഇവിടെ "ടൈപ്പ്" എന്നത് കണ്ടെയ്നർ ആണോ എന്ന് സൂചിപ്പിക്കുന്നു
തത്ഫലമായുണ്ടാകുന്ന XML-ൽ ഉപയോഗിക്കുന്ന ടാഗ് a വ്യക്തമാക്കും നടപടിക്രമം അല്ലെങ്കിൽ രീതി. സ്ഥിരസ്ഥിതി
രീതി. സ്ട്രിംഗിനെ കേസ്-ഇൻഡിപെൻഡന്റ് ആയി കണക്കാക്കുന്നു, ആദ്യ പ്രതീകം മാത്രം ("m" അല്ലെങ്കിൽ
"p") യഥാർത്ഥത്തിൽ കണക്കാക്കപ്പെടുന്നു.

--പതിപ്പ്=STRING
കോഡ് ദിനചര്യയ്‌ക്കായി ഒരു പതിപ്പ് സ്റ്റാമ്പ് വ്യക്തമാക്കുക.

--മറഞ്ഞിരിക്കുന്നു
ഇത് പാസ്സാണെങ്കിൽ, ഫലമായുണ്ടാകുന്ന ഫയലിൽ സെർവർ ഡെമണിനോട് പറയുന്ന ഒരു ടാഗ് ഉൾപ്പെടും
ഏതെങ്കിലും ആത്മപരിശോധനാ ഇന്റർഫേസുകളിലൂടെ ദിനചര്യ ദൃശ്യമാക്കാതിരിക്കാൻ.

--സിഗ്നേച്ചർ=STRING [ --സിഗ്നേച്ചർ=STRING ... ]
രീതിക്കായി ഒന്നോ അതിലധികമോ ഒപ്പുകൾ വ്യക്തമാക്കുക. ഒപ്പുകൾ എന്ന തരത്തിലുള്ള പേരുകളായിരിക്കണം
RPC::XML-ലെ ഡോക്യുമെന്റേഷനിൽ ഒരു കോളൻ കൊണ്ട് വേർതിരിക്കുന്ന ഘടകങ്ങൾ ഉപയോഗിച്ച്. നിങ്ങൾ
നിങ്ങൾ വാദം ഉദ്ധരിക്കുകയാണെങ്കിൽ, അവയെ സ്‌പെയ്‌സ് ഉപയോഗിച്ച് വേർതിരിക്കാം. ഈ ഓപ്ഷൻ ആയിരിക്കാം
ഒന്നിലധികം തവണ വ്യക്തമാക്കിയിട്ടുണ്ട്, കാരണം ചില രീതികൾക്ക് നിരവധി ഒപ്പുകൾ ഉണ്ടായിരിക്കാം.

--helptext=STRING
കമാൻഡ് ലൈനിൽ ലളിതമായ ഒരു സ്ട്രിംഗായി മെത്തേഡിനുള്ള സഹായ വാചകം വ്യക്തമാക്കുക. അല്ല
ഭയങ്കരമായ നീളമുള്ള സഹായ സ്ട്രിംഗുകൾക്ക് അനുയോജ്യം.

--helpfile=FILE
നിർദ്ദിഷ്ട ഫയലിൽ നിന്ന് രീതിയുടെ സഹായ വാചകം വായിക്കുക.

--code=FILE
നിർദ്ദിഷ്ട ഫയലിൽ നിന്ന് ദിനചര്യയുടെ യഥാർത്ഥ കോഡ് വായിക്കുക. ഈ ഓപ്ഷൻ ഇല്ലെങ്കിൽ
നൽകിയിരിക്കുന്നത്, സാധാരണ ഇൻപുട്ട് ഫയൽ ഡിസ്ക്രിപ്റ്ററിൽ നിന്നാണ് കോഡ് വായിക്കുന്നത്.

--output=FILE
തത്ഫലമായുണ്ടാകുന്ന XML പ്രാതിനിധ്യം നിർദ്ദിഷ്ട ഫയലിലേക്ക് എഴുതുക. ഈ ഓപ്ഷൻ ഇല്ലെങ്കിൽ
നൽകിയിരിക്കുന്നു, അപ്പോൾ ഔട്ട്പുട്ട് സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് ഫയൽ ഡിസ്ക്രിപ്റ്ററിലേക്ക് പോകുന്നു.

--ബേസ്=NAME
ഇതൊരു സവിശേഷമായ, "ഓൾ-ഇൻ-വൺ" ഓപ്ഷനാണ്. പാസ്സായാൽ, മറ്റെല്ലാ ഓപ്ഷനുകളും അവഗണിക്കപ്പെടും.

പേരിട്ടിരിക്കുന്ന ഫയലിൽ നിന്നുള്ള വിവരങ്ങൾ വായിക്കുന്നതിനുള്ള അടിസ്ഥാന ഘടകമായി മൂല്യം ഉപയോഗിക്കുന്നു
BASE.അടിസ്ഥാനം. ഈ ഫയലിൽ പേര്, പതിപ്പ്, മറഞ്ഞിരിക്കുന്ന നില, എന്നിവയുടെ സ്പെസിഫിക്കേഷൻ അടങ്ങിയിരിക്കും
ഒപ്പുകളും മറ്റ് രീതി വിവരങ്ങളും. ഫയലിന്റെ ഓരോ വരിയും ഒന്ന് പോലെ ആയിരിക്കണം
ഇനിപ്പറയുന്നവ:

പേര്: സ്ട്രിംഗ്
പ്രസിദ്ധീകരിക്കുന്ന ദിനചര്യയുടെ പേര് വ്യക്തമാക്കുക. ഈ വരി ദൃശ്യമാകുന്നില്ലെങ്കിൽ,
അപ്പോൾ മൂല്യം --അടിസ്ഥാനം നീക്കം ചെയ്ത എല്ലാ ഡയറക്‌ടറി ഘടകങ്ങളുമായും ഉള്ള ആർഗ്യുമെന്റ് ആയിരിക്കും
ഉപയോഗിച്ചു.

പതിപ്പ്: സ്ട്രിംഗ്
പ്രവർത്തനത്തിനായി ഒരു പതിപ്പ് സ്റ്റാമ്പ് നൽകുക. ഈ പാറ്റേണുമായി പൊരുത്തപ്പെടുന്ന ഒരു വരിയും ഇല്ലെങ്കിൽ
നിലവിൽ, പതിപ്പ് ടാഗൊന്നും എഴുതില്ല.

മറച്ചത്: സ്ട്രിംഗ്
ഉണ്ടെങ്കിൽ, സ്ട്രിംഗ് ഒന്നുകിൽ "അതെ" അല്ലെങ്കിൽ "ഇല്ല" (കേസ് പ്രധാനമല്ല) ആയിരിക്കണം. അങ്ങനെ എങ്കിൽ
"അതെ", തുടർന്ന് ഏതെങ്കിലും ആത്മപരിശോധന API-ൽ നിന്ന് ഈ രീതി മറച്ചിരിക്കുന്നതായി അടയാളപ്പെടുത്തിയിരിക്കുന്നു.

കയ്യൊപ്പ്: സ്ട്രിംഗ്
ഈ വരി ഒന്നിലധികം തവണ ദൃശ്യമാകാം, ഇത് ക്യുമുലേറ്റീവ് ആയി കണക്കാക്കുന്നു. മറ്റ് ഓപ്ഷനുകൾ
മുമ്പത്തെ മൂല്യങ്ങൾ ഒന്നിലധികം തവണ ദൃശ്യമാകുകയാണെങ്കിൽ അവ അസാധുവാക്കുക. താഴെയുള്ള ഭാഗം
"സിഗ്നേച്ചർ:" എന്ന ഭാഗം ഈ രീതിയുടെ പ്രസിദ്ധീകരിച്ച ഒപ്പായി എടുക്കുന്നു
വൈറ്റ്‌സ്‌പെയ്‌സ് കൊണ്ട് വേർതിരിച്ച ഘടകങ്ങൾ. ഓരോ രീതിയിലും കുറഞ്ഞത് ഒരു ഒപ്പെങ്കിലും ഉണ്ടായിരിക്കണം, അതിനാൽ
ഒന്നിന്റെ അഭാവം ഒരു പിശകിന് കാരണമാകും.

സഹായ ഫയൽ: സ്ട്രിംഗ്
സഹായ വാചകം വായിക്കേണ്ട ഫയൽ വ്യക്തമാക്കുന്നു. സഹായമില്ലെങ്കിൽ അതൊരു തെറ്റല്ല
ടെക്സ്റ്റ് വ്യക്തമാക്കിയിരിക്കുന്നു.

കോഡ് ഫയൽ: സ്ട്രിംഗ്
കോഡ് വായിക്കേണ്ട ഫയൽ വ്യക്തമാക്കുന്നു. കോഡ് പേൾ ആണെന്ന് അനുമാനിക്കപ്പെടുന്നു, ഒപ്പം
തത്ഫലമായുണ്ടാകുന്ന ഫയലിൽ ടാഗ് ചെയ്യപ്പെടും.

കോഡ് ഫയൽ[ലാംഗ്]: സ്ട്രിംഗ്
ഭാഷ തിരിച്ചറിയുമ്പോൾ കോഡ് വായിക്കേണ്ട ഫയൽ വ്യക്തമാക്കുന്നു
കോഡ് ഉള്ളതാണ്. ഇത് ഒരു സൃഷ്ടിക്കാൻ അനുവദിക്കുന്നു XPL ഉൾപ്പെടുന്ന ഫയൽ
തന്നിരിക്കുന്ന രീതിയുടെയോ നടപടിക്രമത്തിന്റെയോ ഒന്നിലധികം ഭാഷാ നടപ്പാക്കലുകൾ.

മുകളിലുള്ള പാറ്റേണുകളല്ലാതെ മറ്റേതെങ്കിലും വരികൾ അവഗണിക്കപ്പെടും.

ഒരു കോഡും വായിച്ചിട്ടില്ലെങ്കിൽ, ഒരു പിശക് സന്ദേശത്തോടെ ഉപകരണം പുറത്തുകടക്കും.

ഔട്ട്പുട്ട് എഴുതിയിരിക്കുന്നു BASE.xpl, പാത്ത് വിവരങ്ങൾ സംരക്ഷിക്കുന്നു, അങ്ങനെ
തത്ഫലമായുണ്ടാകുന്ന ഫയൽ ഉറവിട ഫയലുകൾക്കൊപ്പം തന്നെയുണ്ട്. ഇതുപോലുള്ള നിർമ്മാണങ്ങളെ ഇത് അനുവദിക്കുന്നു:

make_method --ബേസ്=രീതികൾ/ആത്മപരിശോധന

FILE ഫോർമാറ്റ് ഒപ്പം ഡി.ടി.ഡി

ഈ പ്രസിദ്ധീകരിച്ച ദിനചര്യകൾക്കായുള്ള ഫയൽ ഫോർമാറ്റ് വളരെ ലളിതമായ ഒരു XML ഭാഷയാണ്. ഇത് കുറവാണ്
XML എന്നത് പാർസറിന്റെ ലഭ്യതയേക്കാൾ അനുയോജ്യമായ ഒരു ഫോർമാറ്റ് ആയതിനാൽ,
RPC::XML::സെർവർ ക്ലാസ്സിന് ഇതിനകം തന്നെ കോറിൽ പാർസർ കോഡ് ഉണ്ടായിരിക്കും. തികച്ചും പുതിയത് എഴുതുന്നു
ഫോർമാറ്റ് ഒന്നും നേടുമായിരുന്നില്ല.

ഫോർമാറ്റിനായുള്ള ഡോക്യുമെന്റ് തരം പ്രഖ്യാപനം ഇങ്ങനെ സംഗ്രഹിക്കാം:

<!ELEMENT processdef (പേര്, നെയിംസ്‌പെയ്‌സ്?, പതിപ്പ്?, മറച്ചത്?,
ഒപ്പ്+, സഹായം?, കോഡ്)>
<!ELEMENT methoddef (പേര്, നെയിംസ്‌പെയ്‌സ്?, പതിപ്പ്?, മറച്ചത്?,
ഒപ്പ്+, സഹായം?, കോഡ്)>
<!ELEMENT functiondef (പേര്, നെയിംസ്‌പെയ്‌സ്?, പതിപ്പ്?, മറച്ചത്?,
ഒപ്പ്+, സഹായം?, കോഡ്)>









വിതരണത്തോടൊപ്പം വരുന്ന "rpc-method.dtd" എന്ന ഫയലിന് ചില വ്യാഖ്യാനങ്ങളും ഉണ്ട്
യഥാർത്ഥ സ്പെസിഫിക്കേഷനിലേക്ക്.

ഒരു ഫയൽ (ഇപ്പോൾ) ഒരു നിർവചനത്തിൽ പരിമിതപ്പെടുത്തിയിരിക്കുന്നു. ഓപ്പണിംഗിൽ ഒന്നിൽ നിന്നാണ് ഇത് ആരംഭിക്കുന്നത്
ടാഗുകൾ " "," " അഥവാ " ". ഇത് കൃത്യമായി ഒന്ന് പിന്തുടരുന്നു
" " രീതിയുടെ പേര് വ്യക്തമാക്കുന്ന കണ്ടെയ്നർ, ഒരു ഓപ്ഷണൽ പതിപ്പ് സ്റ്റാമ്പ്, ഒരു ഓപ്ഷണൽ
ആത്മപരിശോധനയിൽ നിന്ന് മറയ്ക്കുക, ഒന്നോ അതിലധികമോ " "സിഗ്നേച്ചറുകൾ വ്യക്തമാക്കുന്ന കണ്ടെയ്നറുകൾ,
ഒരു ഓപ്ഷണൽ " " സഹായ വാചകം ഉള്ള കണ്ടെയ്നർ, തുടർന്ന് " " container with the
യഥാർത്ഥ പ്രോഗ്രാം കോഡ്. എല്ലാ വാചകങ്ങളും ചിഹ്നങ്ങൾക്കായി എന്റിറ്റി എൻകോഡിംഗ് ഉപയോഗിക്കണം:

& സി<&> (ആംപേഴ്സൻഡ്)
ഇ C<<> (കുറവ്)
ഇ C<>> (അതിനേക്കാൾ വലുത്)

സെർവർ ക്ലാസിനുള്ളിലെ പാഴ്‌സിംഗ് പ്രക്രിയ എന്റിറ്റികളെ ഡീകോഡ് ചെയ്യും. കാര്യങ്ങൾ ഉണ്ടാക്കാൻ
എളുപ്പത്തിൽ, ടൂൾ എല്ലാ ടെക്സ്റ്റ് ഘടകങ്ങളും സ്കാൻ ചെയ്യുകയും എഴുതുന്നതിന് മുമ്പ് മുകളിലുള്ള എന്റിറ്റികളെ എൻകോഡ് ചെയ്യുകയും ചെയ്യുന്നു
ഫയൽ.

ദി വിവരണം of കോഡ്
ഇതല്ല "പ്രോഗ്രാമിംഗ് ക്സനുമ്ക്സ ", അതുമല്ല "പേൾ വേണ്ടി The കുറച്ച് മങ്ങിയ". അതാണ് കോഡ്
"*.xpl" ഫയലുകളിലൊന്ന് വഴി കടന്നുപോകുമ്പോൾ, അടുത്തതായി മാറ്റങ്ങളൊന്നുമില്ലാതെ "eval" ലേക്ക് കടന്നുപോകുന്നു
(താഴെ നോക്കുക). അതിനാൽ, മോശമായി എഴുതിയതോ ക്ഷുദ്രകരമായതോ ആയ കോഡ് നിങ്ങളുടെ നാശം വിതച്ചേക്കാം
സെർവർ. ഇത് സെർവർ കോഡിന്റെ തെറ്റല്ല. ഈ സംവിധാനത്തിന്റെ വഴക്കത്തിന്റെ വില
കോഡ് ആണെന്ന് ഉറപ്പാക്കാനുള്ള ഡെവലപ്പറുടെ ഉത്തരവാദിത്തമാണ് ഓഫറുകൾ
പരീക്ഷിച്ചതും സുരക്ഷിതവുമാണ്.

കോഡ് തന്നെ കഴിയുന്നത്ര പദാനുപദമായി കണക്കാക്കുന്നു. ചില തിരുത്തലുകൾ സെർവർ സൈഡിൽ സംഭവിക്കാം,
ഒരു അജ്ഞാത സബ്റൂട്ടീൻ സൃഷ്ടിക്കുന്നതിന് കോഡ് അനുയോജ്യമാക്കുന്നതിനാൽ. ദി ഉണ്ടാക്കുക_രീതി
XML ഡോക്യുമെന്റിനുള്ളിൽ കോഡ് ഉൾച്ചേർക്കുന്നതിനായി ടൂൾ ഒരു "CDATA" വിഭാഗം ഉപയോഗിക്കാൻ ശ്രമിക്കും
എന്റിറ്റികളോ മറ്റുള്ളവയോ എൻകോഡ് ചെയ്യേണ്ട ആവശ്യമില്ല. തത്ഫലമായി ഇത് അനുവദിക്കുന്നു *.xpl
"perl -cx" ഉപയോഗിച്ച് ഫയലുകൾ സിന്റാക്സ്-ടെസ്റ്റ് ചെയ്യാവുന്നവയാണ്. കോഡ് ഉണ്ടെന്ന് ഉറപ്പാക്കിക്കൊണ്ട് നിങ്ങൾക്ക് ഇത് സഹായിക്കാനാകും
ഇനിപ്പറയുന്ന രണ്ട് ക്യാരക്ടർ സീക്വൻസുകളിൽ ഒന്ന് അടങ്ങിയിട്ടില്ല:

]]>

__ഡാറ്റ__

ആദ്യത്തേത് "CDATA" ടെർമിനേറ്ററാണ്. ഇത് സ്വാഭാവികമായും കോഡിൽ സംഭവിക്കുകയാണെങ്കിൽ, അത് ട്രിഗർ ചെയ്യും
പാർസറിലെ അവസാനഭാഗം. രണ്ടാമത്തേത് പരിചിതമായ പേൾ ടോക്കൺ ആണ്, അത് ചേർത്തിരിക്കുന്നു
XML ഡോക്യുമെന്റിന്റെ ശേഷിക്കുന്ന ഭാഗം പേൾ പാർസറിനെ അലങ്കോലപ്പെടുത്താതിരിക്കാൻ.

ഉദാഹരണങ്ങൾ

ദി RPC::XML ഡിസ്ട്രിബ്യൂഷൻ എന്ന് വിളിക്കപ്പെടുന്ന ഒരു ഉപഡയറക്‌ടറിയിൽ നിരവധി ഡിഫോൾട്ട് രീതികൾ വരുന്നു
(നിഗൂഢമായി മതി) "രീതികൾ". ഇവ ഓരോന്നും ഒരു കൂട്ടം ("*.ബേസ്",
"*.കോഡ്", "*.സഹായം") ഫയലുകൾ. Makefile.PL ഫയൽ തത്ഫലമായുണ്ടാകുന്ന Makefile കോൺഫിഗർ ചെയ്യുന്നു
ഈ ടൂൾ ഉപയോഗിച്ച് "*.xpl" ഫയലുകൾ സൃഷ്ടിക്കാൻ ഇവ ഉപയോഗിക്കുന്നു, തുടർന്ന് അവ ഇൻസ്റ്റാൾ ചെയ്യുക.

ഡയഗ്നോസ്റ്റിക്സ്

മിക്ക പ്രശ്‌നങ്ങളും പിശക് സന്ദേശങ്ങളുടെ രൂപത്തിലാണ് പുറത്തുവരുന്നത്, തുടർന്ന് പെട്ടെന്ന് പുറത്തുകടക്കുക.

പുറത്ത് പദവി

ടൂൾ വിജയിക്കുമ്പോൾ 0 എന്ന നിലയോടും അല്ലാത്തപക്ഷം 255 ഉം ആയി പുറത്തുകടക്കുന്നു.

മുന്നറിയിപ്പ്

രീതികൾ വ്യക്തമാക്കുന്നതിനുള്ള ഈ സമീപനം എനിക്ക് അത്ര ഇഷ്ടമല്ല, എന്നാൽ എന്റെ മറ്റ് ആശയങ്ങൾ പോലും എനിക്ക് ഇഷ്ടപ്പെട്ടു
കുറവ്.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് ഓൺലൈനിൽ make_methodp ഉപയോഗിക്കുക