使用区块链存储医疗数据

区块链是否适合公共数据的问题很复杂，没有一刀切的解决方案。但是，可以考虑一些潜在的解决方案：

私有网络：解决围绕区块链技术的隐私问题的一种解决方案是使用私有区块链而不是公共区块链。私有区块链可以提供区块链技术的优势，例如不变性和透明度，同时还可以确保数据的私密性和安全性。
混合方法：另一种选择是使用混合方法，其中敏感数据存储在私有区块链上，非敏感数据存储在公共区块链上。这使您能够享受两种区块链的好处，同时确保敏感信息的安全。
分层架构：分层架构可用于将敏感数据与非敏感数据分离，确保敏感信息安全存储，同时非敏感数据可存储在公共区块链上。
加密：加密可用于确保敏感数据的安全。这可以提供额外的安全层，并有助于防止未经授权访问敏感信息。

智能合约开发

定义用于存储合同所有者、医疗记录、授权用户以及对每条记录的访问限制的变量。 records 和 accessRestrictions 变量是映射、键值存储，其中键和值可以是任何类型。

records 映射将类型为 bytes32 的键映射到类型为 Record 的值，后者是稍后在合约中定义的结构。 authorizedUsers 映射将地址映射到指示用户是否可以访问记录的布尔值。 accessRestrictions 映射将 bytes32 键映射到 Restrictions 类型的值，这也是合约稍后定义的结构。

pragma solidity ^0.7.0;0.7.0;
// 在使用任何智能合约之前彻底审查和测试它是很重要的。

contract MedicalRecord {
    // 合同所有者的地址。
    address private owner;
    // 正在存储的医疗记录。
    mapping(bytes32 => Record) private records;
    // 允许访问记录的授权用户。
    mapping(address => bool) private authorizedUsers;
    // 对每条记录的访问限制。
    mapping(bytes32 => Restrictions) private accessRestrictions;

下面给定的行定义了“Record”和“Restrictions”结构，它们分别用于存储单个医疗记录的数据，以及对单个记录的访问限制。 Record 结构有两个字段：data，它是一个存储实际医疗记录数据的 bytes 值，以及 timestamp，它是一个 uint256 值，它存储记录被添加或上次的时间更新。 Restrictions 结构包含三个字段：authorizedUsers，它是一个映射，用于存储有权访问记录的用户，minRole，它是一个 uint8 值，用于存储访问记录所需的最小角色和 expirationDate，它是一个 uint256 值，用于存储记录的到期日期。

// 用户可以拥有的角色。
    // The data for a single medical record.
    struct Record {
        bytes data;
        uint256 timestamp;
    }

    // 对访问单个记录的限制。
    struct Restrictions {
        // 允许访问记录的用户。
        mapping(address => bool) authorizedUsers;
        // 访问记录所需的最低角色。
        uint8 minRole;
        // The expiration date for the record.
        uint256 expirationDate;
    }

现在，定义一个名为 Roles 的 enum（枚举）类型，用于表示用户可以拥有的不同角色。 enum 具有三个可能的值：Patient、Doctor 和 Administrator。

// 用户可以拥有的角色。
    enum Roles {
        Patient,
        Doctor,
        Administrator
    }

创建一个映射名称“userRoles”，将地址映射到“Roles”类型的值，即之前定义的“enum”。该映射用于存储每个用户的角色。这是它的样子：

// 每个用户的角色。
    mapping(address => Roles) private userRoles;

创建合约的构造函数，在部署合约时调用。构造函数将 owner 变量设置为部署合约的用户的地址。以下是如何做到这一点：

// 构造函数设置合约的所有者。
    constructor() public {
        owner = msg.sender;
    }

现在，创建函数以允许合同所有者授权或撤销用户访问记录的授权并设置用户的角色。 authorizedUsers 映射被更新以反映授权状态的变化。 userRoles 映射也被更新以反映角色的变化。这就是它的样子：

// 只有所有者才能授权用户访问记录。
    function authorizeUser(address user) public onlyOwner {
        authorizedUsers[user] = true;
    }

    // 只有所有者才能取消用户访问记录的授权。
    function removeAuthorization(address user) public onlyOwner {
        authorizedUsers[user] = false;
    }

    // 只有所有者才能设置用户的角色。
    function setUserRole(address user, Roles role) public onlyOwner {
        userRoles[user] = role;
    }

现在，创建一个允许授权用户检索病历的函数。该函数将类型为“bytes32”的键作为输入，用于标识记录。该函数首先使用“records”和“accessRestrictions”映射从存储中检索记录及其限制。该函数然后检查当前时间是否在记录的到期日期之前，用户的角色是否等于或高于访问记录所需的最低角色，以及用户是否有权访问记录。

如果不满足这些条件中的任何一个，该函数将抛出错误。如果满足所有条件，该函数将返回记录的数据。您可能会看到以下内容：

// 如果当前时间在记录的到期日期之前，则只有授权用户才能访问记录
    // 并且用户的角色等于或高于访问记录所需的最低角色。
    function getRecord(bytes32 key) public view onlyAuthorized returns (bytes memory) {
        Record storage record = records[key];
        Restrictions storage restrictions = accessRestrictions[key];
        require(block.timestamp < restrictions.expirationDate, "This record has expired.");
        require(uint8(userRoles[msg.sender]) >= restrictions.minRole, "Your role is not high enough to access this record.");
        require(restrictions.authorizedUsers[msg.sender], "You are not authorized to access this record.");
        return record.data;
    }

setRecord 函数允许所有者添加或更新医疗记录。该函数采用“bytes32”类型的键和记录数据作为输入和到期日期。它看起来像这样：

// 只有所有者可以添加或更新记录。
    function setRecord(bytes32 key, bytes memory data, uint256 expirationDate, uint8 minRole, address[] memory authorizedUsers) public onlyOwner {
        Record storage record = records[key];
        record.data = data;
        record.timestamp = block.timestamp;
        Restrictions storage restrictions = accessRestrictions[key];
        restrictions.expirationDate = expirationDate;
        restrictions.minRole = minRole;
        for (uint i = 0; i < authorizedUsers.length; i++) {
            restrictions.authorizedUsers[authorizedUsers[i]] = true;
        }
    }

deleteRecord 功能允许所有者删除医疗记录。该函数将类型为“bytes32”的键作为输入，并使用“delete”关键字从存储中删除记录及其限制。你可以这样做：

// 只有所有者才能删除记录。
    function deleteRecord(bytes32 key) public onlyOwner {
        delete records[key];
        delete accessRestrictions[key];
    }

以下行定义了两个“修饰符”函数：“onlyOwner”和“onlyAuthorized”。 modifier 是一个函数，可以用来修改其他函数的行为。 onlyOwner 修饰符可以应用于函数以限制函数只能由合约所有者调用。

onlyAuthorized 修饰符可以应用于函数以限制该函数只能由授权用户调用。 modifier 函数使用 require 关键字来强制执行限制。如果不满足 require 语句中指定的条件，该函数将抛出错误。

// 只有所有者才能调用这些函数。
    modifier onlyOwner {
        require(msg.sender == owner, "Only the owner can perform this action.");
        _;
    }

    // 只有授权用户才能调用这些函数。
    modifier onlyAuthorized {
        require(authorizedUsers[msg.sender], "You are not authorized to perform this action.");
        _;
    }
}

