feat(contract): added new contract

Author: MrSIooth

contract/ILicenka.sol

@@ -1,21 +1,10 @@
 pragma solidity >=0.8.0 <0.9.0;
 // SPDX-License-Identifier: MIT License
 
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "@openzeppelin/contracts/utils/math/SafeMath.sol";
-
 interface ILicenka {
-    function createLicence(address owner, string memory name, uint price, uint duration) external;
+    function createLicense(address owner, string memory name, uint price, uint duration) external;
 
     function subscribe(uint licenseId) external;
 
-    function subscribeWeb2(address owner, uint hash, uint licenseId) external;
-
     function verifySubscription(address owner, uint licenseId) external view returns(bool);
-
-    function verifySubscriptionWeb2(address owner, uint hash, uint licenseId) external view returns(bool);
-
-    function getLicenses(address owner) external view returns(uint[] memory);
-
-    function getSubscriptions(address owner) external view returns(uint[] memory);
 }

contract/Licenka.sol

@@ -3,44 +3,21 @@ pragma solidity >=0.8.0 <0.9.0;
 
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts/utils/math/SafeMath.sol";
-import "./LicenkaPassword.sol";
 import "./ILicenka.sol";
+import "./LicenkaLicense.sol";
+import "./LicenkaSubscription.sol";
 
 /**
 * @dev Licenka is a contract that allows you to create a license.
 */
