creating crowd sale ERC20 token

I want the latest smart contract in which I am able to create my own ERC20 token and from another account, anyone can buy it and it can be run in a remix

smart-contract has the function of Whitelist, Hard cap, Soft cap, Lockup, Crowd token sales, ETHICAL ICO, Large investor bonus

CONTRIBUTOR & PRIVATE ROUND, PRIVATE ONLY SALE, FIRST CROWD ROUND, VOUCHER SALE

In a simple word if I will say I want to create a smart contract which will create my own ERC20 token and all the feature of ERC20 token 1. Anyone can buy it and sale it (as we set the rate of our ERC20 token) 2. Only Whitelist account can buy it 3. we can set the bonus of your ERC20 token( Large investor bonus, pre-sale, VOUCHER SALE)

Code i have used pragma solidity ^0.4.19;

library SafeMath {

function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
        return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
}

function div(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a / b;
    return c;
}

function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
}

function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
}

}

contract Ownable {

address public owner;

event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

function Ownable() public {
    owner = msg.sender;
}

modifier isOwner() {
    require(msg.sender == owner);
    _;
}

function transferOwnership(address newOwner) public isOwner {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
}

}

contract StandardToken {

using SafeMath for uint256;

event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);

mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;

uint256 public totalSupply;

function totalSupply() public constant returns (uint256 supply) {
    return totalSupply;
}

function transfer(address _to, uint256 _value) public returns (bool success) {
    if (balances[msg.sender] >= _value && _value > 0) {
        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(_value);
        Transfer(msg.sender, _to, _value);
        return true;
    } else { return false; }
}

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
    if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
        balances[_to] = balances[_to].add(_value);
        balances[_from] = balances[_from].sub(_value);
        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
        Transfer(_from, _to, _value);
        return true;
    } else { return false; }
}

function balanceOf(address _owner) public constant returns (uint256 balance) {
    return balances[_owner];
}

function approve(address _spender, uint256 _value) public returns (bool success) {
    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
}

function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
    return allowed[_owner][_spender];
}

}

contract ERC20Token is StandardToken, Ownable {

using SafeMath for uint256;

string public name;
string public symbol;
string public version = '1.0';
uint256 public totalCoin;
uint8 public decimals;
uint8 public exchangeRate;

event TokenNameChanged(string indexed previousName, string indexed newName);
event TokenSymbolChanged(string indexed previousSymbol, string indexed newSymbol);
event ExhangeRateChanged(uint8 indexed previousRate, uint8 indexed newRate);

function ERC20Token() public {
    decimals        = 0;
    totalCoin       = 1070;                       // Total Supply of Coin
    totalSupply     = totalCoin * 10**uint(decimals); // Total Supply of Coin
    balances[owner] = totalSupply;                    // Total Supply sent to Owner's Address
    exchangeRate    = 20;                            // 100 Coins per ETH   (changable)
    symbol          = "VT_qls_TICKER";                       // Your Ticker Symbol  (changable)
    name            = "VT_qls";             // Your Coin Name      (changable)
}

function changeTokenName(string newName) public isOwner returns (bool success) {
    TokenNameChanged(name, newName);
    name = newName;
    return true;
}

function changeTokenSymbol(string newSymbol) public isOwner returns (bool success) {
    TokenSymbolChanged(symbol, newSymbol);
    symbol = newSymbol;
    return true;
}

function changeExhangeRate(uint8 newRate) public isOwner returns (bool success) {
    ExhangeRateChanged(exchangeRate, newRate);
    exchangeRate = newRate;
    return true;
}

function () public payable {
    fundTokens();
}

function fundTokens() public payable {
    require(msg.value > 0);
    uint256 tokens = msg.value.mul(exchangeRate);
    require(balances[owner].sub(tokens) > 0);
    balances[msg.sender] = balances[msg.sender].add(tokens);
    balances[owner] = balances[owner].sub(tokens);
    Transfer(msg.sender, owner, msg.value);
    forwardFunds();
}

function forwardFunds() internal {
    owner.transfer(msg.value);
}

function approveAndCall(
    address _spender,
    uint256 _value,
    bytes _extraData
) public returns (bool success) {
    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    if(!_spender.call(
        bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))),
        msg.sender,
        _value,
        this,
        _extraData
    )) { revert(); }
    return true;
}

}