Git and WordPress: How to Auto-Update Posts with Pull Requests

At Bitfalls.com, we also use WordPress for now, and use the same peer review approach for content as we do at SitePoint.

We decided to build a tool which automatically pulls content from merged pull requests into articles, giving us the ability to fix typos and update posts from Github, and see the changes reflected on the live site. This tutorial will walk you through the creation of this tool, so you can start using it for your own WordPress site, or build your own version.

The Plan

The first part is identifying the problem and the situation surrounding it.

  • we use WPGlobus for multi-language support, which means content gets saved like this: {:en}English content{:}{:hr}Croatian content{:}.
  • authors submit PRs via Github, the PRs are peer reviewed and merged, and then (currently) manually imported into WP’s Posts UI through the browser.
  • every post has the same folder layout: author_folder/post_folder/language/final.md
  • this is slow and error prone, and sometimes mistakes slip by. It also makes updating posts tedious.

The solution is the following:

  • add a hook processor which will detect pushes to the master branch (i.e. merges from PRs)
  • the processor should look for a meta file in the commit which would contain information on where to save the updated content
  • the processor automatically converts the MD content to HTML, merges the languages in the WPGlobus format, and saves them into the database

Bootstrapping

If you’d like to follow along (highly recommended), please boot up a good virtual machine environment, install the newest version of WordPress on it, and add the WPGlobus plugin. Alternatively, you can use a prepared WordPress box like VVV. Additionally, make sure your environment has ngrok installed – we’ll use that to pipe Github hook triggers to our local machine, so we can test locally instead of having to deploy.

Hooks

For this experiment, let’s create a new repository. I’ll call mine autopush.

In the settings of this repository, we need to add a new hook. Since we’re talking about a temporary Ngrok URL, let’s first spin that up. In my case, entering the following on the host machine does the trick:

ngrok http homestead.app:80

I was given the link http://03672a64.ngrok.io, so that’s what goes into the webhook, with an arbitrary suffix like githook. We only need push events. The json data type is cleaner, so that’s selected as a preference, and the final webhook setup looks something like this:

Webhook setup

Let’s test this now.

git clone https://github.com/swader/autopush
cd autopush
touch README.md
echo "This is a README file" >> README.md
git add -A
git commit -am "We're pushing for the first time"
git push origin master

The ngrok log screen should display something like this:

POST /githook/                  404 Not Found

This is fine. We haven’t made the /githook endpoint yet.

Processing Webhooks

We’ll read this new data into WordPress with custom logic. Due to the spaghetti-code nature of WP itself, it’s easier to circumvent it entirely with a small custom application. First, we’ll create the githook folder in the WordPress project’s root, and an index.php file inside it. This makes the /githook/ path accessible, and the hook will no longer return 404, but 200 OK.

According to the docs, the payload will have a commits field with a modified field in each commit. Since we’re only looking to update posts, not schedule them or delete them – those steps are still manual, for safety – we’ll only be paying attention to that one. Let’s see if we can catch it on a test push.

First, we’ll save our request data to a text file, for debugging purposes. We can do this by modifying our githook/index.php file:

<?php
file_put_contents('test.txt', file_get_contents('php://input'));

Then we’ll create a new branch, add a file, and push it online.

git checkout -b test-branch
touch testfile.md
git add testfile.md
git commit -am "Added test file"
git push origin test-branch

Sure enough, our test.json file is filled with the payload now. This is the payload I got. You can see that we have only one commit, and that commit’s modified field is empty, while the added field has testfile.md. We can also see this happened on refs/heads/test-branch, ergo, we’re not interested in it. But what happens if we make a PR out of this branch and merge it?

Continue reading %Git and WordPress: How to Auto-Update Posts with Pull Requests%


Source: Sitepoint

Leave Your Competitors in the Dust with 280+ Pre-Built Websites

This article was sponsored by Be Themes. Thank you for supporting the partners who make SitePoint possible.

Are you a freelancer? Then your pay often depends on finding clients who can provide you with a steady stream of work. The competition can be fierce, however. Moreover, clients can be picky about who they feel can be trusted to deliver a quality product.

