def get(self):
try:
action_type = 'GET'
parser = reqparse.RequestParser()
parser.add_argument('user_id')
args = parser.parse_args()
if (len(args) == 0):
abort(400, message='Arguments not found')
user_id = args['user_id']
user_action_logging.log_user_actions(ROUTE, user_id, action_type)
product_categories = session.query(ProductCategories).filter(
ProductCategories.is_delete == False).all()
if not product_categories:
abort(400,
message='Ошибка получения данных. Данные не найдены')
categories_without_products = []
for product_category in product_categories:
product = session.query(Products).filter(
Products.category_id == product_category.id).first()
if (product == None):
categories_without_products.append(product_category)
return categories_without_products
except Exception as e:
if (hasattr(e, 'data')):
if (e.data != None and "message" in e.data):
abort(400, message=e.data["message"])
abort(400, message="Неопознанная ошибка")
def get(self):
try:
action_type='GET'
parser = reqparse.RequestParser()
parser.add_argument('user_id')
parser.add_argument('request_user_id')
args = parser.parse_args()
if (len(args) == 0):
abort(400, message='Arguments not found')
user_id = args['user_id']
request_user_id = args['request_user_id']
user_action_logging.log_user_actions(ROUTE,user_id, action_type)
user = session.query(Users).filter(Users.id==request_user_id).first()
if not user:
abort(400, message='Ошибка получения данных. Данные не найдены')
user.user_login = session.query(UserLogins).filter(UserLogins.user_id==user.id).first()
user.user_info_data = session.query(UserInfo).filter(UserInfo.user_id == user.id).first()
return user
except Exception as e:
if (hasattr(e,'data')):
if (e.data!=None and "message" in e.data):
abort(400,message =e.data["message"])
abort(400, message = "Неопознанная ошибка")
def validate_userdata(user: UserCreate):
if session.query(User).filter(User.email.is_(user.email)).first():
raise IOError('Email Already in use')
if session.query(User).filter(User.username.is_(user.username)).first():
raise IOError('Username Already in use')
if len(user.password) < 8:
raise IOError('Password cannot be less than 8 characters')
def fan_out(self, period=30):
LOGGER.debug('Fanning out rows...')
stations = session.query(WeatherStation).filter_by(is_sent=0).all()
for station in stations:
session.begin()
try:
LOGGER.debug('Fanning out station %s' % str(station))
self.publish_station(station)
station.is_sent = 1
session.commit()
except Exception as e:
LOGGER.error('Error %s when processing station.', str(e))
session.rollback()
raise
metrics = session.query(Metric).filter_by(is_sent=0).all()
for metric in metrics:
session.begin()
try:
LOGGER.debug('Fanning out metric %s' % str(metric))
self.publish_metric(metric)
metric.is_sent = 1
session.commit()
except Exception as e:
LOGGER.error('Error %s when processing metric.', str(e))
session.rollback()
raise
threading.Timer(period, self.fan_out, [period]).start() # Periodic loop.
def get(self):
try:
# session.autocommit = False
# session.autoflush = False
entities = session.query(MODEL).filter(MODEL.is_delete == False).all()
for entity in entities:
entity.images_data = []
api_url = settings.API_URL
# if hasattr(entity, 'default_image_data'):
# if (entity.default_image_data != None and entity.default_image_data.file_path != None):
# entity.default_image_data.file_path = urllib.parse.urljoin(api_url,
# entity.default_image_data.file_path)
# if hasattr(entity, 'default_image_data'):
# if (entity.default_image_data != None and entity.default_image_data.thumb_file_path != None):
# entity.default_image_data.thumb_file_path = urllib.parse.urljoin(api_url,
# entity.default_image_data.thumb_file_path)
# if hasattr(entity, 'default_image_data'):
# if (entity.default_image_data != None and entity.default_image_data.optimized_size_file_path != None):
# entity.default_image_data.optimized_size_file_path = urllib.parse.urljoin(api_url,
# entity.default_image_data.optimized_size_file_path)
if (entity.gallery_images != None and len(entity.gallery_images) > 0):
for img_id in entity.gallery_images:
image = session.query(Attachments).filter(Attachments.id == img_id).first()
if not image:
continue
entity.images_data.append(image)
return entities
except Exception as e:
session.rollback()
abort(400, message="Error while update " + ENTITY_NAME)
finally:
pass
def filter_by_favorites(self, user_id):
try:
user_favorite_products = session.query(
UserFavoriteProducts).filter(
UserFavoriteProducts.user_id == user_id).first()
if (not user_favorite_products):
abort(400, message="Not found favorite products")
if (not user_favorite_products):
abort(400, message="Not found favorite products")
products = []
for favorite_product_id in user_favorite_products.products_ids:
product = session.query(Products).filter(
Products.id == favorite_product_id).first()
if (not product):
continue
products.append(product)
return products
except Exception as e:
return None
def filter_by_recommendations(self):
try:
view_settings = session.query(ViewSettings).first()
if (not view_settings):
return None
products = []
rec_elements = view_settings.recomendation_elements
if (not rec_elements):
return None
for rec_element in rec_elements:
product = session.query(Products).filter(
Products.id == rec_element).first()
if (not product):
continue
products.append(product)
return products
pass
except Exception as e:
return None
def get_items(object_id, type_id):
from models.db_models.models import Schemas
from models.db_models.models import Objects
items = []
object = session.query(Objects).filter(Objects.id == object_id).first()
schema = session.query(Schemas).filter(
Schemas.id == object.schema_id).first()
data = json.loads(schema.data)
fields = data["fields"]
for f in fields:
if (f["field_type"] == 5):
v = f["var"]
id = v["schema_id"]
nm = v["title"]
t_schema = session.query(Schemas).filter(Schemas.id == id).first()
if (t_schema.schema_type_id == type_id):
ob = d_object.DynamicObject()
setattr(ob, 'id', id)
setattr(ob, 'name', nm)
items.append(ob)
return items
def get(self):
try:
entities = session.query(MODEL).order_by((MODEL.name)).all()
# session.autocommit = False
# session.autoflush = False
for entity in entities:
entity.images_data = []
if (entity.images != None and len(entity.images) > 0):
for img_id in entity.images:
image = session.query(Attachments).filter(
Attachments.id == img_id).first()
if not image:
continue
entity.images_data.append(image)
entity.products_count = 0
products = session.query(Products).filter(
Products.brand_id == entity.id,
Products.not_show_in_catalog != True,
Products.is_delete != True).all()
if (not products):
entity.products_count = 0
else:
entity.products_count = len(products)
return entities
except Exception as e:
session.rollback()
abort(400, message="Error while update " + ENTITY_NAME)
finally:
pass
def get(self):
try:
action_type = 'GET'
parser = reqparse.RequestParser()
parser.add_argument('user_id')
parser.add_argument('product_id')
args = parser.parse_args()
if (len(args) == 0):
abort(400, message='Arguments not found')
user_id = args['user_id']
product_id = args['product_id']
user_action_logging.log_user_actions(ROUTE, user_id, action_type)
# check login
product = session.query(Products).filter(
Products.id == product_id).first()
if not product:
abort(400,
message='Ошибка получения данных. Данные не найдены')
entity = product
if not entity:
abort(404,
message=ENTITY_NAME + " {} doesn't exist".format(id))
#api_url = settings.API_URL
# if hasattr(entity, 'default_image_data'):
# if (entity.default_image_data != None and entity.default_image_data.file_path != None):
# entity.default_image_data.file_path = urllib.parse.urljoin(api_url,
# entity.default_image_data.file_path)
# if hasattr(entity, 'default_image_data'):
# if (entity.default_image_data != None and entity.default_image_data.thumb_file_path != None):
# entity.default_image_data.thumb_file_path = urllib.parse.urljoin(api_url,
# entity.default_image_data.thumb_file_path)
# if hasattr(entity, 'default_image_data'):
# if (entity.default_image_data != None and entity.default_image_data.optimized_size_file_path != None):
# entity.default_image_data.optimized_size_file_path = urllib.parse.urljoin(api_url,
# entity.default_image_data.optimized_size_file_path)
entity.images_data = []
if (entity.gallery_images != None
and len(entity.gallery_images) > 0):
for img_id in entity.gallery_images:
image = session.query(Attachments).filter(
Attachments.id == img_id).first()
if not image:
continue
entity.images_data.append(image)
return entity
except Exception as e:
if (hasattr(e, 'data')):
if (e.data != None and "message" in e.data):
abort(400, message=e.data["message"])
abort(400, message="Неопознанная ошибка")
finally:
pass
def config_import():
with open(config_path, 'r') as f:
cc_json = json.load(f)
cc = ChimeraConfig()
for key, value in cc_json.items():
setattr(cc, key, value)
session.query(ChimeraConfig).delete()
session.add(cc)
session.commit()
print('Config imported, restart chimera!')
def clean_log_by_condition():
try:
logs = session.query(Log).all()
if (len(logs) > 2000):
session.query(Log).delete()
session.commit()
pass
except Exception as e:
session.rollback()
def put(self, id):
try:
# session.autocommit = False
# session.autoflush = False
json_data = request.get_json(force=True)
entity = session.query(MODEL).filter(MODEL.id == id).first()
if not entity:
abort(404,
message=ENTITY_NAME + " {} doesn't exist".format(id))
product_positions = session.query(ProductsPositions).filter(
ProductsPositions.products_positions.any(entity.id)).all()
if product_positions is not None:
session.bulk_update_mappings(ProductsPositions, [{
'id':
x.id,
'products_positions':
list(filter(lambda y: y != entity.id,
x.products_positions))
} for x in product_positions])
session.commit()
db_transformer.transform_update_params(entity, json_data)
session.add(entity)
session.commit()
# api_url = settings.API_URL
# if hasattr(entity, 'default_image_data'):
# if (entity.default_image_data != None and entity.default_image_data.file_path != None):
# entity.default_image_data.file_path = urllib.parse.urljoin(api_url,
# entity.default_image_data.file_path)
# if hasattr(entity, 'default_image_data'):
# if (entity.default_image_data != None and entity.default_image_data.thumb_file_path != None):
# entity.default_image_data.thumb_file_path = urllib.parse.urljoin(api_url,
# entity.default_image_data.thumb_file_path)
# if hasattr(entity, 'default_image_data'):
# if (entity.default_image_data != None and entity.default_image_data.optimized_size_file_path != None):
# entity.default_image_data.optimized_size_file_path = urllib.parse.urljoin(api_url,
# entity.default_image_data.optimized_size_file_path)
entity.images_data = []
if (entity.gallery_images != None
and len(entity.gallery_images) > 0):
for img_id in entity.gallery_images:
image = session.query(Attachments).filter(
Attachments.id == img_id).first()
if not image:
continue
entity.images_data.append(image)
return entity, 201
except Exception as e:
session.rollback()
abort(400, message="Error while update " + ENTITY_NAME)
finally:
pass
def get(self):
entities = session.query(MODEL).all()
for entity in entities:
entity.order_user_data = session.query(Users).filter(
Users.id == entity.user_id).first()
if entity.executor_id is not None:
entity.order_executor_data = session.query(Users).filter(
Users.id == entity.executor_id).first()
return entities
def get(self):
try:
action_type = 'GET'
parser = reqparse.RequestParser()
parser.add_argument('user_id')
parser.add_argument('product_id')
args = parser.parse_args()
if (len(args) == 0):
abort(400, message='Arguments not found')
user_id = args['user_id']
product_id = args['product_id']
user_action_logging.log_user_actions(ROUTE, user_id, action_type)
product = session.query(Products).filter(
Products.id == product_id).first()
t = 0
products = session.query(Products).filter(
Products.id != product_id, Products.is_delete == False).all()
if not products:
abort(400,
message='Ошибка получения данных. Данные не найдены')
if (not product):
return products
recommendations = product.product_recomendations
if (not recommendations):
# если у продукта нет рекомендаций то выводим весь список товаров
rec_products = session.query(Products).filter(
Products.id != product_id,
Products.is_delete == False).all()
for r_product in rec_products:
r_product.is_recommend = False
return rec_products
if (len(recommendations) > 0):
for pr in products:
p_id = pr.id
if ((p_id in recommendations) == True):
pr.is_recommend = True
else:
pr.is_recommend = False
return products
except Exception as e:
if (hasattr(e, 'data')):
if (e.data != None and "message" in e.data):
abort(400, message=e.data["message"])
abort(400, message="Неопознанная ошибка")
def put(self, id):
try:
# session.autocommit = False
# session.autoflush = False
json_data = request.get_json(force=True)
entity = session.query(MODEL).filter(MODEL.id == id).first()
if not entity:
abort(404, message=ENTITY_NAME + " {} doesn't exist".format(id))
# check if this category has another parent_id, so we should delete it from positions
if json_data['parent_category_id'] != entity.parent_category_id\
or json_data.get('is_delete', False)\
or json_data.get('is_lock', False):
position = session.query(ProductCategoryPositions) \
.filter(ProductCategoryPositions.parent_category_id == entity.parent_category_id).first()
if position is not None:
position.child_category_positions = [e for e in position.child_category_positions if e != entity.id]
session.add(position)
session.commit()
db_transformer.transform_update_params(entity, json_data)
session.add(entity)
session.commit()
# session.close()
# api_url = settings.API_URL
# if hasattr(entity, 'default_image_data'):
# if (entity.default_image_data != None and entity.default_image_data.file_path != None):
# entity.default_image_data.file_path = urllib.parse.urljoin(api_url,
# entity.default_image_data.file_path)
# if hasattr(entity, 'default_image_data'):
# if (entity.default_image_data != None and entity.default_image_data.thumb_file_path != None):
# entity.default_image_data.thumb_file_path = urllib.parse.urljoin(api_url,
# entity.default_image_data.thumb_file_path)
# if hasattr(entity, 'default_image_data'):
# if (entity.default_image_data != None and entity.default_image_data.optimized_size_file_path != None):
# entity.default_image_data.optimized_size_file_path = urllib.parse.urljoin(api_url,
# entity.default_image_data.optimized_size_file_path)
#
entity.images_data = []
if entity.images is not None and len(entity.images) > 0:
for img_id in entity.images:
image = session.query(Attachments).filter(Attachments.id == img_id).first()
if not image:
continue
entity.images_data.append(image)
return entity, 201
except Exception as e:
session.rollback()
abort(400, message="Error while update " + ENTITY_NAME)
finally:
pass
def delete(self, id):
try:
entity = session.query(MODEL).filter(MODEL.id == id).first()
if not entity:
abort(404, message=ENTITY_NAME + " {} doesn't exist".format(id))
prods = session.query(Products).filter(Products.product_recomendations.any(entity.id)).all()
if prods is not None:
session.bulk_update_mappings(Products, [{'id': x.id,
'product_recomendations': list(
filter(lambda y: y != entity.id, x.product_recomendations))}
for x in prods])
session.commit()
v_settings = session.query(ViewSettings).filter(ViewSettings.recomendation_elements.any(entity.id)).all()
if v_settings is not None:
session.bulk_update_mappings(ViewSettings, [{'id': x.id,
'recomendation_elements': list(
filter(lambda y: y != entity.id,
x.recomendation_elements))}
for x in v_settings])
session.commit()
user_favorites = session.query(UserFavoriteProducts).filter(
UserFavoriteProducts.products_ids.any(entity.id)).all()
if user_favorites is not None:
session.bulk_update_mappings(UserFavoriteProducts, [{'id': x.id,
'products_ids': list(
filter(lambda y: y != entity.id,
x.products_ids))}
for x in user_favorites])
session.commit()
product_positions = session.query(ProductsPositions).filter(
ProductsPositions.products_positions.any(entity.id)).all()
if product_positions is not None:
session.bulk_update_mappings(ProductsPositions, [{'id': x.id,
'products_positions': list(
filter(lambda y: y != entity.id,
x.products_positions))}
for x in product_positions])
session.commit()
entity.is_delete = True
session.add(entity)
session.commit()
return {}, 204
except Exception as e:
session.rollback()
abort(400, message="Error while remove " + ENTITY_NAME)
def get(self):
try:
action_type = 'GET'
parser = reqparse.RequestParser()
parser.add_argument('user_id')
args = parser.parse_args()
if (len(args) == 0):
abort(400, message='Arguments not found')
user_id = args['user_id']
user_action_logging.log_user_actions(ROUTE, user_id, action_type)
orders = []
# check login
orders = session.query(Orders).filter(
Orders.user_id == user_id).order_by(desc(Orders.id)).all()
if not orders:
return []
for entity in orders:
entity.display_creation_date = entity.creation_date.strftime(
"%Y-%m-%d %H:%M")
if (entity.processed_date != None):
entity.display_processed_date = entity.processed_date.strftime(
"%Y-%m-%d %H:%M")
if (entity.execute_date != None):
entity.display_execute_date = entity.execute_date.strftime(
"%Y-%m-%d %H:%M")
entity.order_user_data = session.query(Users).filter(
Users.id == entity.user_id).first()
if (entity.executor_id != None):
entity.order_executor_data = session.query(Users).filter(
Users.id == entity.executor_id).first()
entity.bonuses = 0
bonus = session.query(UserBonuses).filter(
UserBonuses.order_id == entity.id).first()
if (bonus != None):
entity.bonuses = bonus.amount
return orders
except Exception as e:
if (hasattr(e, 'data')):
if (e.data != None and "message" in e.data):
abort(400, message=e.data["message"])
abort(400, message="Неопознанная ошибка")
def get(self):
try:
action_type = 'GET'
parser = reqparse.RequestParser()
parser.add_argument('user_id')
parser.add_argument('code')
args = parser.parse_args()
if (len(args) == 0):
abort(400, message='Arguments not found')
user_id = args['user_id']
code = args['code']
user_action_logging.log_user_actions(ROUTE, user_id, action_type)
#products = session.query(Products).filter(Products.category_id==category_id).order_by(desc(Products.id)).all()
user_confirmation_code = session.query(
UserConfirmationCodes).filter(
UserConfirmationCodes.user_id == user_id).order_by(
desc(UserConfirmationCodes.id)).first()
if (not user_confirmation_code):
abort(400, message='Error')
if (user_confirmation_code.code != str(code)):
abort(400, message='Error')
user = session.query(Users).filter(Users.id == user_id).first()
if (not user):
abort(400, message='Error')
user.lock_state = False
session.add(user)
session.commit()
response = {'status_code': 200}
# response = object()
#
#
# response.status_code = type('', (), {})
# setattr(response,'status_code',200)
#
# response.status_code =200
# setattr(response,'status_code',200)
return response
except Exception as e:
if (hasattr(e, 'data')):
if (e.data != None and "message" in e.data):
abort(400, message=e.data["message"])
abort(400, message="Неопознанная ошибка")
def filter_by_popular(self):
try:
limit = 10
order_positions = session.query(OrderPositions).all()
p_ids = []
for order_position in order_positions:
if (order_position.product_id in p_ids == True):
continue
else:
p_ids.append(order_position.product_id)
pass
f_products = []
for p_id in p_ids:
ps = session.query(OrderPositions).filter(
OrderPositions.product_id == p_id).all()
count = 0
for p in ps:
count += p.count
f_products.append([p_id, count])
sorted(f_products, key=itemgetter(1))
result_products = []
counter = 0
for pr in f_products:
if (counter >= limit):
break
p_id = pr[0]
product = session.query(Products).filter(
Products.id == p_id).first()
if (not product):
continue
result_products.append(product)
# products = session.query(Products).filter(Products.name.ilike(r_name)).all()
# return products
return result_products
except Exception as e:
return None
def get(self, clientId):
schemas = session.query(Schemas).filter(
and_(Schemas.schema_type_id != 3),
(Schemas.client_id == clientId)).all()
if not schemas:
abort(400, message="Schemas not found")
return schemas
def get(self, id):
shared_group_object = session.query(SharedGroupObjects).filter(
SharedGroupObjects.id == id).first()
if not shared_group_object:
abort(404,
message="Shared Group Object {} doesn't exist".format(id))
return shared_group_object
def get_to_schema(id):
from models.db_models.models import Schemas
from db.db import session
schema = session.query(Schemas).filter(Schemas.id == id).first()
return schema
pass
def check_default_address(entity):
try:
client_id = entity.client_id
is_default = entity.is_default
id = entity.id
client_addresses = session.query(ClientAddresses).filter(
ClientAddresses.client_id == client_id).all()
if (len(client_addresses) == 1):
for client_address in client_addresses:
client_address.is_default = True
session.add(client_address)
session.commit()
return
if (is_default == False):
return
for client_address in client_addresses:
if (client_address.id == id):
client_address.is_default = True
else:
client_address.is_default = False
session.add(client_address)
session.commit()
pass
except Exception as e:
pass
def get(self):
try:
action_type = 'GET'
parser = reqparse.RequestParser()
parser.add_argument('user_id')
args = parser.parse_args()
if (len(args) == 0):
abort(400, message='Arguments not found')
user_id = args['user_id']
user_bonuses = session.query(UserBonuses).filter(and_(
UserBonuses.user_id == user_id,
UserBonuses.state== True)) \
.all()
for bonus in user_bonuses:
bonus.state = False
session.add(bonus)
session.commit()
response = {'status': 200}
return response
except Exception as e:
if (hasattr(e, 'data')):
if (e.data != None and "message" in e.data):
abort(400, message=e.data["message"])
abort(400, message="Неопознанная ошибка")
def get(self):
try:
action_type = 'GET'
parser = reqparse.RequestParser()
parser.add_argument('user_id')
parser.add_argument('product_id')
args = parser.parse_args()
if (len(args) == 0):
abort(400, message='Arguments not found')
user_id = args['user_id']
product_id = args['product_id']
user_action_logging.log_user_actions(ROUTE, user_id, action_type)
# check login
comments = session.query(ProductComments).filter(
ProductComments.product_id == product_id).all()
if not comments:
return []
#abort(400, message='Ошибка получения данных. Данные не найдены')
return comments
except Exception as e:
if (hasattr(e, 'data')):
if (e.data != None and "message" in e.data):
abort(400, message=e.data["message"])
abort(400, message="Неопознанная ошибка")
def get_schema_by_id(id):
try:
from models.db_models.models import Schemas
schema = session.query(Schemas).filter(Schemas.id == id).first()
return schema
except Exception as e:
return None
def get(self, schemaId):
objects = session.query(Objects).filter(
Objects.schema_id == schemaId).all()
result = dt_generator.generate_dynamic_table_by_objects(objects)
return result
def get(self, id):
group_object_right = session.query(GroupObjectRights).filter(
GroupObjectRights.id == id).first()
if not group_object_right:
abort(404,
message="Group Object Rights {} doesn't exist".format(id))
return group_object_right
def post(self):
try:
json_data = request.get_json(force=True)
login = json_data["login"]
password = json_data["password"]
o_password = copy.copy(password)
t = bytes(password, 'utf-8')
password = str(base64.b64encode(t))
user_login = session.query(UserLogins).filter(and_(
UserLogins.login == login,
UserLogins.password == password))\
.first()
if user_login is None:
message = "Попытка авторизации с IP адреса " + request.remote_addr + ". Данными Login="******" Password="******"User doesn't exist")
user_login.last_login_date = datetime.datetime.now()
session.add(user_login)
message = "Пользователь " + user_login.user_data.first_name + " " + user_login.user_data.last_name + " зашел в кабинет (компания " + user_login.user_data.client.name + ")"
log = Log(message)
session.add(log)
session.commit()
return user_login
except Exception as e:
session.rollback()
abort(400, message="Error Auth")
def get(self):
try:
action_type = 'GET'
parser = reqparse.RequestParser()
parser.add_argument('user_id')
args = parser.parse_args()
if (len(args) == 0):
abort(400, message='Arguments not found')
user_id = args['user_id']
user_action_logging.log_user_actions(ROUTE, user_id, action_type)
# check login
settings = session.query(Settings).order_by(
Settings.id.desc()).all()
if not settings:
abort(400,
message='Ошибка получения данных. Данные не найдены')
return settings
except Exception as e:
if (hasattr(e, 'data')):
if (e.data != None and "message" in e.data):
abort(400, message=e.data["message"])
abort(400, message="Неопознанная ошибка")
def get_stations():
stations = session.query(WeatherStation).all()
stations_list = []
for station in stations:
station_dict = {
'id': station.id,
'name': station.name,
'position': {
'lat': station.latitude,
'lng': station.longitude,
},
'metric_types': [],
}
for metric_type in station.metric_types:
type_dict = {
'id': metric_type.id,
'name': metric_type.name,
'unit': metric_type.unit,
'last': []
}
metrics = (
session.query(Metric).
filter_by(weather_station=station, metric_type=metric_type).
order_by(Metric.timestamp.desc()).
limit(20)
)
for metric in metrics:
metric_dict = {
'value': metric.value,
'timestamp': metric.timestamp.strftime('%s'),
}
type_dict['last'].append(metric_dict)
station_dict['metric_types'].append(type_dict)
stations_list.append(station_dict)
return jsonp(request, {'stations': stations_list})
def on_message(self, unused_channel, basic_deliver, properties, body):
LOGGER.info('Received message # %s from %s: %s',
basic_deliver.delivery_tag, properties.app_id, body)
try:
msg_dict = json.loads(body)
action = msg_dict['action']
data = msg_dict['data']
if action == 'add_metric':
metric_type = session.query(MetricType).filter_by(
id=data['metric_type_id']).first()
station = session.query(WeatherStation).filter_by(
id=data['weather_station_id']).first()
metric = Metric(id=data['id'], value=data['value'],
metric_type=metric_type,
weather_station=station, is_sent=1,
timestamp=datetime.datetime.fromtimestamp(
data['timestamp']))
session.begin()
session.merge(metric)
session.commit()
elif action == 'add_station':
types = session.query(MetricType).filter(
MetricType.id.in_(data['metric_types'])).all()
station = WeatherStation(id=data['id'], name=data['name'],
latitude=data['latitude'],
longitude=data['longitude'],
metric_types=types, is_sent=1)
session.begin()
session.merge(station)
session.commit()
except Exception as e:
LOGGER.error('Error %s when processing message.', str(e))
self.acknowledge_message(basic_deliver.delivery_tag)
