Exemple #1
1
def index(request):
    if request.method == "GET":
        return render_to_response(
            "index.html",
            {"error": False, "token_field_name": TOKEN_FIELD_NAME},
            context_instance=RequestContext(request),
        )
    else:
        formkey = urlparser.get_formkey(request.POST["formurl"])

        if not formkey:
            return render_to_response(
                "index.html",
                {"error": True, "formurl": request.POST["formurl"], "token_field_name": TOKEN_FIELD_NAME},
                context_instance=RequestContext(request),
            )

        form = Form(formkey=formkey)
        form.fill_entry_id()
        if not form.entry_id:
            return render_to_response(
                "index.html",
                {"error": True, "formurl": request.POST["formurl"], "token_field_name": TOKEN_FIELD_NAME},
                context_instance=RequestContext(request),
            )

        form.save()

        return render_to_response("created.html", {"form": form})
Exemple #2
0
def owners(request):
    owners_list = User.objects.filter(pod__in=VIDEOS).order_by(
        'last_name').distinct()  # User.objects.all()
    owners_filter = request.GET.get(
        'owners_filter') if request.GET.get('owners_filter') else None
    if owners_filter:
        owners_list = owners_list.filter(
            last_name__iregex=r'^%s+' % owners_filter)
    #per_page = request.GET.get('per_page') if request.GET.get('per_page') and request.GET.get('per_page').isdigit() else DEFAULT_PER_PAGE
    per_page = request.COOKIES.get('perpage') if request.COOKIES.get(
        'perpage') and request.COOKIES.get('perpage').isdigit() else DEFAULT_PER_PAGE
    paginator = Paginator(owners_list, per_page)
    page = request.GET.get('page')

    owners = get_pagination(page, paginator)

    if request.is_ajax():
        return render_to_response("owners/owners_list.html",
                                  {"owners": owners},
                                  context_instance=RequestContext(request))

    return render_to_response("owners/owners.html",
                              {"owners": owners, "video_count": VIDEOS.filter(
                                  owner__in=list(owners_list)).count()},
                              context_instance=RequestContext(request))
Exemple #3
0
def create_saved_search(request, database_name=settings.MONGO_DB_NAME,
                collection_name=settings.MONGO_MASTER_COLLECTION,
                        skip=0, limit=200, return_keys=()):
    name = _("Create a Saved Search")
    if request.method == 'POST':
        form = SavedSearchForm(request.POST)
        if form.is_valid():
            ss = form.save(commit = False)
            ss.user = request.user
            ss.save()
                
            return HttpResponseRedirect(reverse('saved_searches'))
        else:
            #The form is invalid
             messages.error(request,_("Please correct the errors in the form."))
             return render_to_response('generic/bootstrapform.html',
                                            {'form': form,
                                             'name':name,
                                             },
                                            RequestContext(request))
            
   #this is a GET
    idata ={'database_name': database_name,
            'collection_name': collection_name}
    
    
    context= {'name':name,
              'form': SavedSearchForm(initial=idata)
              }
    return render_to_response('generic/bootstrapform.html',
                             RequestContext(request, context,))
Exemple #4
0
def register(request):

    form_data = request.POST.copy()
    
    form = RegistrationForm(form_data)
    errors = form.errors
    print request.POST
    print form.errors
    if errors:
        return render_to_response('login.html', {'form': form})

    # logout the existing user
    if (isinstance (request.user, AnonymousUser)):
        u = None
    else:
        u = request.user
        logout(request)

    email = request.POST['register_email']
    password = request.POST['register_password']

    try:
        u = User(username=email)
        u.set_password(password)
        u.email = email
        u.save()
    except:
        return render_to_response('login.html', {'form': form})
    response = render_to_response('login.html', {'registration_status': "Registered successfully! Now you can login with your credentials!" })
    return response
Exemple #5
0
def favorites_videos_list(request):
    videos_list = Pod.objects.filter(
        id__in=request.user.favorites_set.all().values_list('video', flat=True))

    per_page = request.COOKIES.get('perpage') if request.COOKIES.get(
        'perpage') and request.COOKIES.get('perpage').isdigit() else DEFAULT_PER_PAGE

    order_by = request.COOKIES.get('orderby') if request.COOKIES.get(
        'orderby') else "order_by_-date_added"
    videos_list = videos_list.order_by(
        "%s" % replace(order_by, "order_by_", ""))

    paginator = Paginator(videos_list, per_page)
    page = request.GET.get('page')

    videos = get_pagination(page, paginator)

    if request.is_ajax():
        return render_to_response("videos/videos_list.html",
                                  {"videos": videos},
                                  context_instance=RequestContext(request))

    return render_to_response("favorites/my_favorites.html",
                              {"videos": videos},
                              context_instance=RequestContext(request))
Exemple #6
0
def user_add(request):
    if request.method=="GET":
        user_list=user_manage.UserGet().get_user_list('')
        return render_to_response('user_add.html',{"user_list":user_list},context_instance=RequestContext(request))
    else:
        result,msg=user_manage.UserManage(request.POST).user_add()
        return render_to_response('user_add.html',{"msg":msg},context_instance=RequestContext(request))
Exemple #7
0
def contactview(request):
    name = request.POST.get('name', '')
    subject = request.POST.get('topic', '')
    message = request.POST.get('message', '')
    from_email = request.POST.get('email', '')

    if name and message and from_email:
        t = get_template('contact_message.txt')
        c = Context({
            'name': name,
            'from_email': from_email,
            'message': message
        })
        email_message = t.render(c)
        try:
            mail_admins(subject, email_message)
        except BadHeaderError:
            return HttpResponse('Invalid header found.')
        return HttpResponseRedirect('/contact/thankyou/')
    else:
        return render_to_response('contact/contacts.html',
                                  {'form': ContactForm()},
                                  RequestContext(request))

    return render_to_response('contact/contacts.html', {'form': ContactForm()},
                              RequestContext(request))
Exemple #8
0
def profile_page(request, view_user):
    if not request.user.is_authenticated():
        return HttpResponseRedirect(reverse('forum.views.main_index',))
    else:
        if request.user.username == view_user:
            if request.method == 'POST':
                #print request.FILES
                form_profile = ProfileUpdate(request.POST, request.FILES)
                if form_profile.is_valid():
                    # process data
                    cd = form_profile.cleaned_data
                    user_update = ForumUser.objects.get(user=request.user)
                    
                    success_reply = []
                    
                    if request.FILES:
                        f = request.FILES['avatar_img']
                        
                        destination = open('%s/avatars/%s' % (settings.MEDIA_ROOT, f.name), 'wb+')
                        for chunk in f.chunks():
                            destination.write(chunk)
                        destination.close()
                        
                        user_update.avatar_img = "avatars/%s" % f.name
                        user_update.save()
                        
                        # uploadedImage = cd['avatar_img']
                        # user_update = (request.FILES)
                    
                    if(cd['password1']):
                        user_update.user.set_password(cd['password1'])
                        user_update.user.save()
                        success_reply.append('Password')
                        
                    if(cd['email1'] != user_update.user.email and cd['email1'] != ''):
                        user_update.user.email = cd['email1']
                        user_update.user.save()
                        success_reply.append('Email')
                    
                    return render_to_response('profile_page.html', {'form_profile' : form_profile, 'success_reply': success_reply,
                                'forum_user': user_update, 'site_root': reverse('forum.views.main_index'), },
                                context_instance=RequestContext(request))
            else:
                default_data = {
                    'email1': request.user.email,
                    'email2': request.user.email,
                }
        
                form_profile = ProfileUpdate(default_data)
                try:
                    forum_user = ForumUser.objects.get(user=request.user)
                except:
                    forum_user = ForumUser(user=request.user)
                    forum_user.save()
        
            return render_to_response('profile_page.html', {'form_profile' : form_profile, 'forum_user' : forum_user,
                                'site_root': reverse('forum.views.main_index',),},
                                context_instance=RequestContext(request))
        else:
            return HttpResponseRedirect(reverse('forum.views.main_index',))
Exemple #9
0
def project_detail(request, pk, page=''):
    print pk, page
    try:
        project = Project.objects.get(pk=pk)
    except Project.DoesNotExist:
        raise Http404
    testers = project.testers.all()
    bugs = project.bugs.all()
    if page == None:
       return render_to_response('project_detail.html', locals(),
                              context_instance=RequestContext(request))
    elif page == '/bugs':
        return render_to_response('project_bugs.html', locals(),
            context_instance=RequestContext(request))
    elif page == '/testers':
        return render_to_response('project_testers.html', locals(),
            context_instance=RequestContext(request))
    elif page == '/enlist':
        user = request.user
        if not user.is_authenticated():
            raise PermissionDenied
        # Текущий залогиненый пользователь должен быть тестером
        if not hasattr(user, 'tester'):
            raise PermissionDenied
        tester = user.tester
        project.add_tester(tester)
        return HttpResponseRedirect('/projects/%i/testers' % project.pk)
    else:
        raise Http404
Exemple #10
0
def protocolos_descricao(request, pdf=False):
    """
     Relatório Administrativo - Relatório de Protocolos por descrição.

    """
    if request.GET.get('termo'):
        termo_id = request.GET.get('termo')
        termo = get_object_or_404(Termo, pk=termo_id)
        retorno = []
        for d in Descricao.objects.all():
            desc = {'descricao': d.__unicode__(),
                    'protocolos': Protocolo.objects.filter(descricao2=d, termo=termo)
                    .order_by('-termo__ano', 'referente')}
            retorno.append(desc)

        if pdf:
            return render_to_pdf_weasy('protocolo/descricoes.pdf', {'protocolos': retorno}, request=request,
                                       filename='protocolos.pdf')
        else:
            return render_to_response('protocolo/descricoes.html', {'protocolos': retorno, 'termo': termo},
                                      context_instance=RequestContext(request))
    else:
        return render_to_response('financeiro/relatorios_termo.html',
                                  {'termos': Termo.objects.all(), 'view': 'protocolos_descricao'},
                                  context_instance=RequestContext(request))
Exemple #11
0
def register_req(request):
    state = "Something wrong happened. Please reload this page"
    username = password1 = password2 = ''
    if request.POST:
        username = request.POST.get('username')
        password1 = request.POST.get('password1')
        password2 = request.POST.get('password2')
        # Check username is blank
        if not username:
            state = "Please type your username in the field"
            return render_to_response('register.html',{'state':state})
        # Check password is same
        if password1 == password2:
            pass
        else:
            state = "Passwords are not same"
            return render_to_response('intg_search.html',{'state':state})
        # Check ID is not exist & Register User
        try:
            find = User.objects.get(username=username)
        except User.DoesNotExist:
            user = User.objects.create_user(username,'',password1)
            user.save()
            state = "Registraion complete. Please log on."
    return render_to_response('intg_search.html',{'state':state})
