问“现在”这个关键词use.how我能做吗？

EN

pragma solidity >0.4.0 ;
pragma experimental ABIEncoderV2;

// 代币系统
contract Token {

    uint tokenTotal;    // 代币总和
    uint tokenPrice;    // 代币价格
    uint balanceTokens; // 合约余额

    // 所有用户余额记录
    mapping(address=>uint) public  balances;

    event buySuccess(address addr, uint num);
    event sellSuccess(address addr, uint num);

    // 获取余额信息 [代币总和 代币价格 合约余额 合约金币 用户余额 用户金币]
    function getBalanceInfo() public view returns (
        uint, uint, uint, uint, uint, uint) {
        return (tokenTotal, tokenPrice,
                balanceTokens, address(this).balance,
                balances[msg.sender], msg.sender.balance);
    }

    // 买入代币
    function buy() public payable {
        uint tokensToBuy = msg.value / tokenPrice;
        require(tokensToBuy <= balanceTokens); // 合约代币是否足够

        // 更新信息
        balances[msg.sender] += tokensToBuy;
        balanceTokens -= tokensToBuy;
        emit buySuccess(msg.sender, tokensToBuy);
    }

    // 卖出代币
    function sell(uint tokensToSell) public {
        require(tokensToSell <= balances[msg.sender]); // 用户代币是否足够

        // 更新信息
        uint total = tokensToSell * tokenPrice;
        balances[msg.sender] -= tokensToSell;
        balanceTokens += tokensToSell;
        payable(msg.sender).transfer(total);
        emit sellSuccess(msg.sender, tokensToSell);
    }
}
contract pile is Token{
    struct owners{
        uint[] publishedpiles;//已经发表的桩
        uint[] borrowedpiles;//已经出借的桩
        uint[] returnedpiles;//已经还了的桩
        uint[] commentedpiles;//已评论的桩
    }
    uint public time;
    struct pile{
        address owner;//桩拥有者的名字
        string location;//桩地址
        string style;//充电桩类型
        string availabletime;//充电桩可用时间段
        string ISBN;//充电桩桩号
        string intro;//充电桩简介
        string cover;//充电桩图片
        string status;//充电桩状态(0：在架；1：借阅)
        uint price;//充电桩价格
        uint publishDate;//充电桩上架时间
        uint score;//充电桩评分
        uint comment;//充电桩评论个数
        mapping(uint => Comment) comments;//评价列表
        mapping(uint => BorrowNums) borrowNums;
    }

    struct Comment {
        address user; // 借阅者
        uint date;      // 评价日期
        uint score;     // 评分
        string content; // 评论正文
    }

    struct BorrowNums{
        uint borrowNum;//出借次数
    }
    function getDate() internal returns(uint)
    {
        time = block.timestamp;
        return(time);
    }
    pile[] piles;
    uint tempNum = 1;
    mapping(address => owners) pilesPool;
    //发布成功
    event publishpileSuccess(uint id, string location, string style, string availabletime,
        string ISBN,string intro, string cover, uint price, string status,
        uint publishDate);
    //图充电桩评价成功
    event evaluateSuccess(uint id,address addr,uint score);
    //借充电桩成功
    event borrowSuccess(uint id, address addr,uint price);
    //还充电桩成功
    event returnpileSuccess(uint id, address addr);
     
    //获取已经被借阅的充电桩单
    function getBorrowedpiles() public view returns (uint[] memory){
        return pilesPool[msg.sender].borrowedpiles;
    }
    //获取已经被评论过的充电桩
    function getCommentedpile() public view returns(uint[] memory){
        return pilesPool[msg.sender].commentedpiles;
    }
    //获取发布的充电桩籍
    function getPublishedpiles() public view returns(uint[] memory){
        return pilesPool[msg.sender].publishedpiles;
    }
    //获取还的充电桩
    function getReturnedpiles() public view returns(uint[] memory){
        return pilesPool[msg.sender].returnedpiles;
    }

    //获取充电桩籍数量
    function getpilesLength() public view returns(uint){
        return piles.length;
    }

    //获取评价数量
    function getCommentLength(uint id) public view returns (uint) {
        return piles[id].comment;
    }

    //获取借阅数据
    function getBorrowNums(uint id) public view returns(uint){
        pile storage pile = piles[id];
        BorrowNums storage b = pile.borrowNums[0];
        return b.borrowNum;
    }

    //获取充电桩信息
    function getpileInfo(uint id) public view returns(address, string memory, string memory, string memory,string memory,string memory,string memory,
        string memory, uint, uint, uint, uint){ 
        require(id < piles.length);
        //获取充电桩,载入合约
        pile storage pile = piles[id];
        return (pile.owner,pile.location,pile.style,pile.availabletime,pile.ISBN,pile.intro,pile.cover,pile.status,
        pile.price,pile.publishDate,pile.score,pile.comment);
    }

    //获得评价消息
    function getCommentInfo(uint pileId,uint commentId) public view returns(
        address, uint, uint, string memory){
        require(pileId < piles.length);
        require(commentId < piles[pileId].comment);
        Comment storage c = piles[pileId].comments[commentId];
        return (c.user, c.date, c.score, c.content);
    }

    // 是否已经评价 通过遍历实现
    function isEvaluated(uint id) public view returns (bool) {
        pile storage pile = piles[id];
        for(uint i = 0; i < pile.comment; i++)
            if(pile.comments[i].user == msg.sender)
                return true; // 已经评价
        return false; // 尚未评价
    }

    // 是否已经借阅 通过遍历实现
    function isBorrowed(uint id) public view returns (bool) {
        owners storage owners = pilesPool[msg.sender];
        for(uint i = 0; i < owners.borrowedpiles.length; i++)
            if(owners.borrowedpiles[i] == id)
                return true; // 已经借阅
        return false; // 尚未借阅
    }

    function isMypile(uint id) public view returns(bool){
        pile storage pile = piles[id];
        if(pile.owner == msg.sender)
            return true;
        return false;
    }

    //查看充电桩是否已经离馆
    function ispileLeft(uint id) public payable returns(bool){
        require(id < piles.length);
        pile storage pile = piles[id];
        if(hashCompareInternal(pile.status,"out"))
            return true;//离馆
        return false;//没有离馆
    }

    //发布充电桩
    function publishpileInfo(string memory location, string memory style, string memory availabletime,string memory ISBN,string memory intro,
        string memory cover,string memory status ,uint price) public {
        uint id = piles.length;
        uint tim= getDate();
        pile memory pile = pile(msg.sender,location,style,availabletime,ISBN,intro,cover,status,price,now,0,0);
        piles.push(pile);
        pilesPool[msg.sender].publishedpiles.push(id);
        emit publishpileSuccess(id,pile.location,pile.style,pile.availabletime,pile.ISBN,pile.intro,pile.cover,
            pile.price,pile.status,pile.publishDate);
    }

    //评价充电桩
    function evaluate(uint id, uint score, string memory content) public{
        require(id < piles.length);
        // 读取合约
        pile storage pile = piles[id];
        //require(pile.owner != msg.sender && !isEvaluated(id)); // 限制条件
        require(0 <= score && score <= 10); // 合法条件
        // 记录评价
        pile.score += score;
        pile.comments[pile.comment++] = Comment(msg.sender, now, score, content);
        pilesPool[msg.sender].commentedpiles.push(id);
        emit evaluateSuccess(id, msg.sender, pile.score);
    }

    //还充电桩
    function returnpile(uint id) public{
        require(id < piles.length);
        pile storage pile = piles[id];
        require(pile.owner != msg.sender && isBorrowed(id)); // 限制条件
        pile.status = "in";
        pilesPool[msg.sender].returnedpiles.push(id);
        emit returnpileSuccess(id, msg.sender);
    }

    //借充电桩
    function borrowedpile(uint id) public{
        require(id < piles.length);
        pile storage pile = piles[id];
        require(pile.owner != msg.sender && !isBorrowed(id)); // 限制条件
        pile.borrowNums[0] = BorrowNums(tempNum++);
        require(balances[msg.sender] >= pile.price); // 合法条件
        balances[msg.sender] -= pile.price;
        balances[pile.owner] += pile.price;
        pilesPool[msg.sender].borrowedpiles.push(id);
        pile.status="out";
        emit borrowSuccess(id, msg.sender,pile.price);

    }

    //字符串比较
    function hashCompareInternal(string memory a, string memory b) internal returns (bool) {
        return keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b));
    }


}