Noggrann lägga till meddelande php. PHP-Swagger Request Parametrar

På samma sätt kan du definiera "

• (mål) - om du behöver det
• (target_url) om du behöver det i din avisering.
• (titel) - Används vanligtvis för att referera till ett objekt som genererade meddelande. Exempel: "Användare X har lagt upp ett nytt foto i Album Y ." Album Y är titeln här
• (title_url) - Som med tidigare, webbadressen till ett objekt som genererade avisering.
• (meddelande) - Denna param kan användas för att ställa in (och eko) meddelandet i kroppen av JomSocial e-post.

Till slut insåg jag: det finns ingen bättre än en fru. Det återstår bara att hitta en fru

I den här artikeln kommer vi att lära oss hur man lägger till, redigerar och tar bort poster i en MySQL-databas med PHP. Vi har använt en jQuery-hanterare som skickar en AJAX-förfrågan till ett serverskript. Hanteraren uppdaterar listan med poster.

När en post läggs till skickar formuläret data till PHP-skriptet via en AJAX-förfrågan. Om tillägget lyckas laddas listan över poster om.

I jQuery AJAX-funktionen har vi en växel för att lägga till redigera och ta bort fall. Dessa fall genererar olika frågesträngar och svarsdata beroende på databasens åtgärder.

function showEditBox(id) ( $("#frmAdd").hide(); var currentMessage = $("#message_" + id + " .message-content").html(); var editMarkUp = ""+currentMessage+" SaveCancel"; $("#message_" + id + " .message-content").html(editMarkUp); ) funktion cancelEdit(meddelande,id) ( $("#meddelande_" + id + ".meddelande-innehåll") .html(meddelande); $("#frmAdd").show(); ) funktion 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, typ: "POST", success:function(data)( switch(action) (case "add": $("#comment-list-box").append(data); break; case "edit": $("#message_" + id + ".message-content").html(data); $("#frmAdd").show(); ha sönder; case "delete": $("#meddelande_"+id).fadeOut(); ha sönder; ) $("#txtmessage").val(""); $("#loaderIcon").hide(); ), error:function ()() )); )

Följande kod kör databasfrågor. Detta PHP-skript, efter att ha utfört en CRUD-åtgärd, uppdaterar posterna som ett resultat av AJAX-svaret.

require_once("dbcontroller.php"); $db_handle = ny DBController(); $action = $_POST["action"]; 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 " Edit Delete " . $_POST["txtmessage"] . " "; ) break; case "edit": $result = mysql_query("UPPDATERA kommentarset meddelande = "".$_POST["txtmessage"]."" WHERE id=".$_POST["message_id"]); if($result) echo $_POST["txtmessage"]; break; case "delete": if (!empty($_POST["meddelande_id"])) ( mysql_query("DELETE FROM comment WHERE id=".$_POST["meddelande_id"]); ) break; ) )

Att visa meddelanden för användaren är en ganska vanlig åtgärd som en webbapplikation bör utföra. Det kan hända under behandling av formulär, det kan vara felmeddelanden, meddelanden som säger att du måste registrera dig när en användare försöker komma åt en begränsad del av webbplatsen och i många andra fall.

Mycket ofta separeras skapandet och utmatningen av meddelanden av olika HTTP-förfrågningar. Som regel är det bekvämt att använda en omdirigering efter att formulär har bearbetats (för att undvika problem med knapparna Tillbaka och Uppdatera), men samtidigt är det naturliga ögonblicket för att skapa ett meddelande just det ögonblick då formulären bearbetas och utföra de åtgärder som åtföljer det. Varför? Föreställ dig att texten i meddelandet ska se ut ungefär så här: "Antalet beställda enheter för objektet 'Musmatta' har framgångsrikt ändrats från 7 till 12." Efter en omdirigering, kanske till en sida som är helt annorlunda vad gäller funktionalitet, blir det ett extra huvud – att avgöra vad som gjordes tidigare.

Oftast visas meddelanden i POST-begäran som behandlar formuläret - det här är inte bra, inskriptionerna "den här sidan är inaktuell" förstör livet (när användaren vill prova tillbaka-knappen).

Någon använder en omdirigering och ger upp vänliga meddelanden.

Samtidigt finns det ett enkelt och självklart sätt att göra livet bättre. Trots det självklara såg jag av någon anledning aldrig någon använda det – åtminstone när jag tittade på andras källor.

