Exemple #1
0
class EthContact(db.Model):
    __tablename__ = 'eth_contact'
    address = db.Column(db.String(42), primary_key=True)
    name = db.Column(db.String(255), index=True)
    desc = db.Column(db.String(255))
    email = db.Column(db.String(255), index=True)
    phone = db.Column(db.String(255), index=True)
    eth_balance = db.Column(db.Float(), default=0)
    ogn_balance = db.Column(db.Float(), default=0)
    dai_balance = db.Column(db.Float(), default=0)
    investor = db.Column(db.Boolean())
    presale_interest = db.Column(db.Boolean())
    dapp_user = db.Column(db.Boolean())
    employee = db.Column(db.Boolean())
    exchange = db.Column(db.Boolean())
    company_wallet = db.Column(db.Boolean())
    investor_airdrop = db.Column(db.Boolean())
    token_count = db.Column(db.Integer())
    transaction_count = db.Column(db.Integer())
    tokens = db.Column(JSONB)
    last_updated = db.Column(db.DateTime(),
                             server_default=db.func.now(),
                             onupdate=db.func.now())
    created_at = db.Column(db.DateTime(timezone=True),
                           server_default=db.func.now())
    country_code = db.Column(db.String(2))

    def __str__(self):
        return '%s' % (self.name)
Exemple #2
0
class EmailList(db.Model):
	__tablename__ = 'email_list'

	email = db.Column(db.String(255), primary_key=True, autoincrement=False)
	unsubscribed = db.Column(db.Boolean())
	created_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now())

	def __str__(self):
		return '%s' % (self.email)
class Todo(db.Model):
    id = db.Column("id", db.Integer, primary_key=True )
    description = db.Column("description", db.String(100))
    complete = db.Column("complete", db.Boolean())
    email = db.Column("email", db.String(100))
    def __init__(self, description, complete, email):
        self.description = description
        self.complete = complete
        self.email = email
Exemple #4
0
class User(db.Model):
    login = db.Column(db.String(8), primary_key=True)
    email = db.Column(db.String(100), default="")
    tel = db.Column(db.String(100), default="")
    is_admin = db.Column(db.Boolean(), default=False)
    date_join = db.Column(db.DateTime())
    last_login = db.Column(db.DateTime())
    active = db.Column(db.Boolean(), default=True)

    collections = db.relationship('Collection', backref='user', lazy='dynamic')

    def __init__(self, login):
        self.login = login
        self.email = "*****@*****.**" % login
        self.date_join = datetime.datetime.now()
        self.last_login = datetime.datetime.now()

    def __repr__(self):
        return '<User %r>' % self.login
Exemple #5
0
class EmailList(db.Model):
    __tablename__ = 'email_list'

    email = db.Column(db.String(255), primary_key=True, autoincrement=False)
    unsubscribed = db.Column(db.Boolean())
    created_at = db.Column(db.DateTime(timezone=True),
                           server_default=db.func.now())
    ip_addr = db.Column(db.String(100))
    country_code = db.Column(db.String(2))
    first_name = db.Column(db.String(255))
    last_name = db.Column(db.String(255))
    # sendgrid feedback loop
    bounced = db.Column(db.Boolean())
    spam_report = db.Column(db.Boolean())
    blocked = db.Column(db.Boolean())
    invalid = db.Column(db.Boolean())

    def __str__(self):
        return '%s' % (self.email)
class Task(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(80))
    description = db.Column(db.String(80))
    done = db.Column(db.Boolean())

    def __init__(self, title, description='', done=''):
        self.title = title
        self.description = description
        self.done = done
Exemple #7
0
class Identity(db.Model):
    eth_address = db.Column(db.Numeric(precision=50, scale=0),
                            primary_key=True)
    phone = db.Column(db.String(20), index=True)
    verified = db.Column(db.Boolean())
    created_at = db.Column(db.DateTime(timezone=True),
                           server_default=func.now())
    updated_at = db.Column(db.DateTime(timezone=True),
                           server_default=func.now(),
                           onupdate=func.now())
Exemple #8
0
class User(db.Model, UserMixin):
    id = db.Column(db.Integer(), primary_key=True)
    api_key = db.Column(db.String(255), unique=True)
    name = db.Column(db.String(50))
    active = db.Column(db.Boolean())
    roles = db.relationship('Role',
                            secondary=roles_users,
                            backref=db.backref('users', lazy='dynamic'))
    jenkins_key = db.Column(db.String(255))
    rundeck_key = db.Column(db.String(255))
