Come to find out there is a simple fix to this issue. You simply need to override the default sendPasswordLinkResponse function from Illuminate/Foundation/Auth/SendsPasswordResetEmails.php in your App/Auth/ForgotPasswordController.php.

To begin, edit your App/Auth/ForgotPasswordController.php and add the following:

/**
     * Get the response for a successful password reset link.
     *
     * @param  string  $response
     * @return \Illuminate\Http\RedirectResponse
     */
    public function sendResetLinkResponse($response)
    {
        return redirect()->route('login')->with('status', trans($response));
    }

You can add whichever route you want to redirect to, in this case it goes back to the login page. Simple as that.

The post Laravel 5.4 Redirect after Password Reset Email Sent appeared first on Jeff Mould.

Without going into all the nuts and bolts of why this works, I will just cut to the chase. 

Resolving Token Mismatch Errors in Laravel 5.2

Step 1:

Go to your App\routes.php file. Find the grouping of routes that have a “web” middleware. It will look something like this:

Route::group(['middleware' => 'web'], function () {
    .....
});

Step 2:

Change the group from middleware to middlewareGroups so that it looks like this now:

Route::group(['middlewareGroups' => 'web'], function () {
    .....
});

Step 3:

Well there is no step 3. That’s all there is to it. To learn more about how and why this fixes the issue you can find out more here:

Weird session behaviour with routes in web middleware group

Hopefully this saves you hours and a lot of hair

The post How to Fix Laravel 5.2 Token Mismatch Errors appeared first on Jeff Mould.

Every June I get my “time to renew” email notice. I don’t have auto-renewal, because that only signals to Sirius XM that they can charge your credit card whatever the going rate may be. Bad idea! A quick look online, from the link in the email that says “a special renewal offer” shows a staggering monthly price of almost $18.00. WHAT?!?! I can subscribe to Pandora and plug my phone into my car for half that price. Thanks but no thanks.

Calling customer service gets us a little movement on the price. I know they have deals, I know I can prepay for 5 or 6 months and get a much better rate than the website advertises. I ask the rep what Sirius XM deals they have going on and am given one price of $25 plus fees/taxes bringing the total to about $28 for 6 months. Wow I just got 6 months for a 1 1/2 times what their website said. A normal customer would probably give up here, and to be honest this wasn’t a bad deal, but I knew they had better.

A little background real quick, I currently had a 5 month Select Plan for $18.00 plus fees/taxes. For budget reasons, and I really don’t want to spend more on a radio service, I wanted to keep the exact same plan and pricing. So while the $25 plus fees/taxes for 6 months was essentially the same price, it was not the price I was ready to pay today. Hey a bucks a buck and I wasn’t ready to spend $8 more for one extra month.

I asked to speak with a supervisor. After a brief 15 minute hold the gentleman came on to inform me that there were currently no other deals. I asked for some details about this 6 months for $25 Sirius XM Deal to see what level of service. At this point I was debating whether to fight for a better deal, but I wanted to know if I was getting an All Access plan or the standard Select plan. I really could care less as I only ever use the Select stations anyway, but hey I am here to get the best deal possible.

After going back and forth with the “supervisor” for probably close to 15 minutes we were no where closer. It was at this point I wanted to see if this was truly their best deal. I asked him if I were to cancel my subscription, what would be the “please come back to Sirius XM deal” they would send me in a few weeks in the mail. The brief pause was really the only answer I needed, but he proceeded to say he didn’t know what they would offer. BINGO! I knew there was a better deal for the taking. 

Time to cancel my subscription. I asked him to go ahead and cancel my subscription. He didn’t even argue or try to keep me as a customer. Five minutes later, no active Sirius XM subscription and the radio has been deactivated.

Let’s Get the best Sirius XM Deals

After about a 10 minute wait, I logged back in to my Sirius XM account online. The message that I had no active radios quickly popped up with a link to “Let’s see what specials we have for you”. Perfect! Click the link and low and behold, now I have completely different pricing available.

Were the deals that much better? Not really, but they were different and the one I wanted was front and center. But what I wanted was right there at the top, 5 months for $18 plus fees/taxes. There were one or two other Sirius XM deals available, but nothing I wanted.

