Urdu Ελληνικά
English English Deutsch Deutsch Español Español Français Français Italiano Italiano Nederlands Nederlands Português Português Русский Русский Ελληνικά Ελληνικά
Login



 
Welkom bij Jumi! Tutorial >> >> Zelf bellen vormen in een Joomla! inhoud

Er is een heleboel mensen die hun aangepaste formulieren te publiceren in een Joomla! inhoud.

Om hun behoeften te voldoen heb ik besloten om deze tutorial te schrijven. De tutorial is gewijd aan Joomla! 1.0.x codering beginners, maar intermediaire batterijen kunnen vond een aantal trucs nuttig ook.

In deze stap voor stap uitleg leert u

  • wat zelf Colling vormen zijn en met welk doel ze dienen,
  • een aantal meest nuttige php en Joomla! 1.0.x trucs die relevant zijn voor zelf bellen vormen. Bijv:
    • hoe een script vangt die een gebruiker heeft verzonden,
    • hoe u een URL-adres waar het script wordt uitgevoerd herkennen,
    • hoe het uitschakelen van de specifieke Joomla! pagina cache uit,
    • wat Joomla! specifiek object $ database, $ mijn zijn, waar ze hun methoden en hun beschrijving te vinden,
    • enz.

Wat zelf bellen vormen zijn en met welk doel ze dienen

Elke vorm verzamelt gegevens uit responders.

De verzamelde gegevens blijven niet in een vorm, maar ze zijn - meestal na het indrukken van de knop in te dienen - gestuurd ergens. Ze worden gezonden aan zo'n verwerking script dat "zit" op een andere URL-mailadres en dat - na een eventuele voorbewerking - schrijft gegevens in de database en / of stuurt ze naar een e-mail adres.

Dit is de meest voorkomende aanpak. En op die aanpak rekenen standaard Joomla! vormen componenten.

Maar mogelijk leven zonder vormen component, is het mogelijk om ons formulieren wordt opgenomen in een artikel weergeven. Formulieren kunnen sturen verzamelde gegevens om zichzelf en verwerken. Ze worden zo genoemd zelf bellen vormen.

Het is zelfs mogelijk nog: om in de vorm resulteert in dezelfde inhoud artikel.

In deze tutorial zal ik laten zien hoe.

Omdat er moet toch een php script er die manipuleert met vorm gegevens die ik gebruik zullen maken van Jumi plugin te maken voor het opnemen van deze scripts in de inhoud. Mocht u liever een andere plugin voor php script opname in Joomla! inhoud die u kunt gebruiken het ook.

Demo vorm omschrijving

Hoewel de volgende demo vorm is heel concreet kunt u schrijven elke vorm je je kunt voorstellen door de aanpak uitgelegd in deze tutorial.

Maak geen tests op uw openbare productie-server, maar op de lokale host alleen!

Laten we aannemen dat we willen

  • een stemformulier dat de antwoorden op 3 elkaar uitsluitende vragen verzamelt,
  • antwoorden bij elkaar op te slaan in een database met datum en tijdstip van het antwoord en samen met de identificatie een gebruiker,
  • om "dank u" aankondiging en samenvatting van de resultaten laten zien, maar voor gebruikers die gestemd.

Basisstrategie

Het splitsen van de code in meerdere stukken, functionele en logische blokken biedt vele voordelen. Hoewel ik niet gesproken over de voordelen hier Ik zal deze algemene goede praktijken hier.

Er zijn twee belangrijke logische blokken in onze taak:

  • tonen vormen + gegevens verzamelen + controleren of ze + gegevens opslaan in een database (zelf bellen vorm)
  • data van een database en tonen de resultaten.

Dus ik zal onze applicatie te splitsen in twee script-bestanden: self_call_form.php en show_results.php.

We zullen ingaan op de details in het volgende.

Maar laten we eerst beginnen met een database.

Database

Laat onze database tabel naam xxx_mytable_test is waarbij xxx staat voor uw Joomla! database prefix. Sommige Joomla! gebruikers hebben jos prefix anderen hebben mos prefix. Ik neem jos prefix in de volgende.

Ik herhaal onze taak is om op te slaan opname datum en tijd, de identificatie van gebruikers en een antwoord.

Zonder in te gaan op MySQL database en tabel ontwerpdetails die elders kan worden gevonden de structuur van de tabel van de in MySQL taal zal zijn:

