def member_iteration(request,project_name,iteration,name):
"""
This view returns the member-specific per iteration view, i.e mlapora's
status for the Spoon iteration.
"""
user_test = User.objects.filter(username=name)
alias_test = Alias.objects.filter(alias=name)
if user_test or alias_test:
template = 'member_iter.html'
#getting bug data
b = bugsQuery.bugsQuery(project_name)
c = b.getBugsForUserAndIteration(name,iteration)
#getting task data
d = sninjaQuery.sninjaQuery(project_name)
if user_test:
e = d.getTasksForUserAndIteration(user_test[0].email,iteration)
else:
e = d.getTasksForUserAndIteration(alias_test[0].email,iteration)
context_data = {'member_name': name,'iteration':iteration, 'bugs': c, 'tasks':e, 'media_url':settings.MEDIA_URL}
return render_to_response(template, context_data)
else: #modify the below to use users
template= 'try_again-iteration.html'
context_description = 'username'
users = User.objects.all()
all_choices = []
for entry in users:
all_choices.append(entry.username)
context_data = {'bad_content':name, 'all_choices':all_choices, 'type':context_description, 'media_url':settings.MEDIA_URL}
return render_to_response(template, context_data)
def iteration(request,project_name,iteration_name):
"""
This view returns the iteration specific page, i.e. the Spoon iteration
of RDS.
"""
iterations = sninjaQuery.sninjaQuery(project_name).getStoryCollections
name_test = Iteration.objects.filter(iteration=iteration_name)
if name_test:
#getting bug stats
bugClass = bugsQuery.bugsQuery(project_name)
bug_stats = bugClass.getBugNumbersForIteration(iteration_name)
#getting task data
taskClass = sninjaQuery.sninjaQuery(project_name)
task_stats = taskClass.getUnclaimedTasksForIteration(iteration_name)
template = 'iteration_dash.html'
context_data = {'bugStats': bug_stats, 'iteration':iteration_name, 'taskStats':task_stats, 'media_url':settings.MEDIA_URL}
return render_to_response(template, context_data)
else:
template= 'try_again-iteration.html'
context_description = 'iteration'
all_choices = []
iterations = Iteration.objects.all()
for entry in iterations:
all_choices.append(entry.iteration)
context_data = {'bad_content':iteration_name, 'all_choices':all_choices, 'type':context_description, 'media_url':settings.MEDIA_URL}
return render_to_response(template, context_data)
def process(request):
if isLogged(request):
return redirect('/stats/empire')
if request.method == 'POST':
lf = LoginForm(request.POST)
if lf.is_valid():
acc = Account.objects.get(login=lf.cleaned_data['login'])
if acc.banexpire != None:
if acc.banexpire < datetime.now():
acc.banexpire = None
acc.save()
else:
return render_to_response('register/login/login.html', {'form':lf,
'banned':True,
'bannedto':acc.banexpire,
'banreason':acc.banreason})
sessLogin(acc, request)
return redirect('/stats/empire/')
try:
lf
except:
lf = LoginForm()
return render_to_response('register/login/login.html', {'form':lf, 'banned':False})
def process(request):
if request.method == 'POST':
rf = RegisterForm(request.POST)
if rf.is_valid():
account = rf.save(commit=False)
account.password = sha1(rf.cleaned_data['login'].encode('utf-8').lower()+rf.cleaned_data['password'].encode('utf-8')).hexdigest()
account.id = None
account.save()
rc = RegisterConfirmation()
rc.account = account
rc.key = sha1(str(datetime.now()) + 'ourwearyeyesstillstraytothehorizon').hexdigest()
while True: # Make it so key is truly unique
try:
rc.save()
except IntegrityError:
rc.key = sha1(rc.key + 'theteaset' + str(datetime.now())).hexdigest()
else:
break
resp = render_to_string('register/register/mail.txt', {'key':rc.key,
'password':rf.cleaned_data['password'],
'login':account.login,
'empire':account.empire})
send(account.email, u'Bellum - aktywacja konta', unicode(resp, 'UTF-8'))
return render_to_response('register/register/success.html', {})
try:
rf
except:
rf = RegisterForm()
return render_to_response('register/register/register.html', {'form':rf, 'sup':sup})
def addposts(request,**args):
cUser = args['User']
currentpage = 'posts'
if request.method == "GET":
book = request.GET.get("book",0)
try:
book = dm.Book.objects.get(id = book)
except dm.Book.DoesNotExist:
book = 0
if request.method == "POST":
postsdata = {
"subject" : request.POST["subject"],\
"content" : request.POST["content"],\
"book" : request.POST["book"],\
"author" : cUser.id
}
if len(postsdata['subject']) == 0:
subjecterror = u'笔记标题不能为空!'
return render_to_response('dushu/addposts.html',locals())
elif len(postsdata['content']) == 0:
contenterror = u'笔记内容不能为空!'
return render_to_response('dushu/addposts.html',locals())
newPosts = dm.Posts.objects.create(**postsdata)
buildship(int(postsdata['book']),cUser.id)
return HttpResponseRedirect("/posts/" + str(newPosts.id))
return render_to_response('dushu/addposts.html',locals())
def login(request):
currentpage = 'user'
if request.session.get('uid'):
return HttpResponseRedirect('/')
ref_page = request.GET.get('ref_page','/')
if '/reg/' in ref_page:
ref_page = '/'
if 'email' in request.POST and 'pwd' in request.POST:
email = request.POST.get('email')
pwd = request.POST.get('pwd')
if len(email) == 0:
etips = u'Email地址不能为空！'
elif len(pwd) == 0:
ptips = u'密码不能为空！'
else:
try:
user = dm.User.objects.get(email = email)
right_pwd = user.pwd
except dm.User.DoesNotExist:
etips = u'用户不存在！'
else:
if right_pwd != md5(pwd).hexdigest():
ptips = u'密码错误！'
else:
if user.valid:
request.session['uid'] = user.id
request.session.set_expiry(0)
return HttpResponseRedirect(ref_page)
else:
return render_to_response('dushu/confirmation.html',locals())
return render_to_response('dushu/login.html',locals())
def edit(request,**args):
cUser = args['User']
currentpage = 'posts'
pid = request.GET.get('pid',0)
try:
model = dm.__dict__[args['model'].capitalize()]
except KeyError:
raise Http404
try:
arc = model.objects.get(id = pid)
postsid = pid
try:
subject = arc.subject
except AttributeError:
postsid = arc.posts
subject = ''
except model.DoesNotExist:
error = u"内容不存在"
return render_to_response("dushu/tips.html",locals())
if request.method == "POST":
if args['model'] == 'posts':
data = {
'subject':request.POST['subject'],
'content':request.POST['content']
}
elif args['model'] == 'reply':
data = {'content':request.POST['content']}
model.objects.filter(id = pid).update(**data)
return HttpResponseRedirect("/posts/" + str(postsid))
return render_to_response("dushu/edit.html",locals())
def ajax_get_file (request):
if not valid_session(request):
return render_to_response('js_play/templates/ajax.html', {'output': 'Error: Invalid session.'})
file_obj, dir_obj = init_workers(request.session['session_type'])
if request.method == 'GET':
file_path = request.GET['file_path']
current_dir = dir_obj.get_current_dir()
file_contents = file_obj.get_file_contents(full_file_path = current_dir + file_path, escape_to_html = False)
return render_to_response('js_play/templates/ajax.html', {'output': file_contents})
return render_to_response('js_play/templates/ajax.html', {'output': 'Error: Invalid file requested.'})
def ajax_save_file (request):
if not valid_session(request):
return render_to_response('js_play/templates/ajax.html', {'output': 'Error: Invalid session.'})
file_obj, dir_obj = init_workers(request.session['session_type'])
if request.method == 'POST':
file_contents = request.POST['file_contents']
file_path = request.POST['file_path']
current_dir = dir_obj.get_current_dir()
file_obj.save_file_contents(current_dir + file_path, file_contents)
return render_to_response('js_play/templates/ajax.html', {'output': ''})
def main(request, demo):
if demo == 'flot':
return render_to_response('demos/flot.mako', {})
elif demo == 'rickshaw':
return render_to_response('demos/rickshaw.mako', {})
elif demo == 'nvd3':
return render_to_response('demos/nvd3.mako', {})
elif demo == 'cubism':
return render_to_response('demos/cubism.mako', {})
else:
return HttpResponse(content="Demo doesn't exist", status=404)
def index(request):
# logged in user
c = Context() # duck-typed context object for Mako
c.ident = request.user
add_auth_info_to_context(request, c)
c.silos = list_silos()
if settings.METADATA_EMBARGOED:
#if not ident:
# abort(401, "Not Authorised")
if request.user.is_authenticated():
c.silos = authz(ident)
else:
return HttpResponseForbidden("Forbidden")
c.silo_infos = {}
for silo in c.silos:
c.silo_infos[silo] = []
state_info = granary.describe_silo(silo)
if 'title' in state_info and state_info['title']:
c.silo_infos[silo].append(state_info['title'])
else:
c.silo_infos[silo].append(silo)
c.silo_infos[silo].append(get_datasets_count(silo))
c.silo_infos[silo].append(getSiloModifiedDate(silo))
# conneg return
accept_list = None
if request.META.has_key('HTTP_ACCEPT'):
try:
accept_list = conneg_parse(request.META['HTTP_ACCEPT'])
except:
accept_list= [MT("text", "html")]
if not accept_list:
accept_list= [MT("text", "html")]
mimetype = accept_list.pop(0)
while(mimetype):
if str(mimetype).lower() in ["text/html", "text/xhtml"]:
return render_to_response('list_of_silos.html', {'c':c})
elif str(mimetype).lower() in ["text/plain", "application/json"]:
response.content_type = 'application/json; charset="UTF-8"'
response.status_int = 200
response.status = "200 OK"
return HttpResponse(json.dumps(c.silos), mimetype='application/json; charset="UTF-8"')
try:
mimetype = accept_list.pop(0)
except IndexError:
mimetype = None
return render_to_response('list_of_silos.html', {'c':c})
def addsource(request):
# A user needs to be authenticated and authorized to be able to administer the DataFinder
# Test if the user is now a university authenticated user
if 'DF_USER_SSO_ID' not in request.session:
return redirect("/login?redirectPath=admin")
# Test if the user is Data Finder authorised user
if request.session['DF_USER_ROLE'] != "admin" :
return redirect("/")
context = {}
if request.GET.has_key('message'):
context["message"]=request.GET['message']
if request.GET.has_key('status'):
context["status"]=request.GET['status']
http_method = request.environ['REQUEST_METHOD']
if http_method == "GET":
return render_to_response('add_metadata_source.html',context, context_instance=RequestContext(request))
if http_method == "POST":
if request.POST.has_key('source'):
context["source"] = request.POST["source"]
context["title"] = request.POST["title"]
context["description"] = request.POST["description"]
context["uri"] = request.POST["uri"]
context["notes"] = request.POST["notes"]
context["activate"] = False
try:
sourceinfo= SourceInfo.objects.get(source=context["source"])
context['message']="Sorry, the source " + context["source"] +" already exists."
context['status']="error"
return redirect("/admin?message="+context['message']+"&status="+context['status'])
except SourceInfo.DoesNotExist,e:
sourceinfo = SourceInfo()
sourceinfo.source = context["source"]
sourceinfo.title = context["title"]
sourceinfo.description = context["description"]
sourceinfo.uri = context["uri"]
sourceinfo.notes = context["notes"]
sourceinfo.save()
context['message']="Thanks, "+ request.POST.get("source") +" has been successfully added."
context['status']="success"
return render_to_response('edit_metadata_source.html',context, context_instance=RequestContext(request))
except Exception,e:
logger.error("Oops, an error occurred, sorry...")
context['message']="Oops, an error occurred, sorry..."
context['status']="error"
return redirect("/admin?"+"message="+context['message']+"&status="+context['status'])
def builder(request, template='packager'):
version = request.GET.get('version', settings.DEFAULT_VERSION)
dpdr = get_depender(version=version, reset=False)
packages = {}
proj = get_version_settings(version)
#Core, More, etc
for p in proj['BUILDER_PACKAGES']:
if not hasattr(packages, p):
packages[p] = {}
#Fx, Element, etc
for name, component in dpdr.packages[p].components.iteritems():
if not hasattr(packages[p], component.filename):
packages[p][component.filename] = {
'provides': [],
'requires': []
}
packages[p][component.filename]['provides'].extend(component.provides)
packages[p][component.filename]['requires'].extend(component.requires)
def get_provides(package, filename):
return [pc[1] for pc in packages[package][filename]['provides']]
def get_depends(package, filename):
return [pc[0] + '/' + pc[1] for pc in packages[package][filename]['requires']]
return render_to_response(template + '.mako',
{
'packages': proj['BUILDER_PACKAGES'],
'package_data': packages,
'get_provides': get_provides,
'get_depends': get_depends,
'dpdr': dpdr,
'markdown': markdown,
'version': version
}
)
def process(request, rankingtype, page):
if not (rankingtype in ('all', 'mother', 'army', 'allied')):
return redirect('/')
rt = {'all':RankingNone, 'army':RankingArmy, 'mother':RankingMother, 'allied':RankingAlliance}
if page == None:
# caveats
pass
else:
page = int(page)
ranking = rt[rankingtype].objects.filter(id__gt=RPP*(page-1)).filter(id__lt=(RPP*page)+1)
acc = getAccount(request)
total_objects_count = rt[rankingtype].objects.count()
pages = int(ceil(total_objects_count / RPP))
pagination = []
if (pages < 8): # special case - static
pagination = range(1, pages+1)
elif (page > 3) and (page < pages-2): # no special cases apply
pagination = [page-3, page-2, page-1, page, page+1, page+2, page+3]
elif (page < 4): # less than 3 entries left
pagination = range(1, page+1) + [page+1, page+2, page+3]
elif (page > pages-4): # less than 3 entries right
pagination = [page-3, page-2, page-1, page] + range(page+1, pages+1)
return render_to_response('stats/ranking/'+rankingtype+'.html',{'pgo':PrimaryGUIObject(request),
'account':acc,
'page':page,
'pagecount':pages,
'pages':pagination,
'ranking':ranking})
def mine(request):
orderitems = OrderItem.objects.select_related('dish__vendor__category').filter(user=request.user.id).order_by('-create_time')
context = create_context(request,
orderitems=orderitems,
)
return render_to_response('/home/mine.html', context)
def show_vendor(request, id):
try:
vendor = Vendor.objects.get(id=id)
context = create_context(request, vendor=vendor)
return render_to_response('home/show_vendor.html', context)
except Vendor.DoesNotExist:
return HttpResponseNotFound('Not Found')
def backlogs(request, team_name):
"""
This view returns the summary of all backlogs under the team umbrella.
"""
template = 'backlogs.html'
team = Team.objects.get(name=team_name.lower())
backlogs = Backlog.objects.filter(team=team.id)
#--------------------------------------------------------------
items_to_display = team.backlog_items_shown #default # of items to display per backlog
#--------------------------------------------------------------
mother_backlog_stats = {}
supplemental_backlog_stats = {}
for backlog in backlogs:
a = sninjaQuery.sninjaQuery(backlog.backlog)
project_id = a.getProjectIdFromProjectName()
if project_id:
if not backlog.supplemental:
mother_backlog_stats[backlog.backlog] = {}
mother_backlog_stats[backlog.backlog]['data'] = a.getTopStories(backlog.supplemental)
mother_backlog_stats[backlog.backlog]['owner'] = backlog.owner
mother_backlog_stats[backlog.backlog]['project_id'] = project_id
if backlog.supplemental:
supplemental_backlog_stats[backlog.backlog] = {}
supplemental_backlog_stats[backlog.backlog]['data'] = a.getTopStories(backlog.supplemental)
supplemental_backlog_stats[backlog.backlog]['owner'] = backlog.owner
supplemental_backlog_stats[backlog.backlog]['project_id'] = project_id
# These 3 arrays comprise the three columns that will be created on the html
# page. This is a preprocessor for the data.3
backlog_box1 = {}
backlog_box2 = {}
backlog_box3 = {}
n = 0
for item in supplemental_backlog_stats.keys():
print item, n
if n % 3 == 0:
backlog_box1[item] = supplemental_backlog_stats[item]
elif n % 3 == 1:
backlog_box2[item] = supplemental_backlog_stats[item]
elif n % 3 == 2:
backlog_box3[item] = supplemental_backlog_stats[item]
n += 1
n = 0
for item in mother_backlog_stats.keys():
print item, n
if n % 3 == 0:
backlog_box1[item] = mother_backlog_stats[item]
elif n % 3 == 1:
backlog_box2[item] = mother_backlog_stats[item]
elif n % 3 == 2:
backlog_box3[item] = mother_backlog_stats[item]
n += 1
context_data = {'backlog_box1': backlog_box1, 'backlog_box2': backlog_box2, \
'backlog_box3': backlog_box3, 'items_to_display': items_to_display, \
'media_url':settings.MEDIA_URL}
return render_to_response(template, context_data)
def redirect(request):
if request.method == 'GET':
clk_dict = create_clk_dict(request)
if 'show_type' in clk_dict and clk_dict['show_type'] == 1:
show_type = 1
else:
show_type = 0
if show_type == 1:
item = SecKill.get_seckill_link_by_id(clk_dict['link_id'])
else:
item = Feeds.get_feed_url_by_linkid(clk_dict['link_id'])
if item:
if show_type == 1:
clk_dict['real_link'] = add_link_id(item['link'])
else:
clk_dict['real_link'] = item['link']
stat_log.info('clk=%s'%json.dumps(dict(clk_dict)))
response = render_to_response("redirect.html",{'id': clk_dict['feed_id'], 'url': clk_dict['real_link']}, context_instance=RequestContext(request))
timestamp = str(int(time.time())) + '000'
message = TAOBAO_APP_SECRET + 'app_key' + TAOBAO_APP_KEY + 'timestamp' + timestamp + TAOBAO_APP_SECRET
mysign = hmac.new(TAOBAO_APP_SECRET)
mysign.update(message)
mysign = mysign.hexdigest().upper()
set_cookie(response,'timestamp',timestamp)
set_cookie(response,'sign',mysign)
return response
else:
info_log.info('invalid clk url %s'%clk_dict)
return HttpResponseRedirect('/')
else:
return HttpResponseRedirect('/')
def home(request):
(top_feeds,common_feeds) = Feeds.get_all_feeds_ret_2(1,0)
userinfo = None
open_id = get_cookie(request,'od')
if open_id:
userinfo = UserInfo.get_user_info_by_openid(open_id)
response = render_to_response("index.html",{'top_feeds': top_feeds, 'common_feeds': common_feeds, 'userinfo': userinfo}, context_instance=RequestContext(request))
stat_dict={}
stat_dict['pn'] = 1
stat_dict['type'] = 0
if get_cookie(request,'cid'):
cid = get_cookie(request,'cid')
info_log.info('cookie %s coming'%cid)
stat_dict['cid'] = cid
stat_dict['ua'] = request.META.get('HTTP_USER_AGENT','unknown')
stat_dict['ip'] = request.META.get('REMOTE_ADDR','unknown')
stat_log.info('get_home=%s'%json.dumps(dict(stat_dict)))
else:
cid = create_cookie_id(request)
set_cookie(response,'cid',cid)
info_log.info('create cookie id %s'%cid)
stat_dict['cid'] = cid
stat_dict['ua'] = request.META.get('HTTP_USER_AGENT','unknown')
stat_dict['ip'] = request.META.get('REMOTE_ADDR','unknown')
stat_log.info('get_home=%s'%json.dumps(dict(stat_dict)))
return response
def home(request):
args = {
"user": request.user,
"login_date": request.session["login_date"],
"login_method": request.session["login_method"]
}
return render_to_response("home.mako", args)
def seckill(request):
if 'req_type' in request.GET and request.GET['req_type'].isdigit():
req_type = int(request.GET['req_type'])
else:
req_type = 3
order = 1
page_num = 1
sec_kills = SecKill.get_return_list(req_type,order,page_num)
userinfo = None
open_id = get_cookie(request,'od')
if open_id:
userinfo = UserInfo.get_user_info_by_openid(open_id)
response = render_to_response("seckill.html",{'sec_kills': sec_kills, 'userinfo': userinfo, 'req_type': req_type}, context_instance=RequestContext(request))
stat_dict={}
stat_dict['pn'] = 1
stat_dict['type'] = 0
if get_cookie(request,'cid'):
cid = get_cookie(request,'cid')
info_log.info('cookie %s coming'%cid)
stat_dict['cid'] = cid
stat_dict['ua'] = request.META.get('HTTP_USER_AGENT','unknown')
stat_dict['ip'] = request.META.get('REMOTE_ADDR','unknown')
stat_log.info('get_seckill_home=%s'%json.dumps(dict(stat_dict)))
else:
cid = create_cookie_id(request)
set_cookie(response,'cid',cid)
info_log.info('create cookie id %s'%cid)
stat_dict['cid'] = cid
stat_dict['ua'] = request.META.get('HTTP_USER_AGENT','unknown')
stat_dict['ip'] = request.META.get('REMOTE_ADDR','unknown')
stat_log.info('get_seckill_home=%s'%json.dumps(dict(stat_dict)))
return response
def movie(request, generation, orgname):
gdir = 'gen-%s' % generation
gdir = os.path.join(BASEDIR, gdir)
mpath = get_movie(gdir, orgname)
url = 'http://www.polymerase.org/~ghall/coindrop/movies/%s.flv' % orgname
macros = {'movie_url': url}
return render_to_response('movie.tmpl', macros)
def login(request):
'''login view'''
if request.session.get("uid"):
return HttpResponseRedirect("/")
ref_page = request.GET.get('ref_page','/')
if "usm" in request.POST and "pwd" in request.POST:
usm = request.POST["usm"]
pwd = request.POST["pwd"]
if len(usm) == 0:
utips = u'用户名不能为空！'
elif len(pwd) == 0:
ptips = u'密码不能为空！'
else:
try:
user = sm.User.objects.get(usm = usm)
right_pwd = user.pwd
except sm.User.DoesNotExist:
utips = u'用户不存在！'
else:
#if right_pwd != md5(pwd).hexdigest():
if right_pwd != pwd:
ptips = u'密码错误！'
else:
request.session['uid'] = user.id
request.session.set_expiry(0)
return HttpResponseRedirect(ref_page)
return render_to_response("system/login.html",locals())
def process(request):
if request.method == 'POST':
rf = RemindForm(request.POST)
if rf.is_valid():
acc = Account.objects.get(email=rf.cleaned_data['email'])
if acc.passwordremindtoken_set.count() > 0:
acc.passwordremindtoken_set.all().delete()
didRemovePrevious = True
else:
didRemovePrevious = False
prt = PasswordRemindToken(account=acc)
prt.key = sha1(str(datetime.now()) + 'thelightwasbrighter').hexdigest()
while True: # Make it so key is truly unique
try:
prt.save() # chance is 1:2^160 that key repeats, but the chance is
except IntegrityError:
prt.key = sha1(prt.key + 'hellocharlie' + str(datetime.now())).hexdigest()
else:
break
try:
resp = render_to_string('register/passremind/mail.txt', {'key':prt.key,
'login':acc.login,
'accname':acc.empire,
'newpass':prt.newpassword})
send(acc.email, u'Bellum - przypomnienie hasła', unicode(resp, 'UTF-8'))
except Exception, e:
# something has FEHLED
prt.delete()
raise e
return render_to_response('register/passremind/success.html', {'key':prt.key,
'newpassword':prt.newpassword,
'didRemovePrevious':didRemovePrevious})
def home(request):
args = {
"user": request.user,
"login_date": request.session["login_date"],
"login_method": request.session["login_method"]
}
return render_to_response("home.mako", args)
def sensors_list(request):
sensors = Sensor.objects.filter(
Device=request.session['Device.id']).order_by('sorting')
return render_to_response('device/setup.sensors_list.html', {
'request': request,
'sensors': sensors
})
def index(request):
logger.error(_('error log test'))
logger.info(_('info log test'))
logger.debug(_('debug log test'))
context = {}
context.update(csrf(request))
return render_to_response('index.html', context)
def toc(request, path):
toc = get_toc(_read_md(path)[0])
basepath = request.REQUEST.get('basepath')
return render_to_response('toc.mako',{
'basepath': basepath,
'toc': toc
})
def process(request):
mum = getCurrentMother(request)
tech = getTechnology(request)
try:
mro, = MotherRelocationOrder.objects.filter(mother=mum)
except:
relocating = False
mro = None
else:
relocating = True
constructions = mum.getConstructions()
researches = mum.getResearches()
return render_to_response('mother/overview/overview.html', {'mother':mum,
'constructions':constructions,
'c_requirements':mother_construction.getRequirementsArray(mum, getRace(request)),
'c_costs':mother_construction.getCostsArray(mum, getRace(request)),
'technology':tech,
'researches':researches,
't_costs':technology.getCostsArray(tech, getRace(request)),
't_requirements':technology.getRequirementsArray(tech, getRace(request)),
'pgo':PrimaryGUIObject(request),
'relocating':relocating,
'mro':mro,
'race':getRace(request),
})
def process(request):
struct = get_struct(request).exports
if request.method == 'POST':
rf = DatepickForm(request.POST)
rf.fields['method'].choices = struct.EXPORTS(DATEPICK_PRESENTATION)
if rf.is_valid():
s = int(rf.cleaned_data['method'])
if s == 0:
from p24ip.arch.sopmods import excel
return excel.process(request, rf.cleaned_data['dfrom'],
rf.cleaned_data['dto'])
if s == 1:
from p24ip.arch.sopmods import extrema
return extrema.process(request, rf.cleaned_data['dfrom'],
rf.cleaned_data['dto'])
else:
return struct.__dict__['export' + str(s)](
request, rf.cleaned_data['dfrom'], rf.cleaned_data['dto'])
else:
rf = DatepickForm()
rf.fields['method'].choices = struct.EXPORTS(DATEPICK_PRESENTATION)
return render_to_response('arch/export_datepick.html', {
'request': request,
'form': rf
})
def vote_view(request, type, entry_id):
entry = get_object_or_404(Entry, id=entry_id)
if type == "goodnews":
entry.good += 1
elif type == "badnews":
entry.bad += 1
entry.save()
return render_to_response( get_template_name('blank.html'),{})
def ideamaker(request):
template = 'ideas.html'
idea_form = IdeaForm()
all_ideas = Idea.objects.all().order_by('-id')[:25]
context_data = {'idea_form':idea_form,'ideas':all_ideas,'configs':configs}
return render_to_response(template, context_data)
def rights_flags(request,rights_number):
template = 'rights.html'
releasesObject = new_releases_tool.NewReleasesTool()
rights_data = releasesObject.returnRightsFlags(rights_number)
context_data = {'rights':rights_data, 'configs':configs}
return render_to_response(template, context_data)
def batchmaker(request):
template = 'batchmaker.html'
batch_form = BatchForm()
all_batches = Batch.objects.all().order_by('-id')[:25]
context_data = {'batch_form':batch_form,'batches':all_batches,'configs':configs}
return render_to_response(template, context_data)
def contacto(request):
arrayFotos = []
if 'q' in request.GET and request.GET['q']:
get = request.GET['q']
print(get)
if request.method == 'POST':
formulario = fotosPedido(request.POST)
formulario2 = ContactForm(request.POST)
galletas = ""
if (get == "1"):
if formulario.is_valid():
galletas = request.POST['hidden_field0']
galletas = galletas.split('|')
#Imprime url
#print(galletas)
global tipoGalleta
tipoGalleta = galletas[-1]
galletas.pop()
tipoGalleta = tipoGalleta[-5]
descargaAndPaste(galletas, "archivoSal.jpg")
elif (get == "2"):
print("Enviar mensaje")
titulo = 'Mensaje de contacto desde \"Social Cookies\"'
contenido = request.POST['mensaje'] + "\n"
contenido += 'Comunicarse a : ' + request.POST['correo'] + "\n"
contenido += 'A escogido el tipo de galleta: ' "<" + str(
tipoGalleta) + ">"
mandaCorreo(titulo, contenido)
return HttpResponseRedirect('/socialcookies')
else:
formulario = ContactForm()
formulario2 = fotosPedido()
return render_to_response(
'index.html', {
'path': '/static/',
'seccion': 'contacto',
'formulario': formulario,
'formulario2': formulario2,
"csrftoken": csrf(request)["csrf_token"],
'fich': ficheros
})
def api_view(request, api_name):
# logged in user
c = create_context(request.user)
c.ident = request.user
add_auth_info_to_context(request, c)
if api_name not in ['silos', 'datasets', 'states', 'items']:
# redirect(url(controller="api", action="apiview", api_name="silos"))
return redirect("/api/silos")
c.api_file = "%s_api.html" % api_name
return render_to_response('/api.html', {'c': c})
def index(request):
fotosE = os.listdir('./socialcookies/static/img/authors')
fotosE.sort()
return render_to_response('index.html', {
'path': '/static/',
'seccion': 'index',
'fich': ficheros,
'fotos': fotosE
})
def red(request):
d = Device(request.session['Device.dev_number'])
a = d.alerts
d.registry['alert'] = '0'
return render_to_response('device/alertlog.html', {
'request': request,
'alerts': a,
'severity': 1
})
def display(request):
if request.session['AccountDevice.privileges'] == 0:
sensors = Sensor.objects.filter(
Device=request.session['Device.id']).filter(
canUserRead=True).order_by('sorting')
else:
sensors = Sensor.objects.filter(
Device=request.session['Device.id']).order_by('sorting')
return render_to_response('device/control.html', {
'request': request,
'sensors': sensors
})
def process(request):
dev = Device.objects.get(id=request.session['Device.id'])
xd = p24.Device(dev.dev_number)
struct = get_struct(request)
af = AFDevice(dev.dev_number)
return render_to_response(
'device/overview.html', {
'dev': dev,
'request': request,
'vendor': xd.vendor,
'struct': struct,
'af': af
})
def control(request):
from patelnia.p24 import PerDeviceRegistry
r = PerDeviceRegistry(request.session['Device.dev_number'])
if request.session['AccountDevice.privileges'] == 0:
sensors = Sensor.objects.filter(
Device=request.session['Device.id']).filter(canUserRead=True)
else:
sensors = Sensor.objects.filter(Device=request.session['Device.id'])
return render_to_response('structures/rx910smartu1/control.html', {
'request': request,
'registry': r,
'sensors': sensors
})
def sensor_new(request):
af = SensorForm()
if request.method == "POST":
af = SensorForm(request.POST)
af.instance.Device = Device.objects.get(
id=request.session['Device.id'])
if af.is_valid():
af.save()
return render_to_response('device/setup.sensor_new.html', {
'request': request,
'form': af,
'saved': True
})
try:
af
except:
af = SensorForm()
return render_to_response('device/setup.sensor_new.html', {
'request': request,
'form': af,
'saved': False
})
def render_html_or_json(request, c, template_name, json_obj):
# conneg return
accept_list = None
if request.META.has_key('HTTP_ACCEPT'):
try:
accept_list = parse(request.META['HTTP_ACCEPT'])
except:
accept_list = [MimeType("text", "html")]
if not accept_list:
accept_list = [MimeType("text", "html")]
mimetype = accept_list.pop(0)
while (mimetype):
if str(mimetype).lower() in ["text/html", "text/xhtml"]:
return render_to_response(template_name, {'c': c})
elif str(mimetype).lower() in ["text/plain", "application/json"]:
return HttpResponse(json.dumps(json_obj),
mimetype='application/json; charset="UTF-8"')
try:
mimetype = accept_list.pop(0)
except IndexError:
mimetype = None
return render_to_response(template_name, {'c': c})
def sensor_edit(request, sensor_id):
app = Sensor.objects.get(id=sensor_id)
if app.Device.id != request.session['Device.id']:
return redirect('/manage/pick/')
af = SensorForm(instance=app)
if request.method == "POST":
af = SensorForm(request.POST, instance=app)
if af.is_valid():
af.save()
return render_to_response('device/setup.sensor_edit.html', {
'request': request,
'form': af,
'saved': True
})
try:
af
except:
af = SensorForm()
return render_to_response('device/setup.sensor_edit.html', {
'request': request,
'form': af,
'saved': False
})
def save(request):
from afruntime import DEVDB_ROOT
from patelnia.p24 import Device
sensors = Sensor.objects.filter(Device=request.session['Device.id'])
xie = open(
DEVDB_ROOT + str(request.session['Device.dev_number']) + '/CONFIG',
'w')
for sensor in sensors:
xie.write(str(sensor.modbus_devid) + " ")
xie.write(str(sensor.regtype) + " ")
xie.write(str(sensor.register) + " ")
xie.write(str(sensor.interval_0) + " ")
xie.write(str(sensor.interval_1) + "\n")
del xie
Device(request.session['Device.dev_number']).reread_sensorics()
return render_to_response('device/setup.save.html', {'request': request})
def network_info(request):
import subprocess
commands = [
"route -n",
"getent ahosts",
"ip addr",
"cat /etc/resolv.conf",
"cat /etc/hosts",
"ps aux | grep java",
"netstat -lnp",
]
netinfo = dict(
(cmd, subprocess.check_output(cmd, shell=True)) for cmd in commands)
return render_to_response("netinfo.html", {'info': netinfo})
def process(request):
if request.method == 'POST':
lf = LoginForm(request.POST)
if lf.is_valid():
acc = Account.objects.get(login=lf.cleaned_data['login'])
request.session['logged'] = True
request.session['Account.id'] = acc.id
request.session['Account.privileges'] = acc.privileges
request.session['device_picked'] = False
return redirect('/manage/pick/')
try:
lf
except:
lf = LoginForm()
return render_to_response('login/login.html', {
'form': lf,
'request': request
})
def tutorials(request):
location = settings.CONTENT_FRAME_URL() % request.get_host().split(':')[0]
step_location = "/lesson/"
if request.user.is_authenticated() \
and request.user.username != "AnonymousUser":
try:
ustep = UserLocation.objects.get(user=request.user)
hue_location = ustep.hue_location
step_location = ustep.step_location
if step_location == None:
step_location = "/lesson/"
if urlparse(hue_location).netloc == urlparse(location).netloc:
location = hue_location
except UserLocation.DoesNotExist:
pass
return render_to_response("sandbox-tutorials/frames.html", {
'content': location,
'step_location': step_location
})
def process(request, dfrom, dto):
# Prepare reads
archsensors = ArchSensor.objects.filter(
Sensor__Device__id=request.session['Device.id'])
sheets = {}
for archsensor in archsensors:
minimo = archsensor.read_set.filter(readed_on__lte=dto).filter(
readed_on__gte=dfrom).exclude(data=None).order_by('data')[0]
maximo = archsensor.read_set.filter(readed_on__lte=dto).filter(
readed_on__gte=dfrom).exclude(data=None).order_by('-data')[0]
sheets[archsensor.Sensor.name] = (minimo, maximo)
return render_to_response('arch/sopmods/extrema.html', {
'request': request,
'reads': sheets
})
def login_handler(request):
c = Context() # duck-typed context object for Mako
c.came_from = request.GET.get('came_from', "/")
if request.method == "POST":
if request.POST.has_key('login') and request.POST.has_key('password'):
username = request.POST['login']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
# Redirect to a success page.
return redirect('/welcome')
else:
# Return a 'disabled account' error message
request.session[
'login_flash'] = """Your account is currently disabled. Please contact the administrator."""
else:
# Return an 'invalid login' error message.
request.session[
'login_flash'] = """Wrong credentials. Have you been registered?"""
return render_to_response("login.html", {'c': c, 'request': request})
def about(request):
return render_to_response('publica/about.html', {})
def index(request):
return render_to_response('publica/index.html', {})
def process(request):
return render_to_response('manage/registry.html', {
'request': request,
'registry': GlobalRegistry()
})
def render_to_response(template_name, context):
context['static'] = settings.STATIC_URL
return shortcuts.render_to_response(template_name, context)
def testhello(self):
print render_to_response('hello.html', {'name': 'sand'})
def dataset_view(request, siloname, id):
if not granary.issilo(siloname):
raise Http404
rdfsilo = granary.get_rdf_silo(siloname)
if not rdfsilo.exists(id):
raise Http404
c = Context()
silo = siloname
#tmpl_context variables needed: c.silo_name, c.zipfiles, c.ident, c.id, c.path
c.silo_name = siloname
c.id = id
ident = request.user
c.ident = ident.username
dataset = rdfsilo.get_item(id)
creator = None
if dataset.manifest and dataset.manifest.state and 'metadata' in dataset.manifest.state and dataset.manifest.state['metadata'] and \
'createdby' in dataset.manifest.state['metadata'] and dataset.manifest.state['metadata']['createdby']:
creator = dataset.manifest.state['metadata']['createdby']
http_method = request.method
if http_method == "GET":
c.editor = False
if settings.METADATA_EMBARGOED:
if not ident:
return HttpResponse("Not Authorised", status=401)
silos = authz(ident)
if silo not in silos:
return HttpResponseForbidden("Forbidden")
silos_admin = authz(ident, permission='administrator')
silos_manager = authz(ident, permission='manager')
if c.ident == creator or silo in silos_admin or silo in silos_manager:
c.editor = True
elif ident:
silos = authz(ident)
if silo in silos:
silos_admin = authz(ident, permission='administrator')
silos_manager = authz(ident, permission='manager')
if ident[
'repoze.who.userid'] == creator or silo in silos_admin or silo in silos_manager:
c.editor = True
else:
#identity management of item
if not ident:
return HttpResponse("Not Authorised", status=401)
silos = authz(ident)
if silo not in silos:
return HttpResponseForbidden("Forbidden")
silos_admin = authz(ident, permission='administrator')
silos_manager = authz(ident, permission='manager')
if not (c.ident == creator or silo in silos_admin
or silo in silos_manager):
return HttpResponseForbidden("Forbidden")
if http_method == "GET":
c.zipfiles = get_zipfiles_in_dataset(dataset)
# conneg return
accept_list = None
if 'HTTP_ACCEPT' in request.META:
try:
accept_list = conneg_parse(request.META['HTTP_ACCEPT'])
except:
accept_list = [MT("text", "html")]
if not accept_list:
accept_list = [MT("text", "html")]
mimetype = accept_list.pop(0)
while (mimetype):
if str(mimetype).lower() in ["text/html", "text/xhtml"]:
return render_to_response("/list_of_zipfiles.html", {
'c': c,
})
elif str(mimetype).lower() in ["text/plain", "application/json"]:
return HttpResponse(
json.dumps(list(c.zipfiles.keys())),
mimetype='application/json; charset="UTF-8"')
try:
mimetype = accept_list.pop(0)
except IndexError:
mimetype = None
#Whoops nothing satisfies - return text/html
return render_to_response("/list_of_zipfiles.html", {
'c': c,
})
elif http_method == "POST":
params = request.POST
if not (params.has_key("filename") and params['filename']):
return HttpResponse("You must supply a filename to unpack",
status=400)
item_real_filepath = dataset.to_dirpath()
target_filepath = "%s/%s" % (item_real_filepath, params['filename'])
if not os.path.isfile(target_filepath):
return HttpResponse("File to unpack not found", status=404)
if not check_file_mimetype(target_filepath, 'application/zip'):
return HttpResponse("File is not of type application/zip",
status=415)
if params.has_key("id") and params['id']:
target_dataset_name = params['id']
else:
target_dataset_name = id
#step 1: Create / initialize target dataset
if not rdfsilo.exists(target_dataset_name):
if not allowable_id2(target_dataset_name):
return HttpResponse(
"Data package name can contain only the following characters - %s and has to be more than 1 character"
% ag.naming_rule_humanized,
status=400,
mimetype="text/plain")
target_dataset = create_new(rdfsilo, target_dataset_name, c.ident)
hr = HttpResponse("Created", status=201, mimetype="text/plain")
hr["Content-Location"] = reverse("dataset_view",
kwargs={
'siloname': siloname,
'id': target_dataset_name
})
else:
hr = HttpResponse("204 Updated", status=204, mimetype="text/plain")
target_dataset = rdfsilo.get_item(target_dataset_name)
#step 2: Unpack zip item
try:
unpack_zip_item(target_dataset, dataset, params['filename'],
rdfsilo, c.ident)
except BadZipfile:
return HttpResponse("BadZipfile: Couldn't unpack zipfile",
status=400,
mimetype="text/plain")
# FIXME: err.. wat is this?!
target_dataset.sync()
target_dataset.sync()
target_dataset.sync()
if hr.status == 201:
try:
b.creation(silo, id, ident=c.ident)
except:
pass
else:
try:
b.change(silo, id, ident=c.ident)
except:
pass
# conneg return
accept_list = None
if 'HTTP_ACCEPT' in request.META:
try:
accept_list = conneg_parse(request.META['HTTP_ACCEPT'])
except:
accept_list = [MT("text", "html")]
if not accept_list:
accept_list = [MT("text", "html")]
mimetype = accept_list.pop(0)
while (mimetype):
if str(mimetype).lower() in ["text/html", "text/xhtml"]:
return redirect(
reverse("dataset_view", kwargs={
'silo': silo,
'id': id
}))
elif str(mimetype).lower() in ["text/plain", "application/json"]:
hr.mimetype = "text/plain"
return hr
try:
mimetype = accept_list.pop(0)
except IndexError:
mimetype = None
# Whoops - nothing satisfies - return text/plain
hr.mimetype = "text/plain"
return hr
def sitemap(request):
return render_to_response('sitemap.xml', {})
def process_list(request):
ads = AccountDevice.objects.filter(Account=request.session['Account.id'])
return render_to_response('manage/pick.list.html', {
'ads': ads,
'request': request
})
def mako_html(request):
context = {
't': 'for test',
}
return render_to_response('misc/mako_html.html', context)
def process(request):
return render_to_response(
'device/registry.html', {
'request': request,
'registry': Device(request.session['Device.dev_number']).registry
})