Long story short, you want the best Sirius XM deals, cancel your subscription when it is up for renewal, wait a few minutes after canceling, log in to your account online and presto the best Sirius XM deals are ready and waiting for you.

The post How to Get Sirius XM Deals appeared first on Jeff Mould.

Below we are going to go over some basic changes to the Laravel handler to add better support for some Exceptions. I will also go over adding support for the Laravel Whoops error handler if you would like to install it as well.

Improving Laravel 5.2 Error Handling

Laravel error handling is handled by the App/Exceptions/Handler.php file. 

public function render($request, Exception $e)
    {

        // the below code is for Whoops support. Since Whoops can open some security holes we want to only have it
        // enabled in the debug environment. We also don't want Whoops to handle 404 and Validation related exceptions.
        if (config('app.debug') && !($e instanceof ValidationException) && !($e instanceof HttpResponseException))
        {
            return $this->renderExceptionWithWhoops($e);
        }
        
        
        // this line allows you to redirect to a route or even back to the current page if there is a CSRF Token Mismatch
        if($e instanceof TokenMismatchException){
            return redirect()->route('index');
        }       

        // let's add some support if a Model is not found 
        // for example, if you were to run a query for User #10000 and that user didn't exist we can return a 404 error
        if ($e instanceof ModelNotFoundException) {
            return response()->view('errors.404', [], 404);
        }  

        // Let's return a default error page instead of the ugly Laravel error page when we have fatal exceptions
        if($e instanceof \Symfony\Component\Debug\Exception\FatalErrorException) {
            return \Response::view('errors.500',array(),500);
        }
       
        // finally we are back to the original default error handling provided by Laravel
        if($this->isHttpException($e))
        {
            switch ($e->getStatusCode()) {
                // not found
                case 404:
                    return \Response::view('errors.404',array(),404);
                break;
                // internal error
                case 500:
                    return \Response::view('errors.500',array(),500);   
                break;
 
                default:
                    return $this->renderHttpException($e);
                break;
            }
        }
        else
        {
            return parent::render($request, $e);
        }       
        
    }

Adding Whoops Error Handling Support to Laravel 5

I touched on this briefly in the function above. If you noticed the if…then statement points to a separate function within the App/Exceptions/Handler.php file.  That function is below and you should include it in the Handler.php file as well. But before we can begin to use Whoops we still need to install it.

Installing Whoops is as simple as running a composer command:

composer require filp/whoops:~1.0

That’s all there is to it. Finally, add the below function and make sure you included the if…then statement from the updated render function above. Now when you get an error in Laravel 5 you will get a nice dump to the screen. 

/**
     * Render an exception using Whoops.
     * 
     * @param  \Exception $e
     * @return \Illuminate\Http\Response
     */
    protected function renderExceptionWithWhoops(Exception $e)
    {
        $whoops = new \Whoops\Run;
        $whoops->pushHandler(new \Whoops\Handler\PrettyPageHandler());

        return new \Illuminate\Http\Response(
            $whoops->handleException($e),
            $e->getStatusCode(),
            $e->getHeaders()
        );
    }

One last reminder:

Remember to disable Whoops though when in production. Failing to do so can open up some security holes to your users. Database passwords and user passwords can be dumped in clear text to the user and you obviously do not want that in a production environment.

The post Laravel 5 Error Handling appeared first on Jeff Mould.

Let’s Encrypt SSL

Let’s Encrypt has made obtaining and installing SSL certificates a no-brainer for websites. However, if you plan to use Let’s Encrypt with Laravel running on NGINX there are a couple little modifications you will need to make to the install process. The problem is that with Laravel, your NGINX config probably points to your public directory as the root (for example: /var/www/example.com/public/). Let’s Encrypt, however, wants a directory under the root named .well-known and needs to have access to that directory publicly when installing the certificates. If you fail to account for this you will get “client lacks sufficient privileges” errors when attempting to obtain a certificate.

Below is a step-by-step guide for installing a Let’s Encrypt SSL certificate with Laravel running on NGINX. For this post I am going to assume that you are familiar with installing NGINX and Laravel. Note also that this install is done on Ubuntu 14.04 and assumes you have access to a sudo user.