-contract Licenka is ILicenka, licenkaPassword {
+contract Licenka is ILicenka, LicenkaLicense, LicenkaSubscription {
 
     using SafeMath for uint;
 
     IERC20 public token;
 
-    struct License {
-        string name;
-        address owner;
-        uint price;
-        uint duration;
-    }
-
-    struct LicenseSubscribe {
-        uint licenseId;
-        uint validTime;
-        bool isInfinite;
-    }
-
     address _owner;
-    uint _nextLicenseId = 1;
-    uint _nextLicenseSubscriptionId = 1;
-    uint percentageFee = 3;
-
-    //Licences
-    mapping (uint => License) public licenses;
-    mapping (address => uint[]) _licenseOwner;
-
-    //Subscriptions
-    mapping (uint => LicenseSubscribe) public subscriptions;
-    mapping (address => uint[]) _subscriptionOwner;
-    mapping (address => mapping(uint => uint))  _subcriptionIndex;
+    uint public fee = 3;
 
     /**
     * @dev Check if the caller is the owner of the contract.
@@ -63,7 +40,7 @@ contract Licenka is ILicenka, licenkaPassword {
     */
     function setFee(uint newFee) external isOwner(msg.sender) {
         require(0 <= newFee && newFee <= 100, "The fee must be between 0 and 100");
-        percentageFee = newFee;
+        fee = newFee;
     }
 
     /**
@@ -74,7 +51,7 @@ contract Licenka is ILicenka, licenkaPassword {
     }
 
     /**
-    * @dev Transfert funds from the wallet to a given address. Only callable by the owner.
+    * @dev Transfert funds from the contract to a given address. Only callable by the owner.
     */
     function transferFunds(address dest, uint amount) external isOwner(msg.sender) {
         token.transfer(dest, amount);
@@ -83,98 +60,27 @@ contract Licenka is ILicenka, licenkaPassword {
     /**
     * @dev Create a new license.
     */
-    function createLicence(address owner, string memory name, uint price, uint duration) external {
-        License memory license = License(name, owner, price, duration);
-        licenses[_nextLicenseId] = license;
-        _licenseOwner[owner].push(_nextLicenseId);
-        _nextLicenseId++;
-    }
-
-
-    function _subscribe(address owner, uint licenseId) internal {
-        License memory license = licenses[licenseId];
-        require(license.owner != address(0x0), "Wrong id number"); //Test if license id is valid
-        require(token.allowance(owner, address(this)) >= license.price, "Didn't approve enough fund for the license"); //Test if the user has sufficient fund
-
-        uint index = _subcriptionIndex[owner][licenseId];
-        if (index == 0) { //if First time subscribing, add the licence to array
-            subscriptions[_nextLicenseSubscriptionId] = LicenseSubscribe(licenseId, 0, false);
-            _subscriptionOwner[owner].push(_nextLicenseSubscriptionId);
-            _subcriptionIndex[owner][licenseId] = _nextLicenseSubscriptionId;
-            index = _nextLicenseSubscriptionId;
-            _nextLicenseSubscriptionId++;
-        }
-
-        require(subscriptions[index].isInfinite == false, "Already subcribed");
-        LicenseSubscribe memory subscription_ = subscriptions[index];
-        if (license.duration == 0)
-            subscriptions[index].isInfinite = true;
-        else {
-            uint rootTimestamp = subscription_.validTime < block.timestamp  ? block.timestamp : subscription_.validTime;
-            subscriptions[index].validTime = rootTimestamp + license.duration;
-        }
-        token.transferFrom(owner, address(this), license.price);
-        token.transfer(license.owner, license.price.mul(100 - percentageFee).div(100));
-    }
-
-    /**
-    * @dev Subscribe to a license. With your own wallet
-    */
-    function subscribe(uint licenseId) external {
-        _subscribe(msg.sender, licenseId);
+    function createLicense(address owner, string memory name, uint price, uint duration) override external {
+        _mintLicense(owner, name, price, duration);
     }
 
     /**
-    * @dev Create a new license. With the api call
+    * @dev Subscribe to a license.
     */
-    function subscribeWeb2(address owner, uint hash, uint licenseId) external isPasswordSet(owner) isPasswordMatch(owner, hash) {
-        _subscribe(owner, licenseId);
-    }
+    function subscribe(uint licenseId) override external licenseExist(licenseId) licenseUnpaused(licenseId) {
+        License memory license = licenses[licenseId];
+        require(token.allowance(msg.sender, address(this)) >= license.price, "Didn't approve enough fund for the license"); //Test if the user has sufficient fund
 
-    function _verifySubscription(address owner, uint licenseId) internal view returns(bool) {
-        if (_subcriptionIndex[owner][licenseId] == 0)
-            return false;
-        uint index = _subcriptionIndex[owner][licenseId];
-        LicenseSubscribe memory subscription_ = subscriptions[index];
-        if (subscription_.isInfinite == true)
-            return true;
-        if (subscription_.validTime > block.timestamp)
-            return true;
-        return false;
-    }
+        _subscribe(msg.sender, licenseId, license.duration);
 
-    /**
-    * @dev Verify if a wallet owns a license.
-    */
-    function verifySubscription(address owner, uint licenseId) external view returns(bool) {
-        return _verifySubscription(owner, licenseId);
+        token.transferFrom(msg.sender, address(this), license.price);
+        token.transfer(license.owner, license.price.mul(100 - fee).div(100));
     }
 
     /**
-    * @dev Verify if a wallet owns a license. With the api call
+    * @dev Verify if a wallet is subscribed to a license.
     */
-    function verifySubscriptionWeb2(address owner, uint hash, uint licenseId) external view isPasswordSet(owner) isPasswordMatch(owner, hash) returns(bool) {
+    function verifySubscription(address owner, uint licenseId) override external view licenseExist(licenseId) returns(bool) {
         return _verifySubscription(owner, licenseId);
     }
-
-    /**
-    * @dev Get all owned licenses by a wallet.
-    */
-    function getLicenses(address owner) external view returns(uint[] memory) {
-        return _licenseOwner[owner];
-    }
-
-    /**
-    * @dev Get all owned subscriptions by a wallet.
-    */
-    function getSubscriptions(address owner) external view returns(uint[] memory) {
-        return _subscriptionOwner[owner];
-    }
-
-    /**
-    * @dev Get a wallet subscription for a given license.
-    */
-    function getSubscriptionIdForLicense(address owner, uint licenseId) external view returns(uint) {
-        return _subcriptionIndex[owner][licenseId];
-    }
 }

contract/LicenkaLicense.sol

@@ -0,0 +1,80 @@
+pragma solidity >=0.8.0 <0.9.0;
+// SPDX-License-Identifier: MIT License
+
+import "@openzeppelin/contracts/utils/math/SafeMath.sol";
+
+/**
+* @dev Licenka is a contract that allows you to create a license.
+*/
+contract LicenkaLicense {
+
+    using SafeMath for uint;
+
+    struct License {
+        address owner;
+        string name;
+        uint price;
+        uint duration;
+    }
+
+    event LicenseCreate(address indexed owner, string indexed name, uint price, uint duration);
+    event LicensePause(uint indexed licenseId, bool indexed isPaused);
+
+    uint _nextLicenseId = 1;
+
+    mapping (uint => License) public licenses;
+    mapping (uint => bool) _licensePaused;
+    mapping (address => uint[]) _licenseOwner;
+
+    /**
+    * @dev Modifier msg.sender musdt be the license owner.
+    */
+    modifier licenseOwner(uint licenseId) {
+        require(licenses[licenseId].owner == msg.sender, "You are not the license owner.");
+        _;
+    }
+
+    /**
+    * @dev Modifier license must not be paused.
+    */
+    modifier licenseUnpaused(uint licenseId) {
+        require(_licensePaused[licenseId] == false, "The license is paused.");
+        _;
+    }
+
+    /**
+    * @dev Modifier license must exist.
+    */
+    modifier licenseExist(uint licenseId) {
+        require(0 < licenseId && licenseId < _nextLicenseId, "The license doesn't exist.");
+        _;
+    }
+
+    /**
+    * @dev Create a new license.
+    */
+    function _mintLicense(address owner, string memory name, uint price, uint duration) internal {
+        License memory license = License(owner, name, price, duration);
+        licenses[_nextLicenseId] = license;
+        _licenseOwner[owner].push(_nextLicenseId);
+        _nextLicenseId++;
+
+        emit LicenseCreate(owner, name, price, duration);
+    }
+
+    /**
+    * @dev Set a license pause value to false or true.
+    */
+    function setLicensePause(uint licenseId, bool isPaused) external licenseExist(licenseId) licenseOwner(licenseId) {
+        _licensePaused[licenseId] = isPaused;
+
+        emit LicensePause(licenseId, isPaused);
+    }
+
+    /**
+    * @dev Get the licenses owned by a wallet.
+    */
+    function getLicenses(address owner) external view returns(uint[] memory) {
+        return _licenseOwner[owner];
+    }
+}