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})
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))
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,))
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
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))
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))
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))
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',))
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
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))
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})
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))
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))
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))
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)
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))
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)
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)
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))
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))
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))
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))
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))
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),
)
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})
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')
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))
def rank_teams_ajax(request):
return render_to_response('rank_teams.html', {'title': "Team Rankings"},
context_instance=RequestContext(request))
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))
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
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))
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
# 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))
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)
def fbpage(request):
return render_to_response('fbpage.html', {}, context_instance=RequestContext(request))
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))
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)
def user_remove(request):
return render_to_response("backend/index.html", context_instance=RequestContext(request))
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'))
def index(req, *args, **kwargs):
return render_to_response('sdksy/index.html')
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)
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")
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))
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)
def index(request):
return render_to_response('base.html')
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)
def tomorrow(req, *args, **kwargs):
return render_to_response('sdksy/tomorrow.html')
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)
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))
def today(req, *args, **kwargs):
business = sdksy_models.business.objects.all()
return render_to_response('sdksy/today.html', {
'business': business,
})