Exemple #9
0
class SubjectTag(db.Model, Serialize):
    __tablename__ = 'tag'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100))
    description = db.Column(db.TEXT)
    count = db.Column(db.Integer)
    sentiment = db.Column(db.TEXT)
    trending = db.Column(db.TEXT)
    created = db.Column(db.Integer)
    updated = db.Column(db.Integer)
    comment = db.Column(db.Boolean())
class User(db.Model):
    id = db.Column("id", db.Integer, primary_key=True)
    name = db.Column("name", db.String(100))
    email = db.Column("email", db.String(100))
    password = db.Column("password", db.String(100))
    admin = db.Column("admin", db.Boolean())
    def __init__(self, name, email, password, admin):
        self.name = name
        self.email = email
        self.password = password
        self.admin = admin
Exemple #11
0
class User(db.Model, UserMixin):
    """
	User model building off of flask-registration
	"""
    __tablename__ = 'user'
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(60))
    password = db.Column(db.String())
    last_login_at = db.Column(db.DateTime())
    current_login_at = db.Column(db.DateTime())
    last_login_ip = db.Column(db.String())
    current_login_ip = db.Column(db.String())
    login_count = db.Column(db.Integer())
    created = db.Column(db.Date())
    company = db.Column(db.String)
    apis = db.relationship('API',
                           secondary=apis,
                           backref=db.backref('apis', lazy='dynamic'))
    active = db.Column(db.Boolean())
    confirmed_at = db.Column(db.DateTime())
    roles = db.relationship('Role',
                            secondary=roles_users,
                            backref=db.backref('user'))
    onboarded = db.Column(db.Boolean(), default=False)
    returning_visitors = db.relationship('GoogleAnalyticsReturningVisitors',
                                         secondary=returning_visitors,
                                         backref=db.backref('user'))
    signups = db.relationship('GoogleAnalyticsSignups',
                              secondary=signups,
                              backref=db.backref('user'))

    def __repr__(self):
        return '<User %s>' % self.email

    def as_dict(self):
        return {
            'email': self.email,
            'roles': [str(role) for role in self.roles],
            'onboarded': self.onboarded
        }
Exemple #12
0
class Supplier(db.Model):
    __tablename__ = 'suppliers'

    id = db.Column(db.String(36), default=lambda: str(uuid4()), primary_key=True)
    active = db.Column(db.Boolean(), default=True)
    company_name = db.Column(db.String(100), nullable=False)
    cnpj = db.Column(db.String(14), unique=True, nullable=False)
    trading_name = db.Column(db.String(100), nullable=False)
    phone = db.Column(db.String(11), nullable=False)
    email = db.Column(db.String(100), nullable=False)
    address = db.relationship(Address)
    address_id = db.Column(db.String(36), db.ForeignKey(Address.id), nullable=False)
    category = db.relationship(Category)
    category_id = db.Column(db.String(36), db.ForeignKey(Category.id), nullable=False)
    on_create = db.Column(db.DateTime, default=datetime.datetime.now)
    on_update = db.Column(db.DateTime, default=datetime.datetime.now, onupdate=datetime.datetime.now)

    def serialize(self) -> Dict[str, Union[bool, str]]:
        return {
            'id': self.id,
            'active': self.active,
            'company_name': self.company_name,
            'cnpj': self.cnpj,
            'trading_name': self.trading_name,
            'phone': self.phone,
            'email': self.email,
            'address_id': self.address_id,
            'category_id': self.category_id,
            'on_create': self.on_create,
            'on_update': self.on_update
        }

    def serialize_summed_version(self) -> Dict[str, Union[bool, str]]:
        return {
            'id': self.id,
            'trading_name': self.trading_name,
            'on_create': self.on_create,
            'on_update': self.on_update
        }

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        validating_empty_fields(['description'], **kwargs)
        validating_if_field_is_not_str(['active', 'on_create', 'on_update'], **kwargs)
        validating_if_field_is_bool(['active'], **kwargs)
        validating_if_field_is_numeric(['phone', 'cnpj'], **kwargs)
        validating_if_field_is_alpha(['company_name', 'trading_name'], **kwargs)
        validating_email(**kwargs)
        validating_maximum_size_of_fields(**kwargs)
        validating_minimum_size_of_fields(**kwargs)
        validating_equal_size_of_fields(**kwargs)