Installing Let’s Encrypt SSL on NGINX with Laravel

Step 1

Let’s create a directory in your Laravel root directory. This directory is going to be called .well-known (IMPORTANT: notice the period in front of the directory name to create a hidden directory):

$ mkdir /var/www/example.com/.well-known

Step 2

Make sure that the permissions on the directory are set to 755. You will also want to make sure that the nginx user/group is able to read/write to the directory.

chmod 755 .well-known

Step 3

This step assumes you already have a Laravel site running on the server via HTTP or have previously configured your NGINX config file for your site. In this step you will want to make two changes. First you will need to change the root statement to point to the root of the site and not the public directory. Second you will add a location directive for the .well-known directory. The following changes should be made in your nginx.conf file (or whichever file contains your configuration for your site):

# we are going to comment out a line similar to this:
#root /var/www/example.com/public/;

# and we are going to add a line like this:
root /var/www/example.com/;

#next we will add the following location directive:
location ~ /.well-known { allow all; }

Step 4

Create the dhparam.pem file, which is used by the Diffie-Hellman algorithm.

openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048

 Step 5

Install the Let’s Encrypt client (note the $ represents the command prompt):

$ apt-get update

$ apt-get -y install git

$ git clone https://github.com/letsencrypt/letsencrypt /opt/letsencrypt

Step 6

Change to the /opt/letsencrypt directory and run the client. Be sure to change the path and domain name to point to your site and domain. Note that we are assuming you already have a registered domain name and that the DNS points to your webserver properly.

$ cd /opt/letsencrypt

$ letsencrypt-auto certonly -a webroot --agree-tos --renew-by-default --webroot-path=/var/www/example.com -d example.com

Step 7

You should see a message saying your certificate was successfully created.

IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at
   /etc/letsencrypt/live/example.com/fullchain.pem. Your
   cert will expire on 2016-08-04. To obtain a new version of the
   certificate in the future, simply run Let's Encrypt again.
 - If you like Let's Encrypt, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le

If there were errors, the message will give you a description of the issue. In most cases problems can relate to one of three main issues:

1. You don’t have proper permissions set on the .well-known directory above.
2. You don’t currently own the domain.
3. Your DNS is not configured properly.

Assuming your certificate was created successfully, the message should also contain a path to your new certificate. Although the message only includes the path for the public key file (.pem), the path for the private key will be the same as well. Make note of this path as you will now edit your nginx conf file (or whichever file contains your site configuration). 

Step 8

Finally, we are going to bring it all together. A couple things we need to remember: (1) the path the the dhparam.pem file we created in Step 4 above; and (2) the path to our certificates from Step 7 above. We are now going to edit the nginx config file to enable SSL (HTTPS) on our site and disable the HTTP site.

...

