def on_get(self, req, res):
LOG.info("v2.market_information.GetAgreement")
if config.IBET_SB_EXCHANGE_CONTRACT_ADDRESS is None and \
config.IBET_MEMBERSHIP_EXCHANGE_CONTRACT_ADDRESS is None and \
config.IBET_CP_EXCHANGE_CONTRACT_ADDRESS is None and \
config.IBET_SHARE_EXCHANGE_CONTRACT_ADDRESS is None:
raise NotSupportedError(method="GET", url=req.path)
# 入力値チェック
request_json = self.validate(req)
# リクエストから情報を抽出
order_id = request_json["order_id"]
agreement_id = request_json["agreement_id"]
exchange_address = to_checksum_address(
request_json["exchange_address"])
# 取引コントラクトに接続
ExchangeContract, exchange = self.exchange_contracts(exchange_address)
# 注文情報の取得
if exchange != "IbetOTCExchange":
maker_address, token_address, _, _, is_buy, _, _ = \
ExchangeContract.functions.getOrder(order_id).call()
else:
maker_address, _, token_address, _, _, _, _ = \
ExchangeContract.functions.getOrder(order_id).call()
is_buy = False
if maker_address == config.ZERO_ADDRESS:
raise InvalidParameterError("Data not found")
# 約定情報の取得
taker_address, amount, price, canceled, paid, expiry = \
ExchangeContract.functions.getAgreement(order_id, agreement_id).call()
if taker_address == config.ZERO_ADDRESS:
raise InvalidParameterError("Data not found")
if is_buy:
buyer_address = maker_address
seller_address = taker_address
else:
buyer_address = taker_address
seller_address = maker_address
res_data = {
"token_address": token_address, # トークンアドレス
"counterpart": taker_address, # Takerのアドレス
"buyer_address": buyer_address, # 買い手EOA
"seller_address": seller_address, # 売り手EOA
"amount": amount, # 約定数量
"price": price, # 約定単価
"canceled": canceled, # 約定取消フラグ
"paid": paid, # 支払済フラグ
"expiry": expiry # 有効期限（unixtime）
}
self.on_success(res, res_data)
def on_post(self, req, res):
session = req.context["session"]
user_req = req.context["data"]
if user_req:
try:
projectinfo_db = Projects.find_by_project_id(
session=session, project_id=user_req.get("project_id"))
projectinfo = projectinfo_db if projectinfo_db else Projects()
projectinfo.user_id = user_req.get("user_id") if user_req.get(
"user_id") else projectinfo.user_id
projectinfo.name = user_req.get("name") if user_req.get(
"name") else projectinfo.name
projectinfo.p_revenue = user_req.get(
"revenue") if user_req.get(
"revenue") else projectinfo.p_revenue
projectinfo.p_net_income = user_req.get(
"net_income") if user_req.get(
"net_income") else projectinfo.p_net_income
projectinfo.p_total_assets = user_req.get(
"total_assets") if user_req.get(
"total_assets") else projectinfo.p_total_assets
projectinfo.fund_source = user_req.get(
"fund_source") if user_req.get(
"fund_source") else projectinfo.fund_source
session.add(projectinfo)
self.on_success(res, None)
except Exception as e:
print(e)
raise InvalidParameterError(req.context["data"])
else:
raise InvalidParameterError(req.context["data"])
def validation(req, res, resource, params):
schema = {'vendor_name': FIELDS['vendor_name'], 'id': FIELDS['id']}
v = Validator(schema)
try:
if not v.validate(req.context['data']):
raise InvalidParameterError(v.errors)
except ValidationError:
raise InvalidParameterError('Invalid Request %s' % req.context)
def on_post(self, req, res):
LOG.info("v2.token.Tokens(POST)")
session = req.context["session"]
# 入力値チェック
request_json = self.validate(req)
contract_address = request_json["contract_address"]
# 既存レコードの存在チェック
_listing = session.query(Listing). \
filter(Listing.token_address == contract_address). \
first()
if _listing is not None:
raise InvalidParameterError("contract_address already exist")
_executable_contract = session.query(ExecutableContract). \
filter(ExecutableContract.contract_address == contract_address). \
first()
if _executable_contract is not None:
raise InvalidParameterError("contract_address already exist")
# token情報をTokenListコントラクトから取得
ListContract = Contract.get_contract(
'TokenList', config.TOKEN_LIST_CONTRACT_ADDRESS)
token = ListContract.functions.getTokenByAddress(
contract_address).call()
# contract_addressの有効性チェック
if token[1] is None or token[1] not in self.available_token_template():
raise InvalidParameterError(
"contract_address is invalid token address")
owner_address = token[2]
# 新規レコードの登録
is_public = request_json["is_public"]
max_holding_quantity = request_json[
"max_holding_quantity"] if "max_holding_quantity" in request_json else None
max_sell_amount = request_json[
"max_sell_amount"] if "max_sell_amount" in request_json else None
listing = Listing()
listing.token_address = contract_address
listing.is_public = is_public
listing.max_holding_quantity = max_holding_quantity
listing.max_sell_amount = max_sell_amount
listing.owner_address = owner_address
session.add(listing)
executable_contract = ExecutableContract()
executable_contract.contract_address = contract_address
session.add(executable_contract)
session.commit()
self.on_success(res)
def on_get(self, req, res, contract_address=None):
LOG.info('v2.token.TransferHistory')
session = req.context["session"]
# 入力値チェック
try:
contract_address = to_checksum_address(contract_address)
if not Web3.isAddress(contract_address):
description = 'invalid contract_address'
raise InvalidParameterError(description=description)
except:
description = 'invalid contract_address'
raise InvalidParameterError(description=description)
# validation
request_json = self.validate(req)
# 取扱トークンチェック
listed_token = session.query(Listing). \
filter(Listing.token_address == contract_address). \
first()
if listed_token is None:
raise DataNotExistsError('contract_address: %s' % contract_address)
# 移転履歴取得
query = session.query(IDXTransfer). \
filter(IDXTransfer.token_address == contract_address). \
order_by(IDXTransfer.id)
list_length = query.count()
if request_json["offset"] is not None:
query = query.offset(request_json['offset'])
if request_json["limit"] is not None:
query = query.limit(request_json['limit'])
transfer_history = query.all()
resp_data = []
for transfer_event in transfer_history:
resp_data.append(transfer_event.json())
data = {
"result_set": {
"count": list_length,
"offset": request_json['offset'],
"limit": request_json['limit'],
"total": list_length
},
"transfer_history": resp_data
}
self.on_success(res, data=data)
def validate_user_create(req, res, resource, params):
schema = {
'username': FIELDS['username'],
'email': FIELDS['email'],
'password': FIELDS['password'],
'info': FIELDS['info']
}
v = Validator(schema)
try:
if not v.validate(req.context['data']):
raise InvalidParameterError(v.errors)
except ValidationError:
raise InvalidParameterError('Invalid Request %s' % req.context)
def process_request(self, req, res):
if req.content_type == 'application/json':
try:
raw_json = req.stream.read()
except Exception:
message = 'Read Error'
raise falcon('Bad request', message)
try:
req.context['data'] = json.loads(raw_json.decode('utf-8'))
except ValueError:
raise InvalidParameterError('No JSON object could be decoded or Malformed JSON')
except UnicodeDecodeError:
raise InvalidParameterError('Cannot be decoded by utf-8')
else:
req.context['data'] = None
def validate_item_request(req, res, resource, params):
schema = {
'cart_id': FIELDS['cart_id'],
'external_id': FIELDS['external_id'],
'name': FIELDS['name'],
'value': FIELDS['value']
}
v = Validator(schema)
try:
if not v.validate(req.context['data']):
raise InvalidParameterError(v.errors)
except ValidationError:
raise InvalidParameterError(req.context)
def validate(req):
request_json = req.context["data"]
if request_json is None:
raise InvalidParameterError
validator = Validator({
"token_address": {
"type": "string",
"empty": False,
"required": True
},
"account_address_list": {
"type": "list",
"schema": {
"type": "string"
},
"empty": False,
"required": True
}
})
if not validator.validate(request_json):
raise InvalidParameterError(validator.errors)
if not Web3.isAddress(request_json["token_address"]):
raise InvalidParameterError
for account_address in request_json["account_address_list"]:
if not Web3.isAddress(account_address):
raise InvalidParameterError
return request_json
def on_get(self, req, res, eth_address=None):
LOG.info('v2.company.CompanyInfo')
if not Web3.isAddress(eth_address):
description = 'invalid eth_address'
raise InvalidParameterError(description=description)
isExist = False
try:
if config.APP_ENV == 'local' or config.COMPANY_LIST_LOCAL_MODE is True:
company_list = json.load(open('data/company_list.json', 'r'))
else:
company_list = \
requests.get(config.COMPANY_LIST_URL, timeout=config.REQUEST_TIMEOUT).json()
except Exception as err:
LOG.error('Failed To Get Data: %s', err)
raise AppError
for company_info in company_list:
if to_checksum_address(company_info['address']) == \
to_checksum_address(eth_address):
isExist = True
self.on_success(res, company_info)
if not isExist:
raise DataNotExistsError('eth_address: %s' % eth_address)
def on_delete(self, req, res, _id):
if _id:
session = req.context['session']
session.query(Customer).filter(Customer._id == _id).delete()
self.on_success(res, None)
else:
raise InvalidParameterError('_id is required')
def on_get(self, req, res, _id):
session = req.context['session']
if _id:
cus = session.query(Customer).get(_id)
self.on_success(res, cus.to_dict())
else:
raise InvalidParameterError('_id is required')
def validate(req):
request_json = {
'cursor': req.get_param('cursor'),
'limit': req.get_param('limit'),
}
validator = Validator({
'cursor': {
'type': 'integer',
'coerce': int,
'min': 0,
'required': False,
'nullable': True,
},
'limit': {
'type': 'integer',
'coerce': int,
'min': 0,
'required': False,
'nullable': True,
},
})
if not validator.validate(request_json):
raise InvalidParameterError(validator.errors)
return validator.document
def on_post(self, req, res):
session = req.context["session"]
user_req = req.context["data"]
if user_req:
user = User()
user.username = user_req["username"]
user.email = user_req["email"]
user.password = hash_password(user_req["password"]).decode("utf-8")
user.info = user_req["info"] if "info" in user_req else None
sid = uuid()
user.sid = sid
user.token = encrypt_token(sid).decode("utf-8")
session.add(user)
userData = {
"username": user.username,
"email": user.email,
"info": user.info,
"_id": sid,
"user_id": user.sid,
"token": user.token
}
self.on_success(res, userData)
else:
raise InvalidParameterError(req.context["data"])
def validate(req):
request_json = {
"offset": req.get_param("offset"),
"limit": req.get_param("limit")
}
validator = Validator({
"offset": {
"type": "integer",
"coerce": int,
"min": 0,
"required": False,
"nullable": True,
},
"limit": {
"type": "integer",
"coerce": int,
"min": 0,
"required": False,
"nullable": True,
},
})
if not validator.validate(request_json):
raise InvalidParameterError(validator.errors)
return validator.document
def on_post(self, req, res):
session = req.context["session"]
user_req = req.context["data"]
if user_req:
userinfo_db = UserInfo.find_by_user_id(session=session,
user_id=user_req["user_id"])
if userinfo_db:
userinfo = userinfo_db
else:
raise UserNotExistsError("user id: %s" % user_req["user_id"])
userinfo.user_id = user_req["user_id"]
userinfo.address = user_req.get("address") if user_req.get(
"address") else userinfo.address
userinfo.dob = user_req.get("dob") if user_req.get(
"dob") else userinfo.dob
userinfo.contact = user_req.get("contact") if user_req.get(
"contact") else userinfo.contact
userinfo.nationality = user_req.get("nationality") if user_req.get(
"nationality") else userinfo.nationality
userinfo.profile_strength = user_req.get(
"profile_strength") if user_req.get(
"profile_strength") else userinfo.profile_strength
userinfo.verified = user_req.get("verified") if user_req.get(
"verified") is not None else userinfo.verified
session.add(userinfo)
self.on_success(res, None)
else:
raise InvalidParameterError(req.context["data"])
def validate(req):
request_json = {
"account_address": req.get_param("account_address"),
"agent_address": req.get_param("agent_address")
}
validator = Validator({
"account_address": {
"type": "string",
"empty": False,
"required": True
},
"agent_address": {
"type": "string",
"empty": False,
"required": True
}
})
if not validator.validate(request_json):
raise InvalidParameterError(validator.errors)
if not Web3.isAddress(request_json["account_address"]):
raise InvalidParameterError
if not Web3.isAddress(request_json["agent_address"]):
raise InvalidParameterError
return request_json
def validate(req):
request_json = req.context["data"]
if request_json is None:
raise InvalidParameterError
validator = Validator({
"account_address": {
"type": "string"
},
"token_address": {
"type": "string",
"empty": False,
"required": True
},
"order_type": {
"type": "string",
"empty": False,
"required": True,
"allowed": ["buy", "sell"]
},
})
if not validator.validate(request_json):
raise InvalidParameterError(validator.errors)
if not Web3.isAddress(request_json["token_address"]):
raise InvalidParameterError
if "account_address" in request_json:
if not Web3.isAddress(request_json["account_address"]):
raise InvalidParameterError
return request_json
def exchange_contracts(exchange_address):
if config.IBET_SB_EXCHANGE_CONTRACT_ADDRESS is not None and \
exchange_address == to_checksum_address(config.IBET_SB_EXCHANGE_CONTRACT_ADDRESS):
ExchangeContract = Contract.get_contract(
"IbetStraightBondExchange", exchange_address)
exchange = "IbetStraightBondExchange"
elif config.IBET_MEMBERSHIP_EXCHANGE_CONTRACT_ADDRESS is not None and \
exchange_address == to_checksum_address(config.IBET_MEMBERSHIP_EXCHANGE_CONTRACT_ADDRESS):
ExchangeContract = Contract.get_contract("IbetMembershipExchange",
exchange_address)
exchange = "IbetMembershipExchange"
elif config.IBET_CP_EXCHANGE_CONTRACT_ADDRESS is not None and \
exchange_address == to_checksum_address(config.IBET_CP_EXCHANGE_CONTRACT_ADDRESS):
ExchangeContract = Contract.get_contract("IbetCouponExchange",
exchange_address)
exchange = "IbetCouponExchange"
elif config.IBET_SHARE_EXCHANGE_CONTRACT_ADDRESS is not None and \
exchange_address == to_checksum_address(config.IBET_SHARE_EXCHANGE_CONTRACT_ADDRESS):
ExchangeContract = Contract.get_contract("IbetOTCExchange",
exchange_address)
exchange = "IbetOTCExchange"
else:
raise InvalidParameterError(description="Invalid Address")
return ExchangeContract, exchange
def on_get(self, req, res, contract_address=None):
LOG.info("v2.token.TransferApprovalHistory")
db_session = req.context["session"]
# Validation
try:
contract_address = to_checksum_address(contract_address)
if not Web3.isAddress(contract_address):
raise InvalidParameterError("invalid contract_address")
except:
raise InvalidParameterError("invalid contract_address")
request_json = self.validate(req)
# Check that it is a listed token
_listed_token = db_session.query(Listing). \
filter(Listing.token_address == contract_address). \
first()
if _listed_token is None:
raise DataNotExistsError(f"contract_address: {contract_address}")
# Get transfer approval data
query = db_session.query(IDXTransferApproval). \
filter(IDXTransferApproval.token_address == contract_address). \
order_by(IDXTransferApproval.application_id)
list_length = query.count()
# パラメータを設定
if request_json["offset"] is not None:
query = query.offset(request_json["offset"])
if request_json["limit"] is not None:
query = query.limit(request_json["limit"])
transfer_approval_history = query.all()
resp_data = []
for transfer_approval_event in transfer_approval_history:
resp_data.append(transfer_approval_event.json())
data = {
"result_set": {
"count": list_length,
"offset": request_json['offset'],
"limit": request_json['limit'],
"total": list_length
},
"transfer_approval_history": resp_data
}
self.on_success(res, data=data)
def authorised_user(req, res, resource, params):
auth_required(req, res, resource, params)
try:
user_db = User.find_by_sid(req.context["session"], req.context["auth_user"])
if int(user_db.user_id) != int(req.context["data"]["user_id"]):
raise UnauthorizedUser()
except KeyError:
raise InvalidParameterError(req.context["data"])
def validate_user_create(req, res, resource=None, params=None):
schema = {
'username': FIELDS['username'],
'email': FIELDS['email'],
'password': FIELDS['password'],
'role': FIELDS['role'],
'phone': FIELDS['phone'],
'is_active': FIELDS['is_active']
}
v = Validator(schema)
v.schema = {}
v.allow_unknown = True
try:
if not v.validate(req.context['data']):
raise InvalidParameterError(v.errors)
except ValidationError:
raise InvalidParameterError('Invalid Request %s' % req.context)
def validate_user_create(req, res, resource, params):
schema = {
"email": FIELDS["email"],
"password": FIELDS["password"],
}
v = Validator(schema)
if not v.validate(req.context["data"]):
raise InvalidParameterError(v.errors)
def on_get(self, req, res):
LOG.info('v2.token.MembershipTokens')
session = req.context["session"]
if config.MEMBERSHIP_TOKEN_ENABLED is False:
raise NotSupportedError(method='GET', url=req.path)
# Validation
request_json = MembershipTokens.validate(req)
# TokenList-Contractへの接続
ListContract = Contract.get_contract(
'TokenList', config.TOKEN_LIST_CONTRACT_ADDRESS)
# 取扱トークンリストを取得
available_tokens = session.query(Listing).\
filter(Listing.is_public == True).\
order_by(Listing.id).\
all()
list_length = len(available_tokens)
if request_json['cursor'] is not None and request_json['cursor'] > list_length:
raise InvalidParameterError("cursor parameter must be less than token list num")
# パラメータを設定
cursor = request_json['cursor']
if cursor is None:
cursor = list_length
limit = request_json['limit']
if limit is None:
limit = 10
token_list = []
count = 0
# TokenListを降順に調べる(登録が新しい順)
for i in reversed(range(0, cursor)):
if count >= limit:
break
# TokenList-Contractからトークンの情報を取得する
token_address = to_checksum_address(available_tokens[i].token_address)
token = ListContract.functions. \
getTokenByAddress(token_address).call()
token_detail = MembershipTokenDetails.get_token_detail(
session=session,
token_id=i,
token_address=token[0],
token_template=token[1]
)
if token_detail is not None:
token_list.append(token_detail)
count += 1
self.on_success(res, token_list)
def on_get(self, req, res, contract_address=None):
LOG.info('v2.token.ShareTokenDetails')
if config.SHARE_TOKEN_ENABLED is False:
raise NotSupportedError(method='GET', url=req.path)
# 入力アドレスフォーマットチェック
try:
contract_address = to_checksum_address(contract_address)
if not Web3.isAddress(contract_address):
description = 'invalid contract_address'
raise InvalidParameterError(description=description)
except:
description = 'invalid contract_address'
raise InvalidParameterError(description=description)
session = req.context["session"]
# 取扱トークン情報を取得
# NOTE:非公開トークンも取扱対象とする
listed_token = session.query(Listing).\
filter(Listing.token_address == contract_address). \
first()
if listed_token is None:
raise DataNotExistsError('contract_address: %s' % contract_address)
# TokenList-Contractへの接続
ListContract = Contract.get_contract('TokenList', config.TOKEN_LIST_CONTRACT_ADDRESS)
# TokenList-Contractからトークンの情報を取得する
token_address = to_checksum_address(contract_address)
token = ListContract.functions.getTokenByAddress(token_address).call()
token_detail = self.get_token_detail(
session=session,
token_address=token_address,
token_template=token[1]
)
if token_detail is None:
raise DataNotExistsError('contract_address: %s' % contract_address)
self.on_success(res, token_detail)
def on_put(self, req, res):
session = req.context['session']
request = req.context['data']
if request:
if request['id'] != None:
Vendors.find_update(session, request['id'], request)
self.on_success(res, None)
else:
raise InvalidParameterError(req.context['data'])
def on_post(self, req, res):
session = req.context['session']
request = req.context['data']
if request:
data = Transaction_Types()
data.transaction_type_name = request['transaction_type_name']
session.add(data)
self.on_success(res, None)
else:
raise InvalidParameterError(req.context['data'])
def on_post(self, req, res):
session = req.context['session']
request = req.context['data']
if request:
data = Vendors()
data.vendor_name = request['vendor_name']
session.add(data)
self.on_success(res, None)
else:
raise InvalidParameterError(req.context['data'])
def on_get(self, req, res, contract_address=None):
LOG.info('v2.token.TokenStatus')
# 入力アドレスフォーマットチェック
try:
contract_address = to_checksum_address(contract_address)
if not Web3.isAddress(contract_address):
description = 'invalid contract_address'
raise InvalidParameterError(description=description)
except:
description = 'invalid contract_address'
raise InvalidParameterError(description=description)
session = req.context["session"]
# 取扱トークンチェック
listed_token = session.query(Listing).filter(Listing.token_address == contract_address).first()
if listed_token is None:
raise DataNotExistsError('contract_address: %s' % contract_address)
# TokenList-Contractへの接続
ListContract = Contract.get_contract('TokenList', config.TOKEN_LIST_CONTRACT_ADDRESS)
# TokenList-Contractからトークンの情報を取得する
token_address = to_checksum_address(contract_address)
token = ListContract.functions.getTokenByAddress(token_address).call()
token_template = token[1]
try:
# Token-Contractへの接続
TokenContract = Contract.get_contract(token_template, token_address)
status = TokenContract.functions.status().call()
transferable = TokenContract.functions.transferable().call()
except Exception as e:
LOG.error(e)
raise DataNotExistsError('contract_address: %s' % contract_address)
response_json = {
'status': status,
'transferable': transferable
}
self.on_success(res, response_json)
def on_post(self, req, res):
session = req.context['session']
request = req.context['data']
if request:
data = Devices()
data.device_name = request['device_name']
data.description=request['description']
session.add(data)
self.on_success(res, None)
else:
raise InvalidParameterError(req.context['data'])