Exemple #13
0
class User(UserMixin, PkModel):
    """A user of the app."""

    __tablename__ = "users"
    username = Column(db.String(80), unique=True, nullable=False)
    email = Column(db.String(80), unique=True, nullable=False)
    #: The hashed password
    password = Column(db.LargeBinary(128), nullable=True)
    created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
    first_name = Column(db.String(30), nullable=True)
    last_name = Column(db.String(30), nullable=True)
    active = Column(db.Boolean(), default=False)
    is_admin = Column(db.Boolean(), default=False)

    def __init__(self, username, email, password=None, **kwargs):
        """Create instance."""
        super().__init__(username=username, email=email, **kwargs)
        if password:
            self.set_password(password)
        else:
            self.password = None

    def set_password(self, password):
        """Set password."""
        self.password = bcrypt.generate_password_hash(password)

    def check_password(self, value):
        """Check password."""
        return bcrypt.check_password_hash(self.password, value)

    @property
    def full_name(self):
        """Full user name."""
        return f"{self.first_name} {self.last_name}"

    def __repr__(self):
        """Represent instance as a unique string."""
        return f"<User({self.username!r})>"
Exemple #14
0
class Note(db.Model):
    id = db.Column("id", db.Integer, primary_key=True)
    title = db.Column("title", db.String(200))
    text = db.Column("text", db.String(100))
    date = db.Column("date", db.String(50))
    last_modified = db.Column("last_modified", db.String(50))
    is_favorite = db.Column("is_favorite", db.Boolean())
    is_published = db.Column("is_published", db.Boolean())
    # can create a foreign key; referencing the id variable in the User class, so that is why it is lowercase u
    user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
    comments = db.relationship("Comment",
                               backref="note",
                               cascade="all, delete-orphan",
                               lazy=True)

    def __init__(self, title, text, date, user_id):
        self.title = title
        self.text = text
        self.date = date
        self.last_modified = date
        self.user_id = user_id
        self.is_favorite = False
        self.is_published = False
Exemple #15
0
class User(db.Model, UserMixin):
    """Registered users of the sight, copied from the setup found in the
    flask admin auth example here:

    https://github.com/flask-admin/flask-admin/blob/master/examples/auth/app.py
    """

    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(255), unique=True, primary_key=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'))
Exemple #16
0
class Listing(db.Model):
    contract_address = db.Column(db.String(255), primary_key=True)
    owner_address = db.Column(db.String(255), index=True)
    registry_id = db.Column(db.Integer())

    price = db.Column(db.Integer())
    units = db.Column(db.Integer())
    expired = db.Column(db.Boolean())

    ipfs_hash = db.Column(db.String(255))
    ipfs_data = db.Column(db.JSON())

    created_at = db.Column(db.DateTime(timezone=True))
    expires_at = db.Column(db.DateTime(timezone=True))
Exemple #17
0
class User(db.Model, UserMixin):
    __tablename__ = 'user'
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(255), unique=True)
    username = db.Column(db.String(255))
    password = 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())
    roles = db.relationship('Role', secondary='roles_users', backref=db.backref('users', lazy='dynamic'))
Exemple #18
0
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(), default=datetime.datetime.now)

    roles = db.relationship('Role',
                            secondary=roles_users,
                            backref=db.backref('users', lazy='dynamic'))

    def __str__(self):
        return self.email
class Presale(db.Model):
    __tablename__ = 'presale'

    id = db.Column(db.Integer, primary_key=True)
    full_name = db.Column(db.String(255))
    email = db.Column(db.String(255))
    accredited = db.Column(db.Boolean())
    entity_type = db.Column(db.String(255))
    desired_allocation = db.Column(db.String(255))
    desired_allocation_currency = db.Column(db.String(3))
    citizenship = db.Column(db.String(2))
    sending_addr = db.Column(db.String(255))
    note = db.Column(db.Text())

    def __str__(self):
        return '%s' % (self.email)
Exemple #20
0
class Comment(db.Model, Serialize):
    __tablename__ = 'comment'
    id = db.Column(db.Integer, primary_key=True)
    user_id =  db.Column(db.Integer)
    post_id = db.Column(db.Integer)
    parent = db.Column(db.Integer)
    children=db.Column(db.TEXT)
    visible = db.Column(db.Boolean())
    text = db.Column(db.TEXT)
    tag = db.Column(db.TEXT)
    upvote = db.Column(db.Integer)
    downvote = db.Column(db.Integer)
    modifier = db.Column(db.Integer)
    toponym=db.Column(db.String(200))
    created = db.Column(db.Integer)
    updated = db.Column(db.Integer)
