def user(phone_number):
new_user = User(
uuid=generate_uuid(),
email='a@a',
email_confirmed=True,
username='******',
name='bob',
dob='1/1/1991',
password_hash=generate_password_hash('pass'),
secondary_password_hash=generate_password_hash('1234'),
is_suspended=False,
phone_id=phone_number.id,
bank_name='bankbankbank',
bank_account_number='123-456',
bank_account_holder='bob',
balance=1000000,
pending_commissions=0,
payable_commissions=0,
created_at=datetime(2000, 1, 1, 0, 5, 10),
role=UserRole.HQ,
partner_name="partner bob",
partner_referral_code="test123",
)
db.session.add(new_user)
db.session.commit()
yield new_user
def user_ru(phone_number_ru, user_f):
u = User(
uuid=generate_uuid(),
email='ru@ru',
email_confirmed=True,
username='******',
name='ruru',
dob='1/1/1991',
password_hash=generate_password_hash('pass'),
secondary_password_hash=generate_password_hash('1234'),
is_suspended=False,
referring_user_id=user_f.id,
phone_id=phone_number_ru.id,
bank_name='rubonk',
bank_account_number='654-321',
bank_account_holder='ru',
balance=1000000,
pending_commissions=0,
payable_commissions=0,
created_at=datetime(2000, 1, 1, 0, 5, 10),
role=UserRole.REGULAR_USER,
)
db.session.add(user_ru)
db.session.commit()
yield user_ru
def create_template(name, img):
"""Adds this template to the datastore along with a generated
thumbnail and accompanied dimension metadata"""
thumb = Image(img)
template_data = Image(img)
t_img = db.Blob(img)
width, height = template_data.width, template_data.height
if width != 500:
template_data.resize(width=500)
template_data = template_data.execute_transforms()
t_data = Image(template_data)
width, height = t_data.width, t_data.height
t_img = db.Blob(template_data)
thumb.resize(height=125)
thumb = thumb.execute_transforms(quality=75,output_encoding=JPEG)
t = Template(uid=generate_uuid(16),
name=name,
img=t_img,
thumb=db.Blob(thumb),
real_width=width,
real_height=height)
t.put()
def register(tokens, sender_number):
"""
Complete user registration.
Expected msg format: 'register [new pin] [new pin]'
"""
messages = []
new_pin = tokens[1]
new_pin_confirm = tokens[2]
if new_pin != new_pin_confirm:
msg = "the pins entered are not the same. please try again"
sms = OutgoingMessage(body=msg, receiver=sender_number,
timestamp=time.time())
messages.append(sms)
return send_sms(messages)
try:
user = User.objects.get(phone=sender_number)
user.pin_salt = util.generate_uuid()
user.pin = hashlib.md5(new_pin + user.pin_salt).hexdigest()
user.save()
msg = ("Your registration has been completed. Send '[balance] [pin]' to"
" check your available balance.")
sms = OutgoingMessage(body=msg, receiver=user.phone,
timestamp=time.time(), type='complete_reg')
messages.append(sms)
return send_sms(messages)
except User.DoesNotExist:
return msg_user_does_not_exist(sender_number)
def __init__(self,uuid=None):
'''
@param {_CommitManager} commit_manager --- When we either want
to commit or backout the changes that the invalidation
listener makes to its objs_touched, do so through _CommitManager
@param {uuid} uuid --- If uuid is None, generates a new uuid.
Otherwise, uses old one.
'''
# keeps track of all objects that were read/written to during
# the course of this event. we distinguish two types of
# objects during the course of completing a commit. The first
# is a priority object. We will run complete commit on all of
# these before running complete commit on the lower priority
# objects. The reason for distinguishing objects into high
# and low priority tiers is that some objects may wrap
# additional data. For instance, a folder map object may wrap
# many files. At commit time, we want to serialize the
# changes to a variable so that can replay those changes on
# the file system. However, for this to work, we need to
# ensure that the folder object is complete_commit-ed before
# any of the subfiles are.
self.priority_touched_objs = {}
self.objs_touched = {}
self.peered_modified = False
if uuid == None:
uuid = util.generate_uuid()
self.uuid = uuid
def user_sd(phone_number_sd, user_1):
u = User(
uuid=generate_uuid(),
email='sd@sd',
email_confirmed=True,
username='******',
name='sdsd',
dob='1/1/1991',
password_hash=generate_password_hash('pass'),
secondary_password_hash=generate_password_hash('1234'),
is_suspended=False,
referring_user_id=user_1.id,
phone_id=phone_number_sd.id,
bank_name='sdbonk',
bank_account_number='654-321',
bank_account_holder='sd',
balance=1000000,
pending_commissions=0,
payable_commissions=0,
created_at=datetime(2000, 1, 1, 0, 5, 10),
role=UserRole.SOLE_DISTRIBUTOR,
)
db.session.add(user_sd)
db.session.commit()
yield user_sd
def cashout(tokens, sender_number):
"""
Generate cashout ticket
Expected Format: 'cashout [amount] [pin]'
"""
messages = []
try:
amount = float(tokens[1])
pin = tokens[2]
user = User.objects.get(phone=sender_number)
if not account_activated(user):
return msg_account_not_activated(user.phone)
if not validate_pin(user, pin):
return msg_invalid_pin(user.phone)
# check account balance
if amount > (user.balance - 100):
msg = ("You do not have enough balance to cashout.")
sms = OutgoingMessage(body=msg, receiver=sender_number,
timestamp=time.time(),
type='insufficient_balance')
messages.append(sms)
return send_sms(messages)
if amount > 3000:
msg = ("You cannot cashout above NGN3,000 in one transaction."
" Please try again.")
sms = OutgoingMessage(body=msg, receiver=sender_number,
timestamp=time.time(), type='excess_cashout')
messages.append(sms)
return send_sms(messages)
transaction = Transaction(
id=util.generate_uuid()[0:12], sender=user.phone,
receiver=user.phone, timestamp=time.time(), amount=amount,
type='user_cashout')
# return message to confirm transaction
msg = ("transaction-id: %s, amount: %s, type: cashout. Please"
" reply this message with 'confirm' to confirm this"
" transaction." % (transaction.id, transaction.amount))
sms = OutgoingMessage(body=msg, receiver=sender_number,
timestamp=time.time(), meta=transaction,
type='confirm_transaction')
messages.append(sms)
return send_sms(messages)
except User.DoesNotExist:
return msg_user_does_not_exist(sender_number)
except IndexError:
expected_format = ("Unkown message format. Expected message format:"
" 'cashout [amount] [pin]'")
return msg_unknown_format(expected_format, sender_number)
return None
def __init__(self,waldo_classes,host_uuid,conn_obj,global_var_store):
'''
@param {dict} waldo_classes --- Contains common utilities
needed by emitted code, such as WaldoNumVariable
@param {uuid} host_uuid --- The uuid of the host this endpoint
lives on.
@param {ConnectionObject} conn_obj --- Used to write messages
to partner endpoint.
@param {_VariableStore} global_var_store --- Contains the
peered and endpoint global data for this endpoint. Will not
add or remove any peered or endpoint global variables. Will
only make calls on them.
'''
self._uuid = util.generate_uuid()
self._endpoint_uuid_str = str(self._uuid)
self._waldo_classes = waldo_classes
self._act_event_map = waldoActiveEventMap._ActiveEventMap(self)
self._conn_obj = conn_obj
# whenever we create a new _ExecutingEvent, we point it at
# this variable store so that it knows where it can retrieve
# variables.
self._global_var_store = global_var_store
self._endpoint_service_thread = waldoEndpointServiceThread._EndpointServiceThread(self)
self._endpoint_service_thread.start()
self._host_uuid = host_uuid
self._signal_queue = Queue.Queue()
# When go through first phase of commit, may need to forward
# partner's endpoint uuid back to the root, so the endpoint
# needs to keep track of its partner's uuid. FIXME: right
# now, manually setting partner uuids in connection object.
# And not checking to ensure that the partner endpoint is set
# before doing additional work. should create a proper
# handshake instead.
self._partner_uuid = None
# both sides should run their onCreate methods to entirety
# before we can execute any additional calls.
self._ready_lock_ = threading.Lock()
self._this_side_ready_bool = False
self._other_side_ready_bool = False
self._ready_waiting_list_mutex = threading.Lock()
self._ready_waiting_list = []
self._conn_obj.register_endpoint(self)
def run_test():
start = time.time()
for i in range(0,NUM_ITERATIONS):
# u = buuid.uuid4()
u = util.generate_uuid()
elapsed = time.time() - start
print '\n\n'
print elapsed
print '\n\n'
def run_test():
start = time.time()
for i in range(0, NUM_ITERATIONS):
# u = buuid.uuid4()
u = util.generate_uuid()
elapsed = time.time() - start
print '\n\n'
print elapsed
print '\n\n'
def add_user():
"""
添加用户
:return:
"""
user_uid = generate_uuid('user')
print(111111111111111)
kv = request.get_json(force=True)
print(kv)
kv['user_uid'] = user_uid
ticket.add_user(**kv)
def __init__(self,host_uuid,peered,init_val,version_obj):
'''
@param {bool} peered --- True if this variable is a piece of
sequence local data. False if it's just a regular-old local
variable.
'''
self.host_uuid = host_uuid
self.uuid = util.generate_uuid()
self.val = init_val
self.version_obj = version_obj
self.peered = peered
def simulate(self, max_turns=None, verbose=False):
'''
Simulate a dialogue.
'''
self.events = []
self.max_turns = max_turns
time = 0
num_turns = 0
game_over = False
self.describe_scenario()
if random.random() < 0.5:
first_speaker = 0
else:
first_speaker = 1
while not game_over:
for agent, session in enumerate(self.sessions):
if num_turns == 0 and agent != first_speaker:
continue
event = session.send()
time += 1
if not event:
continue
event.time = time
self.event_callback(event)
self.events.append(event)
if verbose:
print('agent=%s: session=%s, event=%s' %
(agent, type(session).__name__, event.to_dict()))
else:
action = event.action
data = event.data
event_output = data if action == 'message' else "Action: {0}, Data: {1}".format(
action, data)
print('agent=%s, event=%s' % (agent, event_output))
num_turns += 1
if self.game_over() or (max_turns and num_turns >= max_turns):
game_over = True
break
for partner, other_session in enumerate(self.sessions):
if agent != partner:
other_session.receive(event)
uuid = generate_uuid('E')
outcome = self.get_outcome()
if verbose:
print('outcome: %s' % outcome)
print('----------------')
# TODO: add configurable names to systems and sessions
agent_names = {'0': self.session_names[0], '1': self.session_names[1]}
return Example(self.scenario, uuid, self.events, outcome, uuid,
agent_names)
def add_subway_line(subway_line_name):
if line_exist(subway_line_name, "name"):
raise STPHTTPException("subway line %s has been exist." %
subway_line_name,
403,
10200)
uuid = util.generate_uuid(uuid_type="upper")
db.line.add_subway_line(uuid, subway_line_name)
new_line = compute.line.Line(uuid=uuid, name=subway_line_name)
compute.line.lines[subway_line_name] = new_line
return
def update_model(self, form, model):
form_data = form.data
try:
original_model_json = model.to_json()
# referring_user can't be in the column_editable_list because it's not supported for inline edits.
for editable_column in self.column_editable_list + ['referring_user', 'username']:
if editable_column in form_data:
setattr(model, editable_column, form_data[editable_column])
if form.role.data != UserRole.FRANCHISEE.value:
assert model.owned_promotion is None and form_data['owned_promotion'] is None
# TODO: check to make sure a promotion isn't being taken away from another user
if form.password.data != '': # reset password if new password entered
assert isinstance(form.password.data, str), form.password.data
model.uuid = generate_uuid() # log the user out of all existing sessions
model.password_hash = generate_password_hash(form.password.data)
logger.info(f'User update by admin {auth_get_current_username()} was a password reset for {model}')
if form.secondary_password.data != '': # reset secondary password if new secondary password entered
assert isinstance(form.secondary_password.data, str), form.secondary_password.data
model.uuid = generate_uuid() # log the user out of all existing sessions
model.secondary_password_hash = generate_password_hash(form.secondary_password.data)
logger.info(f'User update by admin {auth_get_current_username()} was a secondary password reset for {model}')
if form.is_suspended.data != model.is_suspended: # user suspended or unsuspended
assert isinstance(form.is_suspended.data, bool), form.is_suspended.data
model.uuid = generate_uuid() # log the user out of all existing sessions
if form.owned_promotion.data:
model.owned_promotion_id = form.owned_promotion.data.id
model.assert_hierarchy()
self.session.add(model)
self.session.commit()
caching.set_user(model)
logger.info(f'User updated by admin {auth_get_current_username()}: {original_model_json} -> {model.to_json()}')
except Exception as ex:
self.session.rollback()
flash(f'Failed to update user. {str(ex)}', 'error')
logger.exception(f'User update by admin {auth_get_current_username()} raised exception')
return False
return True
def __init__(self,uuid=None):
'''
@param {_CommitManager} commit_manager --- When we either want
to commit or backout the changes that the invalidation
listener makes to its objs_touched, do so through _CommitManager
@param {uuid} uuid --- If uuid is None, generates a new uuid.
Otherwise, uses old one.
'''
self.objs_touched = {}
self.peered_modified = False
if uuid == None:
uuid = util.generate_uuid()
self.uuid = uuid
def __init__(
self,host_uuid,peered,init_val,version_obj,
dirty_element_constructor):
self.host_uuid = host_uuid
self.uuid = util.generate_uuid()
self.version_obj = version_obj
self.peered = peered
self.val = init_val
self.dirty_element_constructor = dirty_element_constructor
self.notification_map = waldoNotificationMap._NotificationMap(
self.uuid,self.host_uuid)
# keys are uuids. values are dirty values of each object.
self._dirty_map = {}
self._mutex = threading.Lock()
def change_pin(tokens, sender_number):
"""
Change user pin number
Expected message format: 'change pin [old pin] [new pin] [new pin]'
"""
messages = []
try:
old_pin = tokens[2]
new_pin = tokens[3]
new_pin_confirm = tokens[4]
user = User.objects.get(phone=sender_number)
if not account_activated(user):
return msg_account_not_activated(user.phone)
if not validate_pin(user, old_pin):
return msg_invalid_pin(user.phone)
if new_pin != new_pin_confirm:
msg = ("The pin entered are not the same. please try again."
" Format: 'change pin [old pin] [new pin] [new pin]'")
sms = OutgoingMessage(body=msg, receiver=sender_number,
timestamp=time.time())
messages.append(sms)
return send_sms(messages)
user.pin_salt = util.generate_uuid()
user.pin = hashlib.md5(new_pin + user.pin_salt).hexdigest()
user.save()
msg = ("Your pin has been successfully changed.")
sms = OutgoingMessage(body=msg, receiver=sender_number,
timestamp=time.time(), type='change_pin')
messages.append(sms)
return send_sms(messages)
except User.DoesNotExist:
return msg_user_does_not_exist(sender_number)
except IndexError:
expected_format = ("Unknow message format. Expected format. 'change pin"
"[old pin] [new pin] [new pin]'")
return msg_unknown_format(expected_format, sender_number)
def init_user():
engine, cursor = db.engine.get_engine()
sql = """
create table if not exists user(
uuid char(27) not null,
email varchar(30),
username varchar(24) default "subway user",
password varchar(18) not null,
token char(10) not null,
user_type enum("admin", "user") not null default "user",
create_time datetime not null,
status enum("active", "down", "lock") not null default "active",
image varchar(100),
primary key(email)
) charset utf8
"""
cursor.execute(sql)
logger.info("Setup user finished.")
# add admin user
conf_path = util.get_root_path() + "/conf/platform.conf"
deploy_conf = ConfigParser()
deploy_conf.read([conf_path])
uuid = util.generate_uuid()
admin_user = deploy_conf.get("deploy", "admin_user")
admin_pwd = deploy_conf.get("deploy", "admin_pwd")
email = deploy_conf.get("deploy", "admin_email")
image = "/root/image/localhost/default.jpeg"
try:
get_user_detail(email)
except DBError:
now = util.get_time_string_format()
token = util.general_token()
user_type = "admin"
sql = "insert into user " \
"values(%s, %s, %s, %s, %s, %s, %s, default, %s)"
val = (uuid, email, admin_user, admin_pwd, token, user_type, now,
image)
cursor.execute(sql, val)
logger.info("Init default admin user success.")
engine.commit()
engine.close()
return
def add_entry(self, data_entry):
#import pdb; pdb.set_trace()
date = datetime.date.fromtimestamp(eval(data_entry['time_in']))
query = {'camera_id' : data_entry['camera_id'],
'date_in' : str(date),
'item_name' : data_entry['item_name']}
same_entry = entriesdb.find_entry(query)
document = query
if same_entry == None:
print document
document['count'] = data_entry['count'] if data_entry.has_key('count') else 1
document['id'] = util.generate_uuid()
document['time_in'] = data_entry['time_in']
entriesdb.insert_entry(document)
else:
same_entry['count'] += data_entry['count'] if data_entry.has_key('count') else 1
entriesdb.update_entry({'id' : same_entry['id']}, same_entry)
def simulate(self, max_turns=100):
'''Simulate the dialogue.'''
self.events = []
time = 0
self.selections = [None, None]
self.reward = 0
num_turns = 0
timeup = False
while True:
for agent, session in enumerate(self.sessions):
event = session.send()
time += 1
if not event:
continue
event.time = time
self.events.append(event)
if event.action == 'select':
self.selections[agent] = event.data
print 'agent=%s: session=%s, event=%s' % (
agent, type(session).__name__, event.to_dict())
num_turns += 1
if num_turns >= max_turns:
timeup = True
for partner, other_session in enumerate(self.sessions):
if agent != partner:
other_session.receive(event)
# Game is over when the two selections are the same
if self.game_over():
self.reward = 1
break
if self.game_over() or timeup:
break
uuid = generate_uuid('E')
outcome = {'reward': self.reward}
print 'outcome: %s' % outcome
return Example(self.scenario, uuid, self.events, outcome, uuid, None)
def create_model(self, form):
form_data = form.data
try:
if form.password.data == '':
raise Exception('Password cannot be empty')
if form.secondary_password.data == '':
raise Exception('Secondary password cannot be empty')
if not isinstance(form.phone.data, PhoneNumber):
raise Exception('Phone field must be a PhoneNumber object')
model = User(
uuid=generate_uuid(),
username=form.username.data,
phone_id=form.phone.data.id,
password_hash=generate_password_hash(form.password.data),
email_confirmed=True,
agree_receive_email=True,
agree_receive_text=True,
pending_commissions=0,
payable_commissions=0,
secondary_password_hash=generate_password_hash(form.secondary_password.data),
referring_user_id=form.referring_user.data.id if form.referring_user.data else None,
owned_promotion_id=form.owned_promotion.data.id if form.owned_promotion.data else None,
)
for editable_column in self.column_editable_list:
if editable_column in form_data:
setattr(model, editable_column, form_data[editable_column])
# auto confirm email for partners
if model.role != UserRole.REGULAR_USER.value:
model.email_confirmed = True
model.assert_hierarchy()
self.session.add(model)
self.session.commit()
caching.set_user(model)
logger.info(f'User create by admin {auth_get_current_username()}: {model.to_json()}')
except Exception as ex:
self.session.rollback()
flash(f'Failed to create user. {str(ex)}', 'error')
logger.exception(f'User create by admin {auth_get_current_username()} raised exception')
return False
return True
def __init__(self):
self._mutex = threading.Lock()
self._uuid = util.generate_uuid()
self._stopped = False
]
issue_jrds_trace(16000, u_activity_id, 0, cloud_trace_format)
def issue_jrds_trace(event_id, activity_id, log_type, arg_array):
jrds_client.set_log(event_id, activity_id, log_type, map(str, arg_array))
def dict_to_str(input_dict):
output_str = ""
for key, value in input_dict.iteritems():
output_str = output_str + "[" + str(key) + "=" + str(value) + "]"
return output_str
u_activity_id = util.generate_uuid()
COMPONENT_SANDBOX = "Sandbox"
COMPONENT_WORKER = "Worker"
KEYWORD_DEBUG = "Debug"
KEYWORD_INFO = "Info"
KEYWORD_ERROR = "Error"
KEYWORD_WARNING = "Warning"
KEYWORD_STARTUP = "Startup"
KEYWORD_ROUTINE = "Routine"
KEYWORD_JOB = "Job"
KEYWORD_RUNTIME = "Runtime"
KEYWORD_CONFIGURATION = "Configuration"
KEYWORD_TELEMETRY = "Telemetry"
message]
issue_jrds_trace(16000, activity_id, 0, cloud_trace_format)
def issue_jrds_trace(event_id, activity_id, log_type, arg_array):
jrds_client.set_log(event_id, activity_id, log_type, map(str, arg_array))
def dict_to_str(input_dict):
output_str = ""
for key, value in input_dict.iteritems():
output_str = output_str + "[" + str(key) + "=" + str(value) + "]"
return output_str
u_activity_id = util.generate_uuid()
COMPONENT_SANDBOX = "Sandbox"
COMPONENT_WORKER = "Worker"
KEYWORD_DEBUG = "Debug"
KEYWORD_INFO = "Info"
KEYWORD_ERROR = "Error"
KEYWORD_WARNING = "Warning"
KEYWORD_STARTUP = "Startup"
KEYWORD_ROUTINE = "Routine"
KEYWORD_JOB = "Job"
KEYWORD_RUNTIME = "Runtime"
KEYWORD_RUNBOOK = "Runbook"
KEYWORD_CONFIGURATION = "Configuration"
KEYWORD_TELEMETRY = "Telemetry"
import util
import waldoConnectionObj
from util import Queue
import wVariables
import waldoCallResults
import waldoEndpoint
import waldoExecutingEvent
import waldoVariableStore
import shim.get_math_endpoint
import waldoReferenceBase
StoppedException = util.StoppedException
_host_uuid = util.generate_uuid()
_threadsafe_stoppable_cleanup_queue = Queue.Queue()
_waldo_classes = {
# waldo variables
'WaldoNumVariable': wVariables.WaldoNumVariable,
'WaldoTextVariable': wVariables.WaldoTextVariable,
'WaldoTrueFalseVariable': wVariables.WaldoTrueFalseVariable,
'WaldoMapVariable': wVariables.WaldoMapVariable,
'WaldoListVariable': wVariables.WaldoListVariable,
'WaldoUserStructVariable': wVariables.WaldoUserStructVariable,
'WaldoFunctionVariable': wVariables.WaldoFunctionVariable,
'WaldoEndpointVariable': wVariables.WaldoEndpointVariable,
'WaldoExtNumVariable': wVariables.WaldoExtNumVariable,
'WaldoExtTrueFalseVariable': wVariables.WaldoExtTrueFalseVariable,
def transfer_funds(tokens, sender_number):
"""
Transfer funds to user or non-user
Expected format: 'transfer [amount] [receiver] [pin]'
transaction limit: NGN3,000
daily transaction limit: NGN30,000
"""
messages = []
try:
amount = float(tokens[1])
receiver_number = tokens[2]
pin = tokens[3]
user = User.objects.get(phone=sender_number)
if not validate_pin(user, pin):
return msg_invalid_pin(user.phone)
if not account_activated(user):
return msg_account_not_activated(user.phone)
# check account balance
if amount > (user.balance - 100):
msg = ("You do not have enough balance to make this transfer.")
sms = OutgoingMessage(body=msg, receiver=sender_number,
timestamp=time.time(),
type='insufficient_balance')
messages.append(sms)
return send_sms(messages)
if amount > 3000:
msg = ("You cannot transfer above NGN3,000 in one transaction."
" Please try again.")
sms = OutgoingMessage(body=msg, receiver=sender_number,
timestamp=time.time(), type='excess_transfer')
messages.append(sms)
return send_sms(messages)
# add restriction of daily limit of 3ok
# validate receiver exists
# if not generate cash out ticket instead
transaction = Transaction(
id=util.generate_uuid()[0:12], sender=user.phone,
receiver=receiver_number, timestamp=time.time(), amount=amount)
try:
User.objects.get(phone=receiver_number)
transaction.type = 'user_to_user_transfer'
except User.DoesNotExist:
transaction.type = 'user_to_guest_transfer'
transaction.save()
# return message to confirm transaction
msg = ("transaction-id: %s, amount: %s, receiver: %s. Please"
" reply this message with 'confirm' to confirm this"
" transaction."
% (transaction.id, transaction.amount, transaction.receiver))
sms = OutgoingMessage(body=msg, receiver=sender_number,
timestamp=time.time(), meta=transaction,
type='confirm_transaction')
messages.append(sms)
return send_sms(messages)
except User.DoesNotExist:
return msg_user_does_not_exist(sender_number)
except IndexError:
expected_format = ("Unknown message format. Expeted format: transfer"
" [amount] [receiver] [pin]. Please try again.")
return msg_unknown_format(expected_format, sender_number)
def confirm_transaction(transaction):
messages = []
if transaction.type == 'user_to_user_transfer':
receiver = User.objects.get(phone=transaction.receiver)
sender = User.objects.get(phone=transaction.sender)
receiver.balance = receiver.balance + transaction.amount
sender.balance = sender.balance - transaction.amount
transaction.status = 'complete'
receiver.save()
sender.save()
transaction.save()
# send confirmation to both parties
# receiver's notification
msg = ("NGN%s has been successfully transferred from the account "
" of %s to you. Your new balance is NGN%s. Thank you for using Mopay."
% (transaction.amount, transaction.sender, receiver.balance))
sms = OutgoingMessage(body=msg, receiver=transaction.receiver,
timestamp=time.time(),
type='transfer_notif_receiver_completed')
messages.append(sms)
# sender's notification
msg = ("You have successfully transferred NGN%s to %s. Your new"
" balance is NGN%s. Thank you for using Mopay."
% (transaction.amount, transaction.receiver, sender.balance))
sms = OutgoingMessage(body=msg, receiver=transaction.sender,
timestamp=time.time(),
type='transfer_notif_sender_completed')
messages.append(sms)
return send_sms(messages)
elif transaction.type == 'user_to_guest_transfer':
sender = User.objects.get(phone=transaction.sender)
sender.balance = sender.balance - transaction.amount
cashout_ticket = CashoutTicket(
id=util.generate_uuid()[0:15],sender=sender.phone,
receiver=transaction.receiver,transaction=transaction,
timestamp=time.time())
cashout_ticket.save()
transaction.status = 'generated_guest_cashout'
sender.save()
transaction.save()
# send notifications
# receiver's notification.
msg = ("NGN%s has been sent to you from the account of %s via mopay."
" Ticket-ID: %s. Please go to the nearest mopay agent to"
" retrieve."
% (transaction.amount, transaction.sender, cashout_ticket.id))
sms = OutgoingMessage(body=msg, receiver=transaction.receiver,
timestamp=time.time(),
type='notif_receiver_transfer_cashout')
messages.append(sms)
# sender's notificationDoesNotExist
msg = ("You have sent NGN%s to %s. Thank you for using mopay."
% (transaction.amount, transaction.receiver))
sms = OutgoingMessage(body=msg, receiver=transaction.sender,
timestamp=time.time(),
type='notif_sender_cashout_gen')
messages.append(sms)
return send_sms(messages)
elif transaction.type == 'user_cashout':
sender = User.objects.get(phone=transaction.sender)
sender.balance = sender.balance - transaction.amount
cashout_ticket = CashoutTicket(
id=util.generate_uuid()[0:15],sender=sender.phone,
receiver=transaction.receiver,transaction=transaction,
timestamp=time.time())
cashout_ticket.save()
transaction.status = 'cashout_ticket_generated'
sender.save()
transaction.save()
msg = ("NGN%s been deducted from your account for a cashout ticket."
" Ticket-ID: %s. Please go to the nearest mopay agent to"
" retrieve." % (transaction.amount, cashout_ticket.id))
sms = OutgoingMessage(body=msg, receiver=transaction.receiver,
timestamp=time.time(),
type='notif_receiver_transfer_cashout')
messages.append(sms)
return send_sms(messages)