def page_menu(context):
role_name = context['role']
if context['role'] == 'admin' or context['role'] == 'corporate':
if 'market_id' in context['request'].session:
market_id = context['request'].session['market_id']
else:
market = get_user_market_or_main_market(context['request'].user)
market_id = context['request'].session['market_id'] = market.pk
else:
market = get_user_market_or_main_market(context['request'].user)
market_id = market.pk
if context['role'] == 'corporate':
role = Roles.objects.filter(name='coordinator').get()
role_id = role.pk
else:
role = Roles.objects.filter(name=role_name).get()
role_id = role.pk
role = Roles.objects.filter(name='all').get()
role_id_all = role.pk
query_set = Category.objects.prefetch_related('pages').order_by('name')
if context['role'] == 'admin':
query_set = query_set.filter(market_id=market_id, is_active=True)
elif context['role'] == 'trainee':
query_set = query_set.filter(market_id=market_id, role_id=role_id, is_active=True)
else:
query_set = query_set.filter(
market_id=market_id, is_active=True, role_id__in=[role_id, role_id_all]
)
return {'categories': query_set, 'context': context}
def update_network(request, role=None):
data = json.loads(request.body)
if not role:
role = get_role(request.user)
id = data.get('id')
url = data.get('url')
active = data.get('active')
type = data.get('type')
if id == 0:
if role == 'corporate':
if 'market_id' in request.session:
market_id = request.session['market_id']
market = Market.objects.filter(pk=market_id).get()
else:
market = get_user_market_or_main_market(request.user)
else:
market = get_user_market_or_main_market(request.user)
network = SocialNetwork(market=market, type_id=type)
else:
network = SocialNetwork.objects.get(pk=id)
network.active = active
network.url = url
network.save()
response = {
'id': network.pk,
'url': network.url,
'active': network.active,
'type': network.type_id
}
return JsonResponse(response)
def programs_list(request):
role = request.user.role
menu_type = request.GET.get('menu_type', 'finance')
if role.code == 'corporate':
market = get_market_or_main_market(request, menu_type)
# add role finance
elif role.code == 'admin' or 'finance':
if 'market_id' in request.session:
market_id = request.session['market_id']
market = Market.objects.filter(pk=market_id).get()
else:
market = get_user_market_or_main_market(request.user)
else:
market = get_user_market_or_main_market(request.user)
programs = (Program.objects.select_related(
'program_base__city__state__country',
'program_base__category').is_visible_by_role(
role.code).by_market(market).is_active().annotate(
total=Count('id')))
# add market
context = {'programs': programs, 'menu_type': menu_type, 'market': market}
return render(request, 'programs/programs_list.html', context)
def program_permission(user, market, program_query):
if user.is_authenticated:
role = get_role(user)
if role == "admin":
if market:
program_query = filter_by_market_name(program_query, market)
else:
market_obj = get_user_market_or_main_market(user)
program_query = program_query.filter(markets=market_obj)
else:
market_obj = get_user_market_or_main_market(user)
if market_obj.name.lower() == market or not market:
program_query = program_query.is_visible_by_role(role).filter(
markets=market_obj)
else:
program_query = []
else:
if market:
program_query = filter_by_market_name(program_query, market)
else:
market_program = Market.objects.get(main_market=True)
program_query = program_query.filter(markets=market_program)
return program_query
def change_log_index(request):
request_data = json.loads(request.body)
newest_id = request_data.get('newest_id', 0)
latest_id = request_data.get('latest_id', 0)
market = get_user_market_or_main_market(request.user)
update_query_set = ChangeLog.objects.filter(
Q(program__markets=market) |
Q(page_attachment__page__market=market)
)
if latest_id:
update_query_set = update_query_set.filter(id__lt=latest_id)
updates = update_query_set.prefetch_related(
'program', 'category', 'page_attachment__page__category',
'page_attachment__category', 'page_attachment__country',
'page_attachment__visa_type'
).order_by('-id')[:10]
response = {
'updates': updates.as_dict_list()
}
return JsonResponse(response, status=200)
def social_networks_json(request):
role = get_role(request.user)
if role in ['corporate', 'admin']:
market_id = request.session['market_id']
market = Market.objects.filter(pk=market_id).get()
else:
market = get_user_market_or_main_market(request.user)
social_models = SocialNetworkTypes.objects.prefetch_related(
Prefetch("social_networks",
queryset=SocialNetwork.objects.filter(market=market),
to_attr="networks"))
networks = []
for social in social_models:
network = {
'id': 0,
'active': False,
'url': "",
'type_id': social.pk,
'social': social.name,
'icon': social.icon.url,
}
if len(social.networks) > 0:
network['id'] = social.networks[0].pk
network['active'] = social.networks[0].active
network['url'] = social.networks[0].url
networks.append(network)
response = {'data': networks}
return JsonResponse(response)
def home(request):
role = get_role(request.user)
tags = Tag.objects.all()
posts = Post.objects.prefetch_related('author')
if role not in ['admin', 'coordinator', 'corporate']:
posts = posts.filter(Q(status=1) | Q(author=request.user))
else:
posts = posts.exclude(Q(status=2))
posts = posts.order_by('-id')
if not role == "coordinator":
market = get_user_market_or_main_market(request.user)
coordinators = ConsultantProfile.objects.select_related(
'consultant').get_coordinator_by_market(market)
else:
coordinators = None
context = {
'role': role,
'posts': output_posts(request, role, posts),
'tags': tags,
'coordinators': coordinators,
'user': request.user,
'user_name': request.user.person.get_full_name()
}
if role == "corporate":
context['menu_type'] = 'general'
return render(request, 'board/board.html', context)
def market_session(request):
if 'market_id' in request.session:
market_id = request.session['market_id']
else:
market = get_user_market_or_main_market(request.user)
market_id = market.pk
market = Market.objects.filter(pk=market_id).get()
return market
def market_name_session(request):
import unidecode
if 'market_id' in request.session:
market_id = request.session['market_id']
marketSelected = Market.objects.filter(pk=market_id).get()
else:
marketSelected = get_user_market_or_main_market(request.user)
market = unidecode.unidecode(marketSelected.name)
return market
def get_grades(request):
market_id = request.GET.get('market_id', 0)
if market_id == 0:
market_id = get_user_market_or_main_market(request.user)
grades = Grades.objects.filter(market=market_id)
if not grades:
market_id = get_user_market_or_main_market(request.user)
grades = Grades.objects.filter(market=market_id)
results = []
for grade in grades:
grades_dict = {'id': grade.pk, 'name': grade.name}
results.append(grades_dict)
return JsonResponse(results, safe=False)
def create_post(request):
role = get_role(request.user)
tags = Tag.objects.all()
form = PostForm()
if request.method == 'POST':
form = PostForm(data=request.POST, files=request.FILES)
if form.is_valid():
market = get_user_market_or_main_market(request.user)
post = form.save(commit=False)
post.author = request.user
post.market = market
if role == "coordinator" or role == "admin":
post.status = 1
post.save()
short_title = (post.title[:25] +
'..') if len(post.title) > 25 else post.title
details = (post.content[:100] +
'..') if len(post.content) > 100 else post.content
description = u'New board created - {}'.format(short_title)
notification = create_notification_from(post)
notification.type = 3
notification.creator = request.user
notification.description = description
notification.details = details
notification.save()
coordinators_ids = (
ConsultantProfile.objects.prefetch_related('consultant').
get_coordinator_by_market(market).is_active().values_list(
'consultant__id', flat=True))
bulk_receiver_creation(notification, coordinators_ids)
if role == "coordinator" or role == "admin":
messages.success(request, 'Post successfully created.')
else:
messages.success(
request,
'Post successfully created. An administrator will review it shortly.'
)
return redirect('/board/')
else:
messages.error(
request,
'There was a problem creating the post. Please correct the errors and try again.'
)
if role == 'corporate':
menu_type = 'general'
return render(request, 'board/create.html', locals())
def school_grade_validate(request):
role = get_role(request.user)
if role == 'admin':
if 'market_id' in request.session:
market_id = request.session['market_id']
market = Market.objects.filter(pk=market_id).get()
else:
market = get_user_market_or_main_market(request.user)
else:
market = get_user_market_or_main_market(request.user)
grades = Grades.objects.filter(market=market)
if not grades:
school_grade = False
else:
school_grade = True
return school_grade
def supervisor_consultant_list(request):
"""
Retrieve the supervisor consultant list
"""
role = request.user.role
consultants = get_user_model().objects.select_related(
'person__profile__address__city',
'person__profile__address__state',
'person__profile__address__country',
'consultantprofile',
).filter(is_active=True).can_create_register().annotate(
registrations_count=Count(
'registrations',
filter=Q(registrations__helper_creator=request.user)))
if role.code in ['admin', 'coordinator', 'info', 'corporate']:
if role.code in ['coordinator', 'info']:
market = get_user_market_or_main_market(request.user)
else:
if 'market_id' in request.session:
market_id = request.session['market_id']
else:
market = get_user_market_or_main_market(request.user)
market_id = market.pk
market = Market.objects.filter(pk=market_id).get()
consultants = consultants.filter(consultantprofile__market=market)
else:
consultants = consultants.filter(
consultantprofile__supervisor=request.user)
context = {
'consultants': consultants,
}
if role.code == 'corporate':
context['menu_type'] = 'general'
return render(request, 'profiles/supervisor_consultant_list.html', context)
def image_preview(request, uuid):
"""
Return card rendered as image
"""
user = get_user_model().objects.get(username=uuid)
market = get_user_market_or_main_market(user)
card_template, created = CardTemplate.objects.get_or_create(market=market)
# Adjust width size to fit template
width = 382
if card_template.enabled == 2:
width = 618
url = '{}?iframe=True&template={}'.format(
request.build_absolute_uri(
reverse('cards:view_usercard', args=[user.username])),
card_template.enabled)
options = {'width': width, 'xvfb': '', 'format': 'png', 'quiet': ''}
img = imgkit.from_url(url, False, options=options)
return HttpResponse(img, content_type='image/png')
def pagesMarkets(request):
market = get_user_market_or_main_market(request.user)
markets = Market.objects.all().exclude(pk=14).order_by('name')
context = {'menu_type': 'administration', 'markets': markets}
return render(request, 'catalogs/pages_markets.html', context)
def index(request):
role = get_role(request.user)
start_date = datetime.fromisoformat(request.GET.get('start')).astimezone(
pytz.utc).strftime("%Y-%m-%d %H:%M:%S")
end_date = datetime.fromisoformat(request.GET.get('end')).astimezone(
pytz.utc).strftime("%Y-%m-%d %H:%M:%S")
if role in ['admin', 'corporate', 'finance']:
if 'market_id' in request.session:
market_id = request.session['market_id']
else:
market = get_user_market_or_main_market(request.user)
market_id = market.pk
else:
market = get_user_market_or_main_market(request.user)
market_id = market.pk
sql = (
"SELECT distinct(ee.id) FROM events_event ee " +
"LEFT JOIN events_event_markets eem on ee.id = eem.event_id "
"LEFT JOIN events_eventusers eeu on ee.id = eeu.event_id and eeu.user_id = %s "
+ "WHERE (" + "(ee.start >= %s and ee.end <= %s) or " +
"(ee.start >= %s and ee.start <= %s and ee.end is null)" + ") and (" +
"(" + "visibility = 5 and (" +
"(eem.market_id = %s and eeu.user_id = %s and eeu.hide = false) or" +
"(eem.market_id is null and eeu.user_id = %s and eeu.hide = false) or "
+ "(eeu.hide is null and eem.market_id = %s) or " +
"(not ee.user_id = eeu.user_id and eeu.user_id = %s and eeu.hide = false)"
+ ")" + ") or " +
"(visibility = 4 and (eeu.hide = false or eeu.hide is null)) or "
"(visibility = 2 and ee.user_id = %s) or "
"(visibility is null and ee.user_id = %s) or "
"ee.user_id = %s"
")")
events = Event.objects.filter(
pk__in=RawSQL(sql, (request.user.pk, start_date, end_date, start_date,
end_date, market_id, request.user.pk,
request.user.pk, market_id, request.user.pk,
request.user.pk, request.user.pk,
request.user.pk)))
data = []
for event in events:
item = {
'id': event.id,
'title': event.title,
'start': localtime(event.start).isoformat() if event.start else '',
'end': localtime(event.end).isoformat() if event.end else '',
'eventColor': event.color,
'description': event.description,
'url': event.url,
'allDay': event.all_day,
'userId': int(0 if event.user is None else event.user.id),
'reminderId': event.reminder_id if event.reminder_id else '',
'isOwner': (event.user_id == request.user.pk)
}
if event.reminder_id:
item['reminder'] = {
'id':
event.reminder.pk,
'registrationId':
event.reminder.registration_id
if event.reminder.registration_id else ''
}
data.append(item)
return JsonResponse(data, safe=False)
def usercard(request, uuid, iframe, signature, preview, template):
iframe = request.GET.get('iframe', False)
signature = request.GET.get('signature', False)
preview_signature = request.GET.get('preview_signature', False)
current_signature = request.GET.get('current_signature', False)
role_id = request.GET.get('role_id')
preview = request.GET.get('preview', False)
template = request.GET.get('template', 1)
try:
user = get_user_model().objects.select_related('person').get(
username=uuid)
except Exception:
return render(request, 'inactive_card.html')
market = get_user_market_or_main_market(user)
role = user.role.name
card_market, created = CardMarket.objects.get_or_create(market=market)
card_template, created = CardTemplate.objects.get_or_create(market=market)
enabled_card = card_market.is_enabled_card(market)
base_url = request.build_absolute_uri()
common_name = user.common_name
business_card_name = user.business_card_name
phone_mobile = user.person.profile.get_phone_mobile()
try:
city = user.person.profile.address.city.name
except Exception:
city = ''
networks = SocialNetwork.objects.filter(market=market,
active=True).select_related('type')
try:
country = user.person.profile.address.country.name
except Exception:
country = ''
# Calculate offset to social_networks
offset = 2
if networks:
count = len(networks)
offset = int(12 / count)
# Card with horizontal layout
card_layout = 'vertical'
if card_template.enabled == 2:
card_layout = 'horizontal'
context = {
'user': user,
'role': role,
'common_name': common_name,
'business_card_name': business_card_name,
'phone_mobile': phone_mobile,
'city': city,
'market': market,
'country': country,
'offset': offset,
'card_url': base_url,
'iframe_url': base_url + '?iframe=True',
'social_networks': networks,
'card_layout': card_layout,
'preview': preview,
}
# Render image with management command in corporate template settings
# python manage.py card_previews
if iframe and preview:
t = "cards/template{}_iframe.html".format(template)
return render(request, t, context)
# To render in card public home
if iframe and not preview:
t = "cards/template{}_iframe.html".format(card_template.enabled)
return render(request, t, context)
if signature:
return render(request, 'cards/signature_iframe.html', context)
if preview_signature or current_signature:
# Signature settings detail
if preview_signature:
elements_list = []
signature_elements = PreviewEmailSignature.objects.filter(
role__pk=role_id)
image_element = PreviewImageAsElementSignature.objects.filter(
role__pk=role_id).last()
# List current signatures by role
if current_signature:
elements_list = []
signature_elements = EmailSignature.objects.filter(
role__pk=role_id)
image_element = ImageAsElementSignature.objects.filter(
role__pk=role_id).last()
# Add extra element variables to context
try:
context['image'] = image_element.file.url
except Exception:
context['image'] = None
for element in signature_elements:
elements_list.append(element.as_rendered_dict(context))
context['elements'] = elements_list
return render(request, 'cards/signature_base.html', context)
if not enabled_card or not user.is_active:
return render(request, 'inactive_card.html')
home_count = CardCountVisit()
home_count.user = user
home_count.click_type = 1
home_count.save()
return render(request, 'cards/card_home.html', context)
def calendar_dashboard(request, role=None):
activities = []
users_list = []
markets_dict = []
if not role:
role = get_role(request.user)
if role in ['corporate', 'admin', 'finance']:
if 'market_id' in request.session:
market_id = request.session['market_id']
market = Market.objects.filter(pk=market_id).get()
else:
market = get_user_market_or_main_market(request.user)
else:
market = get_user_market_or_main_market(request.user)
roles = ['corporate', 'coordinator', 'admin', 'finance']
if role in roles:
users = get_user_model().objects.prefetch_related(
'consultantprofile__market', 'person').filter(
Q(groups__name='new markets coordinator')
| Q(groups__name='supervisors') | Q(groups__name='free agents')
| Q(groups__name='consultants') | Q(groups__name='info')
| Q(groups__name='corporate admin')
| Q(groups__name='super admin')
| Q(groups__name='finances')).exclude(
Q(pk=request.user.pk)).filter(is_active=True)
if role == 'coordinator':
users = users.filter(consultantprofile__market=market)
markets_dict.append(market.as_dict())
else:
markets_dict = Market.objects.filter(is_active=True).as_dict_list()
for user in users.distinct():
users_list.append({
'id': user.pk,
'common_name': user.common_name,
'email': user.person.email
})
pages = Page.objects.all()
default_period = AcademicPeriod.objects.next_to_current_period()
update_query_set = ChangeLog.objects.filter(
Q(program__markets=market)
| Q(page_attachment__page__market=market)).filter(
program__visibility=True, program__is_active=True)
updates = update_query_set.prefetch_related(
'program__program_base', 'category', 'page_attachment__page__category',
'page_attachment__category', 'page_attachment__country',
'page_attachment__visa_type').order_by('-id')[:10]
if role in ['consultant', 'free_agent', 'supervisor']:
tracing_query_set = Registration.objects.filter(
status=1,
consultant=request.user,
tracing__completed_date__isnull=True).exclude(
academic_period__start_date__year='2015', ).annotate(
student_full_name=Concat(
'costumer__first_name', Value(' '),
'costumer__last_name'), ).select_related(
'costumer', 'tracing__lead').prefetch_related(
'tracing__follow_ups', 'tracing__meetings',
'tracing__decision_makings')
for registration in tracing_query_set.all():
student_full_name = registration.student_full_name.strip()
current_step = registration.tracing.get_current_step()
next_step = registration.tracing.get_next_step()
if next_step['id'] != current_step['id']:
continue
activities.append({
'id':
registration.pk,
'studentFullName':
student_full_name if student_full_name else 'NO NAME',
'step':
current_step['step'],
'datetime':
'' if current_step['step'] == 1 else current_step['date']
})
request_context = {
'role':
role,
'pages':
pages,
'total_comission':
0,
'timezone':
settings.TIME_ZONE,
'updates_count':
update_query_set.count(),
'default_period':
default_period,
'market':
market,
'updates_json':
json.dumps({
'updates': updates.as_dict_list(),
'count': update_query_set.count()
})
}
context_json = {
'activities': activities,
'defaultPeriod': {
'id': default_period.pk,
'startDate': default_period.start_date.strftime('%Y-%m-%d'),
'endDate': default_period.end_date.strftime('%Y-%m-%d')
},
'steps': tuple_as_dict(STEP_CHOICES),
'reminderOptions': tuple_as_dict(REMINDER_CHOICES),
'byOptions': tuple_as_dict(BY_CHOICES),
'timezone': settings.TIME_ZONE,
'marketId': market.pk,
'market': market.as_dict(),
'markets': markets_dict,
'user': request.user.as_dict(),
'usersList': users_list,
'urls': {
'changeLogIndex': reverse('api_activities:change_log_index'),
'chartSalesTarget':
reverse('api_registrations:chart_sales_target'),
'chartProspects': reverse('api_registrations:chart_prospects'),
'chartCustomers': reverse('api_registrations:chart_customers'),
'registrationCards': reverse('registration:cards_show', args=[0]),
'events': reverse('api_events:index'),
'eventRemove': reverse('api_events:remove'),
'eventCreateEdit': reverse('api_events:create_edit'),
'event': reverse('api_events:event')
}
}
if role == 'corporate':
request_context['menu_type'] = 'general'
if role:
request_context['markets'] = Market.objects.all()
request_context['context_json'] = json.dumps(context_json)
return render(request, 'events/dashboard.html', request_context)
def dt_get_registrations_consultant_list(request):
academic_period_id = request.POST.get('academic_period_id', None)
status_id = request.POST.get('status_id', None)
results = []
role = get_role(request.user)
columns = {
'academic_period': 'academic_period',
'status': 'status',
'student_name': 'student_full_name',
'consultant': 'consultant__common_name',
'created': 'created',
'registration_date': 'registration_date',
'finance_date': 'finance_date',
'customer_date': 'customer_date',
'follow_up': 'costumer',
}
data_table = DataTable(request.POST, columns)
market = get_user_market_or_main_market(request.user)
query_set = Registration.objects.select_related(
'costumer', 'consultant',
'academic_period').active().annotate(student_full_name=Concat(
'costumer__first_name', Value(' '),
'costumer__last_name'), ).exclude(
academic_period__start_date__year='2015')
if role == 'corporate' or role == 'finance':
pass
elif role in ['coordinator', 'info']:
query_set = query_set.by_consultantprofile_market(market)
elif role in ['admin']:
if 'market_id' in request.session:
market_id = request.session['market_id']
market = Market.objects.filter(pk=market_id).get()
query_set = query_set.by_consultantprofile_market(market)
else:
query_set = query_set.filter(consultant=request.user)
registration_list = []
notes_dict = {}
if role == "info" or role == "coordinator":
# for info and coordinator roles we added last notes in each registration that can cause a lot of extra queries
notes_values = Note.objects.values('registration_id').annotate(
max_id=Max('id'))
recent_notes_ids = [k['max_id'] for k in notes_values]
notes = Note.objects.filter(id__in=recent_notes_ids)
for note in notes:
notes_dict[note.registration_id] = note
default_period = AcademicPeriod.objects.next_to_current_period()
total = query_set.count()
if data_table.search_value != "":
try:
query_set = query_set.filter(
Q(student_full_name__icontains=data_table.search_value)
| Q(consultant__common_name__icontains=data_table.search_value)
)
except ValueError:
query_set = query_set.filter(
Q(costumer__icontains=data_table.search_value))
if academic_period_id:
query_set = query_set.filter(academic_period_id=academic_period_id)
if status_id:
query_set = query_set.filter(status=status_id)
else:
query_set = query_set.filter(status__in=['1', '2', '3', '4'])
records_filtered = query_set.count()
query_set = query_set.order_by(*data_table.get_orderings())
registrations = query_set[data_table.start:data_table.limit]
extra_note = ''
for registration in registrations:
if registration.pk in notes_dict:
extra_note = notes_dict[registration.pk].description
result = {
'id':
registration.pk,
'academic_period':
registration.academic_period.get_year(),
'status':
registration.get_status_display(),
'student_name':
registration.costumer.get_full_name()
if registration.costumer.get_full_name() else u'No Name',
'consultant':
registration.consultant.common_name,
'created':
registration.created.strftime("%Y-%m-%d")
if registration.created else '',
'registration_date':
registration.registration_date.strftime("%Y-%m-%d")
if registration.registration_date else '',
'finance_date':
registration.finance_date.strftime("%Y-%m-%d")
if registration.finance_date else '',
'customer_date':
registration.customer_date.strftime("%Y-%m-%d")
if registration.customer_date else '',
'follow_up':
extra_note if extra_note else ''
}
results.append(result)
response = {
'draw': data_table.draw,
'recordsTotal': total,
'recordsFiltered': records_filtered,
'data': results
}
return JsonResponse(response, status=200)
def image(request, uuid, filetype, preview, template):
"""
Return card rendered as image
"""
import os
from pyvirtualdisplay import Display
filetype = request.GET.get('filetype', 'png')
preview = request.GET.get('preview', False)
template = request.GET.get('template', '1')
user = get_user_model().objects.get(username=uuid)
market = get_user_market_or_main_market(user)
card_template, created = CardTemplate.objects.get_or_create(market=market)
# Adjust width size to fit template
width = 382
if card_template.enabled == 2 or template == '2':
width = 618
base_url = request.build_absolute_uri(
reverse('cards:view_usercard', args=[user.username]))
iframe_url = base_url + '?iframe=True'
if preview:
iframe_url = base_url + '?iframe=True&preview=True&template={}'.format(
template)
filename = 'Ad_Astra_{}.{}'.format(
user.business_card_name.strip().replace(' ', '_'), filetype)
options = {'width': width, 'xvfb': ''}
xephyr = Display(visible=0, size=(650, 650))
xephyr.start()
try:
imgkit.from_url(iframe_url, filename, options=options)
except Exception as e:
print(e)
xephyr.stop()
return JsonResponse('Error rendering image', safe=False)
image_data = open(filename, 'rb')
content_type = 'image/{}'.format(filetype)
response = HttpResponse(image_data.read(), content_type=content_type)
response['Content-Disposition'] = 'attachment; filename=%s' % filename
if preview:
response['Content-Disposition'] = 'inline'
xephyr.stop()
image_data.close()
os.remove(filename)
if not preview:
image_count = CardCountVisit()
image_count.user = user
image_count.click_type = 3
image_count.save()
return response
def card_stats(request):
role = get_role(request.user)
market = get_user_market_or_main_market(request.user)
if role not in ['admin', 'coordinator', 'corporate']:
return redirect('/')
start_date = request.GET.get('start_date', None)
end_date = request.GET.get('end_date', None)
if start_date:
start_date_obj = datetime.strptime(start_date, '%d-%m-%Y').date()
if end_date:
end_date_obj = datetime.strptime(end_date, '%d-%m-%Y').date()
month = datetime.now().month
year = datetime.now().year
month_representation = calendar.month_name[month]
@register.filter
def get_item(dictionary, key):
return dictionary.get(key)
social_list = []
social_networks_types = SocialNetworkTypes.objects.all()
for social_network_type in social_networks_types:
social_list.append(social_network_type.as_dict())
count_year = CardCountVisit.objects.filter(created_at__year=year,
click_type=1).count()
count_month = CardCountVisit.objects.filter(created_at__month=month,
click_type=1).count()
if start_date and end_date:
total_home = CardCountVisit.objects.filter(
click_type=1,
created_at__gte=start_date_obj,
created_at__lte=end_date_obj,
).count()
total_contact = CardCountVisit.objects.filter(
click_type=2,
created_at__gte=start_date_obj,
created_at__lte=end_date_obj,
).count()
total_networks = CardSocialNetworkCountVisit.objects \
.filter(
created_at__gte=start_date_obj,
created_at__lte=end_date_obj,
) \
.order_by('network') \
.values('network_id') \
.annotate(count=Count('network_id'))
total_social = {c['network_id']: c['count'] for c in total_networks}
else:
total_home = CardCountVisit.objects.filter(created_at__year=year,
click_type=1).count()
total_contact = CardCountVisit.objects.filter(created_at__year=year,
click_type=2).count()
total_networks = CardSocialNetworkCountVisit.objects \
.all() \
.order_by('network') \
.values('network_id') \
.annotate(count=Count('network_id'))
total_social = {c['network_id']: c['count'] for c in total_networks}
total_counts = {
'year': count_year,
'month': count_month,
'home': total_home,
'contact': total_contact,
'social': total_social
}
current_year = year
current_month = month_representation
users = get_user_model().objects.prefetch_related(
'consultantprofile',
'consultantprofile__market',
).filter(
Q(groups__name="new markets coordinator") | # noqa
Q(groups__name="finances") | # noqa
Q(groups__name="supervisors") | # noqa
Q(groups__name="free agents") | # noqa
Q(groups__name="consultants") | # noqa
Q(groups__name="info") | # noqa
Q(groups__name="visas") | # noqa
Q(groups__name="corporate admin") | # noqa
Q(groups__name="super admin")).distinct()
if role == 'coordinator':
users = users.filter(consultantprofile__market__id=market.id)
users_list = []
for user in list(users):
if start_date and end_date:
home_visit = CardCountVisit.objects.filter(
user=user,
click_type=1,
created_at__gte=start_date_obj,
created_at__lte=end_date_obj,
).count()
contact_download = CardCountVisit.objects.filter(
user=user,
click_type=2,
created_at__gte=start_date_obj,
created_at__lte=end_date_obj,
).count()
card_networks = CardSocialNetworkCountVisit.objects \
.filter(
user=user,
created_at__gte=start_date_obj,
created_at__lte=end_date_obj,
) \
.order_by('network') \
.values('network_id') \
.annotate(count=Count('network_id'))
social_count = {c['network_id']: c['count'] for c in card_networks}
else:
home_visit = CardCountVisit.objects.filter(
user=user,
click_type=1,
).count()
contact_download = CardCountVisit.objects.filter(
user=user,
click_type=2,
).count()
card_networks = CardSocialNetworkCountVisit.objects \
.filter(user=user) \
.order_by('network') \
.values('network_id') \
.annotate(count=Count('network_id'))
social_count = {c['network_id']: c['count'] for c in card_networks}
user_dict = {
'id': user.pk,
'common_name': user.common_name,
'home_visit': home_visit,
'social_count': social_count,
'contact_download': contact_download,
'consultantprofile': {
'market_name': '',
}
}
if hasattr(user, 'consultantprofile'):
market = list(user.consultantprofile.market.all())
if len(market) > 0:
user_dict['consultantprofile']['market_name'] = market[0].name
users_list.append(user_dict)
context = {
'menu_type': 'administration',
'total_counts': total_counts,
'current_year': current_year,
'current_month': current_month,
'social_networks': social_list,
'users': users_list,
}
return render(request, 'cards/card_stats.html', context)
def pages(request):
if request.method == 'GET':
role = get_role(request.user)
market = get_user_market_or_main_market(request.user)
# categories with subcategories
categories_available_list = Category.objects.filter(
is_active=True).values_list('id', flat=True).annotate(
Count('id')).filter(market=market,
id__count__gt=0,
pages__id__isnull=False)
categories_available = len(categories_available_list) > 0
categories_ids = []
if categories_available:
for id in categories_available_list:
categories_ids.append(id)
attachments = Attachment.objects.prefetch_related(
'page__category').filter(page__category__market=market)
categories = Category.objects.filter(
id__in=categories_ids).order_by('name')
attachment_categories = AttachmentCategory.objects.all()
visas_country = VisasCountry.objects.all()
visas_types = VisasType.objects.all()
context = {
'role': role,
'categories_available': categories_available,
'attachments': attachments,
'categories': categories,
'attachment_categories': attachment_categories,
'visas_country': visas_country,
'visas_types': visas_types
}
if role == 'corporate':
context['menu_type'] = 'general'
return render(request, 'static_pages/pages_view.html', context)
if request.method == 'POST' and request.is_ajax():
page_id = request.POST.get('pageId', None)
page = Page.objects.select_related('category').filter(
pk=page_id).first()
if not page:
return JsonResponse({}, status=400)
name = request.POST.get('name', None)
link = request.POST.get('link', None)
type_id = request.POST.get('type_id', None)
country_id = request.POST.get('country_id', None)
category_id = request.POST.get('category_id', None)
archive = request.FILES.get('file', None)
icon_new = request.POST.get('icon_new', None)
icon_name = request.POST.get('icon_name', None)
icon_attachment = request.FILES.get('icon_attachment', None)
input_view_icon = request.POST.get('input_view_icon', None)
input_view_image = request.POST.get('input_view_image', None)
iframe_link = request.POST.get('iframe_link', None)
category = None
if page.type == 1 and not (link or archive):
return JsonResponse({}, status=400)
if page.type == 3 and not (link or archive):
return JsonResponse({}, status=400)
if page.type == 4 and not archive:
return JsonResponse({}, status=400)
if category_id:
category = AttachmentCategory.objects.filter(
pk=category_id).first()
if not category:
return JsonResponse({}, status=400)
attachment = Attachment()
attachment.name = name
attachment.page = page
attachment.visa_type_id = type_id
attachment.country_id = country_id
if category:
attachment.category = category
attachment.active = True
attachment.url = link
attachment.file = archive
if iframe_link:
attachment.view = iframe_link
attachment.save()
response = {
'id': attachment.pk,
'name': attachment.name if attachment.name else '',
'categoryName': page.category.name if page.category.name else '',
'subcategoryName': page.title if page.title else '',
'date': attachment.created.strftime("%d/%m/%Y"),
'sortDate': attachment.created.strftime("%Y-%m-%d %H:%M:%S"),
'link': attachment.url if attachment.url else '',
'url': attachment.file.url if attachment.file else '',
}
add_change_log_by_page_attachment(page_attachment=attachment)
return JsonResponse(response, status=200)
def supervisor_consultant_detail(request, consultant_id):
role = request.user.role
menu_type = request.GET.get('menu_type', '')
is_same_user = int(consultant_id) == request.user.pk
users = []
user_viewed = get_user_model().objects.select_related(
'role',
'person').prefetch_related('consultantprofile__supervisor').filter(
pk=consultant_id).first()
if not user_viewed or role.code == 'info':
return redirect('/')
if role.code in ['consultant'] and not request.user.pk == user_viewed.pk:
return redirect('/')
if role.code == 'supervisor' and (
not request.user.pk == user_viewed.consultantprofile.supervisor_id
and not is_same_user):
return redirect('/')
currency = Currency.objects.filter(main=True).first()
if not currency:
return redirect('/')
if role.code == 'corporate':
market = get_corporate_market_filter(request)
else:
market = get_user_market_or_main_market(request.user)
previous_period = AcademicPeriod.objects.active_period()
current_period = AcademicPeriod.objects.next_to_current_period()
main_currency = Currency.objects.filter(main=True).first()
common_query_set = Registration.objects.exclude(
Q(status='5') | Q(academic_period__start_date__year='2015'))
market_by_filter = (role.code in ['corporate', 'coordinator']
and is_same_user)
if market_by_filter:
registrations = common_query_set.filter(
consultant__consultantprofile__market=market)
else:
registrations = common_query_set.filter(consultant=user_viewed)
def find_by_status(status, elements):
return next(
(x['status__count'] for x in elements if x['status'] == status), 0)
# region Registration Cycles
if user_viewed.role.code == 'trainee' or role.code == 'trainee':
cycle_query_set = common_query_set.filter(
academic_period=current_period)
cycle_counts = {
'lead_trainee': cycle_query_set.filter(status='9').count(),
'lead': cycle_query_set.filter(helper_creator=user_viewed).count()
}
else:
cycle_query_set = registrations.filter(academic_period=current_period)
results = cycle_query_set.values('status').filter(
status__in=['1', '2', '3', '4']).annotate(Count('status'))
cycle_counts = {
'lead': find_by_status('1', results),
'registration': find_by_status('2', results),
'finance': find_by_status('3', results),
'customer': find_by_status('4', results),
}
# endregion
# region Total Counts
if user_viewed.role.code == 'trainee':
total_counts = {
'lead_trainee': common_query_set.filter(status='9').count(),
'lead':
common_query_set.filter(helper_creator=user_viewed).count(),
}
else:
registrations_total = registrations.values('status').filter(
status__in=['1', '4']).annotate(Count('status'))
total_counts = {
'lead': find_by_status('1', registrations_total),
'customer': find_by_status('4', registrations_total),
}
# endregion
prev_cycle = [{'currency': main_currency.code, 'amount': Decimal('0.00')}]
current_cycle = [{
'currency': main_currency.code,
'amount': Decimal('0.00')
}]
total_cycles = []
common_query_set = RegistrationCommission.objects.filter(
registration__academic_period__start_date__year__lte=current_period.
start_date.year,
registration__status__in=[2, 3, 4],
registration__registrationfinance__commission_currency__isnull=False
).exclude(registration__academic_period__start_date__year='2015').annotate(
currency=F(
'registration__registrationfinance__commission_currency__code'))
if market_by_filter:
commission_accumulated = User.objects.can_register().market(
market).aggregate(total=Sum('consultantprofile__commission_start'))
total_cycles.append({
'currency': main_currency.code,
'amount': commission_accumulated['total']
})
cycles = common_query_set.filter(
is_special=False, registration__program__markets=market).values(
'currency', 'registration__academic_period_id').annotate(
academic_period_id=F('registration__academic_period_id'),
amount=Sum('amount'))
users = User.objects.select_related('person').can_register().filter(
is_active=True, consultantprofile__market=market).exclude(
pk=user_viewed.pk).order_and_annotate_full_name()
else:
total_cycles.append({
'currency':
main_currency.code,
'amount':
user_viewed.consultantprofile.commission_start
})
cycles = common_query_set.filter(user=user_viewed, ).values(
'currency', 'registration__academic_period_id').annotate(
academic_period_id=F('registration__academic_period_id'),
amount=Sum('amount'))
for cycle in cycles:
if cycle['academic_period_id'] == current_period.pk:
target_cycle = current_cycle
elif cycle['academic_period_id'] == previous_period.pk:
target_cycle = prev_cycle
else:
target_cycle = total_cycles
has_currency = False
for total in target_cycle:
if total['currency'] == cycle['currency']:
has_currency = True
total['amount'] = total['amount'] + cycle['amount']
break
if not has_currency:
target_cycle.append({
'currency': cycle['currency'],
'amount': cycle['amount']
})
request_context = {
'role':
role.code,
'currency':
currency,
'default_period':
current_period,
'user_viewed':
user_viewed,
'periods_json':
AcademicPeriod.objects.exclude(start_date__year='2015').as_json(),
'cycle_counts':
cycle_counts,
'total_counts':
total_counts,
'prev_cycle':
prev_cycle,
'current_cycle':
current_cycle,
'total_cycles':
total_cycles,
'enable_targes':
False,
'menu_type':
menu_type,
'timezone':
settings.TIME_ZONE,
'users':
users,
'market':
market,
'market_by_filter':
market_by_filter
}
return render(request, 'profiles/supervisor_consultant_detail.html',
request_context)
def index(request):
if request.method == 'GET':
role = request.user.role
user = request.user
menu_type = request.GET.get('menu_type', '')
markets = Market.objects.filter(is_active=True).order_by('name')
if role.code == 'program':
# TODO add custom permission to get this users instead of hardcode the username
program_user_options = get_user_model().objects.select_related('person').filter(
username__in=['*****@*****.**', '*****@*****.**', '*****@*****.**']
)
program_profile = ProgramProfile.objects.prefetch_related('markets').filter(user=user).first()
if not program_profile:
markets = []
else:
markets = program_profile.markets.all()
received_notifications = []
if role.code == 'corporate' and menu_type == 'general':
if 'market_id' in request.session:
market_id = request.session['market_id']
else:
market = get_user_market_or_main_market(request.user)
market_id = market.pk
consultant_by_market = ConsultantProfile.objects.select_related(
'consultant'
).get_coordinator_by_market(market_id).first()
if consultant_by_market:
consultant_id = consultant_by_market.consultant.pk
received_notifications = NotificationReceiver.objects.prefetch_related('notification').filter(
receiver=consultant_id
)
else:
received_notifications = NotificationReceiver.objects.prefetch_related('notification').filter(
receiver=request.user
)
unseen_ids = []
notifications_data = []
for received in received_notifications:
n = {
'id': received.pk,
'description': received.notification.description,
'comment': received.notification.comment,
'viewed': received.viewed,
'backed_up': received.backed_up,
'created': received.notification.created,
'notification_id': received.notification.pk,
}
notifications_data.append(n)
if not received.viewed:
unseen_ids.append(received.pk)
NotificationReceiver.objects.filter(pk__in=unseen_ids).update(viewed=True)
context = {
'user': user,
'role': role.code,
'notifications': notifications_data,
'markets': markets,
'user_name': request.user.person.get_full_name(),
'menu_type': menu_type
}
if role.code == 'program':
context['program_user_options'] = program_user_options
query_set = User.objects.order_and_annotate_common_name_or_username().filter(
is_active=True,
)
if role.code in ['coordinator', 'consultant', 'free_agent', 'supervisor', 'info']:
market = get_user_market_or_main_market(request.user)
context['users'] = query_set.can_create_register().filter(
consultantprofile__market=market
).exclude(pk=request.user.pk)
elif role.code == 'finance':
context['users'] = query_set.acs_users().exclude(pk=request.user.pk)
elif role.code == 'corporate':
if menu_type == 'general':
market = Market.objects.filter(pk=market_id).get()
context['users'] = query_set.filter(
role__code='coordinator',
consultantprofile__market=market
).exclude(pk=request.user.pk)
else:
context['users'] = query_set.acs_users().exclude(pk=request.user.pk)
elif role.code in ['admin', 'finance']:
market = get_market(request)
context['users'] = query_set.can_create_register().filter(
consultantprofile__market=market
).exclude(
pk=request.user.pk
)
elif role.code == 'trainee':
context['users'] = query_set.filter(pk=request.user.consultantprofile.supervisor_id)
return render(request, 'notifications/notifications.html', context)
def generate_excel(request):
menu_type = request.GET.get('menu_type')
if request.method == 'POST':
date1 = request.POST['date1']
date2 = request.POST['date2']
status = request.POST.getlist('id_status[]')
academic_period_id = request.POST['id_academic_period']
reports = request.POST.getlist('id_reports[]')
market_id = request.POST.get('market', None)
full_year = to_boolean(request.POST.get('full_year', False))
report_type = int(reports[0])
role = get_role(request.user)
today_end = utc_to_local(timezone.now()).replace(
hour=0, minute=0, second=0, microsecond=0) + datetime.timedelta(
days=1) - datetime.timedelta(seconds=1)
if date1:
date1 = unaware_to_local(
datetime.datetime.strptime(date1, '%Y-%m-%d'))
if date2:
date2 = unaware_to_local(
datetime.datetime.strptime(
date2, '%Y-%m-%d')) + datetime.timedelta(
days=1) - datetime.timedelta(seconds=1)
# if report_type == 9 and not market_id and role in ['admin', 'corporate', 'finance']:
# return redirect('static_pages:reports_view')
if role in ['admin', 'corporate', 'finance']:
market_user = get_user_market_or_main_market(request.user)
if role == 'corporate' and menu_type == 'general':
market_filter = get_market_or_main_market(request, menu_type)
market_user = market_filter
else:
if market_id:
market_filter = Market.objects.filter(pk=market_id).first()
else:
market_filter = None
elif role in ['info', 'visa']:
market_user = None
market_filter = None
else:
market_user = get_user_market_or_main_market(request.user)
market_filter = market_user
selected_report = ReportList().get_report(report_type)
query = Registration.objects.select_related(
'short_term', 'program__program_base', 'program__parent',
'academic_period', 'costumer', 'costumer__profile',
'payment_responsible', 'emergency_contact', 'consultant__person',
'costumer__profile__address__city',
'costumer__profile__address__state', 'registrationflight',
'registrationfinance', 'grade').prefetch_related(
'registrationvisa', 'program__program_base__category',
'program__program_base__city__state__country', 'tutors',
'tutors__profile__phone_set', 'note_set',
'costumer__profile__address', 'costumer__profile__phone_set',
'consultant__consultantprofile__supervisor__person')
if date1 and date2:
query = query.filter(created__range=[date1, date2])
# review only admins should download all info , if not only their registrations
if role in [
'admin', 'corporate', 'finance', 'program_review', 'info',
'visa'
] or report_type == 11:
if role == 'coordinator':
query = query.by_consultantprofile_market(market_user)
elif role == 'corporate' and menu_type == 'general':
market_filter = get_market_or_main_market(request, menu_type)
query = query.by_consultantprofile_market(market_filter)
else:
pass
elif role == 'coordinator':
if report_type != 9:
query = query.by_consultantprofile_market(market_user)
# if user is supervisor, then only their consultant and his own
elif role == 'supervisor':
if not report_type == 12:
query = query.filter(
Q(consultant__consultantprofile__supervisor=request.user)
| Q(consultant=request.user))
else:
query = query.filter(Q(consultant=request.user))
# regular consultant
else:
query = query.filter(consultant=request.user)
# filter by academic period ( if present )
if academic_period_id != '' and selected_report.id != 9:
query = query.filter(academic_period_id=academic_period_id)
query_all_status = query
# filter by status ( if present )
if len(status) > 0:
query = query.filter(status__in=status)
today = datetime.datetime.today()
month_abbrev, day, year_abbrev = (
today.strftime('%b-%d-%y')).split('-')
if role in ['admin', 'corporate', 'finance']:
report_name = u'{}-{}'.format(
selected_report.safe_name,
u'{}.{}.{}'.format(month_abbrev, day, year_abbrev))
password = u'AdastraALL{}!'.format(year_abbrev)
elif role in ['info', 'visa']:
report_name = u'{}-{}'.format(
selected_report.safe_name,
u'{}.{}.{}'.format(month_abbrev, day, year_abbrev))
if role == 'info':
password = u'Leads!'
elif role == 'visa':
# not defined
password = u''
else:
report_name = u'{}-{}-{}'.format(
selected_report.safe_name, market_user.code.upper(),
u'{}.{}.{}'.format(month_abbrev, day, year_abbrev))
password = u'Adastra{}{}!'.format(market_user.code.upper(),
year_abbrev)
class DTO(object):
pass
dto = DTO()
dto.user = request.user
dto.role = get_role(request.user)
dto.academic_period_id = academic_period_id
dto.market_id = market_id
dto.status = status
dto.timezone = request.POST['timezone']
dto.market_user = market_user
dto.market_filter = market_filter
dto.start_date = date1 if date1 else None
dto.end_date = date2 if date2 else None
dto.now = timezone.now().replace(hour=23, minute=59, second=59)
dto.today_end = today_end
dto.full_year = full_year
if selected_report.protected:
compression_level = 5 # 1-9
temp_dir = tempfile.gettempdir()
dst_file = '{}.xlsx'.format(report_name)
dst_dir = '{}/{}.zip'.format(temp_dir, report_name)
src_dir = '{}/{}'.format(temp_dir, dst_file)
xlsx_data = write_to_excel(query,
selected_report.id,
query_all_status,
request,
date1,
date2,
academic_period_id,
dto,
dest_dir=src_dir)
pyminizip.compress(src_dir, None, dst_dir, password,
compression_level)
f = open(dst_dir, 'rb')
response = HttpResponse(f, content_type='application/zip')
response[
'Content-Disposition'] = 'attachment; filename={}.zip'.format(
report_name)
return response
else:
response = HttpResponse(content_type='application/vnd.ms-excel')
response[
'Content-Disposition'] = 'attachment; filename={}.xlsx'.format(
report_name)
xlsx_data = write_to_excel(query,
selected_report.id,
query_all_status,
request,
date1,
date2,
academic_period_id,
dto,
dest_dir=None)
response.write(xlsx_data)
return response
else:
return HttpResponse('{Only POST request allowed.}', status=200)
