News Feed
Sections




News Archive
feed this:

Looking for more information on how to do PHP the right way? Check out PHP: The Right Way

Konrad Podgórski:
A better way to work with assets in Symfony 2
June 25, 2014 @ 13:02:11

Konrad Podgórski has a recent post to his site with his suggestion of a better way to deal with assets in Symfony 2-based applications with the help of some other tools, namely NodeJS, Bower and GruntJS.

I will explain how to work with assets in Symfony framework without having to use Assetic Bundle at all. [...] The process will be really fast and easy to understand even if you never used software listed here. However if you experience any problems do not hesitate to ask for help in comments. Post is quite long because it contain a lot of different configs but don't run away just yet. They are ready to copy & paste.

The setup will download the needed dependencies, merge and minify JS/CSS files, copy font files to the right place and deploy it all to an S3 bucket. He first walks you through the installation of the three tools complete with the commands and configurations to get them all integrated. With those installed and working, he then gets into three "scenarios", the steps in the process to build and deploy the completed version:

  • Download latest jQuery, Bootstrap, Font Awesome with Bower and copy the only necessary files to web/assets/*
  • Download dependencies with Bower, copy necessary files to web/assets/*. Then minify javascript and stylesheet files.
  • Download dependencies with Bower, merge them with your custom css and js files, then minify.

Finally, he includes the steps you'll need to follow to get the whole thing deployed out to S3 (or a CDN). In the next part of the series he'll continue the process and look at things like LESS/SASS, watching for changes in assets and how to use RequireJs.

0 comments voice your opinion now!
assets symfony2 grunt bower nodejs tutorial install configure deploy

Link: http://konradpodgorski.com/blog/2014/06/23/better-way-to-work-with-assets-in-symfony-2/

NetTuts.com:
Working With Databases in Symfony 2
June 19, 2014 @ 12:45:20

In the next part of their Symfony2 screencast series, NetTuts.com has released their introduction to using databases from inside the framework-based application. Other posts in this beginner series (all authored by Andrew Perkins) can be found here.

Today we'll continue working with Symfony 2 where I'll show you how to get started working with databases. I'll be covering setup and config, generating the database, generating your getter/setter methods and table schema, and how to persist data from a form, into a database.

The video walks you through the setup and use of a MySQL database and Doctrine (from the command line) to create the database structure. The use the sample application that's been evolving through a few of the screencasts. In this application, they show how to connect the "Person" entity to a database table through annotations. Included is the code and commands to set up the "Person" entity correctly and how to fetch/save one from a simple controller method.

0 comments voice your opinion now!
symfony2 screencast series database tutorial

Link: http://code.tutsplus.com/tutorials/working-with-databases-in-symfony-2--cms-21461

Matthias Noback:
Symfony2 How to create framework independent controllers?
June 18, 2014 @ 09:15:16

Matthias Noback has a new post to his site today, the first part of a series, looking at making framework-independent controllers for use in a Symfony2 framework-based project.

The general belief is that controllers are the most tightly coupled classes in every application. Most of the time based on the request data, they fetch and/or store persistent data from/in some place, then turn the data into HTML, which serves as the response to the client who initially made the request. [...] In this post I demonstrate that this high level of coupling is definitely not necessary. I will show you how you can decrease coupling a lot by taking some simple steps. We will end with a controller that is reusable in different types of applications, e.g. a Silex application, or even a Drupal application.

In this first part he focuses on a few places where the common practices lead to some unnecessary coupling between the controller and framework:

  • Using the framework helper methods
  • Using dependency injection (manually injecting instead)
  • Making the controller a service instead

The next post in the series will look at the use of annotations and how to refactor them out of the controller to remove yet another coupling point.

0 comments voice your opinion now!
framework independent controller symfony2 tutorial refactor decouple

Link: http://php-and-symfony.matthiasnoback.nl/2014/06/how-to-create-framework-independent-controllers/

NetTuts.com:
Form Validation in Symfony 2
June 12, 2014 @ 10:15:29

NetTuts.com has continued their screencast series introducing the Symfony 2 framework and some of the basic concepts around things like routing, templating and controllers. In this latest post they build on a previous post and show how to use the form validation already built into the framework in some custom forms.

Today we're going to continue where we left off last time, where we learned how to build reusable forms in Symfony 2. In this video, we'll learn how to validate the data that has been submitted to our form to ensure it is in the correct format, meets our data's requirements and then process the form submission accordingly. [Once finished we'll] now have a working form, which validates our data and displays the validation error messages back to the user.

The screencast (also viewable on YouTube) is only about ten minutes long and shows you how to validate a form with an email address and that the other field is "not blank". He does base it off of the form created in the previous tutorial so if you haven't done that one yet, it's better to start there and come back.

0 comments voice your opinion now!
form validation screencast symfony2 tutorial series

Link: http://code.tutsplus.com/tutorials/form-validation-in-symfony-2--cms-21397

SitePoint PHP Blog:
Building and Processing Forms in Symfony 2
June 06, 2014 @ 13:45:07

The SitePoint PHP blog has a new tutorial posted from author Daniel Sipos about form handling in Symfony2. More specifically, about creating them and handling the results from their submission. This is an introduction to the topic and gets into two examples, one focusing on a view implementation and the other using the form builder.

In this tutorial we will look at two examples of using forms in Symfony 2. In the the first, we will place form elements straight in the View file and then handle the form processing manually in the controller. In the second, we'll use the Symfony form system to declare forms in an object oriented way and have Symfony process and persist the values. We will be working on a simple installation of the Symfony framework.As you may know, it comes with a default bundle called AcmeDemoBundle and we will use that to illustrate working with forms.

In the first example he looks at "non-entity forms" and shows how to create the form from normal HTML elements in the view. The form is just a simple input field and a submit button. He includes the code you'll need to process the form submission too. In the second example he includes an example of how to create the same setup but using the Form Builder instead. It's also links it to a data object, making it simpler to save the submission results.

0 comments voice your opinion now!
symfony2 form processing view builder entity manager tutorial

Link: http://www.sitepoint.com/building-processing-forms-in-symfony-2

SitePoint PHP Blog:
Autogenerate CRUD Apps with Phreeze
May 30, 2014 @ 12:45:02

On the SitePoint PHP blog today Taylor Ren has shared a tutorial about using Phreeze to easily create CRUD applications for a MySQL backend. Phreeze is made up of three parts: an MVC handler, an ORM for database interaction and the "Phreeze Builder" to generate the application code.

Back in the times of Symfony 1.x, the framework had a powerful backend module to help the developers and site administrators create a good enough app and provide necessary CRUD features to manage the database (and save us from using PHPMyAdmin). [...] In this article, we will take a look at Phreeze, a simple and easy to use PHP framework that can help us generate a MySQL CRUD backend app. I will use my book collection test site as the underlying database. Please refer to my Data Fixtures in Symfony2 article for more details on the database structure.

He walks you through the installation of Phreeze (downloaded from GitHub) and what the first page should look like when pulled up in a browser. The wizard helps with the database setup and lets you pick the tables to generate models for as well as a few other application options. He shows how to integrate this generated code with a simple Symfony2-based application and easily allow for working with the database contents. He modifies the Symfony2 code to handle some additional options to pass into the generated code and talks some about the API interface Phreeze generates automatically.

0 comments voice your opinion now!
phreeze generate code application symfony2 integration

Link: http://www.sitepoint.com/autogenerate-crud-apps-phreeze/

Joshua Thijssen:
Throttle your API calls RateLimitBundle
May 29, 2014 @ 09:02:51

In his latest post Joshua Thijssen introduces a new tool he's created to help Symfony2-based APIs handle rate limiting relatively easily: the RateLimit Bundle. The project was recently created as a part of some work he's been doing on the TechAnalyze service.

Too many times third party applications will be polling your API when they don't really need too, and maybe you can lighten the load a bit with some heavy-duty caching, but in essence you want that every API call made matters. [...] Most of our calls are pretty lightweight, but some of them aren't, nor are they easily cacheable. This is why we are limiting the number of calls each client can make to the API. But it wouldn't be fair to just limit the number of calls in general.

[...] Our platform is written in PHP, based on the Symfony2 framework. There are many different bundles available for symfony2, all adding new functionality, but somehow we couldn't find a (good) bundle for throttling our API. But after a search, we found a gist by Ruud Kamphuis, which pretty much does what we need. So we decided to set up a similar bundle, and added some flexibility in its usage.

The RateLimitBundle allows you to add a "@ratelimit" annotation directly to the controller or action in the application and adds remaining allowed calls to the response headers. The mentions some drawbacks to the bundle like a dependency on redis and how it figures out "distinct calls" to the API. He also breaks it down into the functional pieces and talks about how each one works and where it fits into the overall functionality.

0 comments voice your opinion now!
ratelimitbundle symfony2 api ratelimit throttle

Link: https://www.adayinthelifeof.nl/2014/05/28/throttle-your-api-calls-ratelimitbundle

NetTuts.com:
Creating Reusable Forms in Symfony 2
May 28, 2014 @ 12:53:55

NetTuts.com continues their series covering some of the basics of using the Symfony2 framework with this new screencast looking at creating reusable forms.

In this video, we'll build upon our existing knowledge of Symfony 2 to learn how to create reusable forms. We'll learn how to create a separate form class to house our form logic, build the form in a controller and then render it to the browser, from a template.

In the previous parts of the series they built up knowledge on the basics, routing, controllers and templates. In this screencast they use their DemoBundle to create the Person object, make a form populated with its data (name) and the Twig template to render the form.

0 comments voice your opinion now!
symfony2 series tutorial screencast reusable forms

Link: http://code.tutsplus.com/tutorials/creating-reusable-forms-in-symfony-2--cms-21244

NetTuts.com:
Working With Templates in Symfony 2
May 20, 2014 @ 10:34:05

NetTuts.com continues their introductory screencast series today with the latest episode focusing on using templates in Symfony 2. Other parts of the series have looked at using controllers, routing and some of the basics of the framework.

Today, let's learn about Symfony 2's Twig Templates. With Twig, you can seamlessly and painlessly integrate your PHP and HTML together, giving you a very clean looking presentation of your view code, without all the clutter of PHP tags, an overabundance of parenthesis, or semicolons. Instead, we have a simple and elegant syntax that we can use.

The screencast works with a sample application and a bundle to render the Twig template and includes examples of defining blocks of content and extending other templates. They also show you how to use layouts and pass data out to the template to be rendered on load. You can watch the screencast in-page or over on YouTube.

0 comments voice your opinion now!
introduction symfony2 template twig screencast series

Link: http://code.tutsplus.com/tutorials/working-with-templates-in-symfony-2--cms-21172

NetTuts.com:
Working With Controllers in Symfony 2
May 15, 2014 @ 10:44:34

The NetTuts.com site has posted a new screencast looking at using one particular part of a Symfony2-based application, the controllers. In this new addition to their series (there's more on routing and some of the basics) they introduce you to the basic handling of controllers and how to make them work.

Today we'll take a quick look at controllers from within Symfony 2. The easiest way to get started learning, is to just dive right in, see some code examples and I'll explain everything as we proceed. [...] I hope this video has show you how easy and fun controllers are to work with in Symfony 2. We can use the console to generate them and link everything up so that it all works seamlessly.

In the screencast, they start with the "WelcomeController" to show you the basic structure of the class and the action methods they hold. There's also an example of the commands you'll need to do the controller generation and what all is included in the result (controller, template, route, etc).

0 comments voice your opinion now!
symfony2 controller screencast tutorial introduction

Link: http://code.tutsplus.com/tutorials/working-with-controllers-in-symfony-2--cms-21111


Community Events





Don't see your event here?
Let us know!


community laravel release framework language developer introduction list podcast unittest interview install testing refactor symfony2 opinion threedevsandamaybe api code series

All content copyright, 2014 PHPDeveloper.org :: info@phpdeveloper.org - Powered by the Solar PHP Framework