Vise meldinger til brukeren i nettapplikasjoner. PHP AJAX CRUD: opprette, slette, redigere poster i MySQL-databasen PHP-skript for CRUD-operasjoner

På samme måte kan du definere "

• (mål) - hvis du trenger det
• (target_url) hvis du trenger det i varselet.
• (tittel) - Vanligvis brukt for å referere til et objekt som genererte varsling. Eksempel: "Bruker X la ut nytt bilde i Album Y." Album Y er tittelen her
• (title_url) - Som med tidligere, url til et objekt som genererte varsling.
• (melding) - Denne parameteren kan brukes til å angi (og ekko) meldingen i brødteksten til JomSocial e-post.

Å vise meldinger til brukeren er en ganske vanlig handling som en nettapplikasjon bør utføre. Det kan oppstå ved behandling av skjemaer, det kan være feilmeldinger, meldinger som ber deg registrere deg når en bruker prøver å få tilgang til en begrenset del av nettstedet, og i mange andre tilfeller.

Svært ofte er oppretting og produksjon av meldinger delt opp i forskjellige HTTP-forespørsler. Som regel er det praktisk å bruke en omdirigering etter å ha behandlet skjemaer (for å unngå problemer med Tilbake- og Oppdater-knappene), men samtidig er det naturlige øyeblikket for å lage en melding nettopp øyeblikket for å behandle skjemaer og utføre handlinger som følger med den. Hvorfor? Tenk deg at meldingsteksten skal se omtrent slik ut: "Antall enheter bestilt for elementet 'Musematte' har blitt endret fra 7 til 12." Etter en omdirigering, kanskje til en helt annen side med tanke på funksjonalitet, vil det være en ekstra hodepine å finne ut hva som ble gjort før.

Oftest vises meldinger i POST-forespørselen som behandler skjemaet - dette er ikke bra, ordene "denne siden er utdatert" ødelegger livet (når brukeren bestemmer seg for å prøve Tilbake-knappen).

Noen bruker en omdirigering og gir opp vennlige meldinger.

Samtidig er det en enkel og åpenbar måte å gjøre livet bedre på. Til tross for det åpenbare har jeg av en eller annen grunn aldri sett noen bruke det – i hvert fall når jeg så på andres kilder.

Så vi har et problem - meldingen må "leve" i forskjellige forespørsler. Vi trenger en mekanisme for å overføre teksten i meldingen til siden som skal vise den. Du har sikkert allerede husket øktene.

Ja, generelt har du rett. Andre metoder, for eksempel gjennom en global variabel, tillater ikke lagring av data i tilfelle en omdirigering brukes (merknad av Maxim Naumenko). I tillegg sørger jeg vanligvis for at hver skjerm i applikasjonen har muligheten, sammen med annen informasjon, til å vise meldinger som ble generert på tidligere skjermer. Dette er praktisk fordi det ikke er nødvendig å forberede separate skjermer for visning av meldinger, og brukeren trenger ikke å klikke med musen igjen. Men egentlig må designeren tenke her - for å fremheve området der meldinger vil vises.

Ideen er veldig enkel og kan implementeres med et par klasser.

Det første du tenker på er å lage en meldingsklasse, som faktisk vil representere en melding i vårt enkle klassediagram. Meldingen må kunne lagre seg selv i økten, samt vise seg selv på skjermen.