Worrying about how other designers get lucrative assignments is a waste of time. It’s what you are doing to capture some of those assignments that counts, and it’s not as difficult as you might think.

These three strategies can help you. They can put you on the path to getting more clients who are eager to pay you handsomely for your work.

1. Build or Update Your Own Creative Website

Be webmaster

Freelance web designers need to have their own websites to publicize their skills. Being able to present clients with a gallery or portfolio of your work is key to getting more work. Yet having a portfolio, even an awesome one, isn’t necessarily enough.

You need to have your website’s visitors blown away by the user experience you’re able to provide. You want those prospective clients to see the features they would like to see in theirs. These include page load speed, SEO, navigation, and well-structured content.

Now they know who can do it for them!

2. Getting More Clients in Less Time

The strategy? It’s easier than you think. A problem you may face is that a range of clients represents a wide variety of industry niches. These also come with a variation of website types added into the mix.

In addition, these clients can have vastly different website requirements. It’s incumbent on you to be nimble enough to find an appropriate template or theme quickly. You should be able to deliver a product in hours, instead of days or weeks.

Do that, and you’re already a step or two ahead of the competition. Do it consistently, and before you know it, the competition will be the least of your concerns.

Be Theme gives you the flexibility you need to completely satisfy any client’s needs, and do so quickly. Be Theme’s pre-built websites address every single industry sector and business niche. It’s not all that difficult to create a beautiful website for a client the same day you get the go-ahead.

These pre-built website examples demonstrate why this is possible.

Showcase

Showcase

This is an excellent example for a creative client with a product or service to sell. You might even consider it as a starting point for your own creative website.

Continue reading %Leave Your Competitors in the Dust with 280+ Pre-Built Websites%


Source: Sitepoint

Learning Angular: Everything You Need to Get Started

Whether it’s AngularJS 1.X – a framework, or Angular – a platform, Google’s Angular project has taken over the web. Here’s a collection of articles, projects and courses that’ll help you get to grips with the powerful front-end tool.

But if you’re starting from scratch, and you’d like to go from zero to expert fast, a course recommendation. For expert-led online Angular training courses you can’t go past Ultimate Angular by Todd Motto. Try his courses here [ultimateangular], and use the code SITEPOINT to get 25% off and to help support SitePoint.

Introductions and Comparisons

Fundamentals

Testing

Authentication

Slightly More Advanced

Projects

You’ve got the basics – and perhaps even a little bit more. Here are some projects to take on to put that knowledge into practice.

Continue reading %Learning Angular: Everything You Need to Get Started%


Source: Sitepoint

Confessions Of An Impostor




 


 

Five years ago, when, for the first time ever, I was invited to speak at one of the best front-end conferences in Europe, I had quite a mixture of feelings. Obviously, I was incredibly proud and happy: I had never had a chance to do this before for a diverse audience of people with different skillsets. But the other feelings I had were quite destructive.

Confessions Of An Impostor

I sincerely could not understand how I could be interesting to anyone: Even though I had been working in front-end for many years by then, I was very silent in the community. I hadn’t contributed to popular frameworks or libraries. I was just average. So, the feeling of a mistake having been made, that I did not deserve to be at that conference, was very strong, and I could not believe that I would indeed be speaking until I had bought my plane ticket.

The post Confessions Of An Impostor appeared first on Smashing Magazine.


Source: Smashing Magazine

Naming Things In CSS Grid Layout




 


 

When first learning how to use Grid Layout, you might begin by addressing positions on the grid by their line number. This requires that you keep track of where various lines are on the grid, and also be aware of the fact the line numbers reverse if your site is displayed for a right-to-left language.

Naming Things In CSS Grid Layout

Built on top of this system of lines, however, are methods that enable the naming of lines and even grid areas. Using these methods enables easier placement of items by name rather than number, but also brings additional possibilities when creating systems for layout. In this article, I’ll take an in-depth look at the various ways to name lines and areas in CSS Grid Layout, and some of the interesting possibilities this creates.

