def calc_weekly(user, last_date, next_date, dry=True):
# calculate number of weeks passed since last_date before next_date
# print "for user %s" %(user.username)
pkg = get_package(user)
user_doj = pkg.created_at.date()
num_weeks = 0
# user_doj = user.date_joined.date()
# user_doj = date(user_doj.year, user_doj.month, user_doj.day)
# old_date_time = pkg.created_at if pkg.created_at > last_date else last_date
old_date_time = greater_date(pkg.created_at, last_date)
new_date = next_date.date()
old_date = old_date_time.date()
if old_date_time < next_date:
delta = next_date - old_date_time
num_weeks = floor(delta.days / 7.0)
# pkg = get_package(user)
# payout = (pkg.package.payout/100.) * pkg.package.price
# res = (round((payout * num_weeks), 2), 'direct')
res = payout, _ = calc_daily(user, old_date_time, next_date)
else:
res = payout, _ = (0.0, 'direct')
if num_weeks and dry == False:
divide_conquer(
range(int(num_weeks)), 0,
int(num_weeks) - 1,
lambda num: gen_txn_weekly(num, old_date, new_date, user, payout))
return res
def is_valid_eth_paid(amt, src_addr, addr, txn_id, txn_res):
# print txn_res
result = txn_res['result']
return any(
divide_conquer(result, 0,
len(result) - 1,
lambda r: valid_ether(r, amt, src_addr, addr, txn_id)))
def test_all_members_traversed(self):
tot = [self.user1]
members = Members.objects.filter(parent_id=self.user1)
[tot.append(m) for m in members]
while members:
members = reduce(lambda x, y: x|y, divide_conquer(members, 0, len(members)-1, get_user_from_member))
[tot.append(m) for m in members]
# print "users are: {}".format([m.child_id.username if type(m)==Members else m.username for m in tot])
self.assertEqual(len(tot), 7, "should be 7 users in all but are: %s" %(len(tot)))
def test_filter_valid_users(self):
"find valid users for calculation between last_date and next_date"
filtered_members = []
sponsor_id = self.user1.profile.user_auto_id
last_date = self.pkg1.created_at
next_date = self.next_date
members = Members.objects.filter(parent_id=self.user1)
while members:
filtered_members.extend(filter_by_sponsor(sponsor_id, last_date, next_date, members))
members = reduce(lambda x, y: x|y, divide_conquer(members, 0, len(members)-1, get_user_from_member))
self.assertEqual(len(filtered_members), 6, "should be 6 but is {}".format(len(filtered_members)))
def is_valid_btc_paid(amt, dest_addr, addr, txn_id, j_addr, j_txn):
txrefs = j_addr.get("txrefs", None)
if txrefs is not None:
tx_hashes = divide_conquer(txrefs, 0,
len(txrefs) - 1,
lambda txref: txref["tx_hash"])
inputs = j_txn["inputs"]
outputs = j_txn["outputs"]
total_amt = j_txn["total"]
return (total_amt == amt) and any(
divide_conquer(
tx_hashes, 0,
len(tx_hashes) - 1,
lambda tx_hash: tx_hash == txn_id)) and (addr in reduce(
lambda a, b: a + b,
divide_conquer(inputs, 0,
len(inputs) - 1,
lambda input: input['addresses'])
)) and (dest_addr in reduce(
lambda a, b: a + b,
divide_conquer(outputs, 0,
len(outputs) - 1,
lambda output: output['addresses'])))
return False
def calc_sum(sponsor_id, last_date, next_date, members, dry=True):
"""Used for Direct Sum Calculation:
Calculates total package price of all members under a user sponsored by that user"""
users_sum = 0.0
profile = Profile.objects.get(user_auto_id=sponsor_id)
u = profile.user
while members:
# find active members' total package price sum in current cycle by sponsor id
users_sum += sum(
map(
lambda m: get_active_mem_price(m),
filter_by_sponsor(sponsor_id,
last_date,
next_date,
members,
dry=dry)))
# tree level traversal - get more members per child level
members = reduce(
lambda x, y: x | y,
divide_conquer(members, 0,
len(members) - 1, get_user_from_member))
return users_sum
def calc_sum(sponsor_id, last_date, next_date, members):
"""Used for Direct Sum Calculation:
Calculates total package price of all members under a user sponsored by that user"""
users_sum = 0.0
# u = User.objects.get(username=sponsor_id)
profile = Profile.objects.get(user_auto_id=sponsor_id)
u = profile.user
# print "u is {}".format(u)
# tot = [u]
# print "members {}".format([m.child_id.username for m in members])
# [tot.append(m) for m in members]
while members:
# find active members' total package price sum in current cycle by sponsor id
users_sum += sum(map(lambda m: get_active_mem_price(m),
filter_by_sponsor(sponsor_id, last_date, next_date, members)))
# tree level traversal - get more members per child level
# print "FUNCTION calc_sum > users_sum is: %s" %users_sum
members = reduce(lambda x, y: x | y, divide_conquer(
members, 0, len(members)-1, get_user_from_member))
# [tot.append(m) for m in members]
# print "users are: {}".format([m.child_id.username if type(m)==Members else m.username for m in tot])
return users_sum
def test_valid_input_btc_addr(self):
txn, _ = get_btc(self.true_btc, self.btc_txn_id)
inputs = txn["inputs"]
res = self.true_btc in reduce(lambda a, b: a+b, divide_conquer(inputs, 0, len(inputs) - 1, lambda input: input['addresses']))
self.assertTrue(res, "Should contain a valid btc address. address is %s" %self.true_btc)
def test_valid_txn_hash(self):
_, addr = get_btc(self.true_btc, self.btc_txn_id)
txrefs = addr.get("txrefs", None)
tx_hashes = divide_conquer(txrefs, 0, len(txrefs) - 1, lambda txref: txref["tx_hash"])
res = any(divide_conquer(tx_hashes, 0, len(tx_hashes) - 1, lambda tx_hash: tx_hash == self.btc_txn_id))
self.assertTrue(res, "Should contain a valid transaction id")
def test_divide_conquer_odd(self):
res = divide_conquer(self.odd, 0, len(self.odd)-1, lambda r: r)
self.assertEqual(res, self.odd, "should be {} but is {}".format(self.odd, res))
def test_valid_dest_btc_addr(self):
txn, _ = get_btc(self.true_btc, self.btc_txn_id)
outputs = txn["outputs"]
res = self.dest_btc_addr in reduce(lambda a, b: a+b, divide_conquer(outputs, 0, len(outputs) - 1, lambda output: output['addresses']))
self.assertTrue(res, "Should contain a valid destination btc address. destination address is %s" %self.dest_btc_addr)
def run_scheduler(**kw):
users = User.objects.all()
divide_conquer(users, 0, len(users)-1,
lambda user: calculate_investment(user, **kw))
