def check_basket_is_valid(self, request):
"""
Check that the basket is permitted to be submitted as an order. That
is, all the basket lines are available to buy - nothing has gone out of
stock since it was added to the basket.
检查允许将购物篮作为订单提交。 也就是说，所有购物篮行都可以买到 - 因为
它被添加到购物篮里，所以没有任何东西已经缺货。
"""
messages = []
strategy = request.strategy
for line in request.basket.all_lines():
result = strategy.fetch_for_line(line)
is_permitted, reason = result.availability.is_purchase_permitted(
line.quantity)
if not is_permitted:
# Create a more meaningful message to show on the basket page
# 创建更有意义的消息以显示在购物篮页面上
msg = _(
"'%(title)s' is no longer available to buy (%(reason)s). "
"Please adjust your basket to continue"
) % {
'title': line.product.get_title(),
'reason': reason}
# '％（标题）s'不再可供购买（％（原因）s）。 请调整你的购物篮继续
messages.append(msg)
if messages:
raise exceptions.FailedPreCondition(
url=reverse('basket:summary'),
messages=messages
)
def get_document_emails(ipr):
"""Returns a list of messages to inform document authors that a new IPR disclosure
has been posted"""
messages = []
for rel in ipr.iprdocrel_set.all():
doc = rel.document.document
if is_draft(doc):
doc_info = 'Internet-Draft entitled "{}" ({})'.format(
doc.title, doc.name)
else:
doc_info = 'RFC entitled "{}" (RFC{})'.format(
doc.title, get_rfc_num(doc))
addrs = gather_address_lists('ipr_posted_on_doc',
doc=doc).as_strings(compact=False)
author_names = ', '.join(
a.person.name
for a in doc.documentauthor_set.select_related("person"))
context = dict(doc_info=doc_info,
to_email=addrs.to,
to_name=author_names,
cc_email=addrs.cc,
ipr=ipr)
text = render_to_string('ipr/posted_document_email.txt', context)
messages.append(text)
return messages
def register(self, postData):
print 'First name: ', postData['first_name']
messages = []
if (len(postData['first_name']) < 2) and (len(postData['last_name']) <
2):
messages.append(
'First and last name must be longer than two characters')
elif (not NAME_REGEX.match(postData['first_name'])) and (
not NAME_REGEX.match(postData['last_name'])):
messages.append(
'Name cannot contain numbers or special characters')
if not EMAIL_REGEX.match(postData['email']):
messages.append('Please enter a valid email address')
if (len(postData['password']) < 7):
messages.append('Password must be at least 8 characters long')
elif not postData['password'] == postData['confirm_pw']:
messages.append('Passwords must match')
if len(messages) != 0:
return (False, messages)
else:
pw_hash = bcrypt.hashpw(str(postData['password']),
bcrypt.gensalt())
user = User.objects.create(first_name=postData['first_name'],
last_name=postData['last_name'],
email=postData['email'],
password=pw_hash)
return (True, user)
def sendWelcomeEmail(self, request, queryset):
"""Generates a random password for, and sends a welcome e-mail to, the selected users"""
messages = []
subject = get_template('users/email/welcome-email-subject.txt').render(Context({}))
appUrl = request.build_absolute_uri(reverse('webapp:app'))
fromAddr = getattr(settings, 'EMAIL_FROM', None)
for user in queryset:
# Check user has an e-mail address
if user.email == '':
self.message_user(request, 'User %s has no e-mail address' % user.username, ERROR)
continue
# Assign new password
newPassword = User.objects.make_random_password()
user.set_password(newPassword)
user.save()
# Prepare e-mail
context = {
'appUrl': appUrl,
'user': user,
'password': newPassword
}
message = get_template('users/email/welcome-email.txt').render(Context(context))
messages.append((subject, message, fromAddr, [user.email]))
# Send messages
if len(messages) > 0:
sent = send_mass_mail(messages, fail_silently=True)
self.message_user(request, '%d e-mails sent' % sent)
else:
self.message_user(request, 'No e-mails sent', WARNING)
def get_document_emails(ipr):
"""Returns a list of messages to inform document authors that a new IPR disclosure
has been posted"""
messages = []
for rel in ipr.iprdocrel_set.all():
doc = rel.document.document
authors = doc.authors.all()
if is_draft(doc):
doc_info = 'Internet-Draft entitled "{}" ({})'.format(doc.title,doc.name)
else:
doc_info = 'RFC entitled "{}" (RFC{})'.format(doc.title,get_rfc_num(doc))
addrs = gather_address_lists('ipr_posted_on_doc',doc=doc).as_strings(compact=False)
author_names = ', '.join([a.person.name for a in authors])
context = dict(
doc_info=doc_info,
to_email=addrs.to,
to_name=author_names,
cc_email=addrs.cc,
ipr=ipr)
text = render_to_string('ipr/posted_document_email.txt',context)
messages.append(text)
return messages
def send(self, force=False, test=True):
final_receivers = []
if self.pk:
activate_url = re.search(r'\*\|ACTIVATE_URL\|\*', self.template)
archive_url = re.search(r'\*\|ARCHIVE\|\*', self.template)
mc_subject = re.search(r'\*\|MC:SUBJECT\|\*', self.template)
receivers = self.receivers_test if test else self.receivers
receivers = receivers.split(',')
messages = []
irange = 0
for receiver in receivers:
receiver = receiver.strip()
if is_valid_email(receiver):
html = self.template
html = set_mailchimp_vars(html)
if activate_url:
activation_token, created = EmailingUserActivationToken.objects.get_or_create(email=receiver)
html = html.replace(activate_url.group(0), activation_token.get_activate_url() )
# if archive_url:
# html = html.replace(archive_url.group(0), self. )
if mc_subject:
html = html.replace(mc_subject.group(0), self.subject )
html = clean_html_for_email(html)
if not test:
transaction, created = EmailingTransaction.objects.get_or_create(
receiver=receiver,
emailing=self
)
else:
created = True
if irange < self.send_range and (created or transaction.send_count == 0):
message = HtmlTemplateEmail(
subject=self.subject,
sender=self.sender,
receivers=[receiver],
html=html,
)
messages.append(message)
final_receivers.append(receiver)
if not test:
transaction.send_count += 1
transaction.save()
irange += 1
send_mass_email(messages)
if test:
self.test_count += 1
else:
self.send_count += 1
self.save()
return final_receivers
def get_new_message(request):
messages = []
try:
room_id = request.GET.get('room_id')
user = request.user
messagestemp = Message.objects.filter(read='0')
for message in messagestemp:
if int(message.user_id) == int(user.id):
pass
else:
if message.read == "0":
data = {}
data['message_id'] = message.id
data['room_id'] = message.room_id
data['user_name'] = CustomUser.objects.get(
id=message.user_id).username
if CustomUser.objects.get(id=message.user_id).avatar:
data['avatar'] = CustomUser.objects.get(
id=message.user_id).avatar.url
else:
data['avatar'] = ""
data['message'] = message.content
data['created_at'] = get_different_time(message.created_at)
if CustomUser.objects.get(
id=message.user_id).username == user.username:
data['me'] = "1"
else:
data['me'] = "0"
messages.append(data)
else:
pass
return JsonResponse({'messages': messages})
except:
return JsonResponse({'messages': messages})
def questions(request):
if not request.user.is_authenticated():
messageform = None
else:
messageform = MessageForm()
link = Links_Tables.objects.get(Src_name="QUESTIONS", Dst_name="MESSAGES")
metalinks = Metalinks.objects.filter(Link_tables=link)
mess = []
#выбрать все "вопросы", привязанные металинками
for m in metalinks:
mess.append(Message.objects.get(id=m.Dst_id))
messages = []
for m in mess:
req = list(Message.objects.filter(Parent=m))
req.insert(0, m)
messages.append(req)
template = get_template("questions.html")
context = RequestContext(request, {
'messageform': messageform,
'ms': messages
})
return HttpResponse(template.render(context))
def get_posted_emails(ipr):
"""Return a list of messages suitable to initialize a NotifyFormset for
the notify view when a new disclosure is posted"""
messages = []
addrs = gather_address_lists('ipr_posting_confirmation',ipr=ipr).as_strings(compact=False)
context = dict(
to_email=addrs.to,
to_name=ipr.submitter_name,
cc_email=addrs.cc,
ipr=ipr)
text = render_to_string('ipr/posted_submitter_email.txt',context)
messages.append(text)
# add email to related document authors / parties
if ipr.iprdocrel_set.all():
messages.extend(get_document_emails(ipr))
# if Generic disclosure add message for General Area AD
if isinstance(ipr, (GenericIprDisclosure,NonDocSpecificIprDisclosure)):
role = Role.objects.filter(group__acronym='gen',name='ad').first()
context = dict(
to_email=role.email.address,
to_name=role.person.name,
ipr=ipr)
text = render_to_string('ipr/posted_generic_email.txt',context)
messages.append(text)
return messages
def get_posted_emails(ipr):
"""Return a list of messages suitable to initialize a NotifyFormset for
the notify view when a new disclosure is posted"""
messages = []
addrs = gather_address_lists('ipr_posting_confirmation',
ipr=ipr).as_strings(compact=False)
context = dict(to_email=addrs.to,
to_name=ipr.submitter_name,
cc_email=addrs.cc,
ipr=ipr)
text = render_to_string('ipr/posted_submitter_email.txt', context)
messages.append(text)
# add email to related document authors / parties
if ipr.iprdocrel_set.all():
messages.extend(get_document_emails(ipr))
# if Generic disclosure add message for General Area AD
if isinstance(ipr, (GenericIprDisclosure, NonDocSpecificIprDisclosure)):
role = Role.objects.filter(group__acronym='gen', name='ad').first()
context = dict(to_email=role.email.address,
to_name=role.person.name,
ipr=ipr)
text = render_to_string('ipr/posted_generic_email.txt', context)
messages.append(text)
return messages
def get(self, request):
codigos = Codigos.objects.all().exists()
laboratorios = Laboratorio.objects.all().exists()
tipos_estudios = Tipos_Estudios.objects.all().exists()
sub_tipos_estudios = Sub_Tipos_Estudios.objects.all().exists()
nomina = Nomina.objects.all().exists()
messages = []
sub_tipos_estudios_message = 'El administrador no ha resistrado sub tipos de estudios.'
tipos_estudios_message = 'El administrador no ha resistrado tipos de estudios.'
laboratorios_message = 'El administrador no ha resistrado laboratorios.'
codigos_message = 'El administrador no ha resistrado codigos.'
nomina_message = 'El administrador no ha resistrado nomina.'
if not codigos:
messages.append({'message': codigos_message})
if not laboratorios:
messages.append({'message': laboratorios_message})
if not tipos_estudios:
messages.append({'message': tipos_estudios_message})
if not sub_tipos_estudios:
messages.append({'message': sub_tipos_estudios_message})
if not nomina:
messages.append({'message': nomina_message})
print messages
return Response(messages, status=status.HTTP_200_OK)
def send_newsletter(request):
charity = get_object_or_404(Charity, user=request.user)
favorited = charity.favorite.all()
email_list = []
for user in favorited:
email_list.append(user.email)
email_list.append(request.user.email)
if request.method == 'GET':
form = EmailForm()
else:
form = EmailForm(request.POST)
if form.is_valid():
subject = form.cleaned_data['subject']
message = form.cleaned_data['message']
try:
messages = []
for email in email_list:
message_to_send = (charity.charity_name + ': ' + subject,
message, '*****@*****.**',
[email])
messages.append(message_to_send)
#send_mail(charity.charity_name +': '+subject, message, '*****@*****.**', email_list)
send_mass_mail(messages, fail_silently=False)
except BadHeaderError:
return HttpResponse('Invalid header found.')
return redirect('charities:charity_dashboard')
return render(request, "users/charities/email.html", {'form': form})
def post(self, userData):
messages = []
if len(userData['secret_post']) == 0:
messages.append('Enter a valid secret')
return messages
else:
return True
def get_group_messages(request, group):
messages = []
if group == "global":
try:
targetgroup = Chat_group.objects.get(global_group=True)
except:
return HttpResponse(json.dumps(messages))
else:
targetgroup = Chat_group.objects.get(pk=group)
query_data = GroupChatMessage.objects.filter(
group=targetgroup).order_by('-created')[:20]
for item in query_data:
messages.append({
"created": item.created.strftime("%Y-%m-%d %H:%M"),
"message": item.message,
"group": item.group.pk,
"username": item.user.username,
"profile_photo": str(item.user.profile.profile_photo),
"user_id": item.user.pk,
"content_type": item.content_type,
"message_pk": item.pk
})
return HttpResponse(json.dumps(messages))
def get_stored_message_nav(request):
user = request.user
messages = []
try:
roomtemp = Room.objects.filter(who=user.id) | Room.objects.filter(
whom=user.id).order_by('-created_at')
for room in roomtemp:
rows = Message.objects.filter(room_id=room.id).exclude(
user_id=user.id)
if len(messages) < 4:
if rows.count() > 0:
data = {}
count_message = rows.count()
first_message = rows.order_by('-created_at').first()
data['room_id'] = room.id
data['full_name'] = CustomUser.objects.get(
id=first_message.user_id
).first_name + " " + CustomUser.objects.get(
id=first_message.user_id).last_name
if CustomUser.objects.get(id=first_message.user_id).avatar:
data['user_avatar'] = CustomUser.objects.get(
id=first_message.user_id).avatar.url
else:
data['user_avatar'] = ""
data['cnt_message'] = count_message
data['message'] = first_message.content
data['created_at'] = get_different_time(
first_message.created_at)
messages.append(data)
return JsonResponse({'messages': messages})
except:
return JsonResponse({'messages': messages})
def login_page(request, message=None, error=None):
"Displays the login form and handles the login action."
redirect_to = request.GET.get('next', '')
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
auth.login(request, form.cleaned_data['user'])
return HttpResponseRedirect(redirect_to or '/')
else:
form = LoginForm()
info = {
'form': form,
'next': redirect_to,
'site_name': Site.objects.get_current().name,
}
messages = info['messages'] = []
if message:
message.append(message)
url_message = request.GET.get('message')
if url_message:
messages.append(url_message)
if error:
info['reset_error'] = error
return render(request, 'registration/login.html', info)
def save_ajax(request):
if not request.method == 'POST':
return _get_http_response({'errors': 'It is not a POST request'})
adaptor = _get_adaptor(request, 'POST')
if not adaptor:
return _get_http_response({'errors': 'Params insufficient'})
if not adaptor.can_edit():
return _get_http_response({'errors': 'You can not edit this content'})
value = adaptor.loads_to_post(request)
new_data = get_dict_from_obj(adaptor.obj)
form_class = adaptor.get_form_class()
field_name = adaptor.field_name
new_data['in_menus'] = ''
form = form_class(data=new_data, instance=adaptor.obj)
try:
value_edit = adaptor.get_value_editor(value)
value_edit_with_filter = apply_filters(value_edit, adaptor.filters_to_edit)
new_data[field_name] = value_edit_with_filter
if form.is_valid():
adaptor.save(value_edit_with_filter)
return _get_http_response({'errors': False,
'value': adaptor.render_value_edit()})
messages = [] # The error is for another field that you are editing
for field_name_error, errors_field in form.errors.items():
for error in errors_field:
messages.append("%s: %s" % (field_name_error, unicode(error)))
message_i18n = ','.join(messages)
return _get_http_response({'errors': message_i18n})
except ValidationError as error: # The error is for a field that you are editing
message_i18n = ', '.join([u"%s" % m for m in error.messages])
return _get_http_response({'errors': message_i18n})
def process(request, methods=['POST']):
context = {}
try:
request.session['counter'] += 1
except Exception as e:
request.session['counter'] = 1
try:
yourName = request.POST['yourName']
dojoLocation = request.POST['dojoLocation']
favLanguage = request.POST['favLanguage']
comment = request.POST['comment']
except Exception as e:
messages.append("Exception thrown:", str(e))
return redirect('/')
if len(yourName) == 0:
messages.debug(request, 'Your Name can not be blank.')
if len(dojoLocation) == 0:
messages.debug(request, 'Dojo Location can not be blank.')
if len(favLanguage) == 0:
messages.debug(request, 'Fav Language can not be blank.')
if len(comment) == 0:
messages.debug(request, 'Comment can not be blank.')
if len(comment) > 640:
messages.debug(request,
'Comment can not be more thanb 640 characters.')
request.session['yourName'] = yourName
request.session['dojoLocation'] = dojoLocation
request.session['favLanguage'] = favLanguage
request.session['comment'] = comment
return redirect('/results')
def check_basket_is_valid(self, request):
"""
Check that the basket is permitted to be submitted as an order. That
is, all the basket lines are available to buy - nothing has gone out of
stock since it was added to the basket.
"""
messages = []
strategy = request.strategy
for line in request.basket.all_lines():
result = strategy.fetch_for_line(line)
is_permitted, reason = result.availability.is_purchase_permitted(
line.quantity)
if not is_permitted:
# Create a more meaningful message to show on the basket page
msg = _(
"'%(title)s' is no longer available to buy (%(reason)s). "
"Please adjust your basket to continue"
) % {
'title': line.product.get_title(),
'reason': reason}
messages.append(msg)
if messages:
raise exceptions.FailedPreCondition(
url=reverse('basket:summary'),
messages=messages
)
def invite_participants(modeladmin, request, queryset):
messages = []
for user in queryset:
# user = user.user
# print(user.user.pk)
user.is_active = False
current_site = get_current_site(request)
mail_subject = 'Activate your online examinations account.'
message = render_to_string('participants/acc_active_email.html', {
'user': user.user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.user.pk)),
'token':account_activation_token.make_token(user),
})
to_email = user.email
email = EmailMessage(
mail_subject, message, to=[to_email], reply_to=['*****@*****.**'],
headers={'Message-ID': 'foo'},
)
email.content_subtype = "html"
messages.append(email)
connection = mail.get_connection(fail_silently=True)
print(messages)
connection.open()
connection.send_messages(messages)
def get_upsell_messages(self, basket):
offers = Applicator().get_offers(self.request, basket)
messages = []
for offer in offers:
if offer.is_condition_partially_satisfied(basket):
data = {"message": offer.get_upsell_message(basket), "offer": offer}
messages.append(data)
return messages
def reviewers_message(reviewers):
messages = []
for role, reviewers in group_reviewers(reviewers).items():
message = ', '.join(str(reviewer) for reviewer in reviewers)
if role:
message += ' as ' + str(role)
message += '.'
messages.append(message)
return messages
def chatRoom(request, id1, id2):
messages = list()
num = User.objects.latest('id').id
lastmessages = list()
friend = User.objects.get(id=id2).profile.nickname
notices = Notice.objects.filter(user_to=request.user, feed=None)
for notice in notices:
notice.checked = True
notice.save()
for i in range(1, num + 1):
if Message.objects.filter(
user_to_id=i,
user_from_id=id1).count() > 0 and Message.objects.filter(
user_to_id=id1, user_from_id=i).count() > 0:
if Message.objects.filter(user_to_id=i, user_from_id=id1).order_by(
'-created_at')[0].created_at < Message.objects.filter(
user_to_id=id1,
user_from_id=i).order_by('-created_at')[0].created_at:
lastmessages.append(
Message.objects.filter(
user_to_id=id1,
user_from_id=i).order_by('-created_at')[0])
else:
lastmessages.append(
Message.objects.filter(
user_to_id=i,
user_from_id=id1).order_by('-created_at')[0])
elif Message.objects.filter(
user_to_id=i,
user_from_id=id1).count() > 0 and Message.objects.filter(
user_to_id=id1, user_from_id=i).count() == 0:
lastmessages.append(
Message.objects.filter(
user_to_id=i, user_from_id=id1).order_by('-created_at')[0])
elif Message.objects.filter(
user_to_id=i,
user_from_id=id1).count() == 0 and Message.objects.filter(
user_to_id=id1, user_from_id=i).count() > 0:
lastmessages.append(
Message.objects.filter(
user_to_id=id1, user_from_id=i).order_by('-created_at')[0])
for message in Message.objects.filter(user_to_id=id2, user_from_id=id1):
messages.append(message)
for message in Message.objects.filter(user_to_id=id1, user_from_id=id2):
messages.append(message)
return render(
request, 'accounts/chatroom.html', {
'chat_from': id1,
'chat_to': id2,
'lastmessages': lastmessages,
'messages': messages,
'friend': friend
})
def component(request, uuid):
messages = []
fields_saved = False
# get set/field data and initialize dict of form field values
metadata_set, created = models.TransferMetadataSet.objects.get_or_create(
pk=uuid, defaults={'createdbyuserid': request.user.id})
if created:
metadata_set.save()
fields = models.TransferMetadataField.objects.all().order_by('sortorder')
values = {} # field values
options = [] # field options (for value selection)
for field in fields:
if field.optiontaxonomy is not None:
# check for newly added terms
new_term = request.POST.get('add_to_' + field.pk, '')
if new_term != '':
term = models.TaxonomyTerm()
term.taxonomy = field.optiontaxonomy
term.term = new_term
term.save()
messages.append('Term added.')
# load taxonomy terms into option values
optionvalues = ['']
for term in field.optiontaxonomy.taxonomyterm_set.iterator():
optionvalues.append(term.term)
options.append({'field': field, 'options': optionvalues})
# determine whether field should allow new terms to be specified
field.allownewvalue = True
# support allownewvalue
# by loading taxonomy and checked if it's open
try:
field_value = models.TransferMetadataFieldValue.objects.get(
field=field, set=metadata_set)
values[(field.fieldname)] = field_value.fieldvalue
except models.TransferMetadataFieldValue.DoesNotExist:
if request.method == 'POST':
field_value = models.TransferMetadataFieldValue()
field_value.field = field
field_value.set = metadata_set
else:
values[(field.fieldname)] = ''
if request.method == 'POST':
field_value.fieldvalue = request.POST.get(field.fieldname, '')
field_value.save()
fields_saved = True
values[(
field.fieldname
)] = field_value.fieldvalue # override initially loaded value, if any
if fields_saved:
messages.append('Metadata saved.')
return render(request, 'transfer/component.html', locals())
def get_form_message(competition, distance_id, year, insurance_id=None):
totals = get_total(competition, distance_id, year, insurance_id)
if totals:
messages = [_("<div class='entry'>Entry fee: <span>%(entry_fee)s€</span></div>") % totals, ]
if insurance_id:
messages.append(_("<div class='insurance'>Insurance fee: <span>%(insurance_fee)s€</span></div>") % totals)
messages.append(_("<div class='total'>Total: <span>%(total)s€</span></div>") % totals)
else:
messages = [_("This distance isn't available for birth year %(year)s.") % {'year': year}, ]
return messages
def get_form_message(competition, distance_id, year, insurance_id=None):
totals = get_total(competition, distance_id, year, insurance_id)
if totals:
messages = [_("<div class='fs12 fw700 c-white--70 uppercase text-align--right bottom-margin--10'>Entry fee - <span>%(entry_fee)s€</span></div>") % totals, ]
if insurance_id:
messages.append(_("<div class='fs12 fw700 c-white--70 uppercase text-align--right bottom-margin--10'>Insurance fee - <span>%(insurance_fee)s€</span></div>") % totals)
messages.append(_("<div class='fs14 fw700 c-white uppercase text-align--right'>Total - <span class='c-yellow'>%(total)s€</span></div>") % totals)
else:
messages = [_("<div class='fs14 fw700 c-white uppercase text-align--right'>This distance isn't available for birth year %(year)s.</div>") % {'year': year}, ]
return messages
def pastChat(request, uuid):
if request.method == 'POST':
vote_form = whichVote(request.POST, request.FILES)
pastDebate = PastDebates.objects.get(id=uuid)
numUser = vote_form.data['vote']
numUser = numUser[:1]
if numUser == '1':
pastDebate.user1votes = pastDebate.user1votes + 1
pastDebate.save()
else:
pastDebate.user2votes = pastDebate.user2votes + 1
pastDebate.save()
return HttpResponseRedirect("/discourz/debate")
else:
pastDebate = []
otherUsername = ''
topic = ''
user1 = ''
user2 = ''
user1votes = 0
user2votes = 0
category = ''
try:
pastDebate = PastDebates.objects.get(id=uuid)
topic = pastDebate.topic
user1 = pastDebate.user1
user2 = pastDebate.user2
user1votes = pastDebate.user1votes
user2votes = pastDebate.user2votes
category = pastDebate.tags
except PastDebates.DoesNotExist:
raise Http404('Topic does not exist')
chatList = Chat.objects.filter(debates=pastDebate)
usernames = []
messages = []
for chat in chatList:
usernames.append(chat.username)
messages.append(chat.message)
chats = zip(usernames, messages)
context = {
'chats': chats,
'topic': topic,
'user1': user1,
'user2': user2,
'user1votes': user1votes,
'user2votes': user2votes,
'tagList': pastDebate.get_tag_list(),
'uuid': uuid
}
return render(request, 'pastChatTemplate.html', context=context)
def get_upsell_messages(self, basket):
offers = Applicator().get_offers(self.request, basket)
messages = []
for offer in offers:
if offer.is_condition_partially_satisfied(basket):
data = {
'message': offer.get_upsell_message(basket),
'offer': offer
}
messages.append(data)
return messages
def Checkout(request):
trolley = request.session['cart']
if request.method == 'POST':
form = CheckoutForm(request.POST)
details = {}
if form.is_valid():
details['Street_Address'] = form.cleaned_data['Street_Address']
details['Suburb'] = form.cleaned_data['Suburb']
details['City'] = form.cleaned_data['City']
details['ZipCode'] = form.cleaned_data['ZipCode']
cart_account = get_object_or_404(Account, user=request.user)
shoppingcart = ShoppingCartOrder.objects.create(Owner=cart_account)
messages = []
for key, value in trolley.items():
p = Product.objects.get(id=int(value['item_id']))
orderitem = OrderItem.objects.create(
product=p,
quantity=value['quantity'],
attribute=ProductImage.objects.get(id=int(key)).name,
size=value['size'])
shoppingcart.CartOrder.add(orderitem.id)
shoppingcart.save()
messages.append(shoppingcart.ReferenceNumber())
logging.basicConfig(filename='Checkout.log',
level=logging.INFO,
format='%(message)s')
logging.info(f'{messages}')
cart_id = shoppingcart.id
progress_bar = ProgressBar.objects.create(account=cart_account,
cart_id=cart_id)
progress_bar.save()
for item in shoppingcart.CartOrder.all():
obj = item.product
shop = obj.shop
inventory = get_object_or_404(Inventory, shop=shop)
item_id = item.id
inventory.Messages(cart_id, item_id)
request.session['shipping'] = details
request.session['cart'] = {}
request.session.modified = True
#add a flash message here to tell the user their order is being processed and they will
#find their reference number below.
return redirect('account')
else:
form = CheckoutForm()
cost = 0
number = 0
for vars in trolley.values():
cost = cost + int(vars['quantity']) * float(vars['Price'])
request.session['cost'] = cost
request.session.modified = True
number += 1
context = {'form': form, 'cost': cost, 'number': number}
return render(request, 'ecommerce/checkout.html', context)
def check_headers(user_specs):
headers = set(user_specs.fieldnames)
illegal_headers = headers - allowed_headers
missing_headers = required_headers - headers
messages = []
for header_set, label in (missing_headers, 'required'), (illegal_headers, 'illegal'):
if header_set:
messages.append('The following are %s column headers: %s.' % (label, ', '.join(header_set)))
if messages:
raise Exception('\n'.join(messages))
def add(self, content, rating, user, book):
messages = []
if len(content) == 0:
messages.append("Reviews can not be blank!")
return (False, messages)
elif len(content) > 0:
review = Review.reviewsManager.create(content=content,
rating=rating,
user_id=user,
book_id=book)
return (True, review)
def messages(request):
# Remove duplicate messages
messages = []
unique_messages = []
for m in get_messages(request):
if m.message not in messages:
messages.append(m.message)
unique_messages.append(m)
return {
'messages': unique_messages,
'DEFAULT_MESSAGE_LEVELS': DEFAULT_LEVELS,
}
def dw_repeat_task(self):
monthly_users = SpotifyUser.objects.filter(dw_monthly=True)
yearly_users = SpotifyUser.objects.filter(dw_yearly=True)
messages = []
if monthly_users:
for spotify_user in monthly_users:
messages.append(self.dw_monthly_task(spotify_user.user_id))
if yearly_users:
for spotify_user in yearly_users:
messages.append(self.dw_yearly_task(spotify_user.user_id))
return messages
def logout_view(request):
try:
name = request.user.full_name
logout(request)
messages = []
messages.append(
name +
' has successfully logged out. Than you for using the MTA Assistant App!'
)
return render(request, 'Train_Website/landing.html',
{'messages': messages})
except:
return render(request, 'Train_Website/landing.html')
def add(self, title, author):
messages = []
if len(title) == 0:
messages.append("You must enter a book title!")
return (False, messages)
if len(author) == 0:
messages.append("You must enter or select an author!")
return (False, messages)
else:
book = Book.booksManager.create(title=title, author=author)
return (True, book)
def registerA(request):
messages = []
if request.method == 'POST':
form = UserRegisterForm(request.POST)
profile_form = ProfileRegisterForm(request.POST)
if form.is_valid() and profile_form.is_valid():
user = form.save()
profile = profile_form.save(commit=False)
profile.user = user
academic_position = profile_form.cleaned_data.get(
'academic_position')
article_reviewed = profile_form.cleaned_data.get(
'article_reviewed')
keywords = str(random.sample(words, json["keywords_num"]))
keywords = keywords.replace("'", "").replace("]",
"").replace("[", "")
range_a, range_b = json['range']
prices = random.choices(range(range_a, range_b), k=550)
for i, val in enumerate(prices):
if val > json["max"]:
prices[i] = json["max"]
elif val < json["min"]:
prices[i] = json["min"]
prices = str(prices).replace("]", "").replace("[", "")
profile = Profile(user=user,
group='A',
keywords=keywords,
prices=prices,
academic_position=academic_position,
article_reviewed=article_reviewed)
profile.save()
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password1')
user = authenticate(username=username, password=raw_password)
login(request, user)
return redirect('blog-instructionsbefore')
else:
for error in form.errors.values():
messages.append(error[0])
else:
form = UserRegisterForm()
profile_form = ProfileRegisterForm()
context = {
'form': form,
'profile_form': profile_form,
'messages': messages
}
return render(request, 'users/registerA.html', context)
def login(self, email, password):
messages = []
invalid = False
if len(email) < 1:
invalid = True
messages.append("You must enter an email address!")
if len(password) < 1:
invalid = True
messages.append("You must enter a password!")
if invalid:
return (False, messages)
else:
user = Users.usersManager.filter(email = email)
if len(user) == 0:
messages.append('The email submitted does not match our records.')
return (False, messages)
elif bcrypt.checkpw(password.encode(), user[0].password.encode()):
return (True, user[0])
else:
messages.append('Incorrect password!')
return (False, messages)
def show_messages(request):
if request.is_ajax():
username = request.GET.get('user')
user = get_object_or_404(User, username=username)
conversation = Message.objects.filter(
(Q(receiver=request.user) & Q(sender=user)) | (Q(receiver=user) & Q(sender=request.user))).order_by(
'-created_at')[:50]
messages = list()
for message in conversation:
if message.sender == request.user:
messages.append({"user": "******", "message": message.msg_content, "created_at": message.created_at})
else:
messages.append({"user": "******", "message": message.msg_content, "created_at": message.created_at})
return HttpResponse(json.dumps(messages, cls=DjangoJSONEncoder), content_type='application/json')
def insert(request, data):
messages = []
if len(data['title']) == 0:
messages.append('You suck, y u no give title')
if len(data['description']) == 0:
messages.append('Add a message!')
if len(messages) > 0:
return messages
else:
new_note = Note.objects.create(title=data['title'], description=data['description'])
return new_note.id
def person_edit(request, id):
if request.user.is_authenticated:
messages = []
try:
person = Person.objects.get(id=id)
except Person.DoesNotExist:
url = "/person/unknown/"
return HttpResponseRedirect(url)
if request.method == 'POST':
form = PersonForm(request.POST)
if form.is_valid():
data = form.cleaned_data
try:
person = Person(id=id,
name=data['name'],
code=data['code'],
unit=data['unit'],
serial=data['serial'],
id_number=data['id_number'])
person.save()
personLog = PersonLog(user=request.user,
person=person,
name=person.name,
code=person.code,
unit=person.unit,
serial=person.serial,
id_number=person.id_number,
operation='update')
personLog.save()
messages.append('保存成功')
url = "/person/detail/%s" % (id)
return HttpResponseRedirect(url)
except:
messages.append('保存失败')
else:
messages.append('保存失败，请检查输入数据')
return render_to_response('person_edit.html', {
'user': request.user,
'form': form,
'messages': messages
})
else:
messages.append('找到记录')
form = PersonForm(
initial={
'name': person.name,
'code': person.code,
'unit': person.unit,
'serial': person.serial,
'id_number': person.id_number
})
return render_to_response('person_edit.html', {
'user': request.user,
'form': form,
'messages': messages
})
else:
url = "/login/"
return HttpResponseRedirect(url)
def _get(self, *args, **kwargs):
"""
Retrieves a list of stored messages. Returns a tuple of the messages
and a flag indicating whether or not all the messages originally
intended to be stored in this storage were, in fact, stored and
retrieved; e.g., ``(messages, all_retrieved)``.
"""
if not get_user(self.request).is_authenticated():
return super(PersistentMessageStorage, self)._get(*args, **kwargs)
messages = []
for message in self._message_queryset():
if not message.is_persistent():
self.non_persistent_messages.append(message)
messages.append(message)
return (messages, True)
def _get(self, *args, **kwargs):
"""
Retrieves a list of stored messages. Returns a tuple of the messages
and a flag indicating whether or not all the messages originally
intended to be stored in this storage were, in fact, stored and
retrieved: `(messages, all_retrieved)`
This is called by BaseStorage._loaded_messages
"""
if self.is_anonymous:
return super(PersistentMessageStorage, self)._get(*args, **kwargs)
messages = []
for message in self._message_queryset():
if not message.is_persistent():
self.non_persistent_messages.append(message)
messages.append(message)
return (messages, True)
def process_remove_time(self):
"""
Receives the data input in the Time Process view,
retrieves the associated Order Process instance, and
calls helper function to remove the start time of the
retrieved Order Process instance.
"""
# call helper function to process input
order_process, messages = (
OrderController.process_input_time_view(self))
# call helper function to remove time
msg = OrderController.remove_start_time(order_process)
messages.append(msg)
# load context
context = {'order_process': order_process}
# add messages
context['messages'] = messages
return SimpleTemplateResponse(
template='control_produccion/time_processes_result.html',
context=context)
def update_cart(request):
if not request.method == 'POST':
raise Http404
mess = []
try:
quantity = int(request.POST.get('quantity', 1))
product_id = int(request.POST.get('product_id', None))
except ValueError:
mess.append(_('Data entry errors'))
else:
try:
product = Product.objects.get(pk=product_id, is_active=True)
except Product.DoesNotExist:
messages.append(_('Product not found'))
else:
if quantity > 0:
cart = ExtCart(request)
cart.update(product, quantity)
messages.info(request, _("Number of %(name)s updated by %(count)s") % {'name': product.name, 'count': quantity})
return redirect_to_back(request)
def get_messages(self):
days=datetime.timedelta(days=7)
last_week_puppet_errors = db.CIChangePuppet.objects.filter(
ci=self.ci,
time__range=(datetime.datetime.now(), datetime.datetime.now() - days)
).count()
incidents = db.CIIncident.objects.filter(
ci=self.ci,
).count()
problems = db.CIProblem.objects.filter(
ci=self.ci,
).count()
messages=[]
if last_week_puppet_errors:
messages.append(dict(
message="Puppet reported %d errors since last week." % ( last_week_puppet_errors ),
title='Warning',
type='warning',
))
if incidents:
messages.append(dict(
message="This CI has %d incidents." % ( incidents ),
title='Be carefull.',
type='error',
))
if problems:
messages.append(dict(
message="This CI has %d problems." % ( problems ),
title='Be carefull.',
type='error',
))
return messages
def domain_edit(request, domain_id, **kwargs):
messages = []
try:
srv = get_srv(request)
domain = srv.domains.get(domain_id=domain_id)
except Exception as e:
logging.exception(e)
raise Http404
if request.method == 'POST':
form = DomainForm(request.POST)
if form.is_valid():
domain.dns = form.cleaned_data['dns']
domain.shared = form.cleaned_data['shared']
domain.refresh_time = form.cleaned_data['refresh_time']
domain.retry_time = form.cleaned_data['retry_time']
domain.expire_time = form.cleaned_data['expire_time']
domain.minimum_cache_time = form.cleaned_data['minimum_cache_time']
domain.ttl = form.cleaned_data['ttl']
domain.domain_type = form.cleaned_data['domain_type']
domain.allow_transfer = []
for a in form.cleaned_data['allow_transfer'].strip(',').split(','):
domain.allow_transfer.append(a)
domain.masters = []
for m in form.cleaned_data['masters'].strip(',').split(','):
domain.masters.append(m)
srv.session.add(domain)
try:
srv.session.commit()
messages.append(_('Succeed to save data'))
except Exception as e:
srv.log.exception(e)
messages.append(_('Failed to save data'))
else:
messages.append(_('Form contain errors'))
else:
masters = ''
try:
for m in domain.masters:
masters += '%s,' % m
masters = masters.strip(',')
except:
masters = None
try:
allow_transfer = ''
for m in domain.allow_transfer:
allow_transfer += '%s,' % m
allow_transfer = allow_transfer.strip(',')
except:
pass
form = DomainForm(initial = {'shared':domain.shared, 'dns': domain.dns, 'refresh_time' : domain.refresh_time,
'retry_time': domain.retry_time, 'expire_time': domain.expire_time,
'minimum_cache_time': domain.minimum_cache_time, 'ttl':domain.ttl,
'domain_type':domain.domain_type, 'masters': masters, 'allow_transfer': allow_transfer})
form.fields['shared'].initial = domain.shared
form.fields['dns'].initial = domain.dns
print("FORM: %s" % vars(form.fields['dns']))
form.fields['minimum_cache_time'].initial = domain.minimum_cache_time
return render_to_response('renki/domains_edit.html',{'domain':domain, 'form':form, 'messages': messages},
context_instance=RequestContext(request))
def create_fatlink_view(request):
logger.debug("create_fatlink_view called by user %s" % request.user)
if request.method == 'POST':
logger.debug("Post request to create_fatlink_view by user %s" % request.user)
form = FatlinkForm(request.POST)
if 'submit_fat' in request.POST:
logger.debug("Submitting fleetactivitytracking by user %s" % request.user)
if form.is_valid():
fatlink = Fatlink()
fatlink.name = slugify(form.cleaned_data["fatname"])
fatlink.fleet = form.cleaned_data["fleet"]
fatlink.duration = form.cleaned_data["duration"]
fatlink.fatdatetime = timezone.now()
fatlink.creator = request.user
fatlink.hash = ''.join(random.choice(string.ascii_letters + string.digits) for i in range(10))
try:
fatlink.full_clean()
fatlink.save()
except ValidationError as e:
form = FatlinkForm()
messages = []
for errorname, message in e.message_dict.items():
messages.append(message[0].decode())
context = {'form': form, 'errormessages': messages}
return render(request, 'fleetactivitytracking/fatlinkformatter.html', context=context)
else:
form = FatlinkForm()
context = {'form': form, 'badrequest': True}
return render(request, 'registered/fatlinkformatter.html', context=context)
return redirect('auth_fatlink_view')
else:
form = FatlinkForm()
logger.debug("Returning empty form to user %s" % request.user)
context = {'form': form}
return render(request, 'fleetactivitytracking/fatlinkformatter.html', context=context)
def write_review(request):
context = {}
forms = get_forms(request)
if(request.POST.has_key('submit_review')):
form = form_clean(request, forms)
if form._get_errors():
messages = []
errors = form._get_errors()
for key, value in errors.items():
messages.append("%s - %s\t" % (form.fields[key].label, value[0]))
context['review_error'] = messages
context['review_form'] = form
context['section_form'] = None if len(forms) <= 1 else forms[1]
else:
forms = get_forms(request)
if len(forms) > 1:
context['section_form'] = forms[1]
context['review_form'] = forms[0]
return context
if len(forms) > 1:
context['section_form'] = forms[1]
context['review_form'] = forms[0]
return context
def call_api_hybrid_view_for_api(func, request, *args, **kwargs):
response = func(request, *args, **kwargs)
if isinstance(response, APIHybridResponse):
result = OrderedDict(response.get_api_response(request))
messages = []
for message in get_messages(request):
messages.append({
'level': DEFAULT_MESSAGE_TAGS[message.level],
'message': message.message
})
if messages:
result['messages'] = messages
result.move_to_end('messages', last=False)
api_response = APIResponse(result, status=response.status_code)
if request.method == 'GET':
response.add_headers(api_response)
return api_response
elif isinstance(response, HttpResponse) and response.status_code in (304, 412):
# 304 Not Modified, 412 Precondition Failed
return response
raise NoAPIHybridResponse
def _get_alert_messages(self):
"""
Generates 'bootstrap' Alert, Info, etc... messages if any part of
the Hotel's required configuration is not set, and gives the User
a link to navigate to, to set the needed configuration.
"""
messages = []
subaccount = self.hotel.get_subaccount()
if subaccount and not subaccount.active:
messages.append(no_funds_alert()) # 'subaccount' gets deactivated when there's
# isufficient funds
if not self.hotel.customer:
messages.append(no_customer_alert())
if not self.hotel.twilio_ph_sid:
messages.append(no_twilio_phone_number_alert())
return messages
def request_invite(request):
#messages = []
if request.method == 'POST':
form = RequestInviteForm(request.POST)
if form.is_valid():
email = form.cleaned_data.pop('email')
username = form.cleaned_data.pop('username')
firstname = form.cleaned_data.pop('first_name')
lastname = form.cleaned_data.pop('last_name')
reason = form.cleaned_data.pop('reason_for_requesting_an_account')
affiliation = form.cleaned_data.pop('affiliation')
project_description = form.cleaned_data.pop('project_description')
how_did_you_hear_about_us = form.cleaned_data.pop('how_did_you_hear_about_us')
policy_agree = form.cleaned_data.pop('agree_to_data_policy')
response_field = request.POST.get("recaptcha_response_field")
challenge_field = request.POST.get("recaptcha_challenge_field")
try:
client_ip = request.META['HTTP_X_FORWARDED_FOR']
except:
client_ip = request.META['REMOTE_ADDR']
print client_ip
message = 'Email: ' + email + '\n' + \
'Username: '******'\n' + \
'First name: ' + firstname + '\n' + \
'Last name: ' + lastname + '\n' + \
'Reason: ' + reason + '\n' + \
'affiliation: ' + affiliation + '\n' + \
'project_description: ' + project_description +'\n'+\
'how_did_you_hear_about_us: ' + how_did_you_hear_about_us + '\n'+\
'agree_to_data_policy: ' + str(policy_agree) + '\n'
params = urllib.urlencode ({
'privatekey': encode_if_necessary(CAPTCHA_PRIVATE_KEY),
'remoteip' : encode_if_necessary(client_ip),
'challenge': encode_if_necessary(challenge_field),
'response' : encode_if_necessary(response_field),
})
captcha_verify = urllib2.Request (
url = "http://www.google.com/recaptcha/api/verify",
data = params,
headers = {
"Content-type": "application/x-www-form-urlencoded",
"User-agent": "CoralNet"
}
)
httpresp = urllib2.urlopen (captcha_verify)
return_values = httpresp.read ().splitlines ();
httpresp.close();
return_code = return_values [0]
try:
if (return_code == "true"):
mail_admins('User Account Requested', message)
messages.success(request, 'Your request was sent!')
# messages.append('Your request was sent!')
return HttpResponseRedirect(reverse('request_account_confirm'))
else:
messages.error(request, 'Invalid Captcha')
except BadHeaderError:
messages.append('Invalid header found.')
else:
messages.error(request, 'Make sure all fields are entered and valid.')
else:
form = RequestInviteForm()
return render_to_response('requests/request_invite.html', {
'form': form,
'public_key': CAPTCHA_PUBLIC_KEY,
},
context_instance=RequestContext(request)
)
_('<a href="{async_url}">{name}</a> is running on the background'),
_('<a href="{async_url}">{async} backends</a> are running on the background'),
async)
if errors:
if total == 1:
msg = _('<a href="{url}">{name}</a> has fail to execute')
else:
msg = ungettext(
_('<a href="{url}">{errors} out of {total} backends</a> has fail to execute'),
_('<a href="{url}">{errors} out of {total} backends</a> have fail to execute'),
errors)
if async_msg:
msg += ', ' + str(async_msg)
msg = msg.format(errors=errors, async=async, async_url=async_url, total=total, url=url,
name=log.backend)
messages.append(('error', msg + '.'))
elif successes:
if async_msg:
if total == 1:
msg = _('<a href="{url}">{name}</a> has been executed')
else:
msg = ungettext(
_('<a href="{url}">{successes} out of {total} backends</a> has been executed'),
_('<a href="{url}">{successes} out of {total} backends</a> have been executed'),
successes)
msg += ', ' + str(async_msg)
else:
msg = ungettext(
_('<a href="{url}">{name}</a> has been executed'),
_('<a href="{url}">{total} backends</a> have been executed'),
total)
def home(request):
form_class = ContactForm
category_list = Category.objects.order_by('-id').reverse()
work_list = Job.objects.order_by('-id').reverse()
context = {'category_list': category_list, 'work_list': work_list}
errors = []
messages = []
# new logic!
if request.method == 'POST':
form = form_class(data=request.POST)
if form.is_valid():
contact_name = request.POST.get('contact_name', '')
contact_email = request.POST.get('contact_email', '')
form_content = request.POST.get('content', '')
# Add message to database
contact = Contact(name=contact_name, message=form_content, sender=contact_email)
contact.save()
# # Email the message
# template = get_template('commons/contact_template.txt')
# mail_context = Context({
# 'contact_name': contact_name,
# 'contact_email': contact_email,
# 'content': form_content,
# })
#
# content = template.render(mail_context)
# send_mail(
# 'Subject here',
# content,
# '*****@*****.**',
# ['*****@*****.**'],
# fail_silently=False,
# )
sg = sendgrid.SendGridAPIClient(apikey=os.environ.get("SENDGRID_API_KEY"))
from_email = Email("*****@*****.**")
to_email = Email("*****@*****.**")
subject = "I've seen your Website!"
content = Content(form_content + "\n\n Contact name: " + contact_name + " Email:" + contact_email)
mail = Mail(from_email, subject, to_email, content)
response = sg.client.mail.send.post(request_body=mail.get())
print(response.status_code)
print(response.body)
print(response.headers)
messages.append('Form submission successful!')
else:
errors.append('Form not properly submitted!')
context = {'category_list': category_list, 'work_list': work_list, 'messages':messages, 'errors':errors}
return render(request, 'commons/home.html', context)
def tick(cls):
"""
Tick the game state forward one day.
"""
from messaging.models import Message
# Resolve auctions.
auctioned_items = Item.objects.filter(id__in=ItemBid.objects.filter(day=GameDay.get_day()).values('item'))
for item in auctioned_items:
bids = ItemBid.objects.filter(day=GameDay.get_day(), item=item, character__alive=True).order_by('-amount')
winning = bids[0]
winner = winning.character
winning.won = True
winning.resolved = True
winning.save()
NodeEvent.objects.create(
where=winning.node,
who=winner,
day=GameDay.get_day(),
type=EVENT_AUCTION,
who_disguised=bids[0].disguised
)
Message.mail_to(winner, "Congratulations! You won %s!" % item.name,
"You've won %s at a cost of %s.<br />Here's what you've won:<br/><br/>%s"
% (item.name, winning.amount, item.post_buy), sender="Bakaara Market")
losers = bids[1:]
for loser in losers:
loser.won = False
loser.resolved = True
loser.save()
Message.mail_to(loser.character, "Sorry, you didn't win %s." % item.name,
"You didn't win %s. Add %s back to your budget. Better luck next time!"
% (item.name, loser.amount), sender="Bakaara Market")
item.valid = False
item.save()
for char in Character.objects.all():
char.points = char.market_stat()
char.save()
for w in CharNodeWatch.objects.filter():
messages = []
events = {0:set(), 1:set(), 2:set()}
for e in NodeEvent.objects.filter(where=w.node, day=GameDay.get_day()):
events[0].update([e])
nodes = set()
for n in w.node.get_all_neighbors():
for e in NodeEvent.objects.filter(where=n, day=GameDay.get_day()):
if not e in events[0]:
events[1].update([e])
nodes.update(n.get_all_neighbors())
for n in nodes:
for e in NodeEvent.objects.filter(where=n, day=GameDay.get_day()):
if not e in events[0] or e in events[1]:
events[2].update([e])
for ed in events:
for e in events[ed]:
messages.append(e.display_for(ed, w.char))
random.shuffle(messages)
Message.mail_to(w.char, "Agent report from %s" % w.node.name,
"I saw the following things: <ul>" + "".join(("<li>%s</li>" % a) for a in messages) + "</ul>",
sender="Bakaara Market")
for item in Item.objects.filter(valid=True):
if item.rarity_class == RARITY_SCARCE:
num_purchase_events = NodeEvent.objects.filter(day__gte=(GameDay.get_day() - 1), item=item).count()
if num_purchase_events > 0:
if reduce(lambda a, b: a or b,
[random.random() < item.rarity_prob for _foo in range(num_purchase_events)],
False): # Roll num_purchase_events random()s. If any come up True, item vanishes. So sad.
item.valid = False
item.save()
gameday = GameDay.objects.get()
gameday.day += 1
gameday.save()
debug("TICK. Day is now %d." % gameday.day)
def get_and_delete_messages(self):
messages = []
for m in self.message_set.all():
messages.append(m.message)
m.delete()
return messages
def messages_ctx(request):
messages = []
for message in RequestContext(request)['messages']:
message = dict(tags=message.tags, message=message.message)
messages.append(message)
return messages
def handle_form(self, form, files):
action = form.cleaned_data['action']
path = form.cleaned_data['path']
name = form.cleaned_data['name']
ufile = form.cleaned_data['ufile']
file_or_dir = form.cleaned_data['file_or_dir']
self.current_path = form.cleaned_data['current_path']
messages = []
if name and file_or_dir == 'dir' and not re.match(r'[\w\d_ -]+', name).group(0) == name:
messages.append(_('Invalid folder name') + ' : ' + name)
return messages
if name and file_or_dir == 'file' and (
re.search('\.\.', name) or not re.match(r'[\w\d_ -.]+', name).group(0) == name):
messages.append(_('Invalid file name') + ' : ' + name)
return messages
if not re.match(r'[\w\d_ -/]+', path).group(0) == path:
messages.append(_('Invalid path') + ' : ' + path)
return messages
if action == 'upload':
for f in files.getlist('ufile'):
if re.search('\.\.', f.name) or not re.match('[\w\d_ -/.]+', f.name).group(0) == f.name:
messages.append(_('File name is not valid') + ' : ' + f.name)
elif f.size > self.maxfilesize * 1024:
messages.append(_('File size exceeded') + ' ' + str(self.maxfilesize) + " KB : " + f.name)
elif (settings.FILEMANAGER_CHECK_SPACE and
((self.get_size(self.basepath) + f.size) > self.maxspace * 1024)):
messages.append(_('Total Space size exceeded') + ' ' + str(self.maxspace) + " KB : " + f.name)
elif self.extensions and len(f.name.split('.')) > 1 and f.name.split('.')[-1] not in self.extensions:
messages.append(_('File extension not allowed') + ' (.' + f.name.split('.')[-1] + ') : ' + f.name)
elif self.extensions and len(f.name.split('.')) == 1 and f.name.split('.')[-1] not in self.extensions:
messages.append(_('No file extension in uploaded file') + ' : ' + f.name)
else:
filepath = self.basepath + path + self.rename_if_exists(self.basepath + path, f.name)
with open(filepath, 'wb') as dest:
for chunk in self.read_in_chunks(f):
dest.write(chunk)
f.close()
if len(messages) == 0:
messages.append(_('All files uploaded successfully'))
elif action == 'add':
os.chdir(self.basepath)
no_of_folders = len(list(os.walk('.')))
if (no_of_folders + 1) <= self.maxfolders:
try:
os.chdir(self.basepath + path)
os.mkdir(name)
messages.append(_('Folder created successfully') + ' : ' + name)
except:
messages.append(_('Folder couldn\'t be created') + ' : ' + name)
else:
messages.append(_('Folder couldn\' be created because maximum number of folders exceeded') + ' : ' +
str(self.maxfolders))
elif action == 'rename' and file_or_dir == 'dir':
oldname = path.split('/')[-2]
path = os.sep.join(path.split('/')[:-2])
try:
os.chdir(self.basepath + path)
os.rename(oldname, name)
messages.append(_('Folder renamed successfully from') + ' ' + oldname + ' ' + _('to') + ' ' + name)
except:
messages.append(_('Folder couldn\'t renamed to') + ' ' + name)
elif action == 'delete' and file_or_dir == 'dir':
if path == '/':
messages.append(_('Root folder can\'t be deleted'))
else:
name = path.split('/')[-2]
path = os.sep.join(path.split('/')[:-2])
try:
os.chdir(self.basepath + path)
shutil.rmtree(name)
messages.append(_('Folder deleted successfully') + ' : ' + name)
except:
messages.append(_('Folder couldn\'t deleted') + ' : ' + name)
elif action == 'rename' and file_or_dir == 'file':
oldname = path.split('/')[-1]
old_ext = oldname.split('.')[1] if len(oldname.split('.')) > 1 else None
new_ext = name.split('.')[1] if len(name.split('.')) > 1 else None
if old_ext == new_ext:
path = os.sep.join(path.split('/')[:-1])
try:
os.chdir(self.basepath + path)
os.rename(oldname, name)
messages.append(_('File renamed successfully from') + ' ' + oldname + ' ' + _('to') + ' ' + name)
except:
messages.append(_('File couldn\'t be renamed to') + ' ' + name)
else:
if old_ext:
messages.append(_('File extension should be same') + ' : .' + old_ext)
else:
messages.append(_('New file extension didn\'t match with old file extension'))
elif action == 'delete' and file_or_dir == 'file':
if path == '/':
messages.append(_('Root folder can\'t be deleted'))
else:
name = path.split('/')[-1]
path = os.sep.join(path.split('/')[:-1])
try:
os.chdir(self.basepath + path)
os.remove(name)
messages.append(_('File deleted successfully') + ' : ' + name)
except:
messages.append(_('File couldn\'t deleted') + ' : ' + name)
elif action == 'move' or action == 'copy':
# from path to current_path
if self.current_path.find(path) == 0:
messages.append(_('Cannot move/copy to a child folder'))
else:
path = os.path.normpath(path) # strip trailing slash if any
if os.path.exists(self.basepath + self.current_path + os.path.basename(path)):
messages.append(_('ERROR: A file/folder with this name already exists in the destination folder.'))
else:
if action == 'move':
method = shutil.move
else:
if file_or_dir == 'dir':
method = shutil.copytree
else:
method = shutil.copy
try:
method(self.basepath + path, self.basepath + self.current_path + os.path.basename(path))
except:
messages.append(_('File/folder couldn\'t be moved/copied.'))
return messages