Exemple #12
0
def addQuest(request):
	"""
	create a default quest for the user
	"""
	try:
		name = request.GET['name']
		latitude = float(request.GET['latitude'])
		longitude = float(request.GET['longitude'])
		description = request.GET['description']
		b1_lon = request.GET['b1_lon']
		b1_lat = request.GET['b1_lat']
		b2_lon = request.GET['b2_lon']
		b2_lat = request.GET['b2_lat']
		b3_lon = request.GET['b3_lon']
		b3_lat = request.GET['b3_lat']
		b4_lon = request.GET['b4_lon']
		b4_lat = request.GET['b4_lat']
		id = request.GET['username']
		pw = request.GET['password']

	except:
		return render_to_response('addquest.xml', {'result' : False,'reason': "parsing error"})
	try:
		user = returnUser(id,pw)
		q=quest(owner=user,name=name,latitude=latitude,longitude=longitude,description=description,b1_lon=b1_lon,b1_lat=b1_lat, b2_lon=b2_lon,b2_lat=b2_lat, b3_lon=b3_lon,b3_lat=b3_lat,b4_lon=b4_lon,b4_lat=b4_lat)
		q.save()
	except:
		return render_to_response('addquest.xml', {'result' : False, 'reason': "transaction error"})
	
	return render_to_response('addquest.xml', {'result' : True, 'questid' : q.id})
def show_aloj_id(request,ide):
    pathf=request.path+"/xmlfrances"
    pathi=request.path+"/xmlingles"
    try:
        hotel=Hotel.objects.get(id=ide)
        print hotel.stars
        print hotel.tipo
    except Hotel.DoesNotExist:
            context={'name': ""}
            return render_to_response('alojid.html',context);
    listimages=Image.objects.filter(hid=hotel.id)
    listcoms=""
    if request.method =='POST':
        value = request.POST.get('comentarios', "")

        n= hotel.numbercom+1;
        hotel.numbercom=n
        hotel.save()
        comment=Comment(hid=hotel.id,com=hotel,text=value)
        comment.save()
    listcoms=Comment.objects.filter(hid=hotel.id)
    
    try:
        us=PagUser.objects.get(user=request.user.username)
    except PagUser.DoesNotExist:
        context = {'lista':listimages[0:5],'condicion':"",'url':hotel.url,'name':hotel.name,'address':hotel.address,'body':hotel.body,'comentarios':listcoms,'type':hotel.tipo,'stars':hotel.stars,'pathf':pathf,'pathi':pathi,'id':ide,'email':hotel.email,
                    'phone':hotel.phone}
        return render_to_response('alojid.html', context,context_instance = RequestContext(request))
    context = {'lista':listimages[0:5],'condicion':"",'url':hotel.url,'name':hotel.name,'address':hotel.address,'body':hotel.body,'comentarios':listcoms,'type':hotel.tipo,'stars':hotel.stars,'pathf':pathf,'pathi':pathi,'id':ide,'email':hotel.email,
                'phone':hotel.phone,'color':us.color,'size':us.size}
    return render_to_response('alojid.html', context,context_instance = RequestContext(request))
def search(request):
    """
    Search for blog posts.

    This template will allow you to setup a simple search form that will try to return results based on
    given search strings. The queries will be put through a stop words filter to remove words like
    'the', 'a', or 'have' to help imporve the result set.

    Template: ``blog/post_search.html``
    Context:
        object_list
            List of blog posts that match given search term(s).
        search_term
            Given search term.
    """
    if request.GET:
        stop_word_list = re.compile(STOP_WORDS, re.IGNORECASE)
        search_term = '%s' % request.GET['q']
        cleaned_search_term = stop_word_list.sub('', search_term)
        cleaned_search_term = cleaned_search_term.strip()
        if len(cleaned_search_term) != 0:
            post_list = Post.objects.filter(body__icontains=cleaned_search_term, status__gte=2, publish__lte=datetime.datetime.now())
            context = {'object_list': post_list, 'search_term':search_term}
            return render_to_response('blog/post_search.html', context, context_instance=RequestContext(request))
        else:
            message = 'Search term was too vague. Please try again.'
            context = {'message':message}
            return render_to_response('blog/post_search.html', context, context_instance=RequestContext(request))
    else:
        return render_to_response('blog/post_search.html', {}, context_instance=RequestContext(request))
Exemple #15
0
def combo1(request):
    query = request.GET.get('q', '') 
    elementos= Ciudad.objects.all()
    if query:
        results=Universidad.objects.filter(ciudad=query)
        return render_to_response("consulta_ciudad.html",{"results": results,"query": query,"elementos": elementos}, context_instance=RequestContext(request) )
    return render_to_response("consulta_ciudad.html",{"results": elementos,"query":  query,"elementos": elementos}, context_instance=RequestContext(request))         
Exemple #16
0
def new(request):
    if request.method == 'POST':
        # We're accepting form data for save to DB
        if not request.user.is_authenticated():
            return render_to_response('registration/pleaselogin.html')
        form = NewItemForm(request.POST)
        if not form.is_valid():
            # throw error
            return HttpResponse("Error! Form invalid. Form: %s" % form)
        else:
            new_item = form.save(commit=False) 

            # grab the user id from the current user
            #new_item.seller = request.user.id
            new_item.seller = request.user

            #cd = form.cleaned_data
            new_item.save()
            #send_mail(
            #    cd['subject'],
            #    cd['message'],
            #    cd.get('email', '*****@*****.**'),
            #    ['*****@*****.**'],
            #)
            #return HttpResponseRedirect('/contact/thanks/')
        return HttpResponseRedirect('/listings/')
    else:
        # user GET
        if not request.user.is_authenticated():
            # not logged in
            return render_to_response('registration/pleaselogin.html')
        else:
            # we are logged in
            form = NewItemForm()
            return render_to_response('listings/item_form.html', {'form': form}, context_instance=RequestContext(request))
Exemple #17
0
def TaskInstanceValidate(request, task_instance_id):
    task_instance = get_object_or_404(TaskInstance, pk=task_instance_id, task__owner=request.user)
    if request.POST:

        form = ValidationForm(request.POST)
        if form.is_valid():
            if 'validation' not in task_instance.parameters:
        # TODO: unify with the api, now the code is copied
                value = form.cleaned_data['validation']
                task_instance.quality = value
                pars = task_instance.parameters
                if pars is None:
                    pars = {}
                pars['validation'] = value
                task_instance.save()
                # if ("process_tactics_id" in task_instance.parameters):
                #     signal(task_instance.parameters['process_tactics_id'], task_instance.task.id, task_instance.id)
                messages.info(request, 'Validation made')
            else:
                messages.warning(request, 'Validation was already set')
            return redirect(reverse('r-taskinstances',args={task_instance.task.process.id,task_instance.task.id,}))
        else:
            return render_to_response('requester/form.html', {'form': form}, context_instance=RequestContext(request))
    else:
        form = ValidationForm()
        return render_to_response('requester/form.html', {'form': form}, context_instance=RequestContext(request))
def course_edit_homework_handler(request, course_id = 'CSC540', homework_id = 'CSC540_1'):
	args = {}
	args.update(csrf(request))
	args['course'] = course_id	

	if request.method == 'POST':
		homework = Homework.objects.get(homework_id__contains = homework_id)
		homework.homework_id = request.POST.get('homeworkid')
		homework.homework_startdate = request.POST.get('startdate')
		homework.homework_enddate = request.POST.get('enddate')
		homework.homework_numretries = request.POST.get('numberattempts')
		homework.homework_mindifficulty = request.POST.get('mindiff')
		homework.homework_maxdifficulty = request.POST.get('maxdiff')
		homework.homework_correctanswerpts = request.POST.get('correctpoints')
		homework.homework_wronganswerpts = request.POST.get('wrongpoints')

		homework.save()

		return render_to_response('coursepage_prof.html', args)	
	else:
		homework = Homework.objects.filter(homework_cid__course_id__contains = course_id).filter(homework_id__contains = homework_id)
		args['homework'] = homework[0].homework_id
		args['startdate'] = homework[0].homework_startdate
		args['enddate'] = homework[0].homework_enddate
		args['numretries'] = homework[0].homework_numretries
		args['mindifficulty'] = homework[0].homework_mindifficulty
		args['maxdifficulty'] = homework[0].homework_maxdifficulty
		args['correctanswerpts'] = homework[0].homework_correctanswerpts
		args['wronganswerpts'] = homework[0].homework_wronganswerpts
		args['cid'] = homework[0].homework_cid

		return render_to_response('course_edit_homework_prof.html', args)
def process_application(request, status):
    context = RequestContext(request)

    if request.method == 'GET':
        # process request if both IDs are available in the request
        if 'intern_id' in request.GET and 'job_id' in request.GET:
            try:
                recruiter = Recruiter.objects.get(user=request.user)

                intern = Intern.objects.get(id=request.GET['intern_id'])
                job = Job.objects.get(id=request.GET['job_id'])

                application = Application.objects.get(intern=intern,job=job)

                # restrict access to that user, who is offering the internship
                if job.company != recruiter:
                    return render_to_response('error.html', {'error': "You don't have the permission to accept interns for this job"}, context)

                application.status = status
                application.save()

                return render_to_response('company/process_application_feedback.html', {'status': status, 'intern': intern, 'user_type': 1}, context)

            # Invalid data
            except (Intern.DoesNotExist, Job.DoesNotExist, Application.DoesNotExist, Recruiter.DoesNotExist):
                return render_to_response('error.html', {'error': "Could not process your request"}, context)

        else:
            # Missing data
            return render_to_response('error.html', {'error': "Missing dictionary key"}, context)

    else:
        return render_to_response('error.html', {'error': "Something is wrong"}, context)
Exemple #20
0
def TaskValidate(request, task_id):
    log.debug("task_id %s - %s - %s" %(task_id,request.POST,request.GET))
    task = get_object_or_404(Task, pk=task_id, owner=request.user)

    if request.POST:

        form = ValidationForm(request.POST)
        if form.is_valid():
        # TODO: unify with the api, now the code is copied
            value = form.cleaned_data['validation']
            for task_instance in task.taskinstance_set.all():
                if 'validation' not in task_instance.parameters:
                    task_instance.quality = value
                    pars = task_instance.parameters
                    if pars is None:
                        pars = {}
                    pars['validation'] = value
                    task_instance.save()
                    # if ("process_tactics_id" in task_instance.parameters):
                    #     signal(task_instance.parameters['process_tactics_id'], task_instance.task.id, task_instance.id)
            messages.info(request, 'Validation made')
            return redirect(reverse('r-taskinstances',args={task_instance.task.process.id,task_instance.task.id,}))
        else:
            return render_to_response('requester/form.html', {'form': form}, context_instance=RequestContext(request))
    else:
        log.debug("GET task_id %s",task_id)
        form = ValidationForm()
        return render_to_response('requester/form.html', {'form': form}, context_instance=RequestContext(request))
