def __call__(self, request, *args, **kwargs):
# generate our view via genericbase
view = super(GenericForm, self).__call__(request, *args, **kwargs)
self.form_class = view.params['form_class']
self.form_args = view.params['form_args']
self.initial = view.params['initial']
self.template_name = view.params['template_name']
self.success_message = view.params['success_message']
if request.method == 'POST':
form = self.form_class(
data=request.POST,
files=request.FILES,
**self.form_args
)
if form.is_valid():
self.handle_valid(form=form, request=request, *args, **kwargs)
if self.success_message:
msg = ugettext(self.success_message)
messages.success(request, msg, fail_silently=True)
redirect = self.redirect(request, *args, **kwargs)
if redirect:
return redirect
else:
form = self.form_class(initial=self.initial, **self.form_args)
context = RequestContext(request, {})
context.update({
'form': form,
})
context.update(view.params['extra_context'])
return render_to_response(self.template_name, context)
def post(request):
search_text = request.POST['search_text']
context = RequestContext(request)
context.update({
'posts': Post.objects.search(search_text)
})
return render_to_response('search.html', {}, context)
def add_view(self, request):
"""
new_instance is the created instance of self.model or none, depending on if form.is_valid.
Passed, for consistancy's sake to the template as "object"
This view is csrf_exempt, which aparently conflicts with django's admin_view wrapper.
This is problematic, as it exposes this view to anybody who knows the URL. @@TODO
Uploadify doesn't properly pass the csrf_token, hopefully this is fixed in the release version of
Uploadify.
"""
instance_form = self.get_minimal_add_form()
form = instance_form(request.POST, request.FILES, prefix=self.base_url())
new_instance = None
if form.is_valid():
new_instance = form.save()
template = select_template(self.item_add_template)
context = RequestContext(request)
context.update({
"insert": self,
"form": form,
"object": new_instance
})
response = HttpResponse(template.render(context))
response.status_code = 201
return response
response = HttpResponse(form.errors)
response.status_code = 400
return response
def login(request):
if (request.method == 'GET'): # redirecionamento padrao
#carrega o template da tela de login
template = loader.get_template('registration/login.html')
#carrega o contexto
c = RequestContext (request, {})
#retorna o template a ser renderizado
return HttpResponse(template.render(c))
if (request.method == 'POST'):
#formalidades de seguranca
c = {}
c.update(csrf(request))
#recebe o form
form = LoginForm(request.POST)
#redireciona caso esteja autenticado
if isUserAutenticated(form) is not None:
#redireciona para o template da list
return HttpResponseRedirect("/list")
else:
#redireciona para o template do index
return HttpResponseRedirect("/")
def index(request, path=None):
f = open("/tmp/log.txt", "a")
f.write("path: %s\n" % str(path))
f.write("request: %s\n" % str(request))
path = request.GET.get('page', None)
if path == '':
path = 'index'
f.write("pth: %s \n" % (path))
if path is None:
# workaround in history tokens: must have a query
return HttpResponseRedirect("./?page=#index")
p = Page.objects.get(name=path)
f.write("page: %s \n" % (str(p)))
f.close()
args = {'title': p.name,
'noscript': p.text
}
context_instance=RequestContext(request)
context_instance.autoescape=False
try:
template = Page.objects.get(name='index.html')
except Page.DoesNotExist:
template = None
if not template:
return render_to_response('index.html', args, context_instance)
tpl = loader.get_template_from_string(template)
context_instance.update(args)
tpl = tpl.render(context_instance)
return HttpResponse(tpl)
def posting(request):
if request.user.is_authenticated():
username = request.user.username
useremail = request.user.email
messages.get_messages(request)
if request.method == 'POST':
user = User.objects.get(username=username)
diary = models.Diary(user=user)
post_form = forms.DiaryForm(request.POST, instance=diary)
if post_form.is_valid():
messages.add_message(request, messages.INFO, "日记已保存")
post_form.save()
return HttpResponseRedirect('/')
else:
messages.add_message(request, messages.INFO, '要张贴日记，每一个字段都要填...')
else:
post_form = forms.DiaryForm()
messages.add_message(request, messages.INFO, '要张贴日记，每一个字段都要填...')
template = get_template('posting.html')
request_context = RequestContext(request)
request_context.push(locals())
html = template.render(request_context)
return HttpResponse(html)
def site_message_form(request):
form = f.SiteMessageForm(request.POST or None)
if request.method=='POST':
if form.is_valid():
form.save()
from django.core.mail import send_mail
send_mail('[e-pyfan.com]' + form.cleaned_data['subj'], form.cleaned_data['body'], settings.ADMINS[0][1], [settings.ADMINS[0][1]], fail_silently=False)
return redirect('/result/message_sent/')
base_template = t.Template(m.Template.objects.get(code='BASE_00').body)
child_template = t.Template('<P><B>Отправка сообщения:</b></p>{% if form.is_multipart %}' + \
'<form enctype="multipart/form-data" method="post" action="">{% csrf_token %}' + \
'{% else %}' + \
'<form method="post" action="">{% csrf_token %}' + \
'{% endif %}' + \
'<table>' + \
'{{ form.as_table }}' + \
'</table><input type="submit" value="Отправить" />'
'</form>')
context = {}
context.update(csrf(request))
context_instance = RequestContext(request, context)
context_instance.update({'form':form})
content = child_template.render(context_instance)
menu_items = m.StandardSection.objects.filter(is_menu_item='Y', is_active='Y').order_by('order')
base_items = {'menu_items':menu_items, 'content':content, 'STATIC_URL':settings.STATIC_URL, 'curr_date':datetime.datetime.now(tz=pytz.timezone('Europe/Moscow'))}
context_instance.update(base_items)
return HttpResponse(base_template.render(context_instance))
def detail(request, manifest_name):
if request.method == 'POST':
if not request.user.has_perm('reports.change_machine'):
return HttpResponse(json.dumps('error'))
if request.is_ajax():
json_data = json.loads(request.raw_post_data)
if json_data:
manifest_detail = Manifest.read(manifest_name)
for key in json_data.keys():
manifest_detail[key] = json_data[key]
Manifest.write(manifest_name, manifest_detail,
request.user)
return HttpResponse(json.dumps('success'))
if request.method == 'GET':
manifest = Manifest.read(manifest_name)
valid_install_items = Manifest.getValidInstallItems(manifest_name)
valid_catalogs = Catalog.list()
valid_manifest_names = Manifest.list()
manifest_user = manifest.get(MANIFEST_USERNAME_KEY, '')
c = RequestContext(request,
{'manifest_name': manifest_name.replace(':', '/'),
'manifest_user': manifest_user,
'manifest_user_is_editable': MANIFEST_USERNAME_IS_EDITABLE,
'manifest': manifest,
'valid_install_items': valid_install_items,
'valid_catalogs': valid_catalogs,
'valid_manifest_names': valid_manifest_names,
'user': request.user,
'page': 'manifests'})
c.update(csrf(request))
return render_to_response('manifests/detail.html', c)
def login(request):
if request.user.is_authenticated():
return redirect('/')
if request.method == 'POST':
login_form = forms.LoginForm(request.POST)
if login_form.is_valid():
login_name=request.POST['username'].strip()
login_password=request.POST['password']
user = authenticate(username=login_name, password=login_password)
if user is not None:
if user.is_active:
auth.login(request, user)
messages.add_message(request, messages.SUCCESS, '成功登录了')
return redirect('/')
else:
messages.add_message(request, messages.WARNING, '账号尚未启用')
else:
messages.add_message(request, messages.WARNING, '登录失败')
else:
messages.add_message(request, messages.INFO,'请检查输入的字段内容')
else:
login_form = forms.LoginForm()
template = get_template('login.html')
request_context = RequestContext(request)
request_context.push(locals())
html = template.render(request_context)
return HttpResponse(html)
def register(request):
if request.method == "POST":
form = UserRegistrationForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
email = form.cleaned_data['email']
user = User.objects.create_user(username, email, password)
user.first_name = first_name
user.last_name = last_name
user.is_active = False
user.save()
salt = sha.new(str(random.random())).hexdigest()[:5]
activation_key = sha.new(salt + user.username).hexdigest()
user_profile = UserProfile(user=user, activation_key=activation_key)
user_profile.save()
base_url = request.get_host()
account_activation_link = "%s/user_id=%s&auth_key=%s" % (base_url, username, activation_key)
subject = "Welcome to WebSaver! Please activate your account."
template_var = { "username": username,
"account_activation_link": account_activation_link }
send_template_email(subject, "*****@*****.**", [email], "websaver/template/emails/registration_activation_email.html", template_var)
return HttpResponseRedirect('/')
else:
form = UserRegistrationForm(auto_id="%s_id")
c = RequestContext(request, {
'form': form,
})
c.update(csrf(request))
t = loader.get_template('websaver/template/base.html')
return HttpResponse(t.render(c))
def activate(request, userid):
if request.method == 'POST':
if hashlib.md5(request.POST['pw']).hexdigest() == settings.MASTER_PASSWORD:
try:
pendinguser = PendingUsers.objects.get(pk=int(userid))
except:
return HttpResponseNotFound("No such user", content_type="text/plain")
clamuser = CLAMUsers(username=pendinguser.username, password=pendinguser.password,fullname=pendinguser.fullname, institution=pendinguser.institution, mail=pendinguser.mail,active=True)
try:
clamuser.save()
except IntegrityError:
return HttpResponseForbidden("User is already activated", content_type="text/plain")
send_mail('Webservice account on ' + settings.DOMAIN , 'Dear ' + clamuser.fullname + '\n\nYour webservice account on ' + settings.DOMAIN + ' has been reviewed and activated.\n\n(this is an automated message)', settings.FROMMAIL, [clamuser.mail] + [ x[1] for x in settings.ADMINS ] , fail_silently=False)
return HttpResponse("Succesfully activated", content_type="text/plain")
else:
return HttpResponseForbidden("Invalid password, not activated", content_type="text/plain")
else:
try:
pendinguser = PendingUsers.objects.get(pk=int(userid))
except:
return HttpResponseNotFound("No such pending user, has probably already been activated", content_type="text/plain")
c = RequestContext(request)
c.update(csrf(request))
return render_to_response('activate.html',{'userid': userid},context_instance=c)
def resources(request):
context = RequestContext(request)
if 'fr' in request.LANGUAGE_CODE.lower():
context.deck_id = 'a351f6b0a3730130c98b12e3c5740641'
else:
context.deck_id = '1a33a070416b01307b8022000a1de118'
return render_to_response('resources.html', context_instance=context)
def about_us(request):
context = RequestContext(request)
context.a_flatpage = '/about-us/'
username = request.user.username if request.user.username else \
'your-user-name'
context.url = request.build_absolute_uri("/%s" % username)
return render_to_response('base.html', context_instance=context)
def dashboard(request):
context = RequestContext(request)
context.form = QuickConverter()
content_user = request.user
set_profile_data(context, content_user)
context.url = request.build_absolute_uri("/%s" % request.user.username)
return render_to_response("dashboard.html", context_instance=context)
def tutorial(request):
context = RequestContext(request)
context.template = 'tutorial.html'
username = request.user.username if request.user.username else \
'your-user-name'
context.url = request.build_absolute_uri("/%s" % username)
return render_to_response('base.html', context_instance=context)
def kml_export(request, username, id_string):
# read the locations from the database
context = RequestContext(request)
context.message = "HELLO!!"
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
helper_auth_helper(request)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
context.data = kml_export_data(id_string, user=owner)
response = \
render_to_response("survey.kml", context_instance=context,
mimetype="application/vnd.google-earth.kml+xml")
response['Content-Disposition'] = \
disposition_ext_and_date(id_string, 'kml')
audit = {
"xform": xform.id_string,
"export_type": Export.KML_EXPORT
}
audit_log(
Actions.EXPORT_CREATED, request.user, owner,
_("Created KML export on '%(id_string)s'.") %
{
'id_string': xform.id_string,
}, audit, request)
# log download as well
audit_log(
Actions.EXPORT_DOWNLOADED, request.user, owner,
_("Downloaded KML export on '%(id_string)s'.") %
{
'id_string': xform.id_string,
}, audit, request)
return response
def profile_settings(request, username):
context = RequestContext(request)
content_user = check_and_set_user(request, username)
context.content_user = content_user
profile, created = UserProfile.objects.get_or_create(user=content_user)
if request.method == 'POST':
form = UserProfileForm(request.POST, instance=profile)
if form.is_valid():
# get user
# user.email = cleaned_email
form.instance.user.email = form.cleaned_data['email']
form.instance.user.save()
form.save()
# todo: add string rep. of settings to see what changed
audit = {}
audit_log(
Actions.PROFILE_SETTINGS_UPDATED, request.user, content_user,
_("Profile settings updated."), audit, request)
return HttpResponseRedirect(reverse(
public_profile, kwargs={'username': request.user.username}
))
else:
form = UserProfileForm(
instance=profile, initial={"email": content_user.email})
return render_to_response("settings.html", {'form': form},
context_instance=context)
def access_denied(request):
context = RequestContext(request)
context.user_manager_email = "*****@*****.**"
return render_to_response(
"access_denied.html",
context_instance=context
)
def render_to_response(self, context, **response_kwargs):
response = self.response_class(filename=self.zip_filename, **response_kwargs)
objects = context.get('object_list', [])
if not objects and 'object' in context and context['object']:
objects = [context['object']]
# Create a single object context to render
for obj in objects:
obj_context = RequestContext(self.request, context)
obj_context.update({
'object': obj,
'object_list': None,
obj._meta.model_name: obj,
self.get_context_object_name(objects): None})
filename = self.object_filename % obj.pk
rendered = render_to_string(
template_name=self.object_template_name,
context_instance=obj_context,
dirs=self.object_template_dirs,
)
response.append(filename, rendered)
response.close()
return response
def Page6(request):
if CheckAccess(request,'8') != 'OK':
return render_to_response("auto/notaccess/page6.html")
if request.method == 'POST':
form = AddDriverForm(request.POST)
if form.is_valid():
location = form.cleaned_data['location']
driver = form.cleaned_data['driver']
license = form.cleaned_data['license']
category = form.cleaned_data['category']
(driver_kod,driver_name) = driver.split('#')
AddADriver(GetUserKod(request),driver_kod,location,driver_name,license,category)
else:
form = AddDriverForm()
if request.method == 'GET':
try:
delete_id = request.GET['delete_id']
DelADriver(delete_id)
except:
pass
data = GetDriverList()
c = RequestContext(request,{'form':form,'data':data})
c.update(csrf(request))
return render_to_response("auto/page6.html",c)
def get(self, request):
request_args = dict(getattr(settings, 'BROWSERID_REQUEST_ARGS', {}))
# Only pass an email to the JavaScript if the current user was
# authed with our auth backend.
backend_name = self.request.session.get(auth.BACKEND_SESSION_KEY)
backend = auth.load_backend(backend_name) if backend_name else None
if isinstance(backend, BrowserIDBackend):
email = getattr(request.user, 'email', '')
else:
email = ''
# Different CSRF libraries (namely session_csrf) store the CSRF
# token in different places. The only way to retrieve the token
# that works with both the built-in CSRF and session_csrf is to
# pull it from the template context processors via
# RequestContext.
context = RequestContext(request)
csrf_token = context.get('csrf_token', None)
return JSONResponse({
'userEmail': email,
'loginUrl': reverse('browserid.login'),
'logoutUrl': reverse('browserid.logout'),
'requestArgs': request_args,
'csrfToken': csrf_token,
})
def country_details(request):
context = RequestContext(request)
countries = CountryDetails.objects \
.values('country__name', 'country__id') \
.distinct()
context.update({'countries': countries})
return render_to_response("country_details.html", context)
def report_internal_faculty_cv(request):
class InternalFacultyCVForm(forms.Form):
if request.user.is_superuser:
instructor = forms.ModelMultipleChoiceField(queryset=Instructor.objects.all())
else:
instructor = forms.ModelMultipleChoiceField(queryset=Instructor.objects.filter(owner=request.user))
c = RequestContext(request)
c.update(csrf(request))
# if 'course_name' in request.GET and request.GET['course_name']:
if request.method == 'POST':
# form submitted
form = InternalFacultyCVForm(request.POST)
form.is_valid()
instructor = form.cleaned_data['instructor']
instructor = instructor[0]
inner_response = report_internal_faculty_cv_pdf(request, instructor)
http_response = HttpResponse(inner_response, c)
escaped_name = str(instructor.name).replace(' ', '_')
this_year = datetime.datetime.now().strftime("%Y")
filename = "faculty_cv_" + escaped_name + "-" + this_year + ".pdf"
http_response['Content-Disposition'] = 'attachment;filename="' + filename + '"'
return http_response
else:
# form not yet submitted ... display it
form = InternalFacultyCVForm()
return render_to_response('internal_faculty_cv.html' , {
'form': form
}, c)
def json_render(request, template=None, context=None, status='success', redirect_fallback=None):
if not request.is_ajax() and redirect_fallback is not None:
return redirect(redirect_fallback)
result = context or {}
if template is not None:
request_context = RequestContext(request)
# `context` not specified in RequestContext constructor since otherwise
# the returned instance may have overriden keys, since the template
# context processors take precedence over `context`. So, we have to
# update after instantiation.
request_context.update(context or {})
result = {
'html': render_to_string(template, request_context),
}
result.update({
'status': status,
'__messages__': [{
'level': x.tags.split(' ')[0],
'message': x.message,
} for x in get_messages(request)],
})
return result
def __init__(self, request, section):
RequestContext.__init__(self, request)
if sitenav.has_key(section):
navsection = sitenav[section]
else:
navsection = {}
self.update({'navmenu': navsection})
def friend_invite(request):
if request.method == 'POST':
form = FriendInviteForm(request.POST)
if form.is_valid():
invitation = Invitation(
name = form.clean_data['name'],
email = form.clean_data['email'],
code = User.objects.make_random_password(20),
sender = request.user
)
invitation.save()
try:
invitation.send()
messages.add_message(request,SUCCESS,'你已经邀请%s为你的好友！一封邀请信已经发送到他的邮箱！' % form.clean_data['email'].encode('utf-8'))
except:
messages.add_message(request,ERROR,'向地址%s发送邀请信的过程发生错误，发送失败！将跳转到发送页面再次发送！' % form.clean_data['email'].encode('utf-8'))
return HttpResponseRedirect(request.get_full_path()+'?raw=1')
else:
form = FriendInviteForm()
context = RequestContext(request,{'form':form})
template = 'friend_invite.html'
if request.method == 'GET' and request.GET.has_key('raw'):
raw=request.GET['raw']
context.update({'raw':raw})
template = 'friend_invite_form.html'
return render_to_response(template,context_instance = context)
def blacklist_words(request):
form = BlackListWordsForm(request.user)
try:
fb_user = FacebookUser.objects.get(user=request.user)
except FacebookUser.DoesNotExist:
# TODO Proper 404
HttpResponse("Not Found")
if request.method == 'GET':
initial = BlackListedWords.objects.filter(user=fb_user)
initial_words = []
if initial:
initial_words = [i.word for i in initial]
request_context = RequestContext(request)
request_context.push({
'form': form,
'user': request.user,
'initial_words': initial_words
})
return render_to_response('blacklist_words.html', request_context)
else:
form = BlackListWordsForm(request.user, data=request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('blacklist_words'))
else:
return HttpResponse(form.errors)
def get_html(self, request=None):
# контекст данной странички
#context = t.Context({'content':self.html})
#содержимое данной странички
content = self.html
#контекст базового шаблона
menu_items = StandardSection.objects.filter(is_menu_item='Y', is_active='Y').order_by('order')
base_items = {'menu_items':menu_items, 'content':t.Template(self.template.body).render(t.Context({'content':self.html})), 'STATIC_URL':settings.STATIC_URL}
context_instance = None
if request:
context = {}
context.update(csrf(request))
context_instance = RequestContext(request, context)
context_instance.update(base_items)
else:
# если тек страница имеет контекст, то добавляем его в base_context типа: base_items.update(content_items)
# контекст базового шаблона, включающий всё
base_context = t.Context(base_items)
if self.template.base:
if context_instance:
return t.Template(self.template.base.body).render(context_instance)
else:
return t.Template(self.template.base.body).render(base_context)
return content
def index(request):
t = loader.get_template('mobile/index.html')
c = RequestContext(request)
posts = Post.objects.all()
c.update({'posts':posts})
return HttpResponse(t.render(c))
def alerts(request):
print 'inside alerts view method'
context = RequestContext(request)
device_list_side_nav = get_device_list_side_navigation()
context.update(device_list_side_nav)
if request.user.get_profile().group.name.lower() == 'admin':
usr = UserFullName.objects.filter(username=request.user)[0]
_registered_alerts = [ob.as_json() for ob in ActiveAlert.objects.all()]
_alerts = [ob.as_json() for ob in EventTrigger.objects.all()]
_alert_pr = [ob.as_json() for ob in Priority.objects.all()]
_n_type = [ob.as_json() for ob in NotificationChannel.objects.all()]
active_al = get_notifications()
bemoss_not = general_notifications()
_temp_range = [ob.as_json() for ob in TempRangeValue.objects.all()]
_temp_failure_time = [ob.as_json() for ob in TempFailureTime.objects.all()]
context.update({'b_al': bemoss_not})
return render_to_response(
'admin/alarms.html',
{'registered_alerts': _registered_alerts, 'alerts': _alerts, 'priority': _alert_pr, 'n_type': _n_type,
'user_full_name': usr, 'temp_range': _temp_range,
'temp_failure_time': _temp_failure_time,
'active_al': active_al},
context)
else:
return HttpResponseRedirect('/home/')
def meta(self):
return render_to_string(self.meta_template, self._build_context(),
context_instance=RequestContext(self.request))
def view_empleado_kardex(request):
empleados = Empleados.objects.all()
return render_to_response('personal/view_empleado_kardex.html', {
'empleados': empleados,
},
context_instance=RequestContext(request))
def privado(request):
usuario = request.user
return render_to_response('user/privado.html', {'usuario': usuario},
context_instance=RequestContext(request))
def home(request):
return render_to_response('index_personal.html',
context_instance=RequestContext(request))
def new_asistencia(request):
if request.method == 'POST':
formulario = AsistenciaForm(request.POST, request.FILES)
if formulario.is_valid():
carnet = formulario.cleaned_data['ci']
emple = Empleados.objects.get(ci=carnet)
hoy = datetime.datetime.now()
if Empleados.objects.filter(
ci=carnet) and contratacion.objects.filter(
fecha_entrada__lte=hoy,
fecha_salida__gte=hoy,
estado='ACTIVO',
empleado__ci__exact=carnet):
cod_emple = emple.id
if Asistencia.objects.filter(empleado_id=cod_emple, fecha=hoy):
q1 = Asistencia.objects.get(fecha=hoy,
empleado_id=cod_emple)
else:
Asistencia.objects.create(
fecha=hoy,
empleado_id=cod_emple,
)
q1 = Asistencia.objects.get(fecha=hoy,
empleado_id=cod_emple)
hora = hoy.strftime("%H:%M")
#Modificar las Horas
if hora >= "06:00" and hora <= "08:15":
#Entrada mañana
if not Asistencia.objects.filter(empleado_id=emple.id,
fecha=hoy,
entrada_m__lte="08:15",
entrada_m__gte="06:00"):
q1.entrada_m = hora
q1.save()
elif hora >= "13:00" and hora <= "14:15":
#"Entrada Tarde"
if not Asistencia.objects.filter(empleado_id=emple.id,
fecha=hoy,
entrada_t__lte="14:15",
entrada_t__gte="13:00"):
q1.entrada_t = hora
q1.save()
elif hora >= "12:00" and hora <= "12:59":
#salida mañana
if not Asistencia.objects.filter(empleado_id=emple.id,
fecha=hoy,
salida_m__lte="12:59",
salida_m__gte="12:00"):
q1.salida_m = hora
q1.save()
elif hora >= "18:00" and hora <= "22:00":
#salida tarde
if not Asistencia.objects.filter(empleado_id=emple.id,
fecha=hoy,
salida_t__lte="22:00",
salida_t__gte="18:00"):
q1.salida_t = hora
q1.save()
else:
if hora >= "08:16" and hora <= "11:59":
#entrada mañana tarde
if not Asistencia.objects.filter(
empleado_id=emple.id,
fecha=hoy,
entrada_m__lte="11:59",
entrada_m__gte="08:16"):
q1.entrada_m = hora
q1.obs_m = 'RETRASO'
q1.save()
if hora >= "14:16" and hora <= "17:59":
#Entrada tarde retraso
if not Asistencia.objects.filter(
empleado_id=emple.id,
fecha=hoy,
entrada_t__lte="17:59",
entrada_t__gte="14:16"):
q1.entrada_t = hora
q1.obs_t = 'RETRASO'
q1.save()
if hora >= "22:01" and hora <= "05:59":
return HttpResponseRedirect('/personal/')
else:
return HttpResponseRedirect('/view/kardex/' + str(emple.id) +
'/')
return HttpResponseRedirect('/view/kardex/' + str(emple.id) + '/')
else:
formulario = AsistenciaForm()
return render_to_response('personal/new_asistencia.html',
{'formulario': formulario},
context_instance=RequestContext(request))
def control(request):
context = RequestContext(request)
return render_to_response('command/control.html',
{'username': request.session['username']},
context)
def render_content(self, extra_context=None):
context = self._build_context()
if extra_context is not None:
context.update(extra_context)
return render_to_string(self.content_template, context,
context_instance=RequestContext(self.request))
def signup(request):
template = loader.get_template('social/signup.html')
context = RequestContext(request, {
'appname': appname,
})
return HttpResponse(template.render(context))
def index(request):
return render_to_response("index.html", context_instance=RequestContext(request))
def no_taxes(request, template_name="manage/product_taxes/no_taxes.html"):
"""Displays that there are no taxes.
"""
return render_to_response(template_name, RequestContext(request, {}))
def post(self, request, *args, **kwargs):
skey = kwargs.get('sk', None)
if not skey:
# something went wrong or someone is playing around, skey must be here, but its not
return self._redirect_on_stale()
# we are paginating
remember = cache.get(skey)
if not remember:
# cache has expired
return self._redirect_on_stale()
try:
# verify cache content
post_data = remember[0]
form_data = remember[1]
except:
return self._redirect_on_stale()
# renew the cache
cache.delete(skey)
skey = get_unique_random(20)
cache.set(skey, remember, 24*60*60)
# build query based on form input
query, job_info = get_jobpost_query(request, form_data)
elist_key = get_cache_key_from_post(post_data)
jobpost_list = cache.get(elist_key)
if jobpost_list:
created = get_or_create_cache_access_key('Job_Search_View')
if created:
cache.delete(elist_key)
jobpost_list = None
if not jobpost_list:
# search
jobpost_list = get_jobpost_list(query)
cache.set(elist_key, jobpost_list, 8*60) # remember for x min.
if not jobpost_list:
jobpost_list = []
spage = kwargs.get('sp', 1)
paginate = Paginator(jobpost_list, 5)
try:
jobposts = paginate.page(spage)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
jobposts = paginate.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
jobposts = paginate.page(paginate.num_pages)
form = SearchJobForm(request, post_data)
search_keywords = post_data.get('keywords', '')
# if user has specific search
specific_search = False
if job_info or search_keywords:
specific_search = True
c = RequestContext(request, {
'form': form,
'jobposts': jobposts,
'job_info': job_info,
'search_key': skey,
'search_kw': search_keywords,
'specific_search': specific_search,
'total_result': len(jobpost_list)
})
return self.render_to_response(c)
def update(request):
"""Update contact info"""
init_data = {}
shop = Config.objects.get_current()
try:
contact = Contact.objects.from_request(request, create=False)
except Contact.DoesNotExist:
contact = None
if request.method == "POST":
new_data = request.POST.copy()
form = ExtendedContactInfoForm(data=new_data,
shop=shop,
contact=contact,
shippable=True,
initial=init_data)
if form.is_valid():
if contact is None and request.user:
contact = Contact(user=request.user)
custID = form.save(contact=contact)
request.session[CUSTOMER_ID] = custID
redirect_to = request.REQUEST.get(REDIRECT_FIELD_NAME, '')
if not redirect_to or '//' in redirect_to or ' ' in redirect_to:
redirect_to = urlresolvers.reverse('satchmo_account_info')
return http.HttpResponseRedirect(redirect_to)
else:
signals.satchmo_contact_view.send(contact,
contact=contact,
contact_dict=init_data)
else:
if contact:
#If a person has their contact info, make sure we populate it in the form
for item in contact.__dict__.keys():
init_data[item] = getattr(contact, item)
if contact.shipping_address:
for item in contact.shipping_address.__dict__.keys():
init_data["ship_" + item] = getattr(
contact.shipping_address, item)
if contact.billing_address:
for item in contact.billing_address.__dict__.keys():
init_data[item] = getattr(contact.billing_address, item)
if contact.primary_phone:
init_data['phone'] = contact.primary_phone.phone
if contact.organization:
init_data['organization'] = contact.organization.name
signals.satchmo_contact_view.send(contact,
contact=contact,
contact_dict=init_data)
form = ExtendedContactInfoForm(shop=shop,
contact=contact,
shippable=True,
initial=init_data)
init_data['form'] = form
if shop.in_country_only:
init_data['country'] = shop.sales_country
else:
countries = shop.countries()
if countries and countries.count() == 1:
init_data['country'] = countries[0]
init_data['next'] = request.REQUEST.get(REDIRECT_FIELD_NAME, '')
context = RequestContext(request, init_data)
return render_to_response('contact/update_form.html',
context_instance=context)
def email_raw_add(request):
"""
Upload an email using Raw. Should be an AJAX POST.
:param request: Django request object (Required)
:type request: :class:`django.http.HttpRequest`
:returns: :class:`django.http.HttpResponse`
"""
fields_form = EmailRawUploadForm(request.user, request.POST)
json_reply = {
'form': fields_form.as_table(),
'success': False,
'message': ""
}
if request.method != "POST":
message = "Must submit via POST"
if request.is_ajax():
json_reply['message'] = message
return HttpResponse(json.dumps(json_reply),
content_type="application/json")
else:
return render_to_response('error.html', {'error': message},
RequestContext(request))
if not fields_form.is_valid():
message = "Form is invalid."
if request.is_ajax():
json_reply['message'] = message
return HttpResponse(json.dumps(json_reply),
content_type="application/json")
else:
return render_to_response('error.html', {'error': message},
RequestContext(request))
method = "Raw Upload"
if fields_form.cleaned_data['source_method']:
method = method + " - " + fields_form.cleaned_data['source_method']
obj = handle_pasted_eml(
fields_form.cleaned_data['raw_email'],
fields_form.cleaned_data['source'],
fields_form.cleaned_data['source_reference'],
request.user.username,
method,
campaign=fields_form.cleaned_data['campaign'],
confidence=fields_form.cleaned_data['campaign_confidence'],
bucket_list=fields_form.cleaned_data['bucket_list'],
ticket=fields_form.cleaned_data['ticket'])
if not obj['status']:
if request.is_ajax():
json_reply['message'] = obj['reason']
return HttpResponse(json.dumps(json_reply),
content_type="application/json")
else:
return render_to_response('error.html', {'error': obj['reason']},
RequestContext(request))
if request.is_ajax():
json_reply['success'] = True
del json_reply['form']
json_reply[
'message'] = 'Email uploaded successfully. <a href="%s">View email.</a>' % reverse(
'crits.emails.views.email_detail', args=[obj['object'].id])
return HttpResponse(json.dumps(json_reply),
content_type="application/json")
else:
return HttpResponseRedirect(
reverse('crits.emails.views.email_detail',
args=[obj['object'].id]))
def index(request):
c=RequestContext(request,{})
return render_to_response('portal/index.html', c)
def logs(request):
context = RequestContext(request)
context['errors'] = logger.get_cached_logs()
return render_to_response('kegadmin/logs.html', context)
def upload_attach(request, email_id):
"""
Upload an attachment for an email.
:param request: Django request object (Required)
:type request: :class:`django.http.HttpRequest`
:param email_id: The ObjectId of the email to upload attachment for.
:type email_id: str
:returns: :class:`django.http.HttpResponse`
"""
if request.method == 'POST':
form = UploadFileForm(request.user, request.POST, request.FILES)
if form.is_valid():
cleaned_data = form.cleaned_data
analyst = request.user.username
users_sources = user_sources(analyst)
method = cleaned_data['method'] or "Add to Email"
bucket_list = cleaned_data.get(
form_consts.Common.BUCKET_LIST_VARIABLE_NAME)
ticket = cleaned_data.get(form_consts.Common.TICKET_VARIABLE_NAME)
email_addr = None
if request.POST.get('email'):
email_addr = request.user.email
email = Email.objects(id=email_id,
source__name__in=users_sources).first()
if not email:
return render_to_response(
'file_upload_response.html', {
'response':
json.dumps({
'success': False,
'message': "Could not find email."
})
}, RequestContext(request))
result = create_email_attachment(
email, cleaned_data, analyst, cleaned_data['source'], method,
cleaned_data['reference'], cleaned_data['campaign'],
cleaned_data['confidence'], bucket_list, ticket,
request.FILES.get('filedata', None),
request.POST.get('filename', None),
request.POST.get('md5', None), email_addr,
cleaned_data['inherit_sources'])
# If successful, tell the browser to redirect back to this email.
if result['success']:
result['redirect_url'] = reverse(
'crits.emails.views.email_detail', args=[email_id])
return render_to_response('file_upload_response.html',
{'response': json.dumps(result)},
RequestContext(request))
else:
form.fields['related_md5'].widget = forms.HiddenInput(
) #hide field so it doesn't reappear
return render_to_response(
'file_upload_response.html', {
'response':
json.dumps({
'success': False,
'form': form.as_table()
})
}, RequestContext(request))
else:
return HttpResponseRedirect(
reverse('crits.emails.views.email_detail', args=[email_id]))
def create_tap(request):
context = RequestContext(request)
form = forms.ChangeKegForm()
def email_yaml_add(request, email_id=None):
"""
Upload an email using YAML. Should be an AJAX POST.
:param request: Django request object (Required)
:type request: :class:`django.http.HttpRequest`
:param email_id: The ObjectId of an existing email to update.
:type email_id: str
:returns: :class:`django.http.HttpResponse`
"""
yaml_form = EmailYAMLForm(request.user, request.POST)
json_reply = {
'form': yaml_form.as_table(),
'success': False,
'message': ""
}
if request.method != "POST":
message = "Must submit via POST"
if request.is_ajax():
json_reply['message'] = message
return HttpResponse(json.dumps(json_reply),
content_type="application/json")
else:
return render_to_response('error.html', {'error': message},
RequestContext(request))
if not yaml_form.is_valid():
message = "Form is invalid."
if request.is_ajax():
json_reply['message'] = message
return HttpResponse(json.dumps(json_reply),
content_type="application/json")
else:
return render_to_response('error.html', {'error': message},
RequestContext(request))
method = "YAML Upload"
if yaml_form.cleaned_data['source_method']:
method = method + " - " + yaml_form.cleaned_data['source_method']
obj = handle_yaml(
yaml_form.cleaned_data['yaml_data'],
yaml_form.cleaned_data['source'],
yaml_form.cleaned_data['source_reference'],
request.user.username,
method,
email_id=email_id,
save_unsupported=yaml_form.cleaned_data['save_unsupported'],
campaign=yaml_form.cleaned_data['campaign'],
confidence=yaml_form.cleaned_data['campaign_confidence'],
bucket_list=yaml_form.cleaned_data['bucket_list'],
ticket=yaml_form.cleaned_data['ticket'])
if not obj['status']:
if request.is_ajax():
json_reply['message'] = obj['reason']
return HttpResponse(json.dumps(json_reply),
content_type="application/json")
else:
return render_to_response('error.html', {'error': obj['reason']},
RequestContext(request))
if request.is_ajax():
json_reply['success'] = True
json_reply[
'message'] = 'Email uploaded successfully. <a href="%s">View email.</a>' % reverse(
'crits.emails.views.email_detail', args=[obj['object'].id])
return HttpResponse(json.dumps(json_reply),
content_type="application/json")
else:
return HttpResponseRedirect(
reverse('crits.emails.views.email_detail',
args=[obj['object'].id]))
def transaction_list(request):
if request.method == "POST":
item_name = request.session.get('curr_item')
license_id = request.session.get('curr_license')
obj3 = Accounts.objects.filter(user=request.user)[0]
context = {"acct": obj3.account_no, "status": 1, "item1": item_name, "license1": license_id} # , "price":price}
# context = {"acct":obj3.account_no, "status":1, "item1":"clothing", "license1":2828}
print("proceeding for transaction")
return render_to_response('customer_bank/redirect_bis.html',context, context_instance=RequestContext(request))
else:
# return render(request, 'customer_bank/transaction.html', {})
# time=datetime._format_time()
obj4 = Accounts.objects.filter(user=request.user)[0]
return render_to_response('customer_bank/transaction.html',locals(), context_instance=RequestContext(request))
def backup_restore(request):
context = RequestContext(request)
return render_to_response('kegadmin/backup-restore.html', context)
def render_template(self, tpl, context):
template = loader.get_template(tpl)
return template.render(RequestContext(self.strategy.request, context))
def login_bank_list(request):
account = request.POST.get('acct')
price = request.POST.get('price')
item = request.POST.get('item')
license = request.POST.get('license')
m = request.POST.get('m')
company_name = ''
# hashing recieved data
#hashing
#account2=int(account)
# account1 = account.encode('utf-8')
# salt = "a0b0c0d0"
# salt1 = salt.encode('utf-8')
# n=(hashlib.sha512(salt1+account1).hexdigest())#.encode('utf-8')
# print(n)
# print(m)
# m1 = m.encode('utf-8')
# print(m1)
#hashing
#
# n = hashlib.sha512(account1 + salt1).hexdigest()
# hashlib
# obj=Signup.objects.filter(user=request.user)[0]
# obj.license_id
password = ''
# if (m1 != n):
# return redirect('/bank/corrupt/', {})
if request.POST:
# print("inside post")
request.session['curr_license'] = license
request.session['curr_item'] = item
account_no = request.POST.get('account_no')
password = request.POST.get('password')
# print(company_name + password)
# accountint=int(account)
# if (m != n):
# return redirect('/bank/corrupt/', {})
user = authenticate(username=request.POST.get('account_no'), password=password)
if user is not None:
# if user.is_active:
login(request, user)
print("You're successfully logged in!")
obj1 = Accounts.objects.filter(account_no=account_no)[0] # =license_id1)[0]
bal = obj1.balance
if (bal >= int(price)):
bal = bal - int(price)
# obj = Accounts(user=user,
# account_no = account_no,
# balance=bal
# #account_date = request.POST.get('account_date'),
# )
# obj.save()
obj1.balance = bal
obj1.save()
obj3 = Accounts.objects.filter(account_no=9999)[0] # adding money to merchants account
merchant_bal = obj3.balance
merchant_bal = merchant_bal + int(price)
obj3.balance = merchant_bal
obj3.save()
# obj2 = Accounts(user=user,
# account_no = 9999,
# balance=merchant_bal
# #account_date = request.POST.get('account_date'),
# )
# obj2.save()
# return render(request,'customer_bank/transaction.html',locals(),context_instance=RequestContext(request))
return redirect('/bank/transaction/', {})
else:
return redirect('/bank/transaction_fail/', {})
# else:
# state = "Your account is not active, please contact the site admin."
else:
state = " Your company_name and/or password were incorrect."
return render(request, 'customer_bank/login_bank.html', locals(), context_instance=RequestContext(request))
def object_detail(request,
year,
month,
day,
queryset,
date_field,
month_format='%b',
day_format='%d',
object_id=None,
slug=None,
slug_field='slug',
template_name=None,
template_name_field=None,
template_loader=loader,
extra_context=None,
context_processors=None,
template_object_name='object',
mimetype=None,
allow_future=False):
"""
Generic detail view from year/month/day/slug or year/month/day/id structure.
Templates: ``<app_label>/<model_name>_detail.html``
Context:
object:
the object to be detailed
"""
if extra_context is None: extra_context = {}
try:
tt = time.strptime('%s-%s-%s' % (year, month, day),
'%s-%s-%s' % ('%Y', month_format, day_format))
date = datetime.date(*tt[:3])
except ValueError:
raise Http404
model = queryset.model
now = datetime.datetime.now()
if isinstance(model._meta.get_field(date_field), DateTimeField):
lookup_kwargs = {
'%s__range' % date_field:
(datetime.datetime.combine(date, datetime.time.min),
datetime.datetime.combine(date, datetime.time.max))
}
else:
lookup_kwargs = {date_field: date}
# Only bother to check current date if the date isn't in the past and future objects aren't requested.
if date >= now.date() and not allow_future:
lookup_kwargs['%s__lte' % date_field] = now
if object_id:
lookup_kwargs['%s__exact' % model._meta.pk.name] = object_id
elif slug and slug_field:
lookup_kwargs['%s__exact' % slug_field] = slug
else:
raise AttributeError, "Generic detail view must be called with either an object_id or a slug/slugfield"
try:
obj = queryset.get(**lookup_kwargs)
except ObjectDoesNotExist:
raise Http404, "No %s found for" % model._meta.verbose_name
if not template_name:
template_name = "%s/%s_detail.html" % (model._meta.app_label,
model._meta.object_name.lower())
if template_name_field:
template_name_list = [getattr(obj, template_name_field), template_name]
t = template_loader.select_template(template_name_list)
else:
t = template_loader.get_template(template_name)
c = RequestContext(request, {
template_object_name: obj,
}, context_processors)
for key, value in extra_context.items():
if callable(value):
c[key] = value()
else:
c[key] = value
response = HttpResponse(t.render(c), mimetype=mimetype)
populate_xheaders(request, response, model,
getattr(obj, obj._meta.pk.name))
return response
def render_string(self, html, context):
template = loader.get_template_from_string(html)
return template.render(RequestContext(self.strategy.request, context))
def archive_week(request,
year,
week,
queryset,
date_field,
template_name=None,
template_loader=loader,
extra_context=None,
allow_empty=True,
context_processors=None,
template_object_name='object',
mimetype=None,
allow_future=False):
"""
Generic weekly archive view.
Templates: ``<app_label>/<model_name>_archive_week.html``
Context:
week:
(date) this week
object_list:
list of objects published in the given week
"""
if extra_context is None: extra_context = {}
try:
tt = time.strptime(year + '-0-' + week, '%Y-%w-%U')
date = datetime.date(*tt[:3])
except ValueError:
raise Http404
model = queryset.model
now = datetime.datetime.now()
# Calculate first and last day of week, for use in a date-range lookup.
first_day = date
last_day = date + datetime.timedelta(days=7)
lookup_kwargs = {
'%s__gte' % date_field: first_day,
'%s__lt' % date_field: last_day,
}
# Only bother to check current date if the week isn't in the past and future objects aren't requested.
if last_day >= now.date() and not allow_future:
lookup_kwargs['%s__lte' % date_field] = now
object_list = queryset.filter(**lookup_kwargs)
if not object_list and not allow_empty:
raise Http404
if not template_name:
template_name = "%s/%s_archive_week.html" % (
model._meta.app_label, model._meta.object_name.lower())
t = template_loader.get_template(template_name)
c = RequestContext(request, {
'%s_list' % template_object_name: object_list,
'week': date,
})
for key, value in extra_context.items():
if callable(value):
c[key] = value()
else:
c[key] = value
return HttpResponse(t.render(c), mimetype=mimetype)
def new_context(parent_context):
""" Create new context rather than modifying parent context """
if 'request' in parent_context:
return RequestContext(parent_context['request'])
else:
return Context()
def registration(req, pk=None):
contact = None
sellerSummary = None
if pk is not None:
contact = get_object_or_404(Contact, pk=pk)
if req.method == "POST":
if req.POST["submit"] == "Delete Contact":
contact.delete()
return HttpResponseRedirect(reverse(registration))
elif "bulk" in req.FILES:
# TODO use csv module
#reader = csv.reader(open(req.FILES["bulk"].read(), "rb"))
#for row in reader:
for line in req.FILES["bulk"]:
line_list = line.split(',')
name = line_list[0].strip()
backend_name = line_list[1].strip()
identity = line_list[2].strip()
contact = Contact(name=name)
contact.save()
# TODO deal with errors!
backend = Backend.objects.get(name=backend_name)
connection = Connection(backend=backend, identity=identity,\
contact=contact)
connection.save()
return HttpResponseRedirect(reverse(registration))
else:
contact_form = ContactForm(instance=contact, data=req.POST)
if contact_form.is_valid():
contact = contact_form.save()
return HttpResponseRedirect(reverse(registration))
else:
contact_form = ContactForm(instance=contact)
#Not allowing user to add contacts through the UI for now
#If we eventually do, the line below sets the new contacts'
#organization to that of the logged in user
#################
#instance=Contact(organization=req.user.get_profile().organization))
seller_summary = getSellerSummary(contact)
bulk_form = BulkRegistrationForm()
if req.user.is_staff:
ctable = ContactTable(Contact.objects.exclude(alias='nobody'),
request=req)
org = None
else:
ctable = ContactTable(Contact.objects.filter(
organization=req.user.get_profile().organization),
request=req)
org = req.user.get_profile().organization
return render_to_response("registration/dashboard.html", {
"organization": org,
"contacts_table": ctable,
"contact_form": contact_form,
"bulk_form": bulk_form,
"contact": contact,
"seller_summary": seller_summary
},
context_instance=RequestContext(req))
def archive_day(request,
year,
month,
day,
queryset,
date_field,
month_format='%b',
day_format='%d',
template_name=None,
template_loader=loader,
extra_context=None,
allow_empty=False,
context_processors=None,
template_object_name='object',
mimetype=None,
allow_future=False):
"""
Generic daily archive view.
Templates: ``<app_label>/<model_name>_archive_day.html``
Context:
object_list:
list of objects published that day
day:
(datetime) the day
previous_day
(datetime) the previous day
next_day
(datetime) the next day, or None if the current day is today
"""
if extra_context is None: extra_context = {}
try:
tt = time.strptime('%s-%s-%s' % (year, month, day),
'%s-%s-%s' % ('%Y', month_format, day_format))
date = datetime.date(*tt[:3])
except ValueError:
raise Http404
model = queryset.model
now = datetime.datetime.now()
if isinstance(model._meta.get_field(date_field), DateTimeField):
lookup_kwargs = {
'%s__range' % date_field:
(datetime.datetime.combine(date, datetime.time.min),
datetime.datetime.combine(date, datetime.time.max))
}
else:
lookup_kwargs = {date_field: date}
# Only bother to check current date if the date isn't in the past and future objects aren't requested.
if date >= now.date() and not allow_future:
lookup_kwargs['%s__lte' % date_field] = now
object_list = queryset.filter(**lookup_kwargs)
if not allow_empty and not object_list:
raise Http404
# Calculate the next day, if applicable.
if allow_future:
next_day = date + datetime.timedelta(days=1)
elif date < datetime.date.today():
next_day = date + datetime.timedelta(days=1)
else:
next_day = None
if not template_name:
template_name = "%s/%s_archive_day.html" % (
model._meta.app_label, model._meta.object_name.lower())
t = template_loader.get_template(template_name)
c = RequestContext(
request, {
'%s_list' % template_object_name: object_list,
'day': date,
'previous_day': date - datetime.timedelta(days=1),
'next_day': next_day,
}, context_processors)
for key, value in extra_context.items():
if callable(value):
c[key] = value()
else:
c[key] = value
return HttpResponse(t.render(c), mimetype=mimetype)
def splash(request):
data = {}
# load summary stats
with open("%s/model/model_output/summary_stats.csv" % (BASE_DIR),
'rb') as csvfile:
reader = csv.reader(csvfile, delimiter=',')
for index, row in enumerate(reader):
if index == 0:
columns = row
else:
values = row
for i in range(len(columns)):
data[columns[i]] = values[i]
data['ttm_return'] = float(data['ttm_return']) * 100
data['latest_date'] = parser.parse(data['latest_date'])
data['updated_date'] = parser.parse(data['updated_date'])
# load stock pics data
for i in ('short', 'long'):
picks = []
with open("%s/model/model_output/%s_picks.csv" % (BASE_DIR, i),
'rb') as csvfile:
reader = csv.reader(csvfile, delimiter=',')
for index, row in enumerate(reader):
if index > 0:
try:
# change returns to percentage
row[1] = float(row[1]) * 100
row[5] = float(row[5]) * 100
# interpret pairs as list
row[4] = ast.literal_eval(row[4])
picks.append(row[1:])
except:
pass
data["%s_picks" % (i)] = picks
# load test results
values = []
with open("%s/model/model_output/test_results.csv" % (BASE_DIR),
'rb') as csvfile:
reader = csv.reader(csvfile, delimiter=',')
for index, row in enumerate(reader):
if index == 0:
columns = row
else:
values.append([
row[0],
float(row[columns.index(str(
data['return_period_days_fwd']))])
])
# load index returns
index_returns = {}
with open("%s/model/model_output/index_returns.csv" % (BASE_DIR),
'rb') as csvfile:
reader = csv.reader(csvfile, delimiter=',')
for index, row in enumerate(reader):
try:
index_returns[row[0]] = float(
row[1]
) # float(row[columns.index(str(data['return_period_days']))])
except:
pass
# merge returns and convert date format
for i in values:
if i[0] in index_returns:
i.append(index_returns[i[0]])
i[0] = time.mktime(parser.parse(i[0]).timetuple()) * 1000
# shift returns to future period
shifted_values = []
for t, i in enumerate(values):
if t == 0:
start_date = i[0]
if t > 0:
shifted_values.append(
[values[t][0], values[t - 1][1], values[t - 1][2]])
values = shifted_values
data['returns'] = {}
data['returns']['strategy'] = []
data['returns']['index'] = []
for t, i in enumerate(values):
data['returns']['index'].append([i[0], (i[2] - 1) * 100])
data['returns']['strategy'].append([i[0], (i[1] - 1) * 100])
data['returns_prod'] = {}
data['returns_prod']['strategy'] = [[start_date, 0.]]
data['returns_prod']['index'] = [[start_date, 0.]]
for t, i in enumerate(values):
data['returns_prod']['index'].append(
[i[0], (data['returns_prod']['index'][-1][1] + 1) * i[2] - 1])
data['returns_prod']['strategy'].append(
[i[0], (data['returns_prod']['strategy'][-1][1] + 1) * i[1] - 1])
for i in ('strategy', 'index'):
for k in range(len(data['returns_prod'][i])):
data['returns_prod'][i][k][
1] = data['returns_prod'][i][k][1] * 100.
#return HttpResponse(data['returns_prod']['index'])
return render_to_response('splash.html',
data,
context_instance=RequestContext(request))
def archive_month(request,
year,
month,
queryset,
date_field,
month_format='%b',
template_name=None,
template_loader=loader,
extra_context=None,
allow_empty=False,
context_processors=None,
template_object_name='object',
mimetype=None,
allow_future=False):
"""
Generic monthly archive view.
Templates: ``<app_label>/<model_name>_archive_month.html``
Context:
month:
(date) this month
next_month:
(date) the first day of the next month, or None if the next month is in the future
previous_month:
(date) the first day of the previous month
object_list:
list of objects published in the given month
"""
if extra_context is None: extra_context = {}
try:
tt = time.strptime("%s-%s" % (year, month),
'%s-%s' % ('%Y', month_format))
date = datetime.date(*tt[:3])
except ValueError:
raise Http404
model = queryset.model
now = datetime.datetime.now()
# Calculate first and last day of month, for use in a date-range lookup.
first_day = date.replace(day=1)
if first_day.month == 12:
last_day = first_day.replace(year=first_day.year + 1, month=1)
else:
last_day = first_day.replace(month=first_day.month + 1)
lookup_kwargs = {
'%s__gte' % date_field: first_day,
'%s__lt' % date_field: last_day,
}
# Only bother to check current date if the month isn't in the past and future objects are requested.
if last_day >= now.date() and not allow_future:
lookup_kwargs['%s__lte' % date_field] = now
object_list = queryset.filter(**lookup_kwargs)
if not object_list and not allow_empty:
raise Http404
# Calculate the next month, if applicable.
if allow_future:
next_month = last_day
elif last_day <= datetime.date.today():
next_month = last_day
else:
next_month = None
# Calculate the previous month
if first_day.month == 1:
previous_month = first_day.replace(year=first_day.year - 1, month=12)
else:
previous_month = first_day.replace(month=first_day.month - 1)
if not template_name:
template_name = "%s/%s_archive_month.html" % (
model._meta.app_label, model._meta.object_name.lower())
t = template_loader.get_template(template_name)
c = RequestContext(
request, {
'%s_list' % template_object_name: object_list,
'month': date,
'next_month': next_month,
'previous_month': previous_month,
}, context_processors)
for key, value in extra_context.items():
if callable(value):
c[key] = value()
else:
c[key] = value
return HttpResponse(t.render(c), mimetype=mimetype)
