def get_hijri_month_length(month, year):
date = HijriDate(year, month, 1)
date = HijriDate(int(date.year_gr),
int(date.month_gr),
int(date.day_gr),
gr=True)
return date.month_len
def action_across_month(self):
loan_id = self._context.get('active_id', False)
loan_obj = self.env['hr.loan']
loan_line_obj = self.env['hr.loan.line']
action = self._context.get('action', False)
dt = fields.Date.from_string(self.period_id.date_start)
day = dt.day
if loan_id:
if action == 'across': # تجاوز شهر
# must delete this month add another month
loan_lines = loan_line_obj.search([
('loan_id', '=', loan_id),
('date_start', '=', self.period_id.date_start),
('date_stop', '=', self.period_id.date_stop)
])
loan_lines.unlink()
um = HijriDate()
loan = loan_obj.search([('id', '=', loan_id)])
last_date_start = fields.Date.from_string(
loan.line_ids[-1].date_start)
last_date_stop = fields.Date.from_string(
loan.line_ids[-1].date_stop)
temp_date_start = last_date_stop + relativedelta(days=1)
hijri_month = get_hijri_month_by_date(HijriDate, Umalqurra,
temp_date_start)
hijri_year = get_hijri_year_by_date(HijriDate, Umalqurra,
temp_date_start)
new_date_start = get_hijri_month_start_by_year(
HijriDate, Umalqurra, hijri_year, hijri_month)
new_date_stop = get_hijri_month_end__by_year(
HijriDate, Umalqurra, hijri_year, hijri_month)
dates = str(new_date_start).split('-')
um.set_date_from_gr(int(dates[0]), int(dates[1]), day)
new_line_val = {
'loan_id': loan_id,
'amount': loan.monthly_amount,
'date_start': new_date_start,
'date_stop': new_date_stop,
'name': MONTHS[int(um.month)] + '/' + str(int(um.year)),
}
loan_line_obj.create(new_line_val)
val = {
'loan_id': loan_id,
'reason': self.reason,
'period_id': self.period_id.id,
'number_decision': self.number_decision,
'date_decision': self.date_decision,
'action': action,
}
if action == 'full_amount':
loan = self.env['hr.loan'].browse(loan_id)
loan.write({'state': 'done', 'payment_full_amount': True})
# make all line payed
loan.line_ids.write({'state': 'done'})
self.env['hr.loan.history'].create(val)
return {'type': 'ir.actions.act_window_close'}
def get_month(passed_date=None, passed_month=None, passed_year=None):
if passed_date == None and passed_month == None and passed_year == None:
current_date_object = HijriDate.today()
else:
current_date_object = HijriDate(passed_year,
passed_month,
passed_date,
gr=True)
return int(current_date_object.month)
def genrate_dim_date(start_date, end_date):
data = DataFrame({'gregorian_date': date_range(start_date, end_date)})
data['gregorian_year'] = data.apply(lambda x: x.gregorian_date.year,
axis=1)
data['gregorian_month'] = data.apply(lambda x: x.gregorian_date.month,
axis=1)
data['gregorian_day'] = data.apply(lambda x: x.gregorian_date.day, axis=1)
data['jalali_year'] = data.apply(lambda x: GregorianToJalali(
x.gregorian_year, x.gregorian_month, x.gregorian_day).jyear,
axis=1)
data['jalali_month'] = data.apply(lambda x: GregorianToJalali(
x.gregorian_year, x.gregorian_month, x.gregorian_day).jmonth,
axis=1)
data['jalali_day'] = data.apply(lambda x: GregorianToJalali(
x.gregorian_year, x.gregorian_month, x.gregorian_day).jday,
axis=1)
data['jalali_month_name'] = data.jalali_month.map(jalali_months_dict)
data['week_day'] = data.apply(lambda x: datetime.datetime(
x.gregorian_year, x.gregorian_month, x.gregorian_day).weekday(),
axis=1).map(week_days_dict)
data['week_day_en'] = data.apply(lambda x: datetime.datetime(
x.gregorian_year, x.gregorian_month, x.gregorian_day).weekday(),
axis=1).map(week_days_en_dict)
data['hijri_year'] = data.apply(lambda x: int(
HijriDate(
x.gregorian_year, x.gregorian_month, x.gregorian_day, gr=True).year
),
axis=1)
data['hijri_month'] = data.apply(lambda x: int(
HijriDate(
x.gregorian_year, x.gregorian_month, x.gregorian_day, gr=True).
month),
axis=1)
data['hijri_day'] = data.apply(lambda x: int(
HijriDate(
x.gregorian_year, x.gregorian_month, x.gregorian_day, gr=True).day
),
axis=1)
data['hijri_month_name'] = data.hijri_month.map(hijri_months_dict)
data['gregorian_month_name_en'] = data.gregorian_month.map(
gregorian_months_en_dict)
data['gregorian_month_name_fa'] = data.gregorian_month.map(
gregorian_months_fa_dict)
data['gregorian_week_number'] = data.apply(lambda x: datetime.date(
x.gregorian_year, x.gregorian_month, x.gregorian_day).isocalendar()[1],
axis=1)
data['jalali_week_number'] = data.apply(
lambda x: jalali_week(x.jalali_year, x.jalali_month, x.jalali_day),
axis=1)
data.to_csv(dim_date_file, encoding='utf8')
def _onchange_date(self):
# لا يمكن أن يكون القسط أكبر من ثلث الراتب
grid_id, basic_salary = self.employee_id.get_salary_grid_id(False)
if not grid_id:
return
if self.monthly_amount > basic_salary / 3.0:
warning = {
'title':
_('تحذير!'),
'message':
_(u'لا يمكن أن يكون القسط (%s) أكبر من ثلث الراتب (%s)' %
(self.monthly_amount, basic_salary / 3.0))
}
self.monthly_amount = False
return {'warning': warning}
if self.date_from and self.amount and self.monthly_amount:
# get lines
dt = fields.Date.from_string(self.date_from)
months = []
amount = 0.0
diff = self.amount - amount
installment_number = 0
final_amount = self.monthly_amount
while diff > 0:
um = HijriDate()
dates = str(dt).split('-')
um.set_date_from_gr(int(dates[0]), int(dates[1]),
int(dates[2]))
date_start = get_hijri_month_start_by_year(
HijriDate, Umalqurra, int(um.year), int(um.month))
date_stop = get_hijri_month_end__by_year(
HijriDate, Umalqurra, int(um.year), int(um.month))
month_val = {
'loan_id': self.id,
'amount': final_amount,
'date_start': date_start,
'date_stop': date_stop,
'name': MONTHS[int(um.month)] + '/' + str(int(um.year)),
'state': 'progress'
}
months.append(month_val)
dt = fields.Date.from_string(str(dt)) + relativedelta(days=30)
installment_number += 1
amount += self.monthly_amount
diff = self.amount - amount
if diff >= self.monthly_amount:
final_amount = self.monthly_amount
else:
final_amount = diff
self.installment_number = installment_number
self.line_ids = months
self.date_to = date_stop
def _hijri_day_of_year(date):
date_um = gregorian_to_hijri(date)
first_day_of_year_um = HijriDate(date_um.year, 1, 1)
first_day_of_year_gr = hijri_to_gregorian(first_day_of_year_um)
tdiff = date - first_day_of_year_gr
day_of_year = tdiff.days + 1
return day_of_year
def _get_years(self, date, separator):
if date:
date = fields.Date.from_string(date)
hijri_date = HijriDate(date.year, date.month, date.day, gr=True)
return str(int(hijri_date.year))
return None
def _get_hijra(self):
um = HijriDate(datetime.now().year,
datetime.now().month,
datetime.now().day,
gr=True)
self.hijri_date = str(int(um.day)) + "/" + str(int(
um.month)) + "/" + str(int(um.year))
def get_ummqura(self, g_date):
try:
g_date = fields.Date.from_string(g_date)
hijri_date = HijriDate(g_date.year, g_date.month, g_date.day, gr=True)
hijri_date_str = "{0}/{1}/{2}".format(int(hijri_date.year), int(hijri_date.month), int(hijri_date.day))
return self.num2hindi(hijri_date_str)
except Exception:
return False
def _hijri_to_gregorian(year, month, day, date_obj=None):
hd = HijriDate(year=year, month=month, day=day)
year_gr = int(hd.year_gr)
month_gr = int(hd.month_gr)
day_gr = int(hd.day_gr)
if date_obj:
return date_obj.replace(year=year_gr, month=month_gr, day=day_gr)
else:
return datetime(year=year_gr, month=month_gr, day=day_gr)
def hijri_year_range(min_date, max_date):
"""Get an array of start and end dates for each year in the given gregorian date ranges
There is no periodic year range
Args:
min_date (date): gregorian date to start the date range at
max_date (date): gregorian date to end the date range at
Returns:
{'type': 'years', 'bounds': bounds, 'date_sets': days, 'periodic': periodic}
bounds: bounding DateRange which the date sets contain
days: array of HijriDateSets
"""
min_date = datetime.combine(min_date, datetime.min.time())
max_date = datetime.combine(max_date, datetime.min.time())
min_date_um = gregorian_to_hijri(min_date)
max_date_um = gregorian_to_hijri(max_date)
bounds = DateRange(start=min_date, end=max_date)
hijri_years = xrange(int(min_date_um.year), int(max_date_um.year) + 1)
years = []
for year in hijri_years:
start_date_um = HijriDate(year, 1, 1)
start_date_gr = hijri_to_gregorian(start_date_um)
end_date_um = HijriDate(year + 1, 1, 1)
end_date_gr = hijri_to_gregorian(end_date_um)
years.append(
HijriDateSet(key=str(year),
label=[{
'text': str(year),
'translate': False
}],
ranges=[
DateRange(start=local_tz.localize(start_date_gr),
end=local_tz.localize(end_date_gr))
]))
return {
'type': 'years',
'bounds': bounds,
'date_sets': years,
'periodic': False
}
def _get_hijri_date(self, date, separator):
'''
convert georging date to hijri date
:return hijri date as a string value
'''
if date:
date = fields.Date.from_string(date)
hijri_date = HijriDate(date.year, date.month, date.day, gr=True)
return str(int(hijri_date.day)).zfill(2) + separator + str(int(hijri_date.month)).zfill(2) + separator + str(int(hijri_date.year))
return None
def _get_recrute_employee(self, data, date, separator):
employee_id = data['employee_id'] and data['employee_id'][0] or False
emp_obj = self.pool.get('hr.employee').browse(self.cr, self.uid,
employee_id)
if emp_obj.recruiter_date:
date = fields.Date.from_string(emp_obj.recruiter_date)
hijri_date = HijriDate(date.year, date.month, date.day, gr=True)
return str(int(hijri_date.year)) + separator + str(
int(hijri_date.month)) + separator + str(int(hijri_date.day))
return None
def compute_age_display(self):
for rec in self:
today_date = date(int(HijriDate.today().year),
int(HijriDate.today().month),
int(HijriDate.today().day))
gr_birthday = fields.Date.from_string(rec.birthday)
hijri_birthday = HijriDate(gr_birthday.year,
gr_birthday.month,
gr_birthday.day,
gr=True)
birthday = date(int(hijri_birthday.year),
int(hijri_birthday.month), int(hijri_birthday.day))
born = birthday.replace(year=today_date.year)
if born > today_date:
years = today_date.year - birthday.year - 1
else:
years = today_date.year - birthday.year
if today_date.month < birthday.month:
if today_date.day < birthday.day:
months = 12 - (birthday.month - today_date.month) - 1
else:
months = 12 - (birthday.month - today_date.month)
else:
if today_date.day < birthday.day and today_date.month != birthday.month:
months = today_date.month - birthday.month - 1
else:
months = today_date.month - birthday.month
if today_date.month == birthday.month:
if today_date.day >= birthday.day:
days = today_date.day - birthday.day
else:
days = birthday.day - today_date.day
else:
if today_date.day >= birthday.day:
days = today_date.day - birthday.day
else:
days = (30 - birthday.day) + today_date.day
res = str(years) + " سنة و" + str(months) + " شهر و " + str(
days) + "يوم"
rec.age_display = res
def get_date(passed_date=None,
passed_month=None,
passed_year=None,
en=False,
arabic=False):
if passed_date == None and passed_month == None and passed_year == None:
current_date_object = HijriDate.today()
else:
current_date_object = HijriDate(passed_year,
passed_month,
passed_date,
gr=True)
passed_year = int(current_date_object.year)
passed_month = int(current_date_object.month)
if arabic == 1:
passed_date = int(current_date_object.day)
else:
passed_date = int(current_date_object.day) - int(1)
passed_week = current_date_object.day_name_en
hijri_date_month_year_bn = {
'date': bangla.convert_english_digit_to_bangla_digit(passed_date),
'month': bangla.convert_english_digit_to_bangla_digit(passed_month),
'year': bangla.convert_english_digit_to_bangla_digit(passed_year),
'weekday': weekdays_dict[passed_week],
}
hijri_date_month_year_en = {
'date': passed_date,
'month': passed_month,
'year': passed_year,
'weekday': passed_week,
}
if en == 1:
return hijri_date_month_year_en
else:
return hijri_date_month_year_bn
def _hijri_week_of_year(date):
date_um = gregorian_to_hijri(date)
first_day_of_year_um = HijriDate(date_um.year, 1, 1)
first_day_of_year_gr = hijri_to_gregorian(first_day_of_year_um)
tdiff = date - first_day_of_year_gr
day_of_year = tdiff.days + 1
date_dow = date.isoweekday()
first_day_dow = first_day_of_year_gr.isoweekday()
weeknum = ((day_of_year + 6) / 7)
if date_dow < first_day_dow:
weeknum += 1
return weeknum
def gregorian_to_hijri(gregorian_date):
"""Convert a python datetime to a HijriDate
Args:
gregorian_date (datetime): date to convert
Returns:
ummalqurra.hijri_date.HijriDate
"""
day = gregorian_date.day
month = gregorian_date.month
year = gregorian_date.year
umalqurra_date = HijriDate(year, month, day, gr=True)
return umalqurra_date
def test_get_date_when_en_is_true(self):
today = HijriDate.today()
date = int(today.day) - int(1)
year = int(today.year)
month = int(today.month)
weekday = today.day_name_en
result = hijricalendar.get_date(en=True)
expect = {
'date': date,
'year': year,
'weekday': weekday,
'month': month
}
self.assertEquals(result, expect)
def test_get_date(self):
today = HijriDate.today()
date = bangla.convert_english_digit_to_bangla_digit(
int(today.day) - int(1))
year = bangla.convert_english_digit_to_bangla_digit(int(today.year))
month = bangla.convert_english_digit_to_bangla_digit(int(today.month))
weekday = hijricalendar.weekdays_dict[today.day_name_en]
result = hijricalendar.get_date()
expect = {
'date': date,
'year': year,
'weekday': weekday,
'month': month
}
self.assertEquals(result, expect)
def getAribaTime(t):
"""将日期字符串转换成阿拉伯日期"""
# print t
if t == 'Not recorded':
return 'None'
else:
date_time = datetime.datetime.strptime(t, '%d %B %Y')
w = date_time.weekday()
m = date_time.month
d = date_time.day
y = date_time.year
# print w,m,t
ld = HijriDate(y, m, d, gr=True)
# print ld,ld.month,m
return ld.month
pass
def middle_east_parsed_date(text_date, kwargs):
"""
:param text_date:
:param kwargs: format : %d-%m-%Y for 12-7-1397.
:return:
"""
dict_month_numeric = dict(
(v, k) for k, v in enumerate(calendar.month_name))
dict_month_abbr_numeric = dict(
(v, k) for k, v in enumerate(calendar.month_abbr))
day = -1
month = -1
year = -1
default_format = ["%d", "%m", "%Y"]
tsplit = split_non_alpha(text_date)
if "format" in kwargs:
format = kwargs["format"]
else:
format = default_format
if len(tsplit) != len(default_format):
#TODO: likely split characters next to each other 29101394
return None
for idx in range(0, len(tsplit)):
item = tsplit[idx]
if not isinstance(item, int) and not isinstance(item, float):
item = item.capitalize().strip()
if item in dict_month_numeric:
item = dict_month_numeric[item]
elif item in dict_month_abbr_numeric:
item = dict_month_abbr_numeric[item]
f_value = format[idx]
if f_value == "%d":
day = int(item)
elif f_value == "%m":
month = int(item)
elif f_value == "%Y":
year = int(item)
if month > 0 and day > 0 and year > 0:
if year < 1410:
jd = jdatetime.datetime(year, month, day)
return jd.togregorian()
if year < 1500:
um = HijriDate(year, month, day)
return datetime(um.year_gr, um.month_gr, um.day_gr)
return None
from umalqurra.hijri_date import HijriDate #create the object with Gregorian date um = HijriDate() #to see the day in Hijri print um.day # result : 3.0 print um.month #to see the month in Hijri # um.month #result is 6.0 # #year # um.year #1409 # #day name in arabic # #day in english # um.day_name_en #Tuesday # #month in Hijri Arabic # print um.month_name # #month in Gregorian English # um.month_name_gr #January # #year in Gregorian # um.year_gr #1989 # #month in Gregorian # um.month_gr # 1 # #day in Gregorian # um.day_gr # 10
def generate_file(self):
# TODO: must check all fields
fp = TemporaryFile()
header_key = '000000000000'
calendar_type = 'H'
current_date = HijriDate.today()
year = str(int(current_date.year)).zfill(4)
month = str(int(current_date.month)).zfill(2)
day = str(int(current_date.day)).zfill(2)
send_date = year + month + day
today = fields.Date.from_string(fields.Date.today())
value_date_g = today + relativedelta(days=14)
hijri_date = HijriDate(value_date_g.year,
value_date_g.month,
value_date_g.day,
gr=True)
value_date = str(int(hijri_date.year)).zfill(4) + str(
int(hijri_date.month)).zfill(2) + str(int(hijri_date.day)).zfill(2)
total_amount = str(self.amount_total).replace('.',
'').replace(',',
'').zfill(15)
total_employees = str(len(self.slip_ids)).zfill(8)
account_number = str(self.env.user.company_id.vat or '').zfill(13)
file_parameter = '1'
file_sequence = '01'
filler = ''.rjust(65, ' ')
file_dec = ''
file_dec += u'%s%s%s%s%s%s%s%s%s%s\n' % (
header_key, calendar_type, send_date, value_date, total_amount,
total_employees, account_number, file_parameter, file_sequence,
filler)
for playslip in self.slip_no_zero_ids:
employee = playslip.employee_id
# add line for each playslip
employee_number = employee.number.ljust(12, ' ')
# search account bank for this employee
banks = self.env['res.partner.bank'].search([
('employee_id', '=', employee.id), ('is_deposit', '=', True)
])
if not banks:
raise UserError(u"يجب إنشاء حساب بنكي للإيداع للموظف %s " %
employee.display_name)
employee_bank = banks[0]
employee_bank_id = employee_bank.bank_id.bic.ljust(4, ' ')
employee_account_number = employee_bank.acc_number.ljust(24, ' ')
employee_name = '*****'.ljust(50, ' ')
employee_amount = str(playslip.salary_net).replace(
'.', '').replace(',', '').zfill(15)
civilian_id = employee.identification_id and employee.identification_id.zfill(
15) or ''.zfill(15)
employee_id_type = '0'
process_flag = ' '
block_amount = ' '
kawadar_flag = ' '
filler = ''.rjust(11, ' ')
file_dec += u'%s%s%s%s%s%s%s%s%s%s%s\n' % (
employee_number, employee_bank_id, employee_account_number,
employee_name, employee_amount, civilian_id, employee_id_type,
process_flag, block_amount, kawadar_flag, filler)
# remove the \n
file_dec = file_dec[0:len(file_dec) - 1]
fp.write(file_dec.encode('utf-8'))
fp.seek(0)
bank_file_name = u'مسير جماعي شهر %s.%s' % (self.period_id.name,
'txt')
self.bank_file = base64.encodestring(fp.read())
self.bank_file_name = bank_file_name
fp.close()
return True
def convert_hijri_to_greg(day, month, year):
date = HijriDate(year, month, day)
return date
def get_today_date():
date = HijriDate.today()
return date
def prayertime(lv_zones):
doc_czones_qry = db.czones.find_one({"_id": lv_zones, "fxpara": {"$ne": "default"}})
lv_ftzone = doc_czones_qry.get('ftzone')
lv_txzone = ' '
if lv_ftzone == 7:
lv_txzone = 'WIB'
elif lv_ftzone == 8:
lv_txzone = 'WITA'
elif lv_ftzone == 9:
lv_txzone = 'WIT'
utctime = datetime.datetime.utcnow()
utctime = utctime.replace(minute=0, second=0, microsecond=0)
localtime = utctime + datetime.timedelta(hours = lv_ftzone)
#Getting midnight of localtime
localtime = localtime.replace(hour=0)
#Getting utctime for midnight of localtime
utcbegtime = localtime + datetime.timedelta(hours = -1*lv_ftzone)
utcendtime = utcbegtime + datetime.timedelta(hours = 24)
#Hijri function
hijritime = HijriDate(localtime.date().year, localtime.date().month, localtime.date().day, gr=True)
doc_chijri_qry = db.chijri.find_one({"_id": int(hijritime.month)})
lv_orihijriday = hijritime.day
hijritime.day = hijritime.day + doc_chijri_qry.get('fadjst')
if int(hijritime.day) == 30:
if doc_chijri_qry.get('f29flg') == True:
hijritime.day = 1
if hijritime.month == 12:
hijritime.month = 1
hijritime.year = hijritime.year + 1
else:
hijritime.month = hijritime.month + 1
elif int(lv_orihijriday) == 1:
if int(hijritime.month) == 1:
doc_chijri_qry = db.chijri.find_one({"_id": 12})
else:
doc_chijri_qry = db.chijri.find_one({"_id": int(hijritime.month)-1})
if doc_chijri_qry.get('f30flg') == True:
hijritime.day = 30
if int(hijritime.month) == 1:
hijritime.month = 12
hijritime.year = hijritime.year - 1
else:
hijritime.month = hijritime.month - 1
#End of Hijri function
msg = '*[Waktu Salat Hari Ini]*\n'
msg = '{}_{}, {} {} {} | '.format(msg, LOCAL_DAY[localtime.weekday()], localtime.day, LOCAL_MONTH[localtime.month], localtime.year)
msg = '{}{} {} {}\n'.format(msg, int(hijritime.day), HIJRI_MONTH[int(hijritime.month)], int(hijritime.year))
msg = '{}{} - {}_\n\n'.format(msg, doc_czones_qry.get('fdescr'), doc_czones_qry.get('fstate'))
msg = '{}```'.format(msg)
csched_qry = db.csched.find({"_id": {"$gt": utcbegtime, "$lt": utcendtime}, "fazfor.czones_id": lv_zones}).sort("_id", 1)
for doc_csched_qry in csched_qry:
for lv_fazfor in doc_csched_qry['fazfor']:
if lv_fazfor.get('czones_id') == lv_zones:
localtime = doc_csched_qry.get('_id') + datetime.timedelta(hours = lv_ftzone)
msg = '{}\n'.format(msg)
msg = '{}{:<6} - {} {}'.format(msg, lv_fazfor.get('ftypes'), localtime.strftime('%H:%M'), lv_txzone)
msg = '{}```\n\n'.format(msg)
msg = '{}[https://t.me/ID_AzanBot](https://t.me/ID_AzanBot)'.format(msg)
return msg
def get_azan(bot, job):
global add_job
# Latency monitoring 1
d1 = datetime.datetime.utcnow()
#Manipulate UTCTime to consider lead time of data fetching
utctime = datetime.datetime.utcnow() + datetime.timedelta(minutes = LEADTIME)
#Testing purpose
#utctime = datetime.datetime(2017, 7, 12, 4, 58)
utctime = utctime.replace(second=0, microsecond=0)
lv_mindt = job.context
utcadjtime = utctime + datetime.timedelta(minutes = lv_mindt)
doc_csched_qry = db.csched.find_one({"_id": utcadjtime})
if doc_csched_qry is not None:
for lv_fazfor in doc_csched_qry['fazfor']:
lv_zones = lv_fazfor.get('czones_id')
lv_ftypes = lv_fazfor.get('ftypes')
doc_czones_qry = db.czones.find_one({"_id": lv_zones, "fxpara": {"$ne": "default"}})
lv_ftzone = doc_czones_qry.get('ftzone')
lv_txzone = ' '
if lv_ftzone == 7:
lv_txzone = 'WIB'
elif lv_ftzone == 8:
lv_txzone = 'WITA'
elif lv_ftzone == 9:
lv_txzone = 'WIT'
cusers_qry = db.cusers.find({"czones_id": lv_zones, "fdsble": False, "fblock": False})
if cusers_qry.count() > 0:
localtime = utcadjtime + datetime.timedelta(hours = lv_ftzone)
#Hijri function
hijritime = HijriDate(localtime.date().year, localtime.date().month, localtime.date().day, gr=True)
doc_chijri_qry = db.chijri.find_one({"_id": int(hijritime.month)})
lv_orihijriday = hijritime.day
hijritime.day = hijritime.day + doc_chijri_qry.get('fadjst')
if int(hijritime.day) == 30:
if doc_chijri_qry.get('f29flg') == True:
hijritime.day = 1
if hijritime.month == 12:
hijritime.month = 1
hijritime.year = hijritime.year + 1
else:
hijritime.month = hijritime.month + 1
elif int(lv_orihijriday) == 1:
if int(hijritime.month) == 1:
doc_chijri_qry = db.chijri.find_one({"_id": 12})
else:
doc_chijri_qry = db.chijri.find_one({"_id": int(hijritime.month)-1})
if doc_chijri_qry.get('f30flg') == True:
hijritime.day = 30
if int(hijritime.month) == 1:
hijritime.month = 12
hijritime.year = hijritime.year - 1
else:
hijritime.month = hijritime.month - 1
#End of Hijri function
lv_msg = ''
if lv_ftypes != 'Imsak' and lv_ftypes != 'Terbit':
lv_msg = '{}*[Azan]* '.format(lv_msg)
lv_msg = '{}`{} - {} {}`\n\n'.format(lv_msg, lv_ftypes, localtime.strftime('%H:%M'), lv_txzone)
lv_msg = '{}_{}, {} {} {} | '.format(lv_msg, LOCAL_DAY[localtime.weekday()], localtime.day, LOCAL_MONTH[localtime.month], localtime.year)
lv_msg = '{}{} {} {}\n'.format(lv_msg, int(hijritime.day), HIJRI_MONTH[int(hijritime.month)], int(hijritime.year))
lv_msg = '{}{} - {}_'.format(lv_msg, doc_czones_qry.get('fdescr'), doc_czones_qry.get('fstate'))
lv_counter = 0
lv_second = 0
for doc_cusers_qry in cusers_qry:
lv_frmndr = doc_cusers_qry.get('frmndr')
msgtype = 0
msg = ''
utcrmndr = utctime + datetime.timedelta(minutes = lv_frmndr)
if utcadjtime == utctime:
msgtype = 1 # Notif
msg = lv_msg
elif utcadjtime == utcrmndr and lv_frmndr > 0:
msgtype = 2 # Reminder
msg = '*[Reminder]* `{} menit menuju waktu `{}'.format(lv_frmndr, lv_msg.replace('*[Azan]* ',''))
if msgtype > 0:
chat_id = doc_cusers_qry.get('_id')
#Testing purpose
#chat_id = xxxxxxxx
jobtime = utctime + datetime.timedelta(seconds = lv_second)
lv_context = []
lv_context.append(chat_id)
lv_context.append(msg)
lv_context.append(job.name)
lv_context.append(utctime)
lv_context.append(lv_zones)
if lv_ftypes == 'Imsak':
if doc_cusers_qry.get('fimsak') == True:
add_job.run_once(set_azan, jobtime, context=lv_context)
lv_counter += 1
elif lv_ftypes == 'Terbit':
if doc_cusers_qry.get('fsyurk') == True:
add_job.run_once(set_azan, jobtime, context=lv_context)
lv_counter += 1
else:
add_job.run_once(set_azan, jobtime, context=lv_context)
lv_counter += 1
if lv_counter%MAX_MESSAGE == 0:
lv_second += 1
# Job limit monitoring
#Testing purpose
#JOB_LIMIT = -1
if lv_second > JOB_LIMIT:
logger.error('[JOB LIMIT] Processing on {} exceeds the {}th second limit: {} seconds!'.format(utctime, JOB_LIMIT, lv_second))
try:
bot.send_message(chat_id=LOG_CHATID, text='[JOB LIMIT] Processing on {} exceeds the {}th second limit: {} seconds!'.format(utctime, JOB_LIMIT, lv_second))
except TelegramError as e:
logger.error('[JOB LIMIT NOTIFICATION] Failed to send job limit notification error: {}'.format(e.message))
else:
logger.info('No message to be sent on {} job {:<11} zone {:<4}'.format(utctime, job.name, lv_zones))
else:
logger.info('No message to be sent on {} job {:<11}'.format(utctime, job.name))
# Latency monitoring 2
d2 = datetime.datetime.utcnow()
lv_latency = (d2 - d1).total_seconds()
#Testing purpose
#LATENCY_LIMIT = 0
if lv_latency > LATENCY_LIMIT:
logger.error('[LATENCY] Processing on {} job {:<11} exceeds {} seconds limit: {} seconds!'.format(utctime, job.name, LATENCY_LIMIT, lv_latency))
try:
bot.send_message(chat_id=LOG_CHATID, text='[LATENCY] Processing on {} job {:<11} exceeds {} seconds limit: {} seconds!'.format(utctime, job.name, LATENCY_LIMIT, lv_latency))
except TelegramError as e:
logger.error('[LATENCY NOTIFICATION] Failed to send latency notification error: {}'.format(e.message))
def next(bot, update):
chat_id = update.message.chat_id
doc_cusers_qry = db.cusers.find_one({"_id": chat_id})
if doc_cusers_qry is not None:
lv_zones = doc_cusers_qry.get('czones_id')
if lv_zones is not None:
doc_czones_qry = db.czones.find_one({"_id": lv_zones, "fxpara": {"$ne": "default"}})
lv_ftzone = doc_czones_qry.get('ftzone')
lv_txzone = ' '
if lv_ftzone == 7:
lv_txzone = 'WIB'
elif lv_ftzone == 8:
lv_txzone = 'WITA'
elif lv_ftzone == 9:
lv_txzone = 'WIT'
utctime = datetime.datetime.utcnow()
localtime = utctime + datetime.timedelta(hours = lv_ftzone)
localtime = localtime.replace(hour=0, minute=0, second=0, microsecond=0)
#Getting midnight of localtime
# localtime = localtime.replace(hour=0)
#Getting utctime for midnight of localtime
# utcbegtime = localtime + datetime.timedelta(hours = -1*lv_ftzone)
# utcendtime = utcbegtime + datetime.timedelta(hours = 24)
csched_qry = db.csched.find({"_id": {"$gt": utctime}, "fazfor.czones_id": lv_zones}).sort("_id", 1)
msg = ''
for doc_csched_qry in csched_qry:
for lv_fazfor in doc_csched_qry['fazfor']:
if lv_fazfor.get('czones_id') == lv_zones:
localtime = doc_csched_qry.get('_id')
lv_diffs = (localtime - utctime).total_seconds()
localtime = localtime + datetime.timedelta(hours = lv_ftzone)
msg = '{}`{} - {} {}`\n\n'.format(msg, lv_fazfor.get('ftypes'), localtime.strftime('%H:%M'), lv_txzone)
break
break
#Hijri function
hijritime = HijriDate(localtime.date().year, localtime.date().month, localtime.date().day, gr=True)
doc_chijri_qry = db.chijri.find_one({"_id": int(hijritime.month)})
lv_orihijriday = hijritime.day
hijritime.day = hijritime.day + doc_chijri_qry.get('fadjst')
if int(hijritime.day) == 30:
if doc_chijri_qry.get('f29flg') == True:
hijritime.day = 1
if hijritime.month == 12:
hijritime.month = 1
hijritime.year = hijritime.year + 1
else:
hijritime.month = hijritime.month + 1
elif int(lv_orihijriday) == 1:
if int(hijritime.month) == 1:
doc_chijri_qry = db.chijri.find_one({"_id": 12})
else:
doc_chijri_qry = db.chijri.find_one({"_id": int(hijritime.month)-1})
if doc_chijri_qry.get('f30flg') == True:
hijritime.day = 30
if int(hijritime.month) == 1:
hijritime.month = 12
hijritime.year = hijritime.year - 1
else:
hijritime.month = hijritime.month - 1
#End of Hijri function
msg = '{}_{}, {} {} {} | '.format(msg, LOCAL_DAY[localtime.weekday()], localtime.day, LOCAL_MONTH[localtime.month], localtime.year)
msg = '{}{} {} {}\n'.format(msg, int(hijritime.day), HIJRI_MONTH[int(hijritime.month)], int(hijritime.year))
msg = '{}{} - {}_'.format(msg, doc_czones_qry.get('fdescr'), doc_czones_qry.get('fstate'))
lv_diffh = int(lv_diffs / 3600)
lv_diffm = int((lv_diffs % 3600) / 60) + ((lv_diffs % 3600) % 60 > 0)
if lv_diffm == 60:
lv_diffm = 0
lv_diffh += 1
if lv_diffh == 0 and lv_diffm > 0:
msg = '`{} menit menuju waktu `{}'.format(lv_diffm, msg)
elif lv_diffh == 0 and lv_diffm == 0:
msg = '`Tepat saat waktu `{}'.format(msg)
elif lv_diffh > 0 and lv_diffm == 0:
msg = '`{} jam menuju waktu `{}'.format(lv_diffh, msg)
elif lv_diffh > 0 and lv_diffm > 0:
msg = '`{} jam dan {} menit menuju waktu `{}'.format(lv_diffh, lv_diffm, msg)
update.message.reply_text(msg, parse_mode='Markdown')
else:
update.message.reply_text('Setting Zona belum dilakukan.\nGunakan perintah /setting untuk melakukan setting Zona.')
else:
update.message.reply_text('Setting Zona belum dilakukan.\nGunakan perintah /setting untuk melakukan setting Zona.')
if not 'test' in DBNAME:
Botan(BOTAN_TOKEN).track(update.message, event_name='next')
def hijri_day_range(min_date, max_date, periodic=False):
"""
Returns one set for each day in the range
If periodic is set to True, then it uses the day of month (31 days)
Args:
min_date (date): gregorian date to start the date range at
max_date (date): gregorian date to end the date range at
periodic (boolean): whether the date range should be periodic over the month
(day of week aggregation isn't handled in hijri since it
is the same in both calendars)
Returns:
{'type': 'days', 'bounds': bounds, 'date_sets': days, 'periodic': periodic}
bounds: bounding DateRange which the date sets contain
days: array of HijriDateSets
"""
min_date_gr = datetime.combine(min_date, datetime.min.time())
max_date_gr = datetime.combine(max_date, datetime.min.time())
min_date_um = gregorian_to_hijri(min_date_gr)
max_date_um = gregorian_to_hijri(max_date_gr)
bounds = DateRange(start=min_date_gr, end=max_date_gr)
years = xrange(int(min_date_um.year), int(max_date_um.year) + 1)
days = []
if periodic:
days = [
HijriDateSet(key=str(day),
label=[{
'text': str(day),
'translate': False
}],
ranges=[]) for day in xrange(1, 31)
]
for year in years:
max_month = 12
if max_date_um.year == year:
max_month = int(max_date_um.month)
for month in xrange(int(min_date_um.month), max_month + 1):
start_date_um = HijriDate(year, month, 1)
if hijri_to_gregorian(min_date_um) > hijri_to_gregorian(
start_date_um):
start_date_um = min_date_um
end_year = year
end_month = month + 1
if end_month >= 12:
end_year = year + 1
end_month = 1
end_date_um = HijriDate(end_year, end_month, 1)
end_date_gr = hijri_to_gregorian(end_date_um)
delta = timedelta(days=1)
last_date_gr = end_date_gr - delta
last_date_um = HijriDate(last_date_gr.year,
last_date_gr.month,
last_date_gr.day,
gr=True)
if hijri_to_gregorian(max_date_um) < hijri_to_gregorian(
last_date_um):
last_date_um = max_date_um
for day in xrange(int(start_date_um.day),
int(last_date_um.day) + 1):
day_um = HijriDate(year, month, day)
day_gr = hijri_to_gregorian(day_um)
next_greg_day = day_gr + delta
day_range = DateRange(start=local_tz.localize(day_gr),
end=local_tz.localize(next_greg_day))
if periodic:
days[day - 1].ranges.append(day_range)
else:
days.append(
HijriDateSet(
key='{}/{}/{}'.format(int(day_um.day),
int(day_um.month),
int(day_um.year)),
label=[{
'text':
u'{} {}\u060c {}'.format( # arabic comma
int(day_um.day),
day_um.month_name.decode('utf-8'),
int(day_um.year)),
'translate':
False
}],
ranges=[day_range]))
return {
'type': 'days',
'bounds': bounds,
'date_sets': days,
'periodic': periodic
}
def hijri_month_range(min_date, max_date, periodic=False):
"""Get an array of start and end dates for each month in the given gregorian date range.
Date ranges have an inclusive start and exclusive end date.
Note:
calculate start of month as the first day of the month, converted to gregorian
calculate end of month as the first day of the next month, converted to gregorian
Any ranges should use GTE start, LT end
Returns all 12 months for periodic, even if they don't have a date range
Args:
min_date (date): gregorian date to start the date range at
max_date (date): gregorian date to end the date range at
periodic (boolean): whether the date range should be periodic over the year
Returns:
{'type': 'months', 'bounds': bounds, 'date_sets': days, 'periodic': periodic}
bounds: bounding DateRange which the date sets contain
days: array of HijriDateSets
"""
min_date = datetime.combine(min_date, datetime.min.time())
max_date = datetime.combine(max_date, datetime.min.time())
min_date_um = gregorian_to_hijri(min_date)
max_date_um = gregorian_to_hijri(max_date)
bounds = DateRange(start=min_date, end=max_date)
years = xrange(int(min_date_um.year), int(max_date_um.year) + 1)
months = []
min_month = int(min_date_um.month)
if periodic:
months = [
HijriDateSet(key=month_num,
label=[{
'text': month,
'translate': False
}],
ranges=[])
for month, month_num in [(
HijriDate(1437, x, 1).month_name.decode('utf-8'), x)
for x in xrange(1, 13)]
]
min_month = 1
for year in years:
for month in xrange(min_month, 13):
start_date_um = HijriDate(year, month, 1)
start_date_gr = hijri_to_gregorian(start_date_um)
end_year = year
end_month = month + 1
if end_month > 12:
end_year = year + 1
end_month = 1
end_date_um = HijriDate(end_year, end_month, 1)
end_date_gr = hijri_to_gregorian(end_date_um)
month_range = DateRange(start=local_tz.localize(start_date_gr),
end=local_tz.localize(end_date_gr))
if periodic:
months[month - 1].ranges.append(month_range)
else:
if max_date < hijri_to_gregorian(HijriDate(year, month, 1)):
break
months.append(
HijriDateSet(
key=month,
label=[{
'text':
u'{} {}'.format(
start_date_um.month_name.decode('utf-8'),
int(start_date_um.year)),
'translate':
False
}],
ranges=[month_range]))
min_month = 1 # reset min_month to 1, it should only limit the first year
return {
'type': 'months',
'bounds': bounds,
'date_sets': months,
'periodic': periodic
}
