def test_engine_options_setup(config, container):
engine_options = {
'pool_size': 100,
'pool_recycle': 3600,
}
db_session = DatabaseSession(DeclBase, engine_options=engine_options)
db_session = db_session.bind(container, 'database')
db_session.setup()
assert db_session.engine.pool.size == 100
assert db_session.engine.pool._recycle == 3600
def test_session_options_setup(config, container):
session_options = {
'autoflush': False,
'expire_on_commit': False,
}
db_session = DatabaseSession(DeclBase, session_options=session_options)
db_session = db_session.bind(container, 'database')
db_session.setup()
assert db_session.Session.kw['autoflush'] is False
assert db_session.Session.kw['expire_on_commit'] is False
class ExampleServiceWithDatabaseSession:
name = 'exampleservice'
session = DatabaseSession(DeclBase)
@dummy
def create_record(self):
self.session.add(ExampleModel(data='hello'))
self.session.commit()
@dummy
@transaction_retry(session=operator.attrgetter('session'))
def get_record_count(self):
return self.session.query(ExampleModel).count()
@dummy
def get_record_count_retry_inside(self):
session = self.session
@transaction_retry(session=session)
def foo():
return session.query(ExampleModel).count()
return foo()
@dummy
def get_record_count_no_retry(self):
return self.session.query(ExampleModel).count()
class UsersService(UserMixin):
name = "users"
auth = Auth()
tracer = Tracer()
db_session = DatabaseSession(DeclarativeBase)
event_dispatcher = EventDispatcher()
@http("GET", "/healthcheck")
def health_check_http(self, request):
return json.dumps(self.health_check())
@rpc
def health_check(self):
result = {"status": "ok"}
return result
@rpc
def check_jwt(self):
try:
decoded_jwt = self.auth.decode_jwt()
except InvalidToken:
return None
try:
user = self.get_user(uuid=decoded_jwt["uuid"])
except UserNotFound:
return None
return self.auth.encode_jwt({
"uuid": user["uuid"],
"email": user["email"]
})
class ContactsService:
name = 'contacts'
session = DatabaseSession(DeclarativeBase)
dispatch = EventDispatcher()
auto_crud = AutoCrudWithEvents(
session,
dispatch,
'contact',
model_cls=Contact,
get_method_name='get_contact',
create_method_name='create_contact',
update_method_name='update_contact',
list_method_name='list_contacts',
count_method_name='count_contacts',
create_event_name='contact_created',
update_event_name='contact_updated',
)
@rtm.handle_message('^create contact (?P<name>\w+)')
def slack_create_contact(self, event, message, name=None):
return 'Contact created on platform: {}'.format(
self.create_contact({'name': name}))
class UserService(object):
name = "user"
db = DatabaseSession(Base)
@rpc
def create(self, username, email, password):
user = User(
username=username,
email=email,
password=password,
)
self.db.add(user)
self.db.commit()
user = UserSchema().dump(user).data
return user
@rpc
def get(self, user_id):
user = self.db.query(User).get(user_id)
return UserSchema().dump(user).data
@rpc
def login(self, username, pwd):
user = self.db.query(User).filter_by(username=username).first()
if user.password == pwd:
return UserSchema().dump(user).data
@rpc
def delete(self, id):
user = self.db.query(User).get(id)
self.db.delete(user)
self.db.commit()
class RefreshTokenService(object):
name = "refresh_token"
db = DatabaseSession(Base)
@rpc
def create(self, uid, cid, ip_address, user_agent):
token = RefreshToken(
user_id=uid,
client_id=cid,
ip_address=ip_address,
user_agent=user_agent
)
self.db.add(token)
self.db.commit()
refresh_token = RefreshTokenSchema().dump(token).data
return refresh_token
@rpc
def get(self, token_uuid):
refresh_token = self.db.query(RefreshToken).get(token_uuid)
return RefreshTokenSchema().dump(refresh_token).data
@rpc
def get_tokens(self, id, uid):
refresh_tokens = self.db.query(RefreshToken.id, RefreshToken.ip_address, RefreshToken.user_agent, RefreshToken.user_id, case([(RefreshToken.id==id, True)], else_=False).label("is_current")).filter_by(user_id = uid, revoke = False)
return TokensSchema.dump(refresh_tokens).data
@rpc
def set_revoke(self, token_uuid):
refresh_token = self.db.query(RefreshToken).get(token_uuid)
refresh_token.revoke = True
self.db.commit()
return RefreshTokenSchema().dump(refresh_token).data
class Command:
name = 'command_politics'
dispatch = EventDispatcher()
db = DatabaseSession(Base)
@rpc
def add_news(self, data):
try:
version = 1
if data.get('version'):
version = (data.get('version') + 1)
if data.get('id'):
id = data.get('id')
else:
id = self.db.execute(Sequence('news_id_seq'))
news = CommandNewsModel(
id=id,
version=version,
title=data['title'],
content=data['content'],
author=data['author'],
published_at=data.get('published_at'),
tags=data['tags'],
)
self.db.add(news)
self.db.commit()
data['id'] = news.id
data['version'] = news.version
self.dispatch('replicate_db_event', data)
return data
except Exception as e:
self.db.rollback()
return e
class Service:
name = 'service'
db = DatabaseSession(DeclarativeBase)
event_dispatcher = EventDispatcher()
@rpc
def get_pessoa(self, pessoa_id):
pessoa = self.db.query(Pessoa)(pessoa_id)
if not pessoa:
raise Notfound('Pessoa com id {} não encontrada'.format(pessoa_id))
return PessoaSchema().dump(pessoa)
@rpc
def create_pessoa(self, pessoa):
p = Pessoa(
nome=pessoa['nome'],
endereco=pessoa['endereco'],
cpf=pessoa['cpf']
)
self.db.add(p)
self.db.commit()
p = PessoaSchema().dump(p)
self.event_dispatcher('pessoa_criada', {
'pessoa': p,
})
return pessoa
@rpc
def get_dividas(self, pessoa_id):
dividas = self.db.query(Divida)(pessoa_id)
if not dividas:
raise Notfound('Dividas para pessoa com id {} não encontradas'.format(pessoa_id))
return DividaSchema().dump(dividas)
@rpc
def create_divida(self, divida_nova):
divida = Divida(
pessoa_id=divida_nova['pessoa_id'],
)
self.db.add(divida)
self.db.commit()
divida = DividaSchema().dump(divida)
self.event_dispatcher('divida_criada', {
'divida': divida,
})
return divida
class OrdersService:
name = 'orders'
db = DatabaseSession(DeclarativeBase)
event_dispatcher = EventDispatcher()
@rpc
def get_order(self, order_id):
order = self.db.query(Order).get(order_id)
if not order:
raise NotFound('Order with id {} not found'.format(order_id))
return OrderSchema().dump(order).data
@rpc
def create_order(self, order_details):
order = Order(order_details=[
OrderDetail(product_id=order_detail['product_id'],
price=order_detail['price'],
quantity=order_detail['quantity'])
for order_detail in order_details
])
self.db.add(order)
self.db.commit()
order = OrderSchema().dump(order).data
self.event_dispatcher('order_created', {
'order': order,
})
return order
@rpc
def update_order(self, order):
order_details = {
order_details['id']: order_details
for order_details in order['order_details']
}
order = self.db.query(Order).get(order['id'])
for order_detail in order.order_details:
order_detail.price = order_details[order_detail.id]['price']
order_detail.quantity = order_details[order_detail.id]['quantity']
self.db.commit()
return OrderSchema().dump(order).data
@rpc
def delete_order(self, order_id):
order = self.db.query(OrderDetail).get(order_id)
self.db.delete(order)
self.db.commit()
order = self.db.query(Order).get(order_id)
self.db.delete(order)
self.db.commit()
class CommandBrands:
name = BRANDS_COMMAND_SERVICE
dispatch = EventDispatcher()
db = DatabaseSession(DeclarativeBase)
def fire_replicate_db_event(self, data):
""" fires off a replication event,
this expose the event-sourcing pattern which will send the
record to the query database from the command database """
self.dispatch(REPLICATE_EVENT, data)
@rpc
def add(self, payload):
if isinstance(payload, str):
payload = json.loads(payload)
name = payload.get('name')
item = ProductBrand()
item.name = name
self.db.add(item)
self.db.commit()
payload['id'] = item.id
payload['updated_at'] = item.updated_at
payload['created_at'] = item.created_at
self.fire_replicate_db_event(payload)
return payload
@rpc
def update(self, id, payload):
brand = self.db.query(ProductBrand).get(id)
if brand is None:
raise NotFound()
brand.name = payload.get('name')
brand.updated_at = datetime.datetime.utcnow()
self.db.add(brand)
self.db.commit()
payload['id'] = brand.id
payload['created_at'] = brand.created_at
payload['updated_at'] = brand.updated_at
self.fire_replicate_db_event(payload)
return payload
@rpc
def delete(self, id):
product_brand = self.db.query(ProductBrand).get(id)
self.db.delete(product_brand)
self.db.commit()
class ProcessesService:
"""Discovery of processes that are available at the back-end.
"""
name = "processes"
db = DatabaseSession(Base)
@rpc
def create(self, user_id: str=None, **process_args):
"""The request will ask the back-end to create a new process using the description send in the request body.
Keyword Arguments:
user_id {str} -- The identifier of the user (default: {None})
"""
try:
parameters = process_args.pop("parameters", {})
process = Process(**{"user_id": user_id, **process_args})
for parameter_name, parameter_specs in parameters.items():
parameter = Parameter(**{"name":parameter_name, "process_id": process.id, **parameter_specs})
self.db.add(parameter)
self.db.add(process)
self.db.commit()
return {
"status": "success",
"code": 201,
"data": "The process {0} has been successfully created.".format(process_args["name"])
}
except exc.IntegrityError as exp:
msg = "Process '{0}' does already exist.".format(
process_args["name"])
return ServiceException(ProcessesService.name, 400, user_id, msg, internal=False,
links=["#tag/EO-Data-Discovery/paths/~1processes/post"]).to_dict()
except Exception as exp:
return ServiceException(ProcessesService.name, 500, user_id, str(exp)).to_dict()
@rpc
def get_all(self, user_id: str=None):
"""The request asks the back-end for available processes and returns detailed process descriptions.
Keyword Arguments:
user_id {str} -- The identifier of the user (default: {None})
"""
try:
processes = self.db.query(Process).order_by(Process.name).all()
return {
"status": "success",
"code": 200,
"data": ProcessSchema(many=True).dump(processes).data
}
except Exception as exp:
return ServiceException(ProcessesService.name, 500, user_id, str(exp)).to_dict()
class ClientService(object):
name = "client"
db = DatabaseSession(Base)
@rpc
def get(self, ecoded_cid):
cid = b64decode(ecoded_cid)
client = self.db.query(Client).filter_by(cid = cid).first()
return ClientSchema().dump(client).data
class ExampleService(object):
name = "exampleservice"
session = DatabaseSession(dec_base)
event_dispatcher = EventDispatcher()
example_crud = AutoCrudWithEvents(
'session',
'event_dispatcher',
model_cls=example_model,
to_event_serializable=lambda obj: {'name': obj.name})
class Service:
name = "service"
db = DatabaseSession(Base)
@rpc
def save(self, value):
result = Result(value=value)
self.db.add(result)
self.db.commit()
class ExampleService(object):
name = "exampleservice"
session = DatabaseSession(dec_base)
event_dispatcher = EventDispatcher()
example_crud = AutoCrudWithEvents(
'session',
'event_dispatcher',
model_cls=example_model,
)
class CommandSite:
name = SITE_COMMAND
dispatch = EventDispatcher()
db = DatabaseSession(DeclarativeBase)
def _save_to_db(self, item):
self.db.add(item)
self.db.commit()
@rpc
def add(self, payload):
if isinstance(payload, str):
payload = json.loads(payload)
name = payload.get('name')
zip_code = payload.get('zip_code')
type_id = payload.get('type_id')
site = Site(name=name, zip_code=zip_code, type_id=type_id)
self._save_to_db(site)
payload['id'] = site.id
payload['created_at'] = site.created_at
payload['updated_at'] = site.updated_at
self.dispatch(REPLICATE_EVENT, payload)
return payload
@rpc
def update(self, id, payload):
if isinstance(payload, str):
payload = json.loads(payload)
site = self.db.query(Site).get(id)
if site is None:
raise NotFound()
site.name = payload.get('name', site.name)
site.zip_code = payload.get('zip_code', site.zip_code)
site.type_id = payload.get('type_id', site.type_id)
site.updated_at = datetime.datetime.utcnow()
self._save_to_db(site)
payload['id'] = site.id
payload['updated_at'] = site.updated_at
self.dispatch(REPLICATE_EVENT, payload)
class Events:
name = 'events'
db = DatabaseSession(Base)
@event_handler('command_stack', 'user_created')
def user_created_normalize_db(self, data):
try:
UsersQueryModel(id=data['id'],
name=data['name'],
email=data.get('email'),
description=data.get('description'),
permission=data.get('permission')).save()
except Exception as e:
return e
class AuthService:
name = "auth"
db = DatabaseSession(Base)
crypt = CryptHandler()
@rpc
def health(self, request):
return { "status": "success"}
@rpc
def login(self, user_id, password):
try:
user = self.db.query(User).filter_by(user_id=user_id).first()
if not user:
raise NotFound("User does not exist.")
if user.password != self.crypt.generate_hash(password, user.password):
raise LoginError("Password is not correct.")
return {
"status": "success",
"data": {
"user_id": user.user_id,
"auth_token": self.crypt.encode_auth_token(user.id)
}
}
except (NotFound, LoginError) as exp:
return {"status": "error", "service": self.name, "key": "Forbidden", "msg": str(exp)}
except Exception as exp:
return {"status": "error", "service": self.name, "key": "InternalServerError", "msg": str(exp)}
@rpc
def identify(self, token):
try:
user_id = self.crypt.decode_auth_token(token)
user = self.db.query(User).filter_by(id=user_id).first()
if not user:
raise NotFound("User does not exist.")
return {
"status": "success",
"data": UserSchema().dump(user).data
}
except (LoginError, InvalidSignatureError) as exp:
return {"status": "error", "service": self.name, "key": "Forbidden", "msg": str(exp)}
except Exception as exp:
return {"status": "error", "service": self.name, "key": "InternalServerError", "msg": str(exp)}
class CollegeService:
name = 'college_service'
db = DatabaseSession(DeclarativeBase)
@rpc
def ping(self):
return 'alive'
@rpc
def process(self, name):
id = str(uuid.uuid4())
temp_data = TempTable()
temp_data.name = name
temp_data.id = id
self.db.add(temp_data)
self.db.commit()
temp_datax = self.db.query(TempTable).filter_by(id=id).first()
return temp_datax.name
@rpc
def process_college(self, college_data):
college = College()
college.unitid = college_data['UNITID']
college.name = college_data['INSTNM']
college.address1 = college_data['ADDR']
college.city = college_data['CITY']
college.state = college_data['STABBR']
college.phone = college_data['GENTELE']
college.web_url = college_data['WEBADDR']
college.admissions_url = college_data['ADMINURL']
college.netprice_url = college_data['NPRICURL']
college.sector = college_data['SECTOR']
college.locale = college_data['LOCALE']
college.hbcu = college_data['HBCU']
college.latitude = college_data['LATITUDE']
college.longitude = college_data['LONGITUD']
#upsert
statement = pg_insert(College).values(
**college.as_dict()).on_conflict_do_update(
constraint='college_pkey', set_=college.props_dict())
self.db.execute(statement)
self.db.commit()
return college.name
class ProductService:
name = 'service_product'
db = DatabaseSession(DeclarativeBase)
event_dispatcher = EventDispatcher()
@rpc
def get_product(self, productId):
product = self.db.query(Product).get(productId)
if not product:
raise ProductNotFound(f'Product Id:{productId} not found!')
return ProductSchema(strict=True).dump(product)
@rpc
def create_product(self, product):
p = Product(name=product['name'],
description=product['description'],
short_description=product['short_description'],
reference=product['reference'],
warehouse_id=product['warehouse_id'])
self.db.add(p)
self.db.commit()
p = ProductSchema(strict=True).dump(p)
self.event_dispatcher('product_created', {'product': p})
return product
@rpc
def get_warehouse(self, warehouseId):
warehouse = self.db.query(Warehouse).get(warehouseId)
if not warehouse:
raise f'Warehouse Id:{warehouseId} not found!'
return ProductSchema(strict=True).dump(warehouse)
@rpc
def create_warehouse(self, warehouse):
w = Warehouse(name=warehouse['name'])
self.db.add(w)
self.db.commit()
w = WarehouseSchema(strict=True).dump(w)
self.event_dispatcher('warehouse_created', {'warehouse': w})
return warehouse
class ArticleService(AuthorMixin, ReviewMixin, ArticleMixin):
name = "articles"
tracer = Tracer()
db_session = DatabaseSession(DeclarativeBase)
event_dispatcher = EventDispatcher()
@http("GET", "/healthcheck")
def health_check_http(self, request):
return json.dumps(self.health_check())
@rpc
def health_check(self):
return {"status": "ok"}
class ExampleService(object):
name = "exampleservice"
session = DatabaseSession(DeclBase)
@dummy
def write(self, value):
obj = ExampleModel(data=value)
self.session.add(obj)
self.session.commit()
return obj.id
@dummy
def read(self, id):
return self.session.query(ExampleModel).get(id).data
class UsersService:
name = "users"
db = DatabaseSession(Base)
@rpc
def create_user(self, user_data):
user = User(username=user_data["username"],
email=user_data["email"],
password=user_data["password"],
project=user_data["project"],
sa_token=user_data["sa_token"])
self.db.add(user)
self.db.commit()
return UserSchema().dump(user)
@rpc
def get_user(self, id):
user = self.db.query(User).get(id)
if not user:
raise NotFound("User with id {0} not found".format(id))
return UserSchema().dump(user)
@rpc
def update_user(self, id, user_data):
user = self.db.query(User).get(id)
for key, value in user_data.items():
if key == "password":
user.password = user.generate_hash(value)
else:
setattr(user, key, value)
self.db.commit()
return UserSchema().dump(user)
@rpc
def delete_user(self, id):
user = self.db.query(User).get(id)
self.db.delete(user)
self.db.commit()
class CommandNewsService:
name = 'command_stack'
dispatcher = EventDispatcher()
db = DatabaseSession(Base)
@rpc
def news_domain(self, data):
try:
data['id'] = str(uuid.uuid1())
news = NewsCommandModel(data)
self.db.add(news)
self.db.commit()
self.dispatcher('news_created', data)
return data.get('id')
except Exception as e:
self.db.rollback()
logging.error(e)
class OrdersService:
name = 'orders'
log = StructlogDependency()
dispatch = EventDispatcher()
db = DatabaseSession(DeclarativeBase)
carts_rpc = RpcProxy('carts')
@rpc
def health_check(self):
self.log.info(f'orders.health:: start')
response = 'Orders service is up and running!'
self.log.info(f'orders.health:: response {response}')
self.log.info(f'orders.health:: end')
return response
@rpc
def create(self, cart_id):
self.log.info(f'orders.create:: start')
self.log.info(f'orders.create:: cart id {cart_id}')
cart = self.carts_rpc.show(cart_id)
order = Order(
total_price=cart['total_price'],
products=[
Product(
serial_number=product['id'],
title=product['title'],
description=product['description'],
price=product['price'],
quantity=product['quantity']
)
for product in cart['products']
]
)
self.db.add(order)
self.db.commit()
order = OrderSchema().dump(order)
self.log.info(f'orders.create: order {order}')
payload = {'order': order, 'cart_id': cart_id}
self.dispatch('order_created', payload)
self.log.info(f'orders.create:: end')
return order
class ContactsService:
name = 'contacts'
session = DatabaseSession(DeclarativeBase)
dispatch = EventDispatcher()
auto_crud = AutoCrudWithEvents(
session,
dispatch,
'contact',
model_cls=Contact,
get_method_name='get_contact',
create_method_name='create_contact',
update_method_name='update_contact',
list_method_name='list_contacts',
count_method_name='count_contacts',
create_event_name='contact_created',
update_event_name='contact_updated',
)
class CommandStack:
name = 'command_stack'
dispatch = EventDispatcher()
db = DatabaseSession(Base)
@rpc
def create_user(self, data):
try:
user = UsersCommandModel(id=data['id'],
name=data['name'],
email=data['email'],
description=data['description'],
permission=data['permission'])
self.db.add(user)
self.db.commit()
data['id'] = user.id
self.dispatch('user_created', data)
return data
except Exception as e:
self.db.rollback()
return e
class ExampleService(object):
name = "exampleservice"
session = DatabaseSession(dec_base)
example_crud = AutoCrud('session',
model_cls=example_model,
list_method_name='_list_examplemodels',
delete_method_name=None)
@rpc
def get_examplemodel(self, id_):
""" Method should not be overwritten """
return "hello"
@rpc
def list_examplemodels(self, *args, **kwargs):
""" Enhancing default method behaviour """
results = self._list_examplemodels(*args, **kwargs)
for result in results:
result['more'] = 'data'
return results
class StudentService:
name = 'student_service'
db = DatabaseSession(DeclarativeBase)
@rpc
def ping(self):
return 'alive'
@rpc
def process(self, name):
id = str(uuid.uuid4())
temp_data = TempTable()
temp_data.name = name
temp_data.id = id
self.db.add(temp_data)
self.db.commit()
temp_datax = self.db.query(TempTable).filter_by(id=id).first()
return temp_datax.name