Exemple #21
0
def create_peg(request):
    if request.method == 'POST':
        form = PegCreateForm(request.POST)
        if form.is_valid():
            print "VALID"
            # Create Peg
            peg, dummy = Peg.objects.get_or_create(
                url = form.cleaned_data['url'],
                name = form.cleaned_data['name'],
                peg_des = form.cleaned_data['desc']
            )
            myboard = Board.objects.get(id = 1)
            #boardname = request.POST['boardname']
            myboard.peg_set.add(peg)
            myboard.save()
            return HttpResponse("Peg Saved")
        else:
            print "INVALID"
            form = PegCreateForm()
            variables = RequestContext(request, {'form': form})
            return render_to_response('CRUD_Peg.html', variables)
    else:
        print "VALID LOad"
        form = PegCreateForm()
        variables = RequestContext(request, {'form': form})
        return render_to_response('CRUD_Peg.html', variables)
Exemple #22
0
def create_board(request):
    if request.method == 'POST':
        form = BoardCreateForm(request.POST)
        if form.is_valid():
            print "VALID"
            # Create Board
            board, dummy = Board.objects.get_or_create(
                Board_name = form.cleaned_data['bname'],
                user_id = "1",                
                Board_des = form.cleaned_data['bdesc']
            )
            mmboard= Board.objects.get(id = 1)
           
            mmboard.save()
                #boardname = request.POST['boardname']            
         
            return HttpResponse("Board Saved")
        else:
            print "INVALID"
            form = BoardCreateForm()
            variables = RequestContext(request, {'form': form})
            return render_to_response('CRUD_Board.html', variables)   
    else:
        print "VALID Load"
        form = BoardCreateForm()
        variables = RequestContext(request, {'form': form})
        return render_to_response('CRUD_Board.html', variables)
Exemple #23
0
def usage_morereset(request):
	quota_update_fail = False
	try:
		refresh_all_quota_usage()
	except:
		quota_update_fail = True

	current_event = get_current_event()
	if current_event == None:
		return render_to_response('frontend/event-not-active.html',
			context_instance=RequestContext(request))

	attendances = EventAttendance.objects.filter(
		event__exact=current_event
	).order_by('-quota_multiplier')
	total = 0L
	for a in attendances:
		total += a.quota_used

	return render_to_response('frontend/usage.html', {
		'attendances': attendances,
		'total': bytes_str(total),
		'mode': _('most resets'),
		'quota_update_fail': quota_update_fail
	}, context_instance=RequestContext(request))
Exemple #24
0
def usage_speed(request):
	quota_update_fail = False
	try:
		refresh_all_quota_usage()
	except:
		quota_update_fail = True

	current_event = get_current_event()
	if current_event == None:
		return render_to_response('frontend/event-not-active.html',
			context_instance=RequestContext(request))

	attendances = list(EventAttendance.objects.filter(
		event__exact=current_event
	))
	attendances.sort(
		key=(lambda o:
			o.last_datapoint().average_speed() if o.last_datapoint() else 0
		),
		reverse=True
	)
	
	total = 0L
	for a in attendances:
		total += a.quota_used

	return render_to_response('frontend/usage.html', {
		'attendances': attendances,
		'total': bytes_str(total),
		'mode': _('highest speed'),
		'quota_update_fail': quota_update_fail
	}, context_instance=RequestContext(request))
