მომხმარებლისთვის შეტყობინებების ჩვენება ვებ აპლიკაციებში. PHP AJAX CRUD: ჩანაწერების შექმნა, წაშლა, რედაქტირება MySQL მონაცემთა ბაზაში PHP სკრიპტი CRUD ოპერაციებისთვის

მიმოხილვა

ჩაშენებული შეტყობინებების სისტემა, პირველად Joomla-ში, საშუალებას აძლევს თქვენს აპს, შეინახოს მომხმარებელი (ან მომხმარებელთა ჯგუფი) ინფორმირებული სხვადასხვა მოვლენის შესახებ. იფიქრეთ შეტყობინებებზე, როგორც მნიშვნელოვან გაფრთხილებებზე, რომლითაც მომხმარებელი დაინტერესდება მისი წაკითხვით და თვალყურის დევნით.
შეტყობინებების გენერირება შესაძლებელია ყველგან. თქვენს კომპონენტში ან დანამატებში და მოგვიანებით ნაჩვენებია JomSocial შეტყობინებების სისტემაში.
ეს გაკვეთილი გაჩვენებთ, თუ როგორ, მაგრამ რადგან ჩვენ არ გვაქვს წარმოდგენა მესამე მხარის კომპონენტზე, შეგვიძლია გამოვიყენოთ:) მაგალითები გაკეთდება საზოგადოების დანამატზე, რომელიც ამოქმედდება onAfterProfileUpdate ღონისძიებაზე
თუ არ იცით როგორ შექმნათ დანამატი, რომელიც ამოქმედდება ამ ღონისძიებაზე, გირჩევთ შეამოწმოთ ეს სახელმძღვანელო

მისი დანერგვა თქვენს კომპონენტში მაინც

როგორც ამ გაკვეთილის მიმოხილვაშია ნათქვამი, ჩვენ შევქმნით შეტყობინებებს საზოგადოების მოდულის გამოყენებით.
თქვენ, სავარაუდოდ, გსურთ შექმნათ შეტყობინებები თქვენს კომპონენტში ან თქვენს დანამატში. შემდეგი გაკვეთილი იმუშავებს ნებისმიერ შემთხვევაში. თქვენ მხოლოდ უნდა განსაზღვროთ თქვენი კოდის რომელ მომენტში შეიქმნება შეტყობინება და უბრალოდ ჩატვირთოთ JomSocial Core Libraries ფაილი.

მოითხოვს_ერთჯერ JPATH_ROOT. "/components/com_community/libraries/core.php" ;

ქვემოთ ახსნილი ინსტრუქციის შემდეგ კარგად იმუშავებს თქვენი გაფართოებისთვისაც

განვითარების გარემოს მომზადება

1. ჩვენ ვივარაუდებთ, რომ თქვენ უკვე შექმენით საზოგადოების ტიპის მაგალითის დანამატი, რომელიც გააქტიურდება, როდესაც მომხმარებელი შეცვლის მის პროფილს
თუ არა, შეგიძლიათ ჩამოტვირთოთ ცარიელი მაგალითი მოდულიდან, დააინსტალიროთ ჯომლაში და ჩართოთ დანამატი. დასახელებულია საზოგადოება - შეტყობინებების მაგალითი
2. გადადით თქვენს მონაცემთა ბაზაში და დააცალეთ ეს ორი ცხრილი, რათა მათ საერთოდ არ ჰქონდეთ ჩანაწერები

ა) პრეფიქსი_საზოგადოების_შეტყობინება
ბ) პრეფიქსი_საზოგადოება_ფოსტა

3. გყავდეთ მინიმუმ ორი (2) მომხმარებელი თქვენს სატესტო საიტებზე და იცოდეთ მათი პირადობის მოწმობები

Joomla-ს ადრინდელ ვერსიებში მომხმარებლის ID-ები ყოველთვის იწყებოდა მითითებული ნომრიდან (62, 42) Joomla 3-ში ეს რიცხვი იქნება შემთხვევითი, შესაბამისად, ჩვენი ტესტირების გარემოს სურათი, რადგან ის აუცილებლად განსხვავებული იქნება თქვენს ბოლოს.

პირველი შეტყობინება

გახსენით მოდულის php ფაილი, რომელიც განთავსდება ROOT/plugins/community/მაგალითად
onAfterProfileUpdate() ფუნქციის ფარგლებში შეცვალეთ

CNotificationLibrary::add ( $cmd , $actor , $target , $subject , $body , $template , $params ) ;

როგორც მაგალითზეა ნაჩვენები, შეტყობინების დამატება api-ს აქვს 7 პარამეტრი

$cmd - არის შეტყობინების ტიპი. თქვენ შეგიძლიათ ნახოთ ყველა ტიპის შეტყობინებები ამ ფაილში. ROOT/components/com_community/libraries/notificationtypes.php დაწყებული 53-ე სტრიქონიდან ან მის გარშემო. ჩვენ გირჩევთ გამოიყენოთ system_messaging შეტყობინების ტიპი.

$actor - არის ადამიანი, რომელიც ახორციელებს მოქმედებას

$target - არის ადამიანი ან ადამიანთა ჯგუფი, რომელიც მიიღებს შეტყობინებას

$subject - არის შეტყობინების თემა, როგორც შეტყობინების ამომხტარ ფანჯარაში, ასევე ელფოსტის სათაური

$body - არის ელ.ფოსტის შეტყობინების შეტყობინება

$template - თუ გჭირდებათ კონკრეტული შაბლონი გამოსაყენებლად, შეგიძლიათ განსაზღვროთ აქ. წინააღმდეგ შემთხვევაში, ეს პარამეტრი შეიძლება ცარიელი იყოს

$params - ინდივიდუალური განსაზღვრული პარამეტრები

ამ ყველაფრის ცოდნამ, მოდით განვსაზღვროთ ცვლადები, რომლებსაც გამოვიყენებთ
შეცვალეთ თქვენი მოდულის კოდი:

$user = CFactory::getUser(); $cmd = "system_messaging" ; // პირველი პარამეტრი, აქტივობის ტიპი $actor = $user -> id ; //second param - მიიღეთ $actor $target = "965" ; // მესამე პარამი. ვინ იღებს შეტყობინებას? ჩვენს დეველოპერულ გარემოში, მისი ადმინისტრატორის მომხმარებელი ID 965-ით. თქვენს გარემოში, დიდი ალბათობით, გსურთ მიიღოთ ID თქვენი ობიექტიდან ან მომხმარებელთა მასივიდან. $subject = "შეტყობინებების საგანი" ; // ორივეს თემა, ელფოსტისა და ამომხტარი შეტყობინებების $body = ; // ტექსტური შეტყობინება ელფოსტაში. $template = "" ; // თუ თქვენ გჭირდებათ კონკრეტული jomsocial შაბლონის ფაილის გამოყენება, შეგიძლიათ მისი განსაზღვრა აქ. $params = ახალი CPparameter("" ); // ჩვენ გვინდა შევქმნათ დამატებითი პარამების ობიექტი და მივცეთ მას მონაცემები, CNotificationLibrary კლასის ოფიციალურად განსაზღვრის გარეშე: add ($cmd , $actor , $target , $subject , $body , $template , $params ) ;

