def test_validate_extension(self):
self.clear_data_before_test()
filename = '2018-09-02 10.12.10.jpg'
actual = storage_bl.validate_extension(filename,
CONST.CROP_ALLOWED_EXTENSIONS)
expected = True
self.assertEqual(actual, expected)
filename = '2018-09-02 10.12.10'
actual = storage_bl.validate_extension(filename,
CONST.CROP_ALLOWED_EXTENSIONS)
expected = False
self.assertEqual(actual, expected)
filename = ''
actual = storage_bl.validate_extension(filename,
CONST.CROP_ALLOWED_EXTENSIONS)
expected = False
self.assertEqual(actual, expected)
filename = None
actual = storage_bl.validate_extension(filename,
CONST.CROP_ALLOWED_EXTENSIONS)
expected = False
self.assertEqual(actual, expected)
def add_match():
try:
from_request = request.headers.get('Request-From', 'mobile')
request_size = request.headers.get('Content-length') # string
uid = int(request.headers['Uid'])
token_id = request.args.get('token_id')
file_name = None
saved_path = None
if request.form.get('data') is None:
return response_error(MESSAGE.INVALID_DATA, CODE.INVALID_DATA)
item = json.loads(request.form.get('data'))
if request.files and len(
request.files) > 0 and request.files['image'] is not None:
if int(
request_size
) <= CONST.UPLOAD_MAX_FILE_SIZE and storage_bl.validate_extension(
request.files['image'].filename,
CONST.UPLOAD_ALLOWED_EXTENSIONS):
file_name, saved_path = storage_bl.handle_upload_file(
request.files['image'])
else:
return response_error(MESSAGE.FILE_TOO_LARGE,
CODE.FILE_TOO_LARGE)
if token_id is None:
contract = contract_bl.get_active_smart_contract()
if contract is None:
return response_error(MESSAGE.CONTRACT_EMPTY_VERSION,
CODE.CONTRACT_EMPTY_VERSION)
else:
token = Token.find_token_by_id(token_id)
if token is None:
return response_error(MESSAGE.TOKEN_NOT_FOUND,
CODE.TOKEN_NOT_FOUND)
token_id = token.id
# refresh erc20 contract
contract = contract_bl.get_active_smart_contract(
contract_type=CONST.CONTRACT_TYPE['ERC20'])
if contract is None:
return response_error(MESSAGE.CONTRACT_EMPTY_VERSION,
CODE.CONTRACT_EMPTY_VERSION)
response_json = []
source = None
category = None
if match_bl.is_validate_match_time(item) == False:
return response_error(MESSAGE.MATCH_INVALID_TIME,
CODE.MATCH_INVALID_TIME)
if "source_id" in item:
# TODO: check deleted and approved
source = db.session.query(Source).filter(
Source.id == int(item['source_id'])).first()
elif "source" in item and "name" in item["source"] and "url" in item[
"source"]:
source = db.session.query(Source).filter(
and_(Source.name == item["source"]["name"],
Source.url == item["source"]["url"])).first()
if source is None:
source = Source(name=item["source"]["name"],
url=item["source"]["url"],
created_user_id=uid)
db.session.add(source)
db.session.flush()
else:
if item['public'] == 1:
return response_error(MESSAGE.MATCH_SOURCE_EMPTY,
CODE.MATCH_SOURCE_EMPTY)
if "category_id" in item:
category = db.session.query(Category).filter(
Category.id == int(item['category_id'])).first()
else:
if "category" in item and "name" in item["category"]:
category = db.session.query(Category).filter(
Category.name == item["category"]["name"]).first()
if category is None:
category = Category(name=item["category"]["name"],
created_user_id=uid)
db.session.add(category)
db.session.flush()
image_url_default = CONST.SOURCE_GC_DOMAIN.format(
app.config['GC_STORAGE_BUCKET'],
'{}/{}'.format(app.config.get('GC_STORAGE_FOLDER'),
app.config.get('GC_DEFAULT_FOLDER')),
CONST.IMAGE_NAME_SOURCE_DEFAULT)
if source is not None and source.image_url is not None and source.image_url != '':
image_url_default = source.image_url
match = Match(
homeTeamName=item.get('homeTeamName', ''),
homeTeamCode=item.get('homeTeamCode', ''),
homeTeamFlag=item.get('homeTeamFlag', ''),
awayTeamName=item.get('awayTeamName', ''),
awayTeamCode=item.get('awayTeamCode', ''),
awayTeamFlag=item.get('awayTeamFlag', ''),
name=item['name'],
public=item['public'],
market_fee=int(item.get('market_fee', 0)),
date=item['date'],
reportTime=item['reportTime'],
disputeTime=item['disputeTime'],
created_user_id=uid,
source_id=None if source is None else source.id,
category_id=None if category is None else category.id,
grant_permission=int(item.get('grant_permission', 0)),
creator_wallet_address=item.get('creator_wallet_address'),
outcome_name=item.get('outcome_name'),
event_name=item.get('event_name'),
image_url=image_url_default)
db.session.add(match)
db.session.flush()
# Add default YES outcome
outcome = Outcome(name=CONST.OUTCOME_DEFAULT_NAME,
match_id=match.id,
contract_id=contract.id,
modified_user_id=uid,
created_user_id=uid,
token_id=token_id,
from_request=from_request,
approved=CONST.OUTCOME_STATUS['PENDING'])
db.session.add(outcome)
db.session.flush()
match_json = match.to_json()
match_json['contract'] = contract.to_json()
match_json['source_name'] = None if source is None else source.name
match_json[
'category_name'] = None if category is None else category.name
if source is not None:
source_json = match_bl.handle_source_data(match.source)
match_json["source"] = source_json
if category is not None:
match_json["category"] = category.to_json()
response_json.append(match_json)
# Send mail create market
send_email_create_market.delay(match.id, uid)
db.session.commit()
# Handle upload file to Google Storage
if file_name is not None and saved_path is not None and storage_bl.check_file_exist(
saved_path):
upload_file_google_storage.delay(socket.gethostname(), match.id,
file_name, saved_path)
return response_ok(response_json)
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def sign_up():
try:
saved_path = None
image_name = None
email = request.form.get('email', '')
password = request.form.get('password', '')
name = request.form.get('name', '')
title = request.form.get('title', '')
if is_valid_email(email) == False:
return response_error(MESSAGE.USER_INVALID_EMAIL,
CODE.USER_INVALID_EMAIL)
if is_valid_password(password) == False:
return response_error(MESSAGE.USER_INVALID_PASSWORD,
CODE.USER_INVALID_PASSWORD)
t = db.session.query(ReviewType).filter(
ReviewType.name == CONST.Type['People']).first()
if t is None:
return response_error(MESSAGE.TYPE_NOT_IN_DATABASE,
CODE.TYPE_NOT_IN_DATABASE)
u = User.find_user_by_email(email)
if u is None:
request_size = request.headers.get('Content-length')
if request.files and len(
request.files) > 0 and request.files['avatar'] is not None:
if int(
request_size
) <= CONST.UPLOAD_MAX_FILE_SIZE and storage_bl.validate_extension(
request.files['avatar'].filename,
CONST.UPLOAD_ALLOWED_EXTENSIONS):
time = datetime.now().timetuple()
seconds = local_to_utc(time)
image_name = '{}_{}'.format(
seconds, request.files['avatar'].filename)
saved_path = storage_bl.handle_upload_file(
request.files['avatar'], file_name=image_name)
else:
return response_error(MESSAGE.FILE_TOO_LARGE,
CODE.FILE_TOO_LARGE)
gc_services.upload_to_storage(g.GC_STORAGE_BUCKET, saved_path,
g.GC_STORAGE_FOLDER, image_name)
u = User(name=name,
email=email,
password=hashlib.md5(password).hexdigest(),
type_id=t.id,
title=title,
avatar='{}{}'.format(CONST.BASE_IMAGE_URL, image_name)
if image_name is not None else None)
db.session.add(u)
db.session.flush()
else:
return response_error(MESSAGE.USER_EMAIL_EXIST_ALREADY,
CODE.USER_EMAIL_EXIST_ALREADY)
response = u.to_json()
response['access_token'] = create_access_token(identity=email,
fresh=True)
db.session.commit()
storage_bl.delete_file(saved_path)
return response_ok(response)
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def update_user(user_id):
try:
u = User.find_user_by_id(user_id)
if u is None:
return response_error(MESSAGE.USER_INVALID, CODE.USER_INVALID)
email = request.form.get('email', '')
password = request.form.get('password', '')
name = request.form.get('name', '')
title = request.form.get('title', '')
role_id = request.form.get('role_id')
t = db.session.query(ReviewType).filter(
ReviewType.name == CONST.Type['People']).first()
if t is None:
return response_error(MESSAGE.TYPE_NOT_IN_DATABASE,
CODE.TYPE_NOT_IN_DATABASE)
if len(email) > 0:
if is_valid_email(email) == False or \
User.find_user_by_email(email) is not None:
return response_error(MESSAGE.USER_INVALID_EMAIL,
CODE.USER_INVALID_EMAIL)
u.email = email
if len(password) > 0:
if is_valid_password(password) == False:
return response_error(MESSAGE.USER_INVALID_PASSWORD,
CODE.USER_INVALID_PASSWORD)
u.password = hashlib.md5(password).hexdigest()
if len(name) > 0:
u.name = name
if len(title) > 0:
u.title = title
if role_id is not None and \
Role.find_role_by_id(role_id) is not None:
u.role_id = role_id
request_size = request.headers.get('Content-length')
if request.files and len(
request.files) > 0 and request.files['avatar'] is not None:
if int(
request_size
) <= CONST.UPLOAD_MAX_FILE_SIZE and storage_bl.validate_extension(
request.files['avatar'].filename,
CONST.UPLOAD_ALLOWED_EXTENSIONS):
time = datetime.now().timetuple()
seconds = local_to_utc(time)
image_name = '{}_{}'.format(seconds,
request.files['avatar'].filename)
saved_path = storage_bl.handle_upload_file(
request.files['avatar'], file_name=image_name)
else:
return response_error(MESSAGE.FILE_TOO_LARGE,
CODE.FILE_TOO_LARGE)
gc_services.upload_to_storage(g.GC_STORAGE_BUCKET, saved_path,
g.GC_STORAGE_FOLDER, image_name)
u.avatar = '{}{}'.format(CONST.BASE_IMAGE_URL, image_name)
db.session.commit()
return response_ok(u.to_json())
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def update_image(source_id):
try:
source = Source.find_source_by_id(source_id)
if source is None:
return False
request_size = request.headers.get('Content-length') # string
is_update_matchs = request.form.get('update_matchs', '0') == '1'
image_name = '{}_{}'.format(source.id, source.name).lower()
image_name = re.sub(r'[^A-Za-z0-9\_\-\.]+', '_', image_name)
image_name = '{}.jpg'.format(image_name)
if request.files and len(
request.files) > 0 and request.files['image'] is not None:
if int(
request_size
) <= CONST.UPLOAD_MAX_FILE_SIZE and storage_bl.validate_extension(
request.files['image'].filename,
CONST.UPLOAD_ALLOWED_EXTENSIONS):
image_name, saved_path = storage_bl.handle_upload_file(
request.files['image'], file_name=image_name)
saved_path, crop_saved_path = storage_bl.handle_crop_image(
image_name, saved_path)
else:
return response_error(MESSAGE.FILE_TOO_LARGE,
CODE.FILE_TOO_LARGE)
if image_name is not None and saved_path is not None:
result_upload = gc_storage_client.upload_to_storage(
app.config.get('GC_STORAGE_BUCKET'), crop_saved_path,
'{}/{}'.format(app.config.get('GC_STORAGE_FOLDER'),
app.config.get('GC_DEFAULT_FOLDER')),
image_name, True)
if result_upload is False:
return response_error()
storage_bl.delete_file(crop_saved_path)
storage_bl.delete_file(saved_path)
# Update image_url all matchs
if is_update_matchs:
t = datetime.now().timetuple()
seconds = local_to_utc(t)
matches = db.session.query(Match)\
.filter(\
and_(\
Match.source_id == source.id,
or_(Match.image_url == None, Match.image_url == ""),
Match.deleted == 0,\
Match.date > seconds,\
Match.public == 1,\
Match.id.in_(db.session.query(Outcome.match_id).filter(and_(Outcome.result == -1, Outcome.hid != None)).group_by(Outcome.match_id))
)\
)\
.all()
image_url = CONST.SOURCE_GC_DOMAIN.format(
app.config['GC_STORAGE_BUCKET'],
'{}/{}'.format(app.config.get('GC_STORAGE_FOLDER'),
app.config.get('GC_DEFAULT_FOLDER')),
image_name)
for match in matches:
match.image_url = image_url
db.session.flush()
db.session.commit()
return response_ok()
except Exception, ex:
db.session.rollback()
return response_error(ex.message)