// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
pragma experimental ABIEncoderV2;
import "./SafeMath.sol";
contract ProductManager {
using SafeMath for uint256;
uint256 productNum;
event NewProduct(
string name,
uint8 productMode,
uint8 productType,
uint16 price,
uint16 weight,
uint16 batchNum,
uint256 productNum,
uint256 productionOfDate
);
struct Product {
uint8 productMode; //产品生产方式
uint8 productType; //产品类型
uint16 price; //商品价格
uint16 weight; //商品重量
uint16 batchNum; //批次编号
uint256 productNum; //产品编号
uint256 productionOfDate; //产品生产日期
string name; //产品名称
string photoURL; //商品的照片
bool isUsed; //判断商品是否存在
}
mapping (uint256 => Product) product;
mapping (uint16 => uint256[]) getbatchNumProduct ; //根据商品的批次编号获取所有的商品上链数据
//构造函数
constructor() {
productNum=0;
}
//添加商品数据上链
function addProduct(uint8 _productMode ,uint8 _productType, string memory _name, uint16 _batchNum, uint16 _price, uint16 _weight, uint _productionOfDate,
string memory _photoURL) public {
productNum = productNum.add(1);
Product memory product1 = Product({
productMode: _productMode,
productType: _productType,
price: _price,
weight: _weight,
batchNum: _batchNum,
productNum: productNum,
productionOfDate: _productionOfDate,
name: _name,
photoURL: _photoURL,
isUsed: true
});
product[productNum] = product1;
getbatchNumProduct[_batchNum].push(product1.productNum);
emit NewProduct(_name, _productMode, _productType, _price, _weight, _batchNum, productNum, _productionOfDate);
}
//获取商品溯源信息根据溯源码编号
function getProductData(uint256 _productId) public view returns(Product memory) {
require(_productId>0,"The parameter must be greater than 0!");
Product memory pro = product[_productId];
return pro;
}
//根据批次编号获取所有的商品上链的编码数据
function getProductBybatchNum(uint16 _batchNum) public view returns (uint256[] memory) {
return getbatchNumProduct[_batchNum];
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
pragma experimental ABIEncoderV2;
contract SellerManager {
event NewSeller(
address owner,
uint8 sellerType,
uint16 sellerNum,
uint256 productNum,
string sellerName,
string sellerPhone
);
struct Seller { //销售商结构体数据
address owner; //销售商钱包地址
uint8 sellerType; //销售商类型
uint16 sellerNum; //销售商编号
uint256 productNum; //溯源的商品编号
string sellerName; //销售商负责人姓名
string sellerPhone; //销售商负责人电话号码
}
mapping (uint256 => Seller[]) sellerDatas;
mapping (uint16 => uint256[]) getSellerProduct ; //根据销售商编号获取所有商品上链数据
//增加零售商数据上链
function addSeller (uint8 _sellerType, uint16 _sellerNum, uint256 _productNum, string memory _sellerName,string memory _sellerPhone) public {
Seller memory sel = Seller({
owner: msg.sender,
sellerType: _sellerType,
sellerNum: _sellerNum,
productNum: _productNum,
sellerName: _sellerName,
sellerPhone: _sellerPhone
});
sellerDatas[_productNum].push(sel);
getSellerProduct[_sellerNum].push(sel.productNum);
emit NewSeller(msg.sender, _sellerType, _sellerNum,_productNum, _sellerName, _sellerPhone);
}
//根据商品的编号获取零售商数据
function getSeller(uint256 _productNum) public view returns(Seller[] memory) {
require(_productNum>0,"The parameter must be greater than 0!");
Seller[] memory sel = sellerDatas[_productNum];
return sel;
}
//根据销售商编号获取所有的商品上链的编码数据
function getProductBySeller(uint16 _sellerNum) public view returns (uint256[] memory) {
return getSellerProduct[_sellerNum];
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
pragma experimental ABIEncoderV2;
contract LogisticsManager {
enum State { Provider, Seller}
event NewLogistics(
address owner,
uint8 transportationMode,
uint256 productNum,
string logisticsPeopleName,
string logisticsPhone,
string trafficToolsNum
);
struct Logistics {
address owner; //物流运输者钱包地址
uint8 transportationMode; //运输方式
uint16 logisticsNum; //运输商编号
uint256 productNum; //运输的产品编号
uint256 date; //装货时间
uint256 endOfDate; //卸货时间
string trafficToolsNum; //运输工具编号
string origin; //装货地
string destination; //卸货地
string logisticsPeopleName; //运输负责人姓名
string logisticsPhone; //运输人电话
State state; //物流状态
}
mapping (uint256 => Logistics[]) logisticsDatas;
mapping (uint16 => uint256[]) getLogisticsProduct ; //根据物流商编号获取所有商品上链数据
//增加物流中转运输信息
function addLogistics(uint8 _transportationMode, uint16 _logisticsNum, uint256 _productNum, string memory _trafficToolsNum,string memory _origin,
string memory _destination, uint256 _date, uint256 _endOfDate,string memory _logisticsPeopleName,string memory _logisticsPhone, State _state) public {
Logistics memory log= Logistics({
owner: msg.sender,
transportationMode: _transportationMode,
logisticsNum: _logisticsNum,
productNum: _productNum,
date: _date,
endOfDate: _endOfDate,
trafficToolsNum: _trafficToolsNum,
origin: _origin,
destination: _destination,
logisticsPeopleName: _logisticsPeopleName,
logisticsPhone: _logisticsPhone,
state: _state
});
logisticsDatas[_productNum].push(log);
getLogisticsProduct[_logisticsNum].push(log.productNum);
emit NewLogistics(msg.sender, _transportationMode, _productNum, _logisticsPeopleName, _logisticsPhone, _trafficToolsNum);
}
//通过商品的编号获得物流相关信息
function getLogistics(uint256 _productNum) public view returns(Logistics[] memory) {
require(_productNum>0,"The parameter must be greater than 0!");
Logistics[] memory node = logisticsDatas[_productNum];
return node;
}
//根据物流商编号获取所有的商品上链的编码数据
function getProductByLogistics(uint16 _logisticsNum) public view returns (uint256[] memory) {
return getLogisticsProduct[_logisticsNum];
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
pragma experimental ABIEncoderV2;
contract ProviderManager{
event NewProvider(
address owner,
uint16 provideNum,
string ownerName,
string phoneNum,
uint256 productNum
);
struct Provider { //生产商结构体数据
address owner; //生产商钱包地址
uint16 providerNum; //生产商编号
uint256 productNum; //生产商生产的商品编号
string ownerName; //生产商负责人姓名
string phoneNum; //生产商电话号码
bool test;
}
mapping (uint256 => Provider) provider;
mapping (uint16 => uint256[]) getProviderProduct ; //根据生产商编号获取所有商品上链数据
//增加商品生产商数据上链
function addProvider (uint16 _providerNum, uint256 _productNum, string memory _ownerName,string memory _phoneNum) public {
Provider memory pro = Provider({
owner: msg.sender,
providerNum: _providerNum,
productNum: _productNum,
ownerName: _ownerName,
phoneNum: _phoneNum,
test: true
});
provider[_productNum] = pro;
getProviderProduct[_providerNum].push(pro.productNum);
emit NewProvider(msg.sender, _providerNum, _ownerName, _phoneNum, _productNum);
}
//根据商品的编号获取提供商信息
function getProvider(uint256 _productNum) public view returns(Provider memory) {
require(_productNum>0,"The parameter must be greater than 0!");
Provider memory pro = provider[_productNum];
return pro;
}
//根据生产商编号获取所有的商品上链的编码数据
function getProductByProvider(uint16 _providerNum) public view returns (uint256[] memory) {
return getProviderProduct[_providerNum];
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "./ProductManager.sol";
import "./SellerManager.sol";
import "./LogisticsManager.sol";
import "./ProviderManager.sol";
contract trace is ProductManager, SellerManager,LogisticsManager, ProviderManager {
address private owner;
ProductManager productManager;
ProviderManager providerManager;
LogisticsManager logisticsManager;
SellerManager sellerManager;
modifier onlyOwner() {
require(msg.sender == owner);
_; // _ 表示我们继续执行我们的函数
}
//构造函数
constructor(address product, address provider,address logistics,address seller) {
owner = msg.sender;
productManager = ProductManager(product);
providerManager = ProviderManager(provider);
logisticsManager = LogisticsManager(logistics);
sellerManager = SellerManager(seller);
}
//只有合约所有者才有权限调用这个函数
function changeAddress(address product, address provider,address logistics,address seller) public onlyOwner {
productManager = ProductManager(product);
providerManager = ProviderManager(provider);
logisticsManager = LogisticsManager(logistics);
sellerManager = SellerManager(seller);
}
//获取商品溯源信息根据溯源码编号
function getProductTraceInfor(uint256 _productId) public view returns (Provider memory, Product memory, Logistics[] memory , Seller[]memory) {
return (providerManager.getProvider(_productId), productManager.getProductData(_productId),logisticsManager.getLogistics(_productId),sellerManager.getSeller(_productId));
}
}
溯源智能合约 Solidity
于 2022-09-16 13:39:34 首次发布