class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
token = db.Column(db.String(255), unique=True, nullable=False)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255))
mobile_number = db.Column(db.String(255))
address = db.Column(db.String(255))
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer)
active = db.Column(db.Boolean())
fs_uniquifier = db.Column(db.String(255), unique=True, nullable=False)
confirmed_at = db.Column(db.DateTime())
tf_totp_secret = db.Column(db.String(255))
tf_primary_method = db.Column(db.String(255))
tf_phone_number = db.Column(db.String(255))
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
photo = db.Column(db.String())
photo_type = db.Column(db.String(255))
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.token = secrets.token_urlsafe(8)
@classmethod
def from_email(cls, session, email):
return session.query(cls).filter(cls.email == email).first()
def __str__(self):
return f'{self.email}'
class Proposal(db.Model):
STATE_CREATED = "created"
STATE_AUTHORIZED = "authorized"
STATE_DECLINED = "declined"
STATE_EXPIRED = "expired"
HOURS_EXPIRY = 72
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime(), nullable=False)
proposer_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
proposer = db.relationship('User',
foreign_keys=[proposer_id],
backref=db.backref('proposals', lazy='dynamic'))
reason = db.Column(db.String())
authorizer_id = db.Column(db.Integer, db.ForeignKey('user.id'))
authorizer = db.relationship('User',
foreign_keys=[authorizer_id],
backref=db.backref('proposals_authorized',
lazy='dynamic'))
date_authorized = db.Column(db.DateTime())
date_expiry = db.Column(db.DateTime())
status = db.Column(db.String(255))
categories = db.relationship('Category',
secondary=categories_proposals,
backref=db.backref('proposals',
lazy='dynamic'))
def __init__(self, proposer, reason):
self.generate_defaults()
self.proposer = proposer
self.reason = reason
def generate_defaults(self):
self.date = datetime.datetime.now()
self.proposer = current_user
self.authorizer = None
self.date_authorized = None
self.date_expiry = None
self.status = self.STATE_CREATED
@classmethod
def count(cls, session):
return session.query(cls).count()
@classmethod
def in_status(cls, session, status):
return session.query(cls).filter(cls.status == status).all()
def __repr__(self):
return "<Proposal %r>" % (self.id)
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 ApiKeyRequest(db.Model):
MINUTES_EXPIRY = 30
id = db.Column(db.Integer, primary_key=True)
token = db.Column(db.String(255), unique=True, nullable=False)
secret = db.Column(db.String(255), unique=True, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship('User', backref=db.backref('api_key_requests', lazy='dynamic'))
device_name = db.Column(db.String(255))
expiry = db.Column(db.DateTime())
created_api_key_id = db.Column(db.Integer, db.ForeignKey('api_key.id'))
created_api_key = db.relationship('ApiKey')
def __init__(self, user, device_name):
self.token = secrets.token_urlsafe(8)
self.secret = secrets.token_urlsafe(16)
self.user = user
self.device_name = device_name
self.expiry = datetime.datetime.now() + datetime.timedelta(self.MINUTES_EXPIRY)
@classmethod
def from_token(cls, session, token):
return session.query(cls).filter(cls.token == token).first()
def __str__(self):
return self.token
class UserUpdateEmailRequest(db.Model):
MINUTES_EXPIRY = 30
id = db.Column(db.Integer, primary_key=True)
token = db.Column(db.String(255), unique=True, nullable=False)
email = db.Column(db.String(255))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship('User', backref=db.backref('update_email_requests', lazy='dynamic'))
expiry = db.Column(db.DateTime())
def __init__(self, user, email):
self.token = secrets.token_urlsafe(8)
self.user = user
self.email = email
self.expiry = datetime.datetime.now() + datetime.timedelta(self.MINUTES_EXPIRY)
@classmethod
def from_email(cls, session, email):
return session.query(cls).filter(cls.email == email).first()
@classmethod
def from_token(cls, session, token):
return session.query(cls).filter(cls.token == token).first()
def __str__(self):
return self.email
class ApiKey(db.Model):
id = db.Column(db.Integer, primary_key=True)
token = db.Column(db.String(255), unique=True, nullable=False)
secret = db.Column(db.String(255), nullable=False)
nonce = db.Column(db.BigInteger, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship('User', backref=db.backref('api_keys', lazy='dynamic'))
device_name = db.Column(db.String(255))
expiry = db.Column(db.DateTime())
permissions = db.relationship('Permission', secondary=permissions_api_keys,
backref=db.backref('api_keys', lazy='dynamic'))
def __init__(self, user, device_name):
self.user_id = user.id
self.token = secrets.token_urlsafe(8)
self.secret = secrets.token_urlsafe(16)
self.nonce = 0
self.device_name = device_name
self.expiry = datetime.datetime.now() + datetime.timedelta(30)
def has_permission(self, permission_name):
perm = Permission.from_name(db.session, permission_name)
if perm:
return perm in self.permissions # pylint: disable=unsupported-membership-test
return False
@classmethod
def from_token(cls, session, token):
return session.query(cls).filter(cls.token == token).first()
class ClaimCode(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship('User',
backref=db.backref('claimcodes', lazy='dynamic'))
date = db.Column(db.DateTime())
token = db.Column(db.String(255), unique=True, nullable=False)
secret = db.Column(db.String(255))
amount = db.Column(db.Integer)
address = db.Column(db.String(255))
status = db.Column(db.String(255))
def __init__(self, user, token, amount):
self.user = user
self.date = datetime.datetime.now()
self.token = token
self.secret = None
self.amount = amount
self.address = None
self.status = "created"
@classmethod
def count(cls, session):
return session.query(cls).count()
@classmethod
def from_token(cls, session, token):
return session.query(cls).filter(cls.token == token).first()
def __repr__(self):
return "<ClaimCode %r>" % (self.token)
def to_json(self):
schema = ClaimCodeSchema()
return schema.dump(self).data
class Referral(db.Model):
STATUS_CREATED = 'created'
STATUS_CLAIMED = 'claimed'
STATUS_DELETED = 'deleted'
REWARD_TYPE_PERCENT = 'percent'
REWARD_TYPE_FIXED = 'fixed'
REWARD_TYPES_ALL = [REWARD_TYPE_PERCENT, REWARD_TYPE_FIXED]
id = db.Column(db.Integer, primary_key=True)
token = db.Column(db.String(255), unique=True, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship('User', backref=db.backref('referrals', lazy='dynamic'))
date = db.Column(db.DateTime(), nullable=False)
recipient = db.Column(db.String, nullable=False)
reward_sender_type = db.Column(db.String(255), nullable=False)
reward_sender = db.Column(db.Integer, nullable=False)
reward_recipient_type = db.Column(db.String(255), nullable=False)
reward_recipient = db.Column(db.Integer, nullable=False)
recipient_min_spend = db.Column(db.Integer, nullable=False)
status = db.Column(db.String, nullable=False)
def __init__(self, user, recipient, reward_sender_type, reward_sender, reward_recipient_type, reward_recipient, recipient_min_spend):
assert reward_sender_type == self.REWARD_TYPE_FIXED
assert reward_recipient_type in self.REWARD_TYPES_ALL
self.token = secrets.token_urlsafe(8)
self.user = user
self.date = datetime.datetime.now()
self.recipient = recipient
self.reward_sender_type = reward_sender_type
self.reward_sender = reward_sender
self.reward_recipient_type = reward_recipient_type
self.reward_recipient = reward_recipient
self.recipient_min_spend = recipient_min_spend
self.status = self.STATUS_CREATED
def to_json(self):
ref_schema = ReferralSchema()
return ref_schema.dump(self).data
@classmethod
def from_token(cls, session, token):
return session.query(cls).filter(cls.token == token).first()
@classmethod
def from_token_user(cls, session, token, user):
return session.query(cls).filter(and_(cls.token == token, cls.user_id == user.id)).first()
@classmethod
def from_user(cls, session, user):
return session.query(cls).filter(cls.user_id == user.id).all()
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 User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
@classmethod
def from_email(cls, session, email):
return session.query(cls).filter(cls.email == email).first()
def __str__(self):
return self.email
class TxNotification(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship('User', backref=db.backref('txnotifications', lazy='dynamic'))
date = db.Column(db.DateTime())
txid = db.Column(db.String(255), unique=True)
def __init__(self, user, txid):
self.user = user
self.date = datetime.datetime.now()
self.txid = txid
@classmethod
def exists(cls, session, txid):
return session.query(cls).filter(cls.txid == txid).first()
@classmethod
def count(cls, session):
return session.query(cls).count()
def __repr__(self):
return "<TxNotification %r>" % (self.txid)
class UserCreateRequest(db.Model):
MINUTES_EXPIRY = 30
id = db.Column(db.Integer, primary_key=True)
token = db.Column(db.String(255), unique=True, nullable=False)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255))
mobile_number = db.Column(db.String(255))
address = db.Column(db.String(255))
photo = db.Column(db.String())
photo_type = db.Column(db.String(255))
password = db.Column(db.String(255))
expiry = db.Column(db.DateTime())
def __init__(self, first_name, last_name, email, mobile_number, address, photo, photo_type, password):
self.token = secrets.token_urlsafe(8)
self.first_name = first_name
self.last_name = last_name
self.email = email
self.mobile_number = mobile_number
self.address = address
self.photo = photo
self.photo_type = photo_type
self.password = password
self.expiry = datetime.datetime.now() + datetime.timedelta(self.MINUTES_EXPIRY)
@classmethod
def from_email(cls, session, email):
return session.query(cls).filter(cls.email == email).first()
@classmethod
def from_token(cls, session, token):
return session.query(cls).filter(cls.token == token).first()
def __str__(self):
return self.email
class ApiKey(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship('User',
backref=db.backref('apikeys', lazy='dynamic'))
date = db.Column(db.DateTime(), nullable=False)
name = db.Column(db.String(255), nullable=False)
token = db.Column(db.String(255), unique=True, nullable=False)
nonce = db.Column(db.Integer, nullable=False)
secret = db.Column(db.String(255), nullable=False)
account_admin = db.Column(db.Boolean, nullable=False)
def __init__(self, name):
self.name = name
self.generate_defaults()
def generate_defaults(self):
self.user = current_user
self.date = datetime.datetime.now()
self.token = generate_key(8)
self.nonce = 0
self.secret = generate_key(16)
@classmethod
def count(cls, session):
return session.query(cls).count()
@classmethod
def from_token(cls, session, token):
return session.query(cls).filter(cls.token == token).first()
@classmethod
def admin_exists(cls, session, user):
return session.query(cls).filter(cls.user == user,
cls.account_admin == True).first()
def __repr__(self):
return "<ApiKey %r>" % (self.token)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
bronze_data = db.relationship('BronzeData',
cascade='delete',
backref=db.backref('user'),
uselist=False)
def __init__(self, **kwargs):
super().__init__(**kwargs)
@classmethod
def from_email(cls, session, email):
return session.query(cls).filter(cls.email == email).first()
def __str__(self):
return '%s' % self.email
class Utility(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime(), nullable=False)
name = db.Column(db.String(255), nullable=False)
description = db.Column(db.Text())
bank_description = db.Column(db.Text(), nullable=False)
def __init__(self, name):
self.generate_defaults()
def generate_defaults(self):
self.date = datetime.datetime.now()
@classmethod
def count(cls, session):
return session.query(cls).count()
@classmethod
def all(cls, session):
return session.query(cls).all()
@classmethod
def all_alphabetical(cls, session):
return session.query(cls).order_by(cls.name).all()
@classmethod
def from_id(cls, session, utility_id):
return session.query(cls).filter(cls.id == utility_id).first()
@classmethod
def jsonify_bank_descriptions(cls, utilities):
for utility in utilities:
utility.bank_description_json = json.loads(
utility.bank_description)
def __repr__(self):
return "<Utility %r>" % (self.name)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
merchant_name = db.Column(db.String(255))
merchant_code = db.Column(db.String(255), unique=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
max_settlements_per_month = db.Column(db.Integer)
settlement_fee = db.Column(db.Numeric)
merchant_rate = db.Column(db.Numeric)
customer_rate = db.Column(db.Numeric)
wallet_address = db.Column(db.String(255))
def __init__(self, **kwargs):
self.merchant_code = generate_key(4)
super().__init__(**kwargs)
def on_admin_created(self):
self.merchant_code = generate_key(4)
self.password = encrypt_password(generate_random_password(16))
self.confirmed_at = datetime.datetime.now()
self.active = True
@classmethod
def from_email(cls, session, email):
return session.query(cls).filter(cls.email == email).first()
@classmethod
def all(cls, session):
return session.query(cls).all()
def __str__(self):
return '%s (%s)' % (self.merchant_code, self.merchant_name)
class UserStashRequest(db.Model):
MINUTES_EXPIRY = 30
ACTION_SAVE = 'save'
ACTION_LOAD = 'load'
id = db.Column(db.Integer, primary_key=True)
key = db.Column(db.String)
email_hash = db.Column(db.String, nullable=False)
iv = db.Column(db.String)
cyphertext = db.Column(db.String)
question = db.Column(db.String)
action = db.Column(db.String)
token = db.Column(db.String, unique=True)
secret = db.Column(db.String)
expiry = db.Column(db.DateTime())
created_stash_id = db.Column(db.Integer, db.ForeignKey('user_stash.id'))
created_stash = db.relationship('UserStash', foreign_keys=[created_stash_id])
loaded_stash_id = db.Column(db.Integer, db.ForeignKey('user_stash.id'))
loaded_stash = db.relationship('UserStash', foreign_keys=[loaded_stash_id])
def __init__(self, key, email, iv, cyphertext, question, action):
self.key = key
self.email_hash = sha256(email)
self.iv = iv # pylint: disable=invalid-name
self.cyphertext = cyphertext
self.question = question
self.action = action
self.token = secrets.token_urlsafe(8)
self.secret = secrets.token_urlsafe(16)
self.expiry = datetime.datetime.now() + datetime.timedelta(self.MINUTES_EXPIRY)
@classmethod
def from_token(cls, session, token):
return session.query(cls).filter(cls.token == token).first()
class PushNotificationLocation(db.Model):
id = db.Column(db.Integer, primary_key=True)
fcm_registration_token = db.Column(db.String, nullable=False)
latitude = db.Column(db.Float, nullable=False)
longitude = db.Column(db.Float, nullable=False)
date = db.Column(db.DateTime(), nullable=False)
def __init__(self, registration_token, latitude, longitude):
self.fcm_registration_token = registration_token
self.update(latitude, longitude)
def update(self, latitude, longitude):
self.latitude = latitude
self.longitude = longitude
self.date = datetime.datetime.now()
@classmethod
def from_token(cls, session, token):
return session.query(cls).filter(cls.fcm_registration_token == token).first()
@classmethod
def tokens_at_location(cls, session, latitude, max_lat_delta, longitude, max_long_delta, max_age_minutes):
since = datetime.datetime.now() - datetime.timedelta(minutes=max_age_minutes)
return session.query(cls).filter(and_(cls.date >= since, and_(and_(cls.latitude <= latitude + max_lat_delta, cls.latitude >= latitude - max_lat_delta), and_(cls.longitude <= longitude + max_long_delta, cls.longitude >= longitude - max_long_delta)))).all()
class Invoice(db.Model):
STATUS_CREATED = "Created"
STATUS_READY = "Ready"
STATUS_INCOMING = "Incomming" #sp :(
STATUS_CONFIRMED = "Confirmed"
STATUS_PAYOUTWAIT = "PayoutWait"
STATUS_SENT = "Sent"
STATUS_EXPIRED = "Expired"
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime(), nullable=False)
token = db.Column(db.String(255), unique=True, nullable=False)
nonce = db.Column(db.Integer, nullable=False)
secret = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255))
amount = db.Column(db.Integer, nullable=False)
amount_zap = db.Column(db.Integer, nullable=False)
bronze_broker_token = db.Column(db.String(255), nullable=False)
status = db.Column(db.String(255))
tx_seen = db.Column(db.Boolean, nullable=False)
utility_name = db.Column(db.String(255))
def __init__(self, email, amount, amount_zap, bronze_broker_token, status,
utility_name):
self.generate_defaults()
self.email = email
self.amount = amount
self.amount_zap = amount_zap
self.bronze_broker_token = bronze_broker_token
self.status = status
self.tx_seen = False
self.utility_name = utility_name
def generate_defaults(self):
self.date = datetime.datetime.now()
self.token = generate_key(8)
self.nonce = 0
self.secret = generate_key(16)
@classmethod
def count(cls, session):
return session.query(cls).count()
@classmethod
def from_token(cls, session, token):
return session.query(cls).filter(cls.token == token).first()
@classmethod
def all_with_email_and_not_terminated(cls, session):
return session.query(cls).filter(
and_(
cls.email != None,
or_(
cls.status == None,
and_(cls.status != cls.STATUS_SENT,
cls.status != cls.STATUS_EXPIRED)))).all()
def __repr__(self):
return "<Invoice %r %r>" % (self.token, self.status)
def to_json(self):
schema = InvoiceSchema()
return schema.dump(self).data
class Settlement(db.Model):
STATE_CREATED = "created"
STATE_SENT_ZAP = "sent_zap"
STATE_VALIDATED = "validated"
STATE_SENT_NZD = "sent_nzd"
STATE_ERROR = "error"
STATE_SUSPENDED = "suspended"
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship('User',
backref=db.backref('settlements', lazy='dynamic'))
token = db.Column(db.String(255), nullable=False, unique=True)
bank_id = db.Column(db.Integer, db.ForeignKey('bank.id'), nullable=False)
bank = db.relationship('Bank',
backref=db.backref('settlements', lazy='dynamic'))
amount = db.Column(db.Integer, nullable=False)
settlement_address = db.Column(db.String(255), nullable=False)
amount_receive = db.Column(db.Integer, nullable=False)
txid = db.Column(db.String(255))
status = db.Column(db.String(255), nullable=False)
def __init__(self, user, bank, amount, settlement_address, amount_receive):
self.date = datetime.datetime.now()
self.user = user
self.token = generate_key(4)
self.bank = bank
self.amount = amount
self.settlement_address = settlement_address
self.amount_receive = amount_receive
self.txid = None
self.status = Settlement.STATE_CREATED
@classmethod
def count(cls, session):
return session.query(cls).count()
@classmethod
def from_token(cls, session, token):
return session.query(cls).filter(cls.token == token).first()
@classmethod
def count_this_month(cls, session, user):
now = datetime.datetime.now()
# month start
month_start = now.replace(day=1,
hour=0,
minute=0,
second=0,
microsecond=0)
# month end
next_month = now.replace(day=28) + datetime.timedelta(
days=4) # this will never fail
last_day_of_month = next_month - datetime.timedelta(
days=next_month.day)
month_end = last_day_of_month.replace(hour=23,
minute=59,
second=59,
microsecond=999999)
return session.query(cls).filter(cls.user_id == user.id,
cls.date >= month_start,
cls.date <= month_end).count()
@classmethod
def all_sent_zap(cls, session):
return session.query(cls).filter(
cls.status == cls.STATE_SENT_ZAP).all()
@classmethod
def all_validated(cls, session):
return session.query(cls).filter(
cls.status == cls.STATE_VALIDATED).all()
@classmethod
def from_id_list(cls, session, ids):
return session.query(cls).filter(cls.id.in_(ids)).all()
def __repr__(self):
return "<Settlement %r>" % (self.token)
def to_json(self):
schema = SettlementSchema()
return schema.dump(self).data
class MerchantTx(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship('User',
backref=db.backref('merchanttxs', lazy='dynamic'))
wallet_address = db.Column(db.String(255), nullable=False)
amount = db.Column(db.Integer)
amount_nzd = db.Column(db.Integer)
txid = db.Column(db.String(255), nullable=False)
direction = db.Column(db.Boolean, nullable=False)
category = db.Column(db.String(255))
attachment = db.Column(db.String(255))
device_name = db.Column(db.String(255))
__table_args__ = (db.UniqueConstraint('user_id',
'txid',
name='user_txid_uc'), )
def __init__(self, user, date, wallet_address, amount, amount_nzd, txid,
direction, attachment):
self.date = date
self.user = user
self.wallet_address = wallet_address
self.amount = amount
self.amount_nzd = amount_nzd
self.txid = txid
self.direction = direction
self.attachment = attachment
try:
self.device_name = json.loads(attachment)['device_name']
except:
pass
try:
self.category = json.loads(attachment)['category']
except:
pass
@classmethod
def count(cls, session):
return session.query(cls).count()
@classmethod
def from_txid(cls, session, txid):
return session.query(cls).filter(cls.txid == txid).first()
@classmethod
def oldest_txid(cls, session, user):
last = session.query(cls).filter(cls.user_id == user.id).order_by(
cls.id.desc()).first()
if last:
return last.txid
return None
@classmethod
def exists(cls, session, user, txid):
return session.query(cls).filter(and_(cls.user_id == user.id),
(cls.txid == txid)).scalar()
@classmethod
def update_wallet_address(cls, session, user):
if user.wallet_address:
# update txs
limit = 100
oldest_txid = None
txs = []
while True:
have_tx = False
txs = blockchain_transactions(logger,
app.config["NODE_ADDRESS"],
user.wallet_address, limit,
oldest_txid)
for tx in txs:
oldest_txid = tx["id"]
have_tx = MerchantTx.exists(db.session, user, oldest_txid)
if have_tx:
break
if tx["type"] == 4 and tx["assetId"] == app.config[
"ASSET_ID"]:
amount_nzd = apply_merchant_rate(tx['amount'],
user,
app.config,
use_fixed_fee=False)
date = datetime.datetime.fromtimestamp(
tx['timestamp'] / 1000)
session.add(
MerchantTx(user, date, user.wallet_address,
tx['amount'], amount_nzd, tx['id'],
tx['direction'], tx['attachment']))
if have_tx or len(txs) < limit:
break
session.commit()
def __repr__(self):
return "<MerchantTx %r>" % (self.txid)
def to_json(self):
schema = MerchantTxSchema()
return schema.dump(self).data
