class AddStruct(db.Model):
__tablename__ = 'addstruct'
date = db.Column(db.Integer, primary_key=True)
year = db.Column(db.Integer)
month = db.Column(db.Integer)
day = db.Column(db.Integer)
total = db.Column(db.Integer)
discarded = db.Column(db.Integer)
totalv6 = db.Column(db.Integer)
discardedv6 = db.Column(db.Integer)
filev4 = db.Column(db.String(80), unique=True)
filev6 = db.Column(db.String(80), unique=True)
spacev4 = db.Column(ARRAY(db.Integer))
spacev6 = db.Column(ARRAY(db.Integer))
def __init__(self, date, year, month, day):
self.date = date
self.year = year
self.month = month
self.day = day
def __repr__(self):
return self.date
def get_db():
"""Get modified db object."""
database = SQLAlchemy()
class String(database.String):
"""Simple subclass of sqlalchemy.orm.String which provides a default
length for `String` types to satisfy MySQL
"""
# pylint: disable=too-few-public-methods
# this class is just to set the default string length and is not meant to
# do anything else, so it does not need any other public methods.
def __init__(self, length=None, *args, **kwargs):
# TODO: Check for MySQL and only apply when needed
if length is None:
length = 250
super(String, self).__init__(length, *args, **kwargs)
database.String = String
database.session.plain_commit = database.session.commit
def hooked_commit(*args, **kwargs):
"""Commit override function.
This function is meant for a single after commit hook that should only be
used for ACL propagation.
"""
database.session.plain_commit(*args, **kwargs)
from ggrc.models.hooks import acl
acl.after_commit()
database.session.commit = hooked_commit
return database
def get_db():
"""Get modified db object."""
database = SQLAlchemy()
class String(database.String):
"""Simple subclass of sqlalchemy.orm.String which provides a default
length for `String` types to satisfy MySQL
"""
# pylint: disable=too-few-public-methods
# this class is just to set the default string length and is not meant to
# do anything else, so it does not need any other public methods.
def __init__(self, length=None, *args, **kwargs):
# TODO: Check for MySQL and only apply when needed
if length is None:
length = 250
super(String, self).__init__(length, *args, **kwargs)
database.String = String
database.session.plain_commit = database.session.commit
database.session.commit_hooks_enable_flag = CommitHooksEnableFlag()
def pre_commit_hooks():
"""All pre commit hooks handler."""
with benchmark("pre commit hooks"):
if not database.session.commit_hooks_enable_flag:
return
database.session.flush()
if hasattr(database.session, "reindex_set"):
database.session.reindex_set.push_ft_records()
def post_commit_hooks():
"""All post commit hooks handler."""
with benchmark("post commit hooks"):
if not database.session.commit_hooks_enable_flag:
return
from ggrc.models.hooks import acl
acl.after_commit()
database.session.post_commit_hooks = post_commit_hooks
database.session.pre_commit_hooks = pre_commit_hooks
def hooked_commit(*args, **kwargs):
"""Commit override function.
This function is meant for a single after commit hook that should only be
used for ACL propagation.
"""
database.session.pre_commit_hooks()
with benchmark("plain commit"):
database.session.plain_commit(*args, **kwargs)
database.session.post_commit_hooks()
database.session.commit = hooked_commit
return database
def get_db():
"""Get modified db object."""
db = SQLAlchemy()
class String(db.String):
"""Simple subclass of sqlalchemy.orm.String which provides a default
length for `String` types to satisfy MySQL
"""
def __init__(self, length=None, *args, **kwargs):
# TODO: Check for MySQL and only apply when needed
if length is None:
length = 250
return super(String, self).__init__(length, *args, **kwargs)
db.String = String
return db
def get_db():
"""Get modified db object."""
from flask.ext.sqlalchemy import SQLAlchemy
db = SQLAlchemy()
class String(db.String):
"""Simple subclass of sqlalchemy.orm.String which provides a default
length for `String` types to satisfy MySQL
"""
def __init__(self, length=None, *args, **kwargs):
# TODO: Check for MySQL and only apply when needed
if length is None:
length = 250
return super(String, self).__init__(length, *args, **kwargs)
db.String = String
return db
#-*- coding: UTF-8 -*-
from flask import current_app, request, json
from flask.ext.sqlalchemy import SQLAlchemy
from datetime import *
from flask.ext.security import current_user, login_required, RoleMixin, Security, SQLAlchemyUserDatastore, UserMixin, utils
db = SQLAlchemy()
roles_users = db.Table(
'roles_users',
db.Column('user_id', db.String(128), db.ForeignKey('user.id')),
db.Column('role_id', db.String(128), db.ForeignKey('role.id')))
class Serializer(object):
__public__ = None
"Must be implemented by implementors"
def to_serializable_dict(self):
dict = {}
for public_key in self.__public__:
value = getattr(self, public_key)
if value:
dict[public_key] = value
return dict
class SWEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, Serializer):
content_type = Column(String(32))
picture_date = Column(DateTime)
picture_data = Column(LargeBinary)
thumbnail = Column(LargeBinary)
user = Column(String(50), nullable=False, default='')
dataset_id = Column(
'ext_dataset_id',
ForeignKey('datasets.id'),
primary_key=True,
)
roles_users = db.Table(
'roles_users',
db.Column('registered_users_user', db.String(50),
db.ForeignKey('registered_users.user')),
db.Column('role_id', db.Integer(), db.ForeignKey('roles.id')),
)
class RegisteredUser(Base, UserMixin):
__tablename__ = 'registered_users'
id = Column('user', String(50), primary_key=True)
name = Column(String(255))
institution = Column(String(45))
abbrev = Column(String(10))
MS = Column(String(255))
email = Column(String(255))
qualification = Column(String(255))
password = db.Column(db.String(255))
# Establish contact with Post's ForeignKey: user_id 关联Post表外键
posts = db.relationship('Post', backref='users', lazy='dynamic')
def __init__(self, id, username, password):
self.id = id
self.username = username
self.password = password
def __repr__(self):
"""Define the string format for instance of User."""
return "<Model User '{}'>".format(self.username)
posts_tags = db.Table(
'posts_tags', db.Column('post_id', db.String(45),
db.ForeignKey('posts.id')),
db.Column('tag_id', db.String(45), db.ForeignKey('tags.id')))
class Post(db.Model):
"""Represents Proected posts."""
__tablename__ = 'posts'
id = db.Column(db.String(45), primary_key=True)
title = db.Column(db.String(255))
text = db.Column(db.Text())
publist_date = db.Column(db.DateTime)
#Set the foreign key for Post
user_id = db.Column(db.String(45), db.ForeignKey('users.id'))
# Establish contact with Comment's ForeignKey: post_id 关联评论表外键
comments = db.relationship('Comment', backref='posts', lazy='dynamic')
db = SQLAlchemy(app)
json_parser = reqparse.RequestParser()
json_parser.add_argument('hostname', type=unicode, required=True, location='json')
json_parser.add_argument('spec_result', type=unicode, required=True, location='json')
json_parser.add_argument('cookbook_name', type=unicode, required=True, location='json')
query_parser = reqparse.RequestParser()
query_parser.add_argument('hostname', type=unicode)
query_parser.add_argument('cookbook_name', type=unicode)
query_parser.add_argument('limit', type=int)
Base = declarative_base()
tests = Table('tests', Base.metadata,
Column('id', db.Integer, primary_key=True),
Column('hostname', db.String(100), index=True),
Column('unix_timestamp', db.Integer, index=True),
Column('spec_result', db.String(20000), index=True),
Column('cookbook_name', db.String(100), index=True)
)
Base.metadata.create_all(db.engine)
class Test(db.Model):
__table__ = tests
__mapper_args__ = {
'primary_key': [tests.c.id]
}
def __init__(self, hostname, spec_result, cookbook_name):
from transporter.utils import store_route_info
from flask.ext.sqlalchemy import SQLAlchemy
from sqlalchemy.orm import relationship
from sqlalchemy.dialects.postgresql import JSON
from geopy.distance import vincenty
from geopy.point import Point
from datetime import datetime, timedelta
from logbook import Logger
from collections import deque
import click
import requests
import json
import time
db = SQLAlchemy()
JsonType = db.String().with_variant(JSON(), 'postgresql')
inf = float('inf')
log = Logger(__name__)
route_station_assoc = db.Table(
'route_station_assoc',
db.Column('route_id', db.Integer, db.ForeignKey('route.id')),
db.Column('station_id', db.Integer, db.ForeignKey('station.id')),
db.Column('sequence', db.Integer),
)
route_edge_assoc = db.Table(
'route_edge_assoc',
db.Column('route_id', db.Integer, db.ForeignKey('route.id')),
db.Column('edge_id', db.Integer, db.ForeignKey('edge.id')),
from flask.ext.sqlalchemy import SQLAlchemy
from cloudtestenvironment import app
db = SQLAlchemy(app)
<<<<<<< HEAD
class User(db.Model):
=======
<<<<<<< Updated upstream
class Registration(db.Model):
>>>>>>> andrew
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(40))
password_hash = db.Column(db.String(255))
customer_id = db.Column(db.Integer, db.ForeignKey('customer.id'))
def __init__(self, username, password_hash, customer_id):
self.username = username
self.password_hash = password_hash
self.customer_id = customer_id
class Account(db.Model):
id = db.Column(db.Integer, primary_key=True)
balance = db.Column(db.Numeric(2))
customer_id = db.Column(db.Integer, db.ForeignKey('customer.id'))
def __init__(self, balance, customer_id):
self.balance = balance
self.customer_id = customer_id
class Message(db.Model):
import datetime
#pour test
from random import randint
app = Flask(__name__)
#app.config['SQLALCHEMY_DATABASE_URI'] = 'postgres://*****:*****@ec2-54-163-238-96.compute-1.amazonaws.com:5432/d6fisokcj01ulm'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db'
db = SQLAlchemy(app)
########################################################################
comments_table = Table(
'comments', db.Model.metadata,
Column('pin_id', Integer, ForeignKey('pins.id')),
Column('text', db.String(400)), Column('username', db.String(400)),
Column('date', db.DateTime, default=datetime.datetime.utcnow))
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
pseudo = db.Column(db.String(50))
passw = db.Column(db.String(50))
def __init__(self, username, passw):
self.pseudo = username
self.passw = passw
def serialize(self):
import datetime
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.security import UserMixin, RoleMixin
from sqlalchemy.orm import backref
db = SQLAlchemy()
_EMAIL_TYPE = db.String(160)
class Mailbox(db.Model):
id = db.Column(db.Integer, primary_key=True)
address = db.Column(_EMAIL_TYPE, unique=True, index=True)
last_activity = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
index=True)
emails = db.relationship("Email",
backref=backref("mailbox"),
cascade="all, delete, delete-orphan")
class Email(db.Model):
id = db.Column(db.Integer, primary_key=True)
mailbox_id = db.Column(db.Integer,
db.ForeignKey("mailbox.id", ondelete="CASCADE"),
index=True)
#mailbox = db.relationship("Mailbox", backref=backref("emails"), cascade="all, delete, delete-orphan", single_parent=True)
fromaddr = db.Column(_EMAIL_TYPE)
message = db.Column(db.Text())
class User(db.Model):
"""
Users who can access the log
"""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(20), index=True, unique=True)
password = db.Column(db.String(176))
posts_categories = db.Table(
'posts_categories', db.metadata,
db.Column('post', db.Integer, db.ForeignKey('post.id')),
db.Column('category', db.String(10), db.ForeignKey('category.name')))
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(30), nullable=False)
slug = db.Column(db.String(30))
content = db.Column(db.Text, nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=dt.utcnow())
covered_period = db.Column(db.Date)
covers_week = db.Column(db.Boolean)
categories = db.relationship('Category',
secondary=posts_categories,
lazy='dynamic',
except:
return None
user = User.query.get(data['id'])
if user and user.can_login():
return user
def __repr__(self):
return self.email
def __hash__(self):
return hash(self.email)
group_banned_user = db.Table( # Secondary Table for many-to-many mapping
'groups_banned_users',
db.Column('group_id', db.String(32), db.ForeignKey('groups.id')),
db.Column('user_id', db.String(32), db.ForeignKey('users.id')),
db.PrimaryKeyConstraint('group_id', 'user_id'))
class GroupUserAssociation(db.Model
): # Association Object for many-to-many mapping
__tablename__ = 'groups_users_association'
group_id = db.Column(db.String(32),
db.ForeignKey('groups.id'),
primary_key=True)
user_id = db.Column(db.String(32),
db.ForeignKey('users.id'),
primary_key=True)
manager = db.Column(db.Boolean, default=False)
owner = db.Column(db.Boolean, default=False)
# Load initial project settings
import settings
# FIXME: This should probably be done in `settings/app_engine.py`
if getattr(settings, 'APP_ENGINE', False):
import sys
import os
sys.path.insert(0, os.path.join(settings.BASE_DIR, 'packages.zip'))
del os
del sys
# FIXME: This should be more complete
import logging
logger = logging.getLogger(__name__)
from flask.ext.sqlalchemy import SQLAlchemy
db = SQLAlchemy()
class String(db.String):
"""Simple subclass of sqlalchemy.orm.String which provides a default
length for `String` types to satisfy MySQL
"""
def __init__(self, length=None, *args, **kwargs):
# TODO: Check for MySQL and only apply when needed
if length is None:
length = 250
return super(String, self).__init__(length, *args, **kwargs)
db.String = String
clothingHistoryEntry = db.relationship('ClothingHistoryEntry',
backref='user',
lazy='dynamic')
autoCompleteGear = db.relationship('UserGear',
backref='usergear',
lazy='dynamic')
def __init__(self):
pass
def __repr__(self):
return '<User %d>' % self.id
usergear = db.Table(
'usergear', db.Column('gear', db.String(100), primary_key=True),
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True), db.Column('frequency', db.Integer))
class ClothingHistoryEntry(db.Model):
location = db.Column(db.String(80), primary_key=True)
date = db.Column(db.Date, primary_key=True)
tempHigh = db.Column(db.Integer)
tempMin = db.Column(db.Integer)
precipitation = db.Column(db.Integer)
comfort = db.Column(db.String(80))
windSpeed = db.Column(db.Integer)
windGust = db.Column(db.Integer)
def get_db(): # noqa
"""Get modified db object."""
database = SQLAlchemy()
class String(database.String):
"""Simple subclass of sqlalchemy.orm.String which provides a default
length for `String` types to satisfy MySQL
"""
# pylint: disable=too-few-public-methods
# this class is just to set the default string length and is not meant to
# do anything else, so it does not need any other public methods.
def __init__(self, length=None, *args, **kwargs):
# TODO: Check for MySQL and only apply when needed
if length is None:
length = 250
super(String, self).__init__(length, *args, **kwargs)
database.String = String
database.session.plain_commit = database.session.commit
database.session.commit_hooks_enable_flag = CommitHooksEnableFlag()
def pre_commit_hooks():
"""All pre commit hooks handler."""
with benchmark("pre commit hooks"):
if not database.session.commit_hooks_enable_flag:
return
database.session.flush()
if hasattr(database.session, "reindex_set"):
database.session.reindex_set.indexing_hook()
def post_commit_hooks():
"""All post commit hooks handler."""
with benchmark("post commit hooks"):
if not database.session.commit_hooks_enable_flag:
return
# delete flask caches in order to avoid
# using cached instances after commit
if hasattr(flask.g, "user_cache"):
del flask.g.user_cache
if hasattr(flask.g, "user_creator_roles_cache"):
del flask.g.user_creator_roles_cache
from ggrc.models.hooks import acl
acl.after_commit()
database.session.post_commit_hooks = post_commit_hooks
database.session.pre_commit_hooks = pre_commit_hooks
def hooked_commit(*args, **kwargs):
"""Commit override function.
This function is meant for a single after commit hook that should only be
used for ACL propagation.
"""
database.session.pre_commit_hooks()
with benchmark("plain commit"):
database.session.plain_commit(*args, **kwargs)
database.session.post_commit_hooks()
database.session.commit = hooked_commit
return database
type=unicode,
required=True,
location='json')
query_parser = reqparse.RequestParser()
query_parser.add_argument('criticality', type=unicode)
query_parser.add_argument('hours_ago', type=float, required=True)
query_parser.add_argument('until', type=int)
query_parser.add_argument('category', type=unicode)
query_parser.add_argument('description', type=unicode)
Base = declarative_base()
events = Table('events', Base.metadata,
Column('criticality', db.Integer, index=True),
Column('unix_timestamp', db.Integer, index=True),
Column('category', db.String(30), index=True),
Column('description', db.String(1000), index=True))
Base.metadata.create_all(db.engine)
class Event(db.Model):
__table__ = events
__mapper_args__ = {
'primary_key': [
events.c.criticality, events.c.unix_timestamp, events.c.category,
events.c.description
]
}
def __init__(self, criticality, unix_timestamp, category, description):
self.criticality = criticality