完整代码

该合约允许所有者存储医疗记录，对每条记录的访问设置限制，并授权用户访问记录。这些限制包括到期日期、最低要求角色和授权用户列表。合约还有一个映射来存储每个用户的角色。

pragma solidity ^0.7.0;


contract MedicalRecord {
    address private owner;

    mapping(bytes32 => Record) private records;

    mapping(address => bool) private authorizedUsers;

    mapping(bytes32 => Restrictions) private accessRestrictions;

    struct Record {
        bytes data;
        uint256 timestamp;
    }

    struct Restrictions {
        mapping(address => bool) authorizedUsers;
        uint8 minRole;
        uint256 expirationDate;
    }

    enum Roles {
        Patient,
        Doctor,
        Administrator
    }

    mapping(address => Roles) private userRoles;

    constructor() public {
        owner = msg.sender;
    }

    function authorizeUser(address user) public onlyOwner {
        authorizedUsers[user] = true;
    }

    function removeAuthorization(address user) public onlyOwner {
        authorizedUsers[user] = false;
    }

    function setUserRole(address user, Roles role) public onlyOwner {
        userRoles[user] = role;
    }

    function getRecord(bytes32 key) public view onlyAuthorized returns (bytes memory) {
        Record storage record = records[key];
        Restrictions storage restrictions = accessRestrictions[key];
        require(block.timestamp < restrictions.expirationDate, "This record has expired.");
        require(uint8(userRoles[msg.sender]) >= restrictions.minRole, "Your role is not high enough to access this record.");
        require(restrictions.authorizedUsers[msg.sender], "You are not authorized to access this record.");
        return record.data;
    }

    function setRecord(bytes32 key, bytes memory data, uint256 expirationDate, uint8 minRole, address[] memory authorizedUsers) public onlyOwner {
        Record storage record = records[key];
        record.data = data;
        record.timestamp = block.timestamp;
        Restrictions storage restrictions = accessRestrictions[key];
        restrictions.expirationDate = expirationDate;
        restrictions.minRole = minRole;
        for (uint i = 0; i < authorizedUsers.length; i++) {
            restrictions.authorizedUsers[authorizedUsers[i]] = true;
        }
    }

    function deleteRecord(bytes32 key) public onlyOwner {
        delete records[key];
        delete accessRestrictions[key];
    }

    modifier onlyOwner {
        require(msg.sender == owner, "Only the owner can perform this action.");
        _;
    }

    modifier onlyAuthorized {
        require(authorizedUsers[msg.sender], "You are not authorized to perform this action.");
        _;
    }
}

通过Github 获取更多区块链学习资料！

https://github.com/Manuel-yang/BlockChainSelfLearning