The post Naming Things In CSS Grid Layout appeared first on Smashing Magazine.


Source: Smashing Magazine

Ember.js: The Perfect Framework for Web Applications

Ember.js is an opinionated frontend JavaScript framework that has been getting a lot of interest lately. This article will introduce some key concepts of the framework while building a simple application with it, in order to show a basic example of what it is capable of producing.

Our example application is going to be a Dice Roller, including the ability to roll some dice and view a history of all dice rolls that have been performed to date. A fully working version of this application is available from Github

The Ember.js framework pulls together a lot of modern JavaScript concepts and technologies into one single bundle, including but not limited to:

  • The use of the Babel transpiler tool, to support ES2016 throughout.
  • Testing support at the Unit, Integration and Acceptance levels as standard, powered by Testem and QTest.
  • Asset building using Broccoli.js.
  • Support for live reloading, for shorter development cycle times.
  • Templating using the Handlebars markup syntax.
  • URL Routing first development to ensure that deep linking is fully supported throughout.
  • Full data layer built around JSON API, but pluggable for whatever API access you need.

In order to work with Ember.js, it is assumed that you have an up-to-date installation of Node.js and npm. If not then these can be downloaded and installed from the Node.js website.

It should also be mentioned that Ember is purely a frontend framework. It has a number of ways of interacting with the backend of your choice, but this backend is not in any way handled by Ember itself.

Introducing ember-cli

A lot of the power of Ember.js comes from its command line interface (CLI). This tool – known as ember-cli – powers much of the development lifecycle of an Ember.js application, starting from creating the application, through adding functionality into it all the way to running the test suites and starting the actual project in development mode.

Almost everything that you do whilst developing an Ember.js application will involve this tool at some level, so it is important to understand how best to use it. We will be making use of it throughout this article.

The first thing we need to do is ensure that the Ember.js CLI is correctly installed and up-to-date. This is done by installing from npm, as follows:

$ npm install -g ember-cli

and we can check it was successfully installed by running the following command:

$ ember --version
ember-cli: 2.15.0-beta.1
node: 8.2.1
os: darwin x64

Creating Your First Ember.js App

Once ember-cli is installed, you are ready to start creating your application. This is the first place we will be making use of the Ember.js CLI tool – it creates the entire application structure, setting everything up ready to run.

$ ember new dice-roller
installing app
  create .editorconfig
  create .ember-cli
  create .eslintrc.js
  create .travis.yml
  create .watchmanconfig
  create README.md
  create app/app.js
  create app/components/.gitkeep
  create app/controllers/.gitkeep
  create app/helpers/.gitkeep
  create app/index.html
  create app/models/.gitkeep
  create app/resolver.js
  create app/router.js
  create app/routes/.gitkeep
  create app/styles/app.css
  create app/templates/application.hbs
  create app/templates/components/.gitkeep
  create config/environment.js
  create config/targets.js
  create ember-cli-build.js
  create .gitignore
  create package.json
  create public/crossdomain.xml
  create public/robots.txt
  create testem.js
  create tests/.eslintrc.js
  create tests/helpers/destroy-app.js
  create tests/helpers/module-for-acceptance.js
  create tests/helpers/resolver.js
  create tests/helpers/start-app.js
  create tests/index.html
  create tests/integration/.gitkeep
  create tests/test-helper.js
  create tests/unit/.gitkeep
  create vendor/.gitkeep
NPM: Installed dependencies
Successfully initialized git.

$

This has caused an entire application to be created which is ready to run. It has even set up Git as source control to track your work.

Note: If you wish, you can disable the Git integration and you can prefer Yarn over npm. The help for the tool describes this and much more.

Now, let’s see what it looks like. Starting the Ember application for development purposes is – once again – also done using ember-cli:

