La función de comprar token no funciona en el contrato inteligente de venta colectiva

Soy nuevo en la cadena de bloques de ethereum. Creé una venta colectiva y un contrato inteligente ERC20 y lo implementé en la red de prueba de rinkeby. La función de transferencia de token ERC20 funciona bien.

Pero cuando verifico la funcionalidad de la función de token de compra. Así que se ejecuta con éxito. Pero cuando reviso su salida en https://rinkeby.etherscan.io/ . Entonces muestra 0 transferencia de token. Y no muestra el precio simbólico en la billetera.

Código de contrato inteligente de Crowd Sale como este: -

pragma solidity ^0.4.2;

import "./DappToken.sol";

contract DappTokenSale {
    address admin;
    DappToken public tokenContract;
    uint256 public tokenPrice;
    uint256 public tokensSold;
    uint256 public decimals;


    event Sell(address _buyer, uint256 _amount);

    function DappTokenSale(DappToken _tokenContract, uint256 _tokenPrice) public {
        admin = msg.sender;
        tokenContract = _tokenContract;
        tokenPrice = _tokenPrice;
    }

    function multiply(uint x, uint y) internal pure returns (uint z) {
        require(y == 0 || (z = x * y) / y == x);
    }

    function buyTokens(address _receiver, uint256 _amount) public payable {
        _amount = msg.value;
        require(_receiver != address(0));
        require(_amount > 0);
        uint256 tokensToBuy = multiply(_amount, (10 ** decimals)) / 1 ether * tokenPrice;
        require(tokenContract.transfer(msg.sender, tokensToBuy));
        tokensSold += _amount;

        emit Sell(msg.sender, tokensToBuy);
    }

  // Ending Token DappTokenSale
    function endSale() public {
            // Require admin
            require (msg.sender == admin);

             // Transfer remaing DappToken to admin
            require(tokenContract.transfer(admin,tokenContract.balanceOf(this)));


            // Destroy Contract
            selfdestruct(admin);
    }
}

Código de solidez de DappToken: -

pragma solidity ^0.4.24;

/**
 * The contractName contract does this and that...
 */

contract DappToken {
    // Name
    string public name = "DappToken";
    // Symbol
    string public symbol = 'DAPP';
    //standard
    string public standard = 'DApp Token v1.0';
    //Decimals
    uint256 public decimals = 18;
    //token price
    uint256 public tokenPrice = 2000; //1 eth = 2000 tokens

    uint256 public totalSupply;

    event Transfer(
        address indexed _form,
        address indexed _to,
        uint256 _value
        );

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


    mapping(address => uint256) public balanceOf;
    mapping(address => mapping (address => uint256)) public allowance;


//  function DappToken (uint256 _intialSupply) public {
//      balanceOf[msg.sender] = _intialSupply;
//      totalSupply = _intialSupply;
//      //allocate the intial supply
//
//  }
    constructor(uint256 _intialSupply) public
            {
                balanceOf[msg.sender] = _intialSupply;
                totalSupply = _intialSupply;
            }

    //Transfar
    function transfer(address _to,uint256 _value) public returns (bool success){
    // Exception if account does not enough
    require(balanceOf[msg.sender] >= _value);
    // Transfar the balance
    balanceOf[msg.sender] -= _value;
    balanceOf[_to] += _value; 

    // Transfar Event
    emit Transfer(msg.sender,_to,_value);

    // Return a boolean
    return true;
    } 

    // approve
    function approve(address _spender,uint256 _value) public returns (bool success){
        //allowence
        allowance[msg.sender][_spender] = _value;

        // Approve event
        emit Approval(msg.sender,_spender,_value);
             return true;

    }
    // transfer form
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        require(_value <= balanceOf[_from]);
        require(_value <= allowance[_from][msg.sender]);
        // change the balance
        balanceOf[_from] -= _value;

        //update the balance
       balanceOf[_to] += _value; 

       allowance[_from][msg.sender] -= _value;

       emit Transfer(_from,_to,_value);


        return true;
    }
}

En realidad, quiero comprar una funcionalidad de token como esta: -

1. Cantidad de token de entrada de usuario (3 éteres).
2. Establecí el precio del token 1 éter = 2000 tokens.
3. Entonces, cuando el usuario ingresa 3 éteres, se transfieren 6000 tokens en su cuenta.

Entonces mi consulta es : -

Consulta-1 : ¿Por qué la función Comprar token no envía 6000 tokens en la cuenta del receptor?

Consulta-1 : ¿Dónde me estoy equivocando en el código de contrato inteligente?