def release_output(self, output):
output.release()
HttpClient.make_request(
TimestampUtils.get_miliseconds(self.starting_interval_seconds),
TimestampUtils.get_miliseconds(self.next_interval_seconds),
self.current_video_piece_filename)
self.delete_file()
def isOnTime(self, priceByTime, nextPriceByTime, isNextDay):
if not priceByTime or not nextPriceByTime:
return False
if not 'from' in priceByTime or not 'from' in nextPriceByTime:
return False
timeArray = priceByTime['from'].split(':')
nextTimeArray = nextPriceByTime['from'].split(':')
if len(timeArray) != 2 or len(nextPriceByTime) != 2:
return False
hour = int(timeArray[0])
minute = int(timeArray[1])
currentHour = TimestampUtils.getVietNamCurrentHour()
currentMinute = TimestampUtils.getVietnamCurrentMinute()
nextPriceByTimeHour = int(nextTimeArray[0])
#print(hour, minute, currentHour, currentMinute, nextPriceByTimeHour)
if currentHour - hour > 0:
return True # Set 3:30 and current time is 4:0
if currentHour - hour == 0 and currentMinute - minute >= 0:
return True # Set 3:30 and current time is 3:40
if currentHour < nextPriceByTimeHour and isNextDay == True:
return True # Set 21:30 and current time is 1:0 of next day.
return False
def send_file_multiple_times(filename='sample.mp4', seconds_to_add=10):
for index in range(MINIMUM_NUMBER_OF_REPETITIONS_EXPECTED):
starting_timestamp = time.time()
final_timestamp = starting_timestamp + float(seconds_to_add)
HttpClient.make_request(
TimestampUtils.get_miliseconds(starting_timestamp),
TimestampUtils.get_miliseconds(final_timestamp), filename)
def createShop():
if (ApiUtils.checkTokenArgument(request.args) == False):
return make_response(jsonify({'error': 'Missing token'}), 400)
if not request.json:
return make_response(
jsonify({'error': 'Missing json parameters value'}), 422)
if not 'name' in request.json:
return make_response(
jsonify({'error': 'Missing json parameter value'}), 422)
if not 'email' in request.json:
return make_response(
jsonify({'error': 'Missing json parameter value'}), 422)
if not 'api_key' in request.json:
return make_response(
jsonify({'error': 'Missing json parameter value'}), 422)
token = request.args.get('token')
shop = {
"name": request.json['name'],
"email": request.json['email'],
"api_key": request.json['api_key'],
"created_at": TimestampUtils.getCurrentDatetime()
}
shopCtrl = ShopController()
result = shopCtrl.createShop(token, shop)
if 'success' in result:
return make_response(jsonify(result), 201)
else:
return make_response(jsonify(result), 400)
def run(self):
user = self.kwargs['user']
accountStatement = self.kwargs['account_statement']
print('''*********** Process Account Statement for {} ***********'''.
format(user['lazada_user_name']))
# Compute income
income, exceptions = self.process(user, accountStatement)
# Update Account Statement income
datetimeStr = TimestampUtils.getCurrentDatetime()
updateException = accountStatementDao.update(user,
accountStatement['id'],
income, datetimeStr)
if (updateException != None):
print(updateException)
# Add Account Statement exceptions
print(exceptions)
for exception in exceptions:
insertException = accountStatementExceptionDao.insert(
user, exception['order_number'], accountStatement['id'],
exception['reason'], datetimeStr)
if (insertException != None):
print(insertException)
def getAllAccountStatement(self, token):
user, exception = Validation.validateToken(token)
if (exception != None):
return ResponseUtils.returnError(exception)
accountStatementDao = AccountStatementDao()
data, exception = accountStatementDao.getAll(user)
if (exception != None):
return ResponseUtils.returnError(exception)
for accountSta in data:
accountSta['start_date'] = TimestampUtils.getDateFromDatetime(
accountSta['start_date'])
accountSta['end_date'] = TimestampUtils.getDateFromDatetime(
accountSta['end_date'])
return ResponseUtils.returnSuccess(data)
def changeOriginPrice(self, token, orderItems, accountStatementId):
user, exception = Validation.validateToken(token)
if (exception != None):
return ResponseUtils.returnError(exception)
orderItemDao = OrderItemDao()
for orderItem in orderItems:
# Get current OrderItem
curOrderItem, exception = orderItemDao.getOrderItemByOrderItemId(
user, orderItem['order_item_id'])
if (exception != None):
return ResponseUtils.returnError(exception)
# Recompute earned/income and update
commission = curOrderItem['actual_paid_price'] - curOrderItem[
'earned'] - curOrderItem['original_price']
orderItem['earned'] = curOrderItem['actual_paid_price'] - (
commission + orderItem['original_price'])
exception = orderItemDao.changeOriginalPrice(user, orderItem)
if (exception != None):
return ResponseUtils.returnError(exception)
# Update product's orginal price if its value is Zero
if (curOrderItem['original_price'] == 0):
productDao = ProductDao()
exception = productDao.updateOriginalPriceByShopSku(
user, orderItem['shop_sku'], orderItem['original_price'])
if (exception != None):
return ResponseUtils.returnError(exception)
# Compute an account statement income
income, exception = orderItemDao.getTotalEarningOfAccountStatement(
user, accountStatementId)
if (exception != None):
return ResponseUtils.returnError(exception)
# Recompute account statment income
accountStatementDao = AccountStatementDao()
updatedDate = TimestampUtils.getCurrentDatetime()
exception = accountStatementDao.update(user, accountStatementId,
income, updatedDate)
if (exception != None):
return ResponseUtils.returnError(exception)
return ResponseUtils.generateSuccessResponse(None)
def insertHistory(self, sku, enemies, user, updateLazadaSpecialPriceStatus):
if enemies == None or len(enemies) == 0:
return
currentMillisecond = TimestampUtils.getCurrentMillisecond()
# Delete oldest histories first
historyDao = HistoryDao()
lastdayMillisecond = currentMillisecond - 6*60*60 # Store history only for 6 latest hours
historyDao.deleteHistories(sku, lastdayMillisecond)
# Only take enemies in a limitation
if len(enemies) > SkuConfig.HISTORY_ENEMY_LIMIT_SIZE:
enemies = enemies[:SkuConfig.HISTORY_ENEMY_LIMIT_SIZE]
history = {
'enemy_json': json.dumps(enemies, ensure_ascii=False),
'status': updateLazadaSpecialPriceStatus,
'created_at': currentMillisecond
}
historyDao.insertHistory(history, sku, user)