def email_template_test_send(request, template_id):
et = EMailTemplate.get_by_id(int(template_id))
if et is None:
raise Http404
if request.method == 'POST':
form = EMailAddressForm(request.POST)
if form.is_valid():
to_a = form.cleaned_data['address']
logging.info('test send template id %d, to: %s', et.key().id(), to_a)
try:
email = EmailMessage(et.data)
email.sender = getConfig('DEFAULT_SENDER')
email.to = to_a
email.check_initialized()
if getConfigBool("ENABLE_MAIL_TEST",False):
logging.info('sending...')
email.send()
else:
logging.info('disabled')
except:
logging.info("can't init email! %s"%sys.exc_info()[1])
return HttpResponse("can't init email - %s"%sys.exc_info()[1])
return redirect('..')
else:
form = EMailAddressForm()
return render_to_response('emails/email_template_test_send.html', RequestContext(request, { 'form' : form, 'et':et}))
def pdf_test(request):
from utils.pdf import pdftest
from utils.config import getConfig
pdf = pdftest(getConfig('PDF_TEST_TEXT'))
r = HttpResponse(pdf,mimetype='application/pdf')
r['Content-Disposition'] = 'attachment; filename=pdf_test.pdf'
return r
def cron_daily(request):
logging.info('cron daily')
if getConfig('REPORT_DAILY_SUMMARY'):
do_accounts_report()
else:
logging.info('daily summary report disabled (cfg key: REPORT_DAILY_SUMMARY)')
if getConfig('REPORT_DAILY_TRANSACTIONS'):
do_trans_reports()
else:
logging.info('daily transactions report disabled (cfg key: REPORT_DAILY_TRANSACTIONS)')
if request.cron_request:
logging.info('HttpResponse ok')
return HttpResponse('ok')
return render_to_response('reports/cron.html', RequestContext(request))
def captcha_test(request):
from utils.captcha import displayhtml,submit
last_result = '?'
if request.method == 'POST':
challenge = request.POST['recaptcha_challenge_field']
response = request.POST['recaptcha_response_field']
remoteip = os.environ['REMOTE_ADDR']
logging.info("challenge=%s, response=%s, remoteip=%s"%(challenge,response,remoteip))
resp = submit(challenge, response, getConfig('CAPTCHA_PRIVATE_KEY',''), remoteip)
if resp.is_valid:
logging.info('OK')
last_result = 'OK'
else:
logging.info('ERROR')
last_result = 'ERROR'
html_captcha = displayhtml(getConfig('CAPTCHA_PUBLIC_KEY',''))
return render_to_response('utils/captcha.html', RequestContext(request, { 'html_captcha': html_captcha , 'last_result':last_result}))
def parse_email(request, file_key):
data = get_blob_data(file_key)
if data is None:
raise Http404
r = ""
email = EmailMessage(data)
# fix_encoding(email)
email.check_initialized()
email.sender = getConfig("MAIL_TEST_FROM")
email.to = getConfig("MAIL_TEST_TO")
if getConfigBool("ENABLE_MAIL_TEST",False):
logging.info('sending email....')
email.send()
r = email.to_mime_message()
return HttpResponse('parse ok - %s'%r)
def send_mail_to_admins(subject='',message=''):
logging.info('sending mail to admin')
sender = getConfig('ADMIN_EMAIL')
if not sender:
logging.info('missing admin email address (cfg key: ADMIN_EMAIL)')
return
if not mail.is_email_valid(sender):
logging.info('admin email is not valid')
#mail.send_mail(admin,admin,subject,message)
mail.send_mail_to_admins(sender, subject,message)
return
def email_job_create(request):
email_groups = EMailList.all()
email_templates = EMailTemplate.all()
if request.method == 'POST':
form = EMailJobCreateForm(request.POST,email_groups=email_groups, email_templates=email_templates)
if form.is_valid():
logging.info('creating new job request')
el = EMailList.get(form.cleaned_data['email_group_id'])
if el is None:
raise Http404
et = EMailTemplate.get(form.cleaned_data['email_template_id'])
if et is None:
raise Http404
job = EMailJob()
job.name = "'%s' -> '%s'"%(et.name,el.name)
job.save()
job_data = EMailJobData(parent=job)
job_data.sender = getConfig('DEFAULT_SENDER')
job_data.split_count = getConfigInt('MAIL_SPLIT_COUNT',10)
job_data.emails = el.emails
job_data.data = et.data
job_data.save()
job.data_ref = job_data.key()
job.save()
logging.info('new job: %s'%job)
taskqueue.add(url='/tasks/prepare_email_job/%d/'%job.key().id(), method='GET')
return redirect('..')
else:
form = EMailJobCreateForm(email_groups=email_groups, email_templates=email_templates)
return render_to_response('emails/email_job_create.html', RequestContext(request, { 'form': form}))
def send_mail_to_user(subject='',message='', user=None):
logging.info('sending mail to user')
sender = getConfig('ADMIN_EMAIL')
if not sender:
logging.info('missing admin email address (cfg key: ADMIN_EMAIL)')
return
if not mail.is_email_valid(sender):
logging.info('admin email is not valid')
return
if not user:
logging.info('missing recipient email address')
return
if not mail.is_email_valid(user):
logging.info('recipient email is not valid')
return
mail.send_mail(sender, user, subject,message)
return
def firstPlay(bank=None, type_='french', minimum_bet=1, maximum_bet=10000, break_=False):
global currentBank, withColors
# Get config
conf = config.getConfig()
# Override bank if necessary
if bank:
config.update('bank', bank)
#LastPos = random.randint(0, 37)
#CounterClock = True
# Vars
currentBank = float(conf['bank']) # Set the default bank
# Create the roulette wheel with colors
withColors = addColors(french if type_ == 'french' else american)
play(type_=type_,
minimum_bet=minimum_bet,
maximum_bet=maximum_bet,
break_=break_)
import json
import os
import random
import shutil
import time
import threading
import PIL
from PIL import Image
import requests
from utils.config import getConfig
__CONFIG_LOC__ = 'config/config.json'
config = getConfig(__CONFIG_LOC__)
extensions = set()
class ThreadClass(object):
def __init__(self, interval=300):
self.interval = interval
thread = threading.Thread(target=self.run, args=())
thread.daemon = True # Daemonize thread
thread.start() # Start the execution
def run(self):
""" Method that runs forever """
while True:
get_list_files()
def clearance_edit(request, clearance_id):
clearance = Clearance.get_by_id(int(clearance_id))
if clearance is None:
raise Http404
if getConfig('CLEARANCE_ALL_ORDER_ITEMS',0):
logging.info('showing all order items!')
order_item_query = OrderItem.objects.all().filter('date =', clearance.date)
else:
order_item_query = OrderItem.objects.all().filter('date =', clearance.date).filter('clearance_item_ref =', None)
c_pick_form = None
c_give_form = None
c_del_form = None
c_clear_form = None
c_load_form = None
c_deposit_form = None
pick_accounts = Account.objects.all().filter('purpose =', 'user').fetch(100)
give_accounts = Account.objects.all().filter('purpose =', 'credit').fetch(100)
if request.method == 'POST':
logging.info(request.POST)
if request.POST['action'] == 'update':
c_form = ClearanceForm(request.POST)
if c_form.is_valid():
clearance.date = c_form.cleaned_data['date']
clearance.desc = c_form.cleaned_data['desc']
clearance.save()
if request.POST['action'] == 'pick_item':
order_items = order_item_query.fetch(100)
c_pick_form = ClearanceItemPickForm(request.POST,accounts=pick_accounts,order_items=order_items)
if c_pick_form.is_valid():
logging.info('c_pick_form is valid!')
order_item = OrderItem.get(c_pick_form.cleaned_data['order_item_id'])
account = Account.get(c_pick_form.cleaned_data['account_id'])
logging.info('account = %s'%account)
logging.info('order_item = %s'%order_item)
if order_item is None:
raise Http404
if account is None:
raise Http404
ci = ClearanceItem(parent=clearance)
ci.account = account
ci.order_item = order_item
ci.cost = order_item.cost
ci.desc = order_item.name
ci.purpose='pick'
ci.save()
order_item.clearance_item_ref = ci.key()
order_item.save()
c_pick_form = None
if request.POST['action'] == 'give_item':
c_give_form = ClearanceItemGiveForm(request.POST, give_accounts)
if c_give_form.is_valid():
logging.info('c_give_form is valid!')
account = Account.get(c_give_form.cleaned_data['account_id'])
logging.info('account = %s'%account)
if account is None:
raise Http404
ci = ClearanceItem(parent=clearance)
ci.account = account
ci.cost = int(c_give_form.cleaned_data['cost'])
ci.purpose='give'
ci.save()
c_give_form = None
if request.POST['action'] == 'load_item':
c_load_form = ClearanceItemLoadForm(request.POST, give_accounts)
if c_load_form.is_valid():
logging.info('c_load_form is valid!')
account = Account.get(c_load_form.cleaned_data['account_id'])
logging.info('account = %s'%account)
if account is None:
raise Http404
ci = ClearanceItem(parent=clearance)
ci.account = account
ci.cost = int(c_load_form.cleaned_data['cost'])
ci.purpose='load'
ci.desc = c_load_form.cleaned_data['desc']
ci.save()
c_load_form = None
if request.POST['action'] == 'deposit_item':
c_deposit_form = ClearanceItemDepositForm(request.POST, pick_accounts)
if c_deposit_form.is_valid():
logging.info('c_deposit_form is valid!')
account = Account.get(c_deposit_form.cleaned_data['account_id'])
logging.info('account = %s'%account)
if account is None:
raise Http404
ci = ClearanceItem(parent=clearance)
ci.account = account
ci.cost = int(c_deposit_form.cleaned_data['cost'])
ci.purpose='deposit'
ci.desc = c_deposit_form.cleaned_data['desc']
ci.save()
c_deposit_form = None
if request.POST['action'] == 'del_item':
c_list = ClearanceItem.objects.all().ancestor(clearance).fetch(100)
c_del_form = ClearanceItemDelForm(request.POST, items = c_list)
if c_del_form.is_valid():
logging.info('c_del_form is valid!')
clearance_item = ClearanceItem.get(c_del_form.cleaned_data['item_id'])
if clearance_item is None:
raise Http404
if not (clearance_item.order_item is None):
logging.info('unmark %s'%clearance_item.order_item)
clearance_item.order_item.clearance_item_ref=None
clearance_item.order_item.save()
clearance_item.delete()
c_del_form = None
if request.POST['action'] == 'clear_item':
c_list = ClearanceItem.objects.all().ancestor(clearance).fetch(100)
c_clear_form = ClearanceItemClearForm(request.POST, items = c_list)
if c_clear_form.is_valid():
logging.info('c_clear_form is valid!')
clearance_item = ClearanceItem.get(c_clear_form.cleaned_data['item_id'])
if clearance_item is None:
raise Http404
c_clear_form = None
c_form = ClearanceForm({'date':clearance.date, 'desc':clearance.desc})
c_list = ClearanceItem.objects.all().ancestor(clearance).fetch(100)
cost_pick = sum([i.cost for i in c_list if i.purpose=='pick'])
cost_give = sum([i.cost for i in c_list if i.purpose=='give'])
cost_load = sum([i.cost for i in c_list if i.purpose=='load'])
cost_deposit = sum([i.cost for i in c_list if i.purpose=='deposit'])
cost_diff = cost_pick - cost_give
cost_put_diff = cost_deposit - cost_load
logging.info('cost_pick=%d, cost_give=%d'%(cost_pick,cost_give))
if c_pick_form is None:
order_items = order_item_query.fetch(100)
c_pick_form = ClearanceItemPickForm(accounts=pick_accounts,order_items=order_items)
if c_give_form is None:
c_give_form = ClearanceItemGiveForm(accounts=give_accounts,cost = cost_pick-cost_give)
if c_del_form is None:
c_del_form = ClearanceItemDelForm(items = c_list)
if c_clear_form is None:
c_clear_form = ClearanceItemClearForm(items = c_list)
if c_load_form is None:
c_load_form = ClearanceItemLoadForm(accounts=give_accounts, cost = cost_put_diff)
if c_deposit_form is None:
c_deposit_form = ClearanceItemDepositForm(accounts=pick_accounts)
return render_to_response('vital/clearance_edit.html', RequestContext(request,
{'c_form':c_form, 'c_list':c_list, 'c_pick_form': c_pick_form, 'c_give_form': c_give_form, 'c_del_form':c_del_form,
'cost_pick':cost_pick, 'cost_give':cost_give, 'cost_diff':cost_diff, 'c_clear_form':c_clear_form,
'c_load_form':c_load_form, 'c_deposit_form':c_deposit_form,
'cost_load':cost_load, 'cost_deposit':cost_deposit, 'cost_put_diff':cost_put_diff,
}))
