def put(self, request):
"""Receive a rows from data table and add to existing google sheet & add to DB"""
body_unicode = request.body.decode('utf-8')
data = json.loads(body_unicode)
user_id = settings.DEFAULT_USER
if isinstance(data['tableRows'], list):
spread_sheet = gc.open(data['title'])
wks = spread_sheet[0]
for row in data['tableRows']:
data_dict = dict(zip(data['tableKeys'], row))
data_dict.update({'user_id': user_id})
exists_db = Transaction.objects.filter(
date=data_dict.get('date'),
amount=data_dict.get('amount'),
location=data_dict.get('location'),
user_id=user_id
)
if not exists_db:
wks.append_table(values=row)
transaction = Transaction(**data_dict)
transaction.save()
return JsonResponse({'success': 'true'}, status=200)
return JsonResponse({'success': 'false'}, status=400)
def parse_transaction(byte_stream):
byte_stream = streamify_if_bytes(byte_stream)
version_bytes = byte_stream.read(4)
version = int.from_bytes(version_bytes, "little")
num_inputs = decode_varint(byte_stream)
# a 0x00 here is the Segwit marker
is_segwit = num_inputs == 0
if is_segwit:
# next byte is flag
_ = byte_stream.read(1)[0] # should be nonzero (0x01 currently)
num_inputs = decode_varint(byte_stream)
inputs = [parse_input(byte_stream) for _ in range(num_inputs)]
num_outputs = decode_varint(byte_stream)
outputs = [parse_output(byte_stream, n) for n in range(num_outputs)]
if is_segwit:
witnesses = [parse_witness(byte_stream) for _ in range(num_inputs)]
for input_, witness in zip(inputs, witnesses):
input_.witness = witness
locktime_bytes = byte_stream.read(4)
locktime = int.from_bytes(locktime_bytes, "little")
transaction = Transaction(version=version, locktime=locktime)
return transaction, inputs, outputs
def create_transaction(request):
user_id = request.user.id
try:
account = Account.objects.get(pk=request.POST['account_id'],
user_id=user_id)
envelope = Envelope.objects.get(pk=request.POST['envelope_id'],
user_id=user_id)
except:
raise Http404('Not found')
amount = float(request.POST['amount'])
if 'subtract' in request.POST:
amount = amount * -1.00
try:
transaction = Transaction(account=account,
envelope=envelope,
date=request.POST['date'],
amount=amount)
except (KeyError):
messages.add_message(request, messages.ERROR,
'Something squiffy happened.')
return render(request, 'envelopes/index.html')
else:
transaction.save()
messages.add_message(request, messages.SUCCESS, 'Transaction added.')
return HttpResponseRedirect(
reverse('envelopes:detail', args=(envelope.id, )))
def calculate_interest():
accounts = BorrowerBankAccount.objects.filter(
balance__gt=0,
interest_start_date__gte=timezone.now(),
initial_deposit_date__isnull=False).select_related('account_type')
this_month = timezone.now().month
created_transactions = []
updated_accounts = []
for account in accounts:
if this_month in account.get_interest_calculation_months():
interest = account.account_type.calculate_interest(account.balance)
account.balance += interest
account.save()
transaction_obj = Transaction(account=account,
transaction_type=INTEREST,
amount=interest)
created_transactions.append(transaction_obj)
updated_accounts.append(account)
if created_transactions:
Transaction.objects.bulk_create(created_transactions)
if updated_accounts:
BorrowerBankAccount.objects.bulk_update(updated_accounts, ['balance'])
def create(self, validated_data):
"""Custom `create()` method to set the `created_by` value."""
_data = self._handle_related_fields(validated_data)
instance = Transaction(**_data)
instance.created_by = self.context['request'].user
instance.updated_by = self.context['request'].user
instance.save()
return instance
def __init__(self):
self.transaction = Transaction()
self.transaction.date = self.__random_date__()
self.transaction.description = self.__random_string__()
self.transaction.amount = self.__random_decimal__()
self.transaction.current_balance = self.__random_decimal__()
self.transaction.date_imported = self.__random_date__()
self.transaction.custom_date_1 = self.__random_date__()
self.transaction.custom_text_1 = self.__random_string__()
def cancel(request):
try:
selected_session = Session.objects.get(pk=request.POST['choice'])
except (KeyError, Session.DoesNotExist):
# Redisplay the session voting form.
return render(request, 'session_list.html', {
'error_message': "You didn't select a session.",
})
else:
if (selected_session.start_time - timezone.now() <=
datetime.timedelta(hours=24)):
return render(request, 'session_list.html', {
'error_message':
"Cannot cancel sessions in coming 24 hours.",
})
else:
student = Student.objects.get(student=request.user)
amount = selected_session.tutor.hourlyRate * 1.05
w = Wallet.objects.get(owner=student.student)
w.balance += Decimal(amount)
new_trans = Transaction(owner=request.user,
amount=amount,
timestamp=timezone.now())
endtime = str(selected_session.end_time)
body = 'Dear ' + selected_session.tutor.tutor.get_full_name(
) + ',\n' + 'A session booked by ' + selected_session.student.student.get_full_name(
) + ' from ' + str(selected_session.start_time) + ' to ' + str(
selected_session.end_time
) + ' is cancelled. Go to Tutoria Homepage to check it out.\nTutoria'
mail.send_mail('A session is cancelled', body, '*****@*****.**',
[selected_session.tutor.tutor.email])
body = 'Dear ' + selected_session.student.student.get_full_name(
) + ',\n' + 'A session taught by ' + selected_session.tutor.tutor.get_full_name(
) + ' from ' + str(selected_session.start_time) + ' to ' + str(
selected_session.end_time
) + ' is cancelled. Your wallet value now is: $' + str(
w.balance
) + '. Go to Tutoria Homepage to check it out.\nTutoria'
mail.send_mail('A session is cancelled', body, '*****@*****.**',
[selected_session.student.student.email])
unavail = NotAvailableSlot.objects.get(
tutor=selected_session.tutor,
start_time=selected_session.start_time,
end_time=selected_session.end_time)
unavail.delete()
selected_session.delete()
new_trans.save()
student.save()
w.save()
# Always return an HttpResponseRedirect after successfully dealing
# with POST data. This prevents data from being posted twice if a
# user hits the Back button.
return render(request, 'cancelok.html')
def create_transactions(self, user):
from decimal import Decimal
from os import urandom
import binascii
from random import randrange
user_transactions = [
Transaction(value=Decimal(randrange(10, 100000)) / 100,
type_transaction=int(randrange(0, 2)),
name=binascii.hexlify(urandom(16)),
wallet=user.wallet) for i in range(30)
]
Transaction.objects.bulk_create(user_transactions)
def create_transaction(document_uploaded, transaction_date, debit, credit,
balance):
transaction = Transaction(transaction_doc=document_uploaded)
print transaction
print "saving now...."
transaction.transaction_date = transaction_date
transaction.debit = debit
transaction.credit = credit
transaction.balance = balance
print transaction
transaction.save()
def createTransaction(instance, methodType, exchangeCoin, valueInvested, pricePerToken):
transaction = Transaction()
transaction.transaction_method = methodType
transaction.exchange_coin = exchangeCoin
transaction.user = User.objects.get(username='******')
transaction.n_tokens = valueInvested
transaction.price_per_token = pricePerToken
transaction.fees = 0
transaction.date = timezone.now()
transaction.synced_transaction = None
transaction.save()
return transaction
def save_transaction(self, serializer):
t = Transaction()
t.origin = serializer.validated_data["origin"]
t.destination = serializer.validated_data["destination"]
t.ammount = serializer.validated_data["ammount"]
t.coin_type = serializer.validated_data["coin_type"]
if t.origin.balance - t.ammount < 0:
raise Exception("El origen no tenia fondos")
t.origin.balance = t.origin.balance - t.ammount
t.destination.balance = t.destination.balance + t.ammount
t.origin.save()
t.destination.save()
serializer.save()
def refill(cls, date, account, envelopes, amount, immutable=None):
if len(envelopes) < 1:
raise ValueError('No envelopes to be filled.')
ratio = 1.0
total = 0.0
for envelope in envelopes:
total += float(envelope.monthly_budget)
if total > amount:
if immutable:
raise ValueError(
'Not enough funds to refill the given envelopes.')
else:
ratio = amount / total
transactions = 0
for envelope in envelopes:
transaction_amount = round(
float(envelope.monthly_budget) * ratio, 2)
if transaction_amount > 0.0:
amount -= transaction_amount
transaction = Transaction(account=account,
envelope=envelope,
date=date,
amount=transaction_amount)
transaction.save()
transactions += 1
if amount > 0.0:
transaction = Transaction(account=account,
date=date,
amount=round(amount, 2))
transaction.save()
transactions += 1
return transactions
def post(self, **kwargs):
tx = Transaction()
data = kwargs.get('data')
userP = UserProfile.objects.get(
user_external_reference=data['user_id'])
data['user_id'] = userP.user
field_names = [
name for name in tx._meta.get_all_field_names() if name in data
]
for name in field_names:
setattr(tx, name, data[name])
tx.save()
return tx
def apiRemCardBonus(request, card_code, salt):
t_type = Operations.bonus_reduce
if request.method == 'POST':
data = request.POST
if ('key' in data) and ('session_key' in data):
box = check_license(data['key'], data['session_key'])
if box:
try:
org = box.co_unit.org
except:
return HttpResponse(status=403)
org = None
else:
return HttpResponse(status=403)
if org is not None:
if org.is_active:
try:
if 'value' in data:
trans = Transaction().create(data)
trans.date = datetime.now()
card = Card.objects.get(code=card_code, org=org.pk)
trans.bonus_before = card.get_total_bonus()
# пишем статистику
trans.org = org
trans.card = card
trans.sum = 0
trans.bonus_reduce = float(data['value'])
trans.type = t_type
trans.save()
value = float(data['value'])
rem_bonus(card, value)
return HttpResponse(data['value'])
else:
return HttpResponse(status='404')
except ObjectDoesNotExist as e:
return HttpResponse(status='404')
else:
return HttpResponse(status='503')
else:
return HttpResponse(status='503')
else:
return HttpResponse(status='503')
def post(self, request, format=None):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = User.objects.create_user(
serializer.data['email'],
request.data['password'],
firstname=serializer.data['firstname'],
lastname=serializer.data['lastname'],
is_children=False
)
token = Token.objects.get(user=user)
# Create a Family instance
family = Family(user=user)
family.save()
# Create a FamilyMember
familyMember = FamilyMember(user=user, family=family)
familyMember.save()
# Set balance of the current account to 1000 and an initial transaction
account = Account.objects.filter(user=user).first()
newBalance = 1000
transaction = Transaction(
account_to=account,
account_from=account,
amount=newBalance,
date_validated=datetime.now()
)
transaction.save()
Account.objects.filter(user=user).update(balance=newBalance)
return Response({
'status': status.HTTP_200_OK,
'token': token.key,
})
else:
return Response({
"status": status.HTTP_404_NOT_FOUND,
'message': serializer.errors,
}, status=status.HTTP_404_NOT_FOUND)
def form_valid(self, form):
account_name = form.cleaned_data['account_name']
initial_balance = form.cleaned_data['initial_balance']
date = form.cleaned_data['date']
account_type = form.cleaned_data['account_type']
balance_description = 'initial'
form.instance.user = self.request.user
self.object = form.save()
account_record = Account.objects.filter(account_name=account_name,
user=self.request.user.id)
print('account record:')
print(account_record)
category = Category.objects.filter(category='Initial Balance',
user=self.request.user.id)
print(category)
new_record = AccountBalance(account=account_record[0],
balance_description=balance_description,
balance=initial_balance,
balance_date=date.date())
new_record.save()
initial_balance_transaction = Transaction(
user=self.request.user,
store=account_name,
description=balance_description,
amount=initial_balance,
trans_date=date.date(),
category=category[0],
account_name=account_record[0])
initial_balance_transaction.save()
new_record_history = AccountHistory(
user=self.request.user,
account=account_record[0],
transaction=initial_balance_transaction,
date=date,
balance=initial_balance)
new_record_history.save()
total_budget_left = 0
print(initial_balance_transaction)
return super().form_valid(form)
def create_transaction(request):
account = get_object_or_404(Account, pk=request.POST['account_id'])
envelope = get_object_or_404(Envelope, pk=request.POST['envelope_id'])
amount = request.POST['amount']
if 'subtract' in request.POST:
amount = float(amount) * -1.00
try:
transaction = Transaction(account=account,
envelope=envelope,
date=request.POST['date'],
amount=amount)
except (KeyError):
messages.add_message(request, messages.ERROR,
'Something squiffy happened.')
return render(request, 'accounts/index.html')
else:
transaction.save()
messages.add_message(request, messages.SUCCESS, 'Transaction added.')
return HttpResponseRedirect(
reverse('accounts:detail', args=(account.id, )))
def prepare_transaction(self, transactions: list):
for transaction_data in transactions:
transaction_data["user_id"] = self.user_id
yield Transaction(**transaction_data)
def processBtcTransactions(FreezedCurrency):
r = {
"processed_addresses": 0,
"created_transactions": [],
"errors_transactions": [],
"errors_addresses": []
}
allWallets = Wallet.objects.filter()
for wallet in allWallets:
for btcAddress in wallet.getWalletToCcAddresses(currency='BTC'):
r['processed_addresses'] += 1
atm = AtmBtc(btcAddress.address.address)
btcAddress.address.address = atm.clean(btcAddress.address.address)
try:
addressRemoteTransactions = atm.getTransactions()
except Exception, ex:
addressRemoteTransactions = []
r['errors_addresses'].append("%s" % (traceback.format_exc()))
if len(addressRemoteTransactions) > 0:
for art in addressRemoteTransactions:
if art.get("error"):
r['errors_addresses'].append(
"failed get data for address: %s" %
(btcAddress.address.address))
else:
if art['positive'] and art['confirmations'] > 0:
try:
new = False
try:
transaction = Transaction.objects.get(
hash=art['hash'],
currency="BTC",
address=btcAddress.address)
except Transaction.DoesNotExist:
previousCredit = wallet.credit
transaction = Transaction()
transaction.hash = art['hash']
transaction.date = art['date']
transaction.type = 'deposit'
transaction.currency = 'BTC'
transaction.freezedUsd = FreezedCurrency.usd
transaction.freezedEur = FreezedCurrency.eur
transaction.amount = art['value']
transaction.wallet = wallet
transaction.address = btcAddress.address
transaction.save()
# update wallet credit
feePercentage = Configuration(
).getConfiguration(
"btc_deposit_percentage")
wallet.depositIn(
FreezedCurrency, transaction,
art['value'],
'by AtmBtc found new tx: %s with positive amount: %s (BTC)'
% (art['hash'], art['value']),
feePercentage)
new = True
#all good
# create transactions info btc
transactionInfo = TransactionInfo()
transactionInfo.transaction = transaction
transactionInfo.description = 'Currency Rate Date: %s' % strftime(
FreezedCurrency.dateUpdated,
'%Y-%m-%d %H:%M:%S')
transactionInfo.save()
transactionInfo = TransactionInfo()
transactionInfo.transaction = transaction
transactionInfo.description = 'BTC -> USD'
transactionInfo.cost = FreezedCurrency.usd
transactionInfo.save()
transactionInfo = TransactionInfo()
transactionInfo.transaction = transaction
transactionInfo.description = 'BTC -> EUR'
transactionInfo.cost = FreezedCurrency.eur
transactionInfo.save()
transactionInfo = TransactionInfo()
transactionInfo.transaction = transaction
transactionInfo.description = 'Previous Credit'
transactionInfo.cost = previousCredit
transactionInfo.save()
transactionInfo = TransactionInfo()
wallet = Wallet.objects.get(id=wallet.id)
transactionInfo.transaction = transaction
transactionInfo.description = 'Current Credit'
transactionInfo.cost = wallet.credit
transactionInfo.save()
except Exception, ex:
transaction = None
r['errors_transactions'].append(
"failed insert for transaction: %s" %
(art['hash']))
if new:
if transaction:
if not any(x.hash == art['hash'] for x in
r['created_transactions']):
r['created_transactions'].append(
transaction)
# Admin Notification
adminNotification = Notification()
adminNotification.email = True
adminNotification.user = User.objects.get(
username="******")
adminNotification.setEmailData(
"New BTC deposit transaction confirmed",
"notifications/email/admin_email_new_deposit_transaction_confirmed.html",
{
'transaction': transaction,
})
def form_valid(self, form):
ok = True
the_student = Student.objects.get(student=self.request.user)
the_tutor = Tutor.objects.get(pk=self.kwargs['tutor_id'])
notAvailable = NotAvailableSlot.objects.filter(tutor=the_tutor)
st = form.instance.start_time
et = st + datetime.timedelta(minutes=the_tutor.timePerSlot)
for slot in notAvailable:
if (slot.start_time <= st) and (slot.end_time >= et):
ok = False
messages.error(self.request,
'Crashed with Tutor Unavailable Slots.')
if ok:
mylist = Session.objects.filter(student=the_student)
for booking in mylist:
if (booking.start_time.date() == st.date()) and (booking.tutor
== the_tutor):
ok = False
messages.error(
self.request,
'Cannot book more than one slot of same tutor in a day.'
)
if (st - timezone.now() <= datetime.timedelta(hours=24)):
ok = False
messages.error(self.request,
'Cannot book session within coming 24 hours.')
if (st - timezone.now() > datetime.timedelta(days=7)):
ok = False
messages.error(self.request,
'Cannot book further than 7 days.')
if (Wallet.objects.get(owner=the_student.student).balance <
(the_tutor.hourlyRate) * 1.05):
ok = False
messages.error(self.request, 'You do not have enough money.')
if (st.time() < datetime.time(hour=9)) or (et.time() >
datetime.time(hour=22)):
ok = False
messages.error(
self.request,
'Exceeded allowable time range. 9am-10pm only.')
if ok:
form.instance.student = the_student
form.instance.tutor = the_tutor
form.instance.end_time = et
w = Wallet.objects.get(owner=the_student.student)
new_unavail = NotAvailableSlot(tutor=the_tutor,
start_time=st,
end_time=et)
w.balance = w.balance - Decimal((the_tutor.hourlyRate) * 1.05)
new_trans = Transaction(owner=self.request.user,
amount=(-(the_tutor.hourlyRate) * 1.05),
timestamp=timezone.now())
body = 'Dear ' + the_tutor.tutor.get_full_name(
) + ',\n' + 'A session is booked by ' + the_student.student.get_full_name(
) + ' from ' + str(st) + ' to ' + str(
et) + '. Go to Tutoria Homepage to check it out.\nTutoria'
mail.send_mail('A session is booked', body, '*****@*****.**',
[the_tutor.tutor.email])
body = 'Dear ' + the_student.student.get_full_name(
) + ',\n' + 'A session taught by ' + the_tutor.tutor.get_full_name(
) + ' from ' + str(st) + ' to ' + str(
et) + ' is booked. Your wallet value now is: $' + str(
w.balance
) + '. Go to Tutoria Homepage to check it out.\nTutoria'
mail.send_mail('A session is cancelled', body, '*****@*****.**',
[the_student.student.email])
new_trans.save()
new_unavail.save()
the_student.save()
w.save()
return super(MakeBooking, self).form_valid(form)
else:
return super(MakeBooking, self).form_invalid(form)
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "discountServer.settings")
try:
import django
except ImportError:
# The above import may fail for some other reason. Ensure that the
# issue is really that Django is missing to avoid masking other
# exceptions on Python 2.
raise
django.setup()
from queues.models import Task
from cards.models import Card
from core.models import DiscountPlan
from transactions.models import Transaction
from datetime import datetime
cards = Card.objects.filter(org_id__exact=3)
d_plan = DiscountPlan.objects.get(org_id__exact=3)
for card in cards:
print(card.code)
_handler = __import__('core.lib.%s' % d_plan.algorithm, globals(), locals(),
['count'], 0)
card = _handler.count(0, card, d_plan, Transaction())
card.save()
print('New discount = %s.' % card.discount)
def count(value, card, d_plan, transaction):
try:
parameters = json.loads(d_plan.parameters)
except:
return None
if type(parameters) is not dict:
return None
value = float(value)
if 'bonus_mechanism' in parameters:
bonus_mechanism = parameters['bonus_mechanism']
else:
return None
if bonus_mechanism == 'bonus_cost':
if 'bonus_cost' in parameters:
bonus_cost = float(parameters['bonus_cost'])
else:
return None
if bonus_mechanism == 'bonus_percent':
if 'bonus_percent' in parameters:
bonus_percent = float(parameters['bonus_percent'])
else:
return None
if 'min_transaction' in parameters:
min_transaction = float(parameters['min_transaction'])
else:
return None
if 'bonus_lifetime' in parameters:
bonus_lifetime = float(parameters['bonus_lifetime'])
else:
return None
if 'round' in parameters:
rounding = parameters['round']
else:
return None
if abs(value) < min_transaction:
return card
bonus = Bonus()
bonus.date = transaction.date
bonus.active_from = datetime.now() + relativedelta(days=d_plan.time_delay)
bonus.card = card
if bonus_mechanism == 'bonus_cost':
bonus.value = custom_round((value / bonus_cost), rounding)
elif bonus_mechanism == 'bonus_percent':
bonus.value = custom_round((value * bonus_percent / 100), rounding)
bonus.active_to = bonus.active_from + relativedelta(
months=int(bonus_lifetime))
bonus.enabled = False
bonus.transaction_id = transaction.pk
trans = Transaction(org=card.org,
card=card,
date=datetime.now(),
bonus_before=card.get_total_bonus(),
doc_number=transaction.doc_number,
session=transaction.session,
sum=transaction.sum,
shop=transaction.shop,
workplace=transaction.workplace)
if value < 0:
trans.type = Operations.bonus_refund
refund_bonus(card, transaction.base_doc_date, -bonus.value)
trans.bonus_add = bonus.value
trans.save()
return card
else:
trans.type = Operations.bonus_add
trans.bonus_add = bonus.value
trans.save()
task = Task(queue_date=datetime.now(),
execution_date=datetime.now().date() +
relativedelta(days=d_plan.time_delay),
data=transaction.sum,
card=card,
operation="bonus",
d_plan=d_plan,
transaction=trans,
org=card.org)
task.save()
bonus.task_id = task.pk
bonus.save()
return card
def rest_add_bonus(request, card_code):
response = {}
if request.method == 'PUT':
user = UserCustom.objects.get(user_id__exact=request.user.pk)
bonus_data = json.loads(request.body.decode())
if not user.administrator:
response['status'] = 'error'
response['message'] = "Недостаточно прав!"
return JsonResponse(response, status=503)
try:
card = Card.objects.get(org_id__exact=user.org.pk,
code__exact=card_code)
except:
response['status'] = 'error'
response['message'] = "Карта с таким кодом не найдена!"
return JsonResponse(response, status=400)
try:
bonus = Bonus()
bonus.card = card
try:
bonus.active_from = datetime.fromtimestamp(
bonus_data['active_from'] / 1000)
except Exception as exc:
bonus.active_from = bonus_data['active_from']
try:
bonus.active_to = datetime.fromtimestamp(
bonus_data['active_to'] / 1000)
except:
bonus.active_to = bonus_data['active_to']
bonus.value = float(bonus_data['value'])
bonus.enabled = True
bonus.save()
trans = Transaction()
trans.card = card
trans.type = 'bonus_add'
trans.date = datetime.now()
trans.org = user.org
trans.bonus_add = bonus.value
trans.workplace = 'ВТИ-ДИСКОНТ'
trans.doc_close_user = user.user.first_name + " " + user.user.last_name
trans.save()
except Exception as err:
response['status'] = 'error'
response['message'] = str(err)
return JsonResponse(response, status=400)
response['status'] = 'success'
response['message'] = 'Бонусы добавлены'
return JsonResponse(response, safe=False)
if request.method == 'DELETE':
user = UserCustom.objects.get(user_id__exact=request.user.pk)
bonus_data = json.loads(request.body.decode())
try:
card = Card.objects.get(org_id__exact=user.org.pk,
code__exact=card_code)
except:
response['status'] = 'error'
response['message'] = "Карта с таким кодом не найдена!"
return JsonResponse(response, status=400)
try:
bonus = Bonus.objects.get(id__exact=int(bonus_data['id']))
bonus.delete()
trans = Transaction()
trans.card = card
trans.type = 'bonus_refund'
trans.date = datetime.now()
trans.org = user.org
trans.bonus_add = bonus.value
trans.workplace = 'ВТИ-ДИСКОНТ'
trans.doc_close_user = user.user.first_name + " " + user.user.last_name
trans.save()
except Exception as err:
response['status'] = 'error'
response['message'] = str(err)
return JsonResponse(response, status=400)
response['status'] = 'success'
response['message'] = 'Бонусы удалены'
return JsonResponse(response, safe=False)
def create_series(request):
current_user = request.user
if request.method == "POST":
form = CreateSeriesForm(current_user.id, data=request.POST)
if form.is_valid():
series = form.save()
series.start_datetime = timezone.make_aware(
datetime.combine(form.cleaned_data["start_date"],
form.cleaned_data["start_time"]))
series.teacher = current_user
series.save()
students = form.cleaned_data["students"]
if series.repeat == Series.RepeatChoices.NEVER:
delta = None
elif series.repeat == Series.RepeatChoices.DAILY:
delta = timedelta(days=1)
elif series.repeat == Series.RepeatChoices.WEEKLY:
delta = timedelta(days=7)
# only RepeatChoice left is monthly
else:
delta = relativedelta(months=1)
lesson_datetime = series.start_datetime
# do-while loop implementation
while True:
lesson = Lesson(
series=series,
teacher=current_user,
datetime=lesson_datetime,
length=series.length,
)
lesson.save()
lesson.students.set(students)
for student in students:
student_status = StudentStatus(student=student,
lesson=lesson)
student_status.save()
lesson_datetime += delta
if lesson_datetime.date(
) > form.cleaned_data["end_date"] or not delta:
break
if (amount := form.cleaned_data["amount"]):
for student in students:
transaction_record = get_create_transaction_record(
current_user, student)
transaction = Transaction(
sender=current_user,
receiver=student,
last_sent_by=current_user,
transaction_record=transaction_record,
amount=amount,
note="fee for " + form.cleaned_data["name"],
series=series,
)
transaction.save()
return HttpResponseRedirect(reverse("lesson_planner:index"))
def createOrderId(em,plan,amount):
t = Transaction(customer_email = em,customer_name=em.first_name+" "+em.last_name,customer_phone_number=em.phone_number,plan = plan,amount = amount,eligibility = json.dumps(cust_set.plan[plan]["details"]))
t.save()
print("saving")
return str(t.order_id)
def apiAddAccumToCard(request, card_code, salt):
t_type = Operations.sell
if request.method == 'POST':
data = request.POST
if ('key' in data) and ('session_key' in data):
box = check_license(data['key'], data['session_key'])
if box:
try:
org = box.co_unit.org
except:
return HttpResponse(status=403)
org = None
else:
return HttpResponse(status=403)
if org is not None:
if org.is_active:
try:
if 'value' in data:
value = float(data['value'])
trans = Transaction().create(data)
trans.date = datetime.now()
card = Card.objects.get(code=card_code, org=org.pk)
trans.bonus_before = card.get_total_bonus()
trans.org = org
trans.card = card
trans.sum = float(data['value'])
trans.bonus_reduce = 0
trans.type = t_type
try:
trans.base_doc_date = parse(
data['base_doc_date'])
except:
trans.base_doc_date = None
d_plan = DiscountPlan.objects.get(
org_id__exact=org.pk)
algorithm = d_plan.algorithm
card.accumulation += float(data['value'])
card.last_transaction_date = datetime.now().date()
card.save()
if value < 0:
t_type = Operations.refund
trans.type = t_type
_handler = __import__(
'core.lib.%s' %
identify_task_operation(card, d_plan),
globals(), locals(), ['count'], 0)
card = _handler.count(value, card, d_plan,
trans)
card.save()
trans.save()
if value > 0:
try: # Добавляем задание
# task = Task(queue_date=datetime.now(),
# execution_date= datetime.now().date() + relativedelta(days=d_plan.time_delay),
# data=data['value'],
# card=card,
# operation=identify_task_operation(card, d_plan),
# d_plan=d_plan,
# transaction=trans,
# org=card.org)
# task.save()
_handler = __import__(
'core.lib.%s' %
identify_task_operation(card, d_plan),
globals(), locals(), ['count'], 0)
card = _handler.count(
value, card, d_plan, trans)
card.save()
except:
pass
return HttpResponse(data['value'])
else:
return HttpResponse(status='404')
except ObjectDoesNotExist as e:
return HttpResponse(status='404')
else:
return HttpResponse(status='503')
else:
return HttpResponse(status='503')
else:
return HttpResponse(status='503')
def count(value, card, d_plan, transaction):
# try:
# parameters = json.loads(d_plan.parameters)
# except:
# return None
# if type(parameters) is not dict:
# return None
try:
rules = json.loads(d_plan.rules)
except:
return None
if type(rules) is not list:
return None
value = float(value)
rules = DiscountParameters().load(rules)
next_discount = None
if value >= 0:
while rules.current <= rules.last:
if rules.get_current()[0] == card.discount:
next_discount = rules.next()
if next_discount is None:
return card
if next_discount[1] <= card.accumulation:
card.discount = next_discount[0]
trans = Transaction(org=card.org,
card=card,
date=datetime.now(),
type=Operations.discount_recount,
bonus_add=card.discount,
doc_number=transaction.doc_number,
session=transaction.session,
sum=transaction.sum,
shop=transaction.shop,
workplace=transaction.workplace)
trans.save()
else:
return card
else:
rules.next()
if value < 0:
rules.current = rules.last
while rules.current >= rules.first:
if rules.get_current()[0] == card.discount:
next_discount = rules.get_previous()
if next_discount is None:
return card
if rules.get_current()[1] > card.accumulation:
card.discount = next_discount[0]
trans = Transaction(org=card.org,
card=card,
date=datetime.now(),
type=Operations.discount_recount,
bonus_add=card.discount,
doc_number=transaction.doc_number,
session=transaction.session,
sum=transaction.sum,
shop=transaction.shop,
workplace=transaction.workplace)
trans.save()
else:
return card
else:
rules.previous()
return card
def startashipment(
request,
host_id=None,
transaction_form_submitted=False,
invoice=None,
cal_form_submitted=False,
packagedays_count=None,
):
random3digits = random.randint(100, 999)
#set timezone
local_timezone = request.session.setdefault('django_timezone', 'UTC')
local_timezone = pytz.timezone(local_timezone)
enduser = request.user
calendar_submit_button_text = "Select Dates and Proceed to Payment"
if host_id:
host = get_object_or_404(UserInfo, pk=host_id)
else:
host = None
#Determine if payment is needed or balance will suffice
balance = enduser.account_balance_packages
if balance > 0:
payment_needed = False
amount_due = 0.00
remaining_balance = balance - 1
else:
if enduser.betauser_free:
payment_needed = False
else:
payment_needed = True
amount_due = None #this is processed on the payment page if they aren't applying account balance
remaining_balance = None
connections_all = Connection.objects.filter(end_user=enduser)
#Empty variables for availability/ conflict stuff
days_package_may_come_thismonth = []
days_package_may_come_nextmonth = []
month1days_count = None
month2days_count = None
conflicts_date_from = []
conflicts_startmonths = []
conflicts_startthismonth = []
conflicts_startnextmonth = []
conflicts_startandend_thismonth = []
conflicts_startandend_nextmonth = []
conflicts_startthismonth_endnextmonth = []
conflicts_startthismonth_endlater = []
conflicts_startnextmonth_endlater = []
days_withconflicts_thismonth = []
days_withconflicts_nextmonth = []
days_withconflicts_later = []
#if host/no host - get caklendar_homebrew created fields
if host:
transcount = Transaction.objects.filter(host=host).count(
) + 1 #counts transactions that this receiver_email has received (could change to host email)
#invoice = "H" + str(host.id) + "U" + str(enduser.id) + "N" +str(transcount) +"D" + str(date_today.month) + str(date_today.day) + str(time.hour) + "R" + str(random3digits) #h2u14N13D112210R123 = transaciton between host2, user14, host's 13th transaction
#JMY updating invoice algorithm - removing date to make it smaller
invoice = "H" + str(
host.id
) + "U" + str(enduser.id) + "N" + str(transcount) + "R" + str(
random3digits
) #h2u14N13D112210R123 = transaciton between host2, user14, host's 13th transaction
conflicts = HostConflicts_DateVersion.objects.filter(host=host)
for conflict in conflicts:
if conflict.month == thismonth_num:
days_withconflicts_thismonth.append(conflict.day)
if conflict.month == nextmonth_num:
days_withconflicts_nextmonth.append(conflict.day)
#i think i do this to remove duplicates
days_withconflicts_thismonth = list(set(days_withconflicts_thismonth))
days_withconflicts_nextmonth = list(set(days_withconflicts_nextmonth))
#determine if there is a conflict
host_package_conflict = False
for day in days_package_may_come_thismonth:
if day in days_withconflicts_thismonth:
host_package_conflict = True
for day in days_package_may_come_nextmonth:
if day in days_withconflicts_nextmonth:
host_package_conflict = True
else: #if no host specified that stuff is empty/none
conflicts = None
host_package_conflict = False
#do payment variables/ transaction form stuff once they've checked the calendar day
favortype = 'package'
#transaction_form_submitted = False
#packagedays_count = None
if cal_form_submitted:
cal_form = CalendarCheckBoxes()
packagedays = None
packagedays_string = None
trans_form_package = None
trans = Transaction()
#request.method = 'GET'
if request.method == 'POST':
trans_form_package = CreatePackageTransaction(request.POST)
if trans_form_package.is_valid():
title = trans_form_package.cleaned_data['title']
payment_option = trans_form_package.cleaned_data[
'payment_option']
note_to_host = trans_form_package.cleaned_data['note_to_host']
paypal_quantity = 1
if payment_option == "bundle10":
price = host.price_package_bundle10
youselected = "Bundle of 10 Packages"
balance_created = 9 #10 minus the 1 they just bought
elif payment_option == "bundle20":
price = host.price_package_bundle20
youselected = "Bundle of 20 Packages"
balance_created = 19 #20 minus the 1 they just bought
elif payment_option == "annual":
price = host.price_package_annual
youselected = "Annual"
balance_created = 1000 #Notional - this option is not in place currently
else:
price = host.price_package_per
youselected = "Per Package"
balance_created = None
#Next, add the data to the transaction table
trans.balance_created_packages = balance_created
trans.payment_option = payment_option
trans.title = title
trans.favortype = favortype
trans.note_to_host = note_to_host
trans.price = price
trans.youselected = youselected
trans.paypal_quantity = paypal_quantity
trans.host = host
trans.enduser = enduser
trans.invoice = invoice
#Account balance/ create amount_due
if enduser.account_balance_packages:
if enduser.account_balance_packages > 0:
trans.amount_due = 0
trans.payment_needed = False
else:
trans.amount_due = price
trans.payment_needed = True
else:
trans.amount_due = price
trans.payment_needed = True
arrivalwindow_days_count = trans_form_package.cleaned_data[
'packagedays_count']
trans.arrivalwindow_days_count = arrivalwindow_days_count
day1 = trans_form_package.cleaned_data['arrivalwindow_day1']
day1string = trans_form_package.cleaned_data[
'arrivalwindow_day1string']
if day1:
trans.arrivalwindow_day1 = day1
day2 = trans_form_package.cleaned_data['arrivalwindow_day2']
day2string = trans_form_package.cleaned_data[
'arrivalwindow_day2string']
if day2:
trans.arrivalwindow_day2 = day2
day3 = trans_form_package.cleaned_data['arrivalwindow_day3']
day3string = trans_form_package.cleaned_data[
'arrivalwindow_day3string']
if day3:
trans.arrivalwindow_day3 = day3
day4 = trans_form_package.cleaned_data['arrivalwindow_day4']
day4string = trans_form_package.cleaned_data[
'arrivalwindow_day4string']
if day4:
trans.arrivalwindow_day4 = day4
day5 = trans_form_package.cleaned_data['arrivalwindow_day5']
day5string = trans_form_package.cleaned_data[
'arrivalwindow_day5string']
if day5:
trans.arrivalwindow_day5 = day5
day6 = trans_form_package.cleaned_data['arrivalwindow_day6']
day6string = trans_form_package.cleaned_data[
'arrivalwindow_day6string']
if day6:
trans.arrivalwindow_day6 = day6
day7 = trans_form_package.cleaned_data['arrivalwindow_day7']
day7string = trans_form_package.cleaned_data[
'arrivalwindow_day7string']
if day7:
trans.arrivalwindow_day7 = day7
if arrivalwindow_days_count == 1:
trans.arrivalwindow_string = str(day1string)
trans.arrivalwindow_lastday = day1
if arrivalwindow_days_count == 2:
trans.arrivalwindow_string = str(
day1string) + " or " + str(day2string)
trans.arrivalwindow_lastday = day2
if arrivalwindow_days_count == 3:
trans.arrivalwindow_string = str(day1string) + ", " + str(
day2string) + ", or " + str(day3string)
trans.arrivalwindow_lastday = day3
if arrivalwindow_days_count == 4:
trans.arrivalwindow_string = str(day1string) + ", " + str(
day2string) + ", " + str(day3string) + ", or " + str(
day4string)
trans.arrivalwindow_lastday = day4
if arrivalwindow_days_count == 5:
trans.arrivalwindow_string = str(day1string) + ", " + str(
day2string) + ", " + str(day3string) + ", " + str(
day4string) + ", or " + str(day5string)
trans.arrivalwindow_lastday = day5
if arrivalwindow_days_count == 6:
trans.arrivalwindow_string = str(day1string) + ", " + str(
day2string) + ", " + str(day3string) + ", " + str(
day4string) + ", " + str(
day5string) + ", or " + str(day6string)
trans.arrivalwindow_lastday = day6
if arrivalwindow_days_count == 7:
trans.arrivalwindow_lastday = day7
trans.arrivalwindow_string = str(day1string) + ", " + str(
day2string) + ", " + str(day3string) + ", " + str(
day4string) + ", " + str(day5string) + ", " + str(
day6string) + ", or " + str(day7string)
trans.save()
transaction_form_submitted = True
else:
print trans_form_package.errors
transaction_form_submitted = False
errors_on_trans_form = 'There are errors on the transaction form'
else:
trans_form_package = CreatePackageTransaction()
transaction_form_submitted = False
errors_on_trans_form = 'Method is not POST'
#if cal_form_submitted is false
else:
transaction_form_submitted = False
errors_on_trans_form = 'Cal_form was not submitted'
trans_form_package = None
transaction_form_submitted = False
packagedays = []
packagedays_string = []
#do the cal_form submission stuff
if request.method == 'POST':
cal_form = CalendarCheckBoxes(data=request.POST)
if cal_form.is_valid():
for daynumber in range(
1,
32): #starts at zero otherwise so this will stop at 31
daycheckedmonth1 = cal_form.cleaned_data['month1day' +
str(daynumber)]
if daycheckedmonth1:
#checked day needs to be in YYYY-MM-DD format
checked_day = str(thisyear) + "-" + str(
thismonth_num) + "-" + str(daynumber)
checked_day_string = str(thismonth) + " " + str(
daynumber)
packagedays.append(checked_day)
packagedays_string.append(checked_day_string)
days_package_may_come_thismonth.append(daynumber)
for daynumber in range(1, 32):
daycheckedmonth2 = cal_form.cleaned_data['month2day' +
str(daynumber)]
if daycheckedmonth2:
checked_day = str(nextmonth_calendar_year) + "-" + str(
nextmonth_num) + "-" + str(daynumber)
checked_day_string = str(nextmonth) + " " + str(
daynumber)
packagedays.append(checked_day)
packagedays_string.append(checked_day_string)
days_package_may_come_nextmonth.append(daynumber)
month1days_count = len(days_package_may_come_thismonth)
month2days_count = len(days_package_may_come_nextmonth)
cal_form_submitted = True
else:
print cal_form.errors
else:
cal_form = CalendarCheckBoxes()
packagedays_count = len(packagedays)
#if the transaction form has been submitted redirect to new page
if transaction_form_submitted == True:
cal_form = None
if payment_needed:
return HttpResponseRedirect("/transactions/payment/host" +
str(host.id) + "/invoice" +
str(invoice) + "/favortype" +
str(favortype) + "/")
else:
return HttpResponseRedirect("/transactions/shippackage/host" +
str(host.id) +
"/account_balance/invoice" +
str(invoice) + "/")
#if the transaction form has not been submitted
else:
return render(
request,
'blocbox/startashipment.html',
{
'enduser': enduser,
'host': host,
'connections_all': connections_all,
#'cal_relations_host_count': cal_relations_host_count, 'cal_relations_host': cal_relations_host, 'cal_list_host': cal_list_host,
'here': quote(request.get_full_path()),
#Python calendar variables (independent of conflict app)
'local_timezone': local_timezone,
'date_today': date_today,
'datetime_now': datetime_now,
'thisyear': thisyear,
'nextyear': nextyear,
'thisyeaer_isleap': thisyear_isleap,
'nextyear_isleap': nextyear_isleap,
'thismonth': thismonth,
'nextmonth': nextmonth,
'thismonth_calendar': thismonth_calendar,
'nextmonth_calendar': nextmonth_calendar,
'monthrange_thismonth': monthrange_thismonth,
'monthrange_nextmonth': monthrange_nextmonth,
'days_in_thismonth': days_in_thismonth,
'days_in_nextmonth': days_in_nextmonth,
'today_dayofmonth_num': today_dayofmonth_num,
'nextmonth_calendar_year': nextmonth_calendar_year,
#conflict app variables (if host)
'conflicts': conflicts,
'conflicts_startthismonth': conflicts_startthismonth,
'conflicts_startnextmonth': conflicts_startnextmonth,
'conflicts_startandend_thismonth':
conflicts_startandend_thismonth,
'conflicts_startandend_nextmonth':
conflicts_startandend_nextmonth,
'days_withconflicts_thismonth': days_withconflicts_thismonth,
'days_withconflicts_nextmonth': days_withconflicts_nextmonth,
#days package may come
'days_package_may_come_thismonth':
days_package_may_come_thismonth,
'days_package_may_come_nextmonth':
days_package_may_come_nextmonth,
'host_package_conflict': host_package_conflict,
#Calendar check boxes form
'cal_form': cal_form,
'packagedays': packagedays,
'packagedays_string': packagedays_string,
'packagedays_count': packagedays_count,
'cal_form_submitted': cal_form_submitted,
'calendar_submit_button_text': calendar_submit_button_text,
#payment stuff once the calendar checkboxes are checked
'trans_form_package': trans_form_package,
'invoice': invoice,
'favortype': favortype,
'errors_on_trans_form': errors_on_trans_form,
'transaction_form_submitted': transaction_form_submitted,
'random3digits': random3digits,
'payment_needed': payment_needed,
'amount_due': amount_due,
'remaining_balance': remaining_balance,
'request': request,
})
line.replace(why_prefix, ''))
elif line.startswith(when_prefix):
save_question_response(sr, when_question,
line.replace(when_prefix, ''))
elif line.startswith(improve_prefix):
save_question_response(sr, improve_question,
line.replace(improve_prefix, ''))
elif line.startswith(skills_prefix):
save_question_response(sr, skills_question,
line.replace(skills_prefix, ''))
save_question_response(sr, t_and_c_question, 'Y')
save_question_response(sr, bene_question, 'Y')
if len(row[1]) > 0:
t = Transaction()
t.user = user
t.date = est.localize(dateparser.parse(row[1]))
t.item = common_item
t.qty = 1
t.amount = 3000 if user.email.split(
'@')[1] == "3cross.coop" else 150
t.save()
members_group.user_set.add(user)
else:
pending_group.user_set.add(user)
preferred_shares = 0
if len(row[21]) > 0:
preferred_shares = int(row[21])
def apiToCardFromService(request):
if request.method == 'POST':
data = request.POST
if ('key' in data) and ('vtikeeper' in data):
box = CashBox.get_by_key(data['key'])
if box:
try:
org = box.co_unit.org
except:
org = None
if org is not None:
if org.is_active:
try:
if 'type' in data:
if data['type'] == 'add':
t_type = Operations.sell
if 'value' in data and 'card' in data:
trans = Transaction().create(data)
trans.date = datetime.strptime(
data['datetime'], "%d.%m.%Y %H:%M:%S")
card = Card.objects.get(code=data['card'],
org=org.pk)
trans.bonus_before = card.get_total_bonus()
d_plan = DiscountPlan.objects.get(
org_id__exact=org.pk)
algorithm = d_plan.algorithm
card.accumulation += float(data['value'])
card.last_transaction_date = datetime.now(
).date()
card.save()
# пишем статистику
trans.org = org
trans.card = card
trans.sum = float(data['value'])
trans.bonus_reduce = 0
trans.type = t_type
try:
trans.base_doc_date = parse(
data['base_doc_date'])
except:
trans.base_doc_date = None
trans.save()
try: # Добавляем задание
task = Task(
queue_date=datetime.now(),
execution_date=trans.date +
relativedelta(
days=d_plan.time_delay),
data=data['value'],
card=card,
operation=identify_task_operation(
card, d_plan),
d_plan=d_plan,
transaction=trans,
org=card.org)
task.save()
except:
pass
return HttpResponse(data['value'])
else:
return HttpResponse(status='404')
if data['type'] == 'rem':
t_type = Operations.bonus_reduce
if 'value' in data and 'card' in data:
trans = Transaction().create(data)
trans.date = datetime.strptime(
data['datetime'], "%d.%m.%Y %H:%M:%S")
card = Card.objects.get(code=data['card'],
org=org.pk)
trans.bonus_before = card.get_total_bonus()
# пишем статистику
trans.org = org
trans.card = card
trans.sum = 0
trans.bonus_reduce = float(data['value'])
trans.type = t_type
trans.save()
value = float(data['value'])
rem_bonus(card, value)
return HttpResponse(data['value'])
else:
return HttpResponse(status='404')
except ObjectDoesNotExist as e:
return HttpResponse(status='404')
else:
return HttpResponse(status='503')
else:
return HttpResponse(status='503')
else:
return HttpResponse(status='503')