CREATE TABLE IF NOT EXISTS `jos_mytable_test` (
`Id` int (11) NOT NULL auto_increment,
`Recordtime` datetime NOT NULL default '0000-00-00 00: 00: 00',
`User_id` varchar (15) NOT NULL default 'host',
`Antwoord` int (6) NOT NULL default '0',
PRIMARY KEY (`id`)
) TYPE = MyISAM;

Het veld id is toegevoegd alleen voor record in unieke identificatie.

Je moet de tabel te maken in de Joomla database. Controleer dat uw prefix is ​​jos_. Als is het nog steeds mos_, wijzigt u de tabel prefix.

U kunt tabel per phpMyAdmin handmatig of automatisch door het copy-paste van de MySQL-statement hierboven.

Ik neem de tafel jos_mytable_test wordt gemaakt op basis van nu.

self_call_form.php

Er zijn twee manieren waarop een vorm communiceren met zijn omgeving: POST en GET. GET stuurt (en leest) gegevens uit URL bijlage. We zullen geen gebruik maken van hier GET methode.

Methode POST schrijft gegevens aan de mondiale php variabele $ _POST. Dus we hebben volledige toegang tot de gegevens hierheen gestuurd.

Algemeen algoritme van de self_call_form.php

Als er geen relevante gegevens in $ _POST, dat wil zeggen er is geen antwoord van een gebruiker, dan geven vorm. Als de gebruiker beantwoord, dan bedank hem en schrijf het antwoord (en andere gegevens) in de database.

Het algoritme bovenstaande vertaald in php taal ziet er als volgt code:

functie self_form()
 // Keuzerondje naam (hier "antwoord") moet ook een kolomnaam in een database zijn !!!
{

 $ Anker = "mijnformulier"; / / De $ anker variabele die we later nodig
 echo " "; / / De html anker zullen we later nog nodig
 echo " "; / / Formulier container

 if(!isset($ _POST['Antwoord'])) / / Als er geen antwoord schrijf dan de vorm
 {
  $ Return_url = Get_return_url($ Anker);
  echo " ";
  echo " Vond je deze tutorial nuttig? ";
  echo " Absoluut nee.\n";
  echo " Middelmatig.\n";
  echo " Ja. Bedankt daarvoor.\n";
  echo " ";
  echo " ";
 }

 anders / / Als er een antwoord te bedanken en het antwoord schrijven in de database
 {
  echo " Bedankt voor je stem ";
  WRITE_DATA($ _POST['Antwoord']);
 }

 echo " ";
}

De uitleg en een paar trucjes

PHP functie isset ('antwoord') controleert weer 'antwoord' bestaat in $ _POST.

We willen het formulier om gegevens te verzenden naar zichzelf. Dat betekent dat naar dezelfde URL-adres (vorm en de verwerking ervan script is te vinden op dezelfde URL). We kunnen moeilijk gecodeerde URL-adres van een pagina of, zoals in ons geval kunnen we de URL krijgen van Joomla omgeving met behulp van een eenvoudige truc. Het gebruik van de truc is beter dan de eerste harde gecodeerde benadering, omdat onze code is herbruikbaar op verschillende pagina's zonder aanraking.

Dus hier komt de truc die in de functie get_return_url ($ anker).

Functie get_return_url ()
functie get_return_url($ Anker)
{
 if ($ QUERY_STRING = MosGetParam( $ _SERVER, 'QUERY_STRING', '' ))

 {
  $ Terug te keren = 'Index.php?' . $ QUERY_STRING;
 }
 anders
 {

  $ Terug te keren = 'Index.php';
 }
 / / Een URL begint met index.php nu
 
 // converteren & naar & voor xtml-compliance

 $ Terug te keren = str_replace( '&', '&', $ Terug te keren );
 / / Toevoegen anker aan het eind van URL

 $ Terug te keren .="# $ anker"; / / Toevoegen anker voor url
 / / Prepand http:// het begin van de URL
 terugkeer sefRelToAbs($ Terug te keren);

}

Er is geen wonder in. De functie geeft alleen URL-adres waar het op draait (in ons formulier). Met inbegrip van het anker.

Daarom heb ik onder meer de (html) anker in het adres van de afzender?

Stel dat onze vorm aan de onderzijde van een zeer lange pagina. Als het niet voor het anker dan na het verzenden van data gebruiker ziet de bovenkant van de pagina en moet naar beneden scrollen. Met de verankering van de gebruiker keert terug worden naar de plaats die hij gestemd.