klasse Melding ( /** * Meldingsinnhold. */ var $content; /** * Konstruktør for initialisering av meldingsteksten. * * @param innhold meldingsinnhold */ funksjon Melding($content) ( $this->content = $ innhold ; ) /** * Skriv en melding til økten. */ function send() ( $_SESSION["session_messages"] = $this->content; ) /** * Send ut en melding til siden. */ function toPage() ( echo " - " . $this->content . "
"; } }

Variabelen $_SESSION brukes for å få tilgang til økten.

Merk at $_SESSION er en matrise, vi bruker bare ett element i denne matrisen med indeksen «session_message».

I dette tilfellet har vi å gjøre med en "array of arrays" - det vi lagrer i 'session_message'-elementet er en matrise, dette er listen over overførte meldinger (selvfølgelig kan det være flere av dem).

Hvis du ikke fant tråden, er det på tide å friske opp delene av håndboken dedikert til økter og arrays.

Du har kanskje et spørsmål. Hvorfor trengs undervisning her? Det ville vært mulig å klare seg med to funksjoner. Men la oss se videre. Det kan hende vi må lage meldinger med forskjellige typer (info, feil, advarsel), og bestemme meldingsmottakere.

Vær oppmerksom på at for øyeblikket er det ikke selve objektet som legges inn i økten, men kun meldingsteksten. OOP lar oss senere endre virkemåten til send()-metoden uten å endre klientkoden som får tilgang til denne metoden (for eksempel kan vi i fremtiden skrive hele Message-objektet til sesjonen hvis det har mange felt).

La oss forestille oss at vi ville gjøre dette ved å bruke funksjoner. Vi vil sannsynligvis ha en message_send($txt)-funksjon, og også en message_to_page($txt)-funksjon. Nå må vi legge til muligheten til å ha ulik oppførsel for ulike typer meldinger. Funksjonskall endres: message_send($txt, $kind), message_to_page($txt, $kind). Du må kjemme gjennom hele applikasjonskoden på jakt etter slike funksjoner og gjøre rettelser.

Dette kan unngås ved å forutse situasjonen på forhånd ved å presentere meldingen som en assosiativ matrise: $msg['txt'], $msg['kind'], så vil det kun være én parameter i funksjonskall. Kan du føle hvordan dette prøver å bli en klasse?

Så, OOP gir deg muligheten til å ha luksusen av å ikke tenke gjennom alt på forhånd.

Den neste klassen - Inbox - er designet nettopp for dette.

class Inbox ( /** * Array av mottatte meldinger. */ var $messages = array(); /** * I konstruktøren får vi alle mottatte meldinger * og sletter dem fra økten. */ function Inbox() ( if (is_array($ _SESSION["session_messages"])) ( $messages = $_SESSION["session_messages"]; $co = sizeof($messages); for ($i = 0; $i< $co; $i++) { $this->meldinger = ny melding($meldinger[$i]); ) ) /* slett meldingsarrayet */ $_SESSION["session_messages"] = array(); ) /** * Vis innholdet i innboksen på siden. */ function toPage() ( $co = sizeof($this->meldinger); if ($co > 0) ( ekko "Melding fra systemet:
"; ) for ($i = 0; $i< $co; $i++) { $this->meldinger[$i]->ToPage(); ) ) )

La oss prøve meldingssystemet vårt.

La oss lage et veldig enkelt eksempel som vil svare på en skjemainnsending ved å rapportere antall sekunder i det gjeldende minuttet.

Vi gjemte alt arbeidet med matriser og økter inne i timene, og den endelige koden ser enkel og vakker ut.

Opprett en katalog på webserveren din, lag deretter disse tre filene i den og prøv skriptet. Vær oppmerksom på at det ikke er noen problemer med Tilbake- og Oppdater-knappene.

Forestill deg nå at du lager en kompleks portal, der det som regel er flere blokker på sidene, og hver enkelt kan inneholde en separat applikasjon.

Her møter vi to vanskeligheter:

* Jeg vil at listen over meldinger skal vises i en bestemt del av siden, og du har allerede funnet et godt sted for dette.
Problemet er at du må kjøre kommandoen $inbox->toPage() akkurat i det øyeblikket som vil tilsvare plasseringen til listen over meldinger på siden. Hvis vi ønsker å endre plasseringen av denne listen, må vi gå inn i koden, men det er ikke bra å hele tiden endre portalrammen for dette. Den beste løsningen vil være å lage utdata av meldinger i form av en egen modul, som vi bare vet at den må kobles til rammeverket.
Det vil si, fri deg fra den strenge sekvensen med å lansere moduler. Faktisk, siden resultatet av innboksutgangen ikke avhenger av driften av systemet (på dette trinnet har vi allerede alle dataene i økten), hvorfor den ekstra kompleksiteten?
* For å opprettholde utseendet (designet) til meldingslisten, må du ta vare på HTML-koden, som er hardkodet i toPage()-metodene til Message- og Inbox-klassene. Vanligvis må du endre PHP-koden for å endre designet.

For å prøve å løse det første problemet, kan du opprette en buffer som lagrer resultatet av innboksens utdata.

Kanskje vil vi fortsatt ha flere lignende (som Inbox) ting, og vi må lage et buffersystem. For ikke å forvirre hvem sin utgang er hvem sin, vil vi sannsynligvis komme til å navngi bufferne. Vi vil lagre et sted sekvensen som bufferene skal sendes ut i henhold til - helst i en ekstern fil for å gjøre endringer enklere.

Dette forsøket på en løsning gir oss allerede ideen om å bruke XML som et middel til å lagre mellomdata. Og bruk av XSLT-stiler vil bidra til å løse det andre problemet.

Jeg vil ikke dvele ved hva XML er og hva XSLT er. Hvis du ikke er kjent med disse tingene, er zvon.org et bra sted å begynne å lete.

Ideen er å generere ikke HTML-kode, men en XML-struktur i toPage()-metodene. Sidedokumentet vil bli opprettet som en streng med XML-kode (det vil tjene som en "buffer"), og i siste fase av skriptet vil vi bruke en XSL-transformasjon.

La oss først forestille oss hva som skal være resultatet av hoveddelen av koden.

minutt 57 sekunder: 45

Hva det er er ganske enkelt å gjette - to meldinger og et skjema. Vær oppmerksom på at PHP-skriptet bare trenger å forberede en slik streng - det er veldig enkelt. Dessuten er rekkefølgen på hovedkodene ikke viktig - du kan sette dem først, for eksempel, som vil være praktisk for programmereren. Hvordan implementere det. Du kan, uten å endre noe, bruke utdatabuffring, skrive ut XML i stedet for HTML-kode, og på slutten ganske enkelt fange utdataene i en streng. Men da vil vi miste fleksibiliteten - for eksempel vil du noen ganger sende ut feilsøkingsinformasjon direkte til siden (ved hjelp av ekko). Samtidig jobber PHP-utviklere med en DOM-modul som tilbyr en mer avansert måte å lage og sende tredokumenter på. Hvis vi ønsker å implementere DOM, må vi redesigne hele applikasjonen, og endre utdataene til strenger til å lage DOM-elementer. Derfor foretrekker jeg å lagre XML-representasjonen av objekter i selve objektene, og sekvensielt sette sammen et felles XML-dokument. Det er ikke så vanskelig, det trenger bare en liten modifikasjon. Du vil se at denne teknikken ikke er strengt knyttet til en spesifikk måte å lagre XML-data på, og dette vil tillate deg å gjøre overgangen til å bruke DOM med liten innsats. Først av alt, legg merke til at hvert av objektene våre har en toPage()-metode. Denne likheten burde få oss til å tenke på å introdusere en ny felles foreldreklasse. La hver klasse som kan lage deler av et XML-dokument for en side, arve fra en klasse som skal ta seg av XML-representasjonen av objektet. La oss kalle det Outputable.

klasse Outputable ( /** * XML-beholder (streng). */ var $output = ""; /** * Gi innholdet i beholderen og tøm beholderen. * * @return en streng med XML-data */ funksjon getOutput () ( $ out = $this->output; $this->output = ""; return $out; ) /** * Legg til en del av innholdet i beholderen. * * @param streng strengen for å legge til * / function appendOutput($string) ( $this ->output .= $string . "n"; ) /** * "Abstract"-metoden. */ function toPage() ( ) )

Metoden toPage() gjøres tom - i dette tilfellet er den nødvendig som en indikator på hvordan eksterne "matryoshka"-klasser skal kommunisere med den indre klassen. Vi kunne imidlertid tilby en standardimplementering her hvis vi la merke til at det er mange objekter som vises på siden på samme måte.

Message- og Inbox-klassene vil endre seg litt - de skal nå begge arve fra Outputable, og toPage()-metodene vil også endres
Message.php

class Message extends Outputable ( /** * Meldingsinnhold. */ var $content; /** * Konstruktør for initialisering av meldingsteksten. * * @param innhold meldingsinnhold */ function Message($content) ( $this->content) = $content; ) /** * Skriv en melding til økten. */ function send() ( $_SESSION["session_messages"] = $this->content; ) /** * Send ut en melding til siden. * / function toPage() ( $this->appendOutput("".$this->content.""); ) )

class Inbox extends Outputable ( /** * Array av mottatte meldinger. */ var $messages = array(); /** * I konstruktøren mottar vi alle mottatte meldinger * og fjerner dem fra økten. */ function Inbox( ) ( if (is_array ($_SESSION["session_messages"])) ( $messages = $_SESSION["session_messages"]; $co = sizeof($messages); for ($i = 0; $i< $co; $i++) { $this->meldinger = ny melding($meldinger[$i]); ) ) /* slett meldingsarrayet */ $_SESSION["session_messages"] = array(); ) /** * Vis innholdet i innboksen på siden. */ function toPage() ( $co = sizeof($this->messages); $this->appendOutput(""); for ($i = 0; $i< $co; $i++) { $this->meldinger[$i]->toPage(); $this->appendOutput($this->meldinger[$i]->getOutput()); ) $this->appendOutput(""); ) )

Utdatametoden har endret seg - nå, i stedet for å sende ut direkte til siden, er den eksterne representasjonen foreløpig lagret i Outputable, som "sitter" i hvert av objektene. AppendOutput()-metoden fungerer som en erstatning for echo()-konstruksjonen. For å få utdata fra et objekt, brukes getOutput()-metoden.

La oss nå se hva klientdelen av koden er, som vil løse det samme problemet som før.
index.php

Hovedinnovasjonen ligger i $global_content-objektet, hvis navn taler for seg selv. I dette tilfellet tilhører den Outputable-klassen; i virkelige oppgaver vil du sannsynligvis opprette en egen klasse for sideinnholdet.

Hvis du ser nøye etter, har innholdet i skriptet praktisk talt ikke endret seg - samme innboks, samme toPage(). Lagt til en instruksjon som viser innholdet i meldingslisten i sideinnholdet. For variasjon er det nå generert to meldinger.

For å se på resultatet gjenstår det bare å forberede XSL-malen.
style.xsl

Eksempel på XSLT

Hva har vi oppnådd?

Først av alt kan du mer selvsikkert ta på deg komplekse prosjekter - reell uavhengighet av moduler er sikret. Rekkefølgen resultatene plasseres i på siden styres nå ved hjelp av en ekstern XSL-mal og er ikke avhengig av rekkefølgen modulene kjøres i.

Enhver modul som genererer XML-data som et resultat av arbeidet kan brukes i et prosjekt. Forresten, dette er en av fordelene i forhold til malmotorer, der dataoppretting består av en sekvens av ringemetoder (tilordne, etc.) til en spesifikk motor, som det ikke er noen felles standard for.

En annen fordel er enkel feilsøking. Hvis du kjører skriptet, vil du legge merke til at hver side inneholder feilsøkingsutdata - en XML-prototype som i stor grad forenkler feilsøkingsapplikasjoner.

Noe annet du må tenke på er hvordan du lager meldingsobjekter. Det er ikke alltid praktisk å bruke nytt direkte i klientkoden. Men kanskje dette er et tema for en egen artikkel.

Til slutt en galopp om utsiktene:

* popup-vinduer for en liste over viktige meldinger
* "avsendersider" og "destinasjonssider" i meldinger
* logge meldinger i databasen
* knapp "vis historikk over handlingene mine"
* statistisk analyse av brukerhandlinger i økter
* "intelligente assistenter" i webapplikasjoner

I KP og BUS, fra og med versjon 11.5, i utgaver som inkluderer et sosialt nettverk, har en ny modul "Web messenger" dukket opp.
Før modulen ble frigitt til alle, gjennomgikk modulen en ilddåp på vårt "sosiale intranett", og samlet så mange som 8 oppdateringer

På seks måneders utvikling har vi gjort mye

Vi forlot det forrige grensesnittet fullstendig og opprettet et nytt, basert på opplevelsen av populære direktemeldinger.
Dialogvinduet begynte å åpne seg på siden, ansikter dukket opp i det, meldinger ble fargekodet, og det ble enkelt å føre en samtale med flere personer samtidig.

Historievinduet er et eget tema, alle har lenge ønsket å ha et historiesøk, nå har vi det endelig, vi planlegger å legge til en kalender der for rask navigering.

Vi opprettet et varslingssenter med forskjellige typer meldinger, ga muligheten til å se historikken til kvitteringen deres, og for utviklere en enkel API for å legge til og tilbakekalle varsler.

Og alt dette er tilgjengelig på hver side på nettstedet ditt!

Dessverre ble ikke alt som var planlagt gjennomført

Først Det vi ikke hadde tid til å gjøre var å oversette meldingene til bordene våre.
En slik overgang vil gjøre det mulig å forlate modulen «sosiale nettverk», som vil gi større frihet i valg av redaktører, og det vil også være mulig å innføre gruppechatter.

Sekund, dette er implementeringen av ekte "umiddelbar" kommunikasjon. Nå bruker modulen vanlig pooling, polling serveren en gang hvert n-sekund, pollingperioden varierer avhengig av kommunikasjonsaktiviteten.
Vi planlegger å skrive en egen tjeneste som vil opprettholde konstante forbindelser og sende ut dataoppdateringer etter behov (for messengeren, for live-feeden, etc.).

Tredje, planlegger vi å endre grensesnittet litt, forlate den separate kontaktlisten og dialogvinduet og kombinere dem til en enkelt helhet, som i fremtiden vil tillate oss å flytte messengeren til en mobilapplikasjon.

Det er ingen dokumentasjon ennå og den vil ikke dukke opp før til høsten, fordi... Modulen utvikles aktivt og vi ønsker å forlate muligheten til å endre API.
Jeg vil imidlertid prøve å publisere eksempler på å jobbe med den delen av APIen som arbeidet allerede er fullført med, og du kan trygt bruke dem i modulene dine.

Arbeide med varsler (relevant for IM fra og med versjon 11.5.2)

Vi har implementert tre typer varsler:
- personlig varsling;
- melding fra systemet;
- melding som krever bekreftelse;

Før du bruker API, må du sjekke om modulen er installert på systemet:

Personlig varsling

Hvis meldinger er satt til NOTIFY_TAG, vil brukeren gruppere dem.

Melding fra systemet

Varsling som krever bekreftelse (bekreft)

For å jobbe med denne typen varsler er det ikke nok å bare sende en melding, du må også levere den.

Service
Det er to alternativer, det enkleste er å følge lenken (hvis du angir den fjerde parameteren i NOTIFY_BUTTONS).
Etter å ha fulgt lenken, må du ringe følgende kode i koden din:
Oppmerksomhet: følg nøye med navnet på taggene; når du kaller sletting, vil alle meldinger med den taggen bli slettet.
Når du sender flere meldinger, må dette tas i betraktning slik at utførelse av en handling av én bruker ikke ved et uhell sletter varselet til alle (bortsett fra steder hvor slik logikk er nødvendig).

Det andre alternativet er på arrangementer.
1. du må registrere avhengigheten

Ikke glem inne i funksjonene dine Bekreft forespørsel Og Avvis forespørsel føre til at varselet slettes CIMNotify::DeleteByTag()

Det er alt for nå, jeg venter på forslagene dine i kommentarene, vellykkede implementeringer!
Hvis du vil prøve API før utgivelsen av 11.5.2 i en matrise med parametere, må du i tillegg spesifisere "MESSAGE_TYPE" => IM_MESSAGE_SYSTEM, også alternativet med en lenke i knapper vil ikke fungere for bekreftelsesvarsler. Men det er bedre å vente; oppdatering 11.5.2 kommer ut 23. mai.

Bedre en dårlig strek enn delirium tremens...

I denne artikkelen vil vi lære om hvordan du legger til, redigerer og sletter poster i en MySQL-database ved hjelp av PHP. Vi brukte en JQuery-behandler som sender en AJAX-forespørsel til et skript på serversiden. Behandleren oppdaterer listen over poster.

Når du legger til en post, sender skjemaet data til PHP-skriptet via en AJAX-forespørsel. Hvis tillegget er vellykket, lastes listen over oppføringer inn på nytt.

I JQuery AJAX-funksjonen har vi byttesaker legg til redigering og sletting. Disse tilfellene genererer forskjellige spørrings- og svardatastrenger avhengig av databasehandlingene.

function showEditBox(id) ( $("#frmAdd").hide(); var currentMessage = $("#message_" + id + " .message-content").html(); var editMarkUp = ""+currentMessage+" SaveCancel"; $("#message_" + id + ".message-content").html(editMarkUp); ) funksjon cancelEdit(message,id) ( $("#message_" + id + ".message-content") .html(melding); $("#frmAdd").show(); ) funksjon 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, type: "POST", success:function(data)( switch(action) (case "add": $("#comment-list-box").append(data); break; case "edit": $("#message_" + id + ".message-content").html(data); $("#frmAdd").show(); gå i stykker; case "delete": $("#message_"+id).fadeOut(); gå i stykker; ) $("#txtmessage").val(""); $("#loaderIcon").hide(); ), error:function ()() )); )

Følgende kode utfører spørringer mot databasen. Dette PHP-skriptet, etter å ha utført en CRUD-handling, oppdaterer postene som et resultat av AJAX-svaret.

require_once("dbcontroller.php"); $db_handle = ny DBController(); $action = $_POST["handling"]; 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("OPPDATERING kommentarsett melding = "".$_POST["txtmessage"]."" WHERE id=".$_POST["message_id"]); if($result) echo $_POST["txtmessage"]; break; case "delete": if ( !empty($_POST["message_id"])) ( mysql_query("DELETE FROM comment WHERE id=".$_POST["message_id"]); ) break; ) )