$ cd dice-roller
$ ember serve
Livereload server on http://localhost:49153
'instrument' is imported from external module 'ember-data/-debug' but never used
Warning: ignoring input sourcemap for vendor/ember/ember.debug.js because ENOENT: no such file or directory, open '/Users/coxg/source/me/writing/repos/dice-roller/tmp/source_map_concat-input_base_path-2fXNPqjl.tmp/vendor/ember/ember.debug.map'
Warning: ignoring input sourcemap for vendor/ember/ember-testing.js because ENOENT: no such file or directory, open '/Users/coxg/source/me/writing/repos/dice-roller/tmp/source_map_concat-input_base_path-Xwpjztar.tmp/vendor/ember/ember-testing.map'

Build successful (5835ms) – Serving on http://localhost:4200/



Slowest Nodes (totalTime => 5% )              | Total (avg)
----------------------------------------------+---------------------
Babel (16)                                    | 4625ms (289 ms)
Rollup (1)                                    | 445ms

We are now ready to go. The application is running on http://localhost:4200, and looks like this:
Default application screen

It is also running a LiveReload service which automatically watches for changes to the filesystem. This means that you can have an incredibly fast turnaround time when tweaking your site design.

Let’s try it?

The initial page already tells us what to do, so let’s go and change the main page and see what happens. We’re going to change the app/templates/application.hbs file to look like the following.

This is my new application.

{{outlet}}

Note: The {{outlet}} tag is part of how Routing works in Ember. We will cover that later on.

The first thing to notice is the output from ember-cli, which should look as follows:

file changed templates/application.hbs

Build successful (67ms) – Serving on http://localhost:4200/

Slowest Nodes (totalTime => 5% )              | Total (avg)
----------------------------------------------+---------------------
SourceMapConcat: Concat: App (1)              | 9ms
SourceMapConcat: Concat: Vendor /asset... (1) | 8ms
SimpleConcatConcat: Concat: Vendor Sty... (1) | 4ms
Funnel (7)                                    | 4ms (0 ms)

This tells us that it has spotted that we changed the template and rebuilt and restarted everything. We’ve had zero involvement in that part of it.

Now let’s look at the browser. If you’ve got LiveReload installed and running you will not even have needed to refresh the browser for this to be picked up, otherwise, you will need to reload the current page.

First Change

Not very exciting, but this is with almost no effort on our part that we’ve achieved this.

In addition, we get a fully set up test suite ready to run. This is – unsurprisingly – run using the Ember tool as well, as follows:

$ ember test
⠸ Building'instrument' is imported from external module 'ember-data/-debug' but never used
⠴ BuildingWarning: ignoring input sourcemap for vendor/ember/ember.debug.js because ENOENT: no such file or directory, open '/Users/coxg/source/me/writing/repos/dice-roller/tmp/source_map_concat-input_base_path-S8aQFGaz.tmp/vendor/ember/ember.debug.map'
⠇ BuildingWarning: ignoring input sourcemap for vendor/ember/ember-testing.js because ENOENT: no such file or directory, open '/Users/coxg/source/me/writing/repos/dice-roller/tmp/source_map_concat-input_base_path-wO8OLEE2.tmp/vendor/ember/ember-testing.map'
cleaning up...
Built project successfully. Stored in "/Users/coxg/source/me/writing/repos/dice-roller/tmp/class-tests_dist-PUnMT5zL.tmp".
ok 1 PhantomJS 2.1 - ESLint | app: app.js
ok 2 PhantomJS 2.1 - ESLint | app: resolver.js
ok 3 PhantomJS 2.1 - ESLint | app: router.js
ok 4 PhantomJS 2.1 - ESLint | tests: helpers/destroy-app.js
ok 5 PhantomJS 2.1 - ESLint | tests: helpers/module-for-acceptance.js
ok 6 PhantomJS 2.1 - ESLint | tests: helpers/resolver.js
ok 7 PhantomJS 2.1 - ESLint | tests: helpers/start-app.js
ok 8 PhantomJS 2.1 - ESLint | tests: test-helper.js

1..8
# tests 8
# pass  8
# skip  0
# fail  0

# ok

Note that the output talks about PhantomJS. This is because there is full support for Integration tests that run in a browser, and by default, these run headless in the PhantomJS browser. There is full support for running them in other browsers if you wish, and when setting up continuous integration (CI) it is worth doing this to ensure that your application works correctly in all supported browsers.

