def post(self):
# Load response template
template = JINJA_ENVIRONMENT.get_template('static/templates/api.json')
self.response.headers['Content-Type'] = 'application/json'
# Session request handler
current_session = Session(self)
# Retrieve uploaded info
upload_files = self.get_uploads("file")
blob_info = upload_files[0]
# Check if user can upload the photo
if current_session.get_role_level() < 2:
self.response.headers['Content-Type'] = 'application/json'
data = '{"error": "Permission denied"}'
result = "FAIL"
self.response.write(template.render(feature="photo",
data=data,
query=self.request.url,
result=result))
# Remove photo from blob store
blobstore.delete(blob_info.key)
return None
# Save photo to database
photo_id = database.PhotosManager.createPhoto("", current_session.get_user_key(), 2, blob_info.key())
# Prompt response to user
data = '{"photo_id": ' + str(photo_id) + '}'
result = "OK"
self.response.write(template.render(feature="photo", data=data, query=self.request.url, result=result))
def get(self, user_id):
# Session request handler
current_session = Session(self)
JINJA_ENVIRONMENT.globals['session'] = current_session
# Language request handler
Language.language(self)
# Retrieved user_id to integer
user_id = int(user_id)
# Retrieve user data
user = database.UserManager.select_by_id(user_id)
# Check if user can see the profile photo
if user.photo is not None:
profilePhoto = database.PhotosManager.get_photo_by_id(int(user.photo))
if current_session.get_id() is None:
profilePhotoAllowed = False
else:
requestUser = database.UserManager.select_by_id(current_session.get_id())
if security.PhotoSecurity.user_is_allowed_to_watch_photo(profilePhoto, requestUser):
profilePhotoAllowed = True
else:
profilePhotoAllowed = False
else:
profilePhotoAllowed = False
# Prompt page
template = JINJA_ENVIRONMENT.get_template('static/templates/profile.html')
self.response.write(template.render(user=user, profilePhotoAllowed=profilePhotoAllowed))
def post(self, photo_id):
# Session
current_session = Session(self)
# Load response template
template = JINJA_ENVIRONMENT.get_template('static/templates/api.json')
self.response.headers['Content-Type'] = 'application/json'
photo = database.PhotosManager.get_photo_by_id(int(photo_id))
if photo is None:
data = '{"error": "Photo does not exist."}'
result = "FAIL"
else:
# Check permission for this petition (only owner or admin can modify)
if(photo.owner == current_session.get_user_key()) or (current_session.get_role_level() > 2):
name = self.request.get('name')
privacy = int(self.request.get('privacy'))
database.PhotosManager.modify_photo(photo.key, name, privacy)
data = '{"message": "Changes done"}'
result = "OK"
else:
data = '{"error": "No permission to change."}'
result = "FAIL"
# Response result json
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
def get(self, option):
# Session
current_session = Session(self)
# Load response template
template = JINJA_ENVIRONMENT.get_template('static/templates/api.json')
self.response.headers['Content-Type'] = 'application/json'
if option == "list":
# List all accesible photos
photos = database.PhotosManager.retrieveAllPhotos()
if current_session.get_id() is None:
user = None
else:
user = database.UserManager.select_by_id(current_session.get_id())
data = '{"photos":['
isAnyPhotoAllowed = False
for photo in photos:
if security.PhotoSecurity.user_is_allowed_to_watch_photo(photo, user): # Check user has permission to retrieve
isAnyPhotoAllowed = True
id = photo.key.id()
username = photo.owner.get().name
date = photo.date
name = photo.name
data += '{"photo_id": ' + str(id) + ', "username": "******", "date": "' + str(
date) + '", "name": "' + name + '"},'
if isAnyPhotoAllowed:
data = data[:-1]
data += ']}'
result = "OK"
else:
# Print method not allowed
data = '{"error": "Method not allowed"}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
def post(self):
# Load response template
template = JINJA_ENVIRONMENT.get_template("static/templates/api.json")
self.response.headers["Content-Type"] = "application/json"
# Session request handler
current_session = Session(self)
# Retrieve uploaded info
upload_files = self.get_uploads("file")
blob_info = upload_files[0]
# Check if user can upload the photo
if current_session.get_role_level() < 2:
self.response.headers["Content-Type"] = "application/json"
data = '{"error": "Permission denied"}'
result = "FAIL"
self.response.write(template.render(feature="photo", data=data, query=self.request.url, result=result))
# Remove photo from blob store
blobstore.delete(blob_info.key)
return None
# Save photo to database
photo_id = database.PhotosManager.createPhoto("", current_session.get_user_key(), 2, blob_info.key())
# Prompt response to user
data = '{"photo_id": ' + str(photo_id) + "}"
result = "OK"
self.response.write(template.render(feature="photo", data=data, query=self.request.url, result=result))
def post(self, photo_id):
# Session
current_session = Session(self)
# Load response template
template = JINJA_ENVIRONMENT.get_template("static/templates/api.json")
self.response.headers["Content-Type"] = "application/json"
photo = database.PhotosManager.get_photo_by_id(int(photo_id))
if photo is None:
data = '{"error": "Photo does not exist."}'
result = "FAIL"
else:
# Check permission for this petition (only owner or admin can modify)
if (photo.owner == current_session.get_user_key()) or (current_session.get_role_level() > 2):
name = self.request.get("name")
privacy = int(self.request.get("privacy"))
database.PhotosManager.modify_photo(photo.key, name, privacy)
data = '{"message": "Changes done"}'
result = "OK"
else:
data = '{"error": "No permission to change."}'
result = "FAIL"
# Response result json
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
def fetch_bin(subsite,
node,
sensor,
method,
stream,
bin_number,
cols,
min_time=None,
max_time=None):
"""
Fetch the specified bin from the database
"""
log.info('fetch_bin(%s, %s, %s, %s, %s, %s, %s, %s, %s)', subsite, node,
sensor, method, stream, bin_number, cols, min_time, max_time)
s = 'select %s from %s where subsite=? and node=? and sensor=? and method=? and bin=?' % (
','.join(cols), stream)
args = [subsite, node, sensor, method, bin_number]
if min_time is not None:
min_time = (min_time - NTP_EPOCH).total_seconds()
s += ' and time >= ?'
args.append(min_time)
if max_time is not None:
max_time = (max_time - NTP_EPOCH).total_seconds()
s += ' and time < ?'
args.append(max_time)
ps = SessionManager.prepare(s)
result = SessionManager.execute_numpy(ps, args)
return pd.concat(
(pd.DataFrame(r, columns=cols) for r in result)).sort_values('time')
def insert_dataframe(subsite, node, sensor, method, stream, deployment,
binsize, dataframe):
"""
Insert the provided dataframe into cassandra, calculating bin based on binsize
"""
log.info('insert_dataframe(%s, %s, %s, %s, %s, %s, %s, <DATAFRAME>)',
subsite, node, sensor, method, stream, deployment, binsize)
metadata_cols = SessionManager.get_query_columns(stream)
data_cols = [col for col in dataframe.columns if col in metadata_cols]
fixed_cols = ['subsite', 'node', 'sensor', 'method', 'deployment']
fixed_values = "'%s', '%s', '%s', '%s', %d" % (subsite, node, sensor,
method, deployment)
variable_cols = ['bin', 'id'] + data_cols
statement = "INSERT INTO %s (%s, %s) VALUES (%s, %s)" % (stream, ','.join(
fixed_cols), ','.join(variable_cols), fixed_values, ','.join(
('?' for _ in variable_cols)))
ps = SessionManager.prepare(statement)
# add bin number to dataframe
dataframe['bin'] = [
get_bin_number(t, binsize) for t in dataframe.time.values
]
# add unique UUID to each row in dataframe
dataframe['id'] = [uuid.uuid4() for _ in dataframe.time.values]
def values_generator(df_group):
for index, row in df_group.iterrows():
vals = []
for col in variable_cols:
val = row[col]
if isinstance(val, np.ndarray):
val = val.tolist()
vals.append(val)
yield vals
inserted = {}
for bin_number, group in dataframe.groupby('bin'):
first = group.time.min()
last = group.time.max()
count = group.time.size
log.info('Inserting into %s bin %d first: %.2f last: %.2f count: %d',
stream, bin_number, first, last, count)
results = execute_concurrent_with_args(SessionManager.session(),
ps,
values_generator(group),
concurrency=200)
success_mask = [success for success, _ in results]
if not all(success_mask):
log.error('Unable to insert all records, failed records: %r',
group[np.logical_not(success_mask)])
first = group.time[success_mask].min()
last = group.time[success_mask].max()
count = group.time[success_mask].size
inserted[bin_number] = {'first': first, 'last': last, 'count': count}
return inserted
def get(self):
# Session request handler
current_session = Session(self)
JINJA_ENVIRONMENT.globals['session'] = current_session
# Language request handler
Language.language(self)
# Check if user is already logged in
if current_session.get_id() is not None:
self.redirect("/")
return None
template = JINJA_ENVIRONMENT.get_template('static/templates/register.html')
self.response.write(template.render())
def file_2_db(dburi, directory):
"""
read from files and write the configuration into database.
:param dburi: database uri
:param directory: folder to read
:return: None
"""
sm = SessionManager()
sess = sm.get_session(dburi)
sm.prepare_db(dburi, [PGEMConfig, TestItem])
# file to db
file_list = []
for root, folder, files in os.walk(directory):
for f in files:
# if(f.endswith(".xml") or f.endswith(".XML")):
regex = re.compile(r"AGIGA\d{4}\-\d{3}\w{3}-\d{2}\.xml",
re.IGNORECASE)
if (regex.match(f)):
file_list.append(os.path.join(root, f))
for f in file_list:
config = load_xml(f)
logger.debug(config)
result = sess.query(PGEMConfig).filter(
PGEMConfig.partnumber == config["partnumber"],
PGEMConfig.revision == config["revision"]).first()
if result:
pgem_config = result
pgem_config.testitems = []
else:
pgem_config = PGEMConfig()
for k, v in config.items():
if k != "testitems" and k != "TESTITEMS":
setattr(pgem_config, k.lower(), v)
else:
items = v
for tk, tv in items.items():
test_item = TestItem()
setattr(test_item, "NAME".lower(), tk)
for dk, dv in tv.items():
setattr(test_item, dk.lower(), dv)
pgem_config.testitems.append(test_item)
logger.debug(pgem_config)
try:
sess.add(pgem_config)
sess.commit()
except Exception as e:
sess.rollback()
raise e
finally:
sess.close()
def file_2_db(dburi, directory):
"""
read from files and write the configuration into database.
:param dburi: database uri
:param directory: folder to read
:return: None
"""
sm = SessionManager()
sess = sm.get_session(dburi)
sm.prepare_db(dburi, [PGEMConfig, TestItem])
# file to db
file_list = []
for root, folder, files in os.walk(directory):
for f in files:
#if(f.endswith(".xml") or f.endswith(".XML")):
regex = re.compile(r"AGIGA\d{4}\-\d{3}\w{3}-\d{2}\.xml",
re.IGNORECASE)
if(regex.match(f)):
file_list.append(os.path.join(root, f))
for f in file_list:
config = load_xml(f)
logger.debug(config)
result = sess.query(PGEMConfig).filter(
PGEMConfig.partnumber == config["partnumber"],
PGEMConfig.revision == config["revision"]).first()
if result:
pgem_config = result
pgem_config.testitems = []
else:
pgem_config = PGEMConfig()
for k, v in config.items():
if k != "testitems" and k != "TESTITEMS":
setattr(pgem_config, k.lower(), v)
else:
items = v
for tk, tv in items.items():
test_item = TestItem()
setattr(test_item, "NAME".lower(), tk)
for dk, dv in tv.items():
setattr(test_item, dk.lower(), dv)
pgem_config.testitems.append(test_item)
logger.debug(pgem_config)
try:
sess.add(pgem_config)
sess.commit()
except Exception as e:
sess.rollback()
raise e
finally:
sess.close()
def db_2_file(dburi, directory):
"""
read out from config database, save to single file
:param dbrui: database uri
:param directory: folder to save the xml files
:return: None
"""
sm = SessionManager()
sess = sm.get_session(dburi)
sm.prepare_db(dburi, [PGEMConfig, TestItem])
# db to file
for config in sess.query(PGEMConfig).all():
save_config(config.to_dict(), directory)
sess.close()
def get(self):
# Session request handler
current_session = Session(self)
JINJA_ENVIRONMENT.globals['session'] = current_session
# Language request handler
Language.language(self)
# Check if user is admin
if (current_session.get_role_level() < 3):
self.redirect("/")
return None
# Retrieve users
users = database.UserManager.select()
# Render template
template = JINJA_ENVIRONMENT.get_template('static/templates/users.html')
self.response.write(template.render(users=users))
def db_2_file(dburi, directory):
"""
read out from config database, save to single file
:param dbrui: database uri
:param directory: folder to save the xml files
:return: None
"""
sm = SessionManager()
sess = sm.get_session(dburi)
sm.prepare_db(dburi, [PGEMConfig, TestItem])
# db to file
for config in sess.query(PGEMConfig).all():
save_config(config.to_dict(), directory)
sess.close()
def get(self):
# Session request handler
current_session = Session(self)
JINJA_ENVIRONMENT.globals['session'] = current_session
# Language request handler
Language.language(self)
# Check if user has session started
if current_session.get_id() is None:
self.redirect("/")
# Logout user
current_session.logout(self)
# Prompt logout page
JINJA_ENVIRONMENT.globals['session'] = current_session
template = JINJA_ENVIRONMENT.get_template('static/templates/logout.html')
self.response.write(template.render())
def _handle_private_send_file(self, session: Session, request):
p_user = self.user_repository.find_by_username(request['p_username'])
if p_user is None:
session.send_response({
'FOR': 'FILE-PRIVATE-SEND',
'status': 'rejected',
'message': 'user not exist'
})
return
session.send_response({'FOR': 'FILE-PRIVATE-SEND', 'status': 'ready'})
file_entity: FileEntity = self._handle_send_file(session, request)
message = {
'text': '[' + request['file_name'] + '], file_code: ' +
file_entity.file_code,
'from_user': session.user.username
}
p_user.add_to_inbox(session.user.username, message)
session.user.add_to_inbox(p_user.username, message)
self.user_repository.save(p_user)
self.user_repository.save(session.user)
message['FOR'] = 'NOTIF'
target_session: Session = SessionManager.get_by_username(
p_user.username)
if target_session is not None:
target_session.send_response(message)
session.send_response(message)
def __init__(self):
settings = dict(
template_path = 'templates',
static_path = 'static',
static_url_path = '/static/',
xsrf_cookies = True,
debug = True,
login_url = '/login',
cookie_secret = "erfI2CItqdJG2AA1su5103panMMlr05ZmamQXSf3OPoq0Bury1YteKtHPAmA+TxWtrTnVNTrOevT==",
session_secret = "OLza01dzGmWXf0V910zynJ4IkrYtR74GWi4pXwR8ZY/DssIhIRPV7CrVY4XclVYdHoAZCCIQtQB==",
session_timeout = 60,
store_options = {
'redis_host': '192.168.47.20',
'redis_port': 6379,
'redis_pass': '',
},)
handlers = [
(r"/", MainHandler),
(r"", MainHandler),
(r"/login", LoginHandler),
(r"/logout", LogoutHandler),
]
tornado.web.Application.__init__(self, handlers, **settings)
self.session_manager = SessionManager(settings["session_secret"], settings["store_options"], settings["session_timeout"])
def get(self, option):
# Session
current_session = Session(self)
# Load response template
template = JINJA_ENVIRONMENT.get_template("static/templates/api.json")
self.response.headers["Content-Type"] = "application/json"
if option == "list":
# List all accesible photos
photos = database.PhotosManager.retrieveAllPhotos()
if current_session.get_id() is None:
user = None
else:
user = database.UserManager.select_by_id(current_session.get_id())
data = '{"photos":['
isAnyPhotoAllowed = False
for photo in photos:
if security.PhotoSecurity.user_is_allowed_to_watch_photo(
photo, user
): # Check user has permission to retrieve
isAnyPhotoAllowed = True
id = photo.key.id()
username = photo.owner.get().name
date = photo.date
name = photo.name
data += (
'{"photo_id": '
+ str(id)
+ ', "username": "******", "date": "'
+ str(date)
+ '", "name": "'
+ name
+ '"},'
)
if isAnyPhotoAllowed:
data = data[:-1]
data += "]}"
result = "OK"
else:
# Print method not allowed
data = '{"error": "Method not allowed"}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
def load_config(dburi, partnumber, revision):
"""
:param dburi: database uri, eg. "sqlite:///config.db"
:param partnumber: partnumber of DUT, eg. "AGIGA9601-002BCA"
:param revision: revision of DUT, eg."04"
:return: PGEMConfig object
"""
sm = SessionManager()
sess = sm.get_session(dburi)
pgem_config = sess.query(PGEMConfig).filter(
PGEMConfig.partnumber == partnumber,
PGEMConfig.revision == revision,
).first()
if pgem_config is None:
raise BackendException(partnumber +
" is not found in configuration database")
logger.debug(pgem_config.to_dict())
sess.close()
return pgem_config
def load_config(dburi, partnumber, revision):
"""
:param dburi: database uri, eg. "sqlite:///config.db"
:param partnumber: partnumber of DUT, eg. "AGIGA9601-002BCA"
:param revision: revision of DUT, eg."04"
:return: PGEMConfig object
"""
sm = SessionManager()
sess = sm.get_session(dburi)
pgem_config = sess.query(PGEMConfig).filter(
PGEMConfig.partnumber == partnumber,
PGEMConfig.revision == revision,
).first()
if pgem_config is None:
raise BackendException(partnumber +
" is not found in configuration database")
logger.debug(pgem_config.to_dict())
sess.close()
return pgem_config
def _handle_send_file(self, session: Session, request):
p_user = self.user_repository.find_by_username(request['p_username'])
if p_user is None:
session.send_response({
'FOR': 'FILE-PRIVATE-SEND',
'status': 'rejected',
'message': 'user not exist'
})
return
session.send_response({
'FOR': 'FILE-PRIVATE-SEND',
'status': 'ready'
})
unique_code = str(uuid.uuid4())[1:7]
file_path = 'storage/'+unique_code + '-' + request['file_name']
fd = open(file_path, 'wb+', 0)
max_size = request['file_size']
received = 0
conn = session.connection
while received < max_size:
data = conn.recv(1024)
received += len(data)
fd.write(data)
fd.close()
file_entity = FileEntity()
file_entity.owner = session.user.username
file_entity.file_path = file_path
file_entity.file_code = unique_code
self.file_repository.save(file_entity)
message = {
'text': '[' + request['file_name'] + '], file_code: ' + unique_code,
'from_user': session.user.username
}
p_user.add_to_inbox(session.user.username, message)
session.user.add_to_inbox(p_user.username, message)
self.user_repository.save(p_user)
self.user_repository.save(session.user)
message['FOR'] = 'NOTIF'
target_session: Session = SessionManager.get_by_username(p_user.username)
if target_session is not None:
target_session.send_response(message)
session.send_response(message)
def get(self, user_id, photo_id, option):
# Session
current_session = Session(self)
# Load response template
template = JINJA_ENVIRONMENT.get_template("static/templates/api.json")
self.response.headers["Content-Type"] = "application/json"
# Check if user and photo exists
photo = database.PhotosManager.get_photo_by_id(int(photo_id))
user = database.UserManager.select_by_id(int(user_id))
if photo is None:
data = '{"error": "Photo does not exist."}'
result = "FAIL"
elif user is None:
data = '{"error": "User does not exist."}'
result = "FAIL"
else:
# Check permission for this petition (only owner or admin can modify)
if (photo.owner == current_session.get_user_key()) or (current_session.get_role_level() > 2):
if option == "give":
result = database.PhotoUserPermissionManager.give_permission(photo, user)
if result is None:
data = '{"error": "Permission already set."}'
result = "FAIL"
else:
data = '{"message": "Permission allowed."}'
result = "OK"
elif option == "restrict":
result = database.PhotoUserPermissionManager.restrict_permission(photo, user)
if result is True:
data = '{"message": "Permission restricted."}'
result = "OK"
else:
data = '{"error": "Permission is not set. Cannot restrict"}'
result = "FAIL"
else:
data = '{"error": "Permission denied. Operation cannot do."}'
result = "FAIL"
# Response result json
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
def get(self, user_id, photo_id, option):
# Session
current_session = Session(self)
# Load response template
template = JINJA_ENVIRONMENT.get_template('static/templates/api.json')
self.response.headers['Content-Type'] = 'application/json'
# Check if user and photo exists
photo = database.PhotosManager.get_photo_by_id(int(photo_id))
user = database.UserManager.select_by_id(int(user_id))
if photo is None:
data = '{"error": "Photo does not exist."}'
result = "FAIL"
elif user is None:
data = '{"error": "User does not exist."}'
result = "FAIL"
else:
# Check permission for this petition (only owner or admin can modify)
if(photo.owner == current_session.get_user_key()) or (current_session.get_role_level() > 2):
if option == "give":
result = database.PhotoUserPermissionManager.give_permission(photo, user)
if result is None:
data = '{"error": "Permission already set."}'
result = "FAIL"
else:
data = '{"message": "Permission allowed."}'
result = "OK"
elif option == "restrict":
result = database.PhotoUserPermissionManager.restrict_permission(photo, user)
if result is True:
data = '{"message": "Permission restricted."}'
result = "OK"
else:
data = '{"error": "Permission is not set. Cannot restrict"}'
result = "FAIL"
else:
data = '{"error": "Permission denied. Operation cannot do."}'
result = "FAIL"
# Response result json
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
def __init__(self, socket_params, opts):
""" Set up a new instance """
self.version = __version__
self.opts = opts
self._setup_logging()
server_address = (opts.host, opts.port)
self.httpserver = HTTPServer(server_address, HTTPRequestHandler, self)
self._setup_openid()
self.auth_service = AuthService()
self.sess_manager = SessionManager()
self.consumer_auth_store = ConsumerAuthStore()
def run(self):
while True:
try:
data = self.connection.recv(1024)
request = json.loads(data.decode('utf-8'))
print(request)
if self.handler_head is not None:
self.handler_head.handle(self.session, request)
except BaseException as e:
traceback.print_exc()
try:
self.session.send_response({
'FOR': None,
'status': 'failed',
'message': 'internal server error'
})
except:
# unregis jika client terputus
SessionManager.del_from_list(self.session)
self.connection.close()
return
def connectServer(self):
cfg = self.settings.connection
constr = f'{cfg.ip}:{cfg.port}'
if cfg.use_ssl:
raise Exception('bitte Sebastian ssl einbauen')
else:
self.channel = grpc.insecure_channel(constr)
self._load_categories()
self._load_model_metadata()
self.stlloadthread = _StlLoadThread(self.channel)
self.sessionManager = SessionManager(self.channel)
self.filterManager = FilterManager(self.categories,
self.modelsMetaData)
def delete_dataframe(dataframe, metadata_record):
"""
Delete all rows exactly matching the deployment number, time and id from the matching rows in this dataframe
"""
log.info('delete_dataframe(<DATAFRAME>, %s)', metadata_record)
query = 'delete from %s where subsite=? and node=? and sensor=? ' \
'and bin=? and method=? and time=? and deployment=? and id=?' % metadata_record.stream
query = SessionManager.prepare(query)
def values_generator(df):
for index, row in df.iterrows():
args = (metadata_record.subsite, metadata_record.node,
metadata_record.sensor, metadata_record.bin,
metadata_record.method, row.time, row.deployment, row.id)
yield args
sess = SessionManager.session()
results = execute_concurrent_with_args(sess,
query,
values_generator(dataframe),
concurrency=200)
return sum((success for success, _ in results if success))
def get(self, photo_id):
# Session
current_session = Session(self)
# Load response template
template = JINJA_ENVIRONMENT.get_template("static/templates/api.json")
# Retrieve photo url for photo_id
photo = database.PhotosManager.get_photo_by_id(int(photo_id))
if current_session.get_id() is None:
user = None
else:
user = database.UserManager.select_by_id(current_session.get_id())
if not photo:
self.response.write("No photo")
elif not blobstore_2.get(photo.image):
self.response.write("No blob")
else:
# Check visualization permissions to current user
if security.PhotoSecurity.user_is_allowed_to_watch_photo(photo, user):
self.send_blob(photo.image)
else:
self.error(404)
def get(self, photo_id):
# Session
current_session = Session(self)
# Load response template
template = JINJA_ENVIRONMENT.get_template('static/templates/api.json')
# Retrieve photo url for photo_id
photo = database.PhotosManager.get_photo_by_id(int(photo_id))
if current_session.get_id() is None:
user = None
else:
user = database.UserManager.select_by_id(current_session.get_id())
if not photo:
self.response.write("No photo")
elif not blobstore_2.get(photo.image):
self.response.write("No blob")
else:
# Check visualization permissions to current user
if security.PhotoSecurity.user_is_allowed_to_watch_photo(photo, user):
self.send_blob(photo.image)
else:
self.error(404)
def post(self):
# Session request handler
current_session = Session(self)
JINJA_ENVIRONMENT.globals['session'] = current_session
# Language request handler
Language.language(self)
# Check if user is already logged in
if current_session.get_id() is not None:
self.redirect("/")
# Language task
Language.language(self)
# Load form
template = JINJA_ENVIRONMENT.get_template('static/templates/login.html')
# Check user and password
submitted_username = cgi.escape(self.request.get("username"))
submitted_password = hashlib.sha1(cgi.escape(self.request.get("password"))).hexdigest()
user = database.UserManager.select_by_username(submitted_username)
# Check user exists
if user is not None:
# Check if user account is blocked or not
if user.attempts < 3:
# Check if user and password matches
if submitted_username == user.name and submitted_password == user.password:
# Session initialization
current_session.set(self, user.key.id())
# Login attempts to zero
database.UserManager.modify_user(user.key, attempts=0)
# Redirection to initial page
self.redirect("/")
else:
# Add an attempt to user login
database.UserManager.modify_user(user.key, attempts=user.attempts+1)
self.response.write(template.render(error=_("InvalidUsernameOrPassword")))
else:
self.response.write(template.render(error=_("AccountBlocked")))
else:
self.response.write(template.render(error=_("InvalidUsernameOrPassword")))
def main():
sm = SessionManager()
session = sm.get_session(DBURI)
sm.prepare_db(DBURI, [DUT])
for csv in get_files(FILEPATH, EXT):
print csv
for dut_dict in get_data(csv):
print dut_dict
dut = DUT()
for k, v in dut_dict.items():
setattr(dut, k, v)
print dut.sn
snr_total = dut.snr.split(',')[2]
dut.snr_total = snr_total
bin_code = dut.bin_codes.split(',')[0]
dut.bin_code = bin_code
session.add(dut)
session.commit()
session.close()
def _handle_group_send_file(self, session: Session, request):
group_entity: GroupEntity = self.group_repository.find_by_code(
request['code'])
if session.user.username in group_entity.members:
pass
else:
session.send_response({
'FOR':
'FILE-GROUP-SEND',
'status':
'failed',
'message':
'You are not a member of the group!'
})
return
session.send_response({'FOR': 'FILE-GROUP-SEND', 'status': 'ready'})
file_entity: FileEntity = self._handle_send_file(session, request)
message = {
'text': '[' + request['file_name'] + '], file_code: ' +
file_entity.file_code,
'from_user': session.user.username
}
group_entity.inbox.append(message)
self.group_repository.save(group_entity)
message['FOR'] = 'NOTIF'
message['from_group'] = group_entity.group_name
members = group_entity.members
for member in members:
if member == session.user.username:
continue
member_session: Session = SessionManager.get_by_username(member)
if member_session is not None:
member_session.send_response(message)
print('send to ' + member_session.user.username)
session.send_response({'FOR': 'MSG-GROUP-SEND', 'status': 'success'})
def _msg_private_send_handler(self, session: Session, request):
target_username = request['p_username']
msg = request['message']
target_session: Session = SessionManager.get_by_username(
target_username)
target_user = self.user_repository.find_by_username(target_username)
if target_session is not None:
target_session.send_response({
'FOR': 'NOTIF',
'from_user': session.user.username,
'text': request['message']
})
session.send_response({
'FOR': request['COMMAND'],
'status': 'success'
})
else:
if target_user is not None:
session.send_response({
'FOR': request['COMMAND'],
'status': 'success'
})
else:
session.send_response({
'FOR': request['COMMAND'],
'status': 'failed',
'message': 'user not found'
})
if target_user is not None:
message = dict()
message['from_user'] = session.user.username
message['text'] = request['message']
# simpan message di 2 inbox
session.user.add_to_inbox(target_user.username, message)
self.user_repository.save(session.user)
target_user.add_to_inbox(session.user.username, message)
self.user_repository.save(target_user)
def message_handler(pipe, lock):
"""A Process task handler performing a loop on pipe.recv()
Pass any messages to the session.SessionManager
"""
log('-- Starting connect handler\n')
handler = SessionManager(pipe, lock)
# send back into the start method -
pipe.send(handler.init_response())
while True:
try:
msg = pipe.recv()
if msg == 'close':
log('connect.message_handler received message from session pipe')
log(message)
break
handler.kill()
handler.recv(msg)
except (EOFError, KeyboardInterrupt):
break
pipe.close()
def _msg_group_send_handler(self, session: Session, request):
group_entity: GroupEntity = self.group_repository.find_by_code(request['code'])
if session.user.username in group_entity.members:
pass
else:
session.send_response({
'FOR': 'MSG-GROUP-SEND',
'status': 'failed',
'message': 'You are not a member of the group!'
})
return
members = group_entity.members
for member in members:
if member == session.user.username:
continue
member_session: Session = SessionManager.get_by_username(member)
if member_session is not None:
member_session.send_response({
'FOR': 'NOTIF',
'from_group': group_entity.group_name,
'from_user': session.user.username,
'text': request['message']
})
print('send to '+member_session.user.username)
group_entity.inbox.append({
'from_user': session.user.username,
'text': request['message']
})
session.send_response({
'FOR': 'MSG-GROUP-SEND',
'status': 'success'
})
self.group_repository.save(group_entity)
def main():
global constants
# enable cudnn auto-tuner to find the best algorithm for the given harware
cudnn.benchmark = True
sm = SessionManager(dataset_name=args.dataset_name,
resume_id=args.session_id)
labeled_trainloader, unlabeled_trainloader, val_loader, test_loader, class_names, constants = \
sm.load_dataset(args)
ts, writer = sm.load_checkpoint(class_names, constants)
step = 0
# Train and val
for epoch in range(ts.start_epoch, constants['epochs']):
print('\nEpoch: [%d | %d]' % (epoch + 1, constants['epochs']))
step = constants['train_iteration'] * (epoch + 1)
if constants['enable_mixmatch']:
train_loss = train(labeled_trainloader, unlabeled_trainloader,
epoch, ts)
else:
train_loss = train_supervised(labeled_trainloader, epoch, ts)
losses, accs, confs, names = validate_all(labeled_trainloader,
val_loader, test_loader,
train_loss, ts)
tensorboard_write(writer, losses, accs, confs, names, class_names,
step)
# save model and other training variables
sm.save_checkpoint(accs[names['validation']], epoch)
sm.close()
def get_session_manager(self):
if self._session_manager is None:
self._session_manager = SessionManager(self)
return self._session_manager
def post(self):
# Session request handler
current_session = Session(self)
JINJA_ENVIRONMENT.globals['session'] = current_session
# Language request handler
Language.language(self)
# Check if user is already logged in
if current_session.get_id() is not None:
self.redirect("/")
return None
# Retrieve request data
username = cgi.escape(self.request.get('username'))
password1 = cgi.escape(self.request.get('password1'))
password2 = cgi.escape(self.request.get('password2'))
email = cgi.escape(self.request.get('email'))
# Load success and fail templates
register_template = JINJA_ENVIRONMENT.get_template('static/templates/register.html')
registered_template = JINJA_ENVIRONMENT.get_template('static/templates/registered.html')
# Check email is well formed
if not re.match(r"[^@]+@[^@]+\.[^@]+", email):
self.response.write(register_template.render(error=_("BadEmail.")))
return None
# Check passwords min size is 6
if len(password1) < 6:
self.response.write(register_template.render(error=_("PasswordMinLengthNotReached.")))
return None
# Check passwords match
if password1 != password2:
self.response.write(register_template.render(error=_("PasswordMissmatch")))
return None
# Username not empty
if len(username) < 1:
self.response.write(register_template.render(error=_("EmptyUsername.")))
return None
# Check user exists
user = database.UserManager.select_by_username(username)
if user is not None:
self.response.write(register_template.render(error=_("UsernameExists")))
return None
# Check email exists
user = database.UserManager.select_by_email(email)
if user is not None:
self.response.write(register_template.render(error=_("EmailExists")))
return None
# Save new user in DB
user_key = database.UserManager.create(username, password1, email)
if user_key:
# Create activation token
token_key = database.TokenManager.create_token(user_key)
# Send activation email
email_handler.Email.send_activation(username, str(token_key.id()), email)
# Autologin new user
current_session.set(self, user_key.id())
JINJA_ENVIRONMENT.globals['session'] = current_session
self.response.write(registered_template.render(username=username))
else:
self.response.write(register_template.render(error=_("DatabaseError")))
return None
def post(self, user_id, option):
# Session
current_session = Session(self)
# Load response template
template = JINJA_ENVIRONMENT.get_template('static/templates/api.json')
self.response.headers['Content-Type'] = 'application/json'
# Check if request is done by admin or himself
user_id = int(user_id)
if current_session.get_role_level() < 3 and current_session.get_id() != user_id:
role_level = str(current_session.get_role_level())
data = '{"error": "Permission denied"}'
result = "FAIL"
self.response.write(template.render(feature="user",
data=data,
query=self.request.url,
result=result))
return None
# Check if user exists
user = database.UserManager.select_by_id(int(user_id))
# If user not exists
if user is None:
data = '{"error": "User not exists."}'
result = "FAIL"
self.response.write(template.render(feature="user",
data=data,
query=self.request.url,
result=result))
return None
# Options
if option == "changeUserData": # update email and user
email = self.request.get("email", None)
username = self.request.get("username", None)
background = self.request.get("background", None)
photo_id = self.request.get("photo", None)
if email is not None:
userbyemail = database.UserManager.select_by_email(email)
if userbyemail is None:
database.UserManager.modify_user(user.key, email=email)
else:
data = '{"error": "Field exists", "field": "email"}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
if username is not None:
userbyname = database.UserManager.select_by_username(username)
if userbyname is None:
database.UserManager.modify_user(user.key, username=username)
else:
data = '{"error": "Field exists", "field": "username"}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
if background is not None:
# Check if photo exists
background_photo = database.PhotosManager.get_photo_by_id(int(background))
if background_photo is not None:
# Change user background image
database.UserManager.modify_user(user.key, background=background_photo.key.id())
else:
data = '{"error": "Field not exists", "field": "background"}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
if photo_id is not None:
# Check if photo exists
photo = database.PhotosManager.get_photo_by_id(int(photo_id))
if photo is not None:
# Change user background image
database.UserManager.modify_user(user.key, photo=photo.key.id())
else:
data = '{"error": "Field not exists", "field": "background"}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
data = '{"message": "User updated"}'
result = "OK"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
def get(self, user_id, option):
# Session
current_session = Session(self)
# Load response template
template = JINJA_ENVIRONMENT.get_template('static/templates/api.json')
self.response.headers['Content-Type'] = 'application/json'
user_id = int(user_id)
# If user is not admin and not himself, not allow to query anything
if current_session.get_role_level() < 3 and current_session.get_id() != user_id:
role_level = str(current_session.get_role_level())
data = '{"error": "Permission denied' + role_level + '"}'
result = "FAIL"
self.response.write(template.render(feature="user",
data=data,
query=self.request.url,
result=result))
return None
# Check if user exists
user = database.UserManager.select_by_id(int(user_id))
# If user not exists
if user is None:
data = '{"error": "User not exists."}'
result = "FAIL"
self.response.write(template.render(feature="user",
data=data,
query=self.request.url,
result=result))
return None
# Options
if option == "activateAccountByAdmin":
# Only admin is allowed to change permissions
if current_session.get_role_level() < 3:
data = '{"error": "You cannot change your permission level."}'
result = "FAIL"
self.response.write(template.render(feature="user",
data=data,
query=self.request.url,
result=result))
return None
# If user has not his account activated, admin cannot active it
if user.role_level != 1:
data = '{"error": "User has not his account activated yet."}'
result = "FAIL"
self.response.write(template.render(feature="user",
data=data,
query=self.request.url,
result=result))
return None
# Activate account by admin
database.UserManager.modify_user(user.key, role_level=2)
data = '{"message": "Account activated by admin."}'
result = "OK"
elif option == "deactivateAccountByAdmin":
# Only admin is allowed to change permissions
if current_session.get_role_level() < 3:
data = '{"error": "You cannot change your permission level."}'
result = "FAIL"
self.response.write(template.render(feature="user",
data=data,
query=self.request.url,
result=result))
return None
# If user has not his account activated, admin cannot active it
if user.role_level != 2:
data = '{"error": "User account can not deactivated."}'
result = "FAIL"
self.response.write(template.render(feature="user",
data=data,
query=self.request.url,
result=result))
return None
# Activate account by admin
database.UserManager.modify_user(user.key, role_level=1)
data = '{"message": "Account deactivated by admin."}'
result = "OK"
elif option == "blockAccount":
# Only admin is allowed to block account
if current_session.get_role_level() < 3:
data = '{"error": "You cannot change your block status."}'
result = "FAIL"
self.response.write(template.render(feature="user",
data=data,
query=self.request.url,
result=result))
return None
# No anyone is allowed to block an admin
if user.role_level == 3:
data = '{"error": "You cannot block an admin account."}'
result = "FAIL"
self.response.write(template.render(feature="user",
data=data,
query=self.request.url,
result=result))
return None
database.UserManager.modify_user(user.key, attempts=3) # Account is blocked with 3 attempts
data = '{"message": "Account blocked by admin."}'
result = "OK"
elif option == "unblockAccount":
# Only admin is allowed to unblock account
if current_session.get_role_level() < 3:
data = '{"error": "You cannot change your permission level."}'
result = "FAIL"
self.response.write(template.render(feature="user",
data=data,
query=self.request.url,
result=result))
return None
database.UserManager.modify_user(user.key, attempts=0) # Account is unblocked with 0 attempts
data = '{"message": "Account unblock by admin."}'
result = "OK"
elif option == "profileChangeRequest":
# Only user himself is allowed to change profile
if current_session.get_id() == user_id:
token = database.TokenManager.create_token(user.key)
email_handler.Email.send_change_profile(user.name, token.id(), user.email)
data = '{"message": "Change profile email send"}'
result = "OK"
else:
data = '{"error": "Method not allowed"}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
def set_weights(weights, lang, sid):
sess = session_manager.get_session(sid)
if sess is None:
return False, "No session"
try:
weights = [float(w.strip()) for w in weights.split(',')]
except Exception:
return False, "Wrong weight format"
responding_characters = get_responding_characters(lang, sid)
if len(weights) != len(responding_characters):
return False, "Number of weights doesn't match number of tiers {}".format(weights)
sess.sdata.weights = weights
return True, "Weights are updated"
from session import SessionManager
session_manager = SessionManager()
MAX_CHAT_TRIES = 5
NON_REPEAT = True
def _ask_characters(characters, question, lang, sid):
chat_tries = 0
sess = session_manager.get_session(sid)
if sess is None:
return
data = sess.get_session_data()
user = getattr(data, 'user')
botname = getattr(data, 'botname')
if hasattr(data, 'weights'):
weights = data.weights
else:
weights = [c.weight for c in characters]
self.name: {
"description": self.description,
"enable": int(self.enable),
"min": self.min,
"max": self.max,
"stoponfail": int(self.stoponfail),
"misc": self.misc
}
}
if __name__ == "__main__":
from session import SessionManager
dburi = "sqlite:///configuration.db"
sm = SessionManager()
session = sm.get_session(dburi)
sm.prepare_db(dburi, [PGEMConfig, TestItem])
# Insert Example
CrystalConfig = PGEMConfig()
CrystalConfig.partnumber = "AGIGA9601-002BCA"
CrystalConfig.description = "Crystal"
CrystalConfig.revision = "04"
CheckTemp = TestItem()
CheckTemp.name = "Check_Temp"
CheckTemp.description = "Check Temperature on chip SE97BTP, data in degree"
CheckTemp.enable = True
CheckTemp.min = 5.0
CheckTemp.max = 30.0
def get(self, photo_id):
# Session request handler
current_session = Session(self)
JINJA_ENVIRONMENT.globals['session'] = current_session
# Language request handler
Language.language(self)
# Load jinja template
template = JINJA_ENVIRONMENT.get_template('static/templates/photo.html')
# Check permission
photo = database.PhotosManager.get_photo_by_id(int(photo_id))
if current_session.get_id() is None:
request_user = None
else:
request_user = database.UserManager.select_by_id(current_session.get_id())
if not security.PhotoSecurity.user_is_allowed_to_watch_photo(photo, request_user):
self.redirect("/")
# Get photo info to display
user = photo.owner.get()
privacy = photo.privacy
date = photo.date
# Check if user can edit photo attributes
edition_permission = (current_session.get_role_level() is 3) or (photo.owner == current_session.get_user_key())
# Get user allowed to watch photo
if privacy == 1:
allowed_users = database.PhotoUserPermissionManager.get_allowed_users_by_photo(photo)
else:
allowed_users = None
# Count photo visited by user
if current_session.get_id() is None:
database.PhotoViewManager.newView(photo, None)
else:
database.PhotoViewManager.newView(photo, current_session.user)
# Photo visualization count
photo_views = database.PhotoViewManager.select_users_by_photo(photo)
views_counter = {}
for photo_view in photo_views:
if photo_view.user is None:
if "Anonymous" in views_counter:
views_counter["Anonymous"]['count'] += 1
else:
views_counter["Anonymous"] = {'count':1,
'name':"Anonymous",
'id': None}
else:
photo_view_user = photo_view.user
if photo_view_user.get().name in views_counter:
views_counter[photo_view_user.get().name]['count'] += 1
else:
views_counter[photo_view_user.get().name] = {'count':1,
'name':photo_view_user.get().name,
'id': photo_view_user.id()}
# Response page
self.response.write(template.render(
photo_id=photo_id,
owner=user,
name=photo.name,
edition_permission= edition_permission,
date= date,
privacy=privacy,
views=views_counter,
every_user_list=database.UserManager.select(),
allowed_users=allowed_users
))
def get(self, user_id, option):
# Session
current_session = Session(self)
# Load response template
template = JINJA_ENVIRONMENT.get_template("static/templates/api.json")
self.response.headers["Content-Type"] = "application/json"
user_id = int(user_id)
# If user is not admin and not himself, not allow to query anything
if current_session.get_role_level() < 3 and current_session.get_id() != user_id:
role_level = str(current_session.get_role_level())
data = '{"error": "Permission denied' + role_level + '"}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
return None
# Check if user exists
user = database.UserManager.select_by_id(int(user_id))
# If user not exists
if user is None:
data = '{"error": "User not exists."}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
return None
# Options
if option == "activateAccountByAdmin":
# Only admin is allowed to change permissions
if current_session.get_role_level() < 3:
data = '{"error": "You cannot change your permission level."}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
return None
# If user has not his account activated, admin cannot active it
if user.role_level != 1:
data = '{"error": "User has not his account activated yet."}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
return None
# Activate account by admin
database.UserManager.modify_user(user.key, role_level=2)
data = '{"message": "Account activated by admin."}'
result = "OK"
elif option == "deactivateAccountByAdmin":
# Only admin is allowed to change permissions
if current_session.get_role_level() < 3:
data = '{"error": "You cannot change your permission level."}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
return None
# If user has not his account activated, admin cannot active it
if user.role_level != 2:
data = '{"error": "User account can not deactivated."}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
return None
# Activate account by admin
database.UserManager.modify_user(user.key, role_level=1)
data = '{"message": "Account deactivated by admin."}'
result = "OK"
elif option == "blockAccount":
# Only admin is allowed to block account
if current_session.get_role_level() < 3:
data = '{"error": "You cannot change your block status."}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
return None
# No anyone is allowed to block an admin
if user.role_level == 3:
data = '{"error": "You cannot block an admin account."}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
return None
database.UserManager.modify_user(user.key, attempts=3) # Account is blocked with 3 attempts
data = '{"message": "Account blocked by admin."}'
result = "OK"
elif option == "unblockAccount":
# Only admin is allowed to unblock account
if current_session.get_role_level() < 3:
data = '{"error": "You cannot change your permission level."}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
return None
database.UserManager.modify_user(user.key, attempts=0) # Account is unblocked with 0 attempts
data = '{"message": "Account unblock by admin."}'
result = "OK"
elif option == "profileChangeRequest":
# Only user himself is allowed to change profile
if current_session.get_id() == user_id:
token = database.TokenManager.create_token(user.key)
email_handler.Email.send_change_profile(user.name, token.id(), user.email)
data = '{"message": "Change profile email send"}'
result = "OK"
else:
data = '{"error": "Method not allowed"}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
''' Created on Mar 6, 2013 @author: lyb ''' import redis from settings.settings import REDIS_DB, REDIS_PORT, REDIS_HOST from users.UserManager import BLUserManager from session import SessionManager, login_required from contacts.ContactManager import BLIVManager from contacts.GroupManager import BLGroupManager rdb = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB) sm = SessionManager() im = BLIVManager() gm = BLGroupManager() um = BLUserManager()
self.name: {
"description": self.description,
"enable": int(self.enable),
"min": self.min,
"max": self.max,
"stoponfail": int(self.stoponfail),
"misc": self.misc
}
}
if __name__ == "__main__":
from session import SessionManager
dburi = "sqlite:///configuration.db"
sm = SessionManager()
session = sm.get_session(dburi)
sm.prepare_db(dburi, [PGEMConfig, TestItem])
# Insert Example
CrystalConfig = PGEMConfig()
CrystalConfig.partnumber = "AGIGA9601-002BCA"
CrystalConfig.description = "Crystal"
CrystalConfig.revision = "04"
CheckTemp = TestItem()
CheckTemp.name = "Check_Temp"
CheckTemp.description = "Check Temperature on chip SE97BTP, data in degree"
CheckTemp.enable = True
CheckTemp.min = 5.0
CheckTemp.max = 30.0
'http://pow7.com:80/announce', 'http://open.acgnxtracker.com:80/announce',
'http://mail2.zelenaya.net:80/announce',
'udp://tracker4.itzmx.com:2710/announce',
'udp://tracker2.itzmx.com:6961/announce',
'udp://tr.bangumi.moe:6969/announce', 'udp://bt2.54new.com:8080/announce',
'https://tracker.hama3.net:443/announce',
'http://tracker4.itzmx.com:2710/announce',
'http://tracker2.itzmx.com:6961/announce',
'http://tracker.gcvchp.com:2710/announce',
'http://tracker.acgnx.se:80/announce', 'http://t.acg.rip:6699/announce'
]
bot_token = os.getenv('BOT_TOKEN')
api_id = int(os.getenv('API_ID'))
api_hash = os.getenv('API_HASH')
session_manager = SessionManager()
client = TelegramClient('toby', api_id, api_hash)
bot = TelegramClient('bot', api_id, api_hash).start(bot_token=bot_token)
in_progress_users = set()
tasks = dict()
pending_torrents = dict()
l = _log.new_logger()
class File():
def __init__(self, file_info):
self.fullpath = file_info[0]
self.num_pieces = file_info[1][0]
self.size = file_info[1][1]
def post(self, user_id, option):
# Session
current_session = Session(self)
# Load response template
template = JINJA_ENVIRONMENT.get_template("static/templates/api.json")
self.response.headers["Content-Type"] = "application/json"
# Check if request is done by admin or himself
user_id = int(user_id)
if current_session.get_role_level() < 3 and current_session.get_id() != user_id:
role_level = str(current_session.get_role_level())
data = '{"error": "Permission denied"}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
return None
# Check if user exists
user = database.UserManager.select_by_id(int(user_id))
# If user not exists
if user is None:
data = '{"error": "User not exists."}'
result = "FAIL"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
return None
# Options
if option == "changeUserData": # update email and user
email = self.request.get("email", None)
username = self.request.get("username", None)
background = self.request.get("background", None)
photo_id = self.request.get("photo", None)
if email is not None:
userbyemail = database.UserManager.select_by_email(email)
if userbyemail is None:
database.UserManager.modify_user(user.key, email=email)
else:
data = '{"error": "Field exists", "field": "email"}'
result = "FAIL"
self.response.write(
template.render(feature="user", data=data, query=self.request.url, result=result)
)
if username is not None:
userbyname = database.UserManager.select_by_username(username)
if userbyname is None:
database.UserManager.modify_user(user.key, username=username)
else:
data = '{"error": "Field exists", "field": "username"}'
result = "FAIL"
self.response.write(
template.render(feature="user", data=data, query=self.request.url, result=result)
)
if background is not None:
# Check if photo exists
background_photo = database.PhotosManager.get_photo_by_id(int(background))
if background_photo is not None:
# Change user background image
database.UserManager.modify_user(user.key, background=background_photo.key.id())
else:
data = '{"error": "Field not exists", "field": "background"}'
result = "FAIL"
self.response.write(
template.render(feature="user", data=data, query=self.request.url, result=result)
)
if photo_id is not None:
# Check if photo exists
photo = database.PhotosManager.get_photo_by_id(int(photo_id))
if photo is not None:
# Change user background image
database.UserManager.modify_user(user.key, photo=photo.key.id())
else:
data = '{"error": "Field not exists", "field": "background"}'
result = "FAIL"
self.response.write(
template.render(feature="user", data=data, query=self.request.url, result=result)
)
data = '{"message": "User updated"}'
result = "OK"
self.response.write(template.render(feature="user", data=data, query=self.request.url, result=result))
