def main():
flavor_name = test_config.instance_properties['flavor_name']
image_name = test_config.instance_properties['image_name']
availability_zone = test_config.instance_properties['availability_zone']
DEFAULT = test_config.instance_properties['default_number_of_instances']
if len(sys.argv) < 2:
print('INFO: Number of instances is not passed, using DEFAULT = %d' % DEFAULT)
num_instances = DEFAULT
else:
try:
num_instances = int(sys.argv[1])
except Exception:
print('ERROR: Invalid argument passed, needs to be integer')
print('INFO: Using DEFAULT = %d instead' % DEFAULT)
num_instances = DEFAULT
keystone_url = credentials.keystone_cfg['service_url']
username = credentials.keystone_cfg['username']
password = credentials.keystone_cfg['password']
user_domain_name = credentials.keystone_cfg['user_domain_name']
project_name = credentials.keystone_cfg['project_name']
project_domain_name = credentials.keystone_cfg['project_domain_name']
VERSION = credentials.keystone_cfg['nova_api_version']
auth_service = AuthService(keystone_url=keystone_url,
username = username,
password = password,
user_domain_name = user_domain_name,
project_name = project_name,
project_domain_name = project_domain_name,
nova_api_version = VERSION)
try:
print('Authenticating, waiting server to respond')
nova = client.Client(VERSION, session=auth_service.get_session())
print('Getting desired flavor %s' % flavor_name)
flavor = nova.flavors.find(name = flavor_name)
print('Getting desired image %s' % image_name)
image = nova.images.find(name = image_name)
print('Getting network list')
networks = nova.networks.list()
print('Creating nic with network id %s' % networks[0].id)
nics = [{'net-id' : networks[0].id}]
for i in range(num_instances):
name = 'random ' + str(i) + str(time())
print('Starting server %s' % name)
server = nova.servers.create(name = name,
image = image.id,
flavor = flavor.id,
nics = nics,
availability_zone = availability_zone)
except Exception as e:
print e
print 'Finished ...'
def o365_auth_callback(request):
AuthService.validate_state(request)
code = request.POST.get('code')
redirect_uri = AuthService.get_redirect_uri(request, 'Auth/O365/Callback')
auth_result = token_service.get_token_with_code(code, redirect_uri,
constant.Resources.MSGraph)
o365_user_id = auth_result.get('oid')
tenant_id = auth_result.get('tenantId')
token_service.cache_tokens(auth_result, o365_user_id)
ms_graph_service = MSGraphService(auth_result.get('accessToken'))
o365_user = ms_graph_service.get_o365_user(tenant_id)
AuthService.set_o365_user(request, o365_user)
for role in o365_user.roles:
user_service.update_role(o365_user.id, role)
user_service.create_or_update_organization(tenant_id,
o365_user.tenant_name)
local_user = user_service.get_user_by_o365_email(o365_user.email)
if local_user:
auth_login(request, local_user)
response = HttpResponseRedirect('/')
response.set_cookie(constant.o365_username_cookie, o365_user.display_name)
response.set_cookie(constant.o365_email_cookie, o365_user.email)
return response
def __call__(self, request):
user = AuthService.get_current_user(request)
if user.are_linked:
if not Profile.objects.filter(id=user.user_id,
o365UserId=user.o365_user_id):
auth_logout(request)
AuthService.set_o365_user(request, user.o365_user)
return self.get_response(request)
def login_o365(request):
extra_params = {
'scope': 'openid+profile',
'nonce': AuthService.get_random_string(),
'prompt': 'login'
}
o365_login_url = AuthService.get_authorization_url(
request, 'code+id_token', 'Link/ProcessCode',
AuthService.get_random_string(), extra_params)
return HttpResponseRedirect(o365_login_url)
def main():
DEFAULT = test_config.instance_properties["default_number_of_instances"]
if len(sys.argv) < 2:
print ("INFO: Number of instances to delete is not passed, using DEFAULT = %d" % DEFAULT)
num_instances = DEFAULT
else:
try:
num_instances = int(sys.argv[1])
except Exception:
print ("ERROR: Invalid argument passed, needs to be integer")
print ("INFO: Using DEFAULT = %d instead" % DEFAULT)
num_instances = DEFAULT
keystone_url = credentials.keystone_cfg["service_url"]
username = credentials.keystone_cfg["username"]
password = credentials.keystone_cfg["password"]
user_domain_name = credentials.keystone_cfg["user_domain_name"]
project_name = credentials.keystone_cfg["project_name"]
project_domain_name = credentials.keystone_cfg["project_domain_name"]
VERSION = credentials.keystone_cfg["nova_api_version"]
auth_service = AuthService(
keystone_url=keystone_url,
username=username,
password=password,
user_domain_name=user_domain_name,
project_name=project_name,
project_domain_name=project_domain_name,
nova_api_version=VERSION,
)
try:
print ("Authenticating, waiting server to respond")
novaclient = client.Client(VERSION, session=auth_service.get_session())
print ("Waiting for server list ")
servers = novaclient.servers.list()
total_num = len(servers)
print ("Total number of servers %d" % total_num)
if total_num < num_instances:
num_instances = total_num
print ("Number of instances to delete %d" % num_instances)
for i in range(num_instances):
print ("Deleting server %s " % servers[i].name)
novaclient.servers.delete(servers[i])
except Exception as e:
print e
print "Finished ..."
def o365_login(request):
extra_params = {'nonce': AuthService.get_random_string()}
o365_email = request.COOKIES.get(constant.o365_email_cookie)
if o365_email:
extra_params['login_hint'] = o365_email
else:
extra_params['prompt'] = 'login'
o365_login_url = AuthService.get_authorization_url(
request, 'code', 'Auth/O365/Callback', AuthService.get_random_string(),
extra_params)
settings.SESSION_EXPIRE_AT_BROWSER_CLOSE = True
return HttpResponseRedirect(o365_login_url)
def process_code(request):
AuthService.validate_state(request)
id_token = AuthService.get_id_token(request)
tenant_id = id_token.get('tid')
user_service.update_organization(tenant_id, True)
message = 'Admin consented successfully!'
user = AuthService.get_current_user(request)
if user.is_authenticated:
request.session['Message'] = message
return HttpResponseRedirect('/Admin')
else:
return HttpResponseRedirect('/Admin/Consent?consented=true')
def consent(request):
user = AuthService.get_current_user(request)
extra_params = {
'scope': 'openid+profile',
'nonce': AuthService.get_random_string(),
'prompt': 'admin_consent'
}
if user.o365_user:
extra_params['login_hint'] = user.o365_email
o365_login_url = AuthService.get_authorization_url(
request, 'code+id_token', 'Admin/ProcessCode',
AuthService.get_random_string(), extra_params)
return HttpResponseRedirect(o365_login_url)
def logoff(request):
user = AuthService.get_current_user(request)
AuthService.clear_o365_user(request)
auth_logout(request)
if not user.are_linked:
return HttpResponseRedirect('/')
else:
scheme = request.scheme
host = request.get_host()
redirect_uri = scheme + '://' + host
logoff_url = constant.log_out_url % (redirect_uri, redirect_uri)
response = HttpResponseRedirect(logoff_url)
response.set_cookie(constant.username_cookie, '')
response.set_cookie(constant.email_cookie, '')
return response
def login_local(request):
user = AuthService.get_current_user(request)
login_local_form = LoginLocalInfo()
context = {'user': user, 'login_local_form': login_local_form}
# POST /Link/LoginLocal
if request.method == 'POST':
login_local_form = LoginLocalInfo(request.POST)
if login_local_form.is_valid():
data = login_local_form.clean()
email = data['Email']
password = data['Password']
local_user = auth_authenticate(username=email, password=password)
if local_user:
link_service.link(local_user, user.o365_user)
auth_login(request, local_user)
request.session[
'Message'] = 'Your local account has been successfully linked to your Office 365 account.'
return HttpResponseRedirect('/')
else:
context['errors'] = ['Invalid login attempt.']
return render(request, 'link/loginlocal.html', context)
# GET /Link/LoginLocal
else:
local_user = user_service.get_user_by_email(user.o365_email)
if local_user:
link_service.link(local_user, user.o365_user)
local_user = user_service.get_user(
local_user.id) # reload local user
auth_login(request, local_user)
request.session[
'Message'] = 'Your local account has been successfully linked to your Office 365 account.'
return HttpResponseRedirect('/')
else:
return render(request, 'link/loginlocal.html', context)
def get_assignment_submission_resources(request,class_id,assignment_id):
user = AuthService.get_current_user(request)
token = token_service.get_access_token(constant.Resources.MSGraph, user.o365_user_id)
education_service = EducationService(user.tenant_id, token)
assignemtnResources = education_service.get_Assignment_Resources(class_id,assignment_id)
submissionResources = education_service.get_Assignment_Submissions_By_User(class_id,assignment_id,user.o365_user_id)
result={}
resourceArray=[]
submissionResourcesArray=[]
for resource in assignemtnResources:
obj={}
obj["id"]=resource.id
obj["resource"]=resource.resource["displayName"]
resourceArray.append(obj)
result["resources"]=resourceArray;
result["submissionId"]=submissionResources[0].id
for resource in submissionResources:
for item in resource.resources:
obj={}
obj["id"]=item["id"]
obj["resource"]=item["resource"]["displayName"]
submissionResourcesArray.append(obj)
result["submissionResources"]=submissionResourcesArray;
return JsonResponse(result, safe=False)
class AuthRouter(Resource):
def __init__(self):
self.resellerService = ResellerService()
self.authService = AuthService()
def post(self, *args, **kwargs):
json = request.get_json() or None
if json is None:
return bad_request()
try:
data = LoginSchema().load(json)
reseller = self.resellerService.get_by_cpf(data["cpf"])
if reseller == None:
return bad_request(
f'Reseller: {data["cpf"]} not found, please register before to tryng login'
)
if not reseller.active:
return bad_request(f'Reseller: {data["cpf"]} are disabled')
if not self.authService.login(reseller, data["password"]):
return bad_request("Check username and password")
jwt = {
'token': create_access_token(identity=reseller.cpf),
'refresh': create_refresh_token(identity=reseller.cpf)
}
return ok(data=jwt)
except NotFoundError:
return bad_request('Reseller not found')
except SchemaValidationError as e:
return bad_request(errors=e.messages)
except Exception as e:
return error(e)
def aboutme(request):
user = AuthService.get_current_user(request)
context = { 'user': user }
login_as =""
if user.local_user.is_authenticated:
context['show_color'] = user.local_user.is_authenticated
context['colors'] = constant.favorite_colors
context['favorite_color'] = user_service.get_favorite_color(user.user_id)
if user.is_admin:
login_as ="Admin"
if not user.is_admin and user.o365_user is not None:
token = token_service.get_access_token(constant.Resources.MSGraph, user.o365_user_id)
education_service = EducationService(user.tenant_id, token)
me = education_service.get_me()
my_school_id = me.schools[0].id
if me.is_teacher:
login_as="Teacher"
if me.is_student:
login_as="Student"
context['me'] = me
context['groups'] = education_service.get_my_classes(my_school_id)
else:
context['groups'] = []
context['login_as'] = login_as
context['role']=login_as
return render(request, 'managements/aboutme.html', context)
def new_assignment(request):
if request.method == 'POST':
post=request.POST
user = AuthService.get_current_user(request)
token = token_service.get_access_token(constant.Resources.MSGraph, user.o365_user_id)
education_service = EducationService(user.tenant_id, token)
dueDate = post["duedate"] + "T" + post["duetime"] + "Z"
dueDateUTC=datetime.strptime(dueDate,"%m/%d/%YT%H:%M %pZ").strftime("%Y-%m-%dT%H:%M:%SZ")
result = education_service.add_assignment(post["classId"],post["name"],dueDateUTC)
jsonContent = result.content.decode('utf8')
assignment = json.loads(jsonContent)
if post['status']=="assigned":
education_service.publish_assignment(post["classId"],assignment["id"])
files= request.FILES.getlist("fileUpload")
if files !=None:
resourceFolderURL = education_service.get_Assignment_Resource_Folder_URL(post["classId"],assignment["id"])["value"]
ids = getIds(resourceFolderURL)
for file in files:
driveFile = uploadFileToOneDrive(resourceFolderURL,file,education_service)
resourceUrl = "https://graph.microsoft.com/v1.0/drives/" + ids[0] + "/items/" + driveFile["id"]
education_service.add_assignment_resources(post["classId"],assignment["id"],driveFile["name"],resourceUrl)
referer = request.META.get('HTTP_REFERER')
if referer.find("?")==-1:
referer +="?tab=assignments"
return HttpResponseRedirect(referer)
def process_exception(self, request, exception):
context = {
'user': AuthService.get_current_user(request),
'reason': str(exception)
}
if exception.__class__.__name__ == 'RefreshTokenException':
return render(request, 'login0365required.html', context)
def admin(request):
user = AuthService.get_current_user(request)
context = {
'user': user,
'is_admin_consented': user_service.is_tenant_consented(user.tenant_id)
}
return render(request, 'admin/index.html', context)
def classes_next(request, school_id):
nextlink = request.GET.get('nextLink')
user = AuthService.get_current_user(request)
token = token_service.get_access_token(constant.Resources.MSGraph, user.o365_user_id)
education_service = EducationService(user.tenant_id, token)
#school = education_service.get_school(school_id)
my_classes = education_service.get_my_classes(school_id)
all_classes, classnextlink = education_service.get_classes(school_id, top=12, nextlink=nextlink)
for c in all_classes:
my_class = next((mc for mc in my_classes if c.id == mc.id), None)
c.custom_data['is_my'] = my_class != None
if my_class != None:
c.members = my_class.members
# my_section_list = [m.to_dict() for m in my_classes]
ajax_result = {}
ajax_result['classes'] = {}
ajax_result['classes']['value'] = [{
'id': c.id,
'is_my': c.custom_data['is_my'],
'display_name': c.display_name,
'code': c.code,
'teachers': [{ 'display_name': t.display_name } for t in c.teachers],
'term_name': c.term.display_name,
'term_start_time': c.term.start_date,
'term_end_time': c.term.end_date } for c in all_classes]
ajax_result['classes']['next_link'] = classnextlink
# ajax_result['MyClasss'] = my_section_list
return JsonResponse(ajax_result, safe=False)
def classes(request, school_id):
user = AuthService.get_current_user(request)
token = token_service.get_access_token(constant.Resources.MSGraph, user.o365_user_id)
education_service = EducationService(user.tenant_id, token)
me = education_service.get_me()
role = get_user_role(user, me)
education_service = EducationService(user.tenant_id, token)
school = education_service.get_school(school_id)
my_classes = education_service.get_my_classes(school_id)
all_classes, classesnextlink = education_service.get_classes(school_id, 12)
for c in all_classes:
my_class = next((mc for mc in my_classes if c.id == mc.id), None)
c.custom_data['is_my'] = my_class != None
if my_class != None:
c.members = my_class.members
context = {
'user': user,
'school': school,
'classesnextlink': classesnextlink,
'classes': all_classes,
'myclasses': my_classes,
'school_id': school_id,
'is_in_a_school': True,
'me': me,
'role':role
}
return render(request, 'schools/classes.html', context)
def update_assignment(request):
if request.method == 'POST':
post=request.POST
files=request.FILES
user = AuthService.get_current_user(request)
token = token_service.get_access_token(constant.Resources.MSGraph, user.o365_user_id)
education_service = EducationService(user.tenant_id, token)
assignment = education_service.get_assignment(post["classId"],post["assignmentId"])
if assignment.status=='draft' and post['assignmentStatus']=='assigned':
education_service.publish_assignment(post['classId'], post['assignmentId'])
files= request.FILES.getlist("newResource")
if files !=None:
resourceFolderURL = education_service.get_Assignment_Resource_Folder_URL(post["classId"],post["assignmentId"])["value"]
ids = getIds(resourceFolderURL)
for file in files:
driveFile = uploadFileToOneDrive(resourceFolderURL,file,education_service)
resourceUrl = "https://graph.microsoft.com/v1.0/drives/" + ids[0] + "/items/" + driveFile["id"]
education_service.add_assignment_resources(post["classId"],post["assignmentId"],driveFile["name"],resourceUrl)
referer = request.META.get('HTTP_REFERER')
if referer.find("?")==-1:
referer +="?tab=assignments"
return HttpResponseRedirect(referer)
def get_submissions(request,class_id,assignment_id):
user = AuthService.get_current_user(request)
token = token_service.get_access_token(constant.Resources.MSGraph, user.o365_user_id)
education_service = EducationService(user.tenant_id, token)
submissions = education_service.get_Submissions(class_id,assignment_id)
ms_graph_service = MSGraphService(token)
result=[]
for submission in submissions:
userId = submission.submittedBy["user"]["id"];
user = ms_graph_service.get_user_info(userId)
resources= education_service.get_Submission_Resources(class_id,assignment_id,submission.id)
array={}
array["displayName"]=user["displayName"]
array["submittedDateTime"] = submission.submittedDateTime
resources_array=[]
for resource in resources:
resources_dict={}
resources_dict["displayName"] = resource.resource["displayName"]
resources_array.append(resources_dict)
array["resources"]= resources_array
result.append(array)
return JsonResponse(result, safe=False)
def create_local(request):
user = AuthService.get_current_user(request)
create_local_form = CreateLocalInfo()
context = {'user': user, 'create_local_form': create_local_form}
# POST /Link/CreateLocal
if request.method == 'POST':
create_local_form = CreateLocalInfo(request.POST)
data = ''
if create_local_form.is_valid():
data = create_local_form.clean()
try:
local_user = user_service.create(user.o365_user)
except:
errors = []
errors.append('Name %s is already taken.' % user.o365_email)
errors.append("Email '%s' is already taken." % user.o365_email)
context['errors'] = errors
return render(request, 'link/createlocal.html', context)
link_service.link(local_user, user.o365_user)
user_service.update_favorite_color(data['FavoriteColor'],
local_user.id)
local_user = user_service.get_user(local_user.id) # reload local user
auth_login(request, local_user)
request.session[
'Message'] = 'Your local account has been successfully linked to your Office 365 account.'
return HttpResponseRedirect('/')
# GET /Link/CreateLocal
else:
return render(request, 'link/createlocal.html', context)
def add_coteacher(request, class_id, user_object_id):
previousURL = request.META.get('HTTP_REFERER')
user = AuthService.get_current_user(request)
token = token_service.get_access_token(constant.Resources.MSGraph, user.o365_user_id)
education_service = EducationService(user.tenant_id, token)
education_service.add_member(class_id,user_object_id)
education_service.add_owner(class_id,user_object_id)
return HttpResponseRedirect(previousURL)
def process_code(request):
AuthService.validate_state(request)
code = request.POST.get('code')
id_token = AuthService.get_id_token(request)
o365_user_id = id_token.get('oid')
tenant_id = id_token.get('tid')
if link_service.is_linked(o365_user_id):
request.session[
'Error'] = 'Failed to link accounts. The Office 365 account %s is already linked to another local account.' % id_token.get(
'upn')
return HttpResponseRedirect('/Link')
redirect_uri = AuthService.get_redirect_uri(request, 'Link/ProcessCode')
auth_result = token_service.get_token_with_code(code, redirect_uri,
constant.Resources.MSGraph)
token_service.cache_tokens(auth_result, o365_user_id)
ms_graph_service = MSGraphService(auth_result.get('accessToken'))
o365_user = ms_graph_service.get_o365_user(tenant_id)
AuthService.set_o365_user(request, o365_user)
user = AuthService.get_current_user(request)
link_service.link(user.local_user, o365_user)
request.session[
'Message'] = 'Your local account has been successfully linked to your Office 365 account.'
response = HttpResponseRedirect('/')
response.set_cookie(constant.o365_username_cookie, o365_user.display_name)
response.set_cookie(constant.o365_email_cookie, o365_user.email)
return response
def photo(request, user_object_id):
user = AuthService.get_current_user(request)
token = token_service.get_access_token(constant.Resources.MSGraph, user.o365_user_id)
ms_graph_service = MSGraphService(token)
user_photo = ms_graph_service.get_photo(user_object_id)
if not user_photo:
local_photo_path = settings.STATICFILES_DIRS[0] + '/Images/DefaultUserPhoto.jpg'
local_photo_file = open(local_photo_path, 'rb')
user_photo = local_photo_file.read()
return HttpResponse(user_photo, content_type='image/jpeg')
def index(request):
user = AuthService.get_current_user(request)
if not user.is_authenticated:
return HttpResponseRedirect('/Account/Login')
if not user.are_linked:
return HttpResponseRedirect('/Link')
if user.is_admin and not user_service.is_tenant_consented(user.tenant_id):
return HttpResponseRedirect('/Admin')
else:
return HttpResponseRedirect('/Schools')
def index(
schema: AuthRequestSchema,
dbcontext: DbContext = Depends(get_dbcontext)
):
try:
token: str = AuthService(dbcontext).authenticate(schema.username, schema.password)
return AuthResponseSchema(token_type="Bearer", access_token=token)
except ValueError as e:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
def login_post(request):
email = ''
password = ''
errors = []
user_form = UserInfo(request.POST)
if user_form.is_valid():
data = user_form.clean()
email = data['Email']
password = data['Password']
rememberme = data['RememberMe']
settings.SESSION_EXPIRE_AT_BROWSER_CLOSE = not rememberme
user = auth_authenticate(username=email, password=password)
if user is not None:
auth_login(request, user)
o365_user = user_service.get_o365_user(user)
if o365_user:
AuthService.set_o365_user(request, o365_user)
return HttpResponseRedirect('/')
errors.append('Invalid login attempt.')
context = {'user_form': user_form, 'errors': errors}
return render(request, 'account/login.html', context)
def link(request):
user = AuthService.get_current_user(request)
context = {'user': user}
if not user.are_linked and user.is_o365:
local_user = user_service.get_user_by_email(user.o365_email)
if local_user:
context['local_existed'] = True
context[
'local_message'] = 'There is a local account: %s matching your O365 account.' % user.o365_email
else:
context['local_existed'] = False
return render(request, 'link/index.html', context)
def unlink_account(request, link_id):
if request.method == 'POST':
link_service.remove_link(link_id)
return HttpResponseRedirect('/Admin/LinkedAccounts')
else:
user = AuthService.get_current_user(request)
link = link_service.get_link(link_id)
context = {
'user': user,
'email': link['email'],
'o365Email': link['o365Email']
}
return render(request, 'admin/unlinkaccount.html', context)
def unconsent(request):
user = AuthService.get_current_user(request)
token = token_service.get_access_token(constant.Resources.AADGraph,
user.o365_user_id)
aad_graph_service = AADGraphService(user.tenant_id, token)
service_principal = aad_graph_service.get_service_principal()
aad_graph_service.delete_service_principal(service_principal['objectId'])
user_service.update_organization(user.tenant_id, False)
link_service.remove_links(user.tenant_id)
request.session['Message'] = 'Admin unconsented successfully!'
return HttpResponseRedirect('/Admin')
def get_assignment_resources(request,class_id,assignment_id):
user = AuthService.get_current_user(request)
token = token_service.get_access_token(constant.Resources.MSGraph, user.o365_user_id)
education_service = EducationService(user.tenant_id, token)
resources = education_service.get_Assignment_Resources(class_id,assignment_id)
result=[]
for resource in resources:
resourceArray={}
resourceArray["id"]=resource.id
resourceArray["resource"]=resource.resource["displayName"]
result.append(resourceArray)
return JsonResponse(result, safe=False)
def login():
"""Log a user in.
Args :
data = { username }
Returns :
A user object
"""
data = request.json
if not data["username"]:
return json_abort(400, f"Empty string not allowed as a username")
user = AuthService.login(data["username"])
return jsonify(user)
timer.start()
print('Scheduled delete timer task %d sec' % (delete_time))
keystone_url = credentials.keystone_cfg['service_url']
username = credentials.keystone_cfg['username']
password = credentials.keystone_cfg['password']
user_domain_name = credentials.keystone_cfg['user_domain_name']
project_name = credentials.keystone_cfg['project_name']
project_domain_name = credentials.keystone_cfg['project_domain_name']
VERSION = credentials.keystone_cfg['nova_api_version']
auth_service = AuthService(keystone_url = keystone_url,
username = username,
password = password,
user_domain_name = user_domain_name,
project_name = project_name,
project_domain_name = project_domain_name,
nova_api_version = VERSION)
try:
print('Authenticating, waiting server to respond')
novaclient = client.Client(VERSION, session = auth_service.get_session())
print('Getting desired flavor %s' % flavor_name)
flavor = novaclient.flavors.find(name = flavor_name)
print('Getting desired image %s' % image_name)
image = novaclient.images.find(name = image_name)
print('Getting network list')
networks = novaclient.networks.list()
print('Creating nic')
nics = [{'net-id' : networks[0].id}]