server {
   listen 443;

   server_name example.com;

   # make sure to point the root back to the public directory in the case of Laravel
   root /var/www/example.com/public/;

   # these are the paths to our certificate files. You should really only have to
   # change the names of the domain directory, as the file names are consistent with
   # Let's Encrypt.
   ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
   ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

   ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
   ssl_prefer_server_ciphers on;
   ssl_ciphers "EECDH+AESGCM:EDH+AESGCM:ECDHE-RSA-AES128-GCM-SHA256:AES256+EECDH:DHE-RSA-AES128-GCM-SHA256:AES256+EDH:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA:ECDHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES256-GCM-SHA384:AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256:AES256-SHA:AES128-SHA:DES-CBC3-SHA:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!MD5:!PSK:!RC4";
   ssl_session_cache shared:SSL:10m;

   # this is the path the to dhparam.pem file you created in Step 4
   ssl_dhparam /etc/ssl/certs/dhparam.pem;

   ssl_session_timeout 1d;
   ssl_session_tickets off;
   ssl_stapling on;
   ssl_stapling_verify on;

...

You may or may not have other server specific directives in your file, but these are the important ones to enable SSL. You should also create a 301 redirect for the HTTP site to point to the HTTPS version.

Step 9

Restart nginx and you should be good to go.

The post How-To Install Let’s Encrypt SSL Certificate with Laravel appeared first on Jeff Mould.

Luckily there are a few simple fixes we can do to make things right so that our Bootstrap 4 mobile menu (collapsible navigation) is the same functionality as the navbar collapse in Bootstrap 3. For this tutorial I am going to use the Dashboard example from the documentation. You can find the Dashboard example here: http://v4-alpha.getbootstrap.com/examples/dashboard/

Bootstrap 4 Mobile Menu

First things first, let’s make some small edits to the menu:

<nav class="navbar navbar-dark navbar-fixed-top bg-inverse">
      <button type="button" class="navbar-toggler hidden-sm-up pull-xs-right" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
        <span class="sr-only">Toggle navigation</span>
        <span class="icon-bar"></span>
        <span class="icon-bar"></span>
        <span class="icon-bar"></span>
      </button>
      <a class="navbar-brand" href="#">Project name</a>
      <div class="collapse navbar-toggleable-xs" id="navbar">
        <nav class="nav navbar-nav pull-xs-left">
          <a class="nav-item nav-link" href="#">Dashboard</a>
          <a class="nav-item nav-link" href="#">Settings</a>
          <a class="nav-item nav-link" href="#">Profile</a>
          <a class="nav-item nav-link" href="#">Help</a>
        </nav>
        <form class="pull-sm-right">
          <input type="text" class="form-control" placeholder="Search...">
        </form>
      </div>
    </nav>

You will notice a few things:

1. For the button, we added a “pull-xs-right” class. Without this the button appears to the left of the branding element. 
2. We added the “collapse” and “navbar-toggleable-xs” classes to the id=”navbar” div.  Without this the navbar will not be collapsible. Also, this tells Bootstrap to collapse for “xs” media.
3. Finally we changed the “pull-xs-right” class on the form element to “pull-sm-right“.

Bootstrap 4 CSS 

Our next set of changes is to add some styling. Instead of making edits to the Bootstrap SASS files, which you could do, but I didn’t want to in this case, just in case future releases resolved this issue or made additional changes. So I simply created another CSS file and included it.

.navbar-brand {
  float: none;
}
.navbar-nav .nav-item {
  float: none;
}
.navbar-divider,
.navbar-nav .nav-item+.nav-item,
.navbar-nav .nav-link + .nav-link {
  margin-left: 0;
}
@media (min-width: 34em) {
  .navbar-brand {
    float: left;
    margin-right: 2rem;
  }
  .navbar-nav .nav-item {
    padding-top: .535rem;
    float: left;
  }
  .navbar-divider,
  .navbar-nav .nav-item + .nav-item,
  .navbar-nav .nav-link + .nav-link {

    margin-left: 2rem;
  }
}
@media (max-width: 34em) {
  .navbar-brand {
      display: block;
      height: 50px;
      padding: .55rem 0;
  }

}

.navbar-toggler {
    vertical-align:middle;
    padding: .7rem .7rem;
    margin: .5rem .25rem;
    background-color: transparent;
    background-image: none;
    border: 1px solid transparent;
    border-radius: 4px;
}

.navbar-toggler {
    border-color: #ddd;
}
.navbar-toggler:focus, .navbar-toggler:hover {
    background-color: #ddd;
}
.navbar-toggler .icon-bar {
    display: block;
    width: 22px;
    height: 2px;
    border-radius: 1px;
}
.navbar-toggler .icon-bar {
    background-color: #888;
}
.navbar-toggler .icon-bar+.icon-bar {
    margin-top: 4px;
}

That’s it! You can play around with the navbar height and padding to adjust your menu if using different base sizes. Your menus now should act and look similar to Bootstrap 3. 

The post Bootstrap 4 Mobile Menu – Collapsible Nav appeared first on Jeff Mould.

How to Get Followers on Twitter

Clients often ask me for the advice on getting started with Twitter and, more importantly, how to get followers on Twitter. Unfortunately, unless you are a celebrity, a Fortune 500 CEO, or major brand, growing you Twitter following is going to be a relentless process and is not going to happen overnight. Once you get the hang of Twitter, and all the little Twitter tricks (i.e. @replies, # hashtags, DM, etc..), it can be a powerful tool for not only communicating with others, but generating leads, identifying job opportunities, and even landing jobs. 

Once you create a Twitter account though, the next question you will probably ask yourself is how to get followers on Twitter. I am assuming that you want to have a large number of followers reading and interacting with your content. If you don’t, and want to keep a small group of people that you interact with, well there is nothing wrong with that approach either. Either way, you will probably wonder what the best way to build your audience and get followers on Twitter is going to be for you.

So How Do You Get Followers on Twitter?

Start with your Twitter bio & profile picture. The first, and probably most important tip, is to add a bio and profile picture. One of the main themes that you will see through all the following tips, is to avoid coming off as a spammer or a robot. This starts with your bio and your profile picture. Tell a little about yourself. Your interests, hobbies, and link to your website or blog if you have one. Include hashtags in your bio to allow people to find it easier when searching Twitter. Try to use a real photo of yourself if you can.

Find like minded individuals. The easiest way to start is to follow people you already know. Your Facebook friends, your LinkedIn connections, your email contacts, etc… People that you have existing relationships with.

This is is good for two reasons. First, it is a quick way to start following people who you already interact with. Second, hopefully these people will follow you back, giving you an initial boost to your own follower count. 

To help address spam accounts, Twitter uses an algorithm that prevents users from following large numbers of other users without having a comparable follower count. I am sure there are other pieces to the algorithm, such as the number of tweets you send and how you interact with the platform. Twitter does not disclose the exact algorithm.

When choosing who to follow I like to think of three groups of followers. The first group is people I am friends with or have an existing relationship with. These are the most important to me and I do my best to interact with them on a regular basis, as well as enjoy reading their tweets/content.

The second group, is people whose content I enjoy reading or whose tweets I find interesting. These are people that I follow solely to stay on top of the content they are producing.

The third group is the “everyone else” group. These may have followed me themselves, they may be followers of people I already follow, or they may be suggested people to follow. I may have come across one of their tweets, found it interesting, followed them, but lost track over time. These are also people that Twitter suggested I follow or people who follow people I follow.

Research who the followers of the people you follow, your own followers and who they follow and who follows them. Once you start get

Use Twitter suggestions. One of the nice features of Twitter is it will make suggestions of people you should follow. It does this two (2) ways. First on the right hand side of the screen when you are logged in, you will see a list of “Who to Follow”.  The second way is you will get occasional emails from Twitter of suggested users to follow based on how you interact. 

Tweet regularly. Set up Google Alerts for the type of content that interests you. When you get notifications from Google of new content read them over and if you think they are useful share the articles with your Twitter followers. Use tools like Buffer to tweet even when you aren’t around.

Groom your follower/following list. This can be useful when you are just getting started, but as your follower/following counts grow, it becomes less critical. As I said above, Twitter has an algorithm that utilizes a follower/following ratio when determining a limit on how many people you are able to follow. When you are just getting started if you begin to follow a large number of people without having people following you back you may eventually run into this roadblock. To keep the ratio in check as you are starting out, you can use tools like JustUnfollow to find people who don’t follow you back, who follow you and then unfollow you, and generally see how your followers interact with you.

The more people you follow on Twitter, the more the noise ratio increases in your timeline. Grooming the list of people you follow from time to time can help make people who matter most to you, and their tweets, stand out. By grooming your list, I am referring to unfollowing people who may not have followed you back, who appear spammy, or who you just lost interest in their content. This is where segmenting you list into user types, as I pointed out above, can be useful. When grooming your list, you probably don’t want to unfollow friends or business associates, but that random user followed based on a Twitter suggestion can probably be unfollowed.

Touch your new followers. No not literally touch them. Keeping with our theme, you don’t want to appear as a robot. When someone follows you thank them or interact in some way. I prefer to use a tweet directly to the person (although I am not as good at this as I should be with my personal Twitter account) thanking them for following and pointing them to my blog. Some people use automated DMs to thank people. I am not a big fan of these. To me this comes across as spam in many instances. A simple tweet is effective enough, plus it helps open the opportunity to start a conversation.

Remember that Twitter is a 2-Way communication tool. If someone responds to your tweet, respond back. If someone tweets something you like, like the tweet, retweet it, and/or comment back to them. Interact with people you don’t know.  

Start a blog. Creating content of your own is important. While you can easily share other people’s content, having your own content to share puts the spotlight on you. Your own content gives your followers something they can share. This works to draw attention not only to your Twitter account, but to your blog itself. 

Don’t buy followers. I can’t stress this enough! While the initial burst can help you around Twitter algorithms, it does neither you or your audience any good. This is different than using Twitter ads for reaching new followers. There are many companies across the Internet that will offer to “sell” you “thousands” of followers. Not only are you wasting your money in most cases, the majority of followers they will sell you are “spam” accounts. These accounts provide no value to you and only clutter the Twitter platform. Don’t waste your money. 

Use hashtags and @mention. Hashtags are important for getting your content noticed. Use Twitter search and trends to find hashtags that interest you. When you tweet be sure to try and include a hashtag. Your tweets will get more views and engagement, resulting in more followers. Also, if you think another user will enjoy a tweet, include them in your tweet, by @mention their user name. 

Link to your Twitter account. Have a blog? Use YouTube? Have a Facebook account? Put links to your Twitter account anywhere you can. Use Follow buttons on your blog and make sure you tweet out any new content you put on your blog. If you can include your Twitter username on your business cards, do so.

It takes time! This is not an overnight process. Initially you should plan to dedicate at least a few hours each week to growing your Twitter followers. You should eventually try to get into the habit of tweeting at least once or twice a day. Using tools like Buffer can ensure you are always sharing content with users. 

Will these tips guarantee you will have millions of followers? Maybe or maybe not. Depends on how much time and effort you dedicate to growing your follower list and what your goals are. Some people see high follower counts as a “status” symbol.  It really comes down to what your goals for using Twitter are. If you are trying to build leads and generate business, you are probably going to want a larger audience. If you are looking to keep your conversation more intimate with a smaller group of followers, you will want to groom your list appropriately. Regardless over time you will see your follower count grow and become more engaging.

Many people are scared away from Twitter because initially it can appear as a black hole to your tweets. But once you start tweeting regularly and interacting with other users you will realize how valuable a tool Twitter can be to your business. Hopefully this article will help you get followers on Twitter and increase the value of your Twitter experience.

The post How to Get Followers on Twitter appeared first on Jeff Mould.

The post Site Feedback Responses appeared first on Jeff Mould.

It is important to note that WordPress may appear to function properly after a base install, if you enable permalinks on your WordPress install you will begin to see issues with Laravel attempting to route WordPress requests.

How to Install WordPress in a Subdirectory of Laravel 5

Create subdirectory

First things first, we need to create a subdirectory for our WordPress installation. We will need to create this subdirectory under the Laravel public directory. So your directory structure may look something like this (it doesn’t really matter, as long as the subdirectory you create is under the public directory in Laravel):

/usr/share/nginx/laravel/public/blog

Edit nginx.conf file

For purposes of this article I am making two assumptions. First, that you are running NGINX as I stated above. Second, that you already have Laravel installed and working properly on your server. With that in mind we need to make a couple simple edits to your nginx.conf file (or wherever you have your configuration stored for the site you are working on):

server {
    listen 80;

    server_name example.com;

    root /usr/share/nginx/example.com/public/;
    index index.php index.html index.htm;

    #WORDPRESS PORTION

    location /blog/index.php(/.*)?$ {        
        fastcgi_split_path_info ^(/blog/index.php)(/.+)$;
        fastcgi_pass unix:/var/run/php5-fpm.sock;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_read_timeout 1000;
        fastcgi_param PATH_INFO $fastcgi_path_info;
        include fastcgi_params;
    }
    location /blog/ { 
        if (!-e $request_filename) {
                rewrite ^.*$ /blog/index.php last;    
            }
        try_files $uri $uri/ blog/index.php?args; 
    }
    
    #LARAVEL PORTION
    
    #if you currently have the if...then statement you see below, you will want to wrap
    #it in the location statement so as to prevent Laravel from attempting to route
    #WordPress permalinks.
    location / {
       if (!-e $request_filename)
       {
          rewrite ^/(.*)$ /index.php?/$1 last;
          break;
       }
    }
    
    # pass php scripts to php-fpm
    location ~ \.php(.*)$ {
       fastcgi_pass unix:/var/run/php5-fpm.sock;
       try_files $uri $uri/ /index.php?q=$uri&args =404;
       fastcgi_split_path_info ^(.+\.php)(/.+)$;
       fastcgi_index index.php;
       fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
       include fastcgi_params;
    }
}

Now your configuration file may look slightly different, and include other directives (i.e. gzip, ignore files, logging configs, etc..), but the general idea is you are going to have four (4) location settings at least. Two for the Laravel installation and two for the WordPress installation. Often times, for a standard Laravel configuration you will find the if…then statement is outside of a location. It is important to note that we have moved it to inside a location for the root of the site. If we don’t do this, you will still be able to get to the /blog URL, however, if you enable permalinks for WordPress you will find that they do not work, and Laravel attempts to handle routing instead.

Once you have updated your configuration file, you simply need to restart NGINX and you will be off and running.

If you are looking for a more in-depth article about utilizing WordPress code within Laravel, for example if you want to use the WordPress admin as a CMS to your Laravel frontend, the following article is a great resource: Working with Laravel 4 or 5 and WordPress Together

The post Exclude Subdirectory from Routing in Laravel 5 appeared first on Jeff Mould.

Fixing the saveState issue in  JQuery-Steps.js with the latest version of js-cookie.js:

First, make sure you download and include the latest version of js-cookie.js from here:

https://github.com/js-cookie/js-cookie

Next we are going to make some edits to the jquery-steps.js file:

On, or about Line 1868 we are going to add an option for cookieExpires after saveState:

/**
     * Saves the current state (step position) to a cookie.
     * By coming next time the last active step becomes activated.
     *
     * @property saveState
     * @type Boolean
     * @default false
     * @for defaults
     **/
    saveState: false,
    cookieExpires: 1,

Note that the cookieExpires is in number of days. 

Next, on or about Line 168 we are going to edit the code to utilize the new Cookies function (note that I have included the old code commented out as a reference for you):

/* OLD
    // Tries to load the saved state (step position)
    if (options.saveState && $.cookie)
    {
        var savedState = $.cookie(_cookiePrefix + getUniqueId(wizard));
        // Sets the saved position to the start index if not undefined or out of range 
        var savedIndex = parseInt(savedState, 0);
        if (!isNaN(savedIndex) && savedIndex < state.stepCount)
        {
            startIndex = savedIndex;
        }
    }
    */

    if (options.saveState && window.Cookies)
    {
        var savedState = Cookies.get(_cookiePrefix + getUniqueId(wizard));
        // Sets the saved position to the start index if not undefined or out of range 
        var savedIndex = parseInt(savedState, 0);
        if (!isNaN(savedIndex) && savedIndex < state.stepCount)
        {
            startIndex = savedIndex;
        }
    }

Finally, we are going to down to Line 1189 and make the following edits to save the new cookie (again you will note the old code for reference, you can remove anything old in your code, I just included it to make it easier to see the changes):

/**
 * Saves the current state to a cookie.
 *
 * @static
 * @private
 * @method saveCurrentStateToCookie
 * @param wizard {Object} A jQuery wizard object
 * @param options {Object} Settings of the current wizard
 * @param state {Object} The state container of the current wizard
 */
function saveCurrentStateToCookie(wizard, options, state)
{
    if (options.saveState && window.Cookies)
    {
        Cookies.set(_cookiePrefix + getUniqueId(wizard), state.currentIndex, { expires: options.cookieExpires });
    }
    /* OLD
    if (options.saveState && $.cookie)
    {
        $.cookie(_cookiePrefix + getUniqueId(wizard), state.currentIndex);
    }
    */
}

That’s all there is to it. You can save this new file and include it in your application. JQuery-Steps will now utilize the js-cookies.js functions to saveState.

The post How to fix JQuery Steps Plugin saveState not working appeared first on Jeff Mould.