def __init__(self, angle, power, player, type): pygame.sprite.Sprite.__init__(self, self.containers) folder = 'dan' self.frame_rate = 1 image_source = Utils.my_load_image(folder, type) self.images = [] if type=='simple.png': self.images = Utils.load_frame(image_source, 0, 0, 30, 30, 0, 4) else: self.images = Utils.load_frame(image_source, 0, 0, 30, 28, 0, 4) self.frame_length = len(self.images) self.frame = 0 self.image = self.images[int(round(self.frame))] self.rect = self.image.get_rect() self.speed_x = math.cos(math.radians(angle)) * power * 2 + 20 self.speed_y = -math.sin(math.radians(angle)) * power * 2 + 50 self.acceleration = Constant.GRAVITY self.t = 0 self.start_x = player.pos[0]#centerx self.start_y = player.pos[1]#.centery - 70 self.rect.move_ip(self.start_x, self.start_y) self.x = self.start_x self.y = self.start_y self.energy_cost = 10 self.pos_creep_screen = -100
def __init__(self, x, y, left, right, direction, speed_x):
"""
Constructor
:param x: position x in screen
:param y: position y in screen
:param direction: direction to move, 0 or 1
:return:
"""
BasicCreep.__init__(self, x, y, left, right)
# Coefficients
self.frame = 0
self.move_speed_x = speed_x
self.frame_rate = 0.8 * 0.25 * speed_x
self.move_speed_y = 1
self.direction = direction # TODO Define enum
if self.direction == 1:
self.move_speed_x = -self.move_speed_x
self.dis = 0
self.left = left
self.right = self.right
# Status
self.down_able = True
image_source = Utils.my_load_image('creep', 'creep3.png')
self.images_forward = Utils.load_frame(image_source, 0, 0, 131.5, 66,
0, 4)
images_forward_ex1 = Utils.load_frame(image_source, 0, 69, 129.3, 47,
0, 3)
images_forward_ex2 = Utils.load_frame(image_source, 0, 143, 131.5, 66,
0, 4)
images_forward_ex3 = Utils.load_frame(image_source, 0, 214, 129.3, 47,
0, 3)
for image in images_forward_ex1:
self.images_forward.append(image)
for image in images_forward_ex2:
self.images_forward.append(image)
for image in images_forward_ex3:
self.images_forward.append(image)
for i in range(len(self.images_forward) - 1, -1, -1):
self.images_forward.append(self.images_forward[i])
self.images_back = []
for image in self.images_forward:
self.images_back.append(pygame.transform.flip(image, 1, 0))
self.frame_length = len(self.images_forward)
self.image = self.images_forward[0]
self.rect = self.image.get_rect() # Default position at (0,0)
self.rect.move_ip(x, y)
def game_over(screen,gamestate):
pygame.mouse.set_visible(1)
# #create the background, tile the bgd image
bgdtile = Utils.load_image('gameover_back.jpg')
background = pygame.Surface(Constant.SCREENRECT.size)
for x in range(0, Constant.SCREENRECT.width, bgdtile.get_width()):
background.blit(bgdtile, (x, 0))
playagain = pygbutton.PygButton((380, 400, 100, 40), 'Play again')
quit = pygbutton.PygButton((520, 400, 100, 40), 'Quit')
while gamestate == Constant.GAMEOVER:
for event in pygame.event.get():
if event.type == QUIT or \
(event.type == KEYDOWN and event.key == K_ESCAPE):
return
if 'click' in playagain.handleEvent(event):
gamestate = Constant.GAME
if(gamestate == Constant.GAME):
CreepManager.init()
main(screen)
if 'click' in quit.handleEvent(event):
if pygame.mixer:
pygame.mixer.music.fadeout(1000)
pygame.time.wait(1000)
pygame.quit()
screen.blit(background, (0,0))
playagain.draw(background)
quit.draw(background)
pygame.display.flip()
def UploadFile(self, strfileName, strFile, strFolder):
try:
strRemoteFileName = strfileName
strURIRequest = self.strURIFile
if strFolder == "":
strURIRequest += strRemoteFileName
else:
strURIRequest += strFolder + "/" + strRemoteFileName
signedURI = Utils.Sign(strURIRequest)
Utils.uploadFileBinary(signedURI, strFile)
except:
raise "exception"
def __init__(self):
pygame.sprite.Sprite.__init__(self, self.containers)
image_resource = Utils.my_load_image('nhan vat 2', 'dead.png')
self.image = image_resource.subsurface(100, 550, 1200, 200)
self.rect = self.image.get_rect(midbottom=Constant.SCREENRECT.midbottom)
self.mask = pygame.mask.from_surface(self.image)
def register_user(email, password):
"""
This method registers a user using e-mail and password.
The password already come with sha-512 hash algorithm.
:param email: user's email (might be invalid)
:param password: sha512-hashed password
:return: True if registered successfully, of False otherwise
"""
userData = Database.find_one("users", {'email': email})
if userData is not None:
raise UserExistsError("user already existed!")
#if email is invalid, then what?
if not Utils.email_is_valid(email):
raise UserEmailInvalid("invalid email!")
#hash password, create new object, then insert to db
User(email, Utils.hash_password(password)).save_to_db()
return True
def __init__(self, x, y, left, right, direction, speed_x):
"""
Constructor
:param x: position x in world
:param y: position y in world
:param direction: direction to move, 0 or 1
:param left, right: limit position for moving of creep
:return: None
"""
CreepA.__init__(self, x, y, left, right, direction, speed_x)
# Coefficients
self.frame = 0
self.move_speed_x = speed_x
self.frame_rate = self.move_speed_x * 0.3
self.move_speed_y = 1
self.direction = direction # TODO Define enum
if self.direction == 1:
self.move_speed_x = -self.move_speed_x
self.x = x
self.y = y
self.pos_creep_screen = 0
self.left = left
self.right = right
# Status
self.down_able = True
image_source = Utils.my_load_image("creep", "creep1.png")
self.images_forward = Utils.load_frame(image_source, 803, 215, 41, 55, 12, 4)
self.images_back = []
for image in self.images_forward:
self.images_back.append(pygame.transform.flip(image, 1, 0))
self.frame_length = len(self.images_forward)
self.image = self.images_forward[0]
self.rect = self.image.get_rect() # Default position at (0,0)
self.rect.move_ip(self.pos_creep_screen, self.y)
self.base_line = self.y
def register_user(email, password):
"""
This method registers a user using e-mail and password.
The password already comes hashed as sha-512.
:param email: user's e-mail (might be invalid)
:param password: sha512-hashed password
:return: True if registered successfully, or False otherwise (exceptions can also be raised)
"""
user_data = Database.find_one(UserConstants.COLLECTION, {"email": email})
if user_data is not None:
raise UserErrors.UserAlreadyRegisteredError("The e-mail you used to register already exists.")
if not Utils.email_is_valid(email):
raise UserErrors.InvalidEmailError("The e-mail does not have the right format.")
user = User(email, Utils.hash_password(password))
user.save_to_db()
return user
def createFolder(self, strFolder):
try:
# build URI
strURIRequest = self.strURIFolder + "/" + strFolder
signedURI = Utils.Sign(Utils(), strURIRequest)
responseStream = Utils.processCommand(Utils(), signedURI, "PUT", "", "")
return responseStream
except:
raise "exception"
def login_valid_user(email, password):
"""
:param email: user's email
:param password: user's password
:return: True if valid, False otherwise
"""
userData = Database.find_one("users", {'email': email})
if userData is None:
raise UserNotExistsError("this user does not existed!")
return False
if not Utils.check_hashed_password(password, userData['password']):
raise UserIncorrectPasswordError("Incorrect password!")
return False
return True
def getSpaceInfo(self):
try:
# build URI
strURI = self.strURIDisc
# sign URI
signedURI = Utils.Sign(Utils(), strURI)
responseStream = Utils.processCommand(Utils(), signedURI, "GET", "JSON", "")
return responseStream
except:
raise "exception"
def __init__(self, folder, sprite_name, direction, whichplayer, offset, screen):
pygame.sprite.Sprite.__init__(self, self.containers)
self.reloading = 0
self.frame = 0
self.thow_frame = 24
self.facing = direction
self.direction = direction
self.sound_change_radar = Utils.load_sound("bite.wav");
self.sound_change_radar.set_volume(0.3)
image_source = Utils.my_load_image(folder, sprite_name+".png")
emotion_source = Utils.my_load_image(folder, sprite_name+"_emotion.png")
if whichplayer == 1:
self.image_frame = Utils.cut_frame(image_source, 114, 90, 110, 90)
self.image_frame.extend(Utils.cut_frame(emotion_source,114,90,110,90))
else:
self.image_frame = Utils.cut_frame(image_source, 114, 85, 110, 98)
self.image_frame.extend(Utils.cut_frame(emotion_source,114,85,110,98))
if self.direction > 0:
self.image = self.image_frame[0]
else:
self.image = pygame.transform.flip(self.image_frame[0],0,0)
self.rect = Rect(160, 200, 110, 90)
self.rect = self.rect.inflate(-30, -30)
self.pos = [self.rect.left + 19 , self.rect.top + 18]
self.origtop = self.rect.top
self.health = 100
self.angle = 45
self.power = Constant.MAXPOWER * self.fireF
self.typeOfBullet = EBulletType.BASIC
self.moveWithScreen = False
self.mask = pygame.mask.from_surface(self.image)
self.whichplayer = whichplayer
self.enegery = 100
self.screen = screen
self.coin = 0
Live_bar(self, None, 1)
Energy_bar(self)
Power_bar(self)
self.money = 0
self.sound_money = Utils.load_sound('yahoo.ogg')
def getFolders(self):
try:
# build URI
strURIRequest = self.strURIFolder
signedURI = Utils.Sign(Utils(), strURIRequest)
responseStream = Utils.processCommand(Utils(), signedURI, "GET", "JSON", "")
if responseStream.status_code != 200:
return False
else:
return responseStream
except:
raise "exception"
def is_login_valid(cls, email, password):
"""
This method verifies that an e-mail/password combo (as sent by the site forms) is valid or not.
Checks that the e-mail exists, and that the password associated to that e-mail is correct.
:param email: The user's email
:param password: A sha512 hashed password
:return: True if valid, False otherwise
"""
user_data = Database.find_one(UserConstants.COLLECTION, {"email": email}) # Password in sha512 -> pbkdf2_sha512
if user_data is None:
# Tell the user that their e-mail doesn't exist
raise UserErrors.UserNotExistsError("Your user does not exist.")
if not Utils.check_hashed_password(password, user_data['password']):
# Tell the user that their password is wrong
raise UserErrors.IncorrectPasswordError("Your password was wrong.")
return cls(**user_data)
def FileExists(self, fileName):
try:
if fileName == "":
raise Exception("No file name specified")
# build URI
strURI = self.strURIExist + fileName
# sign URI
signedURI = Utils.Sign(Utils(), strURI)
responseStream = Utils.processCommand(Utils(), signedURI, "GET", "JSON", "")
return responseStream
except:
raise "exception"
def DeleteFile(self, fileName):
try:
# //check whether file is set or not
if fileName == "":
raise Exception("No file name specified")
# build URI
strURI = self.strURIFile + fileName
# sign URI
signedURI = Utils.Sign(strURI)
responseStream = json_decode(Utils.processCommand(signedURI, "DELETE", "", ""))
if responseStream.code != 200:
return False
else:
return True
except:
raise "exception"
df_growth_data = self.get_growth_data() df_growth_data = df_growth_data.set_index( 'code' ) df_debtpaying_data = self.get_debtpaying_data() df_debtpaying_data = df_debtpaying_data.set_index( 'code' ) df_cashflow_data = self.get_cashflow_data() df_cashflow_data = df_cashflow_data.set_index( 'code' ) df_divi_data = self.get_divi_data() df_divi_data = df_divi_data.set_index( 'code' ) df_forcast_quarter_report_data = self.get_forcast_quarter_report_data() df_forcast_quarter_report_data = df_forcast_quarter_report_data.set_index( 'code' ) df_restrict_stock_data = self.get_restrict_stock_data() df_restrict_stock_data = df_restrict_stock_data.set_index( 'code' ) df_concept_classified = self.get_concept_classified_data() df_concept_classified = df_concept_classified.set_index( 'code' ) LOG( 'finish loading.' ) return [ df_stock_basics, df_quarter_report_data, df_profit_data, df_operation_data, df_growth_data, df_debtpaying_data, \ df_cashflow_data, df_divi_data, df_forcast_quarter_report_data, df_restrict_stock_data, df_concept_classified ] '''--------------- run ---------------''' if __name__ == '__main__': Data( Utils.cur_date() ).update_all()
def register_user(email, password, nick_name, file=None):
el = Elasticsearch(port=port)
"""
This method registers a user using e-mail and password
The password already comes hashed as sha-512
:param email: user's email (might be invalid)
:param password: sha512-hashed password
:return: True if registered successfully, of False otherwise (exceptions can also be raised)
"""
try:
user_data = Database.find_one(UserConstants.COLLECTION,
{"email": email})
if user_data is not None:
# Tell user they are already registered
raise UserErrors.UserAlreadyRegisteredError(
"The e-mail you used to register already exists.")
if not Utils.email_is_valid(email):
# Tell user that their e-mail is not constructed properly.
raise UserErrors.InvalidEmailError(
"The e-mail does not have the right format.")
if nick_name == '' or nick_name == None:
user = User(email,
Utils.hash_password(password),
nick_name=None,
picture=file)
user.save_to_mongo()
doc = {
'email': email,
'nick_name': nick_name,
'user_id': user._id,
}
else:
user = User(email,
Utils.hash_password(password),
nick_name=nick_name,
picture=file)
user.save_to_mongo()
doc = {
'email': email,
'nick_name': nick_name,
'user_id': user._id,
}
el.index(index="users", doc_type='user', body=doc, id=user._id)
return True
except TypeError:
if not Utils.email_is_valid(email):
# Tell user that their e-mail is not constructed properly.
raise UserErrors.InvalidEmailError(
"The e-mail does not have the right format.")
user_id = User.find_by_email(email)._id
if nick_name == '' or nick_name == None:
User(email,
Utils.hash_password(password),
nick_name=None,
picture=file).save_to_mongo()
doc = {
'email': email,
'nick_name': nick_name,
'user_id': user_id,
}
else:
User(email,
Utils.hash_password(password),
nick_name=nick_name,
picture=file).save_to_mongo()
doc = {
'email': email,
'nick_name': nick_name,
'user_id': user_id,
}
el.index(index="users", doc_type='user', body=doc, id=user_id)
return True
def __init__(self):
self.preprocessing = Preprocessing()
self.utils = Utils()
class ServiceStatus:
def __init__(self, repo, net_id):
self.repo = repo
self.route = "/encoding"
self.rex_for_pb_ip = "^(http://)*(https://)*127.0.0.1|^(http://)*(https://)*localhost|^(http://)*(https://)*192.|^(http://)*(https://)*172.|^(http://)*(https://)*10."
self.obj_util = Utils()
self.net_id = net_id
def _get_service_status(self, url, secure=True):
try:
if secure:
channel = grpc.secure_channel(
url,
grpc.ssl_channel_credentials(
root_certificates=certificate))
else:
channel = grpc.insecure_channel(url)
stub = heartb_pb2_grpc.HealthStub(channel)
response = stub.Check(heartb_pb2.HealthCheckRequest(service=""),
timeout=SRVC_STATUS_GRPC_TIMEOUT)
if response is not None and response.status == 1:
logger.info(response.status)
return 1, "", ""
return 0, "", ""
except Exception as e:
logger.info(f"error in making grpc call::url: {url}, |error: {e}")
logger.info(f"error : {e.args}")
return 0, e.args[0].details, e.args[0].debug_error_string
def _ping_url(self, url):
search_count = re.subn(self.rex_for_pb_ip, "", url)[1]
if search_count == 0:
secure = True
if url[:4].lower() == "http" and url[:5].lower() != "https":
secure = False
url = self.obj_util.remove_http_https_prefix(url=url)
return self._get_service_status(url=url, secure=secure)
return 0, "", ""
def _get_service_endpoint_data(self):
query = "SELECT row_id, org_id, service_id, endpoint, is_available, failed_status_count FROM service_endpoint WHERE " \
"next_check_timestamp < UTC_TIMESTAMP AND endpoint not regexp %s AND (org_id,service_id) IN (SELECT org_id, service_id FROM service WHERE service.is_curated=1) ORDER BY last_check_timestamp ASC " \
"LIMIT %s"
result = self.repo.execute(query, [self.rex_for_pb_ip, LIMIT])
if result is None or result == []:
logger.info("Unable to find services.")
return result
def _update_service_status_parameters(self, status, next_check_timestamp,
failed_status_count, row_id):
update_query = "UPDATE service_endpoint SET is_available = %s, last_check_timestamp = current_timestamp, " \
"next_check_timestamp = %s, failed_status_count = %s WHERE row_id = %s "
response = self.repo.execute(
update_query,
[status, next_check_timestamp, failed_status_count, row_id])
return response
def _update_service_status_stats(self, org_id, service_id, old_status,
status):
previous_state = "UP" if (old_status == 1) else "DOWN"
current_state = "UP" if (status == 1) else "DOWN"
try:
insert_query = "insert into service_status_stats " \
"(org_id, service_id, previous_state, current_state, row_created, row_updated) " \
"values (%s, %s, %s, %s, %s, %s)"
self.repo.execute(insert_query, [
org_id, service_id, previous_state, current_state,
dt.utcnow(),
dt.utcnow()
])
except Exception as e:
logger.info(
f"error in inserting service status stats, |error: {e}")
return
def update_service_status(self):
service_endpoint_data = self._get_service_endpoint_data()
rows_updated = 0
for record in service_endpoint_data:
status, error_details, debug_error_string = self._ping_url(
record["endpoint"])
logger.info(f"error_details: {error_details}")
logger.info(f"debug_error_string: {debug_error_string}")
old_status = int.from_bytes(record["is_available"], "big")
failed_status_count = self._calculate_failed_status_count(
current_status=status,
old_status=old_status,
old_failed_status_count=record["failed_status_count"])
next_check_timestamp = self._calculate_next_check_timestamp(
failed_status_count=failed_status_count)
query_data = self._update_service_status_parameters(
status=status,
next_check_timestamp=next_check_timestamp,
failed_status_count=failed_status_count,
row_id=record["row_id"])
if old_status != status:
self._update_service_status_stats(record["org_id"],
record["service_id"],
old_status, status)
if status == 0:
org_id = record["org_id"]
service_id = record["service_id"]
recipients = self._get_service_provider_email(
org_id=org_id, service_id=service_id)
self._send_notification(org_id=org_id,
service_id=service_id,
recipients=recipients,
endpoint=record["endpoint"],
error_details=error_details,
debug_error_string=debug_error_string)
rows_updated = rows_updated + query_data[0]
logger.info(f"no of rows updated: {rows_updated}")
def _calculate_failed_status_count(self, current_status, old_status,
old_failed_status_count):
if current_status == old_status == 0:
return old_failed_status_count + 1
return 1
def _calculate_next_check_timestamp(self, failed_status_count):
time_delta_in_hours = MINIMUM_INTERVAL_IN_HOUR * (2**(
failed_status_count - 1))
if time_delta_in_hours > MAXIMUM_INTERVAL_IN_HOUR:
time_delta_in_hours = MAXIMUM_INTERVAL_IN_HOUR
next_check_timestamp = dt.utcnow() + timedelta(
hours=time_delta_in_hours)
return next_check_timestamp
def _valid_email(self, email):
regex = '^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$'
if re.search(regex, email):
return True
return False
def _send_notification(self, org_id, service_id, recipients, endpoint,
error_details, debug_error_string):
slack_message = self._get_slack_message(
org_id=org_id,
service_id=service_id,
endpoint=endpoint,
recipients=recipients,
error_details=error_details,
debug_error_string=debug_error_string)
util.report_slack(slack_msg=slack_message, SLACK_HOOK=SLACK_HOOK)
for recipient in recipients:
if recipient is None:
logger.info(
f"Email Id is not present for Org Id: {org_id} and Service Id: {service_id}"
)
else:
if self._valid_email(email=recipient):
self._send_email_notification(org_id=org_id,
service_id=service_id,
recipient=recipient,
endpoint=endpoint)
else:
logger.info(f"Invalid email_id: {recipient}")
def _get_slack_message(self, org_id, service_id, endpoint, recipients,
error_details, debug_error_string):
slack_message = f"```Alert!\n\nService {service_id} under organization {org_id} is down for {NETWORK_NAME} " \
f"network.\nEndpoint: {endpoint}\nError Details: {error_details}\nDebug Error String: " \
f"{debug_error_string}\nContributors: {recipients} \n\nFor any queries please email at " \
f"[email protected]. \n\nWarmest regards, \nSingularityNET Marketplace Team```"
return slack_message
def _send_email_notification(self, org_id, service_id, recipient,
endpoint):
RESET_SERVICE_HEALTH_URL = f"{BASE_URL_TO_RESET_SERVICE_HEALTH}/org/{org_id}/service/{service_id}/health/reset"
send_notification_payload = {
"body":
json.dumps({
"message":
f"<html><head></head><body><div><p>Hello,</p><p>Your service {service_id} under organization "
f"{org_id} is down.</p><p>Please click the below URL to update service status on priority. "
f"<br/> <a href='{RESET_SERVICE_HEALTH_URL}'>{RESET_SERVICE_HEALTH_URL}</a></p><br /><p><em>"
f"Please do not reply to the email for any enquiries for any queries please email at "
f"[email protected]. </em></p><p>Warmest regards, <br /> SingularityNET "
f"Marketplace Team</p></div></body></html>",
"subject":
f"Your service {service_id} is down for {NETWORK_NAME} network.",
"notification_type":
"support",
"recipient":
recipient
})
}
boto_util.invoke_lambda(lambda_function_arn=NOTIFICATION_ARN,
invocation_type="RequestResponse",
payload=json.dumps(send_notification_payload))
def _get_service_provider_email(self, org_id, service_id=None):
emails = []
query_response = self.repo.execute(
"SELECT contributors FROM service_metadata WHERE org_id = %s AND "
"service_id = %s", [org_id, service_id])
if len(query_response) == 0:
logger.info(f"Org Id {org_id} is not present.")
return None
contacts = json.loads(query_response[0].get("contributors", '[]'))
for contact in contacts:
email_id = contact.get("email_id", None)
if email_id is not None:
emails.append(email_id)
return emails
class Registry:
def __init__(self, obj_repo):
self.repo = obj_repo
self.obj_utils = Utils()
def service_build_status_notifier(self, org_id, service_id, build_status):
logger.info(
f"received event for service_id: {service_id} org_id:{org_id}")
if build_status == BUILD_CODE['FAILED']:
self.curate_service(org_id, service_id, curated=False)
elif build_status == BUILD_CODE['SUCCESS']:
self.curate_service(org_id, service_id, curated=True)
else:
raise Exception("invalid build status")
def _get_all_service(self):
""" Method to generate org_id and service mapping."""
try:
all_orgs_srvcs_raw = self.repo.execute(
"SELECT O.org_id, O.organization_name,O.org_assets_url, O.owner_address, S.service_id FROM service S, "
"organization O WHERE S.org_id = O.org_id AND S.is_curated = 1"
)
all_orgs_srvcs = {}
for rec in all_orgs_srvcs_raw:
if rec['org_id'] not in all_orgs_srvcs.keys():
all_orgs_srvcs[rec['org_id']] = {
'service_id': [],
'organization_name': rec["organization_name"],
'owner_address': rec['owner_address']
}
all_orgs_srvcs[rec['org_id']]['service_id'].append(
rec['service_id'])
return all_orgs_srvcs
except Exception as e:
print(repr(e))
raise e
def _get_all_members(self, org_id=None):
""" Method to generate org_id and members mapping."""
try:
query = "SELECT org_id, `member` FROM members M"
params = None
if org_id is not None:
query += " where M.org_id = %s"
params = [org_id]
all_orgs_members_raw = self.repo.execute(query, params)
all_orgs_members = defaultdict(list)
for rec in all_orgs_members_raw:
all_orgs_members[rec['org_id']].append(rec['member'])
return all_orgs_members
except Exception as e:
print(repr(e))
raise e
def get_all_org(self):
""" Method to get list and high level details of all organization."""
try:
all_orgs_srvcs = self._get_all_service()
all_orgs_members = self._get_all_members()
all_orgs_data = []
for org_rec in all_orgs_srvcs:
data = {
"org_id": org_rec,
"org_name": all_orgs_srvcs[org_rec]["organization_name"],
"owner_address": all_orgs_srvcs[org_rec]['owner_address'],
"service_id": all_orgs_srvcs[org_rec]['service_id'],
"members": all_orgs_members.get(org_rec, [])
}
all_orgs_data.append(data)
return all_orgs_data
except Exception as e:
print(repr(e))
raise e
def _prepare_subquery(self, s, q, fm):
try:
sub_qry = ""
if s == "all":
for rec in fm:
sub_qry += fm[rec] + " LIKE '%" + str(q) + "%' OR "
sub_qry = sub_qry[:-3] if sub_qry.endswith("OR ") else sub_qry
else:
sub_qry += fm[s] + " LIKE '%" + str(q) + "%' "
return sub_qry.replace("org_id", "M.org_id")
except Exception as err:
raise err
def _get_total_count(self, sub_qry, filter_query, values):
try:
if filter_query != "":
filter_query = " AND " + filter_query
search_count_query = "SELECT count(*) as search_count FROM service A, (SELECT DISTINCT M.org_id, M.service_id FROM " \
"service_metadata M LEFT JOIN service_tags T ON M.service_row_id = T.service_row_id WHERE (" \
+ sub_qry.replace('%',
'%%') + ")" + filter_query + ") B WHERE A.service_id = B.service_id " \
"AND A.org_id = B.org_id AND A.is_curated = 1 "
res = self.repo.execute(search_count_query, values)
return res[0].get("search_count", 0)
except Exception as err:
raise err
def _convert_service_metadata_str_to_json(self, record):
record["service_rating"] = json.loads(record["service_rating"])
record["org_assets_url"] = json.loads(record["org_assets_url"])
record["contributors"] = json.loads(record.get("contributors", "[]"))
record["contacts"] = json.loads(record.get("contacts", "[]"))
if record["contacts"] is None:
record["contacts"] = []
if record["contributors"] is None:
record["contributors"] = []
def _search_query_data(self, sub_qry, sort_by, order_by, offset, limit,
filter_query, values):
try:
if filter_query != "":
filter_query = " AND " + filter_query
srch_qry = "SELECT * FROM service A, (SELECT M.org_id, M.service_id, group_concat(T.tag_name) AS tags FROM " \
"service_metadata M LEFT JOIN service_tags T ON M.service_row_id = T.service_row_id " \
"LEFT JOIN service_endpoint E ON M.service_row_id = E.service_row_id WHERE (" \
+ sub_qry.replace('%', '%%') + ")" + filter_query + \
" GROUP BY M.org_id, M.service_id ORDER BY E.is_available DESC, " + sort_by + " " + order_by + \
" ) B WHERE A.service_id = B.service_id AND A.org_id=B.org_id AND A.is_curated= 1 LIMIT %s , %s"
qry_dta = self.repo.execute(srch_qry, values +
[int(offset), int(limit)])
org_srvc_tuple = ()
rslt = {}
for rec in qry_dta:
org_id = rec['org_id']
service_id = rec['service_id']
tags = rec['tags']
org_srvc_tuple = org_srvc_tuple + ((org_id, service_id), )
if org_id not in rslt.keys():
rslt[org_id] = {}
if service_id not in rslt[org_id].keys():
rslt[org_id][service_id] = {}
rslt[org_id][service_id]["tags"] = tags
qry_part = " AND (S.org_id, S.service_id) IN " + \
str(org_srvc_tuple).replace(',)', ')')
qry_part_where = " AND (org_id, service_id) IN " + \
str(org_srvc_tuple).replace(',)', ')')
print("qry_part::", qry_part)
sort_by = sort_by.replace("org_id", "M.org_id")
if org_srvc_tuple:
services = self.repo.execute(
"SELECT DISTINCT M.row_id, M.service_row_id, M.org_id, M.service_id, M.display_name, M.description, M.url, M.json, M.model_ipfs_hash, M.encoding, M.`type`,"
" M.mpe_address,M.service_rating, M.ranking, M.contributors, M.short_description,"
"O.organization_name,O.org_assets_url FROM service_endpoint E, service_metadata M, service S "
", organization O WHERE O.org_id = S.org_id AND S.row_id = M.service_row_id AND "
"S.row_id = E.service_row_id " + qry_part +
"ORDER BY E.is_available DESC, " + sort_by + " " +
order_by)
services_media = self.repo.execute(
"select org_id ,service_id,file_type ,asset_type,url,alt_text ,`order`,row_id from service_media where asset_type = 'hero_image' "
+ qry_part_where)
else:
services = []
services_media = []
obj_utils = Utils()
obj_utils.clean(services)
available_service = self._get_is_available_service()
for rec in services:
self._convert_service_metadata_str_to_json(rec)
org_id = rec["org_id"]
service_id = rec["service_id"]
tags = []
is_available = 0
if rslt.get(org_id, {}).get(service_id,
{}).get("tags", None) is not None:
tags = rslt[org_id][service_id]["tags"].split(",")
if (org_id, service_id) in available_service:
is_available = 1
asset_media = []
if len(services_media) > 0:
asset_media = [
x for x in services_media
if x['service_id'] == service_id
]
if len(asset_media) > 0:
asset_media = asset_media[0]
rec.update({"tags": tags})
rec.update({"is_available": is_available})
rec.update({"media": asset_media})
return services
except Exception as err:
raise err
def _search_response_format(self, tc, offset, limit, rslt):
try:
return {
"total_count": tc,
"offset": offset,
"limit": limit,
"result": rslt
}
except Exception as err:
raise err
def get_all_srvcs(self, qry_param):
try:
fields_mapping = {
"display_name": "display_name",
"tag_name": "tag_name",
"org_id": "org_id"
}
s = qry_param.get('s', 'all')
q = qry_param.get('q', '')
offset = qry_param.get('offset', GET_ALL_SERVICE_OFFSET_LIMIT)
limit = qry_param.get('limit', GET_ALL_SERVICE_LIMIT)
sort_by = fields_mapping.get(qry_param.get('sort_by', None),
"ranking")
order_by = qry_param.get('order_by', 'desc')
if order_by.lower() != "desc":
order_by = "asc"
sub_qry = self._prepare_subquery(s=s, q=q, fm=fields_mapping)
print("get_all_srvcs::sub_qry: ", sub_qry)
filter_qry = ""
if qry_param.get("filters", None) is not None:
filter_query, values = self._filters_to_query(
qry_param.get("filters"))
print("get_all_srvcs::filter_query: ", filter_query,
"|values: ", values)
total_count = self._get_total_count(sub_qry=sub_qry,
filter_query=filter_query,
values=values)
if total_count == 0:
return self._search_response_format(total_count, offset, limit,
[])
q_dta = self._search_query_data(sub_qry=sub_qry,
sort_by=sort_by,
order_by=order_by,
offset=offset,
limit=limit,
filter_query=filter_query,
values=values)
return self._search_response_format(total_count, offset, limit,
q_dta)
except Exception as e:
print(repr(e))
raise e
def get_group_info(self, org_id, service_id):
try:
group_data = self.repo.execute(
"SELECT G.*, E.* FROM service_group G INNER JOIN service_endpoint E ON G.group_id = E.group_id AND G.service_row_id = E.service_row_id WHERE "
"G.org_id = %s AND G.service_id = %s ", [org_id, service_id])
self.obj_utils.clean(group_data)
groups = {}
for rec in group_data:
group_id = rec['group_id']
if group_id not in groups.keys():
groups = {
group_id: {
"group_id":
rec['group_id'],
"group_name":
rec['group_name'],
"pricing":
json.loads(rec['pricing']),
"endpoints": [],
"free_calls":
rec.get("free_calls", 0),
"free_call_signer_address":
rec.get("free_call_signer_address", "")
}
}
groups[group_id]['endpoints'].append({
"endpoint":
rec['endpoint'],
"is_available":
rec['is_available'],
"last_check_timestamp":
rec["last_check_timestamp"]
})
return list(groups.values())
except Exception as e:
print(repr(e))
raise e
def get_service_media(self, org_id, service_id):
try:
query = """select `row_id`,url,`order`,file_type,asset_type,alt_text from service_media
where service_id = %s and org_id = %s """
query_response = self.repo.execute(query, [service_id, org_id])
media = []
if len(query_response) == 0:
return []
for response_item in query_response:
media.append({
"row_id": response_item['row_id'],
"url": response_item['url'],
"file_type": response_item['file_type'],
"order": response_item['order'],
"alt_text": response_item['alt_text']
})
return media
except Exception as e:
raise e
def _get_is_available_service(self):
try:
available_service = []
srvc_st_dta = self.repo.execute(
"SELECT DISTINCT org_id, service_id FROM service_endpoint WHERE is_available = 1"
)
for rec in srvc_st_dta:
available_service.append((rec['org_id'], rec['service_id']), )
return available_service
except Exception as err:
print(repr(err))
raise err
def _filter_condition_to_query(self, filter_condition):
value = []
if filter_condition.attr in ["org_id", "service_id"]:
filter_condition.attr = "M." + filter_condition.attr
if filter_condition.operator == "=":
value = filter_condition.value
return '%s %s"%s"' % (filter_condition.attr,
filter_condition.operator, "%s"), value
if filter_condition.operator == "IN":
value = filter_condition.value
return '%s %s %s' % (filter_condition.attr,
filter_condition.operator, "(" +
(("%s,") * len(value))[:-1] + ")"), value
if filter_condition.operator == "BETWEEN":
value = filter_condition.value
return '%s %s %s AND %s' % (filter_condition.attr,
filter_condition.operator, "%s",
"%s"), value
def _filters_to_query(self, filter_json):
query = ""
filters = []
values = []
for filter in filter_json:
filters.append(Filter(filter))
for filter in filters:
query += "("
for filter_condition in filter.get_filter().get("filter"):
sub_query, value = self._filter_condition_to_query(
filter_condition)
values += value
query = query + "(" + sub_query + ") AND "
if query.endswith(" AND "):
query = query[:-5]
query += ") OR "
if query.endswith(" OR "):
query = query[:-4]
return query, values
def get_filter_attribute(self, attribute):
""" Method to fetch filter metadata based on attribute."""
try:
filter_attribute = {"attribute": attribute, "values": []}
if attribute == "tag_name":
filter_data = self.repo.execute(
"SELECT DISTINCT tag_name AS 'key', tag_name AS 'value' FROM service_tags T, service S "
"WHERE S.row_id = T.service_row_id AND S.is_curated = 1")
elif attribute == "display_name":
filter_data = self.repo.execute(
"SELECT DISTINCT S.service_id AS 'key',display_name AS 'value' FROM service_metadata M, service S "
"WHERE S.row_id = M.service_row_id AND S.is_curated = 1")
elif attribute == "org_id":
filter_data = self.repo.execute(
"SELECT DISTINCT O.org_id AS 'key' ,O.organization_name AS 'value' from organization O, service S "
"WHERE S.org_id = O.org_id AND S.is_curated = 1")
else:
return filter_attribute
for rec in filter_data:
filter_attribute["values"].append(rec)
return filter_attribute
except Exception as e:
print(repr(e))
raise e
def get_all_group_for_org_id(self, org_id):
""" Method to get all group data for given org_id. This includes group data at org level"""
try:
groups_data = self.repo.execute(
"SELECT group_id, group_name, payment FROM org_group WHERE org_id = %s",
[org_id])
[
group_record.update(
{'payment': json.loads(group_record['payment'])})
for group_record in groups_data
]
groups = {"org_id": org_id, "groups": groups_data}
return groups
except Exception as e:
print(repr(e))
raise e
def get_group_details_for_org_id(self, org_id, group_id):
""" Method to get group data for given org_id and group_id. This includes group data at org level"""
group_data = self.repo.execute(
"SELECT group_id, group_name, payment , org_id FROM org_group WHERE org_id = %s and group_id = %s",
[org_id, group_id])
[
group_record.update(
{'payment': json.loads(group_record['payment'])})
for group_record in group_data
]
return {"groups": group_data}
def get_service_data_by_org_id_and_service_id(self, org_id, service_id):
try:
""" Method to get all service data for given org_id and service_id"""
tags = []
org_groups_dict = {}
basic_service_data = self.repo.execute(
"SELECT M.row_id, M.service_row_id, M.org_id, M.service_id, M.display_name, M.description, M.url, M.json, M.model_ipfs_hash, M.encoding, M.`type`,"
" M.mpe_address,M.service_rating, M.ranking, M.contributors, M.short_description,"
" S.*, O.org_id, O.organization_name, O.owner_address, O.org_metadata_uri, O.org_email, "
"O.org_assets_url, O.description as org_description, O.contacts "
"FROM service_metadata M, service S, organization O "
"WHERE O.org_id = S.org_id AND S.row_id = M.service_row_id AND S.org_id = %s "
"AND S.service_id = %s AND S.is_curated = 1",
[org_id, service_id])
if len(basic_service_data) == 0:
return []
self.obj_utils.clean(basic_service_data)
org_group_data = self.repo.execute(
"SELECT * FROM org_group WHERE org_id = %s", [org_id])
self.obj_utils.clean(org_group_data)
service_group_data = self.get_group_info(org_id=org_id,
service_id=service_id)
tags = self.repo.execute(
"SELECT tag_name FROM service_tags WHERE org_id = %s AND service_id = %s",
[org_id, service_id])
media = self.get_service_media(org_id=org_id,
service_id=service_id)
result = basic_service_data[0]
self._convert_service_metadata_str_to_json(result)
for rec in org_group_data:
org_groups_dict[rec['group_id']] = {
"payment": json.loads(rec["payment"])
}
is_available = 0
# Hard Coded Free calls in group data
for rec in service_group_data:
rec["free_calls"] = rec.get("free_calls", 0)
if is_available == 0:
endpoints = rec['endpoints']
for endpoint in endpoints:
is_available = endpoint['is_available']
if is_available == 1:
break
rec.update(org_groups_dict.get(rec['group_id'], {}))
result.update({
"is_available": is_available,
"groups": service_group_data,
"tags": tags,
"media": media
})
return result
except Exception as e:
print(repr(e))
raise e
def get_org_details(self, org_id):
""" Method to get org details for given org_id. """
try:
org_details = self.repo.execute(
"SELECT * from organization o, (select org_id, count(*) as service_count "
"from service where org_id = %s) s where o.org_id = %s and o.org_id = s.org_id",
[org_id, org_id])
obj_utils = Utils()
obj_utils.clean(org_details)
if len(org_details) > 0:
members = self._get_all_members(org_id)
org_details[0]["members"] = members
return org_details
except Exception as e:
print(repr(e))
raise e
def update_service_rating(self, org_id, service_id):
"""
Method updates service_rating and total_user_rated when user rating is changed for given service_id
and org_id.
"""
try:
update_service_metadata = self.repo.execute(
"UPDATE service_metadata A INNER JOIN "
"(SELECT U.org_id, U.service_id, AVG(U.rating) AS service_rating, count(*) AS total_users_rated "
"FROM user_service_vote AS U WHERE U.rating IS NOT NULL GROUP BY U.service_id, U.org_id ) AS B "
"ON A.org_id=B.org_id AND A.service_id=B.service_id SET A.service_rating "
"= CONCAT('{\"rating\":', B.service_rating, ' , \"total_users_rated\":', B.total_users_rated, '}') "
"WHERE A.org_id = %s AND A.service_id = %s ",
[org_id, service_id])
return "success"
except Exception as e:
print(repr(e))
raise e
def curate_service(self, org_id, service_id, curated):
service_repo = ServiceRepository(self.repo)
if str(curated).lower() == "true":
service_repo.curate_service(org_id, service_id, 1)
elif str(curated).lower() == "false":
service_repo.curate_service(org_id, service_id, 0)
else:
Exception("Invalid curation flag")
def get_service_media(self, org_id, service_id):
try:
query = """select `row_id`,url,`order`,file_type,asset_type,alt_text from service_media
where service_id = %s and org_id = %s """
query_response = self.repo.execute(query, [service_id, org_id])
media = []
if len(query_response) == 0:
return media
for response_item in query_response:
media.append({
"row_id": response_item['row_id'],
"url": response_item['url'],
"file_type": response_item['file_type'],
"order": response_item['order'],
"alt_text": response_item['alt_text'],
"asset_type": response_item['asset_type']
})
return media
except Exception as e:
logger.error(
f'Error in getting service media data for org_id = {org_id} service_id = {service_id}'
)
raise e
def _search_query_data(self, sub_qry, sort_by, order_by, offset, limit,
filter_query, values):
try:
if filter_query != "":
filter_query = " AND " + filter_query
srch_qry = "SELECT * FROM service A, (SELECT M.org_id, M.service_id, group_concat(T.tag_name) AS tags FROM " \
"service_metadata M LEFT JOIN service_tags T ON M.service_row_id = T.service_row_id " \
"LEFT JOIN service_endpoint E ON M.service_row_id = E.service_row_id WHERE (" \
+ sub_qry.replace('%', '%%') + ")" + filter_query + \
" GROUP BY M.org_id, M.service_id ORDER BY E.is_available DESC, " + sort_by + " " + order_by + \
" ) B WHERE A.service_id = B.service_id AND A.org_id=B.org_id AND A.is_curated= 1 LIMIT %s , %s"
qry_dta = self.repo.execute(srch_qry, values +
[int(offset), int(limit)])
org_srvc_tuple = ()
rslt = {}
for rec in qry_dta:
org_id = rec['org_id']
service_id = rec['service_id']
tags = rec['tags']
org_srvc_tuple = org_srvc_tuple + ((org_id, service_id), )
if org_id not in rslt.keys():
rslt[org_id] = {}
if service_id not in rslt[org_id].keys():
rslt[org_id][service_id] = {}
rslt[org_id][service_id]["tags"] = tags
qry_part = " AND (S.org_id, S.service_id) IN " + \
str(org_srvc_tuple).replace(',)', ')')
qry_part_where = " AND (org_id, service_id) IN " + \
str(org_srvc_tuple).replace(',)', ')')
print("qry_part::", qry_part)
sort_by = sort_by.replace("org_id", "M.org_id")
if org_srvc_tuple:
services = self.repo.execute(
"SELECT DISTINCT M.row_id, M.service_row_id, M.org_id, M.service_id, M.display_name, M.description, M.url, M.json, M.model_ipfs_hash, M.encoding, M.`type`,"
" M.mpe_address,M.service_rating, M.ranking, M.contributors, M.short_description,"
"O.organization_name,O.org_assets_url FROM service_endpoint E, service_metadata M, service S "
", organization O WHERE O.org_id = S.org_id AND S.row_id = M.service_row_id AND "
"S.row_id = E.service_row_id " + qry_part +
"ORDER BY E.is_available DESC, " + sort_by + " " +
order_by)
services_media = self.repo.execute(
"select org_id ,service_id,file_type ,asset_type,url,alt_text ,`order`,row_id from service_media where asset_type = 'hero_image' "
+ qry_part_where)
else:
services = []
services_media = []
obj_utils = Utils()
obj_utils.clean(services)
available_service = self._get_is_available_service()
for rec in services:
self._convert_service_metadata_str_to_json(rec)
org_id = rec["org_id"]
service_id = rec["service_id"]
tags = []
is_available = 0
if rslt.get(org_id, {}).get(service_id,
{}).get("tags", None) is not None:
tags = rslt[org_id][service_id]["tags"].split(",")
if (org_id, service_id) in available_service:
is_available = 1
asset_media = []
if len(services_media) > 0:
asset_media = [
x for x in services_media
if x['service_id'] == service_id
]
if len(asset_media) > 0:
asset_media = asset_media[0]
rec.update({"tags": tags})
rec.update({"is_available": is_available})
rec.update({"media": asset_media})
return services
except Exception as err:
raise err
class Signer:
def __init__(self, obj_repo, net_id):
self.repo = obj_repo
self.net_id = net_id
self.lambda_client = boto3.client('lambda')
self.obj_utils = Utils()
def _free_calls_allowed(self, username, org_id, service_id):
"""
Method to check free calls exists for given user or not.
Call monitoring service to get the details
"""
try:
lambda_payload = {"httpMethod": "GET",
"queryStringParameters": {"organization_id": org_id, "service_id": service_id,
"username": username}}
response = self.lambda_client.invoke(FunctionName=GET_FREE_CALLS_METERING_ARN, InvocationType='RequestResponse',
Payload=json.dumps(lambda_payload))
response_body_raw = json.loads(
response.get('Payload').read())['body']
response_body = json.loads(response_body_raw)
free_calls_allowed = response_body["free_calls_allowed"]
total_calls_made = response_body["total_calls_made"]
is_free_calls_allowed = True if (
(free_calls_allowed - total_calls_made) > 0) else False
return is_free_calls_allowed
except Exception as e:
print(repr(e))
raise e
def signature_for_free_call(self, user_data, org_id, service_id):
"""
Method to generate signature for free call.
"""
try:
username = user_data['authorizer']['claims']['email']
if self._free_calls_allowed(username=username, org_id=org_id, service_id=service_id):
current_block_no = self.obj_utils.get_current_block_no(
ws_provider=NETWORKS[self.net_id]['ws_provider'])
provider = Web3.HTTPProvider(
NETWORKS[self.net_id]['http_provider'])
w3 = Web3(provider)
message = web3.Web3.soliditySha3(["string", "string", "string", "string", "uint256"],
[PREFIX_FREE_CALL, username, org_id, service_id, current_block_no])
if not config['private_key'].startswith("0x"):
config['private_key'] = "0x" + config['private_key']
signature = bytes(w3.eth.account.signHash(
defunct_hash_message(message), config['private_key']).signature)
signature = signature.hex()
if not signature.startswith("0x"):
signature = "0x" + signature
return {"snet-free-call-user-id": username, "snet-payment-channel-signature-bin": signature,
"snet-current-block-number": current_block_no, "snet-payment-type": "free-call"}
else:
raise Exception(
"Free calls expired for username %s.", username)
except Exception as e:
print(repr(e))
raise e
def _get_user_address(self, username):
try:
wallet_address_data = self.repo.execute("SELECT address FROM wallet WHERE username = %s AND status = 1 "
"LIMIT 1", [username])
if len(wallet_address_data) == 1:
return wallet_address_data[0]['address']
raise Exception(
"Unable to find wallet address for username %s", username)
except Exception as e:
print(repr(e))
raise e
def _get_service_metadata(self, org_id, service_id):
"""
Method to get group details for given org_id and service_id.
"""
try:
result = self.repo.execute(
"SELECT O.*, G.* FROM org_group O, service_group G WHERE O.org_id = G.org_id AND G.group_id = "
"O.group_id AND G.service_id = %s AND G.org_id = %s AND G.service_row_id IN (SELECT row_id FROM service "
"WHERE is_curated = 1 ) LIMIT 1", [org_id, service_id])
if len(result) == 1:
metadata = result[0]
payment = json.loads(metadata["payment"])
pricing = json.loads(metadata["pricing"])
metadata.update(payment)
metadata["pricing"] = pricing
return metadata
else:
raise Exception(
"Unable to find service for service_id %s", service_id)
except Exception as e:
print(repr(e))
raise e
def _get_channel_id(self, sender_address, recipient_address, group_id, signer_address):
"""
Method to fetch channel id from mpe_channel(RDS).
"""
try:
channel_data = self.repo.execute(
"SELECT channel_id FROM mpe_channel WHERE sender = %s AND recipient = %s AND "
" groupId = %s AND signer = %s LIMIT 1", [sender_address, recipient_address,
group_id, signer_address])
if len(channel_data) == 1:
return channel_data[0]["channel_id"]
raise Exception("Unable to find channels.")
except Exception as e:
print(repr(e))
raise e
def signature_for_regular_call(self, user_data, org_id, service_id):
"""
Method to generate signature for regular call.
"""
try:
username = user_data['authorizer']['claims']['email']
user_address = self._get_user_address(username=username)
metadata = self._get_service_metadata(
org_id=org_id, service_id=service_id)
recipient_address = metadata['payment']['payment_address']
channel_id = self._get_channel_id(sender_address=user_address, recipient_address=recipient_address,
group_id=metadata['group_id'], signer_address=config["signer_address"])
object_service_client = ServiceClient(
config=config, metadata=metadata, options=dict())
return object_service_client.get_service_call_metadata(channel_id=channel_id)
except Exception as e:
print(repr(e))
raise Exception(
"Unable to sign regular call for username %s", username)
class User:
def __init__(self, obj_repo):
self.repo = obj_repo
self.obj_utils = Utils()
self.ssm_client = boto3.client('ssm', region_name="us-east-1")
def _set_user_data(self, user_data):
""" Method to set user information. """
try:
claims = user_data['authorizer']['claims']
email_verified = claims['email_verified']
status = 0
if email_verified:
status = 1
else:
raise Exception("Email verification is pending.")
q_dta = [
claims['email'], user_data['accountId'], claims['nickname'],
claims['email'], status, status, user_data['requestId'],
user_data['requestTimeEpoch'],
dt.utcnow(),
dt.utcnow()
]
set_usr_dta = self.repo.execute(
"INSERT INTO user (username, account_id, name, email, email_verified, status, request_id, "
"request_time_epoch, row_created, row_updated) "
"VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)", q_dta)
if len(set_usr_dta) > 0:
return "success"
else:
return "User already exist"
except Exception as e:
print(repr(e))
raise e
def get_wallet_details(self, user_data):
""" Method to get wallet details for a given username. """
try:
username = user_data['authorizer']['claims']['email']
search_data = self.repo.execute(
"SELECT * FROM wallet WHERE username = %s", username)
self.obj_utils.clean(search_data)
return search_data
except Exception as e:
print(repr(e))
raise e
# def _link_wallet(self, username):
# """ Method to assign wallet address to a user. """
# try:
# return self.repo.execute("UPDATE wallet SET username = %s WHERE username IS NULL AND status = 1 LIMIT 1", username)
# except Exception as e:
# print(repr(e))
# raise e
def _fetch_private_key_from_ssm(self, address):
try:
store = self.ssm_client.get_parameter(Name=PATH_PREFIX +
str(address),
WithDecryption=True)
return store['Parameter']['Value']
except Exception as e:
print(repr(e))
raise Exception("Error fetching value from parameter store.")
def user_signup(self, user_data):
""" Method to assign pre-seeded wallet to user.
This is one time process.
"""
try:
username = user_data['authorizer']['claims']['email']
set_user_data = self._set_user_data(user_data)
print(set_user_data)
return set_user_data
except Exception as e:
self.repo.rollback_transaction()
print(repr(e))
raise e
def del_user_data(self, user_data):
""" Method to delete user data and wallet address.
Deregister User.
"""
try:
username = user_data['authorizer']['claims']['email']
self.repo.begin_transaction()
del_user = self.repo.execute(
"DELETE FROM user WHERE username = %s ", [username])
updt_wallet = self.repo.execute(
"UPDATE wallet SET status=0, username=NULL WHERE username = %s ",
[username])
self.repo.commit_transaction()
return []
except Exception as e:
self.repo.rollback_transaction()
print(repr(e))
raise e
def get_user_profile(self, user_data):
'''
Method to fetch user profile data.
'''
try:
username = user_data['authorizer']['claims']['email']
result = self.repo.execute(
"SELECT * FROM user WHERE username = %s", [username])
self.obj_utils.clean(result)
return {"success": "success", "data": result}
except Exception as e:
print(repr(e))
raise e
def update_user_profile(self, email_alerts, is_terms_accepted, user_data):
'''
Method to update user profile data.
'''
try:
username = user_data['authorizer']['claims']['email']
result = self.repo.execute(
"UPDATE user SET email_alerts = %s, is_terms_accepted = %s WHERE username = %s",
[
int(email_alerts == True),
int(is_terms_accepted == True), username
])
return {"success": "success", "data": []}
except Exception as e:
print(repr(e))
raise e
def validate_and_set_user_feedback(self, feedback_data, user_data):
"""
Method to validate and set user feedback data.
"""
schema = Schema([{
'org_id': And(str),
'service_id': And(str),
'user_rating': And(str),
'comment': And(str)
}])
try:
feedback_data = schema.validate([feedback_data])
feedback_recorded = self._set_user_feedback(feedback_data[0],
user_data=user_data)
if feedback_recorded:
return []
return None
except Exception as err:
print("Invalid Input ", err)
return None
def get_user_feedback(self, user_data, org_id, service_id):
"""
Method to get user feedback data.
"""
try:
user_rating_dict = {}
username = user_data['authorizer']['claims']['email']
query_part = ""
query_part_values = []
if org_id is not None:
query_part = "AND org_id = %s "
query_part_values.append(org_id)
if service_id is not None:
query_part += "AND service_id = %s "
query_part_values.append(service_id)
rating_query = "SELECT * FROM user_service_vote WHERE username = %s " + query_part
rating = self.repo.execute(rating_query,
[username] + query_part_values)
self.obj_utils.clean(rating)
feedback_query = "SELECT * FROM user_service_feedback WHERE username = %s " + query_part
feedback = self.repo.execute(feedback_query,
[username] + query_part_values)
self.obj_utils.clean(feedback)
for record in feedback:
org_id = record['org_id']
service_id = record['service_id']
if org_id not in user_rating_dict.keys():
user_rating_dict[org_id] = {}
if service_id not in user_rating_dict.keys():
user_rating_dict[org_id][service_id] = {}
user_rating_dict[org_id][service_id]['comment'] = []
user_rating_dict[org_id][service_id]['comment'].append(
record['comment'])
for record in rating:
org_id = record['org_id']
service_id = record['service_id']
record.update({
'comment':
user_rating_dict.get(org_id,
{}).get(service_id,
{}).get("comment", [])
})
return rating
except Exception as e:
print(repr(e))
raise e
def _set_user_feedback(self, feedback_data, user_data):
"""
Method to set user rating and feedback.
"""
try:
user_rating = str(feedback_data['user_rating'])
if float(user_rating) > 5.0 or float(user_rating) < 1.0:
raise Exception(
"Invalid Rating. Provided user rating should be between 1.0 and 5.0 ."
)
curr_dt = dt.utcnow()
username = user_data['authorizer']['claims']['email']
org_id = feedback_data['org_id']
service_id = feedback_data['service_id']
comment = feedback_data['comment']
self.repo.begin_transaction()
set_rating = "INSERT INTO user_service_vote (username, org_id, service_id, rating, row_updated, row_created) " \
"VALUES (%s, %s, %s, %s, %s, %s) " \
"ON DUPLICATE KEY UPDATE rating = %s, row_updated = %s"
set_rating_params = [
username, org_id, service_id, user_rating, curr_dt, curr_dt,
user_rating, curr_dt
]
self.repo.execute(set_rating, set_rating_params)
set_feedback = "INSERT INTO user_service_feedback (username, org_id, service_id, comment, row_updated, row_created)" \
"VALUES (%s, %s, %s, %s, %s, %s)"
set_feedback_params = [
username, org_id, service_id, comment, curr_dt, curr_dt
]
self.repo.execute(set_feedback, set_feedback_params)
self._update_service_rating(org_id=org_id, service_id=service_id)
self.repo.commit_transaction()
return True
except Exception as e:
self.repo.rollback_transaction()
print(repr(e))
raise e
def _get_user_address_from_username(self, username):
"""
Method to get user_address for a given username
"""
try:
wallet_details = self.repo.execute(
"SELECT * FROM wallet WHERE username = %s ", [username])
if len(wallet_details) > 0:
return wallet_details[0].get("address", None)
else:
raise Exception("Wallet address does not exist for this user.")
except Exception as e:
print(repr(e))
raise e
def _update_service_rating(self, org_id, service_id):
"""
Method updates service_rating and total_user_rated when user rating is changed for given service_id
and org_id.
"""
try:
update_service_metadata = self.repo.execute(
"UPDATE service_metadata A INNER JOIN (SELECT U.org_id, U.service_id, AVG(U.rating) AS service_rating, "
"count(*) AS total_users_rated FROM user_service_vote AS U WHERE U.rating IS NOT NULL GROUP BY "
"U.service_id, U.org_id ) AS B ON A.org_id=B.org_id AND A.service_id=B.service_id SET A.service_rating "
"= CONCAT('{\"rating\":', B.service_rating, ' , \"total_users_rated\":', B.total_users_rated, '}') "
"WHERE A.org_id = %s AND A.service_id = %s ",
[org_id, service_id])
except Exception as e:
print(repr(e))
raise e
def set_wallet_details(self,
username,
address,
is_default,
status=1,
type=DEFAULT_WALLET_TYPE,
created_by=CREATED_BY):
try:
self.repo.execute(
"INSERT INTO wallet (username, address, type, is_default, status, created_by, row_updated, row_created) "
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s)", [
username, address, type, is_default, status, created_by,
dt.utcnow(),
dt.utcnow()
])
except Exception as e:
print(repr(e))
raise e
def register_wallet(self, user_data, wallet_data):
try:
is_default = wallet_data["is_default"]
username = user_data['authorizer']['claims']['email']
address = wallet_data['address']
print(is_default)
if is_default == 1:
self.repo.begin_transaction()
self.set_wallet_details(username=username,
address=address,
is_default=is_default)
self.repo.execute(
"UPDATE wallet SET is_default = 0 WHERE username = %s AND address != %s",
[username, address])
self.repo.commit_transaction()
# need to be cleaned
else:
self.set_wallet_details(username=username,
address=address,
is_default=is_default)
return []
except Exception as e:
if is_default is not None and is_default == 1:
self.repo.rollback_transaction()
print(repr(e))
raise e
def login_valid(email, password):
user = Database.find_one_by('admins', {"email": email})
if not Utils.unencrypt_pass(password=password, encrypt_password=user['password']):
return False
return True
def __init__(self, email, password):
self.email = email
self.password = Utils.encrypt_pass(password)
from aws_xray_sdk.core import patch_all
from common.logger import get_logger
from common.repository import Repository
from common.utils import Utils, handle_exception_with_slack_notification
from dapp_user.config import NETWORKS, NETWORK_ID, SLACK_HOOK
from dapp_user.constant import SourceDApp
from dapp_user.domain.services.user_service import UserService
from dapp_user.user import User
patch_all()
db = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS)
logger = get_logger(__name__)
obj_util = Utils()
@handle_exception_with_slack_notification(SLACK_HOOK=SLACK_HOOK, NETWORK_ID=NETWORK_ID, logger=logger)
def request_handler(event, context):
print(event)
if 'path' not in event:
return get_response(400, "Bad Request")
payload_dict = None
path = event['path'].lower()
path = re.sub(r"^(\/dapp-user)", "", path)
usr_obj = User(obj_repo=db)
response_data = None
if event['httpMethod'] == 'POST':
payload_dict = json.loads(event['body'])
def is_login_valid(cls, email, password):
user = cls.find_by_email(email)
for users in user:
if not Utils.check_hashed_password(password, users.password):
raise UserErrors.IncorrectPasswordError('The email id or password is incorrect')
return True
def get_profit_grow(self):
return Utils.read_data(self.profit_grow_file)
class MonitorServiceCertificate(MonitorService):
def __init__(self, repo):
self.repo = repo
self.route = "/encoding"
self.obj_util = Utils()
# regex helps to check url is localhost or external address.
self.rex_for_pb_ip = "^(http://)*(https://)*127.0.0.1|^(http://)*(https://)*localhost|^(http://)*" \
"(https://)*192.|^(http://)*(https://)*172.|^(http://)*(https://)*10."
def notify_service_contributors_for_certificate_expiration(self):
service_endpoint_data = self._get_service_endpoint_data(limit=None)
for record in service_endpoint_data:
org_id = record["org_id"]
service_id = record["service_id"]
endpoint = record["endpoint"]
expiration_date = self._get_certification_expiration_date_for_given_service(
endpoint=endpoint)
days_left_for_expiration = (expiration_date - dt.utcnow()).days
if days_left_for_expiration < CERTIFICATION_EXPIRATION_THRESHOLD:
self._send_notification_for_certificate_expiration(
org_id=org_id,
service_id=service_id,
endpoint=endpoint,
days_left_for_expiration=days_left_for_expiration)
def _send_notification_for_certificate_expiration(
self, org_id, service_id, endpoint, days_left_for_expiration):
certificate_expiration_notification_subject = \
self._get_certificate_expiration_email_notification_subject(org_id=org_id, service_id=service_id,
endpoint=endpoint)
certificate_expiration_notification_message = \
self._get_certificate_expiration_email_notification_message(
org_id=org_id, service_id=service_id, endpoint=endpoint,
days_left_for_expiration=days_left_for_expiration)
recipients = self._get_service_provider_email(org_id=org_id,
service_id=service_id)
self._send_email_notification(
certificate_expiration_notification_subject=
certificate_expiration_notification_subject,
certificate_expiration_notification_message=
certificate_expiration_notification_message,
recipients=recipients)
slack_message = self._get_certificate_expiration_slack_notification_message(
org_id=org_id,
service_id=service_id,
endpoint=endpoint,
days_left_for_expiration=days_left_for_expiration)
self._send_slack_notification(slack_message=slack_message)
def _get_certification_expiration_date_for_given_service(self, endpoint):
endpoint = endpoint.lstrip()
if self._valid_url(url=endpoint):
if self._is_https_endpoint(endpoint):
endpoint = self.obj_util.remove_http_https_prefix(url=endpoint)
hostname = endpoint.split(":")[0]
port = endpoint.split(":")[1]
context = ssl.create_default_context()
with socket.create_connection((hostname, port)) as sock:
with context.wrap_socket(
sock, server_hostname=hostname) as ssock:
data = json.dumps(ssock.getpeercert())
expiration_date = json.loads(data)["notAfter"]
return dt.strptime(expiration_date,
"%b %d %H:%M:%S %Y %Z")
@staticmethod
def _get_certificate_expiration_email_notification_subject(
org_id, service_id, endpoint):
return CERT_EXP_EMAIL_NOTIFICATION_SUBJ % (service_id, NETWORK_NAME)
@staticmethod
def _get_certificate_expiration_email_notification_message(
org_id, service_id, endpoint, days_left_for_expiration):
return CERT_EXP_EMAIL_NOTIFICATION_MSG % (
service_id, org_id, NETWORK_NAME, days_left_for_expiration,
endpoint)
@staticmethod
def _get_certificate_expiration_slack_notification_message(
org_id, service_id, endpoint, days_left_for_expiration):
return CERT_EXP_SLACK_NOTIFICATION_MSG % (
service_id, org_id, NETWORK_NAME, days_left_for_expiration,
endpoint)
def getFileName(self):
return Utils.dateTimeString() + "-detail.dxf"
def is_login_valid(cls, email: str, password: str) -> bool:
user = cls.find_by_email(email)
if not Utils.check_hashed_password(password ,user.password):
raise UserErrors.IncorrectPasswordError(f"Incorrect password for the user {email}")
return True
def send_slack_message(self, slack_msg):
Utils().report_slack(slack_msg, APPROVAL_SLACK_HOOK)
def __init__(self, obj_repo):
self.repo = obj_repo
self.obj_utils = Utils()
self.ssm_client = boto3.client('ssm', region_name="us-east-1")
def login_valid(email, password):
user = Database.find_one_by('participants', {'email': email})
if not Utils.unencrypt_pass(password=password,
encrypt_password=user['password']):
return False
return True
def GetPageCount(self):
strURI = Product.BaseProductUri + "/pdf/" + self.FileName + "/pages"
signedURI = Utils.Sign(strURI);
responseStream = Utils.processCommand(signedURI, "GET", "");
_json = json.loads(responseStream)
return len(_json)
def __init__(self, obj_repo):
self.repo = obj_repo
self.obj_utils = Utils()
def main(screen):
pygame.mouse.set_visible(0)
# Load image
background = pygame.image.load("resources\image\TileSet\\background.png").convert()
img = Utils.load_image('explosion1.gif')
coins_image = pygame.image.load('resources\image\TileSet\Coins.png')
Explosion.images = [img, pygame.transform.flip(img, 1, 1)]
# Load font
coin_font = pygame.font.Font("resources\Fonts\Number.ttf", 32)
# Load the sound effects
boom_sound = Utils.load_sound('boom.wav')
shoot_sound = Utils.load_sound('1.wav')
if pygame.mixer:
music = 'resources/data/1037.wav'
pygame.mixer.music.load(music)
pygame.mixer.music.play(-1)
# Initialize Game Groups
aliens = pygame.sprite.Group()
bombs = pygame.sprite.Group()
monsterbombs = pygame.sprite.Group()
render_group = pygame.sprite.OrderedUpdates()
creeps = pygame.sprite.Group()
items = pygame.sprite.Group()
# Assign default groups to each sprite class
# Ground.containers = all_group
# Player.containers = all_group
# BasicCreep.containers = all_group, creeps
coreItem.containers = render_group
Player.containers = render_group
Player.screen = screen
BasicCreep.containers = creeps, render_group
Bullet.containers = bombs, render_group
MonsterBullet.containers = monsterbombs,render_group
Explosion.containers = render_group
Live_bar.containers = render_group
Energy_bar.containers = render_group
Power_bar.containers = render_group
# Create Some Starting Values
# Global score
clock = pygame.time.Clock()
#ground = Ground()
player = Player('nhan vat 1', 'character1', 1, 1, 350, screen)
#*************************************
# Init creeps
#*************************************
BasicCreep.screen = screen
Player.screen = screen
#*************************************
# Init item
#*************************************
money_item = money(360, 200, "money")
items.add(money_item)
money_item = money(400, 200, "money")
items.add(money_item)
money_item = money(440, 200, "money")
items.add(money_item)
money_item = money(480, 200, "money")
items.add(money_item)
money_item = money(520, 200, "money")
items.add(money_item)
money_item = money(360, 80, "money")
items.add(money_item)
money_item = money(400, 80, "money")
items.add(money_item)
money_item = money(440, 80, "money")
items.add(money_item)
money_item = money(480, 80, "money")
items.add(money_item)
money_item = money(520, 80, "money")
items.add(money_item)
money_item = money(680, 40, "money")
items.add(money_item)
money_item = money(720, 40, "money")
items.add(money_item)
money_item = money(760, 40, "money")
items.add(money_item)
money_item = money(800, 40, "money")
items.add(money_item)
money_item = money(840, 40, "money")
items.add(money_item)
money_item = money(1600, 180, "money")
items.add(money_item)
money_item = money(1640, 180, "money")
items.add(money_item)
money_item = money(1680, 180, "money")
items.add(money_item)
money_item = money(1720, 180, "money")
items.add(money_item)
money_item = money(2592, 128, "money")
items.add(money_item)
money_item = money(2624, 128, "money")
items.add(money_item)
money_item = money(2656, 128, "money")
items.add(money_item)
money_item = money(2688, 128, "money")
items.add(money_item)
money_item = money(3744, 384, "money")
items.add(money_item)
money_item = money(3776, 384, "money")
items.add(money_item)
money_item = money(3808, 384, "money")
items.add(money_item)
money_item = money(3840, 384, "money")
items.add(money_item)
money_item = money(4736, 64, "money")
items.add(money_item)
money_item = money(4736, 32, "money")
items.add(money_item)
money_item = money(4768, 64, "money")
items.add(money_item)
money_item = money(4768, 32, "money")
items.add(money_item)
money_item = money(4800, 64, "money")
items.add(money_item)
money_item = money(4800, 32, "money")
items.add(money_item)
money_item = money(4832, 64, "money")
items.add(money_item)
money_item = money(4832, 32, "money")
items.add(money_item)
money_item = money(4864, 64, "money")
items.add(money_item)
money_item = money(4896, 32, "money")
items.add(money_item)
money_item = money(4928, 64, "money")
items.add(money_item)
money_item = money(4928, 32, "money")
items.add(money_item)
money_item = money(4960, 64, "money")
items.add(money_item)
money_item = money(4992, 32, "money")
items.add(money_item)
money_item = money(5024, 64, "money")
items.add(money_item)
money_item = money(5024, 32, "money")
items.add(money_item)
money_item = money(5056, 64, "money")
items.add(money_item)
money_item = money(5056, 32, "money")
items.add(money_item)
money_item = money(5088, 64, "money")
items.add(money_item)
money_item = money(5088, 32, "money")
items.add(money_item)
money_item = money(5120, 64, "money")
items.add(money_item)
money_item = money(5120, 32, "money")
items.add(money_item)
money_item = money(5152, 64, "money")
items.add(money_item)
money_item = money(5152, 32, "money")
items.add(money_item)
money_item = money(5184, 64, "money")
items.add(money_item)
money_item = money(5184, 32, "money")
items.add(money_item)
money_item = money(5216, 64, "money")
items.add(money_item)
money_item = money(5216, 32, "money")
items.add(money_item)
money_item = money(5248, 64, "money")
items.add(money_item)
money_item = money(5248, 32, "money")
items.add(money_item)
money_item = berry(2890, 100, "berry")
items.add(money_item)
money_item = money(5440, 192, "money")
items.add(money_item)
money_item = money(5472, 192, "money")
items.add(money_item)
money_item = money(5504, 192, "money")
items.add(money_item)
money_item = money(5472, 192, "money")
items.add(money_item)
money_item = money(5792, 160, "money")
items.add(money_item)
money_item = money(5824, 160, "money")
items.add(money_item)
money_item = money(5856, 160, "money")
items.add(money_item)
money_item = money(5888, 160, "money")
items.add(money_item)
money_item = money(6080, 160, "money")
items.add(money_item)
money_item = money(6112, 160, "money")
items.add(money_item)
money_item = money(6144, 160, "money")
items.add(money_item)
CreepManager.create_creep(creeps, 'A', 365, 332, 365, 480, 0, 1)
CreepManager.create_creep(creeps, 'A', 611, 332, 576, 989, 0, 1)
CreepManager.create_creep(creeps, 'A', 874, 332, 576, 989, 1, 1)
CreepManager.create_creep(creeps, 'D', 1472+10, 316-50, 1472+10, 1588, 1, 1)
CreepManager.create_creep(creeps, 'D', 1218+10, 380-50, 1218+10, 1374, 1, 1)
CreepManager.create_creep(creeps, 'B', 1280+20, 508-30, 1280+20, 1374-20, 1, 1)
CreepManager.create_creep(creeps, 'B', 1474+20, 508-30, 1474+20, 1628-50, 1, 1)
CreepManager.create_creep(creeps, 'B', 1664+45, 508-30, 1664+45, 1782-20, 1, 1)
CreepManager.create_creep(creeps, 'A', 2592+45, 442-48, 2592+45, 2876-20, 1, 1)
CreepManager.create_creep(creeps, 'F', 2592+45, 100, 2592+45, 2876-20, 1, 4)
CreepManager.create_creep(creeps, 'B', 3302+45, 442 - 30, 3302+45-20, 3548-20, 1, 2)
CreepManager.create_creep(creeps, 'F', 3312+45, 300, 3302+45-20, 3548-20, 1, 4)
CreepManager.create_creep(creeps, 'F', 3400, 200, 3302+45-20, 3548-20, 0, 3)
CreepManager.create_creep(creeps, 'F', 3390, 70, 3302+45-20, 3548-20, 0, 3)
CreepManager.create_creep(creeps, 'A', 3840+55, 442 - 15, 3840+50, 4000-20-20, 0, 1)
CreepManager.create_creep(creeps, 'A', 4706+55, 362, 4706, 4862-20, 0, 1)
CreepManager.create_creep(creeps, 'C', 5365, 162, 5365, 6000, 0, 4)
CreepManager.create_creep(creeps, 'C', 5365, 62, 5365, 6000, 0, 4)
CreepManager.create_creep(creeps, 'B', 6505, 316, 6505, 6645, 0, 4)
CreepManager.create_creep(creeps, 'A_SPECIAL', 4917, 381, 4907, 5033, 0, 1)
tileset = TileCache("resources/image/TileSet/ImageSheet.png", Constant.TILE_WIDTH, Constant.TILE_HEIGHT).load_tile_table()
invisible_tiles = (((9,14), (9,15), (9, 16),(9, 17)),
((6, 19), (6, 20), (6, 21), (6,22)),
((12, 68), (12, 69), (12, 70), (13, 70), (14, 70)),
((5, 81), (5, 82), (5, 83), (5, 84)),
((7,144), (7, 145), (6, 146), (6, 147)))
""" CREATE LIST OF SPECIAL OBJECTS """
special_tiles = []
for line in invisible_tiles:
for element in line:
special_tile = SpecialObject(tileset, element, (Constant.TILE_WIDTH * element[1], Constant.TILE_HEIGHT * element[0]))
special_tiles.append(special_tile)
camera_left = 0
camera_right = Constant.SCREENRECT.width
hCount = 1
player.typeOfBullet = EBulletType.BASIC
mymonster = monster(7400, 270, "monster")
items.add(mymonster)
player.sound_money = pygame.mixer.Sound('resources/data/yahoo.ogg')
# Main loop
while player.health > -10:
# CREEP MANAGER
CreepManager.update(creeps, player.pos[0], player.pos[1], player.rect.left)
CreepManager.create_creep_dynamic(player.pos[0], creeps)
if player.state == Constant.DIE_STATE:
player.health -= 0.1
# Get input
player1_down_to_up = player.fire_down
for event in pygame.event.get():
if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
return
elif event.type == KEYDOWN:
if event.key == Constant.PLAYER1FIREKEY:
player.fire_down = True
elif event.key == Constant.PLAYER1CHANGEBULLET:
player.typeOfBullet += 1
if player.typeOfBullet >= Constant.NUM_BULLET_TYPE:
player.typeOfBullet = EBulletType.BASIC
elif event.key == Constant.PLAYER1JUMPKEY:
if not player.downable:
player.jump = 20
elif event.type == KEYUP:
if event.key == Constant.PLAYER1FIREKEY:
player.fire_down = False
if player.enegery >= 20:
player.state = Constant.THROW_STATE
# Clear/erase the last drawn sprites
render_group.clear(screen, background)
screen.fill((0, 0, 0))
if (camera_right < Constant.SCREENRECT.width * 8):
if camera_left < (hCount - 1) * background.get_width():
hCount -= 1
elif (camera_left < hCount * background.get_width()):
if (camera_right > hCount * background.get_width()):
screen.blit(background, (0 - camera_left + (hCount - 1) * background.get_width(), 0))
screen.blit(background, (hCount * background.get_width() - camera_left, 0))
else:
screen.blit(background, (0 - camera_left + (hCount -1) * background.get_width(), 0))
else:
hCount += 1
tiles = []
for y in range(int(camera_left) / Constant.TILE_WIDTH, (int(camera_right) / Constant.TILE_WIDTH) + 1):
if y > 239:
y = 239
for x in range(0, 20):
if Constant.MAP[x][y] is not 0:
tile = Tile(tileset, (x, y), (32 * y, 32 * x))
for line in invisible_tiles:
if tile.id in line:
tile.visible = False
break
if tile.visible:
screen.blit(tile.image, (Constant.TILE_WIDTH * y - camera_left, Constant.TILE_HEIGHT * x))
tiles.append(tile)
# Update all the sprites
render_group.update()
monsterbombs.update()
for item in items.sprites():
item.update_pos(player.pos[0], player.rect.left)
screen.blit(coins_image, (440, 0))
screen.blit(coin_font.render(' X ' + str(player.money), True, (0, 0, 0)), (480, 0))
items.update()
# Handle player input
key_state = pygame.key.get_pressed()
player.check(key_state)
if player1_down_to_up and not player.fire_down and player.enegery >= 25:
if player.typeOfBullet == EBulletType.BASIC:
butllet = Bullet(player.angle, player.power, player, "fireball.png")
shoot_sound.play()
player.enegery -= butllet.energy_cost
else:
butllet = Bullet(player.angle, player.power, player, "simple.png")
butllet = Bullet(player.angle+10, player.power, player, "simple.png")
butllet = Bullet(player.angle-10, player.power, player, "simple.png")
shoot_sound.play()
player.enegery -= butllet.energy_cost
# *************************************************************
# CHECK COLLISION HERE!
# *************************************************************
for b in bombs.sprites():
b.update_pos(player.pos[0], player.rect.x)
""" COLLIDE WITH SPECIAL OBJECT"""
for tile in tiles:
if tile.id == (11, 21) and Utils.check_collision(player, tile):
for special_tile in special_tiles:
if special_tile.id in invisible_tiles[0]:
special_tile.visible = True
if tile.id == (11, 27) and Utils.check_collision(player, tile):
for special_tile in special_tiles:
if special_tile.id in invisible_tiles[1]:
special_tile.visible = True
if tile.id == (14, 58) and Utils.check_collision(player, tile):
for special_tile in special_tiles:
if special_tile.id in invisible_tiles[2]:
special_tile.visible = True
if tile.id == (6, 77) and Utils.check_collision(player, tile):
for special_tile in special_tiles:
if special_tile.id in invisible_tiles[3]:
special_tile.visible = True
if tile.id == (9, 143) and Utils.check_collision(player, tile):
for special_tile in special_tiles:
if special_tile.id in invisible_tiles[4]:
special_tile.visible = True
for special_tile in special_tiles:
if special_tile.visible:
screen.blit(special_tile.image, (Constant.TILE_WIDTH * special_tile.id[1] - camera_left, Constant.TILE_HEIGHT * special_tile.id[0]))
""" OUT OF MAP"""
if (player.pos[1] + Constant.PLAYERHEIGHT >= Constant.SCREENRECT.height):
game_state = Constant.GAMEOVER
break
"""PLAYER GOES DOWN"""
player.downable = True
for tile in tiles:
is_Visible = True
for special_tile in special_tiles:
if special_tile.id == tile.id and special_tile.visible == False:
is_Visible = False
break
if not is_Visible :
continue
if tile.downable == True:
continue;
if (player.pos[0] >= tile.pos[0] and player.pos[0] <= tile.pos[0] + Constant.TILE_WIDTH) \
or ( player.pos[0] + Constant.PLAYERWIDTH >= tile.pos [0] and player.pos[0] + Constant.PLAYERWIDTH <= tile.pos[0] + Constant.TILE_WIDTH):
if (player.pos[1] + Constant.PLAYERHEIGHT >= tile.pos[1] and player.pos[1] + Constant.PLAYERHEIGHT <= tile.pos[1] + Constant.TILE_HEIGHT):
player.downable = False
break;
""" WALL BLOCK """
player.isBlockByWall = False
for tile in tiles:
is_Visible = True
for special_tile in special_tiles:
if special_tile.id == tile.id and special_tile.visible == False:
is_Visible = False
break
if is_Visible and tile.isBlockByWall == True and player.pos[1] <= tile.pos[1] and player.pos[1] + Constant.PLAYERHEIGHT >= tile.pos[1] \
and player.pos[1] > tile.pos[1] - Constant.TILE_HEIGHT:
""" Player goes to the right """
if player.direction == 1:
if player.pos[0] + Constant.PLAYERWIDTH + player.speed>= tile.pos[0] \
and player.pos[0] + Constant.PLAYERWIDTH + player.speed <= tile.pos[0] + Constant.TILE_WIDTH:
player.isBlockByWall = True
else:
if player.pos[0] - player.speed >= tile.pos[0] \
and player.pos[0] - player.speed <= tile.pos[0] + Constant.TILE_WIDTH:
player.isBlockByWall = True
""" GROUND BLOCK """
player.is_block_by_ground = False
for tile in tiles:
is_Visible = True
for special_tile in special_tiles:
if special_tile.id == tile.id and special_tile.visible == False:
is_Visible = False
break
if is_Visible and tile.isBlockByGround and player.jump > 0 and player.pos[1] >= tile.pos[1] and player.pos[1] <= tile.pos[1] + Constant.TILE_HEIGHT:
if(player.pos[0] >= tile.pos[0] and player.pos[0] <= tile.pos[0] + Constant.TILE_WIDTH) \
or ( player.pos[0] + Constant.PLAYERWIDTH >= tile.pos [0] and player.pos[0] + Constant.PLAYERWIDTH <= tile.pos[0] + Constant.TILE_WIDTH):
player.jump = 0
""" Move with world """
if not player.isBlockByWall and player.state == Constant.MOVE_STATE:
if (((player.pos[0] + player.direction * player.speed) >= 0 ) and (player.pos[0] + player.direction * player.speed <= Constant.SCREENRECT.width * 8)):
player.pos[0] += player.direction * player.speed
if (camera_left + player.direction * player.speed >= 0) and (camera_right + player.direction * player.speed < Constant.SCREENRECT.width * 8):
camera_left += player.direction * player.speed
camera_right += player.direction * player.speed
player.moveWithScreen = False
else:
player.moveWithScreen = True
dict_collide = pygame.sprite.groupcollide(bombs, creeps, True, False)
for key in dict_collide.keys():
boom_sound.play()
Explosion(key)
for creep in dict_collide[key]:
if not isinstance(creep, CreepASpecial):
creep.kill()
else:
creep.check_die()
#check va cham cua player voi dan cua monster
dict_collide1 = pygame.sprite.spritecollide(player,monsterbombs, True)
for key in dict_collide1:
boom_sound.play()
Explosion(key)
player.lost_blood(70)
#check va cham cua monster voi dan cua player
if mymonster:
dict_collide2 = pygame.sprite.spritecollide(mymonster,bombs, True)
for key in dict_collide2:
boom_sound.play()
Explosion(key)
mymonster.lost_blood(5)
if pygame.sprite.spritecollide(player, creeps, True):
player.lost_blood(40)
item_collides = pygame.sprite.spritecollide(player, items, True)
for item in item_collides:
if isinstance(item, berry):
player.typeOfBullet = EBulletType.THREE
continue
#item.playEffect()
player.sound_money.play()
player.money += 1
player.enegery += 5
for b in monsterbombs.sprites():
b.update_pos(player.pos[0], player.rect.x)
dirty = render_group.draw(screen) # Draw all sprite, return list of rect
pygame.display.update(dirty) # Draw only changed rect
pygame.display.flip()
# Cap the frame rate
clock.tick(Constant.FPS)
#Clear tile list
tiles[:] = []
game_state = Constant.GAMEOVER
game_over(screen, game_state)
class Service:
def __init__(self, obj_repo):
self.repo = obj_repo
self.obj_utils = Utils()
def get_group_info(self, org_id=None, srvc_id=None):
print('Inside grp info')
service_status_dict = {}
try:
if org_id is None:
status = self.repo.execute(
"SELECT G.*, S.endpoint, S.is_available, S.last_check_timestamp FROM service_group G, " \
"service_status S WHERE G.service_row_id = S.service_row_id AND G.group_id = S.group_id " \
"AND G.service_row_id IN (SELECT row_id FROM service WHERE is_curated = 1)")
elif org_id is not None and srvc_id is None:
query = "SELECT G.*, S.endpoint, S.is_available, S.last_check_timestamp FROM service_group G, " \
"service_status S WHERE G.service_row_id = S.service_row_id AND G.group_id = S.group_id " \
"AND G.service_row_id IN (SELECT row_id FROM service WHERE is_curated = 1 and org_id = %s)"
status = self.repo.execute(query, org_id)
else:
query = "SELECT G.*, S.endpoint, S.is_available, S.last_check_timestamp FROM service_group G, " \
"service_status S WHERE G.service_row_id = S.service_row_id AND G.group_id = S.group_id " \
"AND G.service_row_id IN (SELECT row_id FROM service WHERE is_curated = 1 and org_id = %s " \
"AND service_id = %s ) "
status = self.repo.execute(query, [org_id, srvc_id])
self.obj_utils.clean(status)
for rec in status:
srvc_rw_id = rec['service_row_id']
grp_id = rec['group_id']
endpoint_value = {
'is_available': rec['is_available'],
'last_check_timestamp': rec['last_check_timestamp']
}
endpoint = rec['endpoint']
if srvc_rw_id not in service_status_dict.keys():
service_status_dict[srvc_rw_id] = {
'service_id': rec['service_id'],
'org_id': rec['org_id']
}
service_status_dict[srvc_rw_id]['grp'] = {}
if grp_id not in service_status_dict.get(srvc_rw_id).keys():
service_status_dict[srvc_rw_id]['grp'][grp_id] = {}
service_status_dict[srvc_rw_id]['grp'][grp_id][
'payment_address'] = rec['payment_address']
service_status_dict[srvc_rw_id]['grp'][grp_id][
'endpoint'] = {}
service_status_dict[srvc_rw_id]['grp'][grp_id][
'endpoint'].update({endpoint: endpoint_value})
service_status = self.process_service_status(service_status_dict)
except Exception as e:
print(repr(e))
raise e
return service_status
def process_service_status(self, service_status_dict):
service_status = []
for srvc_rw_id in service_status_dict.keys():
is_available = 0
grps_dict = service_status_dict.get(srvc_rw_id, {})
grps = []
for grp_id in grps_dict['grp'].keys():
grp_available = 0
endpts_dict = grps_dict['grp'].get(grp_id, {})
endpts = []
for endpt in endpts_dict['endpoint'].keys():
endpt_available = endpts_dict['endpoint'][endpt].get(
'is_available', None)
last_check_timestamp = endpts_dict['endpoint'][endpt].get(
'last_check_timestamp', None)
endpts.append({
'endpoint': endpt,
'is_available': endpt_available,
'last_check_timestamp': last_check_timestamp
})
grp_available = grp_available or endpt_available
is_available = is_available or grp_available
grps.append({
'group_id':
grp_id,
'endpoints':
endpts,
'is_available':
grp_available,
'payment_address':
endpts_dict.get('payment_address', '')
})
service_status.append({
'service_row_id': srvc_rw_id,
'service_id': grps_dict['service_id'],
'org_id': grps_dict['org_id'],
'groups': grps,
'is_available': is_available
})
return service_status
def fetch_total_count(self):
user_vote_count_dict = {}
try:
count_details = self.repo.execute(
"SELECT org_id, service_id, vote, Count(*) AS count FROM user_service_vote GROUP BY vote, service_id, org_id"
)
for rec in count_details:
org_id = rec.get('org_id', '')
service_id = rec.get('service_id', '')
vote = rec.get('vote', '')
count = rec.get('count', '')
if not org_id in user_vote_count_dict.keys():
user_vote_count_dict[org_id] = {}
if not service_id in user_vote_count_dict[org_id].keys():
user_vote_count_dict[org_id][service_id] = {}
user_vote_count_dict[org_id][service_id][vote] = count
except Exception as e:
print(repr(e))
raise e
return user_vote_count_dict
def vote_mapping(self, vote):
return {'up_vote': (vote == 1), 'down_vote': (vote == 0)}
def fetch_user_vote(self, user_address):
user_vote_dict = {}
try:
votes = self.repo.execute(
"SELECT * FROM user_service_vote WHERE user_address = %s",
(user_address))
self.obj_utils.clean(votes)
for rec in votes:
org_id = rec['org_id']
service_id = rec['service_id']
comment = rec.get('comment', None)
if org_id not in user_vote_dict.keys():
user_vote_dict[org_id] = {}
user_vote_dict[org_id][service_id] = {
'user_address': rec['user_address'],
'org_id': rec['org_id'],
'service_id': service_id,
'comment': comment
}
user_vote_dict[org_id][service_id].update(
self.vote_mapping(rec['vote']))
except Exception as e:
print(repr(e))
raise e
return user_vote_dict
def get_user_vote(self, user_address):
vote_list = []
try:
count_details = self.fetch_total_count()
votes = self.fetch_user_vote(user_address)
for org_id in count_details.keys():
srvcs_data = count_details[org_id]
for service_id in srvcs_data.keys():
rec = {
'org_id':
org_id,
'service_id':
service_id,
'up_vote_count':
srvcs_data.get(service_id).get(1, 0),
'down_vote_count':
srvcs_data.get(service_id).get(0, 0),
"up_vote":
votes.get(org_id, {}).get(service_id,
{}).get('up_vote', False),
"down_vote":
votes.get(org_id, {}).get(service_id,
{}).get('down_vote', False)
}
vote_list.append(rec)
except Exception as e:
print(repr(e))
raise e
return vote_list
def fetch_user_feedbk(self, user_address):
user_vote_dict = {}
try:
votes = self.repo.execute(
"SELECT * FROM user_service_vote WHERE user_address = %s",
(user_address))
self.obj_utils.clean(votes)
feedbk = self.repo.execute(
"SELECT A.* FROM user_service_feedback A INNER JOIN (SELECT user_address,org_id, service_id, "
"max(row_updated) latest_dt FROM user_service_feedback WHERE user_address = %s GROUP BY user_address, "
"org_id, service_id) B on A.user_address = B.user_address AND A.org_id = B.org_id AND A.service_id = "
"B.service_id AND A.row_updated = B.latest_dt", (user_address))
self.obj_utils.clean(feedbk)
for rec in votes:
org_id = rec['org_id']
service_id = rec['service_id']
if org_id not in user_vote_dict.keys():
user_vote_dict[org_id] = {}
user_vote_dict[org_id][service_id] = {
'user_address': rec['user_address'],
'org_id': rec['org_id'],
'service_id': service_id
}
user_vote_dict[org_id][service_id].update(
self.vote_mapping(rec['vote']))
for rec in feedbk:
org_id = rec['org_id']
service_id = rec['service_id']
user_vote_dict[org_id][service_id]['comment'] = rec['comment']
except Exception as e:
print(repr(e))
raise e
return user_vote_dict
def get_usr_feedbk(self, user_address):
vote_list = []
try:
count_details = self.fetch_total_count()
votes = self.fetch_user_feedbk(user_address)
for org_id in count_details.keys():
srvcs_data = count_details[org_id]
for service_id in srvcs_data.keys():
rec = {
'org_id':
org_id,
'service_id':
service_id,
'up_vote_count':
srvcs_data.get(service_id).get(1, 0),
'down_vote_count':
srvcs_data.get(service_id).get(0, 0),
"up_vote":
votes.get(org_id, {}).get(service_id,
{}).get('up_vote', False),
"down_vote":
votes.get(org_id, {}).get(service_id,
{}).get('down_vote', False),
"comment":
votes.get(org_id, {}).get(service_id,
{}).get('comment', None)
}
vote_list.append(rec)
except Exception as e:
print(repr(e))
raise e
return vote_list
def is_valid_vote(self, net_id, vote_info_dict):
try:
provider = web3.HTTPProvider(NETWORKS[net_id]['http_provider'])
w3 = web3.Web3(provider)
message_text = str(vote_info_dict['user_address']) + str(vote_info_dict['org_id']) + \
str(vote_info_dict['up_vote']).lower() + str(vote_info_dict['service_id']) + \
str(vote_info_dict['down_vote']).lower()
message = w3.sha3(text=message_text)
message_hash = defunct_hash_message(primitive=message)
recovered = str(
w3.eth.account.recoverHash(
message_hash, signature=vote_info_dict['signature']))
return str(
vote_info_dict['user_address']).lower() == recovered.lower()
except Exception as e:
print(repr(e))
raise e
return False
def set_user_vote(self, vote_info_dict, net_id):
try:
vote = -1
if vote_info_dict['up_vote']:
vote = 1
elif vote_info_dict['down_vote']:
vote = 0
if self.is_valid_vote(net_id=net_id,
vote_info_dict=vote_info_dict):
query = "Insert into user_service_vote (user_address, org_id, service_id, vote, row_created) VALUES (%s, %s, %s, %s, %s) ON DUPLICATE KEY UPDATE VOTE = %s"
q_params = [
vote_info_dict['user_address'], vote_info_dict['org_id'],
vote_info_dict['service_id'], vote,
datetime.datetime.utcnow(), vote
]
res = self.repo.execute(query, q_params)
else:
raise Exception("Signature of the vote is not valid.")
except Exception as e:
print(repr(e))
raise e
return True
def is_valid_feedbk(self, net_id, usr_addr, msg_txt, sign):
try:
provider = web3.HTTPProvider(NETWORKS[net_id]['http_provider'])
w3 = web3.Web3(provider)
message = w3.sha3(text=msg_txt)
message_hash = defunct_hash_message(primitive=message)
recovered = str(
w3.eth.account.recoverHash(message_hash, signature=sign))
return str(usr_addr).lower() == recovered.lower()
except Exception as e:
print(repr(e))
raise e
return False
def set_usr_feedbk(self, feedbk_info, net_id):
try:
vote = -1
if feedbk_info['up_vote']:
vote = 1
elif feedbk_info['down_vote']:
vote = 0
curr_dt = datetime.datetime.utcnow()
usr_addr = feedbk_info['user_address']
org_id = feedbk_info['org_id']
srvc_id = feedbk_info['service_id']
comment = feedbk_info['comment']
msg_txt = str(usr_addr) + str(org_id) + str(feedbk_info['up_vote']).lower() + str(srvc_id) + \
str(feedbk_info['down_vote']).lower() + str(comment).lower()
if self.is_valid_feedbk(net_id=net_id,
usr_addr=usr_addr,
msg_txt=msg_txt,
sign=feedbk_info['signature']):
self.repo.begin_transaction()
insrt_vote = "INSERT INTO user_service_vote (user_address, org_id, service_id, vote, row_updated, row_created) " \
"VALUES (%s, %s, %s, %s, %s, %s) " \
"ON DUPLICATE KEY UPDATE vote = %s, row_updated = %s"
insrt_vote_params = [
usr_addr, org_id, srvc_id, vote, curr_dt, curr_dt, vote,
curr_dt
]
self.repo.execute(insrt_vote, insrt_vote_params)
insrt_feedbk = "INSERT INTO user_service_feedback (user_address, org_id, service_id, comment, " \
"row_updated, row_created)" \
"VALUES (%s, %s, %s, %s, %s, %s) "
insrt_feedbk_params = [
usr_addr, org_id, srvc_id, comment, curr_dt, curr_dt
]
self.repo.execute(insrt_feedbk, insrt_feedbk_params)
self.repo.commit_transaction()
else:
raise Exception("signature of the vote is not valid.")
except MySQLError as e:
self.repo.rollback_transaction()
raise e
except Exception as err:
print(repr(err))
raise err
return True
def get_curated_services(self):
try:
services = self.repo.execute(
"SELECT * FROM service S, service_metadata M WHERE S.row_id = M.service_row_id AND S.is_curated = 1"
)
groups = self.repo.execute("SELECT G.*, E.* FROM service S, service_group G, service_endpoint E WHERE " \
"G.group_id = E.group_id AND G.service_row_id = S.row_id AND " \
"E.service_row_id = S.row_id AND S.is_curated = 1")
tags = self.repo.execute(
"SELECT T.* FROM service S, service_tags T WHERE T.service_row_id = S.row_id AND S.is_curated = 1"
)
grouped_services = self.__merge_service_data(
services, groups, tags)
except Exception as e:
print(repr(e))
raise e
return grouped_services
def get_profile_details(self, user_address):
try:
mpe_details = list()
qry = "SELECT G.org_id, D.display_name, M.* FROM mpe_channel M, service_group G ,service_metadata D, " \
"organization O WHERE M.groupId = G.group_id AND M.recipient = G.payment_address AND " \
"D.service_row_id = G.service_row_id AND O.org_id = G.org_id AND sender = %s "
channel_details = self.repo.execute(qry, (user_address))
for detail in channel_details:
mpe_details.append(self.obj_utils.clean_row(detail))
except Exception as e:
print(repr(e))
raise e
return mpe_details
def __merge_service_data(self, services, groups, tags):
tag_map = self.__map_to_service(tags)
groups_map = self.__map_to_service(groups)
for service in services:
self.obj_utils.clean_row(service)
service_row_id = service['service_row_id']
service['groups'] = self.__get_group_with_endpoints(
groups_map[service_row_id])
if service_row_id in tag_map:
service['tags'] = [
tag['tag_name'] for tag in tag_map[service_row_id]
]
else:
service['tags'] = []
return services
def __map_to_service(self, rows):
map = dict()
for row in rows:
service_id = row['service_row_id']
if service_id not in map:
map[service_id] = list()
map[service_id].append(row)
return map
def __get_group_with_endpoints(self, groups):
segregated_groups = dict()
for group in groups:
group_name = group['group_name']
if group_name not in segregated_groups:
group_details = dict()
group_details['endpoints'] = list()
segregated_groups[group_name] = group_details
else:
group_details = segregated_groups[group_name]
group_details['payment_address'] = group['payment_address']
group_details['group_id'] = group['group_id']
group_details['endpoints'].append(group['endpoint'])
return segregated_groups
def __init__(self, repo, net_id):
self.repo = repo
self.route = "/encoding"
self.rex_for_pb_ip = "^(http://)*(https://)*127.0.0.1|^(http://)*(https://)*localhost|^(http://)*(https://)*192.|^(http://)*(https://)*172.|^(http://)*(https://)*10."
self.obj_util = Utils()
self.net_id = net_id
def send_slack_alert(self, unsuccessful_files):
slack_msg = f"Failed to delete files\n```{unsuccessful_files}```"
return Utils().report_slack(slack_msg=slack_msg, SLACK_HOOK=SLACK_HOOK)
class OrderService:
def __init__(self, obj_repo):
self.repo = obj_repo
self.obj_transaction_history_dao = TransactionHistoryDAO(self.repo)
self.lambda_client = boto3.client('lambda', region_name=REGION_NAME)
self.boto_client = BotoUtils(REGION_NAME)
self.wallet_service = WalletService()
self.obj_blockchain_util = BlockChainUtil(
provider_type="HTTP_PROVIDER",
provider=NETWORKS[NETWORK_ID]['http_provider']
)
self.utils = Utils()
def initiate_order(self, username, payload_dict):
"""
Initiate Order
Step 1 Order Creation
Step 2 Initiate Payment
Step 3 Persist Transaction History
"""
price = payload_dict["price"]
order_type = payload_dict["item_details"]["order_type"]
item_details = payload_dict["item_details"]
group_id = item_details["group_id"]
org_id = item_details["org_id"]
channel_id = ""
amount_in_cogs = self.calculate_amount_in_cogs(amount=price["amount"], currency=price["currency"])
if amount_in_cogs < 1:
raise Exception("Amount in cogs should be greater than equal to 1")
item_details["amount_in_cogs"] = amount_in_cogs
if order_type == OrderType.CREATE_WALLET_AND_CHANNEL.value:
item_details["wallet_address"] = ""
recipient = self.get_payment_address_for_org(group_id=group_id, org_id=org_id)
elif order_type == OrderType.CREATE_CHANNEL.value:
recipient = self.get_payment_address_for_org(group_id=group_id, org_id=org_id)
elif order_type == OrderType.FUND_CHANNEL.value:
channel = self.get_channel_for_topup(username=username, group_id=group_id, org_id=org_id)
if channel is None:
raise Exception(f"Channel not found for the user: {username} with org: {org_id} group: {group_id}")
recipient = channel["recipient"]
channel_id = channel["channel_id"]
item_details["wallet_address"] = channel["address"]
else:
raise Exception("Invalid order type")
item_details["channel_id"] = channel_id
item_details["recipient"] = recipient
order_details = self.manage_create_order(
username=username, item_details=item_details,
price=price
)
order_id = order_details["order_id"]
try:
payment_data = self.manage_initiate_payment(
username=username, order_id=order_id, price=price,
payment_method=payload_dict["payment_method"]
)
payment_id = payment_data["payment_id"]
raw_payment_data = json.dumps(payment_data["payment"])
obj_transaction_history = TransactionHistory(
username=username, order_id=order_id, order_type=order_type,
payment_id=payment_id, raw_payment_data=raw_payment_data,
status=Status.PAYMENT_INITIATED.value
)
self.obj_transaction_history_dao.insert_transaction_history(obj_transaction_history=obj_transaction_history)
return payment_data
except Exception as e:
obj_transaction_history = TransactionHistory(
username=username, order_id=order_id, order_type=order_type,
status=Status.PAYMENT_INITIATION_FAILED.value
)
self.obj_transaction_history_dao.insert_transaction_history(obj_transaction_history=obj_transaction_history)
print(repr(e))
raise e
def get_channel_for_topup(self, username, group_id, org_id):
channel_details = self.wallet_service.get_channel_details(
username=username, group_id=group_id, org_id=org_id
)
wallets = channel_details["wallets"]
for wallet in wallets:
if (wallet["type"] == "GENERAL") and len(wallet["channels"]) > 0:
if wallet["channels"][0]["signer"] == SIGNER_ADDRESS:
wallet_address = wallet["address"]
channel = wallet["channels"][0]
channel["address"] = wallet_address
return channel
return None
def get_payment_address_for_org(self, org_id, group_id):
group_details_event = {
"path": f"/org/{org_id}/group/{quote(group_id, safe='')}",
"pathParameters": {
"orgId": org_id,
"group_id": quote(group_id, safe='')
},
"httpMethod": "GET"
}
logger.info(f"get_group_for_org request: {org_id} and {group_id}")
group_details_lambda_response = self.lambda_client.invoke(
FunctionName=GET_GROUP_FOR_ORG_API_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(group_details_event)
)
group_details_response = json.loads(group_details_lambda_response.get('Payload').read())
logger.info(f"get_group_for_org response: {group_details_response}")
if group_details_response["statusCode"] != 200:
raise Exception(f"Failed to fetch group details for org_id:{org_id} "
f"group_id {group_id}")
group_details_response_body = json.loads(group_details_response["body"])
groups = group_details_response_body["data"]["groups"]
if len(groups) == 0:
raise Exception(f"Failed to find group {group_id} for org_id: {org_id}")
return groups[0]["payment"]["payment_address"]
def calculate_amount_in_cogs(self, amount, currency):
if currency == "USD":
amount_in_cogs = round(amount * USD_TO_COGS_CONVERSION_FACTOR)
return amount_in_cogs
else:
raise Exception("Currency %s not supported.", currency)
def execute_order(self, username, payload_dict):
"""
Execute Order
Step 1 Execute Payment
Step 2 Get Receipient Address
Step 3 Process Order
Step 4 Update Transaction History
"""
order_id = payload_dict["order_id"]
payment_id = payload_dict["payment_id"]
order = self.get_order_details_by_order_id(order_id, username)
payment = None
for payment_item in order["payments"]:
if payment_item["payment_id"] == payment_id:
payment = payment_item
break
if payment is None:
raise Exception(f"Failed to fetch order details for order_id {order_id} \n"
f"payment_id {payment_id} \n"
f"username{username}")
order_type = order["item_details"]["order_type"]
item_details = order["item_details"]
payment_method = payment["payment_details"]["payment_method"]
paid_payment_details = payload_dict["payment_details"]
price = payment["price"]
status = Status.PAYMENT_EXECUTION_FAILED.value
self.manage_execute_payment(
username=username, order_id=order_id, payment_id=payment_id,
payment_details=paid_payment_details, payment_method=payment_method
)
status = Status.PAYMENT_EXECUTED.value
try:
status = Status.ORDER_PROCESSING_FAILED.value
amount_in_cogs = self.calculate_amount_in_cogs(amount=price["amount"], currency=price["currency"])
if amount_in_cogs < 1:
raise Exception("Amount in cogs should be greater than equal to 1")
processed_order_data = self.manage_process_order(
username=username,
order_id=order_id, order_type=order_type,
amount=price["amount"],
currency=price["currency"], order_data=item_details,
amount_in_cogs=amount_in_cogs
)
status = Status.ORDER_PROCESSED.value
obj_transaction_history = TransactionHistory(
username=username, order_id=order_id, order_type=order_type,
status=status, payment_id=payment_id,
payment_method=payment_method,
raw_payment_data=json.dumps(paid_payment_details)
)
self.obj_transaction_history_dao.insert_transaction_history(obj_transaction_history=obj_transaction_history)
processed_order_data["price"] = price
processed_order_data["item_details"] = item_details
return processed_order_data
except Exception as e:
obj_transaction_history = TransactionHistory(
username=username, order_id=order_id,
order_type=order_type, status=status
)
self.obj_transaction_history_dao.insert_transaction_history(obj_transaction_history=obj_transaction_history)
print(repr(e))
raise e
def get_order_details_by_order_id(self, order_id, username):
order_details_event = {
"path": f"order/{order_id}",
"pathParameters": {"order_id": order_id},
"httpMethod": "GET"
}
logger.info(f"Requesting order details for order_id {order_id}")
response = self.lambda_client.invoke(
FunctionName=ORDER_DETAILS_ORDER_ID_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(order_details_event)
)
order_details_response = json.loads(response.get('Payload').read())
if order_details_response["statusCode"] != 200:
raise Exception(f"Failed to fetch order details for order_id {order_id} username{username}")
order_details_data = json.loads(order_details_response["body"])
if order_details_data["username"] != username:
raise Exception(f"Failed to fetch order details for order_id {order_id} username{username}")
return order_details_data
def manage_initiate_payment(self, username, order_id, price, payment_method):
initiate_payment_event = {
"pathParameters": {"order_id": order_id},
"httpMethod": "POST",
"body": json.dumps({"price": price, "payment_method": payment_method})
}
response = self.lambda_client.invoke(
FunctionName=INITIATE_PAYMENT_SERVICE_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(initiate_payment_event)
)
initiate_payment_data = json.loads(response.get('Payload').read())
if initiate_payment_data["statusCode"] == 201:
return json.loads(initiate_payment_data["body"])
else:
logger.error("Error initiating payment for user %s", username)
raise PaymentInitiateFailed
def manage_create_order(self, username, item_details, price):
create_order_event = {
"path": "/order/create",
"httpMethod": "POST",
"body": json.dumps({"price": price, "item_details": item_details, "username": username})
}
create_order_service_response = self.boto_client.invoke_lambda(
lambda_function_arn=CREATE_ORDER_SERVICE_ARN,
invocation_type='RequestResponse',
payload=json.dumps(create_order_event)
)
logger.info(f"create_order_service_response: {create_order_service_response}")
if create_order_service_response["statusCode"] == 201:
return json.loads(create_order_service_response["body"])
else:
raise Exception(f"Error creating order for user {username}")
def manage_execute_payment(self, username, order_id, payment_id, payment_details, payment_method):
execute_payment_event = {
"pathParameters": {"order_id": order_id, "payment_id": payment_id},
"body": json.dumps({"payment_method": payment_method, "payment_details": payment_details})
}
response = self.lambda_client.invoke(
FunctionName=EXECUTE_PAYMENT_SERVICE_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(execute_payment_event)
)
payment_executed = json.loads(response.get('Payload').read())
if payment_executed["statusCode"] == 201:
return payment_executed
else:
raise Exception(f"Error executing payment for username {username} against order_id {order_id}")
def manage_process_order(self, username, order_id, order_type, amount, currency, order_data, amount_in_cogs):
logger.info(f"Order Data {order_data}")
group_id = order_data["group_id"]
org_id = order_data["org_id"]
recipient = order_data["recipient"]
channel_id = order_data["channel_id"]
sender = order_data["wallet_address"]
if order_type == OrderType.CREATE_WALLET_AND_CHANNEL.value:
wallet_create_payload = {
"path": "/wallet",
"body": json.dumps({"username": username}),
"httpMethod": "POST"
}
wallet_create_lambda_response = self.lambda_client.invoke(
FunctionName=WALLETS_SERVICE_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(wallet_create_payload)
)
wallet_create_response = json.loads(wallet_create_lambda_response.get("Payload").read())
if wallet_create_response["statusCode"] != 200:
raise Exception("Failed to create wallet")
wallet_create_response_body = json.loads(wallet_create_response["body"])
wallet_details = wallet_create_response_body["data"]
try:
current_block_no = self.obj_blockchain_util.get_current_block_no()
# 1 block no is mined in 15 sec on average, setting expiration as 10 years
expiration = current_block_no + (10 * 365 * 24 * 60 * 4)
message_nonce = current_block_no
self.EXECUTOR_WALLET_ADDRESS = self.boto_client.get_ssm_parameter(EXECUTOR_ADDRESS)
group_id_in_hex = "0x" + base64.b64decode(group_id).hex()
signature_details = self.generate_signature_for_open_channel_for_third_party(
recipient=recipient, group_id=group_id_in_hex,
amount_in_cogs=amount_in_cogs, expiration=expiration,
message_nonce=message_nonce, sender_private_key=wallet_details["private_key"],
executor_wallet_address=self.EXECUTOR_WALLET_ADDRESS
)
logger.info(f"Signature Details {signature_details}")
open_channel_body = {
'order_id': order_id,
'sender': wallet_details["address"],
'signature': signature_details["signature"],
'r': signature_details["r"],
's': signature_details["s"],
'v': signature_details["v"],
'group_id': group_id,
'org_id': org_id,
'amount': amount,
'currency': currency,
'recipient': recipient,
'current_block_no': current_block_no,
'amount_in_cogs': amount_in_cogs
}
channel_details = self.wallet_service.create_channel(open_channel_body=open_channel_body)
channel_details.update(wallet_details)
return channel_details
except Exception as e:
logger.error("Failed to create channel")
logger.error(repr(e))
response = {
"transaction_hash": "",
"signature": "",
"amount_in_cogs": 0,
"price": {
"amount": amount,
"currency": currency
},
"item_details": order_data
}
response.update(wallet_details)
raise ChannelCreationFailed("Failed to create channel", wallet_details=response)
elif order_type == OrderType.CREATE_CHANNEL.value:
try:
logger.info(f"Order Data {order_data}")
signature = order_data["signature"]
v, r, s = Web3.toInt(hexstr="0x" + signature[-2:]), signature[:66], "0x" + signature[66:130]
open_channel_body = {
'order_id': order_id, 'sender': order_data["wallet_address"],
'signature': order_data["signature"], 'r': r, 's': s, 'v': v,
'group_id': group_id, 'org_id': org_id, 'amount': amount, 'currency': currency,
'recipient': recipient, 'current_block_no': order_data["current_block_number"],
'amount_in_cogs': amount_in_cogs
}
channel_details = self.wallet_service.create_channel(open_channel_body=open_channel_body)
logger.info(f"channel_details: {channel_details}")
return channel_details
except Exception as e:
logger.error("Failed to create channel")
print(repr(e))
raise ChannelCreationFailed("Failed to create channel", wallet_details=order_data)
elif order_type == OrderType.FUND_CHANNEL.value:
try:
fund_channel_body = {
'order_id': order_id,
'group_id': group_id,
'org_id': org_id,
'amount': amount,
'channel_id': channel_id,
'currency': currency,
'recipient': recipient,
'sender': sender,
'amount_in_cogs': amount_in_cogs
}
fund_channel_payload = {
"path": "/wallet/channel/deposit",
"body": json.dumps(fund_channel_body),
"httpMethod": "POST"
}
fund_channel_lambda_response = self.lambda_client.invoke(
FunctionName=WALLETS_SERVICE_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(fund_channel_payload)
)
fund_channel_response = json.loads(fund_channel_lambda_response.get("Payload").read())
if fund_channel_response["statusCode"] != 200:
raise Exception(f"Failed to add funds in channel for {fund_channel_body}")
fund_channel_response_body = json.loads(fund_channel_response["body"])
fund_channel_transaction_details = fund_channel_response_body["data"]
return fund_channel_transaction_details
except Exception as e:
logger.error("Failed to fund channel")
logger.error(repr(e))
raise FundChannelFailed()
else:
raise Exception("Order type is not valid.")
def get_order_details_by_username(self, username):
order_details_event = {
"path": f"/order",
"queryStringParameters": {"username": username},
"httpMethod": "GET"
}
logger.info(f"Requesting order details for username {username}")
order_details_response = self.boto_client.invoke_lambda(
lambda_function_arn=ORDER_DETAILS_BY_USERNAME_ARN,
invocation_type='RequestResponse',
payload=json.dumps(order_details_event)
)
if order_details_response["statusCode"] != 200:
raise Exception(f"Failed to fetch order details for username{username}")
org_id_name_mapping = self.get_organizations_from_contract()
order_details_response_body = json.loads(order_details_response["body"])
orders = order_details_response_body["orders"]
for order in orders:
order_id = order["order_id"]
order["wallet_type"] = "GENERAL"
if "org_id" in order["item_details"]:
org_id = order["item_details"]["org_id"]
if org_id in org_id_name_mapping:
order["item_details"]["organization_name"] = org_id_name_mapping[org_id]
transaction_details_event = {
"path": f"/wallet/channel/transactions",
"queryStringParameters": {"order_id": order_id},
"httpMethod": "GET"
}
transaction_details_lambda_response = self.lambda_client.invoke(
FunctionName=WALLETS_SERVICE_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(transaction_details_event)
)
transaction_details_response = json.loads(transaction_details_lambda_response.get('Payload').read())
if transaction_details_response["statusCode"] != 200:
raise Exception(f"Failed to fetch transaction details for username{order_id}")
transaction_details_response_body = json.loads(transaction_details_response["body"])
order["wallet_transactions"] = transaction_details_response_body["data"]["transactions"]
order_status = TransactionStatus.SUCCESS
for payment in order["payments"]:
if payment["payment_status"] != TransactionStatus.SUCCESS:
order_status = payment["payment_status"]
break
for wallet_transaction in order["wallet_transactions"]:
if wallet_transaction["status"] != TransactionStatus.SUCCESS:
order_status = wallet_transaction["status"]
break
order["order_status"] = order_status
return {"orders": orders}
def get_organizations_from_contract(self):
org_details_event = {
"path": f"/org",
"httpMethod": "GET"
}
org_details_response = self.boto_client.invoke_lambda(
lambda_function_arn=GET_ALL_ORG_API_ARN,
invocation_type='RequestResponse',
payload=json.dumps(org_details_event)
)
if org_details_response["statusCode"] != 200:
raise Exception("Failed to get org details")
org_details = json.loads(org_details_response["body"])["data"]
org_id_name_mapping = {}
for org in org_details:
org_id_name_mapping[org["org_id"]] = org["org_name"]
return org_id_name_mapping
def generate_signature_for_open_channel_for_third_party(self, recipient, group_id, amount_in_cogs, expiration,
message_nonce, sender_private_key, executor_wallet_address):
signature_for_open_channel_for_third_party_body = {
'recipient': recipient,
'group_id': group_id,
'amount_in_cogs': amount_in_cogs,
'expiration': expiration,
'message_nonce': message_nonce,
'signer_key': sender_private_key,
'executor_wallet_address': executor_wallet_address
}
signature_for_open_channel_for_third_party_payload = {
"path": "/signer/open-channel-for-third-party",
"body": json.dumps(signature_for_open_channel_for_third_party_body),
"httpMethod": "POST"
}
signature_for_open_channel_for_third_party_response = self.lambda_client.invoke(
FunctionName=SIGNER_SERVICE_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(signature_for_open_channel_for_third_party_payload)
)
signature_response = json.loads(signature_for_open_channel_for_third_party_response.get("Payload").read())
if signature_response["statusCode"] != 200:
raise Exception(f"Failed to create signature for {signature_for_open_channel_for_third_party_body}")
signature_details = json.loads(signature_response["body"])
return signature_details["data"]
def cancel_order(self):
logger.info("Start of UpdateTransactionStatus::manage_update_canceled_order_in_txn_history")
list_of_order_id_for_expired_transaction = self.obj_transaction_history_dao.get_order_id_for_expired_transaction()
logger.info(f"List of order_id to be updated with ORDER CANCELED: {list_of_order_id_for_expired_transaction}")
update_transaction_status = self.obj_transaction_history_dao.update_transaction_status(
list_of_order_id=list_of_order_id_for_expired_transaction, status=OrderStatus.ORDER_CANCELED.value)
return update_transaction_status
def cancel_order_for_given_order_id(self, order_id):
logger.info("UpdateTransactionStatus::cancel_order_for_given_order_id: %s", order_id)
transaction_data_dict = self.obj_transaction_history_dao.get_transaction_details_for_given_order_id(
order_id=order_id)
if transaction_data_dict["status"] == OrderStatus.ORDER_CANCELED.value:
return f"Order with order_id {order_id} is already canceled."
elif transaction_data_dict["status"] in [OrderStatus.PAYMENT_INITIATED.value,
OrderStatus.PAYMENT_INITIATION_FAILED.value,
OrderStatus.PAYMENT_EXECUTION_FAILED]:
self.obj_transaction_history_dao.update_transaction_status(list_of_order_id=[order_id],
status=OrderStatus.ORDER_CANCELED.value)
return f"Order with order_id {order_id} is canceled successfully."
else:
return f"Unable to cancel order with order_id {order_id}"
def currency_to_token(self, amount, currency):
amount_in_cogs = self.calculate_amount_in_cogs(amount=decimal.Decimal(amount), currency=currency)
conversion_data = {"base": currency, "amount": amount, "amount_in_cogs": str(amount_in_cogs),
"amount_in_agi": str(self.utils.cogs_to_agi(cogs=amount_in_cogs)),
f"{currency}/cogs": str(USD_TO_COGS_CONVERSION_FACTOR), "agi/cogs": str(COGS_TO_AGI)}
logger.debug(f"currency_to_token::conversion_data {conversion_data}")
return conversion_data
def get_divi_earn(self):
return Utils.read_data(self.divi_file)
from common.blockchain_util import BlockChainUtil
from common.utils import Utils
from rfai.config import NETWORK
from rfai.dao.foundation_member_data_access_object import FoundationMemberDAO
from rfai.dao.request_data_access_object import RequestDAO
from rfai.dao.solution_data_access_object import SolutionDAO
from rfai.dao.stake_data_access_object import StakeDAO
from rfai.dao.vote_data_access_object import VoteDAO
from rfai.dao.rfai_request_repository import RFAIRequestRepository
from rfai.rfai_status import RFAIStatusCodes
import json
from common.logger import get_logger
obj_utils = Utils()
obj_blockchain_utils = BlockChainUtil(provider_type="HTTP_PROVIDER", provider=NETWORK["http_provider"])
logger = get_logger(__name__)
class RFAIService:
def __init__(self, repo):
self.request_dao = RequestDAO(repo=repo)
self.vote_dao = VoteDAO(repo=repo)
self.solution_dao = SolutionDAO(repo=repo)
self.stake_dao = StakeDAO(repo=repo)
self.foundation_member_dao = FoundationMemberDAO(repo=repo)
self.rfai_request_dao = RFAIRequestRepository(repo=repo)
def _format_filter_params(self, query_parameters):
filter_params = {}
# if "requester" in query_parameters.keys():
# filter_params["requester"] = query_parameters["requester"]
from common.exception_handler import exception_handler
from common.logger import get_logger
from common.repository import Repository
from common.utils import Utils, validate_dict, generate_lambda_response, make_response_body
from wallets.config import NETWORK_ID, NETWORKS, SLACK_HOOK
from wallets.domain.models.channel_transaction_history import ChannelTransactionHistory
from wallets.error import Error
from wallets.exceptions import EXCEPTIONS
from wallets.infrastructure.repositories.channel_repository import ChannelRepository
from wallets.service.manage_create_channel_event import ManageCreateChannelEvent
from wallets.service.wallet_service import WalletService
NETWORKS_NAME = dict(
(NETWORKS[netId]['name'], netId) for netId in NETWORKS.keys())
repo = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS)
utils = Utils()
logger = get_logger(__name__)
wallet_service = WalletService(repo=repo)
def create_channel(event, context):
logger.info("Received request to initiate order")
try:
payload = json.loads(event["body"])
required_keys = [
"order_id", "sender", "signature", "r", "s", "v",
"current_block_no", "group_id", "org_id", "amount", "currency",
"recipient", "amount_in_cogs"
]
if validate_dict(payload, required_keys):
logger.info(f"Payload for create channel: {payload}")
from common.constant import StatusDescription, ErrorDescription
from common.logger import get_logger
from common.repository import Repository
from common.utils import Utils, generate_lambda_response, extract_payload, validate_dict, format_error_message
from wallets.config import NETWORKS, NETWORK_ID, WALLET_TYPES_ALLOWED
from wallets.config import SLACK_HOOK
from wallets.constant import REQUIRED_KEYS_FOR_LAMBDA_EVENT
from wallets.service.wallet_service import WalletService
from wallets.wallet import Wallet
NETWORKS_NAME = dict(
(NETWORKS[netId]['name'], netId) for netId in NETWORKS.keys())
db = dict((netId, Repository(net_id=netId, NETWORKS=NETWORKS))
for netId in NETWORKS.keys())
util = Utils()
logger = get_logger(__name__)
class WalletStatus(Enum):
ACTIVE = 1
def route_path(path, method, payload_dict, path_parameters):
wallet_manager = WalletService(repo=db[NETWORK_ID])
path_exist = True
response_data = None
if "/wallet" == path and method == "POST":
response_data = wallet_manager.create_and_register_wallet(
username=payload_dict["username"])
def __init__(self, obj_repo, net_id):
self.repo = obj_repo
self.net_id = net_id
self.lambda_client = boto3.client('lambda')
self.obj_utils = Utils()
def wrapper(*args, **kwargs):
handler_name = decorator_kwargs.get("handler_name", func.__name__)
path = kwargs.get("event", {}).get("path", None)
path_parameters = kwargs.get("event", {}).get("pathParameters", {})
query_string_parameters = kwargs.get("event", {}).get(
"queryStringParameters", {})
body = kwargs.get("event", {}).get("body", "{}")
error_message = f"Error Reported! \n" \
f"network_id: {NETWORK_ID}\n" \
f"path: {path}, \n" \
f"handler: {handler_name} \n" \
f"pathParameters: {path_parameters} \n" \
f"queryStringParameters: {query_string_parameters} \n" \
f"body: {body} \n" \
f"x-ray-trace-id: None \n" \
f"error_description: \n"
try:
return func(*args, **kwargs)
except EXCEPTIONS as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
exc_tb_lines = traceback.format_tb(exc_tb)
error_message = error_message + e.error_message + "\n"
logger.exception(error_message)
slack_message = error_message
for exc_lines in exc_tb_lines:
slack_message = slack_message + exc_lines
slack_message = f"```{slack_message}```"
Utils().report_slack(type=0,
slack_message=slack_message,
slack_config=SLACK_HOOK)
return generate_lambda_response(
StatusCode.INTERNAL_SERVER_ERROR, {
"status": "failed",
"data": "",
"error": {
"message": e.error_message,
"details": e.error_details
}
},
cors_enabled=True)
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
exc_tb_lines = traceback.format_tb(exc_tb)
logger.exception(error_message)
slack_message = error_message
for exc_lines in exc_tb_lines:
slack_message = slack_message + exc_lines
slack_message = f"```{slack_message}```"
Utils().report_slack(type=0,
slack_message=slack_message,
slack_config=SLACK_HOOK)
return generate_lambda_response(
StatusCode.INTERNAL_SERVER_ERROR, {
"status": "failed",
"data": "",
"error": {
"code": 0,
"message": repr(e),
"details": {}
}
},
cors_enabled=True)
def __init__(self,x,y,item_name):
pygame.sprite.Sprite.__init__(self,self.containers)
self.item_name = item_name
self.x = x
self.y = y
self.state = Constant.ITEM_STATE_LIVE
self.frame_index = 0
self.frame_count = 0
self.timer_die = 0
self.timer_live = 0
self.fall = True
if self.item_name == Constant.MONEY_ITEM :
self.style = Constant.ADD
self.feature = Constant.MONEY
self.num_frame = 7
image = Utils.my_load_image("vatpham","money.png")
self.image_frame = Utils.load_frame(image,0,0,40,40,0,self.num_frame)
elif self.item_name == Constant.BUMERANGE_TREE_ITEM :
print 28
self.style = Constant.ADD
self.feature = Constant.BUMERANGE
self.num_frame = 1
image = Utils.my_load_image("vatpham","bumerange.png")
self.image_frame = Utils.load_frame(image,0,0,89,70,0,self.num_frame)
print len(self.image_frame)
elif self.item_name == Constant.MAGIC_BOX_ITEM :
self.style = Constant.ADD
self.feature = Constant.LIFE
self.num_frame = 1
image = Utils.my_load_image("vatpham","magic_box.png")
self.image_frame = Utils.load_frame(image,0,0,69,69,0,self.num_frame)
elif self.item_name == Constant.MONSTER_ITEM :
self.style = Constant.SUBTRACT
self.feature = Constant.LIFE
self.num_frame = 1
image = Utils.my_load_image("vatpham","monster.png")
self.image_frame = Utils.load_frame(image,0,0,89,89,0,self.num_frame)
elif self.item_name == Constant.BERRY_ITEM :
self.style = Constant.ADD
self.feature = Constant.ENERGY
self.num_frame = 1
image = Utils.my_load_image("vatpham","berry.png")
self.image_frame = Utils.load_frame(image,0,0,59,59,0,self.num_frame)
print len(self.image_frame)
self.image = self.image_frame[self.frame_index]
self.rect = self.image.get_rect()
self.rect.move_ip(x,y)
self.max_right = x + self.move_length
self.max_left = x - self.move_length
self.sound = Utils.load_sound('Ding.ogg')
self.pos_creep_screen = 0