Ik zal graag uw aandacht richten op Joomla! specifieke functie mosGetParam () ook. Het is de meest nuttige functie. En moet worden gebruikt in u vormt intensief.

De algemene beschrijving van de mosGetParam () kan worden gevonden hier. Een praktische gebruik volgt:

In plaats van:

$ _POST ['Somename']

is het beter om:

mosGetParam ($ _POST, 'somename')

omdat het niet alleen doet wat het trimmen van ongewenste input van de gebruiker, maar er zijn een aantal andere nuttige opties in.

Maar als je veel gegevens moeten worden verwerkt, zal eerder tijd consumptieve om alle waarden van $ _POST een intrekken door middel van een zijn: hetzij door direct toegang te krijgen tot hen of via mosGetParam () functie. Er is een andere truc: gebruik php functie extract ($ _POST) die variabelen bouwt en wijst ze de namen van alle inhoud van de $ _POST.

We $ _SERVER Merk op te gebruiken in de functie get_return_url (). $ _SERVER Is een andere php globale variabele als $ _POST en kan het gebruik van een aantal ook in je scripts. Als u niet weet wat de inhoud van de variabelen die je kunt laten zien in je scripts met behulp van var_dump ($ somoevaribale) functie.

Functie checkForm ()

Dit is de validatie van JavaScript-functie die input van de gebruiker tegen een aantal regels valideert. Dat is echt e-mail is een e-mailadres, die naam is niet leeg, enz.

Nogmaals: u kunt verschillende validatie scripts te vinden op honderden internetbronnen.

In onze demo formulier zullen wij controleren of de gebruiker heeft een "antwoord" keuzerondje geselecteerd. Als er geen "antwoord" niet in te dienen gegevens, maar geven een waarschuwing:

<SCRIPT type="tekst / javascript">
functie checkForm(theForm) {
 var waarom = "";
  op een (i=0; ik) {

   if (theForm.answer[i]. Gecontroleerd) {
    var checkvalue = theForm.answer[i]. Waarde;
     breken;
    }
  }

  waarom + = checkRadio(checkvalue);
  if (waarom! = "") {
   Daarom + = "\nAls u denkt dat het onze fout is, laat het ons dan weten. ";
   te waarschuwen(Waarom);
   terugkeer vals;
  }

  terugkeer waar;
}
 
functie checkRadio(checkvalue) {
 var error = "";
  if (!(checkvalue)) {

   error = "U heeft geen optie geselecteerd.\n";
   }
   terugkeer fout;
}
->

Er zijn geen trucs en geen wonderen hier dus laten we naar de schrijven van gegevens naar de database.

Functie WRITE_DATA ()

U kunt besparen veel tijd als u Joomla! objecten en methoden in plaats van met behulp van standaard MySQL database-functie. Ik bedoel gebruik van database-> load ..., database-> query, etc. Zeer beschrijvende handleiding te vinden hier.

functie WRITE_DATA($ Value)
/ / Als de gebruiker is ingelogd save zijn id behoudens de 'host'

{
 globaal $ Database, $ Mijn;
 if ($ Mijn->id)
  $ User_id = $ Mijn->id;
 anders

  $ User_id = "gastheer";
 $ Database->setQuery( "INVOEGEN IN #__mytable_test (id, opnametijd, gebruikersid, antwoord) WAARDEN ('', '". gegevens('Y-m-d H: i: s')."','".$ User_id."','".$ Value."');" );
 $ Database->vraag(); / / Schrijf data

}

Niets interessant hier, behalve wereldwijde Joomla! variabele $ mijn. Het bevat gebruikers-id, naam, zijn e-mail enz. Ook hier geldt: probeer var_dump ($ mijn) gebruiken in je code en je zal de structuur en de inhoud te zien.

Valideren query:

Ik heb niet een validatie die gegevens daadwerkelijk werd geschreven. U kunt dit doen als je wilt. Alleen de plaats van de regel $ database-> query (); door
if (!$ Database->vraag()) { / / Schrijven van gegevens en als fout optreedt alert

  echo " alert('".$ Database->getErrorMsg()."'); ";
 }

Dus hebben we alle bouwstenen van ons zelf te bellen vorm nu.

U kunt direct proberen (op voorwaarde dat u jos of mos_mytable_test tabel gemaakt).

Maar er is nog een ding ...

