def create_order(self, form_data):
order = self.data_store.order.get(form_data['order_queue_id'])
if isinstance(order, FakeUbersmithError):
self.logger.info("Creating order failed")
return response(error_code=order.code, message=order.message)
self.logger.info("Creating order: {}".format(order))
return response(data=order)
def client_cc_delete(self, form_data):
if isinstance(self.credit_card_delete_response, FakeUbersmithError):
return response(
error_code=self.credit_card_delete_response.code,
message=self.credit_card_delete_response.message
)
return response(data=True)
def service_plan_get(self, form_data):
if isinstance(self.service_plan_error, FakeUbersmithError):
self.logger.info("Error retrieving service plan")
return response(
error_code=self.service_plan_error.code,
message=self.service_plan_error.message
)
service_plan = next(
(
plan for plan in self.data_store.service_plans
if plan["plan_id"] == form_data["plan_id"]
),
None
)
if service_plan is not None:
self.logger.info("Service plan found: {}".format(service_plan))
return response(data=service_plan)
else:
self.logger.error("Service plan not found.")
return response(
error_code=3,
message="No Service Plan found"
)
def acl_resource_add(self, form_data):
parent_resource_name = form_data.get('parent_resource_name', '')
resource_name = form_data.get('resource_name', '')
label = form_data.get('label', '')
actions = form_data.get('actions', 'create,read,update,delete')
self.logger.info("Adding role {}; {}; {}; {}".format(parent_resource_name, resource_name, label, actions))
if not parent_resource_name:
parent_resource_id = "0"
target_resource_dict = self.data_store.acl_resources
else:
parent_resource = self._find_acl_parent(self.data_store.acl_resources, parent_resource_name)
if parent_resource is None:
return response(error_code=1, message="Resource [{}] not found".format(parent_resource_name))
parent_resource_id = parent_resource["resource_id"]
target_resource_dict = parent_resource["children"]
self.data_store.acl_resources_inc_id += 1
target_resource_dict[str(self.data_store.acl_resources_inc_id)] = {
"resource_id": str(self.data_store.acl_resources_inc_id),
"name": resource_name,
"parent_id": parent_resource_id,
"lft": "0",
"rgt": "0",
"active": "1",
"label": label,
"actions": self._to_acl_actions(actions),
"children": {}
}
return response(data="")
def acl_admin_role_get(self, form_data):
user_id = form_data.get('userid')
role_id = str(form_data.get('role_id', ''))
if not role_id:
return response(
error_code=1,
message="role_id parameter not specified"
)
if user_id:
self.logger.info(user_id)
self.logger.info(self.data_store.user_mapping)
self.logger.info(self.data_store.roles)
self.logger.info(self.data_store.user_mapping.get(user_id, {}))
role_ids = self.data_store.user_mapping.get(user_id, {}).get(
'roles'
)
self.logger.info(role_ids)
if not role_ids:
return response(error_code=1, message="No User Roles found")
return response(data={
role_id: self.data_store.roles.get(role_id)
for role_id in role_ids
})
role_data = self.data_store.roles.get(role_id)
if not role_data:
return response(error_code=1, message="No User Roles found")
return response(data=role_data)
def cancel_order(self, form_data):
order_cancel = self.data_store.order_cancel.get(form_data['order_id'])
if isinstance(order_cancel, FakeUbersmithError):
self.logger.error("Cancel order failed.")
return response(error_code=order_cancel.code,
message=order_cancel.message)
self.logger.info("Cancelling order info: {}".format(order_cancel))
return response(data=order_cancel)
def _get_contact_response(self, lookup_key, matcher_key, matcher_value):
contact = next((contact for contact in self.data_store.contacts
if contact[lookup_key] == matcher_value), None)
self.logger.info("Getting contact info: {}".format(contact))
return response(data=contact) if contact else response(
error_code=1, message="Invalid {} specified.".format(matcher_key))
def submit_order(self, form_data):
order_submit = self.data_store.order_submit.get(form_data['order_id'])
if isinstance(order_submit, FakeUbersmithError):
self.logger.error("Order submitted failed.")
return response(error_code=order_submit.code,
message=order_submit.message)
self.logger.info("Order submitted info: {}".format(order_submit))
return response(data=order_submit)
def _get_all_contacts_response(self, lookup_key, matcher_key, matcher_value):
contacts = {
contact['contact_id']: contact
for contact in self.data_store.contacts
if contact[lookup_key] == matcher_value
}
return response(data=contacts) if contacts else response(
error_code=1, message="Invalid {} specified.".format(matcher_key)
)
def user_role_assign(self, form_data):
user_id = form_data.get('user_id')
role_id = str(form_data.get('role_id'))
roles = self.data_store.user_mapping.get(user_id, {}).get('roles', {})
if role_id in roles:
return response(error_code=1,
message="Can't assign role with id '{}' "
"to user with id '{}'".format(role_id, user_id))
self.data_store.user_mapping[user_id]['roles'].add(role_id)
return response(data=1)
def coupon_get(self, form_data):
coupon = next(
(cf for cf in self.data_store.coupons
if cf["coupon"]["coupon_code"] == form_data["coupon_code"]), None)
if coupon is not None:
self.logger.info("Retrieved coupon data: {}".format(coupon))
return response(data=coupon)
else:
self.logger.info("Getting coupon info failed")
return response(error_code=1, message="could not get coupon info")
def check_login(self, form_data):
data = self._get_client(form_data['login'], form_data['pass'])
if data:
data['type'] = 'client'
self.logger.info("Login successful. Client info: {}".format(data))
return response(data=data)
self.logger.error("Login failed")
return response(error_code=3, message="Invalid login or password.")
def _get_contact_response(self, lookup_key, matcher_key, matcher_value):
contact = next((contact for contact in self.data_store.contacts if contact[lookup_key] == matcher_value), None)
if contact:
client = self._client_get(contact["client_id"])
self.logger.info("Getting contact info: {} for client {}".format(contact, client))
return response(data=_format_contact_get(contact, client))
else:
return response(
error_code=1, message="Invalid {} specified.".format(matcher_key)
)
def service_plan_list(self, form_data):
if 'code' in form_data:
plan_code = form_data['code']
self.logger.info(
"Getting service plans for code: {}".format(plan_code))
return response(
data={
plan['plan_id']: plan
for plan in self.data_store.service_plans_list.values()
if plan['code'] == plan_code
})
self.logger.info("Plan not found by code. Listing all plans")
return response(data=self.data_store.service_plans_list)
def client_get(self, form_data):
client_id = form_data.get("client_id") or form_data.get("user_login")
client = next((client.copy() for client in self.data_store.clients
if client["clientid"] == client_id), None)
if client is not None:
client.pop("contact_id")
self.logger.info("client data being returned {}".format(client))
return response(data=client)
else:
self.logger.info("Can't find client ID - {}".format(client_id))
return response(
error_code=1,
message="Client ID '{}' not found.".format(client_id))
def client_metadata_single(self, form_data):
client_id = form_data.get("client_id")
metadata_name = form_data.get("variable")
self.logger.info("Gathering metadata {} for client: {}".format(metadata_name, client_id))
client_metadata = self.data_store.metadatas.get(client_id)
if client_metadata is None:
return response(data="0")
metadata = client_metadata.get(metadata_name)
if metadata is None:
return response(data="0")
return response(data=metadata)
def contact_permission_set(self, form_data):
contact_id = form_data.get("contact_id")
resource_name = form_data.get("resource_name")
action = form_data.get("action")
type = form_data.get("type")
effective = dict(read=0, create=0, update=0, delete=0)
contact = self._get_contact_from_id(contact_id)
if not contact.get(resource_name):
contact[resource_name] = {
"123": {
"resource_id": "123",
"name": resource_name,
"parent_id": "",
"lft": "",
"rgt": "",
"active": "1",
"label": "Manage Contacts",
"actions": ["2", "1", "3", "4"],
"action": [],
"effective": effective
}
}
else:
effective.update(contact[resource_name]['123'].get('effective'))
contact[resource_name]['123']['effective'][action] = 1 if type == "allow" else False
return response(data='')
def shutdown(self):
func = request.environ.get('werkzeug.server.shutdown')
if func is None:
raise RuntimeError('Not running with the Werkzeug Server')
func()
self.logger.info("Shutting down server")
return response(data="Shutting down server...")
def contact_permission_list(self, form_data):
contact_id = form_data.get("contact_id")
resource_name = form_data.get("resource_name")
contact = self._get_contact_from_id(contact_id)
self.logger.info("Gathering permission list for contact_id : {}".format(contact_id))
return response(data=contact.get(resource_name, default_permissions))
def client_get(self, form_data):
client_id = form_data.get("client_id") or form_data.get("user_login")
client = self._client_get(client_id)
if client is not None:
client.pop("contact_id")
if "uber_pass" in client:
client.pop("uber_pass")
if form_data.get("acls") == "1":
client["acls"] = []
self.logger.info("client data being returned {}".format(client))
return response(data=client)
else:
self.logger.info("Can't find client ID - {}".format(client_id))
return response(
error_code=1,
message="Client ID '{}' not found.".format(client_id))
def contact_list(self, form_data):
if "client_id" in form_data:
self.logger.info("Retrieving contact list by client_id")
return self._get_all_contacts_response("client_id", 'client_id',
form_data['client_id'])
self.logger.error("No valid client_id specified")
return response(error_code=1, message="No valid client ID specified")
def contact_add(self, form_data):
contact_id = str(a_random_id())
contact_data = form_data.copy()
contact_data["contact_id"] = contact_id
self.data_store.contacts.append(contact_data)
self.logger.info("Contact info added: {}".format(contact_data))
return response(data=contact_id)
def acl_admin_role_add(self, form_data):
if self._does_role_name_exist(form_data.get('name')):
return response(
error_code=1,
message="The specified Role Name is already in use")
role_id = str(a_random_id())
role_data = {}
acls = collections.defaultdict(dict)
for key, value in form_data.to_dict().items():
if 'acls' in key:
rule, level = list(filter(None, re.split(r"\[|\]", key)))[1:]
acls[rule][level] = value
else:
role_data[key] = value
role_data.update({'role_id': role_id, 'acls': acls})
self.data_store.roles[role_id] = role_data
return response(data=role_id)
def client_cc_info(self, form_data):
# returns no error if providing parameters, only an empty list
if "billing_info_id" in form_data:
return response(
data={
cc["billing_info_id"]: cc
for cc in self.data_store.credit_cards
if cc["billing_info_id"] == form_data["billing_info_id"]
})
elif "client_id" in form_data:
return response(
data={
cc["billing_info_id"]: cc
for cc in self.data_store.credit_cards
if cc["clientid"] == form_data["client_id"]
})
else:
return response(
error_code=1,
message="request failed: client_id parameter not supplied")
def contact_get(self, form_data):
if "user_login" in form_data:
self.logger.info("Looking up contact info by user_login")
return self._get_contact_response("login", 'user_login',
form_data['user_login'])
elif "contact_id" in form_data:
self.logger.info("Looking up contact info by contact_id")
return self._get_contact_response("contact_id", 'contact_id',
form_data['contact_id'])
self.logger.error("No valid user_login or contact_id specified")
return response(error_code=1, message="No contact ID specified")
def contact_update(self, form_data):
contact_id = form_data.get("contact_id")
contact = self._get_contact_from_id(contact_id)
self.logger.info("Updating contact {} with {}".format(contact["contact_id"], form_data))
self._update_if_present(contact, "real_name", form_data, "real_name")
self._update_if_present(contact, "description", form_data, "description")
self._update_if_present(contact, "phone", form_data, "phone")
self._update_if_present(contact, "email", form_data, "email")
self._update_if_present(contact, "login", form_data, "login")
self._update_if_present(contact, "password", form_data, "password")
return response(data=True)
def client_update(self, form_data):
client_id = form_data.get("client_id")
client = next(iter(filter(lambda e: e["clientid"] == client_id, self.data_store.clients)))
self.logger.info("Updating client {} with {}".format(client["clientid"], form_data))
self._update_if_present(client, "first", form_data, "first")
self._update_if_present(client, "last", form_data, "last")
self._update_if_present(client, "email", form_data, "email")
self._update_if_present(client, "login", form_data, "uber_login")
client_metadata = {k: v for k, v in form_data.items() if k.startswith('meta_')}
if len(client_metadata) >= 1:
self._update_client_metadata(client_id, client_metadata)
return response(data=True)
def client_add(self, form_data):
client_id = str(len(self.data_store.clients) + 1)
client_data = form_data.copy()
client_data["clientid"] = client_id
client_data["contact_id"] = str(0)
if client_data.get("uber_login"):
client_data["login"] = client_data.get("uber_login")
del client_data["uber_login"]
self.logger.info("Adding client data: {}".format(client_data))
self.data_store.clients.append(client_data)
return response(data=client_id)
def client_update(self, form_data):
client_id = form_data.get("client_id")
client = next(
iter(
filter(lambda e: e["clientid"] == client_id,
self.data_store.clients)))
self.logger.info("Updating client {} with {}".format(
client["clientid"], form_data))
self._update_if_present(client, "first", form_data, "first")
self._update_if_present(client, "last", form_data, "last")
self._update_if_present(client, "email", form_data, "email")
self._update_if_present(client, "login", form_data, "uber_login")
return response(data=True)
def client_add(self, form_data):
client_id = str(a_random_id())
client_data = form_data.copy()
client_data["clientid"] = client_id
client_data["contact_id"] = str(0)
if client_data.get("uber_login"):
client_data["login"] = client_data.get("uber_login")
del client_data["uber_login"]
self.logger.info("Adding client data: {}".format(client_data))
self.data_store.clients.append(client_data)
self.contact_add(
dict(client_id=client_id,
description="Primary Contact",
login="******",
password="******"))
return response(data=client_id)