På dette tidspunktet i dette kurset er grunnlaget for pluginet vårt lagt ut, en tilpasset krok er definert, og en vedvarende melding er lagt ved for å vise hvordan kroken fungerer.

At vi Ikke gjorde, implementerte de ikke meldingstypene og visningen av dem i henhold til dataene brukeren skrev inn.

Men før vi begynner, må vi legge til støtte for forskjellige meldingstyper, et klassegrensesnitt som støtter hver meldingstype, og datastrukturen som trengs for å lagre slike meldinger.

Jeg ser frem til å fortsette opplæringen, men det er et par ting vi må vurdere før vi dykker med hodet først inn i kildekoden. Sørg for at du har følgende programvare installert på systemet ditt:

• PHP 5.6.25 og MySQL 5.6.28
• Apache eller Nginx
• WordPress 4.6.1
• Din foretrukne IDE eller editor

Og hvis du leter etter en alt-i-ett-løsning, ikke glem å prøve MAMP.

Som nevnt tidligere er vi akkurat midt i dette kurset. Hvis du gikk glipp av noen av de første leksjonene, her er hva vi har dekket så langt:

Og dette er hva vi vil vurdere på det siste stadiet av opplæringen:

Foreløpig har vi andre oppgaver, og vi vil fokusere på dem.

Siden vi har gått over til jobb (og som nevnt i tidligere leksjoner), er vi forpliktet til videre implementering av oppgavene i denne delen:

I forrige artikkel kom vi i gang i Settings Messenger, men bare til det punktet å sette opp en funksjon som kontinuerlig vil vise et suksessvarsel mens brukersiden lastes.

I denne opplæringen vil vi legge til støtte for feil-, advarsels- og suksessmeldinger. Deretter vil vi vise dem på skjermen for å få en ide om hvordan messengeren vil fungere.

I tillegg kommer vi til å gjøre en annen endring som vil legge til støtte for å avvise varsler etter brukerens skjønn.

Dette er hele planen for nødvendig arbeid for denne leksjonen. La oss begynne.

Husk at hele poenget med Settings Messenger er å definere vår måte å jobbe på med tilpassede meldinger, tilpassede kroker og den opprinnelige WordPress API for visning av meldinger i konteksten av WordPress-administrasjonspanelet.

For å gjøre dette, skal vi utvide arbeidet som ble gjort i den siste leksjonen og starte herfra.

Siden vi startet med vellykkede meldinger i forrige leksjon, la oss fortsette med dem. Nå har vi en hardkodet metode som viser et enkelt triks: