# 使用Solidity实现区块链微博

By [haoxueren](https://paragraph.com/@haoxueren) · 2022-12-11

---

    // SPDX-License-Identifier: UNDEFINED
    
    pragma solidity ^0.8.17;
    
    /*
     * 区块链微博程序
     */
    contract MicroBlog {
        address admin;
    
        bool is_running = true;
    
        string app_name; // 应用程序的名称
    
        uint256 blog_id; // 微博ID，从1开始递增
    
        uint256 blog_count; // 微博数量
    
        uint256[] id_array; // 所有微博ID数组
    
        mapping(uint256 => bool) has_id; // 是否包含当前ID
    
        mapping(uint256 => Blog) blogs; // 所有微博集合
    
        event AddBlog(uint256 id, string log); // 发布微博事件
    
        event DeleteBlog(uint256 id, string log); // 删除微博事件
    
        // 微博结构体
        struct Blog {
            uint256 time;
            address owner;
            string content;
        }
    
        constructor() payable {
            admin = msg.sender;
        }
    
        // 设置APP名称
        function setAppName(string memory _name) external {
            app_name = _name;
        }
    
        // 发布一条微博
        function addBlog(string memory _content) public isRunning {
            blog_id++;
            id_array.push(blog_id);
            has_id[blog_id] = true;
            blogs[blog_id] = Blog(block.timestamp, msg.sender, _content);
            emit AddBlog(blog_id, _content);
            blog_count++;
        }
    
        // 删除一条微博
        function delBlogById(uint256 _id) public canAccess(_id) {
            if (has_id[_id]) {
                delete blogs[_id];
                delete has_id[_id];
                blog_count--;
                emit DeleteBlog(_id, blogs[_id].content);
            }
        }
    
        // 根据ID查看微博
        function getBlogById(uint256 id) public view returns (Blog memory) {
            return blogs[id];
        }
    
        // 查询指定用户的所有微博
        function getBlogByAddress(address _address)
            public
            view
            returns (Blog[] memory)
        {
            // 计算该用户的微博数量
            uint256 _user_count;
            for (uint256 i = 0; i < id_array.length; i++) {
                if (has_id[id_array[i]]) {
                    if (blogs[id_array[i]].owner == _address) {
                        _user_count++;
                    }
                }
            }
            // 查询该用户名下的微博
            uint256 index;
            Blog[] memory _blogs = new BlogUnsupported embed;
            for (uint256 i = 0; i < id_array.length; i++) {
                if (has_id[id_array[i]]) {
                    if (blogs[id_array[i]].owner == msg.sender) {
                        _blogs[index] = blogs[id_array[i]];
                        index++;
                    }
                }
            }
            return _blogs;
        }
    
        // 获取所有id
        function getBlogIds() public view returns (uint256[] memory) {
            uint256[] memory _result = new uint256Unsupported embed;
            uint256 index;
            for (uint256 i = 0; i < id_array.length; i++) {
                if (has_id[id_array[i]]) {
                    _result[index] = id_array[i];
                    index++;
                }
            }
            return _result;
        }
    
        // 所有微博数量
        function getBlogCount() public view returns (uint256) {
            return blog_count;
        }
    
        // 设置合约运行状态
        function setIsRunning(bool _running) public isAdmin {
            is_running = _running;
        }
    
        // 变更合约的管理员
        function changeOwner(address _newOwner) external {
            admin = _newOwner;
        }
    
        // 只有合约管理员才可以提取资金
        function withdraw(uint256 _amount) public payable isAdmin {
            payable(admin).transfer(_amount);
        }
    
        // 只有合约管理员才可以提取全部资金
        function withdrawAll() public payable isAdmin {
            payable(admin).transfer(address(this).balance);
        }
    
        // 销毁合约
        function destruct() public isAdmin {
            selfdestruct(payable(admin));
        }
    
        // 是否为合约管理员
        modifier isAdmin() {
            require(msg.sender == admin, "must be admin!");
            _;
        }
    
        // 合约是否在正常运行
        modifier isRunning() {
            require(is_running, "contract is stopped!");
            _;
        }
    
        // 用户仅可操作自己的微博(管理员除外)
        modifier canAccess(uint256 _id) {
            require(
                msg.sender == admin || msg.sender == blogs[_id].owner,
                "permission denied!"
            );
            _;
        }
    }

---

*Originally published on [haoxueren](https://paragraph.com/@haoxueren/solidity)*