Niet voor ons allen de toepassing gedrag zoals in het algemeen worden verwacht: na het indienen van het formulier zal nog steeds zichtbaar en er zal geen "dank u" aankondiging zijn.

Dit zal gebeuren voor degenen wier Joomla! cache is.

En hier komt een andere truc: het uitschakelen van de hele Joomla cache gemakkelijk is, maar het uitschakelen van de cache voor een van de Joomla pagina's lijkt het probleem.

Het grote probleem met een zeer eenvoudige oplossing.

De cache hack werd beschreven in Joomla! forum:

Bewerken / includes / Cache / Lite.php
Je zult zien "-functie save ($ data ..."
verandering

functie besparen($ Data, $ Id = NULL, $ Groep = 'Default')

{
 if ($ This-> _ caching) {

naar

functie besparen($ Data, $ Id = NULL, $ Groep = 'Default')

{
 if(strpos($ Data,' ') ! == vals) {
  $ This-> _ caching = 0;
 }

 if ($ This-> _ caching ) {

Maak vervolgens een module met


in het lichaam, en publiceren naar een weergegeven positie (De gebruikers zullen het niet zien) ... Dan maar mogelijk is dat die module op elke pagina die u niet wilt dat de cache ...

Ik ben gewoon toe te voegen dat "nocache richtlijn" kunnen worden opgenomen in de inhoud ook.

Samenvatting van self_call_form.php

Er is dus de gehele inhoud van self_call_form.php:


gedefinieerd( '_VALID_MOS' ) or sterven( 'Beperkte toegang' ); / / Redenen van veiligheid

?>
<SCRIPT type="tekst / javascript">
functie checkForm(theForm) {
 ...
}
functie checkRadio(checkvalue) {

...
}
->

 


functie self_form()
{
...

}
functie get_return_url($ Anker){
 ...
}
functie WRITE_DATA($ Value){
...
}
 

/ / Directie code begint hier
self_form();
/ / Directie code eindigt hier
?>

NB: het hele script is "verpakt" in de uitvoerende self_form () functies. Geen script variabelen worden gedefinieerd buiten een functie, zodat er geen risico is van de variabelen zal interageren met andere 3rd partij of Joomla! variabelen op een onvoorspelbare manier.

Uff ...

Dat is alles voor het zelf bellen formulier: show formulier + gegevens verzamelen + controleren of ze + gegevens opslaan op een database.

Schrijf nu in uw artikel

{Jumi [somepathway / self_call_form.php]}

en test het.

Eerst ziet u

Jumi vorm ingang

en na uw stem uitbrengen (alleen na de stemming), zie je het resultaat van het tweede deel (show_results.php):

Jumi vorm uitgang

Het tweede deel - presenteren van de resultaten van de database - veel gemakkelijker dan het voorgaande deel.

show_results.php


gedefinieerd( '_VALID_MOS' ) or sterven( 'Beperkte toegang' );

 
functie show_results()
{
 globaal $ Database;
 echo " "; / / Niet noodzakelijk, maar handig hier

 $ Radios_name = "antwoord"; / / Moet een kolom in een database ook zijn!
 if(isset($ _POST[$ Radios_name])) {/ / Show resultaten voor degenen die gestemd alleen
  echo " ";
  echo " Deze tutorial was ";
  $ Database->setQuery( "SELECTEER $ radios_name, COUNT (id) AS numitems FROM #__myform_test GROUP BY $ radios_name");
  $ Rijen = $ Database->loadObjectList();
  foreach ( $ Rijen as $ Row ){ / / Wandelen door antwoorden

   schakelaar ($ Row->beantwoorden){
    geval 1:
     echo "niet bruikbaar voor".$ Row->numItems."lezers,\n";
    breken;
    geval 2:
     echo "zo handig voor".$ Row->numItems."lezers en\n";
    breken;
    geval 3:
     echo "erg handig voor".$ Row->numItems."lezers\n";
    breken;
    verzuim:
   }

 }
 echo " ";
 }
}
show_results();
?>

Schrijf nu in uw content net iets minder dan vorige Jumi plugin verklaring:

{Jumi [somepathway / show_results.php]}

en test het.

Ik denk niet dat er veel voor een toelichting, behalve het manipuleren van database-en rijen objecten. Nogmaals: ga naar Joomla! API beschrijving.

Conclusie

Alles was opgelost, alles werd geschreven. U kunt het hele script hier.