def auto_status_update_ms(doc, method):
new = add_years(doc.installation_date, doc.guarantee_period)
validdate_amc1=add_days(new,-1)
doc.amc_guarantee_valid_upto_date=validdate_amc1
new = add_days(new, days=-1)
if doc.guarantee_period==0:
doc.amc_guarantee_valid_upto_date=""
doc.amc_status="N/A"
frappe.throw("Enter The Guarantee Period")
else:
doc.amc_guarantee_valid_upto_date = new
# if doc.transaction_date
# doc.amc_status = "Untraceable"
# if date_diff(doc.transaction_date,doc.installation_date)<=365*doc.contract_period:
# doc.amc_status = "N/A"
if doc.amc_guarantee_valid_upto_date>doc.transaction_date:
doc.amc_status = "Guarantee"
else:
doc.amc_status="Expired"
if doc.amc_start_month:
guarntee=add_years(doc.amc_start_month,doc.contract_period)
validdate_amc=add_days(guarntee,-1)
doc.amc_guarantee_valid_upto_date=validdate_amc
guarntee = add_days(guarntee, days=-1)
doc.amc_guarantee_valid_upto_date=guarntee
doc.amc_status = "AMC"
if getdate(doc.transaction_date) > getdate(doc.installation_date):
frappe.throw("Installation Date Should be Greater Than Equal To Transaction Date")
def calculate_next_due_date(periodicity,
start_date=None,
end_date=None,
last_completion_date=None,
next_due_date=None):
if not start_date and not last_completion_date:
start_date = frappe.utils.now()
if last_completion_date and (
(start_date and last_completion_date > start_date) or not start_date):
start_date = last_completion_date
if periodicity == 'Daily':
next_due_date = add_days(start_date, 1)
if periodicity == 'Weekly':
next_due_date = add_days(start_date, 7)
if periodicity == 'Monthly':
next_due_date = add_months(start_date, 1)
if periodicity == 'Yearly':
next_due_date = add_years(start_date, 1)
if periodicity == '2 Yearly':
next_due_date = add_years(start_date, 2)
if periodicity == 'Quarterly':
next_due_date = add_months(start_date, 3)
if end_date and ((start_date and start_date >= end_date) or
(last_completion_date
and last_completion_date >= end_date) or next_due_date):
next_due_date = ""
return next_due_date
def validation_from_student_admission(self):
student_admission = get_student_admission_data(
self.student_admission, self.program)
if student_admission and student_admission.min_age and \
date_diff(nowdate(), add_years(getdate(self.date_of_birth), student_admission.min_age)) < 0:
frappe.throw(
_("Not eligible for the admission in this program as per Date Of Birth"))
if student_admission and student_admission.max_age and \
date_diff(nowdate(), add_years(getdate(self.date_of_birth), student_admission.max_age)) > 0:
frappe.throw(
_("Not eligible for the admission in this program as per Date Of Birth"))
def prepare_periodical_data(self):
self.period_wise_data = {}
from_date = add_years(self.filters.from_date, cint(self.filters.no_of_years) * -1)
self.period_list = get_period_list(from_date, self.filters.to_date,
from_date, self.filters.to_date, "Date Range", self.filters.periodicity, ignore_fiscal_year=True)
order_data = self.get_data_for_forecast() or []
for entry in order_data:
key = (entry.item_code, entry.warehouse)
if key not in self.period_wise_data:
self.period_wise_data[key] = entry
period_data = self.period_wise_data[key]
for period in self.period_list:
# check if posting date is within the period
if (entry.posting_date >= period.from_date and entry.posting_date <= period.to_date):
period_data[period.key] = period_data.get(period.key, 0.0) + flt(entry.get(self.based_on_field))
for key, value in self.period_wise_data.items():
list_of_period_value = [value.get(p.key, 0) for p in self.period_list]
if list_of_period_value:
total_qty = [1 for d in list_of_period_value if d]
if total_qty:
value["avg"] = flt(sum(list_of_period_value)) / flt(sum(total_qty))
def validate(self):
member_name = frappe.get_value('Member',
dict(email=frappe.session.user))
if not member_name:
user = frappe.get_doc('User', frappe.session.user)
member = frappe.get_doc(
dict(doctype='Member',
email=frappe.session.user,
member_name=user.get_fullname())).insert(
ignore_permissions=True)
member_name = member.name
self.member = member_name
# get last membership (if active)
last_membership = foundation.get_last_membership()
if last_membership:
# if last membership does not expire in 30 days, then do not allow to renew
if getdate(add_days(last_membership.to_date, -30)) > getdate(
nowdate()):
frappe.throw(
_('You can only renew if your membership expires within 30 days'
))
self.from_date = add_days(last_membership.to_date, 1)
else:
self.from_date = nowdate()
self.to_date = add_years(self.from_date, 1)
def register(args_data):
"""Register on the hub."""
try:
args = json.loads(args_data)
if frappe.get_all("Hub User",
filters={"hub_user_email": args["hub_user_email"]}):
# Renabling user
return
hub_company = frappe.new_doc("Hub Company")
hub_company.company_name = args["company"]
for key in ["country"] + seller_fields:
hub_company.set(key, args[key])
hub_company.insert(ignore_permissions=True)
hub_user = frappe.new_doc("Hub User")
for key in user_profile_fields + seller_fields:
hub_user.set(key, args[key])
hub_user.set("company_name", args["company"])
hub_user.enabled = 1
hub_user.last_sync_datetime = add_years(now(), -10)
hub_user.insert(ignore_permissions=True)
# set created user link for company
hub_company.hub_user_name = args["hub_user_name"]
hub_company.save(ignore_permissions=True)
response = hub_user.as_dict()
return response
except:
print("Server Exception")
print(frappe.get_traceback())
def validate(self):
member_name = frappe.get_value('Member', dict(email=frappe.session.user))
if not member_name:
user = frappe.get_doc('User', frappe.session.user)
member = frappe.get_doc(dict(
doctype='Member',
email=frappe.session.user,
member_name=user.get_fullname()
)).insert(ignore_permissions=True)
member_name = member.name
if self.get("__islocal"):
self.member = member_name
# get last membership (if active)
last_membership = foundation.get_last_membership()
# if person applied for offline membership
if last_membership and not frappe.session.user == "Administrator":
# if last membership does not expire in 30 days, then do not allow to renew
if getdate(add_days(last_membership.to_date, -30)) > getdate(nowdate()) :
frappe.throw(_('You can only renew if your membership expires within 30 days'))
self.from_date = add_days(last_membership.to_date, 1)
elif frappe.session.user == "Administrator":
self.from_date = self.from_date
else:
self.from_date = nowdate()
self.to_date = add_years(self.from_date, 1)
def get_timeline_data(doctype, name):
'''returns timeline data for the past one year'''
from frappe.desk.form.load import get_communication_data
out = {}
fields = 'creation, count(*)'
after = add_years(None, -1).strftime('%Y-%m-%d')
group_by='group by Date(creation)'
data = get_communication_data(doctype, name, after=after, group_by='group by creation',
fields='C.creation as creation, count(C.name)',as_dict=False)
# fetch and append data from Activity Log
data += frappe.db.sql("""select {fields}
from `tabActivity Log`
where (reference_doctype=%(doctype)s and reference_name=%(name)s)
or (timeline_doctype in (%(doctype)s) and timeline_name=%(name)s)
or (reference_doctype in ("Quotation", "Opportunity") and timeline_name=%(name)s)
and status!='Success' and creation > {after}
{group_by} order by creation desc
""".format(fields=fields, group_by=group_by, after=after), {
"doctype": doctype,
"name": name
}, as_dict=False)
timeline_items = dict(data)
for date, count in iteritems(timeline_items):
timestamp = get_timestamp(date)
out.update({ timestamp: count })
return out
def auto_create_fiscal_year():
print "Meso"
for d in frappe.db.sql(
"""select name from `tabFiscal Year` where year_end_date = date_add(current_date, interval 3 day)"""
):
try:
current_fy = frappe.get_doc("Fiscal Year", d[0])
print current_fy
new_fy = frappe.copy_doc(current_fy, ignore_no_copy=False)
new_fy.year_start_date = add_days(current_fy.year_end_date, 1)
new_fy.year_end_date = add_years(current_fy.year_end_date, 1)
start_year = cstr(new_fy.year_start_date.year)
end_year = cstr(new_fy.year_end_date.year)
new_fy.year = start_year if start_year == end_year else (
start_year + "-" + end_year)
frappe.msgprint(
str(start_year if start_year == end_year else (start_year +
"-" +
end_year)))
new_fy.insert(ignore_permissions=True)
#Edited by Maysaa
frappe.db.set_value(
"Global Defaults", None, "current_fiscal_year",
start_year if start_year == end_year else
(start_year + "-" + end_year))
global_defaults = frappe.get_doc("Global Defaults")
global_defaults.check_permission("write")
global_defaults.on_update()
# clear cache
frappe.clear_cache()
except frappe.NameError:
pass
def get_events(self, remote_objectname, filters, page_length):
page_token = None
results = []
events = {"items": []}
while True:
try:
events = self.gcalendar.events().list(calendarId=self.account.gcalendar_id, maxResults=page_length,
singleEvents=False, showDeleted=True, syncToken=self.account.next_sync_token or None).execute()
except HttpError as err:
if err.resp.status in [410]:
events = self.gcalendar.events().list(calendarId=self.account.gcalendar_id, maxResults=page_length,
singleEvents=False, showDeleted=True, timeMin=add_years(None, -1).strftime('%Y-%m-%dT%H:%M:%SZ')).execute()
else:
frappe.log_error(err.resp, "GCalendar Events Fetch Error")
for event in events['items']:
event.update({'account': self.account.name})
event.update({'calendar_tz': events['timeZone']})
results.append(event)
page_token = events.get('nextPageToken')
if not page_token:
if events.get('nextSyncToken'):
frappe.db.set_value("GCalendar Account", self.connector.username, "next_sync_token", events.get('nextSyncToken'))
break
return list(results)
def get_timeline_data(doctype, name):
'''returns timeline data for the past one year'''
from frappe.desk.form.load import get_communication_data
out = {}
fields = 'date(creation), count(name)'
after = add_years(None, -1).strftime('%Y-%m-%d')
group_by='group by date(creation)'
data = get_communication_data(doctype, name,
fields=fields, after=after, group_by=group_by, as_dict=False)
# fetch and append data from Activity Log
data += frappe.db.sql("""select {fields}
from `tabActivity Log`
where reference_doctype="{doctype}" and reference_name="{name}"
and status!='Success' and creation > {after}
{group_by} order by creation desc
""".format(doctype=frappe.db.escape(doctype), name=frappe.db.escape(name), fields=fields,
group_by=group_by, after=after), as_dict=False)
timeline_items = dict(data)
for date, count in iteritems(timeline_items):
timestamp = get_timestamp(date)
out.update({ timestamp: count })
return out
def validate(self):
if not self.member or not frappe.db.exists("Member", self.member):
member_name = frappe.get_value('Member', dict(email=frappe.session.user))
if not member_name:
user = frappe.get_doc('User', frappe.session.user)
member = frappe.get_doc(dict(
doctype='Member',
email=frappe.session.user,
membership_type=self.membership_type,
member_name=user.get_fullname()
)).insert(ignore_permissions=True)
member_name = member.name
if self.get("__islocal"):
self.member = member_name
# get last membership (if active)
last_membership = erpnext.get_last_membership()
# if person applied for offline membership
if last_membership and not frappe.session.user == "Administrator":
# if last membership does not expire in 30 days, then do not allow to renew
if getdate(add_days(last_membership.to_date, -30)) > getdate(nowdate()) :
frappe.throw(_('You can only renew if your membership expires within 30 days'))
self.from_date = add_days(last_membership.to_date, 1)
elif frappe.session.user == "Administrator":
self.from_date = self.from_date
else:
self.from_date = nowdate()
self.to_date = add_years(self.from_date, 1)
def get_scorecard_date(period, start_date):
if period == 'Per Week':
end_date = getdate(add_days(start_date, 7))
elif period == 'Per Month':
end_date = get_last_day(start_date)
elif period == 'Per Year':
end_date = add_days(add_years(start_date, 1), -1)
return end_date
def get_timeline_data(doctype, name):
'''returns timeline data for the past one year'''
from frappe.desk.form.load import get_communication_data
data = get_communication_data(doctype, name,
fields = 'unix_timestamp(date(creation)), count(name)',
after = add_years(None, -1).strftime('%Y-%m-%d'),
group_by='group by date(creation)', as_dict=False)
return dict(data)
def auto_status_update_ms(doc, method): new = add_years(doc.installation_date, doc.guarantee_period) new = add_days(new, days=-1) doc.amc_guarantee_valid_upto_date = new if doc.transaction_date: doc.amc_status = "Untraceable" elif date_diff(doc.transaction_date,doc.installation_date)<=365*doc.contract_period: doc.amc_status = "N/A" elif doc.amc_guarantee_valid_upto_date>doc.transaction_date: doc.amc_status = "Guarantee" else: doc.amc_status="Expired" if doc.amc_start_month: guarntee=add_years(doc.amc_start_month,doc.contract_period) guarntee = add_days(guarntee, days=-1) doc.amc_guarantee_valid_upto_date=guarntee doc.amc_status = "AMC"
def make_holiday_list(self):
if not frappe.db.get_value("Holiday List", "Salary Structure Test Holiday List"):
holiday_list = frappe.get_doc({
"doctype": "Holiday List",
"holiday_list_name": "Salary Structure Test Holiday List",
"from_date": nowdate(),
"to_date": add_years(nowdate(), 1),
"weekly_off": "Sunday"
}).insert()
holiday_list.get_weekly_off_dates()
holiday_list.save()
def make_holiday_list(self):
if not frappe.db.get_value("Holiday List", "Salary Slip Test Holiday List"):
holiday_list = frappe.get_doc({
"doctype": "Holiday List",
"holiday_list_name": "Salary Slip Test Holiday List",
"from_date": nowdate(),
"to_date": add_years(nowdate(), 1),
"weekly_off": "Sunday"
}).insert()
holiday_list.get_weekly_off_dates()
holiday_list.save()
def get_timeline_data(doctype, name):
'''returns timeline data for the past one year'''
from frappe.desk.form.load import get_communication_data
data = get_communication_data(
doctype,
name,
fields='unix_timestamp(date(creation)), count(name)',
after=add_years(None, -1).strftime('%Y-%m-%d'),
group_by='group by date(creation)',
as_dict=False)
return dict(data)
def get_retirement_date(date_of_birth=None):
ret = {}
if date_of_birth:
try:
retirement_age = int(frappe.db.get_single_value("HR Settings", "retirement_age") or 60)
dt = add_years(getdate(date_of_birth),retirement_age)
ret = {'date_of_retirement': dt.strftime('%Y-%m-%d')}
except ValueError:
# invalid date
ret = {}
return ret
def get_retirement_date(date_of_birth=None):
ret = {}
if date_of_birth:
try:
retirement_age = int(frappe.db.get_single_value("HR Settings", "retirement_age") or 60)
dt = add_years(getdate(date_of_birth),retirement_age)
ret = {'date_of_retirement': dt.strftime('%Y-%m-%d')}
except ValueError:
# invalid date
ret = {}
return ret
def add_age_to_filter(filters, doctype, field, date):
from frappe.utils import now_datetime, add_days, add_months, add_years, get_datetime_str
if date == "All Time":
return filters
today = now_datetime()
selected_dates = {
'Last 7 Days': [add_days(today,-6)],
'Last 30 Days': [add_days(today,-29)],
'This Month': [add_days(today, -today.day)],
'Last Month': [add_months(add_days(today, -today.day),-1), add_days(today, -today.day-1)],
'Last 3 Months': [add_months(add_days(today, -today.day),-3)],
'This Financial Year': [frappe.db.get_default("year_start_date"),frappe.db.get_default("year_end_date")],
'Last Financial Year': [add_years(frappe.db.get_default("year_start_date"), -1),
add_years(frappe.db.get_default("year_end_date"), -1)]
}[date]
if len(selected_dates)==2:
return filters + [[ doctype, field,">", get_datetime_str(selected_dates[0]) ],
[ doctype, field, "<", get_datetime_str(selected_dates[1]) ]]
else:
return filters + [[ doctype, field, ">", get_datetime_str(selected_dates[0]) ]]
def get_retirement_date_for_gender(date_of_birth=None, gender=None):
ret = {}
if date_of_birth and gender:
try:
if gender == 'Male':
retirement_age = int(frappe.db.get_single_value("HR Settings", "retirement_age_for_male") or 60)
elif gender == 'Female':
retirement_age = int(frappe.db.get_single_value("HR Settings", "retirement_age_for_female") or 55)
dt = add_years(getdate(date_of_birth), retirement_age)
ret = {'date_of_retirement': dt.strftime('%Y-%m-%d')}
except ValueError:
# invalid date
ret = {}
return ret
def validate_admission_age(self):
student_admission = get_student_admission_data(self.student_admission,
self.program)
if student_admission and student_admission.cutoff_birthdate and getdate(
self.date_of_birth) > getdate(
student_admission.cutoff_birthdate):
frappe.throw(
_("{0} is not eligible for admission to this program as per date of birth."
).format(self.title))
if student_admission and student_admission.maximum_age and date_diff(
nowdate(),
add_years(get_date(self.date_of_birth),
student_admission.maximum_age)) > 0:
frappe.throw(
_("{0} is not eligible for admission to this program as per date of birth."
).format(self.title))
def get_timeline_data(doctype, name):
'''returns timeline data for the past one year'''
from frappe.desk.form.load import get_communication_data
out = {}
data = get_communication_data(doctype, name,
fields = 'date(creation), count(name)',
after = add_years(None, -1).strftime('%Y-%m-%d'),
group_by='group by date(creation)', as_dict=False)
timeline_items = dict(data)
for date, count in timeline_items.iteritems():
timestamp = get_timestamp(date)
out.update({ timestamp: count })
return out
def auto_create_fiscal_year():
for d in frappe.db.sql("""select name from `tabFiscal Year` where year_end_date = date_add(current_date, interval 3 day)"""):
try:
current_fy = frappe.get_doc("Fiscal Year", d[0])
new_fy = frappe.copy_doc(current_fy, ignore_no_copy=False)
new_fy.year_start_date = add_days(current_fy.year_end_date, 1)
new_fy.year_end_date = add_years(current_fy.year_end_date, 1)
start_year = cstr(new_fy.year_start_date.year)
end_year = cstr(new_fy.year_end_date.year)
new_fy.year = start_year if start_year==end_year else (start_year + "-" + end_year)
new_fy.insert(ignore_permissions=True)
except frappe.NameError:
pass
def auto_create_fiscal_year():
for d in frappe.db.sql("""select name from `tabFiscal Year` where year_end_date = date_add(current_date, interval 3 day)"""):
try:
current_fy = frappe.get_doc("Fiscal Year", d[0])
new_fy = frappe.copy_doc(current_fy, ignore_no_copy=False)
new_fy.year_start_date = add_days(current_fy.year_end_date, 1)
new_fy.year_end_date = add_years(current_fy.year_end_date, 1)
start_year = cstr(new_fy.year_start_date.year)
end_year = cstr(new_fy.year_end_date.year)
new_fy.year = start_year if start_year==end_year else (start_year + "-" + end_year)
new_fy.insert()
except frappe.NameError:
pass
def auto_create_fiscal_year():
for d in frappe.db.sql("""select name from `tabFiscal Year` where year_end_date =(current_date + 3)"""):
try:
current_fy = frappe.get_doc("Fiscal Year", d[0])
new_fy = frappe.copy_doc(current_fy)
new_fy.year_start_date = add_days(current_fy.year_end_date, 1)
new_fy.year_end_date = add_years(current_fy.year_end_date, 1)
start_year = new_fy.year_start_date[:4]
end_year = new_fy.year_end_date[:4]
new_fy.year = start_year if start_year==end_year else (start_year + "-" + end_year)
new_fy.insert()
except frappe.NameError:
pass
def auto_create_fiscal_year():
for d in frappe.db.sql("""select name from `tabFiscal Year` where year_end_date =(current_date + 3)"""):
try:
current_fy = frappe.get_doc("Fiscal Year", d[0])
new_fy = frappe.copy_doc(current_fy)
new_fy.year_start_date = add_days(current_fy.year_end_date, 1)
new_fy.year_end_date = add_years(current_fy.year_end_date, 1)
start_year = new_fy.year_start_date[:4]
end_year = new_fy.year_end_date[:4]
new_fy.year = start_year if start_year==end_year else (start_year + "-" + end_year)
new_fy.insert()
except frappe.NameError:
pass
def get_timeline_data(doctype, name):
'''returns timeline data for the past one year'''
from frappe.desk.form.load import get_communication_data
out = {}
data = get_communication_data(doctype, name,
fields = 'date(creation), count(name)',
after = add_years(None, -1).strftime('%Y-%m-%d'),
group_by='group by date(creation)', as_dict=False)
timeline_items = dict(data)
for date, count in timeline_items.iteritems():
timestamp = get_timestamp(date)
out.update({ timestamp: count })
return out
def validate(self):
# get last membership (if active)
last_membership = erpnext.get_last_membership()
# if person applied for offline membership
if last_membership and not frappe.session.user == "Administrator":
# if last membership does not expire in 30 days, then do not allow to renew
if getdate(add_days(last_membership.to_date, -30)) > getdate(nowdate()) :
frappe.throw(_('You can only renew if your membership expires within 30 days'))
self.from_date = add_days(last_membership.to_date, 1)
elif frappe.session.user == "Administrator":
self.from_date = self.from_date
else:
self.from_date = nowdate()
self.to_date = add_years(self.from_date, 1)
def validate_membership_period(self):
# get last membership (if active)
last_membership = erpnext.get_last_membership(self.member)
# if person applied for offline membership
if last_membership and not frappe.session.user == "Administrator":
# if last membership does not expire in 30 days, then do not allow to renew
if getdate(add_days(last_membership.to_date, -30)) > getdate(nowdate()) :
frappe.throw(_("You can only renew if your membership expires within 30 days"))
self.from_date = add_days(last_membership.to_date, 1)
elif frappe.session.user == "Administrator":
self.from_date = self.from_date
else:
self.from_date = nowdate()
if frappe.db.get_single_value("Non Profit Settings", "billing_cycle") == "Yearly":
self.to_date = add_years(self.from_date, 1)
else:
self.to_date = add_months(self.from_date, 1)
def validate(self):
# get last membership (if active)
last_membership = erpnext.get_last_membership()
# if person applied for offline membership
if last_membership and not frappe.session.user == "Administrator":
# if last membership does not expire in 30 days, then do not allow to renew
if getdate(add_days(last_membership.to_date, -30)) > getdate(
nowdate()):
frappe.throw(
_('You can only renew if your membership expires within 30 days'
))
self.from_date = add_days(last_membership.to_date, 1)
elif frappe.session.user == "Administrator":
self.from_date = self.from_date
else:
self.from_date = nowdate()
self.to_date = add_years(self.from_date, 1)
def validate(doc, method):
delelte_all_related_practitioner_availability_detail(doc)
if not doc.repeat_this_event:
detail_doc = create_practitioner_availability_detail(
doc, doc.from_date)
detail_doc.insert(ignore_permissions=True)
else:
start_date = doc.from_date
end_date = doc.repeat_till
current_date = start_date
if doc.repeat_on == "Every Year":
while check_dates(current_date, end_date):
detail_doc = create_practitioner_availability_detail(
doc, current_date)
detail_doc.insert(ignore_permissions=True)
current_date = add_years(current_date, 1)
elif doc.repeat_on == "Every Month":
while check_dates(current_date, end_date):
detail_doc = create_practitioner_availability_detail(
doc, current_date)
detail_doc.insert(ignore_permissions=True)
current_date = add_months(current_date, 1)
elif doc.repeat_on == "Every Week":
while check_dates(current_date, end_date):
detail_doc = create_practitioner_availability_detail(
doc, current_date)
detail_doc.insert(ignore_permissions=True)
current_date = add_days(current_date, 7)
elif doc.repeat_on == "Every Day":
while check_dates(current_date, end_date):
weekday = get_weekday(current_date)
if doc.get(weekday):
detail_doc = create_practitioner_availability_detail(
doc, current_date)
detail_doc.insert(ignore_permissions=True)
current_date = add_days(current_date, 1)
def get_events(self, remote_objectname, filters, page_length):
page_token = None
results = []
events = {"items": []}
while True:
try:
events = self.gcalendar.events().list(
calendarId=self.account.gcalendar_id,
maxResults=page_length,
singleEvents=False,
showDeleted=True,
syncToken=self.account.next_sync_token or None).execute()
except HttpError as err:
if err.resp.status in [410]:
events = self.gcalendar.events().list(
calendarId=self.account.gcalendar_id,
maxResults=page_length,
singleEvents=False,
showDeleted=True,
timeMin=add_years(
None,
-1).strftime('%Y-%m-%dT%H:%M:%SZ')).execute()
else:
frappe.log_error(err.resp, "GCalendar Events Fetch Error")
for event in events['items']:
event.update({'account': self.account.name})
event.update({'calendar_tz': events['timeZone']})
results.append(event)
page_token = events.get('nextPageToken')
if not page_token:
if events.get('nextSyncToken'):
frappe.db.set_value("GCalendar Account",
self.connector.username,
"next_sync_token",
events.get('nextSyncToken'))
break
return list(results)
def update_item(source, target, source_parent):
if source.is_maintenance_applicable_cf == 0:
frappe.msgprint(_(
'Delivery Note item <b>{0}</b> has no value for <i>Is Maintenance Applicable ?</i>'
).format(source.item_code),
title='Maintenance Schedule cannot be created.')
return False
elif source.is_maintenance_applicable_cf == 1:
if source.maintenance_for_years_cf < 2:
frappe.msgprint(_(
'Delivery Note item <b>{0}</b> has <i>Maintenance For Years</i> values as <b>{1}</b>. <br> It should be greater than 1.'
).format(source.item_code, source.maintenance_for_years_cf),
title='Incorrect Maintenance For Years values.'
)
return False
# + 1
target.start_date = add_days(source_parent.posting_date, 1)
target.end_date = add_years(target.start_date,
source.maintenance_for_years_cf)
target.periodicity = 'Yearly'
target.no_of_visits = source.maintenance_for_years_cf
target.serial_no = source.serial_no
target.sales_person = sales_person_name or 'Sales Team'
def create_member(customer_id, plan, pan=None):
client = get_client()
customer = frappe._dict(client.customer.fetch(customer_id))
# defaults
today = getdate()
plan = frappe.db.exists("Membership Type", {"razorpay_plan_id": plan})
member = frappe.new_doc("Member")
member.update({
"member_name": customer.name,
"membership_type": plan,
"pan_number": pan,
"email_id": customer.email,
"contact": customer.contact,
"customer_id": customer_id,
"subscription_activated": 1,
"token_status": "Initiated",
"subscription_start": today,
"subscription_end": add_years(today, 2),
})
member.insert(ignore_permissions=True)
return member.name
from frappe.model.document import Document
from frappe.utils.user import get_enabled_system_users
from frappe.desk.reportview import get_filters_cond
from frappe.utils import (getdate, cint, add_months, date_diff, add_days,
add_years, nowdate, get_datetime_str, cstr,
get_datetime, now_datetime, format_datetime)
from frappe.utils.background_jobs import enqueue
from erpnext.hr.doctype.employee.employee import get_employee_emails
weekdays = [
"monday", "tuesday", "wednesday", "thursday", "friday", "saturday",
"sunday"
]
max_repeat_till = add_years(nowdate(), 1)
class vBookingEvent(Document):
def validate(self):
self.employee_emails = ', '.join(
get_employee_emails([d.employee for d in self.employees]))
if not self.starts_on:
self.starts_on = now_datetime()
if self.starts_on and self.ends_on and get_datetime(
self.starts_on) > get_datetime(self.ends_on):
frappe.msgprint(frappe._("Event end must be after start"),
raise_exception=True)
def add_year(date): return utils.add_years(date, 1)
def set_salary_structure_for_all(doc):
employees = frappe.get_list(
"Employee", filters={"status": "Active"}, fields=["*"])
for emp in employees:
ss = frappe.get_doc({
"name":
emp.employee_name,
"doctype":
"Salary Structure",
"company":
doc.company,
"is_active":
"Yes",
"payroll_frequency":
"Monthly",
"is_default":
"Yes",
"payment_account":
get_default_payroll_payable_account(doc),
"employees": [{
"docstatus": 0,
"doctype": "Salary Structure Employee",
"name": "New Salary Structure Employee 1",
"__islocal": 1,
"__unsaved": 1,
"owner": frappe.session.user,
"parent": "New Salary Structure 1",
"parentfield": "employees",
"parenttype": "Salary Structure",
"idx": 1,
"company": doc.company,
"employee_name": emp.employee_name,
"employee": emp.name,
"from_date": today(),
"base": 0,
"to_date": add_years(today(), 1)
}],
"earnings": [{
"docstatus": 0,
"doctype": "Salary Detail",
"name": "New Salary Detail 1",
"__islocal": 1,
"__unsaved": 1,
"owner": frappe.session.user,
"amount_based_on_formula": 1,
"parent": "New Salary Structure 1",
"parentfield": "earnings",
"parenttype": "Salary Structure",
"idx": 1,
"__unedited": 0,
"abbr": "B",
"salary_component": "Basic",
"amount": 0
}, {
"docstatus": 0,
"doctype": "Salary Detail",
"name": "New Salary Detail 2",
"__islocal": 1,
"__unsaved": 1,
"owner": frappe.session.user,
"amount_based_on_formula": 1,
"parent": "New Salary Structure 1",
"parentfield": "earnings",
"parenttype": "Salary Structure",
"idx": 2,
"__unedited": 0,
"abbr": "H",
"salary_component": "Housing",
"formula": "B * .25"
}, {
"docstatus": 0,
"doctype": "Salary Detail",
"name": "New Salary Detail 3",
"__islocal": 1,
"__unsaved": 1,
"owner": frappe.session.user,
"amount_based_on_formula": 1,
"parent": "New Salary Structure 1",
"parentfield": "earnings",
"parenttype": "Salary Structure",
"idx": 2,
"__unedited": 0,
"abbr": "TA",
"salary_component": "Transportation",
"formula": "B * .10"
}],
"deductions": [{
"docstatus": 0,
"doctype": "Salary Detail",
"name": "New Salary Detail 5",
"__islocal": 1,
"__unsaved": 1,
"owner": frappe.session.user,
"amount_based_on_formula": 1,
"parent": "New Salary Structure 1",
"parentfield": "deductions",
"parenttype": "Salary Structure",
"idx": 1,
"__unedited": 0,
"abbr": "GOSI",
"salary_component": "GOSI",
"formula": "B *.09"
}, {
"docstatus": 0,
"doctype": "Salary Detail",
"name": "New Salary Detail 6",
"__islocal": 1,
"__unsaved": 1,
"owner": frappe.session.user,
"amount_based_on_formula": 1,
"parent": "New Salary Structure 1",
"parentfield": "deductions",
"parenttype": "Salary Structure",
"idx": 2,
"__unedited": 0,
"abbr": "SAND",
"salary_component": "SAND",
"formula": "B *.01"
}]
}).insert()
frappe.msgprint(_("Salary Structure is added to all Employees"))