How an Ember.js app is structured

Before we get to actually writing our application, let’s explore how it is structured on the filesystem. The ember new command above will have created a whole directory structure on your computer, with lots of different parts. Understanding all of these is important to efficiently work with the tool and create amazing projects.

Continue reading %Ember.js: The Perfect Framework for Web Applications%


Source: Sitepoint

Learn a CSS Framework in 6 Minutes with Bulma

In this tutorial, we’ll be getting started with Bulma, a modern CSS Framework built on Flexbox. For best results, follow along with the above video by OpenSource Craft. If you want to learn why you should care about Bulma, check out this video.

We’ll be building a Coding Quotes page, utilizing Bulma’s UI components including a Hero banner, Columns, Cards, Buttons and more.

Continue reading %Learn a CSS Framework in 6 Minutes with Bulma%


Source: Sitepoint

Symfony Flex: Paving the Path to a Faster, Better Symfony

Symfony Flex is a modern replacement for the Symfony Installer, and not the name of the next Symfony version. As the intro text says:

Internally, Symfony Flex is a Composer plugin that modifies the behavior of the require and update commands. When installing or updating dependencies in a Flex-enabled application, Symfony can perform tasks before and after the execution of Composer tasks.

The new Symfony will be called just Symfony 4, and while this tutorial will deal only with the Flex tool, it will mention some Symfony 4 upgrades as well.


Still Under Development

Symfony Flex can be considered a Composer wrapper, in that it provides your Symfony project with additional options during installation and configuration. It was developed with simplicity in mind, and obviously heavily influenced by the user-friendliness of Laravel. Remember, Laravel got to its current level of popularity due to its ease of use and the low entry barrier it provides newcomers with, and Symfony wanted to emulate this.

It should be noted that both Flex and Symfony 4 are still under development, slated for release somewhere at the end of November this year (2017). As such, some of the features mentioned in this post may have changed by the time you read it, but we’ll do our best to keep it up to date.

Most notably, the use of a makefile and the make tool to build a project if Symfony/Console is unavailable is still up in the air, as it seems to not be working properly on some operating systems. Fabien recently held a survey around this, asking for the community’s suggestions to a replacement, and overwhelmingly, the community voted in favor of just making Symfony/Console required.

Survey result

What’s Different?

Most notably, Flex respects the coming Symfony 4 updates which boil down to the following major changes:

  • PHP 7+ is required
  • all folders are optional. If your project isn’t using one, it doesn’t have to be there. This makes the directory tree much simpler and more readable. Additionally, often useless files like .htaccess, LICENSE, and README have been removed as well – a project which needs those can easily add them.
  • there is no more web folder. Instead, there is the public folder, like in all other major frameworks. This consolidates user experience across ecosystems.
  • temporary files go under /var in the root of the project folder, with the /var/cache subfolder reserved for long term cache, like merged class files for deploying apps as read-only artifacts
  • source code goes under /src. No /app.
  • configuration goes into /config.
  • templates go into /templates.
  • Flex will have its own Symfony-verified list of packages that are referenced by one and one alias alone. So executing composer require cli will actually trigger Flex, which will look in its list of packages, find the one tagged as cli (in this case, Symfony Console), and install it. These “official” packages are called recipes, and can be found here. To accept user-submitted recipes, a flag exists in Flex’s configuration which needs to be set to true: composer config extra.symfony.allow-contrib true. Those recipes can be found here. By officially endorsing some packages, Symfony is in many ways becoming as opinionated as Laravel. While this is bad in some ways, it’s very good in many more ways: a consolidated, opinionated way to build Symfony apps used by most people so that everyone is on the same page.
  • bundle fragments no longer need to be custom-activated and added into a ton of files. Flex automates this, as well as their removal.
  • instead of parameters in config files, Symfony 4 will be using environment variables like Laravel

Bootstrapping

As usual, we’ll assume you’re already running a healthy VM environment like Homestead Improved so you can follow along.