Exemple #21
0
class Post(db.Model, Serialize):
    __tablename__ = 'post'
    id = db.Column(db.Integer, primary_key=True)
    user_id =  db.Column(db.Integer)
    upvote = db.Column(db.Integer)
    downvote = db.Column(db.Integer)
    sentiment = db.Column(db.TEXT)
    modifier = db.Column(db.Integer)
    title = db.Column(db.String(140))
    link = db.Column(db.String(2000))
    text = db.Column(db.TEXT)
    tags = db.Column(db.TEXT)
    toponym=db.Column(db.String(200))
    created = db.Column(db.Integer)
    updated = db.Column(db.Integer)
    visible = db.Column(db.Boolean())
Exemple #22
0
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'))
    last_login_at = db.Column(db.DateTime())
    current_login_at = db.Column(db.DateTime())
    last_login_ip = db.Column(db.String(255))
    current_login_ip = db.Column(db.String(255))
    login_count = db.Column(db.Integer)

    def __repr__(self):
        return '<models.User[email=%s]>' % self.email
Exemple #23
0
class TokenTransaction(db.Model):
    __tablename__ = 'token_transaction'
    tx_hash = db.Column(db.String(66), primary_key=True)
    from_address = db.Column(db.String(42), index=True)
    to_address = db.Column(db.String(42), index=True)
    amount = db.Column(db.Float())
    block_number = db.Column(db.Integer())
    notification_sent = db.Column(db.Boolean())
    timestamp = db.Column(db.DateTime(timezone=True))
    last_updated = db.Column(db.DateTime(),
                             server_default=db.func.now(),
                             onupdate=db.func.now())
    created_at = db.Column(db.DateTime(timezone=True),
                           server_default=db.func.now())

    def __str__(self):
        return '%s' % (self.name)
Exemple #24
0
class Person(db.Model):
    id = db.Column(db.Integer, primary_key=True)

    first_name = db.Column(db.String(60))
    middle_name = db.Column(db.String(60), nullable=True)
    last_name = db.Column(db.String(60))

    active = db.Column(db.Boolean(), default=True, nullable=False)

    date_added = db.Column(db.DateTime, default=func.now())

    def __repr__(self):
        return '<Person ID=%s, %s %s %s>' % (self.id, self.first_name,
                                             self.middle_name, self.last_name)

    def __str__(self):
        return '%s, %s %s (%s)' % (self.last_name, self.first_name,
                                   self.middle_name, self.id)
Exemple #25
0
class Product(db.Model):
    __tablename__ = 'products'

    id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid4()))
    name = db.Column(db.String(36), unique=True)
    cost_values = db.Column(db.Float(20))
    unit_per_box = db.Column(db.Numeric(6))
    weight_per_unit = db.Column(db.String(10))
    measure_unit = db.Column(db.String(10), nullable=False)
    shelf_life = db.Column(db.String(10))
    sku = db.Column(db.String(10), unique=True)
    description = db.Column(db.String(70))
    created_at = db.Column(db.DateTime(timezone=True), default=func.now())
    updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
    deleted_at = db.Column(db.DateTime(timezone=True), default=None)
    is_active = db.Column(db.Boolean(10), default=True)
    id_product_line = db.Column(
        db.String(36),
        db.ForeignKey('product_line.id')
    )

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        for keys in kwargs:
            if kwargs[keys] is None or kwargs[keys] == '':
                raise NullValueException(f'The field {keys} can not be null')

    def serialize(self):
        return {
            "id": self.id,
            "name": self.name,
            "cost_values": self.cost_values,
            "unit_per_box": int(self.unit_per_box),
            "weight_per_unit": self.weight_per_unit,
            'measure_unit': self.measure_unit,
            "shelf_life": self.shelf_life,
            "sku": self.sku,
            "description": self.description,
            "id_product_line": self.id_product_line,
            "is_active": self.is_active,
            "created_at": self.created_at,
            "updated_at": self.updated_at,
            "deleted_at": self.deleted_at
        }
Exemple #26
0
class User(db.Model, UserMixin):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String, unique=True, nullable=False)
    email = db.Column(db.String(100), unique=True, nullable=False)
    firstname = db.Column(db.String(80), nullable=False)
    lastname = db.Column(db.String(80), nullable=False)
    password = db.Column(db.String(300), nullable=False)
    active = db.Column(db.Boolean(), nullable=False)
    confirmed_at = db.Column(db.DateTime())
    roles = db.relationship('Role',
                            secondary=roles_users,
                            backref=db.backref('users', lazy='dynamic'))
    submissions = db.relationship('Submission', backref='user', lazy='dynamic')

    def __repr__(self):
        return self.username

    def __unicode__(self):
        return self.username
