def check_authentication(self,email,passcode):
TAG='check_authentication'
if email is not None and passcode is not None:
from db.helpers.user import UserDBHelper
user_helper = UserDBHelper()
users = user_helper.get_user_with_email(email)
if type(users)==dict:
user = users
from db.helpers.enrollment import EnrollmentDBHelper
enrollment_helper = EnrollmentDBHelper()
enrollment_filter = {C.ENROLLMENT_TABLE_USER:user['id']}
enrollments= enrollment_helper.get_enrollments(
enrollment_filter, status=False)
if enrollments is not None:
for enrollment in enrollments:
if str(enrollment[C.ENROLLMENT_TABLE_PASSWORD]) == str(passcode):
self.log.i(TAG, 'Passcodes match')
return enrollment
else:
self.log.i(TAG, 'Invalid passcode email combination')
return None
else:
self.log.e(TAG, 'No entry found in user table corresponding to email '+email)
return None
else:
self.log.e(TAG, 'No user with email address '+email+ ' found')
return None
else:
return None
def check_authentication(self, email, passcode):
TAG = 'check_authentication'
if email is not None and passcode is not None:
from db.helpers.user import UserDBHelper
user_helper = UserDBHelper()
users = user_helper.get_user_with_email(email)
if isinstance(users, dict):
user = users
from db.helpers.enrollment import EnrollmentDBHelper
enrollment_helper = EnrollmentDBHelper()
enrollment_filter = {C.ENROLLMENT_TABLE_USER: user['id']}
enrollments = enrollment_helper.get_enrollments(
enrollment_filter, status=False)
if enrollments is not None:
for enrollment in enrollments:
if str(enrollment[C.ENROLLMENT_TABLE_PASSWORD]) == str(
passcode):
self.log.i(TAG, 'Passcodes match')
return enrollment
else:
self.log.i(TAG,
'Invalid passcode email combination')
return None
else:
self.log.e(TAG,
'No entry found in user table corresponding \
to email ' + email)
return None
else:
self.log.e(TAG, 'No user with email address ' + email + '\
found')
return None
else:
return None
def run(self):
log = Logger('UserPutHandlerThread')
TAG = 'PUT'
input_dict = json.loads(self.request.request.body)
print input_dict
self.user_id = input_dict.get('user_id')
if self.user_id is None:
log.e(TAG, 'No user id sent aborting update')
opJson = json.dumps({'pass': False, 'message': 'No user id sent'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
user = UserDBHelper()
user_dict = {c.USER_TABLE_NAME: str(input_dict.get('user_name')),
c.USER_TABLE_TEAM: str(input_dict.get('user_team')),
c.USER_TABLE_ROLE: str(input_dict.get('user_role'))}
result = user.update_user(str(self.user_id), user_dict)
if result is False:
log.e(TAG, 'Not able to update the Users details')
opJson = json.dumps({'pass': False,
'message': 'Not able to update the Email at DB'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
log.i(TAG, 'Users details Update successfully')
opJson = json.dumps({'pass': True,
'message': 'Email updated for user.'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
# Return All the users in the User table
self.log = Logger('DashboardEnrollmentStatusGetHandlerThread')
# TAG = 'run'
# ToDo : replace this with dynamic company id from cookies.
company_id = self.company_id
return_dict = {}
user = UserDBHelper()
violation = ViolationsDBHelper()
enrollment = EnrollmentDBHelper()
violation_count = violation.get_violation_count(company_id=company_id)
not_enrolled_count = enrollment.get_enrollment_status_count(
company_id=company_id, status=False)
enrolled_count = enrollment.get_enrollment_status_count(
company_id=company_id, status=True)
print "\n printing enrolled count", not_enrolled_count
user_count = user.get_users_count(company_id=company_id)
user_info_dict = {}
user_info_dict['Violations'] = violation_count
user_info_dict['Not Enrolled'] = not_enrolled_count
user_info_dict['Enrolled'] = enrolled_count
user_info_dict['Total Users'] = user_count
return_dict['UserInformation'] = user_info_dict
opJson = json.dumps({'message': 'Everything seems to be working ...',
'data': return_dict, 'pass': True})
#self.request.add_header('Access-Control-Allow-Origin', '*')
self.request.set_header('Content-Type', 'application/json')
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
log = Logger('UserPolicyPutHandlerThread')
TAG = 'run'
# Flag to track status of policy
status = False
if self.data and self.company_id:
# do stuff here
user = UserDBHelper()
url_data = self.data.split('/')
request_data = json.loads(self.request.request.body)
user_id = url_data[0]
plugin_name = url_data[1]
command_handler_json = {'to': 'user', 'id': str(user_id),
'company_id': self.company_id}
user_detail = user.get_user(str(user_id),
company_id=self.company_id)
if user_detail:
user_policy_id = user_detail.get('policy_id')
if plugin_name != 'actions':
status = put_individual_plugin(user_policy_id, plugin_name,
request_data)
else:
status = True
command_handler_json['action'] = request_data.get('action')
command_handler_json['passcode'] = request_data.get('lock_key')
if status:
print "\nprinting the json output will be send to command\
handler\n", command_handler_json
create_command_handler_task.delay(command_handler_json)
request_data['_id'] = user_policy_id
request_data['object_type'] = 'User'
request_data['name'] = user_detail[c.USER_TABLE_NAME]
opJson = json.dumps({'data':request_data, 'pass': True,
'count':1, 'message': 'Everything fine'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
opJson = json.dumps({'pass': False, 'count': 0,
'message': 'Update operation at policy table failed'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
log.e(TAG, 'No valid user id is sent in request')
opJson = json.dumps({'pass': False,
'message': 'No valid user id is sent in request'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
log.e(TAG, 'UnAuthorized Access for user policy ')
self.request.set_status(401)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
# Return All the users in the User table
log = Logger('UserDeleteHandlerThread')
tag = 'DELETE'
if self.data is None:
log.e(tag, 'No user registered in table for this user_id')
opJson = json.dumps(
{'pass': False,
'message': 'No user registered in table for this user_id'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
user = UserDBHelper()
device = DeviceDBHelper()
enrollment = EnrollmentDBHelper()
print 'print data here \n ... \n ', self.data
user_list = user.get_user(str(self.data), company_id=self.company_id)
if user_list is None:
log.e(tag, 'No user registered in table for this user_id')
opJson = json.dumps(
{'pass': False,
'message': 'No user registered in table for this user_id'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
user_deleted = user.delete_user(str(user_list.get('id')))
if not user_deleted:
log.e(tag, 'Not able to delete from user table')
opJson = json.dumps(
{'pass': False,
'message': 'Not able to delete from user table'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
devices = device.get_devices_of_user(str(self.data))
if devices is not None and len(devices) > 0:
for each_device in devices:
device_id = each_device.get('id')
device.delete_device(str(device_id))
enrollment_list = enrollment.get_enrollments({
'device_id': device_id})
for enroll in enrollment_list:
enrollment_id = enroll.get('id')
enrollment.update_enrollment(
str(enrollment_id), {
'device_id': "null", 'is_enrolled': False})
log.i(tag, 'User delelted')
opJson = json.dumps({'pass': True,
'message': 'User Successfully deleted'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
log = Logger('UserPutHandlerThread')
TAG = 'PUT'
input_dict = json.loads(self.request.request.body)
print input_dict
self.user_id = input_dict.get('user_id')
if self.user_id is None:
log.e(TAG, 'No user id sent aborting update')
opJson = json.dumps({'pass': False, 'message': 'No user id sent'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
user = UserDBHelper()
user_dict = {
c.USER_TABLE_NAME: str(input_dict.get('user_name')),
c.USER_TABLE_TEAM: str(input_dict.get('user_team')),
c.USER_TABLE_ROLE: str(input_dict.get('user_role'))
}
result = user.update_user(str(self.user_id), user_dict)
if result is False:
log.e(TAG, 'Not able to update the Users details')
opJson = json.dumps({
'pass':
False,
'message':
'Not able to update the Email at DB'
})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
log.i(TAG, 'Users details Update successfully')
opJson = json.dumps({
'pass': True,
'message': 'Email updated for user.'
})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
# Return All the users in the User table
self.log = Logger('DashboardEnrollmentStatusGetHandlerThread')
# TAG = 'run'
# ToDo : replace this with dynamic company id from cookies.
company_id = self.company_id
return_dict = {}
user = UserDBHelper()
violation = ViolationsDBHelper()
enrollment = EnrollmentDBHelper()
violation_count = violation.get_violation_count(company_id=company_id)
not_enrolled_count = enrollment.get_enrollment_status_count(
company_id=company_id, status=False)
enrolled_count = enrollment.get_enrollment_status_count(
company_id=company_id, status=True)
print "\n printing enrolled count", not_enrolled_count
user_count = user.get_users_count(company_id=company_id)
user_info_dict = {}
user_info_dict['Violations'] = violation_count
user_info_dict['Not Enrolled'] = not_enrolled_count
user_info_dict['Enrolled'] = enrolled_count
user_info_dict['Total Users'] = user_count
return_dict['UserInformation'] = user_info_dict
opJson = json.dumps({
'message': 'Everything seems to be working ...',
'data': return_dict,
'pass': True
})
#self.request.add_header('Access-Control-Allow-Origin', '*')
self.request.set_header('Content-Type', 'application/json')
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
self.log = Logger('UpdateTokenThread')
TAG = 'run'
print 'In UpdateTokenThread\'s POST'
#Get the parameters which are to be used
password = str(self.request.get_argument('password',None))
user_email = str(self.request.get_argument('email', None))
token = str(self.request.get_argument('token',None))
print password
print user_email
print token
token = token.replace('<', '')
token = token.replace('>', '')
token = token.replace(' ', '')
result_dict = {}
user = UserDBHelper()
user_detail_dict = user.get_user_with_email(user_email)
print 'user_dict = ' + str(user_detail_dict)
if user_detail_dict is None:
self.log.e(TAG, 'No user corresponding to the email = ' + str(user_email))
result_dict['pass'] = False
result_dict['is_enrolled'] = False
opJson = json.dumps(result_dict)
self.request.set_header ('Content-Type', 'application/json')
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
company = CompanyDBHelper()
user_id = str(user_detail_dict[C.USER_TABLE_ID])
user_name = str(user_detail_dict[C.USER_TABLE_NAME])
company_id = str(user_detail_dict[C.USER_TABLE_COMPANY])
company_detail_dict = company.get_company(company_id)
company_name = str(company_detail_dict[C.COMPANY_TABLE_NAME])
enrollment = EnrollmentDBHelper()
filter_dict = {
C.ENROLLMENT_TABLE_USER : str(user_id),
C.ENROLLMENT_TABLE_PASSWORD : str(password)
}
enrollment_list = enrollment.get_enrollments(filter_dict)
print 'enrollment_list = ' + str(enrollment_list)
if enrollment_list is None:
self.log.e(TAG, 'No enrollment corresponding to the email = ' + str(user_email) + ' and password = '******'pass'] = False
result_dict['is_enrolled'] = False
opJson = json.dumps(result_dict)
self.request.set_header ('Content-Type', 'application/json')
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
device_id = enrollment_list[0][C.ENROLLMENT_TABLE_DEVICE]
user_data = {'name': user_name, 'company': company_name}
result_dict['data'] = user_data
if device_id is None:
self.log.e(TAG, 'No device ID in enrollment table\
corresponding to the email = ' + \
str(user_email) + ' and password = '******'pass'] = True
result_dict['is_enrolled'] = False
opJson = json.dumps(result_dict)
self.request.set_header ('Content-Type', 'application/json')
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
device_detail = DeviceDetailsDBHelper()
updated = device_detail.update_device_details(str(device_id), {C.DEVICE_DETAILS_TABLE_MESSAGE_TOKEN : str(token)})
if not updated:
self.log.e(TAG, 'Not able to update Message Token in Device Details Table DeviceID = ' + str(device_id))
result_dict['pass'] = False
result_dict['is_enrolled'] = True
opJson = json.dumps(result_dict)
self.request.set_header ('Content-Type', 'application/json')
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
self.log.i(TAG, 'Device Messge Token updated successfully DeviceID = ' + str(device_id))
result_dict['pass'] = True
result_dict['is_enrolled'] = True
opJson = json.dumps(result_dict)
self.request.set_header ('Content-Type', 'application/json')
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
self.log = Logger('UpdateTokenThread')
TAG = 'run'
print 'In UpdateTokenThread\'s POST'
# Get the parameters which are to be used
password = str(self.request.get_argument('password', None))
user_email = str(self.request.get_argument('email', None))
token = str(self.request.get_argument('token', None))
print password
print user_email
print token
token = token.replace('<', '')
token = token.replace('>', '')
token = token.replace(' ', '')
result_dict = {}
user = UserDBHelper()
user_detail_dict = user.get_user_with_email(user_email)
print 'user_dict = ' + str(user_detail_dict)
if user_detail_dict is None:
self.log.e(
TAG,
'No user corresponding to the email = ' +
str(user_email))
result_dict['pass'] = False
result_dict['is_enrolled'] = False
opJson = json.dumps(result_dict)
self.request.set_header('Content-Type', 'application/json')
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
company = CompanyDBHelper()
user_id = str(user_detail_dict[C.USER_TABLE_ID])
user_name = str(user_detail_dict[C.USER_TABLE_NAME])
company_id = str(user_detail_dict[C.USER_TABLE_COMPANY])
company_detail_dict = company.get_company(company_id)
company_name = str(company_detail_dict[C.COMPANY_TABLE_NAME])
enrollment = EnrollmentDBHelper()
filter_dict = {
C.ENROLLMENT_TABLE_USER: str(user_id),
C.ENROLLMENT_TABLE_PASSWORD: str(password)
}
enrollment_list = enrollment.get_enrollments(filter_dict)
print 'enrollment_list = ' + str(enrollment_list)
if enrollment_list is None:
self.log.e(
TAG,
'No enrollment corresponding to the email = ' +
str(user_email) +
' and password = '******'pass'] = False
result_dict['is_enrolled'] = False
opJson = json.dumps(result_dict)
self.request.set_header('Content-Type', 'application/json')
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
device_id = enrollment_list[0][C.ENROLLMENT_TABLE_DEVICE]
user_data = {'name': user_name, 'company': company_name}
result_dict['data'] = user_data
if device_id is None:
self.log.e(TAG, 'No device ID in enrollment table\
corresponding to the email = ' +
str(user_email) + ' and password = '******'pass'] = True
result_dict['is_enrolled'] = False
opJson = json.dumps(result_dict)
self.request.set_header('Content-Type', 'application/json')
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(
self.callback)
else:
device_detail = DeviceDetailsDBHelper()
updated = device_detail.update_device_details(
str(device_id), {
C.DEVICE_DETAILS_TABLE_MESSAGE_TOKEN: str(token)})
if not updated:
self.log.e(
TAG,
'Not able to update Message Token in \
Device Details Table DeviceID = ' + str(device_id))
result_dict['pass'] = False
result_dict['is_enrolled'] = True
opJson = json.dumps(result_dict)
self.request.set_header(
'Content-Type',
'application/json')
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(
self.callback)
else:
self.log.i(
TAG,
'Device Messge Token updated successfully \
DeviceID = ' + str(device_id))
result_dict['pass'] = True
result_dict['is_enrolled'] = True
opJson = json.dumps(result_dict)
self.request.set_header(
'Content-Type',
'application/json')
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(
self.callback)
def run(self):
log = Logger('RoleGetHandlerThread')
TAG = 'GET'
page = self.request.get_argument('offset', None)
count = self.request.get_argument('count', None)
sort_by = self.request.get_argument('sort_by', None)
print page
print count
print sort_by
if self.data and self.company_id:
role = RoleDBHelper()
roles = role.get_role(str(self.data), company_id=self.company_id)
outer_dict = {}
outer_array = []
if roles is None:
log.e(TAG, 'No role found corresponding to the role id ' + \
str(self.data))
opJson = json.dumps({'pass': False, 'message':'No role found \
corresponding to the role id ' + str(self.data)})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
self.role_name = roles[c.ROLE_TABLE_NAME]
user = UserDBHelper()
filter_dict = {
c.USER_TABLE_ROLE: str(roles.get('id'))
}
user_list = user.get_users_with_pages(filter_dict, int(page), int(count), str(sort_by))
inner_array = []
if user_list is not None:
for users in user_list:
inner_dict = {}
self.user_id = str(users[c.USER_TABLE_ID])
self.user_name = str(users[c.USER_TABLE_NAME])
self.user_email = str(users[c.USER_TABLE_EMAIL])
self.user_team_id = str(users[c.USER_TABLE_TEAM])
## Find out the team for user
team = TeamDBHelper()
teams = team.get_team(self.user_team_id,
[c.TEAM_TABLE_NAME])
if teams is None:
self.user_team = None
else:
self.user_team = str(teams[c.TEAM_TABLE_NAME])
## Find out the device for user
device = DeviceDBHelper()
device_list = device.get_devices_of_user(self.user_id)
if device_list is None:
self.user_device = None
else:
devices = device_list[0]
self.user_device = str(
devices[c.DEVICE_TABLE_UDID])
self.user_device_os = str(
devices[c.DEVICE_TABLE_OS])
# Find out user violations
violation = ViolationsDBHelper()
violation_count = violation.get_violation_count(
str(devices.get('id')))
inner_dict = {
'user_id': self.user_id,
'user_name': self.user_name,
'user_role': self.role_name,
'user_team': self.user_team,
'user_device': self.user_device,
'user_violations': violation_count,
'user_device_os': self.user_device_os
}
inner_array.append(inner_dict)
outer_dict['name'] = self.role_name
outer_dict['users'] = inner_array
outer_dict['roleID'] = self.data
outer_array.append(outer_dict)
self.final_dict['pass'] = True
self.final_dict['roles'] = outer_array
opJson = json.dumps(self.final_dict)
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
log.e(TAG, 'UnAuthorized Access for Roles')
self.request.set_status(401)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
log = Logger('CheckInHandler PUT')
TAG = 'run'
# print ' In deviceCheckin PUT Handler\n\n\n'
# parse the body of PUT
# First extract the XML
arguments = cgi.parse_qsl(self.request.request.body)
intermediate = arguments[0]
currentxml = intermediate[1]
final = currentxml[25:-1]
enrollment_id = str(self.data)
# print final
# Actual Parsing
#tree = ET.ElementTree(ET.fromstring(final))
# tree = ET.parse('temp.xml') ### For testing only
node = etree.fromstring(final)
device_data = []
for text_of_child in node.itertext():
if len(text_of_child.strip()) > 0:
device_data.append(text_of_child.strip())
device_data = dict(zip(device_data[::2], device_data[1::2]))
if device_data.get('PushMagic'):
self.push_magic = str(device_data.get('PushMagic'))
if device_data.get('Token'):
self.device_token = str(device_data.get('Token'))
self.device_token = self.device_token.replace(' ', '+')
self.device_token = self.device_token.replace('\n', '')
self.device_token = self.device_token.replace('\t', '')
# print len(self.device_token)
# print self.device_token
if device_data.get('MessageType'):
message = device_data.get('MessageType')
if message == 'TokenUpdate':
self.do_entry = True
elif message == 'Authenticate':
self.do_initial_entry = True
if device_data.get('UnlockToken'):
self.unlock_token = device_data.get('UnlockToken')
self.unlock_token = self.unlock_token.replace(' ', '+')
self.unlock_token = self.unlock_token.replace('\n', '')
self.unlock_token = self.unlock_token.replace('\t', '')
if device_data.get('UDID'):
self.udid = device_data.get('UDID')
### Initial Device DB Entries ###
if self.do_entry:
enrolled_success = False
device_id = None
# fetch info from enrollment table
enrollment = EnrollmentDBHelper()
enrollment_dict = enrollment.get_enrollment(enrollment_id)
# print 'enrollment_dict = ' + str(enrollment_dict)
if enrollment_dict is None:
log.e(TAG,
'No user ID in Enrollment table. Enrollment ID = '
+ str(enrollment_id))
reply = """
<html>
<body>401</body>
</html>
"""
self.request.set_status(401)
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
else:
reply = """
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
</dict>
</plist>
"""
print 'inner write'
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
device = DeviceDBHelper()
violation = ViolationsDBHelper()
user_id = str(enrollment_dict[c.ENROLLMENT_TABLE_USER])
device_id = enrollment_dict.get(c.ENROLLMENT_TABLE_DEVICE)
devices = device.get_device_with_udid(
str(self.udid), status=True)
# print "\n print devices list if available \n\n",devices
device_detail = DeviceDetailsDBHelper()
device_details_dict = {
'token': self.device_token,
'push_magic': self.push_magic,
'unlock_token': self.unlock_token
}
if device_id:
enrolled_success = True
device.update_device(str(device_id),
{c.DEVICE_TABLE_DELETED: False,
c.DEVICE_TABLE_UDID: str(self.udid)})
device_detail.update_device_details(str(device_id),
device_details_dict)
print "Device details table updated."
elif devices:
device_id = devices[0][c.DEVICE_TABLE_ID]
device.update_device(str(device_id),
{c.DEVICE_TABLE_DELETED: False})
device_detail.update_device_details(str(device_id),
device_details_dict)
enrollment.update_enrollment(
enrollment_id, {
c.ENROLLMENT_TABLE_DEVICE: str(device_id)})
enrollment.set_enrolled(enrollment_id)
enrolled_success = True
else:
# print 'user_id = ' + user_id
device_dict = {c.DEVICE_TABLE_USER: user_id,
c.DEVICE_TABLE_OS: 'ios',
c.DEVICE_TABLE_UDID: str(self.udid),
c.DEVICE_TABLE_DELETED: False}
device_id = device.add_device(device_dict)
if device_id is None:
log.e(TAG,
'Not Able to insert in Device table UDID = '
+ str(self.udid) + 'userID = ' + str(user_id))
else:
device_details_dict_new = {}
device_details_dict_new[
c.DEVICE_DETAILS_TABLE_DEVICE] = device_id
device_details_dict_new[
c.DEVICE_DETAILS_TABLE_EXTRAS] = device_details_dict
device_details_id = device_detail.add_device_detail(
device_details_dict_new)
# print 'device_details_id = ' + str(device_details_id)
if device_details_id is None:
log.e(TAG, 'Not Able to insert in Device Details \
table UDID = ' +
str(self.udid) +
'userID = ' +
str(user_id) +
'DeviceID = ' +
str(device_id))
else:
success = enrollment.update_enrollment(
enrollment_id,
{c.ENROLLMENT_TABLE_DEVICE: str(device_id)})
if not success:
log.e(TAG,
'enrollment device table not linked')
else:
success1 = enrollment.set_enrolled(
enrollment_id)
if success1:
enrolled_success = True
else:
log.e(
TAG,
'EnrolledOn time is not updated in \
the Enrollment Table')
if device_id and enrolled_success:
violation_status = violation.update_violations(
str(device_id))
user = UserDBHelper()
user_info = user.get_user(user_id)
if violation_status:
log.i(TAG,
"Violation table updated for device_id" + str(
device_id))
else:
log.e(
TAG,
"Violation table not updated for device_id" +
str(device_id))
### Add task to Queue for celery Worker. ###
json_data = {'to': 'user', 'action': 'device_information',
'id': user_id}
json_data['company_id'] = user_info.get('company_id')
create_command_handler_task.delay(json_data)
### Now send polling Signal to device ###
wrapper = APNSNotificationWrapper(
'/opt/toppatch/assets/ios/PushCert.pem', False)
message = APNSNotification()
message.appendProperty(APNSProperty("mdm",
str(self.push_magic)))
message.tokenBase64(str(self.device_token))
wrapper.append(message)
wrapper.notify()
print 'Payload Sent'
elif device_data.get('MessageType') == 'CheckOut':
reply = """
<html>
<body>401</body>
</html>
"""
self.request.set_status(401)
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
violation = ViolationsDBHelper()
device = DeviceDBHelper()
enrollment = EnrollmentDBHelper()
devices = device.get_device_with_udid(self.udid)
if devices is None:
log.e(TAG, 'No User ID Associated with Device UDID = '
+ self.udid)
else:
device_id = devices[0][c.DEVICE_TABLE_ID]
violation_id = violation.add_violation(str(device_id))
if violation_id is None:
log.e(TAG, 'Not able to insert in Violation Table.\
DeviceID = ' + str(device_id))
else:
device.delete_device(device_id)
enrollment.update_enrollment(
str(enrollment_id), {
'device_id': "null", 'is_enrolled': False})
log.i(TAG, 'Violation added for device id = ' +
str(device_id))
admin_mailer(device_id, violation_id)
else:
reply = """
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
</dict>
</plist>
"""
print 'outer write'
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
TAG = 'run'
print ' In IOSCommandPerformer\'s PUT'
command = IOSCommandDBHelper()
invoke_flag = False
arguments = cgi.parse_qsl(self.request.request.body)
intermediate = arguments[0]
currentxml = intermediate[1]
final = currentxml[25:-1] # Original Line
# final = currentxml[20:] ### For testing only
# print '\n\n\n here is final xml \n\n', final
# temp Parsing
# tree = ET.ElementTree(ET.fromstring(final)) ##Original Line
# tree = ET.parse('temp.xml') ### For testing only
initial_list = []
initial_dict = {}
check_out_requested = False
send_command = False
store_result = False
store_error = False
registered = True
special_result = False
acknowledged = False
update_token = False
object_root = objectify.fromstring(final)
begin = object_root.dict
for child in begin.iterchildren():
initial_list.append(child.text)
initial_dict = dict(zip(initial_list[::2], initial_list[1::2]))
# print '\n\n print here initial dict\n', initial_dict
if 'UDID' in initial_dict:
udid = initial_dict.get('UDID')
device = DeviceDBHelper()
registered = device.is_udid_registered(str(udid))
if 'Status' in initial_dict:
status = initial_dict.get('Status')
if status == 'Idle':
send_command = True
elif status == 'Acknowledged':
acknowledged = True
elif status == 'Error':
store_error = True
uuid = initial_dict.get('CommandUUID')
if 'MessageType' in initial_dict:
message = initial_dict.get('MessageType')
if message == 'TokenUpdate':
update_token = True
elif message == 'CheckOut':
check_out_requested = True
push_magic = 'push_magic'
token = 'Token'
unlock_token = 'UnlockToken'
if registered is False:
reply = """
"""
self.request.set_status(401)
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
else:
device_id = str(device.get_device_with_udid(udid)[0]['id'])
print 'reached here '
if acknowledged:
if 'CommandUUID' in initial_dict:
uuid = initial_dict.get('CommandUUID')
# special uuid for device information
if uuid == '55555555-5555-5555-5555-555555555555' + device_id:
info_list = [
el.text if el.text else el.tag
for el in object_root.iterdescendants()
]
info_list.pop(0)
final = dict(zip(info_list[::2], info_list[1::2]))
store_result = True
special_result = True
# special uuid for installed application list
elif uuid == ('77777777-7777-7777-7777-777777777777' +
device_id):
begin = object_root.dict.array
apps_list = []
for outer_child in begin.iterchildren():
temp_list = []
for inner_child in outer_child.iterchildren():
temp_list.append(inner_child.text)
apps_list.append(
dict(zip(temp_list[::2], temp_list[1::2])))
final = apps_list
store_result = True
invoke_flag = True
else:
store_result = True
if send_command:
if udid is None:
self.log.e(TAG, 'No UDID is supplied from the device')
else:
command_list = command.get_not_executed(str(device_id))
if command_list is None or len(command_list) == 0:
self.log.e(
TAG, 'No command to execute fot the device \
having ID = ' + str(device_id))
reply = " "
print 'outer write'
self.request.set_status(500)
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
else:
device_details = DeviceDetailsDBHelper()
violate_device = False
special_uuid = (
'2929292929-29292929-292929-292929-292929' +
str(device_id))
commands = command_list[0]
action = str(commands[c.COMMAND_TABLE_ACTION])
command_attributes = commands[c.COMMAND_TABLE_ATTRIBUTE]
command_uuid = str(commands[c.COMMAND_TABLE_COMMAND_UUID])
if command_uuid == special_uuid:
violate_device = True
if action is not None and not violate_device:
command_xml_thread = IOSCommandCreatorThread(
action, command_attributes, command_uuid,
device_id)
command_xml_thread.start()
command_xml_thread.join()
final_output = command_xml_thread.command_profile
if final_output is not None:
self.request.write(final_output)
ioloop.IOLoop.instance().add_callback(self.callback)
# send polling signal to device for next command
device_details_list = (
device_details.get_device_details(device_id))
json_extras = device_details_list.get(
c.DEVICE_DETAILS_TABLE_EXTRAS)
self.push_magic = str(json_extras.get('push_magic'))
self.device_token = str(json_extras.get('token'))
wrapper = APNSNotificationWrapper(
'/opt/toppatch/assets/ios/PushCert.pem', False)
message = APNSNotification()
message.appendProperty(
APNSProperty("mdm", self.push_magic))
message.tokenBase64(str(self.device_token))
wrapper.append(message)
wrapper.notify()
print 'Payload Sent'
elif violate_device:
### Wiping device to Factory Reset ###
command_xml_thread = IOSCommandCreatorThread(
action, command_attributes, command_uuid,
device_id)
command_xml_thread.start()
command_xml_thread.join()
final_output = command_xml_thread.command_profile
if final_output is not None:
self.request.write(final_output)
ioloop.IOLoop.instance().add_callback(self.callback)
violation = ViolationsDBHelper()
enrollment = EnrollmentDBHelper()
violation_id = violation.add_violation(str(device_id))
if violation_id is None:
self.log.e(
TAG, 'Not able to insert in Violation \
Table. DeviceID = ' + str(device_id))
else:
device.delete_device(device_id)
enrollment_list = enrollment.get_enrollments(
{'device_id': device_id})
for enroll in enrollment_list:
enrollment_id = enroll.get('id')
enrollment.update_enrollment(
str(enrollment_id), {
'device_id': "null",
'is_enrolled': False
})
self.log.i(
TAG, 'Violation added for device id = ' +
str(device_id) + 'due to remote wipe command')
else:
reply = " "
print 'outer write'
self.request.set_status(500)
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
elif check_out_requested:
violation = ViolationsDBHelper()
device = DeviceDBHelper()
devices = device.get_device_with_udid(udid)
if devices is None:
self.log.e(TAG,
'No User ID Associated with Device UDID = ' + udid)
else:
device_id = str(devices[0][c.DEVICE_TABLE_ID])
violation_id = violation.add_violation(device_id)
if violation_id is None:
self.log.e(
TAG, 'Not able to insert in Violation Table.\
DeviceID = ' + str(device_id))
else:
self.log.i(
TAG,
'Violation added for device id = ' + str(device_id))
reply = """
"""
self.request.set_status(401)
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
elif store_result or store_error:
if special_result:
is_updated = device.update_device(
str(device_id),
{c.DEVICE_TABLE_OS_VERSION: str(final.get('OSVersion'))})
if not is_updated:
self.log.e(
TAG, 'Not able to set the version of the device\
udid = ' + str(udid) + " Device id = " + str(device_id))
else:
self.log.i(
TAG, 'Version Set for the device udid = ' + str(udid) +
" Device id = " + str(device_id))
if store_error:
self.log.e(
TAG, 'Error in Response for uuid = ' + str(uuid) +
' device_id = ' + str(device_id))
# print '\n\nfinal dict to be stored as json is \n\n', final
result_updated = command.update_result(str(uuid), str(device_id),
final)
reply = """
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
</dict>
</plist>
"""
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
if not result_updated:
self.log.e(
TAG, 'Result Not updated for uuid = ' + str(uuid) +
' udid = ' + str(udid))
else:
executed = command.toggle_executed(str(uuid), str(device_id),
True)
if executed is False:
self.log.e(
TAG, 'IOSCommand Table executed \
field is not updated CommandUUID = ' + str(uuid) +
'Device id = ' + str(device_id))
self.log.i(
TAG, 'Result send in DB for uuid = ' + str(uuid) +
' udid = ' + str(udid))
if invoke_flag:
# Queue task to send command to user of app installation
user = UserDBHelper()
user_id = device.get_device_with_udid(
str(udid))[0]['user_id']
user_info = user.get_user(str(user_id))
json_data = {'to': 'user', 'id': user_id}
json_data['company_id'] = user_info.get('company_id')
create_command_handler_task.delay(json_data)
elif update_token:
device = DeviceDBHelper()
device_list = device.get_device_with_udid(udid)
device_id = 'device_id'
if device_list is not None and len(device_list) != 0:
for devices in device_list:
device_id = devices[c.DEVICE_TABLE_ID]
if device_id is None:
self.log.e(
TAG, 'Device id is not found corresponding \
the udid = ' + str(udid))
else:
device_details = DeviceDetailsDBHelper()
device_details_dict = {
c.DEVICE_DETAILS_TABLE_DEVICE_TOKEN: token,
c.DEVICE_DETAILS_TABLE_PUSH_MAGIC: push_magic,
c.DEVICE_DETAILS_TABLE_UNLOCK_TOKEN: unlock_token
}
is_updated = device_details.update_device_details(
str(device_id), device_details_dict)
if not is_updated:
self.log.e(
TAG, 'Not able to update the device \
details of device_id = ' + str(device_id))
else:
self.log.i(
TAG, 'Device Details successfully \
updated device id = ' + str(device_id))
reply = """
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
</dict>
</plist>
"""
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
else:
reply = """
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
</dict>
</plist>
"""
print 'outer write'
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
#Return All the users in the User table
log = Logger('UsersGetHandlerThreadWithPage')
tag = 'run'
company_id = self.company_id
final_dict = {}
user = UserDBHelper()
team = TeamDBHelper()
role = RoleDBHelper()
violation = ViolationsDBHelper()
device = DeviceDBHelper()
offset = self.request.get_argument('offset', None)
count = self.request.get_argument('count', None)
name_query = self.request.get_argument('name', None)
team_query = self.request.get_argument('team', None)
role_query = self.request.get_argument('role', None)
device_query = self.request.get_argument('device_id', None)
sort_by = self.request.get_argument('sort_by', True)#Intentionally done
sort_order = self.request.get_argument('sort', None)
filter_key = self.request.get_argument('filter_key', None)
filter_value = self.request.get_argument('filter_value', None)
if filter_key == 'role':
role_name = filter_value
role_id = role.get_role_by_name(str(role_name), company_id)
else:
role_name = None
role_id = None
if filter_key == 'team':
team_name = filter_value
team_id = team.get_team_by_name(str(team_name), company_id)
else:
team_name = None
team_id = None
if filter_key == 'os':
os_mapper = {'Android': 'samsung', 'iOS': 'ios'}
os_type = os_mapper.get(str(filter_value))
else:
os_type = None
if name_query:
query = name_query
query_type = 'name'
elif role_query:
query = role_query
query_type = 'role'
elif device_query:
query = device_query
query_type = 'device'
elif team_query:
query = team_query
query_type = 'team'
else:
query = None
query_type = None
if offset:
result_list, total_count = user.get_users_for_user(
company_id=company_id, offset=offset, count=count,
role_id=role_id, team_id=team_id, query=query,
query_type=query_type, os_type=os_type,
sort_by=sort_by, sort_order=sort_order,
filter_key=filter_key, filter_value=filter_value)
else:
result_list, total_count = user.get_users(
{c.USER_TABLE_COMPANY: company_id})
if result_list:
for user_dict in result_list:
device_deleted = False
device_info = device.get_device_with_udid(user_dict.get(
'user_device'))
if not device_info:
device_info = device.get_device_with_udid(user_dict.get(
'user_device'), status=True)
device_deleted = True
if device_info:
device_id = device_info[0].get(c.DEVICE_TABLE_ID)
else:
device_id = None
if device_deleted:
user_dict['user_device'] = None
user_dict['user_device_os'] = None
if device_id:
print "printing \n device id", device_id
violation_count = violation.get_violation_count(
company_id=company_id, device_id=str(device_id))
else:
violation_count = 0
user_dict['user_violation'] = violation_count
final_dict['data'] = result_list
final_dict['count'] = total_count
final_dict['pass'] = True
final_dict['message'] = 'Seems like things are working ...'
else:
final_dict['pass'] = True
log.e(tag,'No User in User Table')
final_dict['message'] = 'Seems like things are not working ...'
final_dict['count'] = 0
## add all the data into dictionary and create output json
opJson = json.dumps(final_dict)
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def merge(self, device_id):
user_helper = UserDBHelper()
device_helper = DeviceDBHelper()
roles_helper = RoleDBHelper()
teams_helper = TeamDBHelper()
company_helper = CompanyDBHelper()
policy_helper = PolicyDBHelper()
if device_id is not None:
device_details = device_helper.get_device(device_id)
if device_details is not None and 'user_id' in device_details:
user_details = user_helper.get_user(
str(device_details['user_id']))
team_id = user_details['team_id']
role_id = user_details['role_id']
company_id = user_details['company_id']
team_details = teams_helper.get_team(str(team_id))
role_details = roles_helper.get_role(str(role_id))
company_details = company_helper.get_company(str(company_id))
if user_details is not None and 'policy_id' in user_details:
policy_id_user = user_details['policy_id']
else:
print 'No user details found'
if team_details is not None and 'policy_id' in team_details:
policy_id_team = team_details['policy_id']
else:
print 'no team details found'
if role_details is not None and 'policy_id' in role_details:
policy_id_role = role_details['policy_id']
else:
print 'no role details found'
if (company_details is not None
and 'policy_id' in company_details):
policy_id_company = company_details['policy_id']
else:
print 'no company details found'
if policy_id_company is not None:
print 'company policy id=', policy_id_company
policy_company = policy_helper.get_policy(
str(policy_id_company))
else:
policy_company = None
if policy_id_role is not None:
print 'role policy id=', policy_id_role
policy_role = policy_helper.get_policy(str(policy_id_role))
else:
policy_role = None
if policy_id_team is not None:
print 'team policy id=', policy_id_team
policy_team = policy_helper.get_policy(str(policy_id_team))
else:
policy_team = None
if policy_id_user is not None:
print 'user policy id=', policy_id_user
policy_user = policy_helper.get_policy(str(policy_id_user))
else:
policy_user = None
return self.merge_policies(
policy_company,
policy_role,
policy_team,
policy_user)
else:
print 'Invalid device id'
def run(self):
#Find all the POST arguments required
company_id = self.company_id
company_name = str(self.company_name)
loader = Loader("/opt/toppatch/mv/media/app/")
thread1 = {}
log = Logger('EnrollDevice')
tag = 'POST'
request_body = json.loads(self.request.request.body)
try:
self.user_email = str(request_body.get('user_email', None))
self.user_name = str(request_body.get('user_name', None))
self.team_id = str(request_body.get('team_id', None))
self.role_id = str(request_body.get('role_id', None))
self.company_id = str(company_id)
except:
self.request.write('Some arguments are not supplied')
opJson = json.dumps({'pass':False, 'user_name': None,
'link' : None, 'password':None,
'error':'Some argument not supplied'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
log.e(tag, 'Some arguments not sent in POST request for enrollment')
return
if self.user_email is None or self.user_name is None or\
self.company_id is None:
log.e(tag, 'Email or user_name is NULL')
opJson = json.dumps({'pass':False, 'user_name': None,
'link' : None, 'password':None,
'error':'user_name or Email or Company is None'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
if self.user_name == '' or self.user_email == '':
log.e(tag, 'Email or user_name is empty')
opJson = json.dumps({'pass':False, 'user_name': None,
'link' : None, 'password':None,
'error':'email or user_name or company is empty'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
password = generate_password()
user = UserDBHelper()
user_dict = {
c.USER_TABLE_NAME: str(self.user_name),
c.USER_TABLE_TEAM : str(self.team_id),
c.USER_TABLE_ROLE: str(self.role_id),
c.USER_TABLE_EMAIL: str(self.user_email),
c.USER_TABLE_COMPANY: str(self.company_id)
}
user_id, duplicate = user.add_user_if_not_exists(user_dict)
if duplicate:
log.e(tag,'No id from primary key ')
opJson = json.dumps({'pass':False, 'user_name': self.user_name,
'link' : None, 'password':None, 'duplicate': True,
'error':'DB has problem'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
enrollment_dict = {
c.ENROLLMENT_TABLE_USER: user_id,
c.ENROLLMENT_TABLE_PASSWORD: password,
c.ENROLLMENT_TABLE_IS_ENROLLED: False
}
enrollment = EnrollmentDBHelper()
enrollment_id = str(enrollment.add_enrollment(enrollment_dict))
enrollment_dict = enrollment.get_enrollment(enrollment_id)
if enrollment_id is not None:
self.link += enrollment_id
try:
message = loader.load('user_enroll_mail.html').generate(
company_name=self.company_name,
user_passwd=password, activation_link=self.link)
ses_conn.send_email('*****@*****.**',
'MDM Enrollment verification', message,
[self.user_email], format='html')
print 'No error found'
log.i(tag, 'Enrollment request successful')
opJson = json.dumps({'pass':True, 'user_name': self.user_name,
'link' : 'link', 'password':'******', 'error':None})
except Exception, err:
print 'Mail Sending error exception is :', repr(err)
log.e(tag, 'Incorrect EmailID sent')
opJson = json.dumps({'pass':False, 'user_name': self.user_name,
'link' : None, 'password':None, 'error':'Wrong emailID'})
else:
self.log.e(TAG, 'Exception: ' + repr(err))
return None
if self.cursor.rowcount > 0:
rows = self.cursor.fetchall()
return_array = []
print rows
for row in rows:
temp_dict = dict(zip(zip_list, row))
return_array.append(temp_dict)
return return_array
else:
self.log.e(TAG,
'Not able to perform select operation on Enrollment table')
return None
if __name__ == "__main__":
email = "'*****@*****.**'"
password ='******'
from db.helpers.user import UserDBHelper
user = UserDBHelper()
f= {C.USER_TABLE_EMAIL:email}
print user.get_users(f)
# enrollment = EnrollmentDBHelper()
# filter_dict=dict()
# filter_dict[C.ENROLLMENT_TABLE_USER]='5'
# print enrollment.get_enrollments(filter_dict)
def run(self):
# Return All the users in the User table
log = Logger('TeamsGetHandlerThread')
tag = 'run'
print 'In TeamsGetHandlerThread'
final_dict = {}
role = RoleDBHelper()
team = TeamDBHelper()
user = UserDBHelper()
team_name = self.request.get_argument('team', None)
offset = self.request.get_argument('offset', None)
count = self.request.get_argument('count', None)
sort_by = self.request.get_argument('sort_by',
True) # Intentionally done
name_query = self.request.get_argument('name', None)
role_query = self.request.get_argument('role', None)
device_query = self.request.get_argument('device_id', None)
sort_order = self.request.get_argument('sort', None)
filter_key = str(self.request.get_argument('filter_key', None))
filter_value = self.request.get_argument('filter_value', None)
# Find all the roles in the Roles Table
if filter_key == 'role':
role_name = filter_value
role_id = role.get_role_by_name(str(role_name), self.company_id)
else:
role_name = None
role_id = None
if name_query:
query = name_query
query_type = 'name'
elif role_query:
query = role_query
query_type = 'role'
elif device_query:
query = device_query
query_type = 'device'
else:
query = None
query_type = None
if team_name:
team_id = team.get_team_by_name(str(team_name), self.company_id)
else:
team_id = None
teams_list = team.get_teams(self.company_id,
[c.TEAM_TABLE_NAME, c.TEAM_TABLE_ID])
if team_id:
result_list, total_count = user.get_users_for_team(
team_name=team_name,
team_id=team_id,
role_name=role_name,
role_id=role_id,
offset=offset,
count=count,
sort_by=sort_by,
query=query,
query_type=query_type,
sort_order=sort_order)
elif teams_list:
for _team in teams_list:
_team['team_type'] = _team.get('name')
_team['team_name'] = _team.get('name')
_team['team_id'] = _team.get('id')
del _team['name']
del _team['id']
result_list = teams_list
total_count = len(result_list)
else:
result_list = None
if result_list:
print "\n total", total_count
final_dict['data'] = result_list
final_dict['count'] = total_count
final_dict['pass'] = True
final_dict['message'] = 'Success ...'
else:
final_dict['pass'] = True
final_dict['data'] = []
log.e(tag, 'No Team in Team Table')
final_dict['message'] = 'Failed ...'
final_dict['count'] = 0
opJson = json.dumps(final_dict)
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
log = Logger('TeamGetHandlerThread')
TAG = 'GET'
page = self.request.get_argument('page', None)
count = self.request.get_argument('count', None)
sort_by = self.request.get_argument('sort_by', None)
if self.data is None:
log.e(TAG, 'No Team ID in Request')
opJson = json.dumps({
'pass':
False,
'message':
'No team found corresponding to the team \
id ' + str(self.data)
})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
team = TeamDBHelper()
teams = team.get_team(str(self.data), company_id=self.company_id)
outer_dict = {}
outer_array = []
print teams
if teams is None:
log.e(
TAG, 'No team found corresponding to the team id ' +
str(self.data))
opJson = json.dumps({
'pass':
False,
'message':
'No team found corresponding to the team \
id ' + str(self.data)
})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
self.team_name = teams.get(c.TEAM_TABLE_NAME)
user = UserDBHelper()
filter_dict = {c.USER_TABLE_TEAM: str(teams.get('id'))}
user_list = user.get_users_with_pages(filter_dict, int(page),
int(count), str(sort_by))
inner_array = []
if user_list is not None:
for users in user_list:
inner_dict = {}
self.user_id = str(users[c.USER_TABLE_ID])
self.user_name = str(users[c.USER_TABLE_NAME])
self.user_email = str(users[c.USER_TABLE_EMAIL])
self.user_role_id = str(users[c.USER_TABLE_ROLE])
# Find out the role for user
role = RoleDBHelper()
roles = role.get_role(self.user_role_id,
[c.ROLE_TABLE_NAME])
if roles is None:
self.user_role = None
else:
self.user_role = str(roles[c.ROLE_TABLE_NAME])
# Find out the device for user
device = DeviceDBHelper()
device_list = device.get_devices_of_user(self.user_id)
if device_list is None:
self.user_device = None
else:
devices = device_list[0]
self.user_device = str(
devices[c.DEVICE_TABLE_UDID])
self.user_device_os = str(
devices[c.DEVICE_TABLE_OS])
# Find out user violations
violation = ViolationsDBHelper()
violation_count = violation.get_violation_count(
str(devices.get('id')))
inner_dict = {
'user_id': self.user_id,
'user_name': self.user_name,
'user_role': self.user_role,
'user_team': self.team_name,
'user_device': self.user_device,
'user_violations': violation_count,
'user_device_os': self.user_device_os,
'user_email': self.user_email
}
inner_array.append(inner_dict)
outer_dict['name'] = self.team_name
outer_dict['users'] = inner_array
outer_dict['team_id'] = self.data
print '\nouter_dict'
print outer_dict
outer_array.append(outer_dict)
self.final_dict['pass'] = True
self.final_dict['teams'] = outer_array
opJson = json.dumps(self.final_dict)
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def merge(self, device_id):
user_helper = UserDBHelper()
device_helper = DeviceDBHelper()
roles_helper = RoleDBHelper()
teams_helper = TeamDBHelper()
company_helper = CompanyDBHelper()
policy_helper = PolicyDBHelper()
if device_id is not None:
device_details = device_helper.get_device(device_id)
if device_details is not None and 'user_id' in device_details:
user_details = user_helper.get_user(
str(device_details['user_id']))
team_id = user_details['team_id']
role_id = user_details['role_id']
company_id = user_details['company_id']
team_details = teams_helper.get_team(str(team_id))
role_details = roles_helper.get_role(str(role_id))
company_details = company_helper.get_company(str(company_id))
if user_details is not None and 'policy_id' in user_details:
policy_id_user = user_details['policy_id']
else:
print 'No user details found'
if team_details is not None and 'policy_id' in team_details:
policy_id_team = team_details['policy_id']
else:
print 'no team details found'
if role_details is not None and 'policy_id' in role_details:
policy_id_role = role_details['policy_id']
else:
print 'no role details found'
if (company_details is not None
and 'policy_id' in company_details):
policy_id_company = company_details['policy_id']
else:
print 'no company details found'
if policy_id_company is not None:
print 'company policy id=', policy_id_company
policy_company = policy_helper.get_policy(
str(policy_id_company))
else:
policy_company = None
if policy_id_role is not None:
print 'role policy id=', policy_id_role
policy_role = policy_helper.get_policy(str(policy_id_role))
else:
policy_role = None
if policy_id_team is not None:
print 'team policy id=', policy_id_team
policy_team = policy_helper.get_policy(str(policy_id_team))
else:
policy_team = None
if policy_id_user is not None:
print 'user policy id=', policy_id_user
policy_user = policy_helper.get_policy(str(policy_id_user))
else:
policy_user = None
return self.merge_policies(policy_company, policy_role,
policy_team, policy_user)
else:
print 'Invalid device id'
def perform(self):
TAG = 'run'
print 'In RuN'
self.insert = True
json_data = self.data
print json_data['to']
#Find out the category of the Device on the basis of 'to' field
# Case 1 : Command is sent to the USER
if str(json_data['to']) == 'user':
to_id = str(json_data['id'])
company_id = json_data.get('company_id')
user = UserDBHelper()
user_dict = user.get_user(str(to_id), company_id=company_id,
pluck=[c.USER_TABLE_NAME])
if user_dict is not None:
user_name = str(user_dict[c.USER_TABLE_NAME])
message = "Command sent to " + user_name +\
" having ID = " + str(json_data['id'])
logs = LogsDBHelper()
logs_id = logs.add_log(to_id, str(json_data['to']), 'info',
None, message, raw=None, company=str(company_id))
if logs_id is None:
self.log.e(TAG, 'Not able to insert the logs')
self.command_to_user(json_data)
else:
self.log.e(TAG, 'No details corresponding to user found')
#Case 2: Command is sent to the Teams
elif str(json_data['to']) == 'team':
print 'sending to teams'
team_id = str(json_data['id'])
company_id = json_data.get('company_id')
team = TeamDBHelper()
team_dict = team.get_team(str(team_id), company_id=company_id,
pluck=[c.TEAM_TABLE_NAME])
if team_dict is not None:
team_name = str(team_dict[c.TEAM_TABLE_NAME])
message = "Command sent to " + team_name +\
" having ID = " + str(json_data['id'])
logs = LogsDBHelper()
logs_id = logs.add_log(team_id, str(json_data['to']), 'info',
None, message, raw=None, company=str(company_id))
if logs_id is None:
self.log.e(TAG, 'Not able to insert the logs')
self.command_to_team(json_data)
else:
self.log.e(TAG, "No details corresponding to team_id found. ")
#Case 3: Command is sent to the Role
elif str(json_data['to']) == 'role':
role_id = str(json_data['id'])
company_id = json_data.get('company_id')
role = RoleDBHelper()
role_dict = role.get_role(str(role_id), company_id=company_id,
pluck=[c.ROLE_TABLE_NAME])
if role_dict is not None:
role_name = str(role_dict[c.ROLE_TABLE_NAME])
message = "Command sent to " + role_name +\
" having ID = " + str(json_data['id'])
logs = LogsDBHelper()
logs_id = logs.add_log(role_id, str(json_data['to']), 'info',
None, message, raw=None, company=str(company_id))
if logs_id is None:
self.log.e(TAG, 'Not able to insert the logs')
self.command_to_role(json_data)
else:
self.log.e(TAG, 'No role corresponding to given role_id found')
elif str(json_data['to']) == 'company':
company_id = str(json_data['id'])
company = CompanyDBHelper()
company_dict = company.get_company(str(company_id))
if company_dict is not None:
company_name = str(company_dict[c.COMPANY_TABLE_NAME])
message = "Command sent to " + company_name\
+" having ID = " + str(json_data['id'])
logs = LogsDBHelper()
logs_id = logs.add_log(company_id, str(json_data['to']),
'info', None, message, raw=None, company=company_id)
if logs_id is None:
self.log.e(TAG, 'Not able to insert the logs')
self.command_to_company(json_data)
else:
self.log.e(TAG, 'No data corresponding to team id given found')
#Case 5: Some other parameter sent in 'to' field
else:
self.log.e(TAG, 'Somthing wrong with \'to\' field of POST data')
##Create the O/P JSON
opJson = json.dumps({'pass':False, 'error':'Correct TO field'})
self.log.e(TAG, str(opJson))
def parse(self,
excel_path,
company,
company_name=None,
callback=None,
user_added_callback=None):
COMPANY = company
company_name = company_name
book = open_workbook(filename=excel_path)
sheet = book.sheet_by_index(0)
users = list()
for row_index in range(sheet.nrows):
user = dict()
for col_index in range(sheet.ncols):
cell = sheet.cell(row_index, col_index).value
if col_index == 0:
user[C.USER_TABLE_EMAIL] = cell
elif col_index == 1:
user[C.USER_TABLE_NAME] = cell
elif col_index == 2:
user[C.USER_TABLE_TEAM] = cell
elif col_index == 3:
user[C.USER_TABLE_ROLE] = cell
users.append(user)
roles_list = list()
teams_list = list()
for user in users:
if C.USER_TABLE_ROLE in user:
roles_list.append(user[C.USER_TABLE_ROLE])
if C.USER_TABLE_TEAM in user:
teams_list.append(user[C.USER_TABLE_TEAM])
# get a set to get the unique elements.
roles = dict()
teams = dict()
roles_helper = RoleDBHelper()
teams_helper = TeamDBHelper()
users_helper = UserDBHelper()
enrollment_helper = EnrollmentDBHelper()
for role_name in set(roles_list):
role = dict()
role[C.ROLE_TABLE_COMPANY] = COMPANY
role[C.ROLE_TABLE_NAME] = role_name
roles[role_name] = roles_helper.add_role(role)
for team_name in set(teams_list):
team = dict()
team[C.TEAM_TABLE_COMPANY] = COMPANY
team[C.TEAM_TABLE_NAME] = team_name
team[C.TEAM_TABLE_DELETED] = False
teams[team_name] = teams_helper.add_team(team)
# Now we have id for all teams and roles... Insert the users now.
for user in users:
user_obj = dict()
user_obj[C.USER_TABLE_COMPANY] = COMPANY
user_obj[C.USER_TABLE_EMAIL] = user[C.USER_TABLE_EMAIL]
user_obj[C.USER_TABLE_NAME] = user[C.USER_TABLE_NAME]
user_obj[C.USER_TABLE_ROLE] = roles[user[C.USER_TABLE_ROLE]]
user_obj[C.USER_TABLE_TEAM] = teams[user[C.USER_TABLE_TEAM]]
user['id'] = users_helper.add_user_if_not_exists(user_obj)[0]
if user_added_callback is not None:
user_added_callback(user_obj)
for user in users:
enrollment = dict()
enrollment[C.ENROLLMENT_TABLE_USER] = user['id']
enrollment[C.ENROLLMENT_TABLE_PASSWORD] = generate_password()
enrollment[C.ENROLLMENT_TABLE_IS_ENROLLED] = False
user['passcode'] = enrollment[C.ENROLLMENT_TABLE_PASSWORD]
print 'adding enrollment ', enrollment
user['enrollment_id'] = enrollment_helper.add_enrollment(
enrollment)
user['company_name'] = company_name
if callback is not None:
callback(users)
return users
def run(self):
# Return All the users in the User table
log = Logger('UserDeleteHandlerThread')
tag = 'DELETE'
if self.data is None:
log.e(tag, 'No user registered in table for this user_id')
opJson = json.dumps({
'pass':
False,
'message':
'No user registered in table for this user_id'
})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
user = UserDBHelper()
device = DeviceDBHelper()
enrollment = EnrollmentDBHelper()
print 'print data here \n ... \n ', self.data
user_list = user.get_user(str(self.data), company_id=self.company_id)
if user_list is None:
log.e(tag, 'No user registered in table for this user_id')
opJson = json.dumps({
'pass':
False,
'message':
'No user registered in table for this user_id'
})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
user_deleted = user.delete_user(str(user_list.get('id')))
if not user_deleted:
log.e(tag, 'Not able to delete from user table')
opJson = json.dumps({
'pass':
False,
'message':
'Not able to delete from user table'
})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
devices = device.get_devices_of_user(str(self.data))
if devices is not None and len(devices) > 0:
for each_device in devices:
device_id = each_device.get('id')
device.delete_device(str(device_id))
enrollment_list = enrollment.get_enrollments(
{'device_id': device_id})
for enroll in enrollment_list:
enrollment_id = enroll.get('id')
enrollment.update_enrollment(
str(enrollment_id), {
'device_id': "null",
'is_enrolled': False
})
log.i(tag, 'User delelted')
opJson = json.dumps({
'pass': True,
'message': 'User Successfully deleted'
})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def admin_mailer(device_id, violation_id, *args, **kwargs):
TAG = 'admin mailer'
base = DBHelper()
cur = base.cursor
log = Logger('AdminMailer')
device = DeviceDBHelper()
violation = ViolationsDBHelper()
user = UserDBHelper()
company = CompanyDBHelper()
email_list = []
device_os_mapper = {'ios': 'iOS', 'samsung': 'android'}
### Device information ###
device_info = device.get_device(str(device_id), status=True)
if device_info:
device_os = device_info.get('os')
device_os = device_os_mapper.get(device_os)
device_os_version = device_info.get('os_version')
user_info = user.get_user(str(device_info.get('user_id')))
else:
device_os = None
device_os_version = None
user_info = None
### User information ###
if user_info:
username = user_info.get('name')
company_id = user_info.get('company_id')
company_info = company.get_company(str(company_id))
else:
username = None
company_info = None
company_id = None
### Violation information ###
violation_info = violation.get_violation(str(violation_id))
if violation_info:
violation_time = violation_info.get('timestamp')
violation_time = violation_time.strftime('%d %b, %Y at %H:%M:%S')
else:
violation_time = None
### Company information ###
if company_info:
company_name = company_info.get('name')
### Query to get admin information for the particulat company ###
try:
cur.execute("""SELECT * FROM admin_profile
WHERE company_id = {0}""".format(company_id))
except Exception as err:
log.e(TAG, 'Exception : ' + repr(err))
if cur.rowcount > 0:
rows = cur.fetchall()
for row in rows:
# ipdb.set_trace()
email_list.append(row[1])
else:
log.i(
TAG,
"""No admin user found for the violated device with company
id : {0}""".format(company_id))
print "Query over admin went wrong"
else:
company_name = None
if len(email_list) > 0 and all(
x is not None
for x in (username, company_name, violation_time, device_os)):
message = loader.load('violation_mail.html').generate(
username=username,
company_name=company_name,
violation_time=violation_time,
device_os=device_os,
device_os_version=device_os_version)
try:
ses_conn.send_email('*****@*****.**',
'User MDM Violations Notification',
message,
email_list,
format='html')
except Exception as err:
log.e(TAG, "Error in sending mail from ses side.")
else:
log.i(
TAG, """No admin found for the violated device with company id :
{0}""".format(company_id))
def perform(self):
TAG = 'run'
print 'In RuN'
self.insert = True
json_data = self.data
print json_data['to']
# Find out the category of the Device on the basis of 'to' field
# Case 1 : Command is sent to the USER
if str(json_data['to']) == 'user':
to_id = str(json_data['id'])
company_id = json_data.get('company_id')
user = UserDBHelper()
user_dict = user.get_user(str(to_id), company_id=company_id,
pluck=[c.USER_TABLE_NAME])
if user_dict is not None:
user_name = str(user_dict[c.USER_TABLE_NAME])
message = "Command sent to " + user_name +\
" having ID = " + str(json_data['id'])
logs = LogsDBHelper()
logs_id = logs.add_log(to_id,
str(json_data['to']),
'info',
None,
message,
raw=None,
company=str(company_id))
if logs_id is None:
self.log.e(TAG, 'Not able to insert the logs')
self.command_to_user(json_data)
else:
self.log.e(TAG, 'No details corresponding to user found')
# Case 2: Command is sent to the Teams
elif str(json_data['to']) == 'team':
print 'sending to teams'
team_id = str(json_data['id'])
company_id = json_data.get('company_id')
team = TeamDBHelper()
team_dict = team.get_team(str(team_id), company_id=company_id,
pluck=[c.TEAM_TABLE_NAME])
if team_dict is not None:
team_name = str(team_dict[c.TEAM_TABLE_NAME])
message = "Command sent to " + team_name +\
" having ID = " + str(json_data['id'])
logs = LogsDBHelper()
logs_id = logs.add_log(team_id,
str(json_data['to']),
'info',
None,
message,
raw=None,
company=str(company_id))
if logs_id is None:
self.log.e(TAG, 'Not able to insert the logs')
self.command_to_team(json_data)
else:
self.log.e(TAG, "No details corresponding to team_id found. ")
# Case 3: Command is sent to the Role
elif str(json_data['to']) == 'role':
role_id = str(json_data['id'])
company_id = json_data.get('company_id')
role = RoleDBHelper()
role_dict = role.get_role(str(role_id), company_id=company_id,
pluck=[c.ROLE_TABLE_NAME])
if role_dict is not None:
role_name = str(role_dict[c.ROLE_TABLE_NAME])
message = "Command sent to " + role_name +\
" having ID = " + str(json_data['id'])
logs = LogsDBHelper()
logs_id = logs.add_log(role_id,
str(json_data['to']),
'info',
None,
message,
raw=None,
company=str(company_id))
if logs_id is None:
self.log.e(TAG, 'Not able to insert the logs')
self.command_to_role(json_data)
else:
self.log.e(TAG, 'No role corresponding to given role_id found')
elif str(json_data['to']) == 'company':
company_id = str(json_data['id'])
company = CompanyDBHelper()
company_dict = company.get_company(str(company_id))
if company_dict is not None:
company_name = str(company_dict[c.COMPANY_TABLE_NAME])
message = "Command sent to " + company_name\
+ " having ID = " + str(json_data['id'])
logs = LogsDBHelper()
logs_id = logs.add_log(company_id,
str(json_data['to']),
'info',
None,
message,
raw=None,
company=company_id)
if logs_id is None:
self.log.e(TAG, 'Not able to insert the logs')
self.command_to_company(json_data)
else:
self.log.e(TAG, 'No data corresponding to team id given found')
# Case 5: Some other parameter sent in 'to' field
else:
self.log.e(TAG, 'Somthing wrong with \'to\' field of POST data')
# Create the O/P JSON
opJson = json.dumps({'pass': False, 'error': 'Correct TO field'})
self.log.e(TAG, str(opJson))
self.log.e(TAG, 'Exception: ' + repr(err))
return None
if self.cursor.rowcount > 0:
rows = self.cursor.fetchall()
return_array = []
print rows
for row in rows:
temp_dict = dict(zip(zip_list, row))
return_array.append(temp_dict)
return return_array
else:
self.log.e(TAG, 'Not able to perform select operation on \
Enrollment table')
return None
if __name__ == "__main__":
email = "'*****@*****.**'"
password = '******'
from db.helpers.user import UserDBHelper
user = UserDBHelper()
f = {C.USER_TABLE_EMAIL: email}
print user.get_users(f)
# enrollment = EnrollmentDBHelper()
# filter_dict=dict()
# filter_dict[C.ENROLLMENT_TABLE_USER]='5'
# print enrollment.get_enrollments(filter_dict)
def run(self):
# Return All the users in the User table
log = Logger('RolesGetHandler')
tag = 'run'
final_dict = {}
role = RoleDBHelper()
team = TeamDBHelper()
user = UserDBHelper()
role_name = self.request.get_argument('role', None)
offset = self.request.get_argument('offset', None)
count = self.request.get_argument('count', None)
name_query = self.request.get_argument('name', None)
team_query = self.request.get_argument('team', None)
device_query = self.request.get_argument('device_id', None)
sort_by = self.request.get_argument(
'sort_by',
True) # Intentionally done
sort_order = self.request.get_argument('sort', None)
filter_key = str(self.request.get_argument('filter_key', None))
filter_value = self.request.get_argument('filter_value', None)
print role_name
print "\nUI sorting order \n", sort_order
# Find all the roles in the Roles Table
# outer_array = []
if name_query:
query = name_query
query_type = 'name'
elif team_query:
query = team_query
query_type = 'team'
elif device_query:
query = device_query
query_type = 'device'
else:
query = None
query_type = None
if filter_key == 'team':
team_name = filter_value
team_id = team.get_team_by_name(str(team_name), self.company_id)
else:
team_name = None
team_id = None
print "printing team id here ..", team_id
if role_name:
role_id = role.get_role_by_name(str(role_name), self.company_id)
else:
roles_list = role.get_roles(self.company_id, [c.ROLE_TABLE_NAME,
c.ROLE_TABLE_ID])
role_id = None
if role_id:
result_list, total_count = user.get_users_for_role(
role_name=role_name, role_id=role_id,
team_name=team_name, team_id=team_id, offset=offset,
count=count, sort_by=sort_by, query=query,
query_type=query_type, sort_order=sort_order)
elif roles_list:
for _role in roles_list:
_role['role_type'] = _role.get('name')
_role['role_name'] = _role.get('name')
_role['role_id'] = _role.get('id')
del _role['name']
del _role['id']
result_list = roles_list
total_count = len(result_list)
else:
result_list = None
if result_list:
final_dict['data'] = result_list
final_dict['count'] = total_count
final_dict['pass'] = True
final_dict['message'] = 'Seems like things are working ...'
else:
final_dict['data'] = []
final_dict['pass'] = True
log.e(tag, 'No Role in Role Table')
final_dict['message'] = 'Seems like things are not working ...'
final_dict['count'] = 0
opJson = json.dumps(final_dict)
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def admin_mailer(device_id, violation_id, *args, **kwargs):
TAG = 'admin mailer'
base = DBHelper()
cur = base.cursor
log = Logger('AdminMailer')
device = DeviceDBHelper()
violation = ViolationsDBHelper()
user = UserDBHelper()
company = CompanyDBHelper()
email_list = []
device_os_mapper = {'ios': 'iOS', 'samsung': 'android'}
### Device information ###
device_info = device.get_device(str(device_id), status=True)
if device_info:
device_os = device_info.get('os')
device_os = device_os_mapper.get(device_os)
device_os_version = device_info.get('os_version')
user_info = user.get_user(str(device_info.get('user_id')))
else:
device_os = None
device_os_version = None
user_info = None
### User information ###
if user_info:
username = user_info.get('name')
company_id = user_info.get('company_id')
company_info = company.get_company(str(company_id))
else:
username = None
company_info = None
company_id = None
### Violation information ###
violation_info = violation.get_violation(str(violation_id))
if violation_info:
violation_time = violation_info.get('timestamp')
violation_time = violation_time.strftime('%d %b, %Y at %H:%M:%S')
else:
violation_time = None
### Company information ###
if company_info:
company_name = company_info.get('name')
### Query to get admin information for the particulat company ###
try:
cur.execute("""SELECT * FROM admin_profile
WHERE company_id = {0}""".format(company_id))
except Exception as err:
log.e(TAG, 'Exception : ' + repr(err))
if cur.rowcount > 0:
rows = cur.fetchall()
for row in rows:
# ipdb.set_trace()
email_list.append(row[1])
else:
log.i(
TAG,
"""No admin user found for the violated device with company
id : {0}""".format(company_id))
print "Query over admin went wrong"
else:
company_name = None
if len(email_list) > 0 and all(
x is not None for x in (
username,
company_name,
violation_time,
device_os)):
message = loader.load('violation_mail.html').generate(
username=username, company_name=company_name,
violation_time=violation_time, device_os=device_os,
device_os_version=device_os_version)
try:
ses_conn.send_email('*****@*****.**',
'User MDM Violations Notification',
message, email_list, format='html')
except Exception as err:
log.e(TAG, "Error in sending mail from ses side.")
else:
log.i(
TAG,
"""No admin found for the violated device with company id :
{0}""".format(company_id))
def run(self):
log = Logger('UserPolicyPutHandlerThread')
TAG = 'run'
# Flag to track status of policy
status = False
if self.data and self.company_id:
# do stuff here
user = UserDBHelper()
url_data = self.data.split('/')
request_data = json.loads(self.request.request.body)
user_id = url_data[0]
plugin_name = url_data[1]
command_handler_json = {'to': 'user', 'id': str(user_id),
'company_id': self.company_id}
user_detail = user.get_user(str(user_id),
company_id=self.company_id)
if user_detail:
user_policy_id = user_detail.get('policy_id')
if plugin_name != 'actions':
status = put_individual_plugin(user_policy_id, plugin_name,
request_data)
else:
status = True
command_handler_json['action'] = request_data.get('action')
command_handler_json[
'passcode'] = request_data.get('lock_key')
if status:
print "\nprinting the json output will be send to command\
handler\n", command_handler_json
create_command_handler_task.delay(command_handler_json)
request_data['_id'] = user_policy_id
request_data['object_type'] = 'User'
request_data['name'] = user_detail[c.USER_TABLE_NAME]
opJson = json.dumps(
{'data': request_data, 'pass': True,
'count': 1, 'message': 'Everything fine'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(
self.callback)
else:
opJson = json.dumps(
{'pass': False, 'count': 0,
'message': 'Update operation at policy table \
failed'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(
self.callback)
else:
log.e(TAG, 'No valid user id is sent in request')
opJson = json.dumps(
{'pass': False,
'message': 'No valid user id is sent in request'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
log.e(TAG, 'UnAuthorized Access for user policy ')
self.request.set_status(401)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
# Find all the POST arguments required
company_id = self.company_id
# company_name = str(self.company_name)
loader = Loader("/opt/toppatch/mv/media/app/")
# thread1 = {}
log = Logger('EnrollDevice')
tag = 'POST'
request_body = json.loads(self.request.request.body)
try:
self.user_email = str(request_body.get('user_email', None))
self.user_name = str(request_body.get('user_name', None))
self.team_id = str(request_body.get('team_id', None))
self.role_id = str(request_body.get('role_id', None))
self.company_id = str(company_id)
except:
self.request.write('Some arguments are not supplied')
opJson = json.dumps({
'pass': False,
'user_name': None,
'link': None,
'password': None,
'error': 'Some argument not supplied'
})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
log.e(tag,
'Some arguments not sent in POST request for enrollment')
return
if self.user_email is None or self.user_name is None or\
self.company_id is None:
log.e(tag, 'Email or user_name is NULL')
opJson = json.dumps({
'pass':
False,
'user_name':
None,
'link':
None,
'password':
None,
'error':
'user_name or Email or Company \
is None'
})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
if self.user_name == '' or self.user_email == '':
log.e(tag, 'Email or user_name is empty')
opJson = json.dumps({
'pass':
False,
'user_name':
None,
'link':
None,
'password':
None,
'error':
'email or user_name or company \
is empty'
})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
password = generate_password()
user = UserDBHelper()
user_dict = {
c.USER_TABLE_NAME: str(self.user_name),
c.USER_TABLE_TEAM: str(self.team_id),
c.USER_TABLE_ROLE: str(self.role_id),
c.USER_TABLE_EMAIL: str(self.user_email),
c.USER_TABLE_COMPANY: str(self.company_id)
}
user_id, duplicate = user.add_user_if_not_exists(user_dict)
if duplicate:
log.e(tag, 'No id from primary key ')
opJson = json.dumps({
'pass': False,
'user_name': self.user_name,
'link': None,
'password': None,
'duplicate': True,
'error': 'DB has problem'
})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
enrollment_dict = {
c.ENROLLMENT_TABLE_USER: user_id,
c.ENROLLMENT_TABLE_PASSWORD: password,
c.ENROLLMENT_TABLE_IS_ENROLLED: False
}
enrollment = EnrollmentDBHelper()
enrollment_id = str(enrollment.add_enrollment(enrollment_dict))
enrollment_dict = enrollment.get_enrollment(enrollment_id)
if enrollment_id is not None:
self.link += enrollment_id
try:
message = loader.load('user_enroll_mail.html').generate(
company_name=self.company_name,
user_passwd=password,
activation_link=self.link)
ses_conn.send_email('*****@*****.**',
'MDM Enrollment verification',
message, [self.user_email],
format='html')
print 'No error found'
log.i(tag, 'Enrollment request successful')
opJson = json.dumps({
'pass': True,
'user_name': self.user_name,
'link': 'link',
'password': '******',
'error': None
})
except Exception as err:
print 'Mail Sending error exception is :', repr(err)
log.e(tag, 'Incorrect EmailID sent')
opJson = json.dumps({
'pass': False,
'user_name': self.user_name,
'link': None,
'password': None,
'error': 'Wrong emailID'
})
else:
log.e(
tag,
'Entry is not done in Enrollment table for UserID = ' +
str(user_id))
opJson = json.dumps({
'pass': False,
'user_name': self.user_name,
'link': None,
'password': None,
'error': 'Wrong emailID'
})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
log = Logger('UserPolicyGetHandlerThread')
TAG = 'run'
if self.data and self.company_id:
# do stuff here
user = UserDBHelper()
url_data = self.data.split('/')
user_id = url_data[0]
plugin_name = url_data[1]
user_detail = user.get_user(str(user_id),
company_id=self.company_id)
if user_detail:
user_policy_id = user_detail.get('policy_id')
if plugin_name == 'actions':
action_command = True
else:
action_command = False
print '\nplugin name \n', plugin_name
if user_policy_id and not action_command:
plugin_data = get_individual_plugin(user_policy_id,
plugin_name)
elif not action_command:
user_policy_id, plugin_data = setup_default_policy()
if user_policy_id:
user.update_user_policy(str(user_id),
str(user_policy_id))
plugin_data = plugin_data.get(plugin_name)
print 'printing plugin data here ... \n', plugin_data
else:
log.e(TAG, 'User Policy ID setup failed.')
opJson = json.dumps(
{'pass': False,
'message': 'User policy creation failed.'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(
self.callback)
else:
plugin_data = {}
if isinstance(plugin_data, str):
plugin_data = json.loads(plugin_data)
plugin_data['_id'] = user_policy_id
plugin_data['object_type'] = 'User'
plugin_data['name'] = user_detail.get(c.USER_TABLE_NAME)
opJson = json.dumps({'count': 1, 'message': 'Successfull',
'pass': True, 'data': plugin_data})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
log.e(TAG, 'No Valid User id is sent in request')
opJson = json.dumps(
{'pass': False, 'count': 0,
'message': 'No User id is sent in request'})
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
else:
log.e(TAG, 'UnAuthorized Access for user policy ')
self.request.set_status(401)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
# Return All the users in the User table
log = Logger('TeamsGetHandlerThread')
tag = 'run'
print 'In TeamsGetHandlerThread'
final_dict = {}
role = RoleDBHelper()
team = TeamDBHelper()
user = UserDBHelper()
team_name = self.request.get_argument('team', None)
offset = self.request.get_argument('offset', None)
count = self.request.get_argument('count', None)
sort_by = self.request.get_argument(
'sort_by',
True) # Intentionally done
name_query = self.request.get_argument('name', None)
role_query = self.request.get_argument('role', None)
device_query = self.request.get_argument('device_id', None)
sort_order = self.request.get_argument('sort', None)
filter_key = str(self.request.get_argument('filter_key', None))
filter_value = self.request.get_argument('filter_value', None)
# Find all the roles in the Roles Table
if filter_key == 'role':
role_name = filter_value
role_id = role.get_role_by_name(str(role_name), self.company_id)
else:
role_name = None
role_id = None
if name_query:
query = name_query
query_type = 'name'
elif role_query:
query = role_query
query_type = 'role'
elif device_query:
query = device_query
query_type = 'device'
else:
query = None
query_type = None
if team_name:
team_id = team.get_team_by_name(str(team_name), self.company_id)
else:
team_id = None
teams_list = team.get_teams(self.company_id, [c.TEAM_TABLE_NAME,
c.TEAM_TABLE_ID])
if team_id:
result_list, total_count = user.get_users_for_team(
team_name=team_name, team_id=team_id,
role_name=role_name, role_id=role_id,
offset=offset, count=count, sort_by=sort_by,
query=query, query_type=query_type,
sort_order=sort_order)
elif teams_list:
for _team in teams_list:
_team['team_type'] = _team.get('name')
_team['team_name'] = _team.get('name')
_team['team_id'] = _team.get('id')
del _team['name']
del _team['id']
result_list = teams_list
total_count = len(result_list)
else:
result_list = None
if result_list:
print "\n total", total_count
final_dict['data'] = result_list
final_dict['count'] = total_count
final_dict['pass'] = True
final_dict['message'] = 'Success ...'
else:
final_dict['pass'] = True
final_dict['data'] = []
log.e(tag, 'No Team in Team Table')
final_dict['message'] = 'Failed ...'
final_dict['count'] = 0
opJson = json.dumps(final_dict)
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def admin_mailer(device_id, violation_id, *args, **kwargs):
TAG='admin mailer'
base = DBHelper()
cur = base.cursor
log = Logger('AdminMailer')
device = DeviceDBHelper()
violation = ViolationsDBHelper()
user = UserDBHelper()
company = CompanyDBHelper()
email_list = []
device_os_mapper = {'ios': 'iOS', 'samsung': 'android'}
### Device information ###
device_info = device.get_device(str(device_id), status=True)
if device_info:
device_os = device_info.get('os')
device_os = device_os_mapper.get(device_os)
device_os_version = device_info.get('os_version')
user_info = user.get_user(str(device_info.get('user_id')))
else:
device_os = None
device_os_version = None
user_info = None
### User information ###
if user_info:
username = user_info.get('name')
company_id = user_info.get('company_id')
company_info = company.get_company(str(company_id))
else:
username = None
company_info = None
company_id = None
### Violation information ###
violation_info = violation.get_violation(str(violation_id))
if violation_info:
violation_time = violation_info.get('timestamp')
violation_time = violation_time.strftime('%d %b, %Y at %H:%M:%S')
else:
violation_time = None
### Company information ###
if company_info:
company_name = company_info.get('name')
### Query to get admin information for the particulat company ###
try:
cur.execute("""SELECT * FROM admin_profile
WHERE company_id = {0}""".format(company_id))
except Exception, err:
log.e(TAG, 'Exception : ' + repr(err))
if cur.rowcount > 0:
rows = cur.fetchall()
for row in rows:
#ipdb.set_trace()
email_list.append(row[1])
else:
log.i(TAG, """No admin user found for the violated device with company id : {0}""".format(company_id))
print "Query over admin went wrong"
def run(self):
#Return All the users in the User table
log = Logger('RolesGetHandler')
tag = 'run'
final_dict = {}
role = RoleDBHelper()
team = TeamDBHelper()
user = UserDBHelper()
role_name = self.request.get_argument('role', None)
offset = self.request.get_argument('offset', None)
count = self.request.get_argument('count', None)
name_query = self.request.get_argument('name', None)
team_query = self.request.get_argument('team', None)
device_query = self.request.get_argument('device_id', None)
sort_by = self.request.get_argument('sort_by', True)#Intentionally done
sort_order = self.request.get_argument('sort', None)
filter_key = str(self.request.get_argument('filter_key', None))
filter_value = self.request.get_argument('filter_value', None)
print role_name
print "\nUI sorting order \n", sort_order
## Find all the roles in the Roles Table
# outer_array = []
if name_query:
query = name_query
query_type = 'name'
elif team_query:
query = team_query
query_type = 'team'
elif device_query:
query = device_query
query_type = 'device'
else:
query = None
query_type = None
if filter_key == 'team':
team_name = filter_value
team_id = team.get_team_by_name(str(team_name), self.company_id)
else:
team_name = None
team_id=None
print "printing team id here ..", team_id
if role_name:
role_id = role.get_role_by_name(str(role_name), self.company_id)
else:
roles_list = role.get_roles(self.company_id, [c.ROLE_TABLE_NAME,
c.ROLE_TABLE_ID])
role_id = None
if role_id:
result_list, total_count = user.get_users_for_role(
role_name=role_name, role_id=role_id,
team_name=team_name, team_id=team_id, offset=offset,
count=count, sort_by=sort_by, query=query,
query_type=query_type, sort_order=sort_order)
elif roles_list:
for _role in roles_list:
_role['role_type'] = _role.get('name')
_role['role_name'] = _role.get('name')
_role['role_id'] = _role.get('id')
del _role['name']
del _role['id']
result_list = roles_list
total_count = len(result_list)
else:
result_list = None
if result_list:
final_dict['data'] = result_list
final_dict['count'] = total_count
final_dict['pass'] = True
final_dict['message'] = 'Seems like things are working ...'
else:
final_dict['data'] = []
final_dict['pass'] = True
log.e(tag,'No Role in Role Table')
final_dict['message'] = 'Seems like things are not working ...'
final_dict['count'] = 0
opJson = json.dumps(final_dict)
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
def run(self):
TAG = 'run'
print ' In IOSCommandPerformer\'s PUT'
command = IOSCommandDBHelper()
invoke_flag = False
arguments = cgi.parse_qsl(self.request.request.body)
intermediate = arguments[0]
currentxml = intermediate[1]
final = currentxml[25:-1] # Original Line
# final = currentxml[20:] ### For testing only
# print '\n\n\n here is final xml \n\n', final
# temp Parsing
# tree = ET.ElementTree(ET.fromstring(final)) ##Original Line
# tree = ET.parse('temp.xml') ### For testing only
initial_list = []
initial_dict = {}
check_out_requested = False
send_command = False
store_result = False
store_error = False
registered = True
special_result = False
acknowledged = False
update_token = False
object_root = objectify.fromstring(final)
begin = object_root.dict
for child in begin.iterchildren():
initial_list.append(child.text)
initial_dict = dict(zip(initial_list[::2], initial_list[1::2]))
# print '\n\n print here initial dict\n', initial_dict
if 'UDID' in initial_dict:
udid = initial_dict.get('UDID')
device = DeviceDBHelper()
registered = device.is_udid_registered(str(udid))
if 'Status' in initial_dict:
status = initial_dict.get('Status')
if status == 'Idle':
send_command = True
elif status == 'Acknowledged':
acknowledged = True
elif status == 'Error':
store_error = True
uuid = initial_dict.get('CommandUUID')
if 'MessageType' in initial_dict:
message = initial_dict.get('MessageType')
if message == 'TokenUpdate':
update_token = True
elif message == 'CheckOut':
check_out_requested = True
push_magic = 'push_magic'
token = 'Token'
unlock_token = 'UnlockToken'
if registered is False:
reply = """
"""
self.request.set_status(401)
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
else:
device_id = str(device.get_device_with_udid(udid)[0]['id'])
print 'reached here '
if acknowledged:
if 'CommandUUID' in initial_dict:
uuid = initial_dict.get('CommandUUID')
# special uuid for device information
if uuid == '55555555-5555-5555-5555-555555555555' + device_id:
info_list = [
el.text if el.text else el.tag for el in object_root.iterdescendants()]
info_list.pop(0)
final = dict(zip(info_list[::2], info_list[1::2]))
store_result = True
special_result = True
# special uuid for installed application list
elif uuid == (
'77777777-7777-7777-7777-777777777777' + device_id):
begin = object_root.dict.array
apps_list = []
for outer_child in begin.iterchildren():
temp_list = []
for inner_child in outer_child.iterchildren():
temp_list.append(inner_child.text)
apps_list.append(dict(zip(temp_list[::2],
temp_list[1::2])))
final = apps_list
store_result = True
invoke_flag = True
else:
store_result = True
if send_command:
if udid is None:
self.log.e(TAG, 'No UDID is supplied from the device')
else:
command_list = command.get_not_executed(str(device_id))
if command_list is None or len(command_list) == 0:
self.log.e(TAG, 'No command to execute fot the device \
having ID = ' + str(device_id))
reply = " "
print 'outer write'
self.request.set_status(500)
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
else:
device_details = DeviceDetailsDBHelper()
violate_device = False
special_uuid = (
'2929292929-29292929-292929-292929-292929' +
str(device_id))
commands = command_list[0]
action = str(commands[c.COMMAND_TABLE_ACTION])
command_attributes = commands[c.COMMAND_TABLE_ATTRIBUTE]
command_uuid = str(commands[c.COMMAND_TABLE_COMMAND_UUID])
if command_uuid == special_uuid:
violate_device = True
if action is not None and not violate_device:
command_xml_thread = IOSCommandCreatorThread(
action,
command_attributes,
command_uuid,
device_id)
command_xml_thread.start()
command_xml_thread.join()
final_output = command_xml_thread.command_profile
if final_output is not None:
self.request.write(final_output)
ioloop.IOLoop.instance().add_callback(self.callback)
# send polling signal to device for next command
device_details_list = (
device_details.get_device_details(device_id))
json_extras = device_details_list.get(
c.DEVICE_DETAILS_TABLE_EXTRAS)
self.push_magic = str(json_extras.get('push_magic'))
self.device_token = str(json_extras.get('token'))
wrapper = APNSNotificationWrapper(
'/opt/toppatch/assets/ios/PushCert.pem', False)
message = APNSNotification()
message.appendProperty(
APNSProperty(
"mdm",
self.push_magic))
message.tokenBase64(str(self.device_token))
wrapper.append(message)
wrapper.notify()
print 'Payload Sent'
elif violate_device:
### Wiping device to Factory Reset ###
command_xml_thread = IOSCommandCreatorThread(
action,
command_attributes,
command_uuid,
device_id)
command_xml_thread.start()
command_xml_thread.join()
final_output = command_xml_thread.command_profile
if final_output is not None:
self.request.write(final_output)
ioloop.IOLoop.instance().add_callback(self.callback)
violation = ViolationsDBHelper()
enrollment = EnrollmentDBHelper()
violation_id = violation.add_violation(str(device_id))
if violation_id is None:
self.log.e(TAG, 'Not able to insert in Violation \
Table. DeviceID = ' + str(device_id))
else:
device.delete_device(device_id)
enrollment_list = enrollment.get_enrollments({
'device_id': device_id})
for enroll in enrollment_list:
enrollment_id = enroll.get('id')
enrollment.update_enrollment(
str(enrollment_id), {
'device_id': "null",
'is_enrolled': False})
self.log.i(
TAG,
'Violation added for device id = ' +
str(device_id) +
'due to remote wipe command')
else:
reply = " "
print 'outer write'
self.request.set_status(500)
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
elif check_out_requested:
violation = ViolationsDBHelper()
device = DeviceDBHelper()
devices = device.get_device_with_udid(udid)
if devices is None:
self.log.e(TAG, 'No User ID Associated with Device UDID = '
+ udid)
else:
device_id = str(devices[0][c.DEVICE_TABLE_ID])
violation_id = violation.add_violation(device_id)
if violation_id is None:
self.log.e(TAG, 'Not able to insert in Violation Table.\
DeviceID = ' + str(device_id))
else:
self.log.i(TAG, 'Violation added for device id = ' +
str(device_id))
reply = """
"""
self.request.set_status(401)
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
elif store_result or store_error:
if special_result:
is_updated = device.update_device(
str(device_id), {
c.DEVICE_TABLE_OS_VERSION: str(
final.get('OSVersion'))})
if not is_updated:
self.log.e(TAG, 'Not able to set the version of the device\
udid = ' + str(udid) + " Device id = " + str(device_id))
else:
self.log.i(TAG, 'Version Set for the device udid = '
+ str(udid) + " Device id = " + str(device_id))
if store_error:
self.log.e(TAG, 'Error in Response for uuid = ' +
str(uuid) + ' device_id = ' + str(device_id))
# print '\n\nfinal dict to be stored as json is \n\n', final
result_updated = command.update_result(str(uuid),
str(device_id), final)
reply = """
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
</dict>
</plist>
"""
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
if not result_updated:
self.log.e(TAG, 'Result Not updated for uuid = ' +
str(uuid) + ' udid = ' + str(udid))
else:
executed = command.toggle_executed(str(uuid), str(device_id),
True)
if executed is False:
self.log.e(TAG, 'IOSCommand Table executed \
field is not updated CommandUUID = ' +
str(uuid) + 'Device id = ' + str(device_id))
self.log.i(TAG, 'Result send in DB for uuid = ' +
str(uuid) + ' udid = ' + str(udid))
if invoke_flag:
# Queue task to send command to user of app installation
user = UserDBHelper()
user_id = device.get_device_with_udid(str(
udid))[0]['user_id']
user_info = user.get_user(str(user_id))
json_data = {'to': 'user', 'id': user_id}
json_data['company_id'] = user_info.get('company_id')
create_command_handler_task.delay(json_data)
elif update_token:
device = DeviceDBHelper()
device_list = device.get_device_with_udid(udid)
device_id = 'device_id'
if device_list is not None and len(device_list) != 0:
for devices in device_list:
device_id = devices[c.DEVICE_TABLE_ID]
if device_id is None:
self.log.e(TAG, 'Device id is not found corresponding \
the udid = ' + str(udid))
else:
device_details = DeviceDetailsDBHelper()
device_details_dict = {
c.DEVICE_DETAILS_TABLE_DEVICE_TOKEN: token,
c.DEVICE_DETAILS_TABLE_PUSH_MAGIC: push_magic,
c.DEVICE_DETAILS_TABLE_UNLOCK_TOKEN: unlock_token
}
is_updated = device_details.update_device_details(
str(device_id), device_details_dict)
if not is_updated:
self.log.e(TAG, 'Not able to update the device \
details of device_id = ' + str(device_id))
else:
self.log.i(TAG, 'Device Details successfully \
updated device id = ' + str(device_id))
reply = """
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
</dict>
</plist>
"""
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
else:
reply = """
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
</dict>
</plist>
"""
print 'outer write'
self.request.write(reply)
ioloop.IOLoop.instance().add_callback(self.callback)
def parse(self, excel_path, company, company_name=None, callback=None,
user_added_callback=None):
COMPANY = company
company_name = company_name
book = open_workbook(filename=excel_path)
sheet = book.sheet_by_index(0)
users = list()
for row_index in range(sheet.nrows):
user = dict()
for col_index in range(sheet.ncols):
cell = sheet.cell(row_index, col_index).value
if col_index == 0:
user[C.USER_TABLE_EMAIL] = cell
elif col_index == 1:
user[C.USER_TABLE_NAME] = cell
elif col_index == 2:
user[C.USER_TABLE_TEAM] = cell
elif col_index == 3:
user[C.USER_TABLE_ROLE] = cell
users.append(user)
roles_list = list()
teams_list = list()
for user in users:
if C.USER_TABLE_ROLE in user:
roles_list.append(user[C.USER_TABLE_ROLE])
if C.USER_TABLE_TEAM in user:
teams_list.append(user[C.USER_TABLE_TEAM])
# get a set to get the unique elements.
roles = dict()
teams = dict()
roles_helper = RoleDBHelper()
teams_helper = TeamDBHelper()
users_helper = UserDBHelper()
enrollment_helper = EnrollmentDBHelper()
for role_name in set(roles_list):
role = dict()
role[C.ROLE_TABLE_COMPANY] = COMPANY
role[C.ROLE_TABLE_NAME] = role_name
roles[role_name] = roles_helper.add_role(role)
for team_name in set(teams_list):
team = dict()
team[C.TEAM_TABLE_COMPANY] = COMPANY
team[C.TEAM_TABLE_NAME] = team_name
team[C.TEAM_TABLE_DELETED] = False
teams[team_name] = teams_helper.add_team(team)
# Now we have id for all teams and roles... Insert the users now.
for user in users:
user_obj = dict()
user_obj[C.USER_TABLE_COMPANY] = COMPANY
user_obj[C.USER_TABLE_EMAIL] = user[C.USER_TABLE_EMAIL]
user_obj[C.USER_TABLE_NAME] = user[C.USER_TABLE_NAME]
user_obj[C.USER_TABLE_ROLE] = roles[user[C.USER_TABLE_ROLE]]
user_obj[C.USER_TABLE_TEAM] = teams[user[C.USER_TABLE_TEAM]]
user['id'] = users_helper.add_user_if_not_exists(user_obj)[0]
if user_added_callback is not None:
user_added_callback(user_obj)
for user in users:
enrollment = dict()
enrollment[C.ENROLLMENT_TABLE_USER] = user['id']
enrollment[C.ENROLLMENT_TABLE_PASSWORD] = generate_password()
enrollment[C.ENROLLMENT_TABLE_IS_ENROLLED] = False
user['passcode'] = enrollment[C.ENROLLMENT_TABLE_PASSWORD]
print 'adding enrollment ', enrollment
user['enrollment_id'] = enrollment_helper.add_enrollment(
enrollment)
user['company_name'] = company_name
if callback is not None:
callback(users)
return users
def run(self):
# Return All the users in the User table
log = Logger('UsersGetHandlerThreadWithPage')
tag = 'run'
company_id = self.company_id
final_dict = {}
user = UserDBHelper()
team = TeamDBHelper()
role = RoleDBHelper()
violation = ViolationsDBHelper()
device = DeviceDBHelper()
offset = self.request.get_argument('offset', None)
count = self.request.get_argument('count', None)
name_query = self.request.get_argument('name', None)
team_query = self.request.get_argument('team', None)
role_query = self.request.get_argument('role', None)
device_query = self.request.get_argument('device_id', None)
sort_by = self.request.get_argument('sort_by',
True) # Intentionally done
sort_order = self.request.get_argument('sort', None)
filter_key = self.request.get_argument('filter_key', None)
filter_value = self.request.get_argument('filter_value', None)
if filter_key == 'role':
role_name = filter_value
role_id = role.get_role_by_name(str(role_name), company_id)
else:
role_name = None
role_id = None
if filter_key == 'team':
team_name = filter_value
team_id = team.get_team_by_name(str(team_name), company_id)
else:
team_name = None
team_id = None
if filter_key == 'os':
os_mapper = {'Android': 'samsung', 'iOS': 'ios'}
os_type = os_mapper.get(str(filter_value))
else:
os_type = None
if name_query:
query = name_query
query_type = 'name'
elif role_query:
query = role_query
query_type = 'role'
elif device_query:
query = device_query
query_type = 'device'
elif team_query:
query = team_query
query_type = 'team'
else:
query = None
query_type = None
if offset:
result_list, total_count = user.get_users_for_user(
company_id=company_id,
offset=offset,
count=count,
role_id=role_id,
team_id=team_id,
query=query,
query_type=query_type,
os_type=os_type,
sort_by=sort_by,
sort_order=sort_order,
filter_key=filter_key,
filter_value=filter_value)
else:
result_list, total_count = user.get_users(
{c.USER_TABLE_COMPANY: company_id})
if result_list:
for user_dict in result_list:
device_deleted = False
device_info = device.get_device_with_udid(
user_dict.get('user_device'))
if not device_info:
device_info = device.get_device_with_udid(
user_dict.get('user_device'), status=True)
device_deleted = True
if device_info:
device_id = device_info[0].get(c.DEVICE_TABLE_ID)
else:
device_id = None
if device_deleted:
user_dict['user_device'] = None
user_dict['user_device_os'] = None
if device_id:
print "printing \n device id", device_id
violation_count = violation.get_violation_count(
company_id=company_id, device_id=str(device_id))
else:
violation_count = 0
user_dict['user_violation'] = violation_count
final_dict['data'] = result_list
final_dict['count'] = total_count
final_dict['pass'] = True
final_dict['message'] = 'Seems like things are working ...'
else:
final_dict['pass'] = True
log.e(tag, 'No User in User Table')
final_dict['message'] = 'Seems like things are not working ...'
final_dict['count'] = 0
# add all the data into dictionary and create output json
opJson = json.dumps(final_dict)
self.request.write(opJson)
tornado.ioloop.IOLoop.instance().add_callback(self.callback)