ახლა შედით ნებისმიერ მომხმარებელთან და შეცვალეთ პროფილის ინფორმაცია. მოდით გადავიდეთ მონაცემთა ბაზაში და ვნახოთ რა მოხდა.
გადადით prefix_community_notifications ცხრილში და დააკვირდით ახალ ჩანაწერს

გადადით prefix_community_mailq ცხრილში და ნახეთ ახალი ჩანაწერი

გილოცავ! - თქვენ წარმატებით შექმენით თქვენი პირველი საკუთარი შეტყობინება, რომელიც გაიგზავნა ელექტრონული ფოსტით და შიდა JomSocial შეტყობინებების სისტემის საშუალებით

პოტენციური კოდი Bloat

ზემოთ მოყვანილი მაგალითი კარგია და მუშაობს, მაგრამ ზოგადად არ არის რეკომენდებული მისი ასე გამოყენება. სამაგიეროდ შეიძლება ასე დაიწეროს

$actor = CFactory::getUser(); $params = ახალი CPparameter("" ); CNotificationLibrary:: add ( "system_messaging" , $actor -> "ეს არის შეტყობინების ტექსტი" , "" , $params ) ;

ეს ბევრად უფრო სუფთა და ადვილი შესასრულებელია, ხოლო ძირითადად აკეთებს აბსოლუტურად იგივეს, რაც ზემოთ ნაჩვენები კოდი.

მორგებული შეტყობინების პარამეტრები

შეტყობინებების API შეიძლება გაფართოვდეს ნებისმიერი პარამეტრით, რომლის დამატებაც გსურთ.
ეს პარამეტრები შეიძლება გადაეცეს ელ.ფოსტის შაბლონს, შეტყობინებას და, რა თქმა უნდა, ენის ფაილს.

$actor = CFactory::getUser(); $link = "http://www.google.com" ; $params = ახალი CPparameter("" ); $params -> set ("actor" , $actor -> getDisplayName () ); // შეიძლება გამოყენებულ იქნას როგორც (actor) ტეგი $params -> set ("actor_url" , "index.php?option=com_community&view=profile&userid=" . $actor -> id ) ; // ბმული (actor) ტეგის $params -> set ("url" , $link ) ; //მთელი აქტივობის url. გამოიყენება შეტყობინებების ფანჯარაში ავატარზე გადასვლისას. შეიძლება გამოყენებულ იქნას როგორც (url) ტეგი გამავალ წერილებშიც. დარწმუნდით, რომ განსაზღვრეთ $link ცვლადი:) CNotificationLibrary:: add ( "system_messaging" , $actor -> id , "965" , "შეტყობინებების საგანი" , "ეს არის შეტყობინების ტექსტი" , "" , $params ) ;

$params = ახალი CPპარამეტრი( ); - ჩვენ გვინდა შევქმნათ ახალი params ობიექტი და მივცეთ მას მონაცემები, კლასის ოფიციალურად განსაზღვრის გარეშე.
$params->set("actor", $actor->getDisplayName()); - შენს შეტყობინებას ყოველთვის მსახიობი უნდა ჰქონდეს. ეს პარამეტრი შეიძლება გადაეცეს შაბლონს, როგორც (actor) თეგი. შეტყობინებების ფანჯარაში ის განსაზღვრავს მომხმარებელს, რომელიც ახორციელებს მოქმედებას.
$params->set("actor_url", "index.php?option=com_community&view=profile&userid=" . $actor->id); - მსახიობის URL, როგორც წესი, არის მსახიობის url. შეტყობინების ამომხტარ ფანჯარაში, ის ამატებს ბმულს (მსახიობი) ელემენტს
$params->set("url", $link); - ეს არის ყველაზე მნიშვნელოვანი პარამეტრი, რომელიც ყოველთვის სწორად უნდა დააყენოთ. შეტყობინებების ფანჯარაში ეს პარამეტრი გამოიყენება ავატარის სურათზე. ელ.ფოსტის შეტყობინებაში ის ეხმიანება იმ ადგილს, სადაც მოხდა აქტივობა.

ამ მაგალითისთვის ჩვენ დავაყენებთ ცვლადს $link to lands on www.google.comასე რომ თქვენ შეგიძლიათ ნახოთ როგორ მუშაობს

ენის სტრიქონის დამატება და პარამეტრების გამოყენება

ჩვენ მიერ ახლახან დაყენებული პარამეტრების ქონა შესაძლებელია ჩვენს ენობრივ ფაილებშიც გამოსაყენებლად.
მოდით განვსაზღვროთ ენის გასაღებები ""-ის შეცვლით CNotificationLibrary::add() API

CNotificationLibrary::add("system_messaging" , $actor -> id , "965" , JText::sprintf("PLG_COMMUNITY_EXAMPLE_SUBJECT") , JText::sprintf("PLG_COMMUNITY_EXAMPLE_BODY";

ენის ფაილი ასე უნდა გამოიყურებოდეს

PLG_COMMUNITY_EXAMPLE_SUBJECT = "(მსახიობი) განახლებული პროფილი" PLG_COMMUNITY_EXAMPLE_BODY = "გამარჯობა ადმინისტრატორო \n ეს არის წერილი, რათა გაცნობოთ, რომ (მსახიობი) განახლებულია პროფილი \n\n თუ გსურთ Google-ში გადასვლა, დააწკაპუნეთ აქ \n a href=" _QQ_" (url)"_QQ_">(url)"

ამ მაგალითში, ჩვენ გამოვიყენეთ ტეგი (actor) და (url) მონაცემების გადასაცემად ორივე, შეტყობინებების და ელ.ფოსტის შაბლონებზე. ვნახოთ, როგორ გამოიყურება.
შეტყობინებების ფანჯარაში ავატარზე გადასვლისას შეამჩნიეთ (url) პარამეტრი ჩართული და ამატებს Google-ის ბმულს ავატარზე. ეს არის მიზანმიმართული, რადგან ჩვენ ასე გავაკეთეთ :)

]

იმავე ფანჯარაში, მსახიობის ბმულზე გადასვლისას. ეს არის ის ნაწილი, სადაც (actor) ეხმიანება მომხმარებელს, რომელიც ახორციელებს მოქმედებას, ხოლო (actor_url)" ზრუნავს, რომ ობიექტი სწორად არის დაკავშირებული

ვნახოთ რა ხდება ელ.ფოსტის რიგში

და ბოლოს, ფაქტობრივი ელ.წერილი, რომელიც ეგზავნება საბოლოო მომხმარებელს

წარმატებები
ამ დრომდე, ჩვენ შევქმენით სამი (3) პარამეტრი, რომლებიც წარმატებით გამოიყენება შეტყობინებების ფანჯარაში და ელფოსტაში.

(მსახიობი) - აბრუნებს მომხმარებლის სახელს, რომელიც ახორციელებს მოქმედებას

(actor_url) - აძლევს ატრიბუტი (მსახიობი)