Okay, let’s get our hands dirty with an example app. All Symfony apps can now be started from the bare bones super-minimal Symfony Skeleton app:

 composer create-project symfony/skeleton flexy

Notice the created directory structure.

Directory structure

In /public, we no longer have app.php and app_dev.php, only the index.php file. The type of the environment (test / dev / prod) is now dictated with environment variables, and reads the configuration from the /config folder.

Notice how the end of the installation process mentions that make cache-warmup was called, and that you can run make serve. This is where the new Symfony uses the “controversial” Makefile approach mentioned above. This might change.

Out of the box, opening this skeleton in the browser will throw an error because no routes have been defined yet. Let’s fix this.

index:
    path: /
    defaults: { _controller: 'AppControllerDefaultController::index' }

config/routes.yaml

We’ll need to create this controller and its index action:

<?php

namespace AppController;
use SymfonyComponentHttpFoundationResponse;

class DefaultController
{
    public function index()
    {
        return new Response('Hello');
    }
}

This will produce a simple Hello screen, like so:

Hello Symfony

Execution Permissions

If you try to install a binary like the Symfony/Console with composer req cli, you might run into the following problem:

~ bin/console
-bash: bin/console: Permission denied

This is a known hiccup when using virtual machines, and can be easily fixed by either:

  • running the console with php bin/console instead of running it directly, or
  • adding the “execute” permission to the file on the host machine (not from within the virtual machine), by executing: chmod +x bin/console. This will allow the direct execution of bin/console from within the VM then.

Continue reading %Symfony Flex: Paving the Path to a Faster, Better Symfony%


Source: Sitepoint

How to Write Beautiful Sass

The following is a short extract from our book, Jump Start Sass, written by Hugo Giraudel and Miriam Suzanne. It’s the ultimate beginner’s guide to Sass. SitePoint Premium members get access with their membership, or you can buy a copy in stores worldwide.

Clean, beautiful code should be a goal in every project. If other developers need to make a change, they should be able to read what is there and understand it. Readable code is the core of maintainability, and the first step towards readable code is a good linter. Like a good spell-checker, the linter should catch all your small typos and formatting mistakes, so it’s not left to others to do so. It’s the first line of defense before a good code review with other developers.

There are several great linters for Sass: scss-lint is a Ruby gem, and the newer sasslint and stylelint, which are npm packages for Node. Both allow you to configure linting rules for your project, such as maximum nesting levels, leading zeros on decimals, and organization of properties in a block. You can even create your own rules as needed.

Sass Guidelines are handy for organizing your project, setting up your linters, establishing naming conventions, and so on. Written by Hugo, it’s an opinionated styleguide for your code; it might not all work for you, but it’s a great place to start.

If you’re using Sass variables, functions, and mixins, it’s recommended that you document how they work. Toolkit authors will find it particularly important, but anyone who has extensive tooling built into their projects should also consider documentation for their team. Another great tool from Hugo is SassDoc, an npm package that parses your Sass comments and generates a beautiful static site with your documentation.

Here’s the SassDoc comment for our tint(..) function in Accoutrement-Colors. It starts with a general description, and then explicitly documents each parameter and the expected return:

 /// Mix a color with `white` to get a lighter tint.
///
/// @param {String | list} $color -
///   The name of a color in your palette,
///   with optional adjustments in the form of `(<function-name>:<args>)`.
/// @param {Percentage} $percentage -
///   The percentage of white to mix in.
///   Higher percentages will result in a lighter tint.
///
/// @return {Color} -
///   A calculated css-ready color-value based on your global color palette.
@function tint(
  $color,
  $percentage
) {
  /* … */
}

Using the default theme (from which there are several to choose, or you can design your own), SassDoc converts that comment into a static website, as shown below.

Continue reading %How to Write Beautiful Sass%


Source: Sitepoint

Best Affiliate WooCommerce Plugins Compared

WooCommerce and WordPress have become a powerful combination for online commerce. Leveraging these two is the perfect combination for selling physical products, digital goods, and services online. It’s certainly no accident that it has become “the most customizable eCommerce platform for building your online business.”

