def merge_steps(flow_run, new_steps):
# In case of sub flows, new_steps won't contain steps from the previous flow.
steps = parse_complex_value(object_factory('step_type', FLOW_STEP_MAPPING),
flow_run.steps, True)
saved_step_ids = [step.step_id for step in steps]
for step in new_steps:
if step.step_id not in saved_step_ids:
steps.append(step)
return steps
def flow_member_result(rt_settings, request_id, message_flow_run_id, member,
steps, end_id, end_message_flow_id, parent_message_key,
tag, result_key, flush_id, flush_message_flow_id,
service_identity, user_details, flow_params, **kwargs):
user_details = log_and_parse_user_details(user_details)
steps = parse_complex_value(object_factory("step_type", FLOW_STEP_MAPPING),
steps, True)
f = FMR_TAG_MAPPING.get(parse_to_human_readable_tag(tag))
if not f:
logging.info('[tff] Ignoring flow_member_result with tag %s', tag)
return None
result = f(message_flow_run_id, member, steps, end_id, end_message_flow_id,
parent_message_key, tag, result_key, flush_id,
flush_message_flow_id, service_identity, user_details,
flow_params)
return result and serialize_complex_value(
result, FlowMemberResultCallbackResultTO, False, skip_missing=True)
def flow_member_result(rt_settings, request_id, message_flow_run_id, member, steps, end_id, end_message_flow_id,
parent_message_key, tag, result_key, flush_id, flush_message_flow_id, service_identity,
user_details, flow_params, timestamp, **kwargs):
user_details = log_and_parse_user_details(user_details)
steps = parse_complex_value(object_factory("step_type", FLOW_STEP_MAPPING), steps, True)
f = FMR_TAG_MAPPING.get(parse_to_human_readable_tag(tag))
should_process_flush = f and not flush_id.startswith('flush_monitoring')
result = None
try:
if should_process_flush:
logging.info('Processing flow_member_result with tag %s and flush_id %s', tag, flush_id)
result = f(message_flow_run_id, member, steps, end_id, end_message_flow_id, parent_message_key, tag,
result_key, flush_id, flush_message_flow_id, service_identity, user_details, flow_params)
return result and serialize_complex_value(result, FlowMemberResultCallbackResultTO, False,
skip_missing=True)
else:
logging.info('[tff] Ignoring flow_member_result with tag %s and flush_id %s', tag, flush_id)
finally:
deferred.defer(save_flow_statistics, parent_message_key, steps, end_id, tag, flush_id, flush_message_flow_id,
user_details[0], timestamp, result)
force_language=None, download_attachments_upfront=False, push_message=None, flow=None,
flow_params=None):
from rogerthat.bizz.service.mfr import start_local_flow as start_local_flow_bizz
from rogerthat.bizz.service import get_and_validate_service_identity_user
service_identity_user = get_and_validate_service_identity_user(users.get_current_user(), service_identity)
mm = _convert_to_member_users(service_identity_user, members)
return start_local_flow_bizz(service_identity_user, parent_message_key, xml, mm, tag, context, force_language,
download_attachments_upfront, push_message, None, flow, flow_params)
#############################################
# DO NOT DOCUMENT THIS SERVICE API FUNCTION #
# MFR ONLY #
@service_api(function=u"messaging.mfr_flow_member_result")
@returns(NoneType)
@arguments(message_flow_run_id=unicode, member=unicode, steps=[object_factory("step_type", FLOW_STEP_MAPPING)],
end_id=unicode, flush_id=unicode, parent_message_key=unicode, service_identity=unicode, results_email=bool,
email_admins=bool, emails=[unicode], message_flow_name=unicode, app_id=unicode)
def mfr_flow_member_result(message_flow_run_id, member, steps, end_id, flush_id, parent_message_key,
service_identity=None, results_email=False, email_admins=False, emails=None,
message_flow_name=None, app_id=None):
from rogerthat.bizz.service import get_and_validate_app_id_for_service_identity_user
svc_user = get_current_user()
azzert(svc_user.is_mfr)
if not service_identity or service_identity == MISSING:
service_identity = ServiceIdentity.DEFAULT
mfr = get_message_flow_run_record(svc_user, message_flow_run_id)
if not mfr:
return
from solutions.common.models.order import SolutionOrder, SolutionOrderWeekdayTimeframe
from solutions.common.models.properties import SolutionUser
from solutions.common.to import SolutionInboxMessageTO
from solutions.common.utils import create_service_identity_user_wo_default
try:
from cStringIO import StringIO
except ImportError:
from cStringIO import StringIO
@returns()
@arguments(service_user=users.User,
message_flow_run_id=unicode,
member=unicode,
steps=[object_factory("step_type", FLOW_STEP_MAPPING)],
end_id=unicode,
end_message_flow_id=unicode,
parent_message_key=unicode,
tag=unicode,
result_key=unicode,
flush_id=unicode,
flush_message_flow_id=unicode,
service_identity=unicode,
user_details=[UserDetailsTO])
def _order_received(service_user, message_flow_run_id, member, steps, end_id,
end_message_flow_id, parent_message_key, tag, result_key,
flush_id, flush_message_flow_id, service_identity,
user_details):
from solutions.common.bizz.messaging import send_inbox_forwarders_message
from solutions.common.bizz.loyalty import update_user_data_admins
from solutions.common.dal import get_solution_settings, get_solution_main_branding, \
get_solution_settings_or_identity_settings
from solutions.common.exceptions.sandwich import InvalidSandwichSettingsException
from solutions.common.models import SolutionInboxMessage
from solutions.common.models.properties import SolutionUser
from solutions.common.models.sandwich import SandwichType, SandwichTopping, \
SandwichOrder, SandwichOption, SandwichSettings
from solutions.common.to import SolutionInboxMessageTO
from solutions.common.utils import create_service_identity_user_wo_default
from solutions.flex import SOLUTION_FLEX
@returns(FlowMemberResultCallbackResultTO)
@arguments(service_user=users.User, message_flow_run_id=unicode, member=unicode,
steps=[object_factory("step_type", FLOW_STEP_MAPPING)], end_id=unicode, end_message_flow_id=unicode,
parent_message_key=unicode, tag=unicode, result_key=unicode, flush_id=unicode, flush_message_flow_id=unicode,
service_identity=unicode, user_details=[UserDetailsTO])
def order_sandwich_received(service_user, message_flow_run_id, member, steps, end_id, end_message_flow_id, parent_message_key,
tag, result_key, flush_id, flush_message_flow_id, service_identity, user_details):
type_ = get_first_fmr_step_result_value(steps, u'message_type')
topping = get_first_fmr_step_result_value(steps, u'message_topping')
customizations = get_first_fmr_step_result_value(steps, u'message_customize')
remark = get_first_fmr_step_result_value(steps, u'message_remark')
takeaway_time = get_first_fmr_step_result_value(steps, u'message_takeaway_time')
deferred.defer(process_sandwich_order, service_user, service_identity, user_details, type_, topping, customizations,
remark, takeaway_time, parent_message_key)
sln_settings = get_solution_settings(service_user)
main_branding = get_solution_main_branding(service_user)
from plugins.tff_backend.bizz.email import send_emails_to_support
from plugins.tff_backend.bizz.iyo.utils import get_iyo_username
from plugins.tff_backend.bizz.kyc import save_utility_bill, validate_kyc_status
from plugins.tff_backend.bizz.kyc.onfido_bizz import update_applicant, create_applicant, upload_document
from plugins.tff_backend.bizz.rogerthat import create_error_message
from plugins.tff_backend.bizz.user import get_tff_profile, generate_kyc_flow, set_kyc_status
from plugins.tff_backend.models.user import KYCStatus
from plugins.tff_backend.plugin_consts import KYC_FLOW_PART_2_TAG, SCHEDULED_QUEUE
from plugins.tff_backend.to.user import SetKYCPayloadTO
from plugins.tff_backend.utils import get_step
@returns(FlowMemberResultCallbackResultTO)
@arguments(message_flow_run_id=unicode,
member=unicode,
steps=[object_factory('step_type', FLOW_STEP_MAPPING)],
end_id=unicode,
end_message_flow_id=unicode,
parent_message_key=unicode,
tag=unicode,
result_key=unicode,
flush_id=unicode,
flush_message_flow_id=unicode,
service_identity=unicode,
user_details=[UserDetailsTO],
flow_params=unicode)
def kyc_part_1(message_flow_run_id, member, steps, end_id, end_message_flow_id,
parent_message_key, tag, result_key, flush_id,
flush_message_flow_id, service_identity, user_details,
flow_params):
iyo_username = get_iyo_username(user_details[0])
FLOW_HOSTER_REMINDER, SCHEDULED_QUEUE, FLOW_UTILITY_BILL_RECEIVED, FF_ENDED_TIMESTAMP
from plugins.tff_backend.to.investor import InvestmentAgreementTO, InvestmentAgreementDetailsTO, \
CreateInvestmentAgreementTO
from plugins.tff_backend.utils import get_step_value, round_currency_amount, get_key_name_from_key_string, get_step
from plugins.tff_backend.utils.app import create_app_user_by_email, get_app_user_tuple
INVESTMENT_TODO_MAPPING = {
InvestmentAgreement.STATUS_CANCELED: None,
InvestmentAgreement.STATUS_CREATED: InvestorSteps.FLOW_AMOUNT,
InvestmentAgreement.STATUS_SIGNED: InvestorSteps.PAY,
InvestmentAgreement.STATUS_PAID: InvestorSteps.ASSIGN_TOKENS,
}
@returns(FlowMemberResultCallbackResultTO)
@arguments(message_flow_run_id=unicode, member=unicode, steps=[object_factory("step_type", FLOW_STEP_MAPPING)],
end_id=unicode, end_message_flow_id=unicode, parent_message_key=unicode, tag=unicode, result_key=unicode,
flush_id=unicode, flush_message_flow_id=unicode, service_identity=unicode, user_details=[UserDetailsTO],
flow_params=unicode)
def invest_tft(message_flow_run_id, member, steps, end_id, end_message_flow_id, parent_message_key, tag, result_key,
flush_id, flush_message_flow_id, service_identity, user_details, flow_params):
return invest(message_flow_run_id, member, steps, end_id, end_message_flow_id, parent_message_key, tag, result_key,
flush_id, flush_message_flow_id, service_identity, user_details, flow_params, TOKEN_TFT)
@returns(FlowMemberResultCallbackResultTO)
@arguments(message_flow_run_id=unicode, member=unicode, steps=[object_factory("step_type", FLOW_STEP_MAPPING)],
end_id=unicode, end_message_flow_id=unicode, parent_message_key=unicode, tag=unicode, result_key=unicode,
flush_id=unicode, flush_message_flow_id=unicode, service_identity=unicode, user_details=[UserDetailsTO],
flow_params=unicode)
def invest_itft(message_flow_run_id, member, steps, end_id, end_message_flow_id, parent_message_key, tag, result_key,
from rogerthat.bizz.messaging import message_received
message_received(user, get_message_key(request.message_key, request.message_parent_key), request.received_timestamp)
@rest("/mobi/rest/messaging/get", "get")
@returns(RootMessageListTO)
@arguments(cursor=unicode)
def getMessages(cursor):
from rogerthat.rpc import users
user = users.get_current_user()
result = RootMessageListTO()
result.messages, result.cursor = _get_messages(cursor, user)
result.batch_size = MESSAGES_BATCH_SIZE
return result
@rest("/mobi/rest/messaging/get_single", "post")
@returns(object_factory("message_type", MESSAGE_TYPE_TO_MAPPING))
@arguments(message_key=unicode, parent_message_key=unicode)
def getSingleMessage(message_key, parent_message_key):
from rogerthat.rpc import users
user = users.get_current_user()
message = get_message(message_key, parent_message_key)
return _convert_to_tos(user, [message])[0]
@rest("/mobi/rest/messaging/get_root_message", "get")
@returns(object_factory("message_type", ROOT_MESSAGE_TYPE_TO_MAPPING))
@arguments(message_key=unicode)
def getRootMessage(message_key):
from rogerthat.rpc import users
user = users.get_current_user()
messages = get_root_message(user, message_key)
member = user if not messages[0].sharedMembers and messages[0].sender != user else None
def trans():
sln_l_settings = SolutionLoyaltySettings.get_by_user(service_user)
if is_default_service_identity(service_identity):
sln_li_settings = sln_l_settings
else:
sln_li_settings = SolutionLoyaltyIdentitySettings.get_by_user(service_user, service_identity)
return sln_l_settings, sln_li_settings
xg_on = db.create_transaction_options(xg=True)
sln_l_settings, sln_li_settings = db.run_in_transaction_options(xg_on, trans)
return LoyaltySettingsTO.fromSolutionLoyaltySettingsObject(sln_l_settings, sln_li_settings, loyalty_type) if sln_l_settings else None
@rest("/common/loyalty/settings/put", "post")
@returns(ReturnStatusTO)
@arguments(loyalty_type=(int, long), loyalty_settings=object_factory("loyalty_type", LOYALTY_SETTINGS_MAPPING), loyalty_website=unicode)
def put_loyalty_settings(loyalty_type, loyalty_settings, loyalty_website):
service_user = users.get_current_user()
try:
def trans(loyalty_type):
sln_settings = get_solution_settings(service_user)
if SolutionModule.HIDDEN_CITY_WIDE_LOTTERY in sln_settings.modules:
loyalty_type = SolutionLoyaltySettings.LOYALTY_TYPE_CITY_WIDE_LOTTERY
sln_settings.updates_pending = True
sln_loyalty_settings = SolutionLoyaltySettings.get_by_user(service_user)
if sln_loyalty_settings.loyalty_type != loyalty_type:
sln_loyalty_settings.branding_key = None
sln_settings.loyalty_branding_hash = None
sln_loyalty_settings.loyalty_type = loyalty_type
while True:
if z == 0:
start_y = 1
else:
start_y = 0
for y in range(start_y, 3):
for x in range(start_x, 4):
if [x, y, z] not in all_taken_coords:
spots_to_get = spots_to_get - 1
spots.append([x, y, z])
if not spots_to_get > 0:
return spots
z += 1
@arguments(steps=[object_factory("step_type", FLOW_STEP_MAPPING)],
step_id=unicode)
def get_first_fmr_step_result_value(steps, step_id):
for step in steps:
if step.step_id == step_id:
return step.get_value()
return None
@returns(unicode)
@arguments(src=unicode, path=unicode, default_css=unicode)
def create_pdf(src, path, default_css=None):
"""
Args:
src: The source to be parsed. This can be a file handle or a String - or even better - a Unicode object.