def add_subscriber():
"""add blog subscriber to lead"""
full_name = webnotes.form_dict.get('your_name')
email = webnotes.form_dict.get('your_email_address')
name = webnotes.conn.sql("""select name from tabLead where email_id=%s""",
email)
from webnotes.model.doc import Document
if name:
lead = Document('Lead', name[0][0])
else:
lead = Document('Lead')
if not lead.source: lead.source = 'Blog'
lead.unsubscribed = 0
lead.blog_subscriber = 1
lead.lead_name = full_name
lead.email_id = email
lead.save()
def add_calendar_event(self, milestone, date):
""" Add calendar event for task in calendar of Allocated person"""
event = Document('Event')
event.description = milestone + ' for ' + self.doc.name
event.event_date = date
event.event_hour = '10:00'
event.event_type = 'Public'
event.ref_type = 'Project'
event.ref_name = self.doc.name
event.save(1)
def set_doclist(self, doclist): for i, d in enumerate(doclist): if isinstance(d, dict): doclist[i] = Document(fielddata=d) self.doclist = webnotes.doclist(doclist) self.doc = self.doclist[0] if self.obj: self.obj.doclist = self.doclist self.obj.doc = self.doc
def execute():
"""
Adds various roles to Administrator. This patch is for making master db
ready for on premise installation
"""
import webnotes
from webnotes.model.code import get_obj
from webnotes.model.doc import Document
sc = get_obj('Setup Control', 'Setup Control')
sc.add_roles(Document('Profile', 'Administrator'))
def create_records(self, master_dict):
for d in master_dict.keys():
rec = Document(d)
for fn in master_dict[d].keys():
rec.fields[fn] = master_dict[d][fn]
rec_obj = get_obj(doc=rec)
rec_obj.doc.save(1)
if hasattr(rec_obj, 'on_update'):
rec_obj.on_update()
def set_doclist(self, docs):
for i, d in enumerate(docs):
if isinstance(d, dict):
docs[i] = Document(fielddata=d)
self.docs = self.doclist = webnotes.doclist(docs)
self.doc, self.children = docs[0], webnotes.doclist(docs[1:])
if self.obj:
self.obj.doclist = self.doclist
self.obj.doc = self.doc
def copy(self):
out = []
for d in self:
if isinstance(d, dict):
fielddata = d
else:
fielddata = d.fields
fielddata.update({"name": None})
out.append(Document(fielddata=fielddata))
return DocList(out)
def subscribe(arg):
"""subscribe to blog (blog_subscriber)"""
if webnotes.conn.sql("""select name from `tabBlog Subscriber` where name=%s""", arg):
webnotes.msgprint("Already a subscriber. Thanks!")
else:
from webnotes.model.doc import Document
d = Document('Blog Subscriber')
d.name = arg
d.save()
webnotes.msgprint("Thank you for subscribing!")
def execute():
companies_list = webnotes.conn.sql("SELECT company_name FROM `tabCompany`",
as_list=1)
for company in companies_list:
if company and company[0]:
edigest = Document('Email Digest',
"Default Weekly Digest - " + company[0])
if edigest:
edigest.income_year_to_date = 1
edigest.save()
def add_default_home_page():
if not webnotes.conn.sql("""select name from `tabDefault Home Page`
where role='Guest' and home_page='Login Page'"""):
d = Document('Default Home Page')
d.parent = 'Control Panel'
d.parenttype = 'Control Panel'
d.parentfield = 'default_home_pages'
d.role = 'Guest'
d.home_page = 'Login Page'
d.save(1)
def set_series_for(self, doctype, ol):
options = self.scrub_options_list(ol)
# validate names
for i in options:
self.validate_series_name(i)
if self.doc.user_must_always_select:
options = [''] + options
default = ''
else:
default = options[0]
# update in property setter
from webnotes.model.doc import Document
prop_dict = {'options': "\n".join(options), 'default': default}
for prop in prop_dict:
ps_exists = webnotes.conn.sql(
"""SELECT name FROM `tabProperty Setter`
WHERE doc_type = %s AND field_name = 'naming_series'
AND property = %s""", (doctype, prop))
if ps_exists:
ps = Document('Property Setter', ps_exists[0][0])
ps.value = prop_dict[prop]
ps.save()
else:
ps = Document('Property Setter',
fielddata={
'doctype_or_field': 'DocField',
'doc_type': doctype,
'field_name': 'naming_series',
'property': prop,
'value': prop_dict[prop],
'property_type': 'Select',
'select_doctype': doctype
})
ps.save(1)
self.doc.set_options = "\n".join(options)
from webnotes.utils.cache import CacheItem
CacheItem(doctype).clear()
def add_section_breaks_and_renum(self):
for d in self.in_doclist:
if d.get('parentfield')=='fields':
if d.get('fieldtype') in ('Section Break', 'Column Break', 'HTML'):
tmp = Document(fielddata = d)
tmp.fieldname = ''
tmp.name = None
tmp.save(1, ignore_fields = 1, check_links=0)
else:
webnotes.conn.sql("update tabDocField set idx=%s where %s=%s and parent=%s" % \
('%s', d.get('fieldname') and 'fieldname' or 'label', '%s', '%s'), (d.get('idx'), d.get('fieldname') or d.get('label'), self.doc.name))
def add(email, sender, subject, message, text_content = None):
"""add to bulk mail queue"""
from webnotes.utils.email_lib.smtp import get_email
e = Document('Bulk Email')
e.sender = sender
e.recipient = email
e.message = get_email(email, sender=e.sender, msg=message, subject=subject,
text_content = text_content).as_string()
e.status = 'Not Sent'
e.save()
def __init__(self, settings_doc):
"""
settings_doc must contain
use_ssl, host, username, password
(by name or object)
"""
if isinstance(settings_doc, basestring):
from webnotes.model.doc import Document
self.settings = Document(settings_doc, settings_doc)
else:
self.settings = settings_doc
def create_new_grp(self, arg):
arg = eval(arg)
grp = Document('File Group')
grp.group_name = arg['grp_nm']
grp.parent_group = arg['parent_grp']
grp.description = arg['desc']
grp.name = arg['grp_nm']
grp.save(1)
msgprint('Created a New Group')
return grp.name
def add_calender_event(self,scheduled_date,incharge_email,item_code):
""" Add calendar event for Maintenece Schedule in calendar of Allocated person"""
event = Document('Event')
event.owner = incharge_email
event.description = "Reference:%s, Item Code:%s and Customer: %s" %(self.doc.name, item_code, self.doc.customer)
event.event_date = scheduled_date
event.event_hour = '10:00'
event.event_type = 'Private'
event.ref_type = 'Maintenance Schedule'
event.ref_name = self.doc.name
event.save(1)
def update_serial_purchase_details(self, obj, d, serial_no, is_submit, purpose = ''):
exists = sql("select name, status, docstatus from `tabSerial No` where name = '%s'" % (serial_no))
if is_submit:
if exists and exists[0][2] != 2 and purpose not in ['Material Transfer', 'Sales Return']:
msgprint("Serial No: %s already %s" % (serial_no, exists and exists[0][1]), raise_exception = 1)
elif exists:
s = Document('Serial No', exists and exists[0][0])
self.set_pur_serial_no_values(obj, serial_no, d, s, new_rec = 0)
else:
s = Document('Serial No')
self.set_pur_serial_no_values(obj, serial_no, d, s, new_rec = 1)
else:
if exists and exists[0][1] == 'Delivered' and exists[0][2] != 2:
msgprint("Serial No: %s is already delivered, you can not cancel the document." % serial_no, raise_exception=1)
elif purpose == 'Material Transfer':
sql("update `tabSerial No` set status = 'In Store', purchase_document_type = '', purchase_document_no = '', warehouse = '%s' where name = '%s'" % (d.s_warehouse, serial_no))
elif purpose == 'Sales Return':
sql("update `tabSerial No` set status = 'Delivered', purchase_document_type = '', purchase_document_no = '' where name = '%s'" % serial_no)
else:
sql("update `tabSerial No` set docstatus = 2, status = 'Not in Use', purchase_document_type = '', purchase_document_no = '', purchase_date = null, purchase_rate = 0, supplier = null, supplier_name = '', supplier_address = '', warehouse = '' where name = '%s'" % serial_no)
def add_answer(arg):
arg = load_json(arg)
from webnotes.model.doc import Document
a = Document('Answer')
a.answer = arg['answer']
a.question = arg['qid']
a.points = 1
a.save(1)
webnotes.conn.set_value('Question', arg['qid'], 'modified', now())
def __init__(self, settings_doc):
"""
settings_doc must contain
is_ssl, host, username, password
(by name or object)
"""
if type(settings_doc) == str:
from webnotes.model.doc import Document
self.settings = Document(settings_doc, settings_doc)
else:
self.settings = settings_doc
def set_home_page(self):
from webnotes.model.doc import Document
webnotes.conn.sql("""delete from `tabDefault Home Page` where role='Guest'""")
d = Document('Default Home Page')
d.parent = 'Control Panel'
d.parenttype = 'Control Panel'
d.parentfield = 'default_home_pages'
d.role = 'Guest'
d.home_page = self.doc.home_page
d.save()
def add_node():
from webnotes.model.doc import Document
ctype = webnotes.form_dict.get('ctype')
parent_field = 'parent_' + ctype.lower().replace(' ', '_')
d = Document(ctype)
d.fields[ctype.lower().replace(' ', '_') +
'_name'] = webnotes.form_dict['name_field']
d.fields[parent_field] = webnotes.form_dict['parent']
d.is_group = webnotes.form_dict['is_group']
d.save()
def create_contact(contact_details):
from webnotes.model.doc import Document
contact = Document("Contact")
contact.first_name = contact_details['first_name']
contact.email_id = contact_details['email_id']
contact.mobile_no = contact_details['mobile_no']
if contact_details['doc'] == 'Customer':
contact.customer = contact_details['link']
else:
contact.referrer_physician = contact_details['link']
contact.save()
def add_calendar_event(self):
""" Add calendar event for task in calendar of Allocated person"""
event = Document('Event')
event.owner = self.doc.allocated_to
event.description = self.doc.name
event.event_date = self.doc.exp_start_date and self.doc.exp_start_date or ''
event.event_hour = self.doc.event_hour and self.doc.event_hour or '10:00'
event.event_type = 'Private'
event.ref_type = 'Task'
event.ref_name = self.doc.name
event.save(1)
def add_website_manager():
"""add website manager to system manager"""
for i in webnotes.conn.sql("""select distinct parent from tabUserRole
where role='System Manager'"""):
if not webnotes.conn.sql(
"""select parent from tabUserRole
where role='Website Manager' and parent=%s""", i[0]):
d = Document('UserRole')
d.parent = i[0]
d.role = 'Website Manager'
d.save(1)
def send_welcome_mail(email, args):
"""send welcome mail to user with password and login url"""
pr = Document('Profile', email)
from webnotes.utils.email_lib import sendmail_md
args.update({
'company': webnotes.conn.get_default('company'),
'password': args.get('password'),
'account_url': webnotes.conn.get_value('Website Settings',
'Website Settings', 'subdomain') or ""
})
if not args.get('last_name'): args['last_name'] = ''
sendmail_md(pr.email, subject="Welcome to ERPNext", msg=welcome_txt % args, from_defs=1)
def add_ac(self,arg):
arg = eval(arg)
ac = Document('Account')
for d in arg.keys():
ac.fields[d] = arg[d]
ac.old_parent = ''
ac_obj = get_obj(doc=ac)
ac_obj.validate()
ac_obj.doc.save(1)
ac_obj.on_update()
return ac_obj.doc.name
def update_permissions(self, args=''):
args = eval(args)
di = args['perm_dict']
doctype_keys = di.keys() # ['Opportunity','Competitor','Zone','State']
for parent in doctype_keys:
for permlevel in di[parent].keys():
for role in di[parent][permlevel].keys():
if role:
# check if Permissions for that perm level and Role exists
exists = sql(
"select name from tabDocPerm where parent = %s and role = %s and ifnull(permlevel, 0) = %s",
(parent, role, cint(permlevel)))
# Get values of dictionary of Perm Level
pd = di[parent][permlevel][role]
# update
if exists and (1 in pd.values()):
sql(
"update tabDocPerm set `read` = %s, `write` = %s, `create` = %s, `submit` = %s, `cancel` = %s, `amend` = %s, `match`=%s where parent = %s and role = %s and permlevel = %s",
(pd['read'], pd['write'], pd['create'],
pd['submit'], pd['cancel'], pd['amend'],
pd.get('match'), parent, role, permlevel))
# new
elif not exists and (1 in pd.values()):
ch = Document('DocPerm')
ch.parentfield = 'permissions'
ch.parenttype = 'DocType'
ch.parent = parent
ch.role = role
ch.permlevel = cint(permlevel)
for key in pd.keys():
ch.fields[key] = pd.get(key, None)
ch.save(1)
# delete
elif exists and (1 not in pd.values()):
sql(
"delete from tabDocPerm where parent = %s and role = %s and ifnull(permlevel,0) = %s",
(parent, role, cint(permlevel)))
sql(
"update tabDocType set modified = %s where name = %s",
(now(), parent))
from webnotes.utils.cache import CacheItem
CacheItem(parent).clear()
msgprint("Permissions Updated")
def add_acc(self,lst):
ac = Document('Account')
for d in self.fld_dict.keys():
ac.fields[d] = (d == 'parent_account' and lst[self.fld_dict[d]]) and lst[self.fld_dict[d]] +' - '+ self.doc.abbr or lst[self.fld_dict[d]]
ac_obj = get_obj(doc=ac)
ac_obj.doc.freeze_account='No'
ac_obj.doc.master_type = ''
ac_obj.validate()
ac_obj.doc.save(1)
ac_obj.on_update()
sql("commit")
sql("start transaction")
def add_user_role(self, args):
arg = eval(args)
sql("delete from `tabUserRole` where parenttype='Profile' and parent ='%s'"
% (cstr(arg['user'])))
role_list = arg['role_list'].split(',')
for r in role_list:
pr = Document('UserRole')
pr.parent = arg['user']
pr.parenttype = 'Profile'
pr.role = r
pr.parentfield = 'userroles'
pr.save(1)
def create_profile(self, user_email, user_fname, user_lname, pwd=None):
pr = Document('Profile')
pr.first_name = user_fname
pr.last_name = user_lname
pr.name = pr.email = user_email
pr.enabled = 1
pr.save(1)
if pwd:
webnotes.conn.sql(
"UPDATE `tabProfile` SET password=PASSWORD(%s) WHERE name=%s",
(pwd, user_email))
self.add_roles(pr)