But having the most awesome WooCommerce storefront and the best products may not be all you need to find online business success. You may want to consider an affiliate program to help spread the word and get your business in front of as many eyes as you can.

Let’s take a quick look at some of the best affiliate WooCommerce plugins and how they compare.

Affiliate WooCommerce Plugins You’re Looking For

The following affiliate WooCommerce plugins are what you would usually find in an affiliate solution. There is some deviation among these, but nothing too extreme. You’ll find differences in their feature sets and approaches. From simple to robust, to earning points to multilevel referrals, these are the affiliate WooCommerce plugins you were probably looking for.

Ultimate Affiliate Pro WordPress Plugin

Let’s start with the Ultimate Affiliate Pro WordPress Plugin.

It is easily one of the most robust affiliate WooCommerce plugins as it is integrated with WooCommerce, Easy Digital Downloads, PayPal, and Stripe, and it includes a robust feature set to get your own affiliate program up and running.

Ultimate Affiliate Pro WordPress Plugin

You’ll find all sorts of useful features such as:

  • performance bonuses and banner management
  • unlimited affiliates and special offers
  • rankings and commission levels
  • referrals and social shares
  • PayPal and Stripe Payouts
  • and much, much more

This is one of the best affiliate WooCommerce plugins you’ll find on Envato Market.

If this all wasn’t impressive enough, this also includes free login, register, and account page templates; and connects with the top email marketing platforms like MailChimp, Constant Contact, and many more.

Ultimate Affiliate Pro WordPress Plugin is the ultimate affiliate WordPress plugin.

WooCommerce-Probox

If you’re looking for something a little more WooCommerce centric that offers a unique approach to affiliates, here’s a WordPress plugin you’ll want to check out.

“Your users and visitors can customize the look of the products’ widget to place it into their own web sites and pages by simply copying a line of code into their web pages.”

So instead of providing an affiliate link, you can make a widget generator for users to create custom snippets to be placed and embedded into their website for referrals.

Woocommerce-Probox

Features include:

  • place your widget generator with a simple shortcode
  • add to cart button widget option
  • visual widget options
  • and more

The Woocommerce-Probox takes a clever approach, taking your affiliate program beyond the affiliate link.

WooCommerce Multilevel Referral Plugin

Interested in building a strong referral chain?

The WooCommerce Multilevel Referral Plugin allows affiliates to earn credit points while their followers purchase your products from the existing online store.

Build your affiliate perks through sales.

WooCommerce Multilevel Referral Plugin

Features you’ll find here:

  • set custom credit and redemption limits
  • full admin reporting of registered users
  • global or product specific settings
  • shortcode support
  • and much more

This is a multilevel referral system for WooCommerce, something that’s outside of the typical affiliate transactional system.

WooCommerce Multilevel Referral Plugin is unique in approach and may be exactly what you’re looking for.

SUMO Affiliates – WooCommerce Affiliate System

The SUMO Affiliates – WooCommerce Affiliate System is simple and straightforward.

Its approach is on point:

“…logged in users can apply and become Affiliates and promote the products in the site. Whenever a user purchases a product by using an Affiliate Link, the Affiliate associated with the link will earn commission for the purchase.”

SUMO Affiliates - WooCommerce Affiliate System

This solid solution works with WooCommerce supported themes and also includes:

  • CSV export for unpaid commissions
  • translation and WPML ready
  • affiliate cookie validator
  • affiliate link generator
  • highly customizable
  • affiliate applications
  • affiliate dashboard
  • and much more

If you’re just looking for an affiliate WooCommerce plugin, look no further.

The SUMO Affiliates – WooCommerce Affiliate System hits all the right marks.

Add Some Amazon?

WooCommerce is an excellent platform for selling digital and physical products with WordPress. Adding an affiliate system is an excellent way to increase your reach around the web and reward those who are funneling more sales your way.

But what if you sold your own products and became an affiliate yourself?

RelaZone – Related Amazon Products

By using the RelaZone – Related Amazon Products affiliate WooCommerce plugin, you can advertise Amazon related products with your WooCommerce products.