Exemple #27
0
class UserModel(UserMixin, db.Model):
    __tablename__ = 'user'

    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(255), unique=True, nullable=False)
    email = db.Column(db.String(255), unique=True, nullable=False)
    _password = db.Column('password', db.String(255), nullable=False)
    active = db.Column(db.Boolean(), default=True)

    createTime = db.Column(db.DateTime, nullable=False, default=datetime.now)
    updateTime = db.Column(db.DateTime,
                           nullable=False,
                           default=datetime.now,
                           onupdate=datetime.now)

    def __init__(self, email):
        self.email = email

    def _get_password(self):
        return self._password

    def _set_password(self, password):
        if password:
            password = password.strip()
        self._password = generate_password_hash(password)

    password_descriptor = property(_get_password, _set_password)
    password = synonym('_password', descriptor=password_descriptor)

    # フォームで送信されたパスワードの検証
    def check_password(self, password):
        password = password.strip()
        if not password:
            return False
        return check_password_hash(self.password, password)

    # 認証処理
    @classmethod
    def auth(cls, query, email, password):
        user = query(cls).filter(cls.email == email).first()
        if user is None:
            return None, False
        return user, user.check_password(password)
Exemple #28
0
class Address(db.Model):
    __tablename__ = "addresses"

    id = db.Column(db.String(36),
                   default=lambda: str(uuid4()),
                   primary_key=True)
    active = db.Column(db.Boolean(), default=True)
    street = db.Column(db.String(100), nullable=False)
    number = db.Column(db.String(50), nullable=False)
    complement = db.Column(db.String(300))
    zip_code = db.Column(db.String(11), nullable=False)
    city = db.Column(db.String(50), nullable=False)
    state = db.Column(db.String(50), nullable=False)
    on_create = db.Column(db.DateTime, default=datetime.datetime.now)
    on_update = db.Column(db.DateTime,
                          default=datetime.datetime.now,
                          onupdate=datetime.datetime.now)

    def serialize(self) -> Dict[str, Union[bool, str]]:
        return {
            'id': self.id,
            'active': self.active,
            'street': self.street,
            'number': self.number,
            'complement': self.complement,
            'zip_code': self.zip_code,
            'city': self.city,
            'state': self.state,
            'on_create': self.on_create,
            'on_update': self.on_update
        }

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        validating_empty_fields(['complement'], **kwargs)
        validating_if_field_is_not_str(['active', 'on_create', 'on_update'],
                                       **kwargs)
        validating_if_field_is_bool(['active'], **kwargs)
        validating_if_field_is_alpha_numeric(['street'], **kwargs)
        validating_if_field_is_numeric(['number', 'zip_code'], **kwargs)
        validating_if_field_is_alpha(['city', 'state'], **kwargs)
        validating_size_of_fields(**kwargs)
Exemple #29
0
class Printer(db.Model):
    __tablename__ = "printers"
    id = db.Column(db.Integer, primary_key=True)
    vendor = db.Column(db.String(100), nullable=True, unique=True)
    product = db.Column(db.String(100), unique=True)
    in_ep = db.Column(db.Integer, nullable=True)
    out_ep = db.Column(db.Integer, nullable=True)
    active = db.Column(db.Boolean())
    langu = db.Column(db.String(100))
    value = db.Column(db.Integer)

    def __init__(self, vendor=" ", product=" ",
                 in_ep=0, out_ep=0, active=False,
                 langu='en', value=1):
        self.vendor = vendor
        self.product = product
        self.in_ep = in_ep
        self.out_ep = out_ep
        self.active = active
        self.value = value
Exemple #30
0
class Test(db.Model):
    __tablename__ = "tests"

    id = db.Column(db.Integer, primary_key=True)
    #test_name = db.Column(db.String(100))
    answers = db.Column(db.PickleType())
    status = db.Column(db.Boolean(), default=False)
    #email = db.Column(db.String(255))
    no_questions = db.Column(db.Integer())

    def __init__(self, kwargs):
        self.id = kwargs.get('id')
        #self.test_name = kwargs.get('test_name')
        self.answers = kwargs.get('answers')
        #self.email = kwargs.get('email')
        self.no_questions = kwargs.get('no_questions')
        self.status = kwargs.get('status')

    @classmethod
    def getAll(cls):
        return Test.query.all()