def get_chat_room(student):
company_name = request.args.get('company', None)
user_id = request.args.get('member', None)
if company_name:
company = CompaniesFinder.get_from_name(company_name)
if company is None:
return APIErrorValue("Company not found").json(404)
result = UsersHandler.join_channel(student.user, company.chat_id,
company.chat_code)
if result:
return jsonify({'result': True}), 200
else:
return APIErrorValue("Failed to join room").json(500)
elif user_id:
company_user = UsersFinder.get_from_external_id(user_id)
if company_user is None and not company_user.role.name == 'company':
return APIErrorValue("Invalid user").json(500)
room_id = UsersHandler.create_direct_message(student.user,
company_user)
if room_id is None:
return APIErrorValue(
"Failed to create direct message session").json(500)
return jsonify({"room_id": room_id}), 200
else:
return APIErrorValue("No room found").json(404)
def create_student(cls, name, ist_id, email, course, entry_year, photo,
photo_type):
password = GenerateCredentialsService().call()
referral_code = GenerateCredentialsService().call()
chat_id = UsersHandler.create_chat_user(name, ist_id, email, password,
'Student')
if not chat_id:
return None
user = UsersHandler.create_user(name, ist_id, RolesEnum['student'],
email, password, chat_id)
if not user:
return None
return CreateStudentService(
user_id=user.id,
course=course,
entry_year=entry_year,
referral_code=referral_code,
photo=photo,
photo_type=photo_type,
daily_points=0,
total_points=0,
squad_points=0,
level=LevelsFinder.get_level_by_value(1)).call()
def generate_user_credentials(user_external_id):
user = UsersFinder.get_from_external_id(user_external_id)
if user is None:
return APIErrorValue('Couldnt find user').json(500)
UsersHandler.generate_new_user_credentials(user=user)
return redirect(url_for('admin_api.companies_dashboard'))
def ban_student(student_external_id):
student = StudentsFinder.get_from_external_id(student_external_id)
if student is None:
return APIErrorValue('Couldnt find student').json(500)
if student.squad:
SquadsHandler.delete_squad(student.squad)
banned_student = StudentsHandler.create_banned_student(student)
if banned_student is None:
return APIErrorValue('Error banning student').json(500)
UsersHandler.delete_user(student.user)
return redirect(url_for('admin_api.students_dashboard'))
def ban_squad(squad_external_id):
squad = SquadsFinder.get_from_external_id(squad_external_id)
if squad is None:
return APIErrorValue('Couldnt find squad').json(500)
for member in squad.members:
StudentsHandler.leave_squad(member)
banned_student = StudentsHandler.create_banned_student(member)
if banned_student is None:
return APIErrorValue('Error banning student').json(500)
UsersHandler.delete_user(member.user)
return redirect(url_for('admin_api.squads_dashboard'))
def create_user(name, username, role):
from jeec_brain.handlers.users_handler import UsersHandler
user = UsersHandler.create_user(name=name, username=username, role=role)
if user is None:
print("Failed to create new user!")
exit()
UsersHandler.generate_new_user_credentials(user)
print(f'Name: {user.name}')
print(f'Username: {user.username}')
print(f'Role: {user.role.name}')
print(f'Password: {user.password}')
exit()
def get_job_fair(company_user):
job_fairs = []
for activity in ActivitiesFinder.get_current_company_activities(
company_user.company):
if activity.activity_type.name == 'Job Fair Booth':
_activity = dict(
ActivitiesFinder.get_from_external_id(
activity.external_id).__dict__)
_activity['external_id'] = _activity['external_id'].hex
_activity.pop('_sa_instance_state')
_activity.pop('created_at')
_activity.pop('chat_type')
job_fairs.append(_activity)
if len(job_fairs) == 0:
return APIErrorValue("Job Fair not found").json(404)
now = datetime.utcnow()
today = now.strftime('%d %b %Y, %a')
if today not in [activity['day'] for activity in job_fairs]:
generate_code = False
else:
generate_code = True
chat_token = UsersHandler.get_chat_user_token(company_user.user)
chat_url = Config.ROCKET_CHAT_APP_URL + 'home?resumeToken=' + chat_token
return render_template('companies/activities/job_fair.html', \
generate_code = generate_code, \
chat_url = chat_url, \
job_fairs=job_fairs, \
error=None, \
user=company_user)
def get_chat_token(student):
token = UsersHandler.get_chat_user_token(student.user)
if token:
return jsonify({'token': token}), 200
else:
return APIErrorValue("Error getting token").json(500)
def delete_user(user_external_id):
user = UsersFinder.get_from_external_id(user_external_id)
if user is None:
return APIErrorValue('Couldnt find user').json(500)
if user.role.name == 'company':
company_user = UsersFinder.get_company_user_from_user(user)
if not company_user:
return APIErrorValue('Couldnt find user').json(500)
CompanyUsersHandler.delete_company_user(company_user)
else:
UsersHandler.delete_user(user)
return redirect(url_for('admin_api.users_dashboard'))
def add_company_activity(cls, company, activity, zoom_link=None):
if activity.chat_id:
for company_user in company.users:
user = company_user.user
if not user.chat_id:
chat_id = UsersHandler.create_chat_user(user.username, user.username, user.email, user.password, 'Company')
if not chat_id:
return None
user = UsersHandler.update_user(user, chat_id=chat_id)
if user is None:
return None
result = cls.join_channel(user, activity)
if not result:
print("here")
return None
return AddCompanyActivityService(company.id, activity.id, zoom_link).call()
def create_company_user(cls, name, username, email, company_id, post,
food_manager, evf_username, evf_password):
password = GenerateCredentialsService().call()
chat_id = UsersHandler.create_chat_user(name, username, email,
password, 'Company')
if not chat_id:
return None
user = UsersHandler.create_user(name, username, RolesEnum['company'],
email, password, chat_id)
if not user:
return None
return CreateCompanyUserService(user_id=user.id,
company_id=company_id,
post=post,
food_manager=food_manager,
evf_username=evf_username,
evf_password=evf_password).call()
def accept_terms(company_user):
UsersHandler.update_user(user=company_user.user, accepted_terms=True)
return redirect(url_for('companies_api.dashboard'))
def create_user():
# extract form parameters
name = request.form.get('name')
username = request.form.get('username')
email = request.form.get('email', None)
role = request.form.get('role', None)
post = request.form.get('post', None)
evf_username = request.form.get('evf_username', None)
evf_password = request.form.get('evf_password', None)
# check if is creating company user
company_external_id = request.form.get('company_external_id')
if company_external_id is not None:
company = CompaniesFinder.get_from_external_id(company_external_id)
company_id = company.id
if company is None:
return 'No company found', 404
# extract food_manager from parameters
food_manager = request.form.get('food_manager', None)
if food_manager == 'True':
food_manager = True
elif food_manager == 'False':
food_manager = False
else:
food_manager = None
# create new company user
if company_external_id:
company_user = CompanyUsersHandler.create_company_user(
name, username, email, company_id, post, food_manager,
evf_username, evf_password)
if not company_user:
return render_template('admin/users/add_company_user.html', \
user=current_user, \
companies=CompaniesFinder.get_all(), \
roles=GetRolesService.call(), \
error="Failed to create user!")
if not UsersHandler.join_channel(company_user.user, company.chat_id,
company.chat_code):
CompanyUsersHandler.delete_company_user(company_user)
return render_template('admin/users/add_company_user.html', \
user=current_user, \
companies=CompaniesFinder.get_all(), \
roles=GetRolesService.call(), \
error="Failed to create user!")
for activity in company_user.company.activities:
if activity.chat_id:
if not ActivitiesHandler.join_channel(company_user.user,
activity):
CompanyUsersHandler.delete_company_user(company_user)
return render_template('admin/users/add_company_user.html', \
user=current_user, \
companies=CompaniesFinder.get_all(), \
roles=GetRolesService.call(), \
error="Failed to create user!")
else:
if role not in GetRolesService.call():
return 'Wrong role type provided', 404
else:
role = RolesEnum[role]
user = UsersHandler.create_user(
name=name,
username=username,
email=email,
role=role,
password=GenerateCredentialsService().call())
if user is None:
return render_template('admin/users/add_user.html', \
roles=GetRolesService.call(), \
error="Failed to create user!")
return redirect(url_for('admin_api.users_dashboard'))