Exemple #25
0
def get_view(request, topic_id):
	try:
		topic = Topic.objects.get(pk=topic_id)
	except Topic.DoesNotExist:
		raise Http404
	user = request.user
	if user.is_authenticated():
		counter = {
			'topics' : user.topic_author.all().count(),
			'replies': user.reply_author.all().count(),
			'favorites': user.fav_user.all().count()
		}
		notifications_count = user.notify_user.filter(status=0).count()
		topic_favorited = Favorite.objects.filter(involved_topic=topic, owner_user=user).exists()

	reply_num = 106
	reply_count = topic.reply_count
	print 'reply_count,',reply_count
	reply_last_page = (reply_count // reply_num + (reply_count % reply_num and 1)) or 1
	try:
		current_page = int(request.GET.get('p', reply_last_page))
	except ValueError:
		current_page = reply_last_page
	replies, reply_page = Reply.objects.get_all_replies_by_topic_id(topic_id=topic_id, current_page=current_page, num=reply_num)
	active_page = 'topic'
	floor = reply_num * (current_page - 1)

	topic.reply_count = reply_page.total
	topic.hits = (topic.hits or 0) + 1
	topic.save()

	render_to_response('topic.view.html',locals(),
		context_instance=RequestContext(request))
Exemple #26
0
def regions(request, id=None):
    if id:
        catalog_items = RegionDirectory.objects.filter(parent=id).order_by('name')
    else:
        catalog_items = RegionDirectory.objects.filter(parent=None).order_by('name')
        id = ""
    if request.POST:
        data_dict = request.POST
        form = RegionDirectoryForm(data=data_dict)
        if (form.is_valid()):
            entity = form.save(commit=True)
            if id:
                entity.setParent(RegionDirectory.objects.get(pk=id))
        else:
            return render_to_response('ratings/simple_catalogs_management.html',
                                      dict(form=form,
                                           title="Регионы голосований",
                                           link="/ratings/admin/catalogs/",
                                           link_text="Вернуться в список каталогов",
                                           catalog_items=catalog_items, parent=id),
                              context_instance=RequestContext(request))
    form = RegionDirectoryForm()
    return render_to_response('ratings/simple_catalogs_management.html',
                              dict(form=form,
                                   title="Регионы голосований",
                                   link="/ratings/admin/catalogs/",
                                   link_text="Вернуться в список каталогов",
                                   catalog_items=catalog_items, parent=id),
                              context_instance=RequestContext(request))
Exemple #27
0
def quota_user_reset(request):
	user = request.user
	profile = get_userprofile(user)
	current_event = get_current_event()
	if current_event == None:
		return render_to_response('frontend/event-not-active.html',
			context_instance=RequestContext(request))
	
	attendance = get_userprofile_attendance(current_event, profile)
	if attendance == None:
		return render_to_response('frontend/not-signed-in.html', dict(
			event=current_event
		), context_instance=RequestContext(request))

	# TODO: Make it check you have used at least 70% of your quota before
	# continuing.

	if request.method == "POST":
		reset_form = ResetLectureForm(request.POST)

		if reset_form.check_answers():
			try:
				# reset the quota if allowed.
				# we do ==1 here instead of < 2 because otherwise someone could use
				# this to regain internet access after having it revoked forcefully.
				if attendance.quota_multiplier == 1:
					# create a log of this event
					if settings.RESET_EXCUSE_REQUIRED:
						excuse = reset_form.cleaned_data['excuse']
					else:
						# clear out the reset excuse if one was provided but not
						# allowed.
						excuse = ''
					QuotaResetEvent.objects.create(
						event_attendance=attendance,
						performer=profile,
						excuse=excuse
					)

					attendance.quota_multiplier = 2
					attendance.save()

				enable_user_quota(attendance)
				sync_user_connections(profile)
			except:
				return controller_error(request)

			return redirect('quota')
		else:
			# some answers were incorrect
			return render_to_response('frontend/reset-lecture.html', {
				'reset_form': reset_form,
				'incorrect': True
			}, context_instance=RequestContext(request))
	else:
		reset_form = ResetLectureForm()
		return render_to_response('frontend/reset-lecture.html', {
			'reset_form': reset_form,
			'incorrect': False
		}, context_instance=RequestContext(request))
Exemple #28
0
def nginx_configuration_editor(request):
    config_rw = FileRW()
    if request.method == "POST":
        text = request.POST.get("nginx_config_text", "unknown");
        if text != "unknown":
            response = {}
            try:
                config_rw.write(constant.DEFAULT_NGINX_LOCATION, text)
            except RigeryError as rigery_error:
                response["error_message"] = rigery_error.message
            response["nginx_config_text"] = text
            response["nginx_conf_location"] = constant.DEFAULT_NGINX_LOCATION
            return render_to_response(
                    "nginx_manager/nginx_configuration_editor.html",
                    response,
                    context_instance=RequestContext(request),
                )
        else:
            return render_to_response(
                    "nginx_manager/nginx_configuration_editor.html",
                    {"error_message", "Wrong type of request"},
                    context_instance=RequestContext(request),
                )

    else:
        response = {}
        response["nginx_config_text"] = config_rw.read(constant.DEFAULT_NGINX_LOCATION)
        response["nginx_conf_location"] = constant.DEFAULT_NGINX_LOCATION
        return render_to_response(
                "nginx_manager/nginx_configuration_editor.html",
                response,
                context_instance=RequestContext(request),
            )
Exemple #29
0
def search1(request):
    empty = False
    list_search =[]
    errors=[]
    s_name= request.GET["selection"]
    if 'q' in request.GET and request.GET['q']:
        message = request.GET['q']
        if s_name=="author_name":
            list_search = Book.objects.filter(author__icontains=message)
        if s_name=="book_name":
            list_search = Book.objects.filter(name__icontains=message)
        final_list=[]
        if str(list_search) == "[]":
            empty = True
            errors.append("not found")
            return render_to_response('base2.html',{'errors':errors})
        else:
            final_list = []
            for i in list_search:
                mylist =[]
                mylist.append(i.id_book)
                mylist.append(i.name)
                mylist.append(i.author)
                mylist.append(i.price)

                final_list.append(mylist)

        return render_to_response('proffer.html', {'endlist':final_list})
Exemple #30
0
def upload(request):
	try:
		uid=request.COOKIES['me_uid']
	except KeyError:
		return HttpResponseRedirect('http://www.me.uestc.edu.cn/stu/index.php/Login/')
	auth= UserAuth(uid).is_auth()	
	if not auth:
		return HttpResponseRedirect('http://www.me.uestc.edu.cn/stu/index.php/Login/')
	if request.method == "POST":
		form = UploadFileForm(request.POST,request.FILES)
		typ=request.FILES['files'].name.split('.')[1]
		if not (typ=='xls' or typ=='xlsx'):
			return  HttpResponse("<h1>上传失败 只能上传excel文件</h1></br><a href='upload'>返回重新上传</a>")
		if form.is_valid():
			files = open('static/excel.xls','w+')
			for chunk in request.FILES['files'].chunks():
				files.write(chunk)
			files.close()
			up_suc=handle_upload_file()
			if up_suc :
				q=u"上传失败,请以学号为第一列!"
			else:
				q=u"上传成功!"
			return render_to_response('success.html',{'q':q})
		
	else :
		form = UploadFileForm()
	return render_to_response('upload.html', {'form': form})
def thanks(request):
    return render_to_response('thanks.html')
Exemple #32
0
def bookmarklets(request):
    admin_root = get_root_path()
    return render_to_response('admin_doc/bookmarklets.html', {
        'root_path': admin_root,
        'admin_url': mark_safe("%s://%s%s" % (request.is_secure() and 'https' or 'http', request.get_host(), admin_root)),
    }, context_instance=RequestContext(request))
def userIndexTemplate(request):
    templates = Template.objects.filter(user=request.user.id)

    return render_to_response("template/index.html",
                              locals(),
                              context_instance=RequestContext(request))
def missing_docutils_page(request):
    """Display an error message for people without docutils"""
    return render_to_response('admin_doc/missing_docutils.html')
def model_detail(request, app_label, model_name):
    if not utils.docutils_is_available:
        return missing_docutils_page(request)
        
    # Get the model class.
    try:
        app_mod = models.get_app(app_label)
    except ImproperlyConfigured:
        raise Http404(_("App %r not found") % app_label)
    model = None
    for m in models.get_models(app_mod):
        if m._meta.object_name.lower() == model_name:
            model = m
            break
    if model is None:
        raise Http404(_("Model %(model_name)r not found in app %(app_label)r") % {'model_name': model_name, 'app_label': app_label})

    opts = model._meta

    # Gather fields/field descriptions.
    fields = []
    for field in opts.fields:
        # ForeignKey is a special case since the field will actually be a
        # descriptor that returns the other object
        if isinstance(field, models.ForeignKey):
            data_type = related_object_name = field.rel.to.__name__
            app_label = field.rel.to._meta.app_label
            verbose = utils.parse_rst((_("the related `%(app_label)s.%(data_type)s` object")  % {'app_label': app_label, 'data_type': data_type}), 'model', _('model:') + data_type)
        else:
            data_type = get_readable_field_data_type(field)
            verbose = field.verbose_name
        fields.append({
            'name': field.name,
            'data_type': data_type,
            'verbose': verbose,
            'help_text': field.help_text,
        })

    # Gather model methods.
    for func_name, func in list(model.__dict__.items()):
        if (inspect.isfunction(func) and len(inspect.getargspec(func)[0]) == 1):
            try:
                for exclude in MODEL_METHODS_EXCLUDE:
                    if func_name.startswith(exclude):
                        raise StopIteration
            except StopIteration:
                continue
            verbose = func.__doc__
            if verbose:
                verbose = utils.parse_rst(utils.trim_docstring(verbose), 'model', _('model:') + opts.module_name)
            fields.append({
                'name': func_name,
                'data_type': get_return_data_type(func_name),
                'verbose': verbose,
            })

    # Gather related objects
    for rel in opts.get_all_related_objects():
        verbose = _("related `%(app_label)s.%(object_name)s` objects") % {'app_label': rel.opts.app_label, 'object_name': rel.opts.object_name}
        accessor = rel.get_accessor_name()
        fields.append({
            'name'      : "%s.all" % accessor,
            'data_type' : 'List',
            'verbose'   : utils.parse_rst(_("all %s") % verbose , 'model', _('model:') + opts.module_name),
        })
        fields.append({
            'name'      : "%s.count" % accessor,
            'data_type' : 'Integer',
            'verbose'   : utils.parse_rst(_("number of %s") % verbose , 'model', _('model:') + opts.module_name),
        })
    root_path = re.sub(re.escape('doc/models/%s.%s/' % (app_label, model_name)) + '$', '', request.path)
    return render_to_response('admin_doc/model_detail.html', {
        'root_path': root_path,
        'name': '%s.%s' % (opts.app_label, opts.object_name),
        'summary': _("Fields on %s objects") % opts.object_name,
        'description': model.__doc__,
        'fields': fields,
    }, context_instance=RequestContext(request))
Exemple #36
0
def rank_teams_ajax(request):
    return render_to_response('rank_teams.html', {'title': "Team Rankings"},
                              context_instance=RequestContext(request))
Exemple #37
0
def tab_card(request, team_id):
    try:
        team_id = int(team_id)
    except ValueError:
        return render_to_response('error.html', {
            'error_type': "Tab Card",
            'error_name': "View",
            'error_info': "Team id must be an integer!"
        },
                                  context_instance=RequestContext(request))
    team = Team.objects.get(pk=team_id)
    rounds = ([r for r in Round.objects.filter(gov_team=team)] +
              [r for r in Round.objects.filter(opp_team=team)])
    rounds.sort(key=lambda x: x.round_number)
    roundstats = [RoundStats.objects.filter(round=r) for r in rounds]
    debaters = [d for d in team.debaters.all()]
    d1, d2 = debaters[0], debaters[1]
    round_stats = []
    num_rounds = TabSettings.objects.get(key="tot_rounds").value
    cur_round = TabSettings.objects.get(key="cur_round").value
    blank = " "
    for i in range(num_rounds):
        round_stats.append([blank] * 7)

    for r in rounds:
        dstat1 = [
            k for k in RoundStats.objects.filter(debater=d1).filter(
                round=r).all()
        ]
        dstat2 = [
            k for k in RoundStats.objects.filter(debater=d2).filter(
                round=r).all()
        ]
        blank_rs = RoundStats(debater=d1, round=r, speaks=0, ranks=0)
        while len(dstat1) + len(dstat2) < 2:
            # Something is wrong with our data, but we don't want to crash
            dstat1.append(blank_rs)
        if not dstat2 and not dstat1:
            break
        if not dstat2:
            dstat1, dstat2 = dstat1[0], dstat1[1]
        elif not dstat1:
            dstat1, dstat2 = dstat2[0], dstat2[1]
        else:
            dstat1, dstat2 = dstat1[0], dstat2[0]
        index = r.round_number - 1
        round_stats[index][3] = " - ".join([j.name for j in r.judges.all()])
        round_stats[index][4] = (float(dstat1.speaks), float(dstat1.ranks))
        round_stats[index][5] = (float(dstat2.speaks), float(dstat2.ranks))
        round_stats[index][6] = (float(dstat1.speaks + dstat2.speaks),
                                 float(dstat1.ranks + dstat2.ranks))

        if r.gov_team == team:
            round_stats[index][2] = r.opp_team
            round_stats[index][0] = "G"
            if r.victor == 1:
                round_stats[index][1] = "W"
            elif r.victor == 2:
                round_stats[index][1] = "L"
            elif r.victor == 3:
                round_stats[index][1] = "WF"
            elif r.victor == 4:
                round_stats[index][1] = "LF"
            elif r.victor == 5:
                round_stats[index][1] = "AD"
            elif r.victor == 6:
                round_stats[index][1] = "AW"
        elif r.opp_team == team:
            round_stats[index][2] = r.gov_team
            round_stats[index][0] = "O"
            if r.victor == 1:
                round_stats[index][1] = "L"
            elif r.victor == 2:
                round_stats[index][1] = "W"
            elif r.victor == 3:
                round_stats[index][1] = "LF"
            elif r.victor == 4:
                round_stats[index][1] = "WF"
            elif r.victor == 5:
                round_stats[index][1] = "AD"
            elif r.victor == 6:
                round_stats[index][1] = "AW"

    for i in range(cur_round - 1):
        if round_stats[i][6] == blank:
            round_stats[i][6] = (0, 0)
    for i in range(1, cur_round - 1):
        round_stats[i][6] = (round_stats[i][6][0] + round_stats[i - 1][6][0],
                             round_stats[i][6][1] + round_stats[i - 1][6][1])

    totals = [[0, 0], [0, 0], [0, 0]]
    for r in rounds:
        index = r.round_number - 1
        if round_stats[index][4] == blank or round_stats[index][5] == blank:
            continue
        totals[0][0] += round_stats[index][4][0]
        totals[0][1] += round_stats[index][4][1]
        totals[1][0] += round_stats[index][5][0]
        totals[1][1] += round_stats[index][5][1]
        totals[2][0] += round_stats[index][4][0] + round_stats[index][5][0]
        totals[2][1] += round_stats[index][4][1] + round_stats[index][5][1]

    #Error out if we don't have a bye
    try:
        bye_round = Bye.objects.get(bye_team=team).round_number
    except:
        bye_round = None

    return render_to_response(
        'tab_card.html', {
            'team_name': team.name,
            'team_school': team.school,
            'debater_1': d1.name,
            'debater_1_status': Debater.NOVICE_CHOICES[d1.novice_status][1],
            'debater_2': d2.name,
            'debater_2_status': Debater.NOVICE_CHOICES[d2.novice_status][1],
            'round_stats': round_stats,
            'd1st': tot_speaks_deb(d1),
            'd1rt': tot_ranks_deb(d1),
            'd2st': tot_speaks_deb(d2),
            'd2rt': tot_ranks_deb(d2),
            'ts': tot_speaks(team),
            'tr': tot_ranks(team),
            'bye_round': bye_round
        },
        context_instance=RequestContext(request))
Exemple #38
0
def all_tab_cards(request):
    all_teams = Team.objects.all()
    return render_to_response('all_tab_cards.html',
                              locals(),
                              context_instance=RequestContext(request))
 def wrapper(request, *args, **kwargs):
     out = func(request, *args, **kwargs)
     if isinstance(out, dict):
         out = render_to_response(tpl, out, RequestContext(request))
     return out
Exemple #40
0
def doc_index(request):
    if not utils.docutils_is_available:
        return missing_docutils_page(request)
    return render_to_response('admin_doc/index.html', {
        'root_path': get_root_path(),
    }, context_instance=RequestContext(request))
Exemple #41
0
def uploadify(request):
    cookie = UploadCookie.objects.get(username=request.session['username'])
    # response = render_to_response('uploadify.html', {}, context_instance=RequestContext(request))
    response = render_to_response('fileupload.html', {}, context_instance=RequestContext(request))
    return response
Exemple #42
0
            # This is a new transaction so we continue processing PDT request
            pass

        if pdt_obj is None:
            form = PayPalPDTForm(request.GET)
            if form.is_valid():
                try:
                    pdt_obj = form.save(commit=False)
                except Exception, e:
                    error = repr(e)
                    failed = True
            else:
                error = form.errors
                failed = True

            if failed:
                pdt_obj = PayPalPDT()
                pdt_obj.set_flag("Invalid form. %s" % error)

            pdt_obj.initialize(request)

            if not failed:
                pdt_obj.txn_id = txn_id
                # The PDT object gets saved during verify
                pdt_obj.verify(item_check_callable)
    else:
        pass  # we ignore any PDT requests that don't have a transaction id

    context.update({"failed": failed, "pdt_obj": pdt_obj})
    return render_to_response(template, context, RequestContext(request))
Exemple #43
0
def test(request):
    if request.method == 'POST':
        print request.POST.getlist('files')
    form = RenderForm(userid=request.session['userid'])
    response = render_to_response('render.html', {'form':form}, context_instance=RequestContext(request))
    return HttpResponse(response)
Exemple #44
0
def fbpage(request):
    return render_to_response('fbpage.html', {}, context_instance=RequestContext(request))
Exemple #45
0
def home(request):
    try:
        if request.session['userid']:
            return HttpResponseRedirect(reverse('library'))
    except KeyError:
        return render_to_response('home-new.html', {}, context_instance=RequestContext(request))
Exemple #46
0
def play_video(request, id):
    library_file = Upload.objects.get(id=id)
    response = render_to_response('player.html', {'library_file':library_file}, context_instance=RequestContext(request))
    return HttpResponse(response)
Exemple #47
0
def user_remove(request):
    return render_to_response("backend/index.html", context_instance=RequestContext(request))
Exemple #48
0
def render(request):
    if not request.method == 'POST':
        # get_status_of_render(request)
        default_theme = json.dumps({'call_name':""})
        renderform = RenderForm(userid=request.session['userid'])
        createmovie = CreateMovie.objects.filter(user_id=request.session['userid'], session_id=request.COOKIES['sessionid'])
        username = request.session['username']
        themes = get_theme(request)
        occasions= rumblefish_occassions()
        default_occasion_id = occasions[0][1]
        # defaultplaylist = occasionplaylist(default_occasion_id)
        defaultplaylist_file = open(os.path.join(settings.PROJECT_ROOT, 'playlist.json'), 'r')
        defaultplaylist = json.loads(defaultplaylist_file.read())
        # defaultplaylist = None
        return render_to_response('create-new.html', {'createmovie':createmovie, 'username':username, 'form':renderform, 'themes':themes, 'occasions':occasions, 'defaultplaylist':defaultplaylist, 'default_theme':default_theme}, context_instance=RequestContext(request))

    try:
        uploadcookie = UploadCookie.objects.get(username=request.session['username'])
    except ObjectDoesNotExist:
        return HttpResponseRedirect(reverse('logout'))
    filekey = request.POST.getlist('files')
    uuid_list = []
    for key in filekey:
        if key:
            uuid_list.append(CreateMovie.objects.get(id=int(key)).uuid)
    uuids = ":".join(uuid_list)
    # print uuids
    filter = json.loads(request.POST.get('filter'))
    # print uuid
    renderform = RenderForm(userid=request.session['userid'])
    url = "%srender/" % (settings.SERVER)
    # print request.POST.get('audio')
    cookie = pickle.loads(str(uploadcookie.cookie))
    payload = {}
    payload['uuids'] = uuids
    payload['p__filter'] = filter['call_name']
    payload['p__target_duration'] = request.POST.get('target_duration') if request.POST.get('target_duration') else 30
    payload['fit_duration'] = request.POST.get('fit_duration') if request.POST.get('fit_duration') else 1
    payload['p__quality'] = request.POST.get('quality') if request.POST.get('quality') else 'balanced'
    payload['film_name'] = request.POST.get('title')
    if request.POST.get('audio'):
        payload['soundtrack_url'] = request.POST.get('audio')
    elif request.POST.get('rumblefish_media_id'):
        payload['rumblefish_media_id'] = request.POST.get('rumblefish_media_id')
        payload['p__rumblefish_version'] = 2
    payload['return_style'] = 'json'
    r = requests.post(url,cookies=cookie, data=payload)
    result_dict = json.loads(r.text)
    minimovie_uuid = result_dict['highlight_uuid']
    # movie_detail = get_movie_detail(cookie, minimovie_uuid)
    # print movie_detail
    renderedvideo = RenderedVideo()
    renderedvideo.username = request.session['username']
    renderedvideo.user_id = request.session['userid']
    renderedvideo.uuid = minimovie_uuid
    renderedvideo.url = "http://videos.highlightcam.s3.amazonaws.com/video_" + minimovie_uuid + ".mp4"
    renderedvideo.save()
    print "http://videos.highlightcam.s3.amazonaws.com/video_" + minimovie_uuid + ".mp4"
    request.session['uuid']=minimovie_uuid
    # if renderform.is_valid():
    #   print renderform.cleaned_data['files']
    msg = "Your movie is being generated... Please wait for the email confirmation... \
            Find your completed movie at http://videos.highlightcam.s3.amazonaws.com/video_" + minimovie_uuid + ".mp4"
    CreateMovie.objects.filter(user_id=request.session['userid'], session_id=request.COOKIES['sessionid']).delete()
    # return render_to_response('create-new.html', {'form':renderform, 'message':msg}, context_instance=RequestContext(request))
    return HttpResponseRedirect(reverse('library'))
Exemple #49
0
def index(req, *args, **kwargs):
    return render_to_response('sdksy/index.html')
Exemple #50
0
def render_response(req, *args, **kwargs):
    print("render to response")
    print("render to response")
    kwargs['context_instance'] = RequestContext(req)
    return render_to_response(*args, **kwargs)
Exemple #51
0
def render_javascript(request):
    """ NOTE: This is a really bad way of serving a static file!
        It is only used in this exercise to serve this single JS file easily. """
    return render_to_response("countrydata/ajax_ui.js", mimetype="text/javascript")
Exemple #52
0
def reportQualitativa2( qualitativa , alumnes = [], grups = [], request = None):

    import locale
    locale.setlocale(locale.LC_TIME, 'ca_ES.utf8')
    
    reports = []
    
    for nivell in Nivell.objects.all():
        for curs in nivell.curs_set.all():
            for grup in curs.grup_set.all():
                q_teRespostes = Q(respostaavaluacioqualitativa__isnull = False) 
                q_alumneTriat =  Q(pk__in = [a.pk for a in alumnes ])
                q_grupTriat = Q( grup__in = grups )
                q_filtre_alumn = q_teRespostes & ( q_alumneTriat | q_grupTriat )
                               
                for alumne in grup.alumne_set.filter( q_filtre_alumn ).distinct(): 
                    report = []
                    taula = tools.classebuida()
                    taula.titol = tools.classebuida()
                    taula.titol.contingut = ""
                    taula.classe = 'titol'
                    taula.capceleres = []
                    taula.printIfEmpty = True
                    
                    capcelera = tools.classebuida()
                    capcelera.amplade = 900
                    capcelera.contingut = u'''Butlletí de qualificacions de l'avaluació qualitativa.'''.upper()
                    taula.capceleres.append(capcelera)
                    taula.fileres = []

                    filera = []
                    camp = tools.classebuida()
                    camp.contingut = u'Benvolguts tutors/res'
                    filera.append(camp)      
                    taula.fileres.append(filera)              
                    
                    filera = []
                    camp = tools.classebuida()
                    camp.contingut = u'''L’equip de professors de l’alumne/a {0} que cursa {1} us fem arribar un full de seguiment 
                    de començament de curs. En aquest butlletí us notifiquem algunes observacions que ens semblen significatives en 
                    aquest inici del curs. Esperem que us sigui d’utilitat per prendre les decisions correctes pel normal 
                    desenvolupament del curs.'''.format( alumne, alumne.grup )
                    filera.append(camp)      
                    taula.fileres.append(filera)              
                    
                    report.append(taula)
        
                    taula = tools.classebuida()
                    taula.titol = tools.classebuida()
                    taula.titol.contingut = ""
                    taula.capceleres = []
                    taula.classe = 'pijama'
                    
                    capcelera = tools.classebuida()
                    capcelera.amplade = 300
                    capcelera.contingut = u'''Matèria'''
                    taula.capceleres.append(capcelera)

                    capcelera = tools.classebuida()
                    capcelera.amplade = 700
                    capcelera.contingut = u'''Comentaris'''
                    taula.capceleres.append(capcelera)   
                    
                    taula.fileres = []                 
                    
                    for assignatura in Assignatura.objects.filter( 
                                        respostaavaluacioqualitativa__qualitativa = qualitativa,
                                        respostaavaluacioqualitativa__alumne = alumne  
                                        ).distinct():
                        
                        esPrimeraResposta = True
                        for resposta in RespostaAvaluacioQualitativa.objects.filter(
                                         alumne = alumne,
                                         assignatura = assignatura ):
                            
                            filera = []
                            
                            camp = tools.classebuida()
                            camp.contingut = u'{0}'.format( assignatura.nom_assignatura if esPrimeraResposta else '' )
                            filera.append(camp)

                            camp = tools.classebuida()
                            camp.contingut = u'{0}'.format( resposta.item  )
                            filera.append(camp)   
                                                                                 
                            taula.fileres.append( filera )
                            
                            esPrimeraResposta = False
                        #endfor resposta
                        
                    #endfor assignatura
                    report.append(taula) #------------------------------------------------------------------------------
                    
                    taula = tools.classebuida()
                    taula.titol = tools.classebuida()
                    taula.titol.contingut = ""
                    taula.classe = 'pijama'
                    taula.capceleres = []
                    
                    capcelera = tools.classebuida()
                    capcelera.amplade = 700
                    capcelera.contingut = u'''Comentari del tutor/a'''
                    taula.capceleres.append(capcelera)
                    taula.fileres = []

                    filera = []
                    camp = tools.classebuida()
                    camp.contingut = u''
                    filera.append(camp)      
                    taula.fileres.append(filera)  

                    filera = []
                    camp = tools.classebuida()
                    camp.contingut = u'_____________________________________________________________________________________'
                    filera.append(camp)      
                    taula.fileres.append(filera)  
                    taula.fileres.append(filera)  
                    taula.fileres.append(filera)  
                    report.append(taula) #------------------------------------------------------------------------------

                    taula = tools.classebuida()
                    taula.titol = tools.classebuida()
                    taula.titol.contingut = ""
                    taula.classe = 'pijama'
                    taula.capceleres = []
                    taula.fileres = []
                                        
                    filera = []
                    camp = tools.classebuida()
                    camp.contingut = u'Atentament,'
                    filera.append(camp)      
                    taula.fileres.append(filera)  

                    filera = []
                    camp = tools.classebuida()
                    camp.contingut = u'{0}'.format( u','.join( [u'Sr(a) ' + unicode(t.professor) for t in alumne.tutorsDeLAlumne() ] ) )  
                    filera.append(camp)      
                    taula.fileres.append(filera)

                    filera = []
                    camp = tools.classebuida()
                    camp.contingut = u'Figueres, a {0}'.format( qualitativa.data_tancar_avaluacio.strftime( '%d de %B de %Y' ) )  
                    filera.append(camp)      
                    taula.fileres.append(filera)

                    filera = []
                    camp = tools.classebuida()
                    camp.contingut = u'''................................................................................
                    .......................................................................................'''
                    filera.append(camp)      
                    taula.fileres.append(filera)
                    report.append(taula) #------------------------------------------------------------------------------
                    
                    taula = tools.classebuida()
                    taula.titol = tools.classebuida()
                    taula.titol.contingut = ""
                    taula.classe = 'pijama'
                    taula.capceleres = []
                    taula.fileres = []
                                        
                    filera = []
                    camp = tools.classebuida()
                    camp.contingut = u'''El/la Sr/a ______________________________________ com a pare / mare / tutor/a de l'alumne
                    {0} de {1}, he rebut el butlletí de qualificacions de l'avaluació qualitativa.'''.format( alumne, alumne.grup )
                    filera.append(camp)      
                    taula.fileres.append(filera)  
                    
                    filera = []
                    camp = tools.classebuida()
                    camp.contingut = u'Signat:'
                    filera.append(camp)      
                    taula.fileres.append(filera)  

                    filera = []
                    camp = tools.classebuida()
                    camp.contingut = u'DNI núm:'
                    filera.append(camp)      
                    taula.fileres.append(filera)  

                    filera = []
                    camp = tools.classebuida()
                    camp.contingut = u''
                    filera.append(camp)      
                    taula.fileres.append(filera)  
                    taula.fileres.append(filera)  

                    filera = []
                    camp = tools.classebuida()
                    camp.contingut = u'_________________, ____ de _______________ de {0}'.format( qualitativa.data_tancar_avaluacio.year )
                    filera.append(camp)      
                    taula.fileres.append(filera)  
                    report.append(taula) #------------------------------------------------------------------------------

                    
                    if report: reports.append( report )      
                    
                #endfor alumne   
                            
                       
                              
    formatPDF = True
    if formatPDF:
        return write_pdf('pdfReport.html',{
            'pagesize' : 'A4',
            'reports' : reports,
            })
    else:
        return render_to_response(
            'report.html',
                {'report': report,
                 'head': u'Avaluacions Qualitatives' ,
                },
                context_instance=RequestContext(request))      
Exemple #53
0
def salvar(request, hash):
    db_slug = 'default'
    try:
        usuario_id = request.user.id
        dict_hash = get_hash_url(hash)
        s1070_alteracao_infosusp_id = int(dict_hash['id'])
        if 'tab' not in dict_hash.keys():
            dict_hash['tab'] = ''
        for_print = int(dict_hash['print'])
    except:
        usuario_id = False
        return redirect('login')
    usuario = get_object_or_404(Usuarios.objects.using(db_slug),
                                excluido=False,
                                id=usuario_id)
    pagina = ConfigPaginas.objects.using(db_slug).get(
        excluido=False, endereco='s1070_alteracao_infosusp')
    permissao = ConfigPermissoes.objects.using(db_slug).get(
        excluido=False,
        config_paginas=pagina,
        config_perfis=usuario.config_perfis)
    if s1070_alteracao_infosusp_id:
        s1070_alteracao_infosusp = get_object_or_404(
            s1070alteracaoinfoSusp.objects.using(db_slug),
            excluido=False,
            id=s1070_alteracao_infosusp_id)
    dict_permissoes = json_to_dict(usuario.config_perfis.permissoes)
    paginas_permitidas_lista = usuario.config_perfis.paginas_permitidas
    modulos_permitidos_lista = usuario.config_perfis.modulos_permitidos
    dados_evento = {}
    dados_evento['status'] = 0
    if s1070_alteracao_infosusp_id:
        dados_evento = s1070_alteracao_infosusp.evento()
        if dados_evento['status'] != 0:
            dict_permissoes['s1070_alteracao_infosusp_apagar'] = 0
            dict_permissoes['s1070_alteracao_infosusp_editar'] = 0

    if permissao.permite_visualizar:
        mensagem = None
        if s1070_alteracao_infosusp_id:
            s1070_alteracao_infosusp_form = form_s1070_alteracao_infosusp(
                request.POST or None,
                instance=s1070_alteracao_infosusp,
                slug=db_slug)
        else:
            s1070_alteracao_infosusp_form = form_s1070_alteracao_infosusp(
                request.POST or None, slug=db_slug, initial={})
        if request.method == 'POST':
            if s1070_alteracao_infosusp_form.is_valid():
                dados = s1070_alteracao_infosusp_form.cleaned_data
                import json
                from django.forms.models import model_to_dict
                if s1070_alteracao_infosusp_id:
                    if dados_evento['status'] == 0:
                        dados['modificado_por_id'] = usuario_id
                        dados['modificado_em'] = datetime.datetime.now()
                        #s1070_alteracao_infosusp_campos_multiple_passo1
                        s1070alteracaoinfoSusp.objects.using(db_slug).filter(
                            id=s1070_alteracao_infosusp_id).update(**dados)
                        obj = s1070alteracaoinfoSusp.objects.using(
                            db_slug).get(id=s1070_alteracao_infosusp_id)
                        #s1070_alteracao_infosusp_editar_custom
                        #s1070_alteracao_infosusp_campos_multiple_passo2
                        messages.success(request, 'Alterado com sucesso!')
                        gravar_auditoria(
                            json.dumps(model_to_dict(s1070_alteracao_infosusp),
                                       indent=4,
                                       sort_keys=True,
                                       default=str),
                            json.dumps(model_to_dict(obj),
                                       indent=4,
                                       sort_keys=True,
                                       default=str),
                            's1070_alteracao_infosusp',
                            s1070_alteracao_infosusp_id, usuario_id, 2)
                    else:
                        messages.error(
                            request,
                            'Somente é possível alterar eventos com status "Cadastrado"!'
                        )
                else:

                    dados['criado_por_id'] = usuario_id
                    dados['criado_em'] = datetime.datetime.now()
                    dados['excluido'] = False
                    #s1070_alteracao_infosusp_cadastrar_campos_multiple_passo1
                    obj = s1070alteracaoinfoSusp(**dados)
                    obj.save(using=db_slug)
                    #s1070_alteracao_infosusp_cadastrar_custom
                    #s1070_alteracao_infosusp_cadastrar_campos_multiple_passo2
                    messages.success(request, 'Cadastrado com sucesso!')
                    gravar_auditoria(
                        '{}',
                        json.dumps(model_to_dict(obj),
                                   indent=4,
                                   sort_keys=True,
                                   default=str), 's1070_alteracao_infosusp',
                        obj.id, usuario_id, 1)
                    if request.session['retorno_pagina'] not in (
                            's1070_alteracao_infosusp_apagar',
                            's1070_alteracao_infosusp_salvar',
                            's1070_alteracao_infosusp'):
                        return redirect(request.session['retorno_pagina'],
                                        hash=request.session['retorno_hash'])
                    if s1070_alteracao_infosusp_id != obj.id:
                        url_hash = base64.urlsafe_b64encode(
                            '{"print": "0", "id": "%s"}' % (obj.id))
                        return redirect('s1070_alteracao_infosusp_salvar',
                                        hash=url_hash)
            else:
                messages.error(request, 'Erro ao salvar!')
        s1070_alteracao_infosusp_form = disabled_form_fields(
            s1070_alteracao_infosusp_form, permissao.permite_editar)
        if s1070_alteracao_infosusp_id:
            if dados_evento['status'] != 0:
                s1070_alteracao_infosusp_form = disabled_form_fields(
                    s1070_alteracao_infosusp_form, 0)
        #s1070_alteracao_infosusp_campos_multiple_passo3

        for field in s1070_alteracao_infosusp_form.fields.keys():
            s1070_alteracao_infosusp_form.fields[field].widget.attrs[
                'ng-model'] = 's1070_alteracao_infosusp_' + field
        if int(dict_hash['print']):
            s1070_alteracao_infosusp_form = disabled_form_for_print(
                s1070_alteracao_infosusp_form)
        #[VARIAVEIS_SECUNDARIAS_VAZIAS]
        if s1070_alteracao_infosusp_id:
            s1070_alteracao_infosusp = get_object_or_404(
                s1070alteracaoinfoSusp.objects.using(db_slug),
                excluido=False,
                id=s1070_alteracao_infosusp_id)
            pass
        else:
            s1070_alteracao_infosusp = None
        #s1070_alteracao_infosusp_salvar_custom_variaveis#
        tabelas_secundarias = []
        #[FUNCOES_ESPECIAIS_SALVAR]
        if dict_hash['tab'] or 's1070_alteracao_infosusp' in request.session[
                'retorno_pagina']:
            request.session["retorno_hash"] = hash
            request.session[
                "retorno_pagina"] = 's1070_alteracao_infosusp_salvar'
        controle_alteracoes = Auditoria.objects.using(db_slug).filter(
            identidade=s1070_alteracao_infosusp_id,
            tabela='s1070_alteracao_infosusp').all()
        context = {
            'ocorrencias': dados_evento['ocorrencias'],
            'validacao_precedencia': dados_evento['validacao_precedencia'],
            'validacoes': dados_evento['validacoes'],
            'status': dados_evento['status'],
            'controle_alteracoes': controle_alteracoes,
            's1070_alteracao_infosusp': s1070_alteracao_infosusp,
            's1070_alteracao_infosusp_form': s1070_alteracao_infosusp_form,
            'mensagem': mensagem,
            's1070_alteracao_infosusp_id': int(s1070_alteracao_infosusp_id),
            'usuario': usuario,
            'hash': hash,
            #[VARIAVEIS_SECUNDARIAS]
            'modulos_permitidos_lista': modulos_permitidos_lista,
            'paginas_permitidas_lista': paginas_permitidas_lista,
            'permissao': permissao,
            'data': datetime.datetime.now(),
            'pagina': pagina,
            'dict_permissoes': dict_permissoes,
            'for_print': int(dict_hash['print']),
            'tabelas_secundarias': tabelas_secundarias,
            'tab': dict_hash['tab'],
            #s1070_alteracao_infosusp_salvar_custom_variaveis_context#
        }
        if for_print in (0, 1):
            return render(request, 's1070_alteracao_infosusp_salvar.html',
                          context)
        elif for_print == 2:
            from wkhtmltopdf.views import PDFTemplateResponse
            response = PDFTemplateResponse(
                request=request,
                template='s1070_alteracao_infosusp_salvar.html',
                filename="s1070_alteracao_infosusp.pdf",
                context=context,
                show_content_in_browser=True,
                cmd_options={
                    'margin-top': 10,
                    'margin-bottom': 10,
                    'margin-right': 10,
                    'margin-left': 10,
                    'zoom': 1,
                    'dpi': 72,
                    'orientation': 'Landscape',
                    "viewport-size": "1366 x 513",
                    'javascript-delay': 1000,
                    'footer-center': '[page]/[topage]',
                    "no-stop-slow-scripts": True
                },
            )
            return response
        elif for_print == 3:
            from django.shortcuts import render_to_response
            response = render_to_response(
                's1070_alteracao_infosusp_salvar.html', context)
            filename = "s1070_alteracao_infosusp.xls"
            response[
                'Content-Disposition'] = 'attachment; filename=' + filename
            response[
                'Content-Type'] = 'application/vnd.ms-excel; charset=UTF-8'
            return response

    else:
        context = {
            'usuario': usuario,
            'modulos_permitidos_lista': modulos_permitidos_lista,
            'paginas_permitidas_lista': paginas_permitidas_lista,
            'permissao': permissao,
            'data': datetime.datetime.now(),
            'pagina': pagina,
            'dict_permissoes': dict_permissoes,
        }
        return render(request, 'permissao_negada.html', context)
Exemple #54
0
def index(request):
    return render_to_response('base.html')
Exemple #55
0
def salvar(request, pk=None, tab='master', output=None):

    from emensageriapro.esocial.models import STATUS_EVENTO_CADASTRADO

    evento_dados = {}
    evento_dados['status'] = STATUS_EVENTO_CADASTRADO

    if pk:

        s1000_alteracao_infoorginternacional = get_object_or_404(s1000alteracaoinfoOrgInternacional, id=pk)
        evento_dados = s1000_alteracao_infoorginternacional.evento()

    if request.user.has_perm('s1000.can_see_s1000alteracaoinfoOrgInternacional'):

        if pk:

            s1000_alteracao_infoorginternacional_form = form_s1000_alteracao_infoorginternacional(
                request.POST or None,
                instance=s1000_alteracao_infoorginternacional)
                     
        else:

            s1000_alteracao_infoorginternacional_form = form_s1000_alteracao_infoorginternacional(request.POST or None)
                     
        if request.method == 'POST':

            if s1000_alteracao_infoorginternacional_form.is_valid():

                obj = s1000_alteracao_infoorginternacional_form.save(request=request)
                messages.success(request, u'Salvo com sucesso!')
                 
                if 'return_page' in request.session and request.session['return_page'] and 's1000-alteracao-infoorginternacional' not in request.session['return_page']:

                    return HttpResponseRedirect(request.session['return_page'])

                if pk != obj.id:

                    return redirect(
                        's1000_alteracao_infoorginternacional_salvar',
                        pk=obj.id)

            else:

                messages.error(request, u'Erro ao salvar!')

        s1000_alteracao_infoorginternacional_form = disabled_form_fields(
            s1000_alteracao_infoorginternacional_form,
            request.user.has_perm('s1000.change_s1000alteracaoinfoOrgInternacional'))

        if pk:

            if evento_dados['status'] != STATUS_EVENTO_CADASTRADO:

                s1000_alteracao_infoorginternacional_form = disabled_form_fields(s1000_alteracao_infoorginternacional_form, 0)

        if output:

            s1000_alteracao_infoorginternacional_form = disabled_form_for_print(s1000_alteracao_infoorginternacional_form)



        if pk:

            s1000_alteracao_infoorginternacional = get_object_or_404(s1000alteracaoinfoOrgInternacional, id=pk)


        else:

            s1000_alteracao_infoorginternacional = None

        tabelas_secundarias = []

        controle_alteracoes = Auditoria.objects.filter(identidade=pk, tabela='s1000_alteracao_infoorginternacional').all()

        if not request.POST:
            request.session['return_page'] = request.META.get('HTTP_REFERER')

        context = {
            'usuario': Usuarios.objects.get(user_id=request.user.id),
            'pk': pk,
            'output': output,
            'evento_dados': evento_dados,
            'controle_alteracoes': controle_alteracoes,
            's1000_alteracao_infoorginternacional': s1000_alteracao_infoorginternacional,
            's1000_alteracao_infoorginternacional_form': s1000_alteracao_infoorginternacional_form,
            'modulos': ['s1000', ],
            'paginas': ['s1000_alteracao_infoorginternacional', ],
            'data': datetime.datetime.now(),
            'tabelas_secundarias': tabelas_secundarias,
            'tab': tab,
            #s1000_alteracao_infoorginternacional_salvar_custom_variaveis_context#
        }

        if output == 'pdf':

            from wkhtmltopdf.views import PDFTemplateResponse

            response = PDFTemplateResponse(
                request=request,
                template='s1000_alteracao_infoorginternacional_salvar.html',
                filename="s1000_alteracao_infoorginternacional.pdf",
                context=context,
                show_content_in_browser=True,
                cmd_options={'margin-top': 10,
                             'margin-bottom': 10,
                             'margin-right': 10,
                             'margin-left': 10,
                             'zoom': 1,
                             'dpi': 72,
                             'orientation': 'Landscape',
                             "viewport-size": "1366 x 513",
                             'javascript-delay': 1000,
                             'footer-center': '[page]/[topage]',
                             "no-stop-slow-scripts": True}, )

            return response

        elif output == 'xls':

            from django.shortcuts import render_to_response

            response = render_to_response('s1000_alteracao_infoorginternacional_salvar.html', context)
            filename = "s1000_alteracao_infoorginternacional.xls"
            response['Content-Disposition'] = 'attachment; filename=' + filename
            response['Content-Type'] = 'application/vnd.ms-excel; charset=UTF-8'

            return response

        else:

            return render(request, 's1000_alteracao_infoorginternacional_salvar.html', context)

    else:

        context = {
            'usuario': Usuarios.objects.get(user_id=request.user.id),
            'pk': pk,
            'output': output,
            'tab': tab,
            'modulos': ['s1000', ],
            'paginas': ['s1000_alteracao_infoorginternacional', ],
            'data': datetime.datetime.now(),
        }

        return render(request,
                      'permissao_negada.html',
                      context)
def combat(request, type, template_name='combat/combat.html'):
    _is_login(request)

    hero = Hero.objects.get(id=request.session['hero_id'])
    in_combat = combatmanipulation.in_combat(hero)

    if in_combat:
        combatmanipulation.is_combat(hero)

    if type == '0':

        is_cancel = is_fight = is_refuse = False
        if in_combat:
            is_cancel = combatmanipulation.is_cancel(hero, type)
            is_fight = combatmanipulation.is_fight(hero)
            is_refuse = combatmanipulation.is_refuse(hero)

        if request.method == 'POST' and not in_combat:
            form = DuelForm(request.POST)
            if form.is_valid():
                combat = Combat(time_out=form.cleaned_data['time_out'],
                                injury=form.cleaned_data['injury'],
                                with_things=form.cleaned_data['with_things'],
                                location=combatmanipulation.get_location(
                                    hero.location),
                                one_team_count=1,
                                two_team_count=1,
                                one_team_lvl_min=0,
                                one_team_lvl_max=99,
                                two_team_lvl_min=0,
                                two_team_lvl_max=99)
                combat.save()
                combat.combathero_set.create(hero=hero)
                #
                request.user.message_set.create(message='Your demand accept')
                return HttpResponseRedirect(reverse('combat', args=[type]))
        else:
            form = DuelForm()

        combats = Combat.objects.filter(
            type=0,
            is_active=0,
            location=combatmanipulation.get_location(hero.location))

        variables = RequestContext(
            request, {
                'type': int(type),
                'hero': hero,
                'form': form,
                'combats': combats,
                'in_combat': in_combat,
                'is_cancel': is_cancel,
                'is_fight': is_fight,
                'is_refuse': is_refuse,
            })

    elif type == '1':

        is_cancel = False
        if in_combat:
            is_cancel = combatmanipulation.is_cancel(hero, type)

        if request.method == 'POST' and not in_combat:
            form = GroupForm(request.POST)
            if form.is_valid():
                combat = Combat(
                    type=1,
                    time_out=form.cleaned_data['time_out'],
                    injury=form.cleaned_data['injury'],
                    with_things=form.cleaned_data['with_things'],
                    time_wait=form.cleaned_data['time_wait'],
                    location=combatmanipulation.get_location(hero.location),
                    one_team_count=form.cleaned_data['one_team_count'],
                    two_team_count=form.cleaned_data['two_team_count'],
                    one_team_lvl_min=form.cleaned_data['one_team_lvl_min'],
                    one_team_lvl_max=form.cleaned_data['one_team_lvl_max'],
                    two_team_lvl_min=form.cleaned_data['two_team_lvl_min'],
                    two_team_lvl_max=form.cleaned_data['two_team_lvl_max'])

                combat.save()
                combat.combathero_set.create(hero=hero)
                #
                request.user.message_set.create(message='Your demand accept')
                return HttpResponseRedirect(reverse('combat', args=[type]))
        else:
            form = GroupForm()

        combats = Combat.objects.filter(
            type=1, location=combatmanipulation.get_location(hero.location))

        variables = RequestContext(
            request, {
                'type': int(type),
                'hero': hero,
                'form': form,
                'combats': combats,
                'in_combat': in_combat,
                'is_cancel': is_cancel,
            })
    elif type == '2':

        is_cancel = False
        if in_combat:
            is_cancel = combatmanipulation.is_cancel(hero, type)

        if request.method == 'POST' and not in_combat:
            form = ChaoticForm(request.POST)
            if form.is_valid():
                combat = Combat(type=2,
                                time_out=form.cleaned_data['time_out'],
                                injury=form.cleaned_data['injury'],
                                with_things=form.cleaned_data['with_things'],
                                time_wait=form.cleaned_data['time_wait'],
                                location=combatmanipulation.get_location(
                                    hero.location),
                                one_team_count=form.cleaned_data['count'],
                                one_team_lvl_min=form.cleaned_data['lvl_min'],
                                one_team_lvl_max=form.cleaned_data['lvl_max'])

                combat.save()
                combat.combathero_set.create(hero=hero)
                #
                request.user.message_set.create(message='Your demand accept')
                return HttpResponseRedirect(reverse('combat', args=[type]))
        else:
            form = ChaoticForm()

        combats = Combat.objects.filter(
            type=2, location=combatmanipulation.get_location(hero.location))

        variables = RequestContext(
            request, {
                'type': int(type),
                'hero': hero,
                'form': form,
                'combats': combats,
                'in_combat': in_combat,
                'is_cancel': is_cancel,
            })
    elif type == '3':
        combats = Combat.objects.filter(
            type=3, location=combatmanipulation.get_location(hero.location))

        variables = RequestContext(
            request, {
                'type': int(type),
                'hero': hero,
                'combats': combats,
                'in_combat': in_combat
            })

    elif type == '4':
        combats = Combat.objects.filter(
            is_active=1,
            location=combatmanipulation.get_location(hero.location))

        variables = RequestContext(request, {
            'type': int(type),
            'hero': hero,
            'combats': combats
        })
    elif type == '5':

        combats = Combat.objects.filter(
            is_active=3,
            location=combatmanipulation.get_location(hero.location))

        variables = RequestContext(request, {
            'type': int(type),
            'hero': hero,
            'combats': combats
        })

    return render_to_response(template_name, variables)
Exemple #57
0
def tomorrow(req, *args, **kwargs):
    return render_to_response('sdksy/tomorrow.html')
Exemple #58
0
def listar(request, hash):
    for_print = 0
    db_slug = 'default'
    try:
        usuario_id = request.user.id
        dict_hash = get_hash_url(hash)
        #retorno_pagina = dict_hash['retorno_pagina']
        #retorno_hash = dict_hash['retorno_hash']
        #s1070_alteracao_infosusp_id = int(dict_hash['id'])
        for_print = int(dict_hash['print'])
    except:
        usuario_id = False
        return redirect('login')
    usuario = get_object_or_404(Usuarios.objects.using(db_slug),
                                excluido=False,
                                id=usuario_id)
    pagina = ConfigPaginas.objects.using(db_slug).get(
        excluido=False, endereco='s1070_alteracao_infosusp')
    permissao = ConfigPermissoes.objects.using(db_slug).get(
        excluido=False,
        config_paginas=pagina,
        config_perfis=usuario.config_perfis)
    dict_permissoes = json_to_dict(usuario.config_perfis.permissoes)
    paginas_permitidas_lista = usuario.config_perfis.paginas_permitidas
    modulos_permitidos_lista = usuario.config_perfis.modulos_permitidos

    if permissao.permite_listar:
        filtrar = False
        dict_fields = {}
        show_fields = {
            'show_codsusp': 1,
            'show_dtdecisao': 1,
            'show_inddeposito': 1,
            'show_indsusp': 1,
            'show_s1070_alteracao': 1,
        }
        post = False
        if request.method == 'POST':
            post = True
            dict_fields = {
                'codsusp': 'codsusp',
                'dtdecisao__range': 'dtdecisao__range',
                'inddeposito__icontains': 'inddeposito__icontains',
                'indsusp__icontains': 'indsusp__icontains',
                's1070_alteracao': 's1070_alteracao',
            }
            for a in dict_fields:
                dict_fields[a] = request.POST.get(a or None)
            for a in show_fields:
                show_fields[a] = request.POST.get(a or None)
            if request.method == 'POST':
                dict_fields = {
                    'codsusp': 'codsusp',
                    'dtdecisao__range': 'dtdecisao__range',
                    'inddeposito__icontains': 'inddeposito__icontains',
                    'indsusp__icontains': 'indsusp__icontains',
                    's1070_alteracao': 's1070_alteracao',
                }
                for a in dict_fields:
                    dict_fields[a] = request.POST.get(dict_fields[a] or None)
        dict_qs = clear_dict_fields(dict_fields)
        s1070_alteracao_infosusp_lista = s1070alteracaoinfoSusp.objects.using(
            db_slug).filter(**dict_qs).filter(excluido=False).exclude(
                id=0).all()
        if not post and len(s1070_alteracao_infosusp_lista) > 100:
            filtrar = True
            s1070_alteracao_infosusp_lista = None
            messages.warning(
                request,
                'Listagem com mais de 100 resultados! Filtre os resultados um melhor desempenho!'
            )

        #s1070_alteracao_infosusp_listar_custom
        request.session["retorno_hash"] = hash
        request.session["retorno_pagina"] = 's1070_alteracao_infosusp'
        context = {
            's1070_alteracao_infosusp_lista': s1070_alteracao_infosusp_lista,
            'usuario': usuario,
            'modulos_permitidos_lista': modulos_permitidos_lista,
            'paginas_permitidas_lista': paginas_permitidas_lista,
            'permissao': permissao,
            'dict_fields': dict_fields,
            'data': datetime.datetime.now(),
            'pagina': pagina,
            'dict_permissoes': dict_permissoes,
            'show_fields': show_fields,
            'for_print': for_print,
            'hash': hash,
            'filtrar': filtrar,
        }
        if for_print in (0, 1):
            return render(request, 's1070_alteracao_infosusp_listar.html',
                          context)
        elif for_print == 2:
            #return render_to_pdf('tables/s1000_evtinfoempregador_pdf_xls.html', context)
            from wkhtmltopdf.views import PDFTemplateResponse
            response = PDFTemplateResponse(
                request=request,
                template='s1070_alteracao_infosusp_listar.html',
                filename="s1070_alteracao_infosusp.pdf",
                context=context,
                show_content_in_browser=True,
                cmd_options={
                    'margin-top': 10,
                    'margin-bottom': 10,
                    'margin-right': 10,
                    'margin-left': 10,
                    'zoom': 1,
                    'dpi': 72,
                    'orientation': 'Landscape',
                    "viewport-size": "1366 x 513",
                    'javascript-delay': 1000,
                    'footer-center': '[page]/[topage]',
                    "no-stop-slow-scripts": True
                },
            )
            return response
        elif for_print == 3:
            from django.shortcuts import render_to_response
            response = render_to_response(
                's1070_alteracao_infosusp_listar.html', context)
            filename = "s1070_alteracao_infosusp.xls"
            response[
                'Content-Disposition'] = 'attachment; filename=' + filename
            response[
                'Content-Type'] = 'application/vnd.ms-excel; charset=UTF-8'
            return response
        elif for_print == 4:
            from django.shortcuts import render_to_response
            response = render_to_response(
                'tables/s1070_alteracao_infosusp_csv.html', context)
            filename = "s1070_alteracao_infosusp.csv"
            response[
                'Content-Disposition'] = 'attachment; filename=' + filename
            response['Content-Type'] = 'text/csv; charset=UTF-8'
            return response
    else:
        context = {
            'usuario': usuario,
            'modulos_permitidos_lista': modulos_permitidos_lista,
            'paginas_permitidas_lista': paginas_permitidas_lista,
            'permissao': permissao,
            'data': datetime.datetime.now(),
            'pagina': pagina,
            'dict_permissoes': dict_permissoes,
        }
        return render(request, 'permissao_negada.html', context)
Exemple #59
0
def machine_detail(request, machine_id):
    # check the user is in a BU that's allowed to see this Machine
    machine = get_object_or_404(Machine, pk=machine_id)
    machine_group = machine.machine_group
    business_unit = machine_group.business_unit
    user = request.user
    user_level = user.userprofile.level
    if business_unit not in user.businessunit_set.all():
        if user_level != 'GA':
            return redirect(index)

    report = machine.get_report()
    if machine.facts.count() != 0:
        facts = machine.facts.all()
        if settings.EXCLUDED_FACTS:
            for excluded in settings.EXCLUDED_FACTS:
                facts = facts.exclude(fact_name=excluded)
    else:
        facts = None

    if machine.conditions.count() != 0:
        conditions = machine.conditions.all()
        # get the IP address(es) from the condition
        try:
            ip_address = conditions.get(machine=machine, condition_name__exact='ipv4_address')
            ip_address = ip_address.condition_data
        except:
            ip_address = None
        if settings.EXCLUDED_CONDITIONS:
            for excluded in settings.EXCLUDED_CONDITIONS:
                conditions = conditions.exclude(condition_name=excluded)
    else:
        conditions = None
        ip_address = None

    install_results = {}
    for result in report.get('InstallResults', []):
        nameAndVers = result['name'] + '-' + result['version']
        if result['status'] == 0:
            install_results[nameAndVers] = "installed"
        else:
            install_results[nameAndVers] = 'error'

    if install_results:
        for item in report.get('ItemsToInstall', []):
            name = item.get('display_name', item['name'])
            nameAndVers = ('%s-%s'
                % (name, item['version_to_install']))
            item['install_result'] = install_results.get(
                nameAndVers, 'pending')

        for item in report.get('ManagedInstalls', []):
            if 'version_to_install' in item:
                name = item.get('display_name', item['name'])
                nameAndVers = ('%s-%s'
                    % (name, item['version_to_install']))
                if install_results.get(nameAndVers) == 'installed':
                    item['installed'] = True

    # handle items that were removed during the most recent run
    # this is crappy. We should fix it in Munki.
    removal_results = {}
    for result in report.get('RemovalResults', []):
        m = re.search('^Removal of (.+): (.+)$', result)
        if m:
            try:
                if m.group(2) == 'SUCCESSFUL':
                    removal_results[m.group(1)] = 'removed'
                else:
                    removal_results[m.group(1)] = m.group(2)
            except IndexError:
                pass

    if removal_results:
        for item in report.get('ItemsToRemove', []):
            name = item.get('display_name', item['name'])
            item['install_result'] = removal_results.get(
                name, 'pending')
            if item['install_result'] == 'removed':
                if not 'RemovedItems' in report:
                    report['RemovedItems'] = [item['name']]
                elif not name in report['RemovedItems']:
                    report['RemovedItems'].append(item['name'])

    config_installed = 'config' in settings.INSTALLED_APPS

    if 'managed_uninstalls_list' in report:
        report['managed_uninstalls_list'].sort()
        if config_installed:
            from config.views import filter_uninstalls
            report['managed_uninstalls_list'] = filter_uninstalls(business_unit.id, report['managed_uninstalls_list'])


    c = {'user':user, 'machine_group': machine_group, 'business_unit': business_unit, 'report': report, 'install_results': install_results, 'removal_results': removal_results, 'machine': machine, 'facts':facts, 'conditions':conditions, 'ip_address':ip_address, 'config_installed':config_installed }
    return render_to_response('server/machine_detail.html', c, context_instance=RequestContext(request))
Exemple #60
0
def today(req, *args, **kwargs):
    business = sdksy_models.business.objects.all()

    return render_to_response('sdksy/today.html', {
        'business': business,
    })