This solution can be used on any WordPress site, blogs included, but this solution could be a great way to augment your own products.

RelaZone - Related Amazon Products

Features include:

  • post, page, store product display options
  • six front-end templates included
  • Amazon Affiliate compatible
  • link products to keywords
  • 90-day cookies
  • and more

Get some Amazon affiliate traffic on your WordPress site with RelaZone – Related Amazon Products.

Going Fully Affiliate

I’ve always thought of WooCommerce as being a physical and digital marketplace for those creating a product or offering a service.

But that’s not what it is limited to. It can also be used for affiliates.

Let’s face it, Amazon and other marketplaces are full of everything. So what if you offered a niche of particular products? A curation of the tidal wave that comes your way with every product search?

By using the power of WordPress, WooCommerce, and some of the following plugins, you can create a niche portal that has the look, feel, and convenience of a WooCommerce shopping experience, while serving users products from Amazon, Walmart, and others.

WooAffiliates – WordPress Plugin

Of all the affiliate WooCommerce WordPress plugins, this is the most robust of the bunch.

WooAffiliates – WordPress Plugin draws from some of the biggest online names, including Amazon, eBay, and our very own Envato Market.

WooAffiliates - WordPress Plugin

Earn commissions from all, some, or simply one. Features include:

  • easy product import
  • advance search
  • geotargeting
  • bulk import
  • and more

Join the biggest affiliate networks and then get started with the WooAffiliates – WordPress Plugin.

WordPress Monetize Now

You’re using Envato right now. You’ve searched and found your favorites, so why not build out your own affiliate site?

You’ll want to use WordPress Monetize Now.

“It also connects to your Envato account and right in your WordPress admin you’ll have all the statistics of your account and the last statement.”

WordPress Monetize Now

Features include:

  • for both Envato authors and non-authors
  • all-in-one shortcode generator
  • official Envato API v3
  • real-time stats
  • and more

WordPress Monetize Now will help you monetize now!

WPCJ Pro – WooCommerce CJ Affiliate WordPress Plugin

WPCJ Pro – WooCommerce CJ Affiliate WordPress Plugin will convert your WooCommerce store into an affiliate website by CJ.com.

WPCJ Pro - WooCommerce CJ Affiliate WordPress Plugin

Some features include:

  • cron job scheduling
  • automatic import
  • import options
  • and more

Are you a CJ affiliate?

WPCJ Pro – WooCommerce CJ Affiliate WordPress Plugin is your best bet.

Walmart to WooCommerce Affiliate

Just behind Amazon, you’ve got another big player in the online commerce and affiliate game: Walmart.

Wire up your affiliate WooCommerce store with the easy to use Walmart to WooCommerce Affiliate plugin.

Walmart to WooCommerce Affiliate

“Earn Commission by redirecting to Walmart from your WooCommerce site using Walmart affiliate link share id.”

Import products from Walmart into your WooCommerce site based on keyword search.

It’s that simple.

If you’re interested in building your own Walmart affiliate store, Walmart to WooCommerce Affiliate is exactly what you want.

WooCommerce eBay Product Import Manager

WooCommerce eBay Product Import Manager sets up your affiliate site using the eBay Affiliate with eBay Partner Network.

WooCommerce Ebay Product Import Manager

Import products with

  • item and category URLs
  • store and seller name
  • keyboard
  • IDs
  • and more

Start earning commission as an eBay affiliate with WooCommerce eBay Product Import Manager.

Conclusion

Offering an affiliate program for your products and services is an excellent way to leverage grassroots advertisers and help identify where you may want to give more attention. Envato Market offers some solid and unique solutions that are worth serious consideration.

Diving into this comparison of the different affiliate WooCommerce plugins, I was surprised to find affiliate WooCommerce plugins that were built with affiliates in mind. It was honestly something I had never thought of before.

If you’re looking to start your own affiliate program or you’re an affiliate yourself, you’re likely to find the best affiliate WooCommerce plugin here.


Source: Nettuts Web Development