Die Kauf-Token-Funktion funktioniert nicht im Crowd-Sale-Smart-Contract

Ich bin neu in der Ethereum-Blockchain. Ich habe einen Crowd-Sale und einen ERC20-Smart-Vertrag erstellt und im Rinkeby-Testnetzwerk bereitgestellt. Die ERC20-Token-Übertragungsfunktion funktioniert einwandfrei.

Aber wenn ich die Funktionalität der Kauf-Token-Funktion überprüfe. Es läuft also erfolgreich. Aber wenn ich es überprüfe, wird es auf https://rinkeby.etherscan.io/ ausgegeben . Es zeigt also 0 Token-Transfer. Und es zeigt keinen Token-Preis auf der Brieftasche.

Crowd Sale Smart-Contract-Code wie folgt:-

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);
    }
}

DappToken Solidity-Code:-

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;
    }
}

Eigentlich möchte ich Token-Funktionalität wie folgt kaufen: -

1. Token-Betrag der Benutzereingabe (3 Ether).
2. Ich habe den Token-Preis auf 1 Ether = 2000 Token gesetzt.
3. Wenn der Benutzer also 3 Ether eingibt, werden 6000 Token auf sein Konto übertragen.

Also meine Frage ist : -

Frage 1 : Warum sendet die Funktion Token kaufen nicht 6000 Token an das Empfängerkonto??

Abfrage-1 : Wo mache ich einen Fehler im Smart Contract Code?