Så vi har ett problem - budskapet ska "leva" i olika förfrågningar. Vi behöver en mekanism för att skicka texten i meddelandet till sidan som ska visa den. Du kom säkert redan ihåg sessionerna.

Ja, generellt sett har du rätt. Andra metoder, till exempel genom en global variabel, tillåter inte att data sparas om en omdirigering används (anmärkning av Maxim Naumenko). Dessutom ser jag vanligtvis till att varje skärm i applikationen har möjligheten, tillsammans med annan information, att visa meddelanden som genererades på tidigare skärmar. Detta är praktiskt eftersom det inte finns något behov av att förbereda separata skärmar för att visa meddelanden, och användaren behöver inte klicka med musen igen. Men, egentligen, här måste designern tänka - för att markera det område där meddelandena skulle dyka upp.

Idén är väldigt enkel och kan implementeras med ett par klasser.

Det första som kommer att tänka på är att skapa en meddelandeklass, som i själva verket skulle representera ett meddelande på vårt enkla klassdiagram. Meddelandet måste kunna spara sig själv i sessionen, samt visa sig på skärmen.

klass Meddelande ( /** * Meddelandeinnehåll. */ var $content; /** * Konstruktör för att initiera meddelandetext. * * @param innehåll meddelandeinnehåll */ funktion Meddelande($content) ( $this->content = $content ; ) /** * Skriv meddelandet till sessionen */ function send() ( $_SESSION["session_messages"] = $this->content; ) /** * Skicka meddelandet till sidan */ function toPage() ( echo "-" . $this->content . "
"; } }

Variabeln $_SESSION används för att komma åt sessionen.

Observera att $_SESSION är en array, vi använder bara ett element i denna array med index 'session_message'.

I det här fallet har vi att göra med en "array av arrayer" - det vi lagrar i elementet 'session_message' är en array, det här är listan över överförda meddelanden (det kan finnas flera av dem, naturligtvis).

Om du inte kunde hitta tråden är det dags att fräscha upp avsnitten i manualen om sessioner och arrayer.

Du kanske har en fråga. Varför behövs lektioner här? Det skulle gå att klara sig med två funktioner. Men låt oss titta vidare. Vi kan behöva skapa meddelanden med olika typer (info, fel, varning), definiera meddelandemottagare.

Observera att för tillfället läggs inte själva objektet in i sessionen, utan bara texten i meddelandet. OOP tillåter oss att ändra beteendet för metoden send() i framtiden utan att ändra klientkoden som anropar denna metod (till exempel i framtiden kan hela Message-objektet skrivas till sessionen om det har många fält).

Låt oss föreställa oss att vi skulle göra det med hjälp av funktioner. Förmodligen skulle vi ha en message_send($txt) funktion, vi skulle också ha en message_to_page($txt) funktion. Nu behöver vi lägga till möjligheten till olika beteende för olika typer av meddelanden. Funktionsanrop ändras: message_send($txt, $kind), message_to_page($txt, $kind). Du måste kamma igenom hela applikationskoden för att leta efter sådana funktioner och göra korrigeringar.

Detta kan undvikas genom att förutse situationen i förväg genom att presentera meddelandet som en associativ array: $msg['txt'], $msg['kind'], då blir det bara en parameter i funktionsanrop. Känner du hur det tenderar att bli en klass?

Tja, OOP ger dig lyxen att inte behöva tänka igenom saker i förväg.

Nästa klass - Inbox - är just för detta ändamål.

class Inbox ( /** * Array av inkommande meddelanden. */ var $messages = array(); /** * I konstruktorn, hämta alla inkommande meddelanden * och ta bort dem från sessionen. */ function Inbox() ( om (is_array($ _SESSION["session_messages"])) ( $messages = $_SESSION["session_messages"]; $co = sizeof($messages); för ($i = 0; $i< $co; $i++) { $this->meddelanden = nytt meddelande($meddelanden[$i]); ) ) /* rensa arrayen av meddelanden */ $_SESSION["session_messages"] = array(); ) /** * Visa innehållet i inkorgen på sidan. */ function toPage() ( $co = sizeof($this->messages); if ($co > 0) ( echo "Meddelande från system:
"; ) för ($i = 0; $i< $co; $i++) { $this->meddelanden[$i]->ToPage(); ) ) )

Låt oss testa vårt meddelandesystem.

Låt oss skapa ett mycket enkelt exempel som, som svar på en formulärinlämning, kommer att rapportera antalet sekunder i den aktuella minuten.

Vi har gömt allt arbete med arrayer och sessioner i klasserna, och den slutliga koden ser enkel och vacker ut.

Skapa en katalog på webbservern, skapa sedan dessa tre filer i den och prova skriptet. Observera att det inte finns några problem med knapparna Tillbaka och Uppdatera.

Föreställ dig nu att du skapar en komplex portal, där det som regel finns flera block på sidorna, och var och en kan innehålla en separat applikation inuti.

Här stöter vi på två svårigheter:

* Jag vill att listan med meddelanden ska visas på en viss del av sidan, och du har redan hittat en bra plats för detta.
Problemet är att du måste köra kommandot $inbox->toPage() exakt i det ögonblick som skulle motsvara positionen för listan med meddelanden på sidan. Om vi ​​vill ändra placeringen av den här listan måste vi komma in i koden, men det är inte bra att hela tiden ändra portalramverket för detta. Den bästa lösningen skulle vara att göra utmatningen av meddelanden i form av en separat modul, som bara är känd för att vara ansluten till ramverket.
Det vill säga att bli av med den strikta sekvensen av att lansera moduler. Faktum är att eftersom resultatet av utdata från Inbox inte beror på systemets funktion (i detta steg har vi redan all data i sessionen), varför den extra komplexiteten?
* För att behålla meddelandelistans utseende (design) måste du ta hand om HTML-koden som vi har kopplat upp i toPage-metoderna () för klasserna Message och Inbox. Som regel måste du ändra PHP-koden för att ändra designen.

För att försöka lösa det första problemet kan du skapa en buffert som lagrar resultatet av inkorgen.

Kanske kommer vi fortfarande att ha några liknande (som Inbox) saker, och vi måste skapa ett system med buffertar. För att inte blanda ihop var vems utdata finns, kommer vi förmodligen till namngivningen av buffertar. Vi kommer någonstans att ha lagrat sekvensen i enlighet med vilken utmatningen av buffertar ska ske - helst i en extern fil, så att det är lättare att göra ändringar.

Redan detta försök till en lösning ger oss idén om att använda XML som ett sätt att lagra mellanliggande data. Och användningen av XSLT-stilar hjälper till att hantera det andra problemet.

Jag kommer inte att uppehålla mig vid vad som är XML och vad som är XSLT. Om du inte är bekant med dessa saker är zvon.org en bra utgångspunkt för att lära dig.

Tanken är att inte bilda HTML-kod, utan XML-struktur i toPage()-metoderna. Siddokumentet kommer att skapas som en sträng med XML-kod (det kommer att fungera som en "buffert"), och i det sista steget av skriptet kommer vi att använda XSL-transformationen.

Föreställ dig till att börja med vad som borde vara resultatet av arbetet med huvuddelen av koden.

minut 57 sekunder: 45

Vad det är - det är ganska lätt att gissa - två meddelanden och ett formulär. Observera att PHP-skriptet bara behöver förbereda den här strängen - det är väldigt enkelt. Dessutom är ordningen på huvudtaggarna oviktig - du kan sätta den först, till exempel eftersom det kommer att vara bekvämt för programmeraren. Hur man implementerar det. Det är möjligt, nästan utan att ändra något, att använda output-buffring, mata ut XML istället för HTML-kod, och i slutet helt enkelt fånga utdata till en sträng. Men då kommer vi att tappa i flexibilitet - till exempel vill man ibland visa felsökningsinformation direkt på sidan (med hjälp av eko). Samtidigt arbetar PHP-utvecklarna på en DOM-modul som erbjuder ett mer avancerat sätt att skapa och skicka trädliknande dokument. Om vi ​​vill injicera DOM måste vi designa om hela applikationen och ändra utdata från strängar för att skapa DOM-element. Därför föredrar jag att lagra XML-representationen av objekten i själva objekten och bygga upp det övergripande XML-dokumentet i sekvens. Det är inte så svårt, bara lite modifiering behövs. Du kommer att se att denna teknik inte är strikt knuten till ett speciellt sätt att lagra XML-data, och detta kommer att tillåta dig att göra övergången till att använda DOM "med lite blodsutgjutelse". Först av allt, notera att vart och ett av våra objekt har en toPage()-metod. Denna likhet borde få oss att fundera på att införa en ny gemensam föräldraklass. Låt varje klass som kan skapa delar av XML-dokumentet för sidan ärva från en klass som tar hand om XML-representationen av objektet. Låt oss kalla det Outputable.

class Outputable ( /** * XML-behållare (sträng). */ var $output = ""; /** * Ange innehållet i behållaren och rensa behållaren. * * @retur sträng med XML-data */ funktion getOutput( ) ( $ out = $this->output; $this->output = ""; return $out; ) /** * Lägg till en del till innehållet i behållaren. * * @param sträng strängen som ska läggas till */ function appendOutput($string) ( $this ->output .= $string ."n"; ) /** * "Abstract"-metod.*/ function toPage() ( ) )

Metoden toPage() görs tom - i det här fallet behövs den som en indikator på hur de yttre "matryoshka"-klasserna ska kommunicera med den inre klassen. En standardimplementering skulle dock kunna föreslås här om vi märkte att det finns många objekt som visas på samma sätt på sidan.

Klasserna Message och Inbox kommer att ändras lite - nu borde båda ärva från Outputable, och toPage ()-metoderna kommer också att ändras
meddelande.php

class Message extends Outputable ( /** * Meddelandeinnehåll. */ var $content; /** * Konstruktör för att initiera meddelandetext. * * @param innehåll meddelandeinnehåll */ function Message($content) ( $this->content = $content; ) /** * Skriv meddelandet till sessionen */ function send() ( $_SESSION["session_messages"] = $this->content; ) /** * Skicka meddelandet till sidan */ function toPage () ( $this->appendOutput("".$this->content.""); ) )

class Inbox extends Outputable ( /** * Array av inkommande meddelanden. */ var $messages = array(); /** * I konstruktorn hämtar du alla inkommande meddelanden * och tar bort dem från sessionen. */ function Inbox() ( if (is_array ($_SESSION["session_messages"])) ( $messages = $_SESSION["session_messages"]; $co = sizeof($messages); för ($i = 0; $i< $co; $i++) { $this->meddelanden = nytt meddelande($meddelanden[$i]); ) ) /* rensa arrayen av meddelanden */ $_SESSION["session_messages"] = array(); ) /** * Visa innehållet i inkorgen på sidan. */ function toPage() ( $co = sizeof($this->meddelanden); $this->appendOutput(""); för ($i = 0; $i< $co; $i++) { $this->meddelanden[$i]->toPage(); $this->appendOutput($this->meddelanden[$i]->getOutput()); ) $this->appendOutput(""); ))

Utdatametoden har ändrats - nu istället för att direkt utmatas till sidan, lagras den externa representationen tills vidare i Outputable, som "sitter" i vart och ett av objekten. Metoden appendOutput() fungerar som en slags ersättning för echo()-konstruktionen. För att få utdata från ett objekt används metoden getOutput().

Låt oss nu se vad klientdelen av koden är, som kommer att lösa samma uppgift som tidigare.
index.php

Den huvudsakliga innovationen är i $global_content-objektet, vars namn talar för sig själv. I det här fallet tillhör den Outputable-klassen, i verkligheten skulle du förmodligen skapa en separat klass för sidans innehåll.

Om du tittar noga har innehållet i skriptet inte förändrats mycket - samma inkorg, samma toPage(). Lade till en instruktion som matar ut innehållet i meddelandelistan till sidinnehållet. För en förändring genereras nu två meddelanden.

För att se resultatet återstår det bara att förbereda XSL-mallen.
style.xsl

XSLT-exempel

Vad har vi uppnått?

Först och främst kan du ta dig an komplexa projekt mer djärvt - modulernas verkliga oberoende säkerställs. Ordningen för staplingsresultat på sidan styrs nu av en extern XSL-mall och beror inte på i vilken ordning modulerna lanseras.

Alla moduler som genererar XML-data som ett resultat av sitt arbete kan användas i ett projekt. Detta är förresten en av fördelarna jämfört med mallmotorer, där dataskapande består av sekvensen av anropsmetoder (tilldela, etc.) för en viss motor, som inte har en gemensam standard.

En annan fördel är enkel felsökning. Om du kör skriptet kommer du att märka att varje sida har felsökningsutdata, en XML-prototyp som gör felsökning av applikationer mycket enklare.

En annan sak att tänka på är hur man skapar meddelandeobjekt. Det är inte alltid bekvämt att använda nytt direkt i klientkoden. Men det här är kanske ett ämne för en separat artikel.

Till sist en galopp om utsikterna:

* popup-fönster för en lista över viktiga meddelanden
* "Avsändarsidor" och "Destinationssidor" i meddelanden
* logga meddelanden i databasen
* knappen "visa historiken för mina handlingar"
* Statistisk analys av användaråtgärder inom sessioner
* "intelligenta assistenter" i webbapplikationer