def activation_bonus_handler(request, **kwargs):
"""THE SPONSOR RECEIVES THE MATCHING PERCENTAGE GRADE"""
member = kwargs.get("member", None)
operation = kwargs.get("operation", None)
a_m = ACTIVATION_MATRIX
created_by = member
origin = OperationType.objects.filter(code_name=operation).first()
"""UPDATE SPONSOR BV"""
ancestors_bv_update(member, ACTIVATION_BV, origin)
"""WALLET INCOME"""
try:
ancestors = member.get_ancestors(ascending=True)
ancestors = [ancestor for ancestor in ancestors if ancestor.status]
except ValueError as e:
logger.error(e)
ancestors = []
# print("Ancestors => {}".format(ancestors))
operation_data = {
'wallet': "wallet1",
'sender': member,
'operation': origin,
'created_by': created_by
}
for ancestor, value in zip(ancestors, a_m):
if ancestor:
print("Ancestor => {}, Value => {}".format(ancestor, value))
bonus_amount = ACTIVATION_BV * value / 100
operation_data['member'] = ancestor
operation_data['receiver'] = ancestor
operation_tnx("M2m", bonus_amount, **operation_data)
def initialize():
global updater, dispatcher
try:
updater = Updater(token=api)
dispatcher = updater.dispatcher
except:
logger.error(
__name__,
"Failed to initialize Telegram's API: Please check config.ini")
exit()
def parseTelegram():
if ('TELEGRAM' in parser):
telegram.api = parser['TELEGRAM']['BOT_TOKEN']
telegram.auto_approve = parser.getboolean('TELEGRAM', 'AUTO_APPROVE')
telegram.initialize()
logger.info(__name__, "Telegram API initialized")
else:
logger.error(
__name__,
"Failed to initialize Telegram's API: Check your config.ini")
exit()
def parseGeneral():
try:
if ('GENERAL' in parser):
constants.BOT_NAME = parser['GENERAL']['NAME']
logger.info(__name__, "Parsed general information")
else:
raise Exception()
except:
logger.error(
__name__,
"Failed to get general config information: Check your config.ini")
exit()
def parseOmbi():
if ('OMBI' in parser):
if (parser.getboolean('OMBI', 'ENABLED')):
ombi.enabled = True
ombi.api = parser['OMBI']['API']
ombi.host = parser['OMBI']['HOST']
ombi.initialize()
logger.info(__name__, "Ombi API parsed")
else:
logger.error(__name__,
"Failed to initialize Ombi's API: Check your config.ini")
exit()
def initialize():
try:
payload = {'ApiKey': api}
request = requests.get(host + constants.OMBI_SYSTEM_STATUS,
params=payload)
if (request.status_code is not 200):
raise Exception()
except:
logger.error(
__name__,
"Could not create a connection to Ombi: Please check config.ini")
exit()
def notifyImmediately(bot, job):
# Pulls the watch_id, and decodes the bytes back to the data
try:
watch_id = job.context.decode('utf-8')
data = watch_id.split(";")
except:
logger.error(__name__, "notifyImmediately() failed to extract and process watch_id")
return True
# If the media isn't in the database, refreshes the databases first
if(int(data[1]) == constants.NOTIFIER_MEDIA_TYPE_MOVIE and select.getMovie(data[0]) == None and radarr.enabled):
catalogue.updateMovies(None, None)
elif(int(data[1]) == constants.NOTIFIER_MEDIA_TYPE_TELEVISION and select.getShow(data[0]) == None and sonarr.enabled):
catalogue.updateTelevision(None, None)
# Gets the metadata for the movie and the list of users who need notifications
metadata = select.getMetadata(watch_id, data[1])
users = select.getUsersImmediateUpdate(data[0], data[1])
# If there are no users watching this show or movie, print a log and return
if(len(users) == 0):
logger.info(__name__, "New content ({}): Notified no users".format(metadata[2]), "INFO_GREEN")
return True
# Build the messages
if(int(data[1]) == constants.NOTIFIER_MEDIA_TYPE_TELEVISION):
msg_simple = constants.NOTIFIER_IMMEDIATELY_HEADER + buildSimpleTelevisionMessage(metadata)
msg_complex = constants.NOTIFIER_IMMEDIATELY_HEADER + buildComplexTelevisionMessage(metadata)
is_upgrade = metadata[9]
elif(int(data[1]) == constants.NOTIFIER_MEDIA_TYPE_MOVIE):
msg_simple = constants.NOTIFIER_IMMEDIATELY_HEADER + buildSimpleMovieMessage(metadata)
msg_complex = constants.NOTIFIER_IMMEDIATELY_HEADER + buildComplexMovieMessage(metadata)
is_upgrade = metadata[5]
# Process user messages
notifications_counter = 0
for user in users:
user_data = select.getUser(user[0])
# Checks if the user is banned or restricted
if((not constants.RESTRICTED_NOTIFICATIONS or user_data[1] != constants.ACCOUNT_STATUS_RESTRICTED) and user_data[1] != constants.ACCOUNT_STATUS_BANNED):
# Checks if the media was an upgrade
if(is_upgrade == 1):
if(user_data[3] == constants.ACCOUNT_UPGRADE_YES):
# Gets the complexity and sends the appropriate message
if(user_data[2] == constants.ACCOUNT_DETAIL_SIMPLE):
bot.send_message(chat_id=user_data[0], text=msg_simple, parse_mode=telegram.ParseMode.MARKDOWN)
elif(user_data[2]== constants.ACCOUNT_DETAIL_COMPLEX):
bot.send_message(chat_id=user_data[0], text=msg_complex, parse_mode=telegram.ParseMode.MARKDOWN)
notifications_counter += 1
else:
# Gets the complexity and sends the appropriate message
if(user_data[2] == constants.ACCOUNT_DETAIL_SIMPLE):
bot.send_message(chat_id=user_data[0], text=msg_simple, parse_mode=telegram.ParseMode.MARKDOWN)
elif(user_data[2]== constants.ACCOUNT_DETAIL_COMPLEX):
bot.send_message(chat_id=user_data[0], text=msg_complex, parse_mode=telegram.ParseMode.MARKDOWN)
notifications_counter += 1
logger.info(__name__, "New content ({}): notified {} user(s)".format(metadata[2], notifications_counter), "INFO_GREEN")
def initialize():
#Creates a request for Sonarr to check the system status
try:
payload = {'apikey': api}
request = requests.get(host + constants.SONARR_SYSTEM_STATUS,
params=payload)
if (request.status_code is not 200):
raise Exception()
except:
logger.error(
__name__,
"Could not create a connection to Sonarr: Please check config.ini")
exit()
def parseAdmins():
try:
if ('TELEGRAM' in parser):
for admin in parser['TELEGRAM']['AUTO_ADMINS'].split(','):
telegram.addAdmin(int(admin.strip()))
logger.warning(__name__,
"Telegram admins: {}".format(telegram.admins))
else:
raise Exception()
except:
logger.error(
__name__,
"Failed to get the admin user list: Check your config.ini")
exit()
def initParser():
global parser
try:
parser = configparser.ConfigParser()
parser.read(constants.CONFIG_FILE)
if not (len(parser) > 1):
raise Exception()
logger.info(__name__, "Configparser initialized")
except:
logger.error(
__name__,
"Failed to load config.ini: Please ensure that a valid config file is located at {}"
.format(constants.CONFIG_FILE))
exit()
def secondsToDaily():
now = datetime.datetime.now()
try:
time = constants.NOTIFICATION_TIME.split(":")
# If it's still the same day but past the notification time, adds a day
if(now.hour >= int(time[0]) and now.minute >= int(time[1])):
notification_time = datetime.datetime(now.year, now.month, now.day+1, int(time[0]), int(time[1]))
else:
notification_time = datetime.datetime(now.year, now.month, now.day, int(time[0]), int(time[1]))
except:
logger.error(__name__, "Invalid NOTIFICATION_TIME in backend/constants.py")
exit()
# Returns the total amount of seconds until the notification time
return int(abs((now-notification_time).total_seconds()))
def parseSonarr():
if ('SONARR' in parser):
if (parser.getboolean('SONARR', 'ENABLED')):
sonarr.enabled = True
sonarr.api = parser['SONARR']['API']
sonarr.host = parser['SONARR']['HOST']
sonarr.update_frequency = int(parser['SONARR']['UPDATE_FREQ'])
sonarr.initialize()
logger.info(__name__, "Sonarr API parsed")
else:
logger.error(
__name__,
"Could not read the Sonarr configuration values: Check your config.ini"
)
exit()
def parseNotifications():
try:
if ('NOTIFICATIONS' in parser):
constants.NOTIFICATION_TIME = parser['NOTIFICATIONS']['TIME']
constants.NOTIFICATION_DAY = parser['NOTIFICATIONS']['DAY']
logger.warning(
__name__, "Notification times set: {} @ {}".format(
constants.NOTIFICATION_DAY, constants.NOTIFICATION_TIME))
else:
raise Exception()
except:
logger.error(
__name__,
"Failed to get notification times: Check your config.ini")
exit()
def member_bv_init(sender, instance, created, **kwargs):
"""MEMBER BVS INIT"""
if created:
try:
member_bv = MemberBV.objects.get(member=instance)
except MemberBV.DoesNotExist as e:
logger.info(e)
member_bv = MemberBV(member=instance)
try:
member_bv.save()
except IntegrityError as e:
logger.error(e)
except ValueError as e:
logger.error(e)
def member_wallet_init(sender, instance, created, **kwargs):
"""MEMBER WALLET INIT"""
if created:
try:
member_wallet = MemberWallet.objects.get(member=instance)
except MemberWallet.DoesNotExist as e:
logger.info(e)
member_wallet = MemberWallet(member=instance)
try:
member_wallet.save()
except IntegrityError as e:
logger.error(e)
except ValueError as e:
logger.error(e)
def bv_tnx_handler(**data):
transaction_info = {
"member": data.get("member"),
"bv": data.get("bv"),
"side": data.get("side"),
"sender": data.get("sender"),
"origin": data.get("origin")
}
transaction = MemberBVHistory(**transaction_info)
try:
transaction.save()
return True
except IntegrityError as e:
logger.error(e)
return False
except ValueError as e:
logger.error(e)
return False
def secondsToWeekly():
now = datetime.datetime.now()
try:
time = constants.NOTIFICATION_TIME.split(":")
day = constants.WEEKDAYS.index(constants.NOTIFICATION_DAY)
if(now.hour >= int(time[0]) and now.minute >= int(time[1])):
# If it's still the same day but past the notification time, adds a day
notification_time = datetime.datetime(now.year, now.month, now.day+1, int(time[0]), int(time[1]))
else:
notification_time = datetime.datetime(now.year, now.month, now.day, int(time[0]), int(time[1]))
# Adds days to the notification time until it reaches the correct day
while notification_time.weekday() != day:
notification_time += datetime.timedelta(days=1)
except:
logger.error(__name__, "Invalid NOTIFICATION_TIME or NOTIFICATION_DAY in backend/constants.py")
exit()
# Returns the total amount of seconds until the notification time
return int(abs((now-notification_time).total_seconds()))
def maintenance_pairing(*args, **kwargs):
"""print('ARGS => {}'.format(args))
print('KWARGS => {}'.format(kwargs))
member = kwargs.get('member', None)
limit = kwargs.get('limit')"""
members = Member.objects.filter(status=True)
for member in members:
if member is not None and member.status is True:
left = member.member_bv.left
right = member.member_bv.right
bv = right if left - right >= 0 else left
if bv > 0:
amount = bv * (MAINTENANCE_PARING_PERCENT / 100) * 2
operation_data = {
'member': member,
'wallet': 'wallet1',
'receiver': member,
'operation': 'maintenance_pairing',
'created_by': member
}
transaction_status = operation_tnx("M2m", Decimal(amount),
**operation_data)
if transaction_status:
member_bv = MemberBV.objects.get(member=member)
member_bv.left = F("left") - bv
member_bv.right = F("right") - bv
try:
member_bv.save()
return True
except IntegrityError as e:
logger.error(e)
return False
except ValueError as e:
logger.error(e)
return False
else:
return False
else:
return False
def order_tnx_handler(**data):
member = data.get("member")
order_type = data.get("order_type")
pack = data.get("pack")
payment_mode = data.get("payment_mode")
delivery_method = data.get("delivery_method")
new_order = OrderInfo()
new_order.member = member
new_order.order_type = order_type
new_order.pack = None if pack is None else pack.id
new_order.payment_mode = payment_mode
new_order.delivery_method = delivery_method
try:
new_order.save()
print("new_order => {}".format(new_order.pack))
return True
except IntegrityError as e:
logger.error(e)
return False
except ValueError as e:
logger.error(e)
return False