(url) - არ არის სავალდებულო, მაგრამ ყოველთვის უნდა გქონდეთ შეტყობინებაში. ეს არის მთავარი url, სადაც მოხდა ქმედება, რომლის შესახებაც გვაცნობეს.

ანალოგიურად, შეგიძლიათ განსაზღვროთ "

(სამიზნე) - თუ ეს გჭირდებათ
(target_url) თუ ეს გჭირდებათ თქვენს შეტყობინებაში.
(სათაური) - ჩვეულებრივ გამოიყენება ობიექტთან მიმართებაში, რომელმაც შექმნა შეტყობინება. მაგალითი: "მომხმარებელმა X-მა გამოაქვეყნა ახალი ფოტო ალბომში Y." ალბომის Y არის სათაური აქ
(title_url) - ისევე როგორც წინა, ობიექტის url, რომელმაც შექმნა შეტყობინება.
(შეტყობინება) - ეს პარამეტრი შეიძლება გამოყენებულ იქნას JomSocial ელ.ფოსტის ტექსტში შეტყობინების დასაყენებლად (და ექოზე).

3.3K

მომხმარებლისთვის შეტყობინებების ჩვენება საკმაოდ გავრცელებული მოქმედებაა, რომელიც ვებ აპლიკაციამ უნდა შეასრულოს. ეს შეიძლება მოხდეს ფორმების დამუშავებისას, ეს შეიძლება იყოს შეცდომის შეტყობინებები, შეტყობინებები, რომლებიც გეუბნებიან, რომ დარეგისტრირდეთ, როდესაც მომხმარებელი ცდილობს საიტის შეზღუდულ ნაწილზე წვდომას და ბევრ სხვა შემთხვევაში.

ძალიან ხშირად, შეტყობინებების შექმნა და გამომავალი იყოფა სხვადასხვა HTTP მოთხოვნად. როგორც წესი, მოსახერხებელია გადამისამართების გამოყენება ფორმების დამუშავების შემდეგ (უკან და განახლების ღილაკებთან პრობლემების თავიდან ასაცილებლად), მაგრამ ამავე დროს, შეტყობინების შექმნის ბუნებრივი მომენტი არის ზუსტად ფორმების დამუშავების მომენტი და თანმხლები მოქმედებების შესრულება. ის. რატომ? წარმოიდგინეთ, რომ შეტყობინების ტექსტი ასე უნდა გამოიყურებოდეს: „მაუსის პადისთვის შეკვეთილი ერთეულების რაოდენობა წარმატებით შეიცვალა 7-დან 12-მდე“. გადამისამართების შემდეგ, შესაძლოა, სრულიად განსხვავებულ გვერდზე ფუნქციონალური თვალსაზრისით, ზედმეტი თავის ტკივილი იქნება იმის დადგენა, თუ რა გაკეთდა ადრე.

ყველაზე ხშირად, შეტყობინებები ნაჩვენებია POST მოთხოვნაში, რომელიც ამუშავებს ფორმას - ეს არ არის კარგი, სიტყვები „ეს გვერდი მოძველებულია“ ანგრევს სიცოცხლეს (როდესაც მომხმარებელი გადაწყვეტს სცადო უკან დაბრუნება).

ვიღაც იყენებს გადამისამართებას, უარს ამბობს მეგობრულ შეტყობინებებზე.

ამავდროულად, არსებობს მარტივი და აშკარა გზა ცხოვრების გასაუმჯობესებლად. მიუხედავად აშკარაობისა, რატომღაც არასდროს მინახავს ვინმეს მისი გამოყენება – ყოველ შემთხვევაში, როცა სხვის წყაროებს ვუყურებდი.

ასე რომ, ჩვენ გვაქვს პრობლემა - შეტყობინება უნდა "იცხოვროს" სხვადასხვა მოთხოვნაში. ჩვენ გვჭირდება მექანიზმი, რომ გადავიტანოთ შეტყობინების ტექსტი იმ გვერდზე, რომელიც უნდა იყოს ნაჩვენები. ალბათ უკვე გახსოვთ სესიების შესახებ.

კი, ზოგადად მართალი ხარ. სხვა მეთოდები, მაგალითად, გლობალური ცვლადის საშუალებით, არ იძლევა მონაცემთა შენახვას იმ შემთხვევაში, როდესაც გამოიყენება გადამისამართება (შენიშვნა მაქსიმ ნაუმენკოს მიერ). გარდა ამისა, მე ჩვეულებრივ ვრწმუნდები, რომ აპლიკაციის თითოეულ ეკრანს აქვს შესაძლებლობა, სხვა ინფორმაციასთან ერთად, აჩვენოს შეტყობინებები, რომლებიც შეიქმნა წინა ეკრანებზე. ეს მოსახერხებელია, რადგან არ არის საჭირო ცალკეული ეკრანების მომზადება შეტყობინებების ჩვენებისთვის და მომხმარებელს არ მოუწევს მაუსის ხელახლა დაჭერა. მაგრამ, ნამდვილად, დიზაინერმა უნდა იფიქროს აქ - ხაზი გაუსვას სფეროს, რომელშიც გამოჩნდება შეტყობინებები.

იდეა ძალიან მარტივია და შეიძლება განხორციელდეს რამდენიმე გაკვეთილით.

პირველი, რაც მახსენდება არის Message კლასის შექმნა, რომელიც, ფაქტობრივად, წარმოადგენს შეტყობინებას ჩვენს მარტივ კლასის დიაგრამაში. შეტყობინებას უნდა შეეძლოს თავის შენახვა სესიაზე, ასევე ეკრანზე ჩვენება.

