class AMDevice(db.Model):
__tablename__ = 'amdevice'
id = db.Column(db.Integer(), primary_key=True)
wallet_id = db.Column(db.Integer,
db.ForeignKey('amwallet.id'),
nullable=False)
wallet = db.relationship('AMWallet',
backref=db.backref('devices', lazy='joined'))
date = db.Column(db.DateTime())
app_version = db.Column(db.String())
os = db.Column(db.String())
os_version = db.Column(db.String())
manufacturer = db.Column(db.String())
brand = db.Column(db.String())
device_id = db.Column(db.String())
def __init__(self, wallet, app_version, os, os_version, manufacturer,
brand, device_id):
self.wallet = wallet
self.date = datetime.datetime.now()
self.app_version = app_version
self.os = os
self.os_version = os_version
self.manufacturer = manufacturer
self.brand = brand
self.device_id = device_id
def __repr__(self):
return "<AMDevice %r %r>" % (self.brand, self.device_id)
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
@classmethod
def from_name(cls, session, name):
return session.query(cls).filter(cls.name == name).first()
def __str__(self):
return self.name
class PayDbTransaction(db.Model):
ACTION_ISSUE = "issue"
ACTION_TRANSFER = "transfer"
ACTION_DESTROY = "destroy"
id = db.Column(db.Integer, primary_key=True)
token = db.Column(db.String(255), unique=True, nullable=False)
date = db.Column(db.DateTime())
action = db.Column(db.String(255), nullable=False)
sender_token = db.Column(db.String(255), db.ForeignKey('user.token'), nullable=False)
sender = db.relationship('User', foreign_keys=[sender_token], backref=db.backref('sent', lazy='dynamic'))
recipient_token = db.Column(db.String(255), db.ForeignKey('user.token'), nullable=True)
recipient = db.relationship('User', foreign_keys=[recipient_token], backref=db.backref('recieved', lazy='dynamic'))
amount = db.Column(db.Integer())
attachment = db.Column(db.String(255))
def __init__(self, action, sender, recipient, amount, attachment):
self.token = secrets.token_urlsafe(8)
self.date = datetime.datetime.now()
self.action = action
self.sender = sender
self.recipient = recipient
self.amount = amount
self.attachment = attachment
@property
def timestamp(self):
if not self.date:
return 0
return int(datetime.datetime.timestamp(self.date))
@classmethod
def from_token(cls, session, token):
return session.query(cls).filter(cls.token == token).first()
@classmethod
def related_to_user(cls, session, user, offset, limit):
# pylint: disable=no-member
return session.query(cls).filter(or_(cls.sender_token == user.token, cls.recipient_token == user.token)).order_by(cls.id.desc()).offset(offset).limit(limit)
@classmethod
def all(cls, session):
return session.query(cls).all()
def __str__(self):
return self.token
def to_json(self):
tx_schema = PayDbTransactionSchema()
return tx_schema.dump(self)
class Role(db.Model, RoleMixin):
ROLE_ADMIN = 'admin'
ROLE_PROPOSER = 'proposer'
ROLE_AUTHORIZER = 'authorizer'
ROLE_REFERRAL_CLAIMER = 'referral_claimer'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
@classmethod
def from_name(cls, session, name):
return session.query(cls).filter(cls.name == name).first()
def __str__(self):
return f'{self.name}'
class Category(db.Model):
CATEGORY_MARKETING = 'marketing'
CATEGORY_MISC = 'misc'
CATEGORY_TESTING = 'testing'
CATEGORY_REFERRAL = 'referral'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
@classmethod
def from_name(cls, session, name):
return session.query(cls).filter(cls.name == name).first()
def __str__(self):
return f'{self.name}'
class Permission(db.Model):
PERMISSION_RECIEVE = 'receive'
PERMISSION_BALANCE = 'balance'
PERMISSION_HISTORY = 'history'
PERMISSION_TRANSFER = 'transfer'
PERMISSION_ISSUE = 'issue'
PERMS_ALL = [PERMISSION_BALANCE, PERMISSION_HISTORY, PERMISSION_ISSUE, PERMISSION_RECIEVE, PERMISSION_TRANSFER]
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
@classmethod
def from_name(cls, session, name):
return session.query(cls).filter(cls.name == name).first()
def __str__(self):
return f'{self.name}'
import base58
import qrcode
import qrcode.image.svg
from wtforms.validators import DataRequired
from app_core import app, db, aw, mail
from utils import generate_key, ib4b_response, bankaccount_is_valid, blockchain_transactions, apply_merchant_rate, is_email, generate_random_password
logger = logging.getLogger(__name__)
#
# Define models
#
roles_users = db.Table(
'roles_users', db.Column('user_id', db.Integer(),
db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
@classmethod
def from_name(cls, session, name):
return session.query(cls).filter(cls.name == name).first()
def __str__(self):
return self.name
class AMWallet(db.Model):
__tablename__ = 'amwallet'
id = db.Column(db.Integer(), primary_key=True)
address = db.Column(db.String(), unique=True)
def __init__(self, address):
self.address = address
@classmethod
def from_address(cls, session, address):
return session.query(cls).filter(cls.address == address).first()
@classmethod
def with_multiple_devices(cls, session):
ids = []
for wallet in session.query(cls).join(cls.devices).group_by(
cls.id).having(func.count(AMDevice.id) > 1):
ids.append(wallet.id)
return session.query(cls).filter(cls.id.in_(ids))
@classmethod
def initialize_wallet_addresses(cls, session):
# update txs
addrs = {}
try:
node = cfg.node_http_base_url[:-1]
issuer_addr = issuer_address(node, cfg.asset_id)
if not issuer_addr:
return False
limit = 1000
oldest_txid = None
txs_count = None
txs = []
while True:
have_tx = False
txs = blockchain_transactions(node, issuer_addr, limit,
oldest_txid)
for tx in txs:
oldest_txid = tx["id"]
if tx["type"] == 4 and tx["assetId"] == cfg.asset_id:
if 'sender' in tx:
addrs[tx['sender']] = 1
if 'recipient' in tx:
addrs[tx['recipient']] = 1
# reached end of transaction history for this address
if len(txs) < limit:
break
except requests.exceptions.ConnectionError as ex:
logger.error(ex)
return False
# create all the AMWallet and AMDevice db entries
for key, value in addrs.items():
wallet = AMWallet(key)
session.add(wallet)
session.add(
AMDevice(wallet, 'n/a', 'n/a', 'n/a', 'n/a', 'n/a', 'n/a'))
session.commit()
return True
@classmethod
def is_empty(cls, session):
return not session.query(cls).first()
def __repr__(self):
return "<AMWallet %r>" % (self.address)
### helper functions/classes
class ReloadingIterator:
def __init__(self, iterator_factory):
self.iterator_factory = iterator_factory
def __iter__(self):
return self.iterator_factory()
### Define zapsend models
roles_users = db.Table(
'roles_users', db.Column('user_id', db.Integer(),
db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
@classmethod
def from_name(cls, session, name):
return session.query(cls).filter(cls.name == name).first()
def __str__(self):
return self.name
logger = logging.getLogger(__name__)
### helper functions/classes
class ReloadingIterator:
def __init__(self, iterator_factory):
self.iterator_factory = iterator_factory
def __iter__(self):
return self.iterator_factory()
### Define premio stage models
roles_users = db.Table(
'roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id'))
)
class Role(db.Model, RoleMixin):
ROLE_ADMIN = 'admin'
ROLE_PROPOSER = 'proposer'
ROLE_AUTHORIZER = 'authorizer'
ROLE_REFERRAL_CLAIMER = 'referral_claimer'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
@classmethod
def from_name(cls, session, name):
