1 import os

     2 

     3 from django.http import HttpResponse, Http404

     4 from django.shortcuts import redirect, render_to_response

     5 from django.contrib.auth.models import User

     6 from django.contrib.auth.decorators import login_required

     7 

     8 from pytask.taskapp.models import Task, Profile, Request

     9 

    10 from pytask.taskapp.events.user import createUser

    11 from pytask.taskapp.events.request import reply_to_request

    12 

    13 from pytask.taskapp.forms.user import UserProfileEditForm, UserChoiceForm

    14 

    15 from pytask.taskapp.utilities.request import get_request, create_request

    16 from pytask.taskapp.utilities.notification import get_notification, create_notification

    17 from pytask.taskapp.utilities.user import get_user

    18 

    19 about = {

    20     "addmentors": "about/addmentors.html",

    21     "mentor": "about/mentor.html", 

    22     "starthere": "about/starthere.html",

    23     "task": "about/task.html",

    24     "tasklife": "about/tasklife.html",

    25     "developer": "about/developer.html",

    26     "notification": "about/notification.html",

    27     "request": "about/request.html",

    28     "manager": "about/manager.html",

    29     "admin": "about/admin.html",

    30 }

    31 

    32 def show_msg(user, message, redirect_url=None, url_desc=None):

    33     """ simply redirect to homepage """

    34     

    35     return render_to_response('show_msg.html',{'user':user, 'message':message, 'redirect_url':redirect_url, 'url_desc':url_desc})

    36 

    37 def homepage(request):

    38     """ check for authentication and display accordingly. """

    39    

    40     user = request.user

    41     is_guest = False

    42     is_mentor = False

    43     can_create_task = False

    44     task_list = []

    45     

    46     if not user.is_authenticated():

    47         is_guest = True

    48         disp_num = 10

    49         task_list = Task.objects.exclude(status="UP").exclude(status="CD").exclude(status="CM").order_by('published_datetime').reverse()[:10]

    50         return render_to_response('index.html', {'user':user, 'is_guest':is_guest, 'task_list':task_list})

    51         

    52     else:

    53         user = get_user(request.user)

    54         user_profile = user.get_profile()

    55         is_mentor = True if user.task_mentors.all() else False

    56         can_create_task = False if user_profile.rights == u"CT" else True

    57         

    58         context = {'user':user,

    59                    'is_guest':is_guest,

    60                    'is_mentor':is_mentor,

    61                    'task_list':task_list,

    62                    'can_create_task':can_create_task,

    63                    }

    64 

    65         context["unpublished_tasks"] = user.task_mentors.filter(status="UP")

    66         context["mentored_tasks"] = user.task_mentors.exclude(status="UP").exclude(status="CM").exclude(status="CD").exclude(status="DL")

    67         context["claimed_tasks"] = user.task_claimed_users.exclude(status="UP").exclude(status="CM").exclude(status="CD").exclude(status="DL")

    68         context["working_tasks"] = user.task_assigned_users.filter(status="WR")

    69                    

    70         return render_to_response('index.html', context)

    71 

    72 @login_required

    73 def learn_more(request, what):

    74     """ depending on what was asked for, we render different pages.

    75     """

    76 

    77     user = get_user(request.user)

    78     disp_template = about.get(what, None)

    79     if not disp_template:

    80         raise Http404

    81     else:

    82         return render_to_response(disp_template, {'user':user})

    83 

    84 @login_required

    85 def view_my_profile(request,uid=None):

    86     """ allows the user to view the profiles of users """

    87     user = get_user(request.user)

    88     request_user_profile = request.user.get_profile()

    89     request_user_privilege = True if request_user_profile.rights in ['AD','MG'] else False

    90     if uid == None:

    91         edit_profile = True

    92         profile = Profile.objects.get(user = request.user)

    93         return render_to_response('user/my_profile.html', {'edit_profile':edit_profile,'profile':profile, 'user':user, 'privilege':request_user_privilege})

    94     edit_profile = True if request.user == User.objects.get(pk=uid) else False

    95     try:

    96         profile = Profile.objects.get(user = User.objects.get(pk=uid))

    97     except Profile.DoesNotExist:

    98         raise Http404

    99     return render_to_response('user/my_profile.html', {'edit_profile':edit_profile,'profile':profile, 'user':user, 'privilege':request_user_privilege})

   100 

   101 @login_required

   102 def edit_my_profile(request):

   103     """ enables the user to edit his/her user profile """

   104 

   105     user = get_user(request.user)

   106     user_profile = user.get_profile()

   107 

   108     edit_profile_form = UserProfileEditForm(instance = user_profile)

   109     if request.method == 'POST':

   110 

   111         data = request.POST.copy()

   112         uploaded_photo = request.FILES.get('photo', None)

   113         data.__setitem__('photo', uploaded_photo)

   114 

   115         edit_profile_form = UserProfileEditForm(data, instance=user_profile)

   116         if edit_profile_form.is_valid():

   117             edit_profile_form.save()

   118             return redirect('/user/view/uid='+str(user.id))

   119         else:

   120             return render_to_response('user/edit_profile.html',{'user':user, 'edit_profile_form' : edit_profile_form})

   121     else:

   122         profile = user.get_profile()

   123         edit_profile_form = UserProfileEditForm(instance = profile)

   124         return render_to_response('user/edit_profile.html',{'edit_profile_form' : edit_profile_form, 'user':user})

   125 

   126 @login_required

   127 def browse_requests(request):

   128     

   129     user = get_user(request.user)

   130     active_reqs = user.request_sent_to.filter(is_replied=False).exclude(is_valid=False)

   131     reqs = active_reqs.order_by('creation_date').reverse()

   132 

   133     context = {

   134         'user':user,

   135         'reqs':reqs,

   136     }

   137 

   138     return render_to_response('user/browse_requests.html', context)

   139 

   140 @login_required

   141 def view_request(request, rid):

   142     """ please note that request variable in this method is that of django.

   143     our app request is called user_request.

   144     """

   145 

   146     user = get_user(request.user)

   147     user_rights = user.get_profile().rights

   148     newest, newer, user_request, older, oldest = get_request(rid, user)

   149     if not user_request:

   150         raise Http404

   151 

   152     user_request.is_read = True

   153     user_request.save()

   154 

   155     context = {

   156         'user':user,

   157         'req':user_request,

   158         'sent_users':user_request.sent_to.all(),

   159         'newest':newest,

   160         'newer':newer,

   161         'older':older,

   162         'oldest':oldest,

   163     }

   164 

   165     return render_to_response('user/view_request.html', context)

   166 

   167 @login_required

   168 def process_request(request, rid, reply):

   169     """ check if the method is post and then update the request.

   170     if it is get, display a 404 error.

   171     """

   172 

   173     user = get_user(request.user)

   174     browse_request_url= '/user/requests'

   175     newest, newer, req_obj, older, oldest = get_request(rid, user)

   176 

   177     if not req_obj:

   178         return show_msg(user, "Your reply has been processed", browse_request_url, "view other requests")

   179 

   180     if request.method=="POST":

   181         reply = True if reply == "yes" else False

   182         req_obj.remarks = request.POST.get('remarks', "")

   183         req_obj.save()

   184 

   185         reply_to_request(req_obj, reply, user)

   186 

   187         return redirect('/user/requests/')

   188         return show_msg(user, "Your reply has been processed", browse_request_url, "view other requests")

   189     else:

   190         return show_msg(user, "You are not authorised to do this", browse_request_url, "view other requests")

   191 

   192 @login_required

   193 def browse_notifications(request):

   194     """ get the list of notifications that are not deleted and display in datetime order.

   195     """

   196 

   197     user = get_user(request.user)

   198 

   199     active_notifications = user.notification_sent_to.filter(is_deleted=False).order_by('sent_date').reverse()

   200 

   201     context = {

   202         'user':user,

   203         'notifications':active_notifications,

   204     }

   205 

   206     return render_to_response('user/browse_notifications.html', context)

   207 

   208 @login_required

   209 def view_notification(request, nid):

   210     """ get the notification depending on nid.

   211     Display it.

   212     """

   213 

   214     user = get_user(request.user)

   215     newest, newer, notification, older, oldest = get_notification(nid, user)

   216     if not notification:

   217         raise Http404

   218 

   219     notification.is_read = True

   220     notification.save()

   221 

   222     context = {

   223         'user':user,

   224         'notification':notification,

   225         'newest':newest,

   226         'newer':newer,

   227         'older':older,

   228         'oldest':oldest,

   229     }

   230 

   231     return render_to_response('user/view_notification.html', context)

   232 

   233 @login_required

   234 def edit_notification(request, nid, action):

   235     """ if action is delete, set is_deleted.

   236     if it is unread, unset is_read.

   237     save the notification and redirect to browse_notifications.

   238     """

   239 

   240     user = get_user(request.user)

   241     newest, newer, notification, older, oldest = get_notification(nid, user)

   242 

   243     if not notification:

   244         raise Http404

   245 

   246     notifications_url = "/user/notifications/"

   247 

   248     if request.method == "POST":

   249         if action == "delete":

   250             notification.is_deleted = True

   251         elif action == "unread":

   252             notification.is_read = False

   253         

   254         notification.save()

   255         if older:

   256             return redirect('/user/notifications/nid=%s'%older.id)

   257         else:

   258             return redirect(notifications_url)

   259     else:

   260         return show_msg(user, 'This is wrong', notification_url, "view the notification")

   261  

   262 @login_required

   263 def change_rights(request, role):

   264     """ check if the current user has privileges to do this.

   265     """

   266     

   267     user = get_user(request.user)

   268     role = role.upper()

   269     user_profile = user.get_profile()

   270     user_rights = user_profile.rights

   271 

   272     user_can_view = True if user_rights == "AD" or ( user_rights == "MG" and role in ["MG", "DV"] ) else False

   273 

   274     if user_can_view:

   275         if role == "DV":

   276             current_contributors = list(User.objects.filter(is_active=True,profile__rights="CT"))

   277             pending_requests = user.request_sent_by.filter(is_replied=False,is_valid=True)

   278             pending_dv_requests = pending_requests.filter(role="DV")

   279 

   280             ## one cannot make same request many times

   281             for req in pending_dv_requests:

   282                 current_contributors.remove(req.sent_to.all()[0])

   283 

   284             choices = [ (_.id,_.username ) for _ in current_contributors ]

   285 

   286         elif role == "MG":

   287             active_users = User.objects.filter(is_active=True)

   288             dv_ct_users = list(active_users.filter(profile__rights="CT") | active_users.filter(profile__rights="DV"))

   289             pending_requests = user.request_sent_by.filter(is_replied=False,is_valid=True)

   290             pending_mg_requests = pending_requests.filter(role="MG")

   291 

   292             ## same logic here. you cannot make another request exactly the same.

   293             ## but iam still not decided whether someone who requests a user to be admin,

   294             ## can be given a chance to request the same user to be a manager or developer

   295             for req in pending_mg_requests:

   296                 dv_ct_users.remove(req.sent_to.all()[0])

   297 

   298             choices = [ (_.id, _.username ) for _ in dv_ct_users ]

   299 

   300         elif role == "AD":

   301             active_users = User.objects.filter(is_active=True)

   302             non_ad_users = list(active_users.exclude(profile__rights="AD"))

   303             pending_requests = user.request_sent_by.filter(is_replied=False,is_valid=True)

   304             pending_ad_requests = pending_requests.filter(role="AD")

   305 

   306             ## we filter out users who have already been requested by the user to be an admin

   307             for req in pending_ad_requests:

   308                 non_ad_users.remove(req.sent_to.all()[0])

   309 

   310             choices = [ (_.id,_.username ) for _ in non_ad_users ]

   311 

   312         form = UserChoiceForm(choices)

   313 

   314         context = {

   315             'user':user,

   316             'form':form,

   317         }

   318 

   319         if request.method=="POST":

   320             data = request.POST

   321             form = UserChoiceForm(choices, data)

   322             if form.is_valid():

   323                 user_to_change = User.objects.get(id=form.cleaned_data['user'])

   324                 create_request(sent_by=user, role=role, sent_to=user_to_change)

   325                 return show_msg(user, "A request has been sent", "/", "return to home page")

   326             else:

   327                 raise Http404

   328         else:

   329             return render_to_response('user/changerole.html', context)

   330     else:

   331         raise Http404

   332 

   333 

   334 

   335 

   336 

   337 

   338 

   339 

   340 

   341 

   342 

   343 

   344 

   345 

   346 

   347