def post(self, request):
data = JSONParser().parse(request)
username = data.get('username')
password = data.get('password')
email = data.get('email')
try:
if username and password and email:
user = User.objects.create_user(username=username,
email=email,
password=password)
if user:
user_dict = {}
user_dict['username'] = username
user = str(user_dict)
user = user.replace('\'', '\"')
#Util.sendMessage(message=user,listner=WalletListener(Util.get_stomp_connection()),destination= '/queue/wallet')
Util.sendMessage(message=user, destination='wallet')
else:
raise ValidationError(
get_env_var('exception.business.user.create'))
else:
raise ValidationError(
get_env_var('exception.validation.user.create'))
return JsonResponse(data=data, safe=False, status=201)
except Exception as e:
track = traceback.format_exc()
print(track)
print("error" + str(e))
raise e
def get(self, request):
print('Started ' + self.__class__.__name__ + ' get method')
try:
network = request.GET.get('network')
wallet_id = request.GET.get('wallet_id')
withsum = request.GET.get('withsum')
withsum = bool(withsum)
print('Started ', self.__class__.__name__, ' wallet_id=%s, withsum=%s, network=%s ' % (str(wallet_id),
bool(str(withsum)),network))
address_list = []
if wallet_id and network :
wallet = HDWallet(wallet_id, db_uri=db_uri)
wallet_address_list = wallet.addresslist()
print('Wallet=%s, with unspent value=%s' %(wallet_id,str(wallet.balance())))
address_list = '|'.join([str(a) for a in wallet_address_list])
block_service_url = get_env_var(
'blockchain.service.url') + '/multiaddr?active=' + address_list
print('service_url for get balance', block_service_url)
resp = requests.get(block_service_url)
print('\nreceived for blcokchain multiaddr resp', resp.status_code)
address_list = json.loads(resp.text)
address_list = self.getunspent(wallet_address_list,address_list,withsum)
return JsonResponse(address_list, safe=False)
else:
raise ValidationError(get_env_var('exception.validation.unspent.no_wallet_or_no_network'))
except ServiceException as e:
track = traceback.format_exc()
print(track)
raise ServiceException(e)
except Exception as e:
track = traceback.format_exc()
print(track)
raise ServiceException(get_env_var('exception.business.unspent.serviceexception'))
def post(self, request):
print("enter sign and send")
try:
data = JSONParser().parse(request)
username = data.get("username")
hex = data.get("hex")
coin_type = data.get("type")
if username and coin_type and hex:
print(username + "username")
service_url = get_env_var(
'service.url'
) + '/address/?action=receive&username='******'&type=' + coin_type
print(service_url + "service_url")
resp = requests.get(service_url, auth=service_auth)
if resp.status_code != 200:
print('address response', resp.text)
raise ServiceException(
get_env_var(
'exception.business.sign.serviceexception'))
else:
print('address response', resp.text)
response_list = json.loads(resp.text)
signsend = SignSendView()
sign_dict_str = signsend.sign_txn(hex, response_list)
print('sign request ' + sign_dict_str)
url = get_url(coin_type, "signtxn")
# url = 'https://66f49c90-24e2-4d2b-891d-5746233c8ae7.mock.pstmn.io/sign'
if coin_type == 'BTC':
resp = requests.post(url,
auth=btc_auth,
data=sign_dict_str)
elif coin_type == 'LTC':
resp = requests.post(url,
auth=ltc_auth,
data=sign_dict_str)
print(resp.status_code)
if resp.status_code != 200:
print('sign response ' + resp.text)
raise ServiceException(
get_env_var(
'exception.business.sign.serviceexception'))
else:
print('sign response ' + resp.text)
response_dict = json.loads(resp.text)
return JsonResponse(response_dict, safe=False)
else:
raise ValidationError(
get_env_var(
'exception.validation.sign.no_user_or_no_coin_type_or_no_hex'
))
except Exception as e:
track = traceback.format_exc()
print(track)
print("error" + str(resp.status_code))
raise e
def post(self,request):
print('Started ' + self.__class__.__name__ + ' get method')
try:
data = JSONParser().parse(request)
network = data.get('network')
hex = data.get('hex')
txn_data = {}
txn_data['wallet_id'] = data.get('wallet_id')
txn_data['type'] = data.get('txn_type')
txn_data['destination'] = data.get('address_id')
txn_data['destination_amount'] = data.get('amount')
txn_data['message'] = data.get('message')
txn_data['includes_fee'] = data.get('includes_fee')
print(' txn with data' + str(data))
if network and hex:
if network == 'bitcoin':
txn_data['network'] = 'btc'
resp = btc_srv.sendrawtransaction(hex)
txn_data['network'] = 'ltc'
elif network == 'litecoin':
resp = ltc_srv.sendrawtransaction(hex)
print('\nreceived for sendrawtransaction resp', resp.status_code, 'response %s' %(resp.text))
if resp.status_code != 200:
Util.sendMessage(message=hex,destination='/queue/txn.failure')
raise ServiceException(get_env_var('exception.business.send.serviceexception'))
else:
if resp.text:
print('saving in txn')
response_dict = json.loads(resp.text)
txn_data['txn_id'] = response_dict['result']
print('saving in txn with data' + str(txn_data))
Util.sendMessage(message=txn_data, destination='/queue/txn')
serializer = TxnSerializer(data=txn_data)
if serializer.is_valid():
serializer.save()
else:
return JsonResponse(serializer.errors, status=400)
return JsonResponse(serializer.data, status=201, safe=False)
else:
raise ServiceException(get_env_var('exception.business.send.serviceexception'))
else:
raise ValidationError(get_env_var('exception.validation.send.no_network_or_no_hex'))
except Exception as e:
track = traceback.format_exc()
logger.exception(track)
print("error" + str(track))
raise e;
def get(self,request):
try:
print('get')
txn_id = request.GET.get('txn_id')
service_url = get_env_var('service.url') + '/txn/'+txn_id
print(service_url + "service_url")
resp = requests.get(service_url, auth=service_auth)
if resp.status_code != 200:
print(str(resp.status_code) + "error")
response_dict = json.loads(resp.text)
else:
txn = ltc_srv.gettransaction(txn_id)
print('text' + str(resp.text))
response_dict = json.loads(resp.text)
response_dict['status'] = txn['status']
resp = requests.post(service_url, auth=service_auth,data=response_dict)
if resp.status_code != 200:
print(str(resp.status_code) + "error")
else:
print('txn_id updated' + str(resp.status_code) + " success")
return JsonResponse({}, safe=False)
except Exception as e:
track = traceback.format_exc()
print(track)
print("error" + str(e))
raise e;
def get(self, request):
print('Started ' + self.__class__.__name__ + ' get method')
try:
wallet_id = request.GET.get('wallet_id')
just_address = request.GET.get('just_address')
print(
'Started ', self.__class__.__name__,
' wallet_id=%s, just_address=%s ' %
(str(wallet_id), bool(str(just_address))))
if wallet_id:
wallet = HDWallet(wallet_id, db_uri=db_uri)
keys = wallet.keys(include_private=True)
keys = [x.__dict__ for x in keys]
address_list = []
if bool(just_address) == True:
for key in keys:
address_list.append(key['address'])
else:
for key in keys:
address_list.append({
'address_id': key['address'],
'private_key': key['private'],
'public_key': key['public']
})
return JsonResponse(address_list, safe=False)
else:
raise ValidationError(
get_env_var('exception.validation.address.no_wallet'))
except Exception as e:
raise e
def getNewAddress(account_id,wallet_id):
try:
wallet = HDWallet(wallet_id, db_uri=db_uri)
address = wallet.new_key(account_id=account_id)
address = Address(address_id=address.address, network_name=address.network_name)
return address
except Exception as e:
raise ServiceException(get_env_var('exception.business.newaddress.dumpkey.serviceexception'))
def reset(request):
token = request.GET.get('token')
email = request.GET.get('email')
service_url = get_env_var(
'service.url') + '/user/password_reset/validate_token/'
print('service_url for validate token', service_url)
raw_data = '{ "token" : "' + token + '" }'
headers = {'content-type': 'application/json'}
resp = requests.post(service_url,
auth=service_auth,
data=raw_data,
headers=headers)
print('received for get address resp', resp.status_code,
' and response %s' % (resp.text))
resp = json.loads(resp.text)
context = resp
context['token'] = token
context['email'] = email
print('context', context)
return render(request, 'change_password.html', context)
def get(self, request, account_id, wallet_id):
try:
logger.debug('Started ', self.__class__.__name__, ' get method')
amount = request.GET.get('amount')
qr = request.GET.get('qr')
print(
'Started ', self.__class__.__name__,
' wallet_id=%s, account_id=%s, qr=%s, amount=%s ' %
(str(wallet_id), str(account_id), bool(qr), str(amount)))
if account_id and wallet_id:
addressimpl = AddressImpl()
address = addressimpl.getNewAddress(account_id, wallet_id)
if address:
response_dict = {
'address_id': address.address_id,
'status': 'success'
}
if qr:
text = address.network_name + ':' + address.address_id + ' amoount:' + str(
amount)
output = Util.generate_qr(text)
print('received for response generate_qr %s' %
(output))
image = QRSerializer(output).data
response_dict['file_type'] = image['file_type']
response_dict['image_base64'] = image['image_base64']
return JsonResponse(response_dict, safe=False)
else:
raise ValidationError(
get_env_var(
'exception.validation.address.no_account_or_no_wallet')
)
except AuthenticationError as e:
raise e
except Exception as e:
raise e
def post(self, request, *args, **kwargs):
print('Started ' + self.__class__.__name__ + ' post method %s' %
(request.data))
try:
serializer = self.serializer_class(data=request.data,
context={'request': request})
if serializer.is_valid():
user = serializer.validated_data['user']
print('Started ' + self.__class__.__name__ + ' post user='******'exception.business.auth.serviceexception'))
else:
token, created = Token.objects.get_or_create(user=user)
is_expired, token = token_expire_handler(token)
return Response({
'username': user.username,
'user_id': user.user_id,
'token': token.key
})
else:
response_dict = {
'status': 'error',
# the format of error message determined by you base exception class
'msg': serializer.errors
}
return JsonResponse(response_dict, status=400)
except Exception as e:
raise e
def post(self, request):
print('Started ' + self.__class__.__name__ + ' get method')
try:
data = JSONParser().parse(request)
network = data.get('network')
output_address = data.get('address_id')
wallet_id = data.get('wallet_id')
send_amount = int(data.get('amount'))
print(
'Started ', self.__class__.__name__,
' wallet_id=%s, withsum=%s, network=%s ' %
(str(wallet_id), (str(output_address)), network))
wallet = HDWallet(wallet_id, db_uri=db_uri)
change_address = wallet.get_key_change()
change_address = change_address.address
print('change_address ', change_address)
if wallet_id:
service_url = get_env_var(
'service.url') + '/unspent/?wallet_id=' + str(
wallet_id) + '&network=' + network
print('service_url for unspent', service_url)
resp = requests.get(service_url, auth=service_auth)
print('received status code for unspent resp',
resp.status_code, ' and response %s' % (resp.text))
if resp.status_code != 200:
raise ServiceException(
get_env_var('exception.business.fee.serviceexception'))
else:
wallet_address_list = json.loads(resp.text)
service_url = get_env_var(
'service.url') + '/address/?wallet_id=' + str(wallet_id)
print('service_url for address', service_url)
resp = requests.get(service_url, auth=service_auth)
print('received status code for address resp',
resp.status_code)
if resp.status_code != 200:
private_input_address_list = json.loads(resp.text)
return JsonResponse(private_input_address_list, safe=False)
else:
private_input_address_list = json.loads(resp.text)
blocks = 2
fee_per_kb = 0
if network == 'bitcoin':
fee_per_kb = btc_srv.estimatefee(blocks)
elif network == 'litecoin':
fee_per_kb = ltc_srv.estimatefee(blocks)
print('Fee per kb %s' % (str(fee_per_kb)))
t = self.create_transaction(wallet_address_list,
private_input_address_list,
output_address, change_address,
send_amount, fee_per_kb,
network)
return JsonResponse(t.as_dict(), safe=False)
else:
raise ValidationError(
get_env_var('exception.validation.fee.no_coin_type'))
except ServiceException as e:
track = traceback.format_exc()
print(track)
raise ServiceException(e)
except Exception as e:
track = traceback.format_exc()
print(track)
return HttpResponse(status=404)
def authenticate(self, request):
try:
print('Started ' + self.__class__.__name__ +
' authenticate method')
key = request.headers.get('Authorization')
print('Started ', self.__class__.__name__, ' key=%s' % (key))
if key == None:
return None
auth_key = key.split(' ')
auth = None
if len(auth_key) > 1:
auth = auth_key[0]
key = auth_key[1]
else:
return None
user = None
if auth == 'Basic':
print('Basic Auth ')
username_password = decode(key)
username = username_password[0]
password = username_password[1]
print('Authentication=', auth, 'key=', key, 'username='******'Authentication', auth, 'key', key, 'username',
username, 'user_id', user.user_id)
if user.check_password(password):
print('user exist from user' + str(user.user_id))
token = Token.objects.filter(user_id=user.user_id)
if token.count() > 0:
token = token[0]
print('token key ' + token.key)
if not is_token_expired(
token
): # The implementation will be described further
print('Basic Auth Authentication Success')
return (token.user, token.key)
else:
print(
'Basic Auth Authentication with token key failure with token expired'
)
#is_expired, token = token_expire_handler(token)
#return (token.user, token.key)
raise AuthenticationError(
get_env_var(
'exception.business.auth.expire.serviceexception'
))
else:
print(
'Basic Auth Authentication with no auth token'
)
token = Token.objects.create(user=user)
return (token.user, token.key)
else:
print('Not authenticated User with password for ' +
user.username)
raise AuthenticationError(
get_env_var(
'exception.business.auth.serviceexception'))
else:
print('No user eist with count zero')
raise AuthenticationError(
get_env_var(
'exception.business.auth.expire.serviceexception'))
else:
print('Authentication', auth, 'key', key)
token = Token.objects.filter(key=key)
if token.count() > 0:
print('Token Authentication')
token = token[0]
# token_expire_handler will check, if the token is expired it will generate new one
if not is_token_expired(
token
): # The implementation will be described further
print('Token Auth Authentication Success')
return (token.user, token)
else:
print(
'Token Auth Authentication failure with token expired'
)
return None
raise AuthenticationError(
get_env_var(
'exception.business.auth.expire.serviceexception'
))
else:
print('Token Authentication with no auth token')
raise AuthenticationError(
get_env_var(
'exception.business.auth.expire.serviceexception'))
except User.DoesNotExist or Token.DoesNotExist or Exception as e:
track = traceback.format_exc()
print('-------track start--------')
print(track)
print('-------track end--------')
return None
raise e
print('Authentication Success')
return user
from altcoin.settings.local import db_uri
from altcoin.user.models import User
from bitcoinlib.db import DbInit, DbNetwork
from bitcoinlib.services.bitcoind import BitcoindClient
from bitcoinlib.services.litecoind import LitecoindClient
import base64
import qrcode
import io
import pika
ltc_auth = HTTPBasicAuth(get_coin_env_var('LTC', 'user'),
get_coin_env_var('LTC', 'password'))
btc_auth = HTTPBasicAuth(get_coin_env_var('BTC', 'user'),
get_coin_env_var('BTC', 'password'))
service_auth = HTTPBasicAuth(get_env_var('service.user'),
get_env_var('service.password'))
btc_srv = BitcoindClient()
ltc_srv = LitecoindClient()
user = os.getenv('ACTIVEMQ_USER') or 'guest'
password = os.getenv('ACTIVEMQ_PASSWORD') or 'guest'
host = os.getenv('ACTIVEMQ_HOST') or 'localhost'
#port = int(os.getenv('ACTIVEMQ_PORT') or 61613)
port = int(os.getenv('ACTIVEMQ_PORT') or 15672)
class Util:
@staticmethod
def sendMessage(message, destination):
print('connect')
def post(self, request):
"""
Retrieve, update or delete a code snippet.
"""
print("enter sign and send")
try:
data = JSONParser().parse(request)
wallet_id = data.get('wallet_id')
username = data.get('username')
hex = data.get('hex')
coin_type = data.get('type')
txn_data = {}
txn_data['username'] = data.get('username')
txn_data['type'] = data.get('txn_type')
txn_data['status'] = data.get('status')
txn_data['source'] = data.get('source')
txn_data['source_amount'] = data.get('source_amount')
txn_data['source_currency'] = data.get('source_currency')
txn_data['destination'] = data.get('destination')
txn_data['destination_amount'] = data.get('destination_amount')
txn_data['destination_currency'] = data.get('destination_currency')
txn_data['message'] = data.get('message')
txn_data['includes_fee'] = data.get('includes_fee')
print(' txn with data' + str(data))
if username and coin_type and hex:
print(username + "username")
service_url = get_env_var(
'service.url') + '/key/?wallet_id=' + str(
wallet_id) + '&type=' + coin_type
print(service_url + "service_url")
resp = requests.get(service_url, auth=service_auth)
if resp.status_code != 200:
print('address response', resp.text)
raise ServiceException(
get_env_var(
'exception.business.sign.serviceexception'))
else:
print('address response', resp.text)
response_list = json.loads(resp.text)
sign_dict_str = self.sign_txn(hex, response_list)
print('sign request ' + sign_dict_str)
url = get_url(coin_type, "signtxn")
# url = 'https://66f49c90-24e2-4d2b-891d-5746233c8ae7.mock.pstmn.io/sign'
if coin_type == 'BTC':
resp = requests.post(url,
auth=btc_auth,
data=sign_dict_str)
elif coin_type == 'LTC':
resp = requests.post(url,
auth=ltc_auth,
data=sign_dict_str)
print(resp.status_code)
if resp.status_code != 200:
print('sign response ' + resp.text)
raise ServiceException(
get_env_var(
'exception.business.sign.serviceexception'))
else:
print('sign response ' + resp.text)
send_dict = json.loads(resp.text)
send_dict_str = self.send_txn(hex, send_dict)
url = get_url(coin_type, 'sendtxn')
# url = 'https://66f49c90-24e2-4d2b-891d-5746233c8ae7.mock.pstmn.io/send'
if coin_type == 'BTC':
resp = requests.post(url,
auth=btc_auth,
data=send_dict_str)
elif coin_type == 'LTC':
resp = requests.post(url,
auth=ltc_auth,
data=send_dict_str)
print(resp.status_code)
if resp.status_code != 200:
print('send error response ' + resp.text +
' with status code' + str(resp.status_code))
Util.sendMessage('send', '/queue/test')
raise ServiceException(
get_env_var(
'exception.business.send.serviceexception')
)
else:
print('send suucess response ' + resp.text +
' with status code' + str(resp.status_code))
Util.sendMessage('send', '/queue/test')
if resp.text:
print('saving in txn')
txn_data['txn_id'] = resp.text
serializer = TxnSerializer(data=txn_data)
if serializer.is_valid():
serializer.save()
else:
print('data invalid')
return JsonResponse(serializer.errors,
status=400)
return JsonResponse(serializer.data,
status=201,
safe=False)
else:
raise ServiceException(
get_env_var(
'exception.business.send.serviceexception'
))
else:
raise ValidationError(
get_env_var(
'exception.validation.sign.no_user_or_no_coin_type_or_no_hex'
))
except Exception as e:
track = traceback.format_exc()
print(track)
print("error" + str(e))
raise e