class Message ( /** * შეტყობინების შინაარსი. */ var $content; /** * კონსტრუქტორი შეტყობინების ტექსტის ინიციალიზაციისთვის. * * @param content შეტყობინების შინაარსი */ ფუნქცია Message($content) ($this->content = $ შინაარსი ;) /** * დაწერეთ შეტყობინება სესიაზე */ ფუნქცია send() ($_SESSION["session_messages"] = $this->content; ) /** * გაგზავნეთ შეტყობინება გვერდზე. */ ფუნქცია toPage() (echo " - " . $this->content . "
"; } }

$_SESSION ცვლადი გამოიყენება სესიაზე წვდომისთვის.

გაითვალისწინეთ, რომ $_SESSION არის მასივი, ჩვენ ვიყენებთ ამ მასივის მხოლოდ ერთ ელემენტს ინდექსით "session_message".

ამ შემთხვევაში საქმე გვაქვს „მასივების მასივთან“ - რასაც ვინახავთ „session_message“ ელემენტში არის მასივი, ეს არის გადაცემული შეტყობინებების სია (რა თქმა უნდა, შეიძლება იყოს რამდენიმე მათგანი).

თუ თემა ვერ იპოვეთ, დროა გადახედოთ სახელმძღვანელოს სექციებს და მასივებს.

შეიძლება გქონდეთ შეკითხვა. რატომ არის საჭირო გაკვეთილები აქ? შესაძლებელი იქნებოდა ორი ფუნქციით გატარება. მაგრამ მოდით უფრო შორს ვიყუროთ. შეიძლება დაგვჭირდეს სხვადასხვა ტიპის შეტყობინებების შექმნა (ინფორმაცია, შეცდომა, გაფრთხილება) და განვსაზღვროთ შეტყობინების მიმღებები.

გთხოვთ გაითვალისწინოთ, რომ ამ მომენტში სესიაში არ არის ჩადებული თავად ობიექტი, არამედ მხოლოდ შეტყობინების ტექსტი. OOP საშუალებას გვაძლევს მოგვიანებით შევცვალოთ send() მეთოდის ქცევა კლიენტის კოდის შეცვლის გარეშე, რომელიც წვდება ამ მეთოდს (მაგალითად, მომავალში ჩვენ შეგვიძლია დავწეროთ მთელი Message ობიექტი სესიაზე, თუ მას ბევრი ველი აქვს).

წარმოვიდგინოთ, რომ ამას გავაკეთებთ ფუნქციების გამოყენებით. ჩვენ ალბათ გვექნებოდა message_send($txt) ფუნქცია და ასევე message_to_page($txt) ფუნქცია. ახლა ჩვენ უნდა დავამატოთ განსხვავებული ქცევის უნარი სხვადასხვა ტიპის შეტყობინებებისთვის. ფუნქციის ზარები იცვლება: message_send ($txt, $kind), message_to_page ($txt, $kind). თქვენ მოგიწევთ აპლიკაციის მთელი კოდის გადალახვა ასეთი ფუნქციების მოსაძებნად, შესწორებების შეტანით.

ამის თავიდან აცილება შესაძლებელია სიტუაციის წინასწარ გათვალისწინებით, შეტყობინების ასოციაციური მასივის სახით წარდგენით: $msg['txt'], $msg['kind'], მაშინ ფუნქციის გამოძახებებში იქნება მხოლოდ ერთი პარამეტრი. გრძნობთ, როგორ ცდილობს ეს კლასი გახდეს?

ასე რომ, OOP გაძლევთ შესაძლებლობას გქონდეთ ფუფუნება, წინასწარ არ იფიქროთ ყველაფერი.

შემდეგი კლასი - Inbox - სწორედ ამისთვის არის შექმნილი.

class Inbox ( /** * მიღებული შეტყობინებების მასივი. */ var $messages = array(); /** * კონსტრუქტორში ვიღებთ ყველა მიღებულ შეტყობინებას * და ვშლით მათ სესიიდან. */ ფუნქცია Inbox() ( if (is_array($ _SESSION["session_messages"])) ($messages = $_SESSION["session_messages"]; $co = sizeof($messages); for ($i = 0; $i< $co; $i++) { $this->შეტყობინებები = ახალი შეტყობინება ($messages[$i]); ) ) /* შეტყობინებების მასივის გასუფთავება */ $_SESSION["session_messages"] = array(); ) /** * გვერდზე Inbox-ის შიგთავსის ჩვენება. */ ფუნქცია toPage() ( $co = sizeof($this->messages); if ($co > 0) (echo "შეტყობინება სისტემიდან:
";) ($i = 0; $i< $co; $i++) { $this->შეტყობინებები[$i]->ToPage(); ))))

მოდით ვცადოთ ჩვენი შეტყობინებების სისტემა.

მოდით შევქმნათ ძალიან მარტივი მაგალითი, რომელიც უპასუხებს ფორმის წარდგენას მიმდინარე წუთში წამების რაოდენობის მოხსენებით.

ჩვენ დავმალეთ მთელი სამუშაო მასივებითა და სესიებით კლასების შიგნით და საბოლოო კოდი გამოიყურება მარტივი და ლამაზი.

შექმენით დირექტორია თქვენს ვებ სერვერზე, შემდეგ შექმენით ეს სამი ფაილი მასში და სცადეთ სკრიპტი. გთხოვთ გაითვალისწინოთ, რომ უკან და განახლების ღილაკებთან არანაირი პრობლემა არ არის.

ახლა წარმოიდგინეთ, რომ თქვენ ქმნით რთულ პორტალს, სადაც, როგორც წესი, გვერდებზე რამდენიმე ბლოკია და თითოეული შეიძლება შეიცავდეს ცალკეულ აპლიკაციას.

აქ ჩვენ ვაწყდებით ორ სირთულეს:

* მე მინდა, რომ შეტყობინებების სია გამოჩნდეს გვერდის კონკრეტულ ნაწილში და თქვენ უკვე იპოვეთ ამისთვის კარგი ადგილი.
პრობლემა ის არის, რომ თქვენ უნდა გაუშვათ $inbox->toPage() ბრძანება ზუსტად იმ მომენტში, რომელიც შეესაბამებოდა შეტყობინებების სიის პოზიციას გვერდზე. თუ ჩვენ გვინდა ამ სიის პოზიციის შეცვლა, მოგვიწევს კოდში შესვლა, მაგრამ ამისთვის პორტალის ჩარჩოს მუდმივად შეცვლა არ არის კარგი. საუკეთესო გამოსავალი იქნება შეტყობინებების გამომავალი ცალკე მოდულის სახით, რომელიც მხოლოდ ის ვიცით, რომ ფრეიმიკზე უნდა იყოს დაკავშირებული.
ანუ გათავისუფლდით მოდულების გაშვების მკაცრი თანმიმდევრობისგან. მართლაც, ვინაიდან Inbox-ის გამომავალი შედეგი არ არის დამოკიდებული სისტემის მუშაობაზე (ამ ეტაპზე ჩვენ უკვე გვაქვს ყველა მონაცემი სესიაზე), მაშინ რატომ არის ზედმეტი სირთულე?
* შეტყობინებების სიის გარეგნობის (დიზაინის) შესანარჩუნებლად, თქვენ უნდა იზრუნოთ HTML კოდზე, რომელიც მყარი კოდირებულია Message და Inbox კლასების toPage() მეთოდებში. როგორც წესი, თქვენ უნდა შეცვალოთ PHP კოდი დიზაინის შესაცვლელად.

პირველი პრობლემის გადასაჭრელად, შეგიძლიათ შექმნათ ბუფერი, რომელიც ინახავს Inbox-ის გამომავალი შედეგს.

შესაძლოა, ჩვენ კვლავ გვექნება რამდენიმე მსგავსი (Inbox-ის) რამ და ჩვენ უნდა შევქმნათ ბუფერული სისტემა. იმისათვის, რომ არ აგვერიოს ვისი გამომავალი არის, ჩვენ ალბათ მივალთ ბუფერების დასახელებაზე. ჩვენ სადმე შევინახავთ თანმიმდევრობას, რომლის მიხედვითაც ბუფერები უნდა გამოვიდეს - სასურველია გარე ფაილში ცვლილებების გასაადვილებლად.

გადაწყვეტის ეს მცდელობა უკვე გვაძლევს იდეას გამოვიყენოთ XML, როგორც შუალედური მონაცემების შესანახი საშუალება. და XSLT სტილის გამოყენება დაგეხმარებათ მეორე პრობლემის გადაჭრაში.

მე არ ვისაუბრებ იმაზე, თუ რა არის XML და რა არის XSLT. თუ არ იცნობთ ამ საკითხებს, zvon.org კარგი ადგილია ძიების დასაწყებად.

იდეა არის არა HTML კოდის, არამედ XML სტრუქტურის გენერირება toPage() მეთოდებში. გვერდის დოკუმენტი შეიქმნება სტრიქონის სახით XML კოდით (ის იქნება „ბუფერი“), ხოლო სკრიპტის ბოლო ეტაპზე გამოვიყენებთ XSL ტრანსფორმაციას.

ჯერ წარმოვიდგინოთ, რა შედეგი უნდა მოჰყვეს კოდის ძირითად ნაწილს.

წუთი 57 წამი: 45

რა არის ეს საკმაოდ ადვილი გამოსაცნობია - ორი შეტყობინება და ფორმა. გთხოვთ გაითვალისწინოთ, რომ PHP სკრიპტს მხოლოდ ასეთი სტრიქონის მომზადება სჭირდება - ეს ძალიან მარტივია. უფრო მეტიც, მთავარი ტეგების თანმიმდევრობა არ არის მნიშვნელოვანი - თქვენ შეგიძლიათ განათავსოთ ისინი პირველ რიგში, მაგალითად, როგორც მოსახერხებელი იქნება პროგრამისტისთვის. როგორ განხორციელდეს იგი. თქვენ შეგიძლიათ, არაფრის შეცვლის გარეშე, გამოიყენოთ გამომავალი ბუფერირება, გამოიყვანოთ XML HTML კოდის ნაცვლად და ბოლოს უბრალოდ გადაიღოთ გამომავალი სტრიქონში. მაგრამ შემდეგ ჩვენ დავკარგავთ მოქნილობას - მაგალითად, ზოგჯერ გსურთ გამართვის ინფორმაციის გამოტანა პირდაპირ გვერდზე (ექოს გამოყენებით). ამავდროულად, PHP დეველოპერები მუშაობენ DOM მოდულზე, რომელიც გვთავაზობს ხის დოკუმენტების შექმნისა და გადაცემის უფრო მოწინავე გზას. თუ გვსურს DOM-ის დანერგვა, მოგვიწევს მთლიანი აპლიკაციის ხელახალი დიზაინი, სტრიქონების გამომავალი შევცვალოთ DOM ელემენტების შესაქმნელად. ამიტომ, მირჩევნია ობიექტების XML წარმოდგენა შევინახო თავად ობიექტებში, თანმიმდევრულად შევკრიბო საერთო XML დოკუმენტი. ეს არც ისე რთულია, უბრალოდ ცოტა მოდიფიკაცია სჭირდება. თქვენ ნახავთ, რომ ეს ტექნიკა მკაცრად არ არის დაკავშირებული XML მონაცემების შენახვის კონკრეტულ გზასთან და ეს საშუალებას მოგცემთ მცირე ძალისხმევით გადახვიდეთ DOM-ის გამოყენებაზე. უპირველეს ყოვლისა, გაითვალისწინეთ, რომ ჩვენს თითოეულ ობიექტს აქვს toPage() მეთოდი. ამ მსგავსებამ უნდა გვაფიქრებინოს ახალი საერთო მშობლის კლასის შემოღებაზე. ნება მიეცით თითოეულ კლასს, რომელსაც შეუძლია შექმნას XML დოკუმენტის ნაწილები გვერდისთვის, მემკვიდრეობით მიიღებს კლასისგან, რომელიც იზრუნებს ობიექტის XML წარმოდგენაზე. მოდით ვუწოდოთ მას Outputable.

class Outputable ( /** * XML კონტეინერი (სტრიქონი). */ var $output = ""; /** * მიეცით კონტეინერის შიგთავსი და გაასუფთავეთ კონტეინერი. * * @დააბრუნეთ სტრიქონი XML მონაცემებით */ ფუნქცია getOutput () ( $ out = $this->output; $this->output = ""; დაბრუნება $out; ) /** * დაამატეთ ნაწილი კონტეინერის შიგთავსში. * * @param სტრიქონი დასამატებლად * / ფუნქცია appendOutput($string) ( $this ->output .= $string . "n"; ) /** * "აბსტრაქტული" მეთოდი. */ ფუნქცია toPage() ( ) )

toPage() მეთოდი ცარიელია - ამ შემთხვევაში ის საჭიროა, როგორც ინდიკატორი იმისა, თუ როგორ უნდა დაუკავშირდეს გარე მატრიოშკას კლასები შიდა კლასს. თუმცა, ჩვენ შეგვიძლია შემოგთავაზოთ ნაგულისხმევი იმპლემენტაცია, თუ შევამჩნევთ, რომ ბევრი ობიექტია, რომლებიც ერთნაირად აჩვენებენ თავს გვერდზე.

Message და Inbox კლასები ოდნავ შეიცვლება - მათ ახლა ორივე უნდა მემკვიდრეობით მიიღონ Outputable-დან, ასევე შეიცვლება toPage() მეთოდებიც.
Message.php

class Message extends Outputable ( /** * შეტყობინების შინაარსი. */ var $content; /** * კონსტრუქტორი შეტყობინების ტექსტის ინიციალიზაციისთვის. * * @param content შეტყობინების შინაარსი */ ფუნქცია Message($content) ( $this->content = $content; ) /** * დაწერეთ შეტყობინება სესიაზე */ ფუნქცია send() ( $_SESSION["session_messages"] = $this->content; ) /** * გაგზავნეთ შეტყობინება გვერდზე. * / ფუნქცია toPage() ( $this->appendOutput("".$this->content.""); ) )

class Inbox აფართოებს Outputable ( /** * მიღებული შეტყობინებების მასივი. */ var $messages = array(); /** * კონსტრუქტორში ვიღებთ ყველა მიღებულ შეტყობინებას * და ვხსნით მათ სესიიდან. */ ფუნქცია Inbox( ) ( if (is_array ($_SESSION["session_messages"])) ($messages = $_SESSION["session_messages"]; $co = sizeof($messages); for ($i = 0; $i< $co; $i++) { $this->შეტყობინებები = ახალი შეტყობინება ($messages[$i]); ) ) /* შეტყობინებების მასივის გასუფთავება */ $_SESSION["session_messages"] = array(); ) /** * გვერდზე Inbox-ის შიგთავსის ჩვენება. */ ფუნქცია toPage() ($co = sizeof($this->messages); $this->appendOutput(""); for ($i = 0; $i< $co; $i++) { $this->შეტყობინებები[$i]->toPage(); $this->appendOutput($this->შეტყობინებები[$i]->getOutput()); ) $this->appendOutput(""); ))

გამომავალი მეთოდი შეიცვალა - ახლა, გვერდზე პირდაპირ გამოტანის ნაცვლად, გარე წარმოდგენა ამ დროისთვის ინახება Outputable-ში, რომელიც „ზის“ თითოეულ ობიექტში. appendOutput() მეთოდი ემსახურება echo() კონსტრუქციის ჩანაცვლებას. ობიექტის გამოსავლის მისაღებად გამოიყენება getOutput() მეთოდი.

ახლა ვნახოთ რა არის კოდის კლიენტის ნაწილი, რომელიც გადაჭრის იგივე პრობლემას, როგორც ადრე.
index.php

მთავარი ინოვაცია არის $global_content ობიექტში, რომლის სახელიც თავისთავად მეტყველებს. ამ შემთხვევაში, ის მიეკუთვნება Outputable კლასს; რეალურ ცხოვრებაში, თქვენ ალბათ შექმნით ცალკე კლასს გვერდის შინაარსისთვის.

თუ კარგად დააკვირდებით, სკრიპტის შინაარსი პრაქტიკულად არ შეცვლილა - იგივე inbox, იგივე toPage(). დამატებულია ინსტრუქცია, რომელიც აჩვენებს შეტყობინებების სიის შინაარსს გვერდის შინაარსში. მრავალფეროვნებისთვის, ახლა იქმნება ორი შეტყობინება.

შედეგის დასათვალიერებლად, რჩება მხოლოდ XSL შაბლონის მომზადება.
სტილი.xsl

XSLT მაგალითი

შეტყობინება

რას მივაღწიეთ?

უპირველეს ყოვლისა, შეგიძლიათ უფრო თავდაჯერებულად აიღოთ რთული პროექტები - უზრუნველყოფილია მოდულების რეალური დამოუკიდებლობა. შედეგების გვერდზე განთავსებული თანმიმდევრობა ახლა კონტროლდება გარე XSL შაბლონის გამოყენებით და არ არის დამოკიდებული მოდულების გაშვების თანმიმდევრობაზე.

ნებისმიერი მოდული, რომელიც თავისი მუშაობის შედეგად წარმოქმნის XML მონაცემებს, შეიძლება გამოყენებულ იქნას პროექტში. სხვათა შორის, ეს არის ერთ-ერთი უპირატესობა შაბლონურ ძრავებთან შედარებით, რომლებშიც მონაცემთა შექმნა შედგება კონკრეტული ძრავის გამოძახების მეთოდების თანმიმდევრობით (მინიშნება და ა.შ.), რომლისთვისაც არ არსებობს საერთო სტანდარტი.

კიდევ ერთი უპირატესობა არის გამართვის სიმარტივე. თუ სკრიპტს გაუშვით, შეამჩნევთ, რომ თითოეული გვერდი შეიცავს გამართვის გამომავალს - XML პროტოტიპს, რომელიც მნიშვნელოვნად ამარტივებს აპლიკაციების გამართვას.

კიდევ რაღაც, რაზეც უნდა იფიქროთ, არის თუ როგორ უნდა შექმნათ შეტყობინების ობიექტები. ყოველთვის არ არის მოსახერხებელი ახლის პირდაპირ კლიენტის კოდში გამოყენება. მაგრამ შესაძლოა ეს ცალკე სტატიის თემაა.

და ბოლოს, გალოპი პერსპექტივების შესახებ:

* ამომხტარი ფანჯრები მნიშვნელოვანი შეტყობინებების სიისთვის
* "გამგზავნი გვერდები" და "დანიშნულების გვერდები" შეტყობინებებში
* შეტყობინებების ჩაწერა მონაცემთა ბაზაში
* ღილაკი "ჩემი მოქმედებების ისტორიის ჩვენება"
* მომხმარებლის ქმედებების სტატისტიკური ანალიზი სესიების ფარგლებში
* "ინტელექტუალური ასისტენტები" ვებ აპლიკაციებში

KP-სა და BUS-ში, 11.5 ვერსიიდან დაწყებული, გამოცემებში, რომლებიც მოიცავს სოციალურ ქსელს, გამოჩნდა ახალი მოდული "ვებ მესინჯერი".
სანამ ყველასთვის გავრცელდებოდა, მოდულმა გაიარა ცეცხლოვანი ნათლობა ჩვენს "სოციალურ ინტრანეტზე" და შეაგროვა 8 განახლება.

განვითარების ექვს თვეში ჩვენ ბევრი რამ გავაკეთეთ

ჩვენ მთლიანად მივატოვეთ წინა ინტერფეისი და შევქმენით ახალი, პოპულარული მყისიერი მესინჯერების გამოცდილების საფუძველზე.
გვერდის შიგნით დაიწყო დიალოგური ფანჯრის გახსნა, მასში გამოჩნდა სახეები, შეტყობინებები იყო ფერადი კოდირებული და შესაძლებელი გახდა ერთდროულად რამდენიმე ადამიანთან საუბრის მარტივად გაგრძელება.

ისტორიის ფანჯარა ცალკე თემაა, ყველას დიდი ხანია სურდა ისტორიის ძებნა, ახლა საბოლოოდ გვაქვს, ვგეგმავთ იქ კალენდრის დამატებას სწრაფი ნავიგაციისთვის.

ჩვენ შევქმენით შეტყობინებების ცენტრი სხვადასხვა ტიპის შეტყობინებებით, ვუზრუნველყავით მათი მიღების ისტორიის ნახვის შესაძლებლობა და დეველოპერებისთვის მარტივი API შეტყობინებების დასამატებლად და გასახსენებლად.

და ეს ყველაფერი ხელმისაწვდომია თქვენი საიტის ყველა გვერდზე!

სამწუხაროდ, ყველაფერი, რაც დაგეგმილი იყო, არ განხორციელდა

Პირველირაც დრო არ გვქონდა, იყო შეტყობინებების თარგმნა ჩვენს ცხრილებში.
ასეთი გადასვლა შესაძლებელს გახდის „სოციალური ქსელის“ მოდულის მიტოვებას, რაც მეტ თავისუფლებას მისცემს რედაქტორების არჩევანს, ასევე შესაძლებელი იქნება ჯგუფური ჩატების დანერგვა.

მეორე, ეს არის ნამდვილი "მყისიერი" კომუნიკაციის განხორციელება. ახლა მოდული იყენებს რეგულარულ გაერთიანებას, სერვერის გამოკითხვას ყოველ n-წამში ერთხელ, გამოკითხვის პერიოდი იცვლება კომუნიკაციის აქტივობიდან გამომდინარე.
ჩვენ ვგეგმავთ ცალკე სერვისის დაწერას, რომელიც შეინარჩუნებს მუდმივ კავშირებს და საჭიროებისამებრ გამოაგზავნის მონაცემთა განახლებებს (მესენჯერისთვის, ცოცხალი არხისთვის და ა.შ.).

მესამე, ჩვენ ვგეგმავთ ინტერფეისის ოდნავ შეცვლას, ცალკეული კონტაქტების სიისა და დიალოგური ფანჯრის მიტოვებას და მათ ერთ მთლიანობაში გაერთიანებას, რაც მომავალში საშუალებას მოგვცემს გადავიტანოთ მესინჯერი მობილურ აპლიკაციაში.

ჯერ დოკუმენტაცია არ არის და არც შემოდგომამდე გამოჩნდება, რადგან... მოდული აქტიურად მუშავდება და გვინდა დავტოვოთ API-ის შეცვლის შესაძლებლობა.
თუმცა, შევეცდები გამოვაქვეყნო API-ის იმ ნაწილთან მუშაობის მაგალითები, რომლებზეც მუშაობა უკვე დასრულებულია და შეგიძლიათ უსაფრთხოდ გამოიყენოთ ისინი თქვენს მოდულებში.

შეტყობინებებთან მუშაობა (რელევანტურია IM-ისთვის 11.5.2 ვერსიიდან დაწყებული)

ჩვენ განვახორციელეთ სამი სახის შეტყობინებები:
- პერსონალიზებული შეტყობინება;
- შეტყობინება სისტემიდან;
- შეტყობინება, რომელიც მოითხოვს დადასტურებას;

API-ს გამოყენებამდე უნდა შეამოწმოთ არის თუ არა მოდული სისტემაში დაინსტალირებული:

if (IsModuleInstalled("im") && CModule::IncludeModule("im")) () ?>

პერსონალიზებული შეტყობინება

თუ შეტყობინებები დაყენებულია NOTIFY_TAG-ზე, მაშინ მომხმარებელი დააჯგუფებს მათ.

შეტყობინება სისტემიდან

$arMessageFields = მასივი(// მიმღები "TO_USER_ID" => $USER->GetId(), // გამგზავნი (შეიძლება იყოს >0) "FROM_USER_ID" => 0, // შეტყობინების ტიპი "NOTIFY_TYPE" => IM_NOTIFY_SYSTEM, // მოდული, რომელმაც მოითხოვა შეტყობინების გაგზავნა "NOTIFY_MODULE" => "im", // სიმბოლური ტეგი დაჯგუფებისთვის (გამოჩნდება მხოლოდ ერთი შეტყობინება), თუ ეს არ არის საჭირო, არ დააყენოთ პარამეტრი "NOTIFY_TAG" => "IM_CONFIG_NOTICE", // შეტყობინებების ტექსტი საიტზე (ხელმისაწვდომია html და BB კოდები) "NOTIFY_MESSAGE" => "[b]ყურადღება: თქვენ უნდა შეამოწმოთ და მიუთითოთ სოციალური ქსელის სწორი გზა "მყისიერი შეტყობინებების და შეტყობინებების" მოდულის პარამეტრებში" , // შეტყობინების ტექსტი უნდა გაიგზავნოს ელექტრონული ფოსტით (ან XMPP ), თუ განსხვავებები არ არის, არ დააყენოთ პარამეტრი //"NOTIFY_MESSAGE_OUT" => ""); CIMNotify::Add($arMessageFields); ?>

შეტყობინება, რომელიც მოითხოვს დადასტურებას (დადასტურება)

ამ ტიპის შეტყობინებებთან მუშაობისთვის საკმარისი არ არის უბრალოდ შეტყობინების გაგზავნა; თქვენ ასევე გჭირდებათ მისი სერვისი.

სერვისი
არსებობს ორი ვარიანტი, უმარტივესი არის ბმულის მიყოლა (თუ დააყენეთ მე-4 პარამეტრი NOTIFY_BUTTONS-ში).
ბმულის შემდეგ, თქვენ უნდა გამოძახოთ შემდეგი კოდი თქვენს კოდში:
ყურადღება: ყურადღება მიაქციეთ ტეგების სახელს; წაშლის გამოძახებისას, ამ ტეგის მქონე ყველა შეტყობინება წაიშლება.
მრავალი შეტყობინების გაგზავნისას, ეს გასათვალისწინებელია, რათა ერთი მომხმარებლის მიერ მოქმედების შესრულებამ შემთხვევით არ წაშალოს შეტყობინება ყველასთვის (გარდა ადგილებისა, სადაც ასეთი ლოგიკაა საჭირო).

მეორე ვარიანტი არის ღონისძიებებზე.
1. თქვენ უნდა დაარეგისტრიროთ დამოკიდებულება

ნუ დაივიწყებთ თქვენს ფუნქციებს დაადასტურეთ მოთხოვნადა მოთხოვნის უარყოფაგამოიწვიოს შეტყობინების წაშლა CIMNotify::DeleteByTag()

ჯერ სულ ესაა, ველოდები თქვენს წინადადებებს კომენტარებში, წარმატებულ განხორციელებას!
თუ გსურთ სცადოთ API 11.5.2-ის გამოშვებამდე პარამეტრებთან მასივში, დამატებით უნდა მიუთითოთ "MESSAGE_TYPE" => IM_MESSAGE_SYSTEM, ასევე ღილაკებში ბმული ვარიანტი არ იმუშავებს შეტყობინებების დასადასტურებლად. მაგრამ უმჯობესია დაველოდოთ; 11.5.2 განახლება გამოვა 23 მაისს.

სჯობს ცუდი სერია, ვიდრე დელირიუმის ტრემენსი...

PHP AJAX CRUD: ჩანაწერების შექმნა, წაშლა, რედაქტირება MySQL მონაცემთა ბაზაში

ამ სტატიაში ჩვენ გავიგებთ, თუ როგორ დავამატოთ, დაარედაქტიროთ და წაშალოთ ჩანაწერები MySQL მონაცემთა ბაზაში PHP-ის გამოყენებით. ჩვენ გამოვიყენეთ JQuery დამმუშავებელი, რომელიც აგზავნის AJAX მოთხოვნას სერვერის მხარეს სკრიპტზე. დამმუშავებელი ანახლებს ჩანაწერების სიას.

AJAX ფორმა შექმნის, წაშლის, რედაქტირების მოთხოვნის გაგზავნისთვის

ჩანაწერის დამატებისას, ფორმა აგზავნის მონაცემებს PHP სკრიპტზე AJAX მოთხოვნის საშუალებით. თუ დამატება წარმატებულია, ჩანაწერების სია ხელახლა იტვირთება.

JQuery AJAX ფუნქციები CRUD მონაცემთა ბაზის შეკითხვისთვის

JQuery AJAX ფუნქციაში გვაქვს გადართვის შემთხვევები, დაამატეთ რედაქტირება და წაშლა. ეს შემთხვევები წარმოქმნის სხვადასხვა მოთხოვნისა და პასუხების მონაცემთა სტრიქონებს, რაც დამოკიდებულია მონაცემთა ბაზის მოქმედებებზე.

ფუნქცია showEditBox(id) ($("#frmAdd"). დამალვა(); var currentMessage = $("#message_" + id + ".message-content").html(); var editMarkUp = ""+currentMessage+" SaveCancel"; $("#message_" + id + ".message-content").html(editMarkUp); ) ფუნქცია cancelEdit(წერილი,id) ($("#message_" + id + " .message-content") .html(მესიჯი); $("#frmAdd").show(); ) ფუნქცია callCrudAction(action,id) ($("#loaderIcon").show(); var queryString; switch(action) ( case "add ": queryString = "action="+action+"&txtmessage="+ $("#txtmessage").val(); break; case "edit": queryString = "action="+action+"&message_id="+ id + " &txtmessage="+ $("#txtmessage_"+id).val(); break; case "delete": queryString = "action="+action+"&message_id="+ id; break; ) jQuery.ajax(( url: "crud_action.php", data:queryString, ტიპი: "POST", success:function(data)( switch(action) ( case "add": $("#comment-list-box").append(data); შესვენება; case "რედაქტირება": $("#message_" + id + ".message-content").html(data); $("#frmAdd").show(); შესვენება; case "delete": $("#message_"+id).fadeOut(); შესვენება; ) $("#txtmessage").val(""); $("#loaderIcon").დამალე(); ), შეცდომა:ფუნქცია ()() )); )

PHP სკრიპტი CRUD ოპერაციებისთვის

შემდეგი კოდი ასრულებს შეკითხვებს მონაცემთა ბაზის წინააღმდეგ. ეს PHP სკრიპტი, CRUD მოქმედების შესრულების შემდეგ, აახლებს ჩანაწერებს AJAX პასუხის შედეგად.

require_once ("dbcontroller.php"); $db_handle = ახალი DBController(); $action = $_POST["მოქმედება"]; if(!empty($action)) ( switch($action) ( case "add": $result = mysql_query("INSERT INTO comment(message) VALUES("".$_POST["txtmessage"].")" ) ; if($result)($insert_id = mysql_insert_id(); echo " წაშლის რედაქტირება " . $_POST["txtmessage"] . " "; ) შესვენება; შემთხვევა "რედაქტირება": $result = mysql_query("განახლება კომენტარის ნაკრების შეტყობინება = "".$_POST["txtmessage"]."" WHERE id=".$_POST["message_id"]); if($result) echo $_POST["txtmessage"]; შესვენება; შემთხვევა "წაშლა": თუ ( !empty($_POST["message_id"])) ( mysql_query("DELETE FROM comment WHERE id=".$_POST["message_id"]); ) break; ) )

ამ კურსის ამ ეტაპზე, ჩვენი მოდულის საფუძველი ჩაეყარა, განისაზღვრა მორგებული კაუჭი და მიმაგრებულია მუდმივი შეტყობინება, რათა აჩვენოს როგორ მუშაობს კაკალი.

რომ ჩვენ არაგააკეთეს, მათ არ განახორციელეს შეტყობინებების ტიპები და მათი ჩვენება მომხმარებლის მიერ შეყვანილი მონაცემების მიხედვით.

მაგრამ სანამ დავიწყებთ, ჩვენ უნდა დავამატოთ მხარდაჭერა სხვადასხვა ტიპის შეტყობინებებისთვის, კლასის ინტერფეისი, რომელიც მხარს დაუჭერს შეტყობინების თითოეულ ტიპს და მონაცემთა სტრუქტურას, რომელიც საჭიროა ასეთი შეტყობინებების შესანახად.

მზად ხართ დასაწყებად?

მოუთმენლად ველოდები გაკვეთილის გაგრძელებას, მაგრამ არის რამდენიმე რამ, რაც უნდა გავითვალისწინოთ, სანამ პირველ კოდს ჩავუღრმავდებით. დარწმუნდით, რომ თქვენს სისტემაზე დაინსტალირებული გაქვთ შემდეგი პროგრამული უზრუნველყოფა:

PHP 5.6.25 და MySQL 5.6.28
Apache ან Nginx
WordPress 4.6.1
თქვენი სასურველი IDE ან რედაქტორი

და თუ თქვენ ეძებთ ერთ-ერთ გადაწყვეტას, არ დაგავიწყდეთ MAMP სცადოთ.

ჩვენ წინ წავედით

როგორც უკვე აღვნიშნეთ, ჩვენ ზუსტად ამ კურსის შუაში ვართ. თუ რომელიმე პირველი გაკვეთილი გამოტოვეთ, აი, რა განვიხილეთ აქამდე:

პირველ გაკვეთილზე ჩვენ ყურადღება გავამახვილეთ მინიმალურ საფუძვლებზე ჩვენი მოდულის შესაქმნელად და იმაზე, რაც გჭირდებათ დასაწყებად.

მეორე ნაწილში ჩვენ უფრო შორს გადავედით დანამატით, ცოტათი დავამატეთ WordPress-ის ძირითადი ადმინისტრაციის გვერდი. ჩვენ ასევე მივანიჭეთ მორგებული ჰუკი, რომელსაც ვიყენებთ და გავუშვით სერვერის მხარეს. ჩვენ ასევე დავაყენეთ ძირითადი პარამეტრები ჩვენი Settings Messenger-ისთვის.

და ეს არის ის, რასაც განვიხილავთ ტრენინგის დასკვნით ეტაპზე:

ჩვენ ყველაფერს გავაერთიანებთ, ვნახავთ მოქმედებაში და გახდის დანამატს საჯაროდ ხელმისაწვდომი ჩამოსატვირთად.

ამჟამად სხვა ამოცანები გვაქვს და მათზე გავამახვილებთ ყურადღებას.

დავუბრუნდეთ საქმეს

მას შემდეგ, რაც ჩვენ გადავედით სამუშაოზე (და როგორც წინა გაკვეთილებში აღინიშნა), ჩვენ მზად ვართ ამ ნაწილის ამოცანების შემდგომი განხორციელება:

ამ სახელმძღვანელოში ჩვენ გავაგრძელებთ ჩვენი Settings Messenger-ის განვითარებას წარმატებისა და წარუმატებლობის შეტყობინებების მხარდაჭერის დამატებით, ასევე უსაფრთხოების საკითხებზე შეხებით.

წინა სტატიაში დავიწყეთ Settings Messenger-ში, მაგრამ მხოლოდ იმ ფუნქციის დაყენებამდე, რომელიც გამუდმებით აჩვენებს წარმატების შეტყობინებას მომხმარებლის გვერდის ჩატვირთვისას.

ამ სახელმძღვანელოში ჩვენ დავამატებთ შეცდომის, გაფრთხილებისა და წარმატების შეტყობინებების მხარდაჭერას. შემდეგ ჩვენ გამოვაჩენთ მათ ეკრანზე, რათა გავიგოთ, თუ როგორ იმუშავებს მესინჯერი.

გარდა ამისა, ჩვენ ვაპირებთ კიდევ ერთი ცვლილების შეტანას, რომელიც დაამატებს მხარდაჭერას მომხმარებლის შეხედულებისამებრ შეტყობინებების გაუქმებისთვის.

ეს არის ამ გაკვეთილისთვის საჭირო სამუშაოს მთელი გეგმა. Დავიწყოთ.

პარამეტრები მესენჯერის გაფართოება

დაიმახსოვრეთ, Settings Messenger-ის მთელი მიზანი არის განსაზღვროს ჩვენი მუშაობის გზა მორგებული შეტყობინებებით, მორგებული კაკვებით და მშობლიური WordPress API-ით, რათა აჩვენოს შეტყობინებები WordPress-ის ადმინისტრაციული პანელის კონტექსტში.

ამისათვის ჩვენ ვაპირებთ გავაფართოვოთ ბოლო გაკვეთილზე შესრულებული სამუშაო და დავიწყოთ აქედან.

წარმატებული შეტყობინებები

ვინაიდან წინა გაკვეთილზე წარმატებული შეტყობინებებით დავიწყეთ, განვაგრძოთ ისინი. ახლა ჩვენ გვაქვს მყარი კოდირებული მეთოდი, რომელიც აჩვენებს ერთ ტექნიკას: