def register_all(self, cr):
rv = super(ir_actions_report_xml, self).register_all(cr)
cr.execute(
"SELECT *"
" FROM ir_act_report_xml r"
" INNER JOIN ir_model_data d"
" ON r.id = d.res_id"
" WHERE d.module = 'via_cash_flow_realization_report'"
" AND d.model = 'ir.actions.report.xml'"
" ORDER BY r.id"
)
records = cr.dictfetchall()
class parser(object):
def __init__(self, cr, uid, ids, data, context):
_id = data["form"]["id"]
pool = pooler.get_pool(cr.dbname).get("via.cash.flow.realization.report")
o = pool.browse(cr, uid, _id, context)
self.parameters = {}
if o.arg is None:
self.parameters["ARG"] = ""
else:
self.parameters["ARG"] = o.arg
self.parameters["TREE_TABLE"] = o.tree_table
self.parameters["REPORT_PARAMETERS_TABLE_LEFT"] = o.report_parameters_table_left
self.parameters["REPORT_PARAMETERS_TABLE_RIGHT"] = o.report_parameters_table_right
self.parameters["REPORT_PARAMETERS_TABLE"] = (
o.report_parameters_table_left + "," + o.report_parameters_table_right
)
self.parameters["USE_INDENTATION"] = o.use_indentation
self.parameters["DECIMAL_PRECISION"] = 0 if o.rpt_output == "pdf" else o.decimal_precision
def get(self, key, default):
if key == "parameters":
return self.parameters
else:
return default
from jasper_reports.jasper_report import report_jasper
for record in records:
name = "report.%s" % record["report_name"]
report_jasper(name, record["model"], parser)
return rv
def register_all(self, cr):
rv = super(ir_actions_report_xml, self).register_all(cr)
cr.execute("SELECT *"
" FROM ir_act_report_xml r"
" INNER JOIN ir_model_data d"
" ON r.id = d.res_id"
" WHERE d.module = 'via_cash_flow_realization_report'"
" AND d.model = 'ir.actions.report.xml'"
" ORDER BY r.id")
records = cr.dictfetchall()
class parser(object):
def __init__(self, cr, uid, ids, data, context):
_id = data['form']['id']
pool = pooler.get_pool(cr.dbname).get('via.cash.flow.realization.report')
o = pool.browse(cr, uid, _id, context)
self.parameters = {}
if o.arg is None:
self.parameters['ARG'] = ''
else:
self.parameters['ARG'] = o.arg
self.parameters['TREE_TABLE'] = o.tree_table
self.parameters['REPORT_PARAMETERS_TABLE_LEFT'] = o.report_parameters_table_left
self.parameters['REPORT_PARAMETERS_TABLE_RIGHT'] = o.report_parameters_table_right
self.parameters['REPORT_PARAMETERS_TABLE'] = (o.report_parameters_table_left
+ "," + o.report_parameters_table_right)
self.parameters['USE_INDENTATION'] = o.use_indentation
self.parameters['DECIMAL_PRECISION'] = (0
if o.rpt_output == 'pdf'
else o.decimal_precision)
def get(self, key, default):
if key == 'parameters':
return self.parameters
else:
return default
from jasper_reports.jasper_report import report_jasper
for record in records:
name = 'report.%s' % record['report_name']
report_jasper(name, record['model'], parser)
return rv
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val = {}
user_rec = self.pool.get('res.users').browse(cr, uid, uid)
slip_ids = []
for item in ids:
slip_ids.append(str(item))
val['printed_by'] = user_rec.name
val['slip_id'] = ",".join(str(x) for x in ids)
print val
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_packing_slip_spare_report',
'kg.packing.slip',
parser=onscreen_packing_slip_spare_report)
for s in ids:
sql = """INSERT INTO tmp_kg_general_grn(grn_id,user_id) values(%s,%s)""" % (s, uid)
cr.execute(sql)
sql_c = """commit"""
cr.execute(sql_c)
print "-----------------hai ----------------------"
super(onscreen_general_grn_report, self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return "records"
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return val
def generate_parameters(self, cr, uid, ids, data, context):
val = {}
val["user_id"] = uid
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper("report.onscreen_general_grn_report", "kg.general.grn", parser=onscreen_general_grn_report)
'voucher_no':
move_line.move_line_name or '',
'voucher_date':
date,
'party_name':
move_line.partner_id and move_line.partner_id.name or '',
'job_id':
move_line.job_id and move_line.job_id.name or '',
'narration':
move_line.name or '',
'currency':
move_line.currency_id and move_line.currency_id.name or '',
'amt_fc':
abs(move_line.amount_currency) or "0.00",
'amt_aed':
abs(debit - credit) or "0.00",
'due_date':
due_date,
'total_amt_aed':
abs(total_amt_aed)
}
result.append(vals)
result = sorted(result, key=operator.itemgetter('voucher_date'))
return result
jasper_report.report_jasper('report.upcoming_payable_report_scheduler.jasper',
'account.move.line',
parser=upcoming_payable_report_scheduler)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
reste_a_payer = round(facture_nonregler['residual'], 3)
retenue = facture_nonregler['montant_retenue'] or 0
montant_payer = round(facture_nonregler['montant_paye'],
3) - round(retenue, 3)
data = {
'header1': header1,
'header2': header2,
'raison_socaile': rs_fournisseur,
'matricule_fiscale': mf_fournisseur,
'numerofacture': numero_facture,
'datefacturation': datefacturation,
'reference_fournisseur': ref_fournisseur,
'montant_facture': montant_facture,
'montant_payer2': round(montant_payer, 3),
'reste_a_payer2': reste_a_payer,
'retenue': round(retenue, 3),
'user': obj_user.name,
}
result.append(data)
return result
jasper_report.report_jasper(
'report.jasper_facture_fournisseur_nonregler_print',
'account.invoice',
parser=jasper_client,
)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:c
elif (data['form']['print_type'] == 'supplier'):
self.ACCOUNT_TYPE = ['payable']
else:
self.ACCOUNT_TYPE = ['payable', 'receivable']
return True
def generate_records(self, cr, uid, ids, data, context):
result = []
self.set_context(cr, data, ids, context=context)
result = self._get_lines(data['form'])
check_list = []
final_result = []
for item in result:
if not item['ref']:
if item['ref'] in check_list:
continue
else:
check_list.append(item['ref'])
final_result.append(item)
else:
final_result.append(item)
result = sorted(final_result,
key=operator.itemgetter('partner_name', 'doc_date'))
return result
jasper_report.report_jasper('report.partner.ageing.jasper',
'partner.ageing.report.wizard',
parser=aging_report_summary)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
and inv.purchase_others.journal_id.code,
'po_name':
inv.purchase_others and inv.purchase_others.name,
'sub_report': []
}
for payment in inv.payments_ids:
pay_vals = {
'cheque_no':
payment.cheque_no and "CH: %s" % (payment.cheque_no),
'cheque_date':
payment.cheque_date and "DT: %s" %
(datetime.strptime(payment.cheque_date,
'%Y-%m-%d').strftime("%d.%m.%Y")),
'bank_details':
payment.bank_details,
'pay_code':
payment.journal_id.code,
'pay_name':
payment.name
}
vals['sub_report'].append(pay_vals)
result.append(vals)
return result
jasper_report.report_jasper('report.payment_details_jasper',
'shipping.invoice',
parser=payment_details_report)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
to_d1 = datetime.strptime(to_date,'%Y-%m-%d')
to_d2 = datetime.strftime(to_d1, '%d-%m-%Y')
from_date = date_from.encode('utf-8')
from_d1 = datetime.strptime(from_date,'%Y-%m-%d')
from_d2 = datetime.strftime(from_d1, '%d-%m-%Y')
val['to_date_range'] = to_d2
val['from_date_range'] = from_d2
val['date_from'] = date_from
val['date_to'] = date_to
val['user_id'] = uid
val['printed_by'] = str(printed)
val['print_date'] = p_date
if data['form']['division_id']:
val['division_id'] = division_id
val['division_name'] = division_name
else:
val['division_id'] = 0
val['division_name'] = 'ALL'
pass
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.jasper_qc_register_report', 'kg.qc.register', parser=jasper_qc_register_report_print, )
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
class onscreen_contractor_inward_report(JasperDataParser.JasperDataParser):
def __init__(self, cr, uid, ids, data, context):
super(onscreen_contractor_inward_report, self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return "records"
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val = {}
val["cr_id"] = ids[0]
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper(
"report.onscreen_contractor_inward_report", "kg.contractor.inward", parser=onscreen_contractor_inward_report
)
company_id = data['form']['company_id']
company_rec = self.pool.get('res.company').browse(self.cr,self.uid,company_id[0])
company_name = company_rec.name
partner_obj = self.pool.get('res.partner').search(self.cr, self.uid, [('id','=',company_rec.partner_id.id)])
partner_rec = self.pool.get('res.partner').browse(self.cr,self.uid,partner_obj[0])
partner_st = partner_rec.street
partner_st2 = partner_rec.street2
partner_zip = partner_rec.zip
partner_add = partner_st+""+partner_st2+""+partner_zip
# account_rec = data['form']['account_id']
val['m_from_date'] = t_d4
val['m_to_date'] = t_d2
val['account_id'] = 2
val['user_name'] = user_name
val['current_time'] = crt_time
val['t_date'] = t_d2
val['company_name'] = company_name
val['company_add'] = partner_add
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.jasper_sale_cash', 'res.users', parser=sale_cash)
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val={}
qc_ids = ids
qc_rec = self.pool.get('kg.qc.verification').browse(cr,uid,ids[0])
print"sssssssssssssssssssss", qc_rec.stock_type
if qc_rec.stock_type == 'pump':
return {'value':{},'warning':{'title':'warning','message':'Your message'}}
if len(qc_ids) == 1:
list_ids = qc_ids[0]
val['id'] = list_ids
else:
list_ids = ''
for item in qc_ids:
list_ids = str(list_ids) + str(item) + ","
val['id'] = list_ids[:-1]
print_date = datetime.now().strftime('%d-%m-%Y %H:%M:%S')
user_rec = self.pool.get('res.users').browse(cr,uid,uid)
val['printed_by'] = str(user_rec.name)
val['print_date'] = print_date
val['id'] = str(val['id'])
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_part_qc_verification_report', 'kg.qc.verification', parser=onscreen_part_qc_verification_report)
to_d1 = datetime.strptime(to_date,'%Y-%m-%d')
to_d2 = datetime.strftime(to_d1, '%d-%m-%Y')
from_date = date_from.encode('utf-8')
from_d1 = datetime.strptime(from_date,'%Y-%m-%d')
from_d2 = datetime.strftime(from_d1, '%d-%m-%Y')
val['to_date_range'] = to_d2
val['from_date_range'] = from_d2
val['date_from'] = date_from
val['date_to'] = date_to
val['user_id'] = uid
val['printed_by'] = str(printed)
val['print_date'] = p_date
if data['form']['division_id']:
val['division_id'] = division_id
val['division_name'] = division_name
else:
val['division_id'] = 0
val['division_name'] = 'ALL'
pass
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.jasper_planning_register_report', 'kg.planning.register', parser=jasper_planning_register_report_print, )
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
sql = """INSERT INTO tmp_kg_po_grn(grn_id,user_id) values(%s,%s)""" % (s,uid)
cr.execute(sql,)
sql_c="""commit"""
cr.execute(sql_c,)
print "-----------------hai ----------------------"
super(onscreen_po_grn_report, self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val={}
val['user_id'] = uid
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_po_grn_report', 'kg.po.grn', parser=onscreen_po_grn_report)
super(onscreen_dealer_wo_ack_report,
self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val = {}
user_rec = self.pool.get('res.users').browse(cr, uid, uid)
val['offer_id'] = ids[0]
val['printed_by'] = user_rec.name
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_dealer_wo_ack_report',
'kg.crm.offer',
parser=onscreen_dealer_wo_ack_report)
move_obj.journal_partner_id
and move_obj.journal_partner_id.name.upper() or '',
'ref':
move_obj.ref or '',
'amount_in_words':
amount_curr and amount_curr.upper() or '',
'bank':
bank_name,
'check_no':
move_obj.display_check_details and move_obj.cheque_no or '',
'check_date':
move_obj.display_check_details and move_obj.cheque_date
and datetime.strptime(move_obj.cheque_date, '%Y-%m-%d'),
'curr_name':
journal_curr.name == 'AED' and "DIRHAMS" or journal_curr.name,
'user_name':
user_obj.name.upper() or '',
'sett_lines':
sett_lines
}
vals['move_lines'] = lines
result.append(vals)
return result
jasper_report.report_jasper('report.voucher.report.jasper',
'account.move',
parser=voucher_report)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
val['from_date']=''
val['to_date']=''
val['dep_id']=''
val['product']=''
val['t_date']=''
val['account_id']=0
val['company_name']=1
val['company_add']=''
frm_rec = data['form']['from_date']
current_time = datetime.now()
ist_time = current_time + timedelta(minutes = 308)
crt_time = ist_time.strftime('%d/%m/%Y %H:%M:%S')
t_rec = data['form']['to_date']
to_date = t_rec.encode('utf-8')
t_d1 = datetime.strptime(to_date,'%Y-%m-%d')
t_d2 = datetime.strftime(t_d1, '%d/%m/%Y')
val['from_date'] = frm_rec
val['to_date'] = t_rec
val['wiz_id'] = data['form']['id']
altered_time=data['form']['print_date']
val['print_date'] = crt_time
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.jasper_kg_dep_issue', 'kg.department.issue', parser=kg_dep_issue)
class onscreen_cd_report(JasperDataParser.JasperDataParser):
def __init__(self, cr, uid, ids, data, context):
super(onscreen_cd_report, self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val = {}
val['offer_id'] = ids[0]
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_cd_report',
'kg.crm.offer',
parser=onscreen_cd_report)
date_print = printed_date.encode('utf-8')
d1 = datetime.strptime(date_print,'%Y-%m-%d %H:%M:%S')
p_date = d1.strftime( '%d-%m-%Y %H:%M:%S')
as_date = as_on_date.encode('utf-8')
as_d1 = datetime.strptime(as_date,'%Y-%m-%d')
as_d2 = datetime.strftime(as_d1, '%d-%m-%Y')
val['as_date_range'] = as_d2
val['as_on_date'] = as_on_date
val['user_id'] = uid
val['printed_by'] = str(printed)
val['print_date'] = p_date
if data['form']['division_id']:
val['division_id'] = division_id
val['division_name'] = division_name
else:
val['division_id'] = 0
val['division_name'] = 'ALL'
pass
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.jasper_stock_statement_report', 'kg.stock.statement', parser=jasper_stock_statement_report_print, )
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
class onscreen_issue_return_report(JasperDataParser.JasperDataParser):
def __init__(self, cr, uid, ids, data, context):
super(onscreen_issue_return_report,
self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val = {}
val['issue_id'] = ids[0]
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_issue_return_report',
'kg.issue.return',
parser=onscreen_issue_return_report)
user_rec = user_id.login
val['date_from']=''
val['date_to']=''
val['dep_id']=''
val['product']=''
val['t_date']=''
val['account_id']=0
val['company_name']=1
val['company_add']=''
frm_rec = data['form']['date_from']
current_time = datetime.now()
ist_time = current_time + timedelta(minutes = 308)
crt_time = ist_time.strftime('%d/%m/%Y %H:%M:%S')
t_rec = data['form']['date_to']
to_date = t_rec.encode('utf-8')
t_d1 = datetime.strptime(to_date,'%Y-%m-%d')
t_d2 = datetime.strftime(t_d1, '%d/%m/%Y')
val['date_from'] = frm_rec
val['date_to'] = t_rec
val['wiz_id'] = data['form']['id']
val['print_date'] = crt_time
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.jasper_kg_po_register', 'purchase.order', parser=kg_purchase_order_register)
val={}
ids_list = tuple(ids)
cr.execute('''
DROP TABLE IF EXISTS ms_inward_report_ids
''')
cr.execute('''
CREATE TABLE IF NOT EXISTS ms_inward_report_ids(
ID INT
)
''')
for s in ids:
sql = """INSERT INTO ms_inward_report_ids(id) values(%s)""" % (s)
cr.execute(sql,)
sql_c="""commit"""
cr.execute(sql_c,)
val['user_id'] = uid
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_ms_inward_report', 'kg.machineshop', parser=onscreen_ms_inward_report)
# 'city': product_data.company_id.partner_id.city,
# 'state_id': {'name': product_data.company_id.partner_id.state_id.name},
# 'country_id': {'name': product_data.company_id.partner_id.country_id.name},
# 'zip': product_data.company_id.partner_id.zip,
# 'vat': product_data.company_id.partner_id.vat,
# 'branch': product_data.company_id.partner_id.branch,
# },
# },
# 'stock_card_ids': [],
# }
# product_stock_ids = pool.get('product.stock.card').search(cr, uid, domain)
# product_stock_lines = pool.get('product.stock.card').browse(cr, uid, product_stock_ids, context)
# for line in product_stock_lines:
# stock_card_data = {
# 'id': line.id,
# 'name': line.name,
# 'date': line.date,
# 'in_qty': line.in_qty,
# 'out_qty': line.out_qty,
# 'balance': line.balance,
# 'default_uom': {'name': line.default_uom.name},
# 'location_id': {'name': line.location_id.name},
# 'location_dest_id': {'name': line.location_dest_id.name}
# }
# result['stock_card_ids'].append(stock_card_data)
# results.append(result)
# return results
jasper_report.report_jasper('report.report.product.stock.card', 'product.product', parser=jasper_user_analysis, )
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
class onscreen_payslip(JasperDataParser.JasperDataParser):
def __init__(self, cr, uid, ids, data, context):
super(onscreen_payslip, self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val = {}
val['payslip_id'] = ids[0]
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_payslip',
'hr.payslip',
parser=onscreen_payslip)
import os
class onscreen_service_order_report(JasperDataParser.JasperDataParser):
def __init__(self, cr, uid, ids, data, context):
super(onscreen_service_order_report, self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val={}
val['so_id'] = ids[0]
return val
def generate_records(self, cr, uid, ids, data, context):
print data,'afdssgsggsgfs'
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_service_order_report', 'kg.service.order', parser=onscreen_service_order_report, )
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val = {}
user_rec = self.pool.get('res.users').browse(cr, uid, uid)
invoice_ids = []
for item in ids:
invoice_ids.append(str(item))
print "dc_ids", invoice_ids
print "idsidsids", ids
print "idsidsids", str(ids)
val['printed_by'] = user_rec.name
val['invoice_id'] = ids[0]
print "val['invoice_id']val['invoice_id']", type(val['invoice_id'])
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_customer_invoice_report',
'purchase.order',
parser=onscreen_customer_invoice_report)
company_id = data['form']['company_id']
company_rec = self.pool.get('res.company').browse(self.cr,self.uid,company_id[0])
company_name = company_rec.name
partner_obj = self.pool.get('res.partner').search(self.cr, self.uid, [('id','=',company_rec.partner_id.id)])
partner_rec = self.pool.get('res.partner').browse(self.cr,self.uid,partner_obj[0])
partner_st = partner_rec.street
partner_st2 = partner_rec.street2
partner_zip = partner_rec.zip
partner_add = partner_st+""+partner_st2+""+partner_zip
# account_rec = data['form']['account_id']
val['from_date'] = frm_rec
val['to_date'] = t_rec
val['account_id'] = 2
val['user_name'] = user_name
val['current_time'] = crt_time
val['t_date'] = t_d2
val['company_name'] = company_name
val['company_add'] = partner_add
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.jasper_profit_loss_report', 'res.users', parser=profit_loss_report)
purchase_curr = po_obj.currency_id
comp_curr = po_obj.company_id.currency_id
if purchase_curr != comp_curr:
exchange_rate = curr_pool._get_conversion_rate(
cr, uid, purchase_curr, comp_curr, context=context)
else:
exchange_rate = 1.0000
vals = {
'si_no': count,
'name': po_obj.name or '',
'partner_name': partner_name,
'supplier_name': po_obj.partner_id.partner_nick_name or \
po_obj.partner_id.name or '',
'date_order': po_obj.date_order and \
datetime.strptime(po_obj.date_order, '%Y-%m-%d'),
'job_ac': po_obj.job_id and po_obj.job_id.name or '',
'curr': po_obj.currency_id and po_obj.currency_id.name or '',
'po_value': (po_obj.amount_total * exchange_rate) or "0.00",
'tran_type': po_obj.transaction_type_id and po_obj.transaction_type_id.name or '',
'customer_po_no': po_obj.job_id and po_obj.job_id.cust_po_num or ''
}
result.append(vals)
result = sorted(result, key=itemgetter("tran_type", "name"))
return result
jasper_report.report_jasper('report.po.summary.jasper',
'po.summary',
parser=po_summary)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
class onscreen_purchase_order_report(JasperDataParser.JasperDataParser):
def __init__(self, cr, uid, ids, data, context):
super(onscreen_purchase_order_report, self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return "records"
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val = {}
val["po_id"] = ids[0]
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper(
"report.onscreen_purchase_order_report", "purchase.order", parser=onscreen_purchase_order_report
)
def __init__(self, cr, uid, ids, data, context):
super(onscreen_contractor_inward_report,
self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val = {}
val['cr_id'] = ids[0]
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper(
'report.onscreen_contractor_inward_report',
'kg.contractor.inward',
parser=onscreen_contractor_inward_report,
)
from osv import osv, fields
from tools.translate import _
from osv.orm import browse_record, browse_null
import os
class onscreen_issue_return_report(JasperDataParser.JasperDataParser):
def __init__(self, cr, uid, ids, data, context):
super(onscreen_issue_return_report, self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val={}
val['issue_id'] = ids[0]
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_issue_return_report', 'kg.issue.return', parser=onscreen_issue_return_report)
'quote_text':
"AS PER %s" % ((data.get('carrier_id')).upper()) +
" QUOTE",
'quote_freight':
quotation.carrier_freight or "0.00",
'total_quote':
format(total_quote, '.2f') or "0.00",
'cost_freight':
quotation.costsheet_freight_charge or "0.00",
'total_cost':
total_cost or "0.00",
'extra_cost':
extra_cost or "0.00",
'rounding_off':
inv.rounding_off or "0.00",
'total_amt': (total_inv - inv.rounding_off) or "0.00",
'remarks':
quotation.remarks,
'courier_company': (data.get('carrier_id')),
'notes':
"NOTE: %s" % (notes)
}
result.append(vals)
return result
jasper_report.report_jasper('report.shipping_payment_details_jasper',
'wizard.shipping.payment.details',
parser=shipping_payment_report)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
debit = amount
elif invoice_type == 'in_invoice' and amount > 0:
credit = amount
elif invoice_type == 'out_invoice' and amount < 0:
credit = amount * -1
elif invoice_type == 'in_invoice' and amount < 0:
debit = amount * -1
elif invoice_type in ['out_refund', 'in_refund']:
credit = amount * -1
data = {
'date': move_line_obj.date,
'journal': move_line_obj.journal_id and \
move_line_obj.journal_id.name or '',
'account': move_line_obj.account_id.code + " " + move_line_obj.account_id.name or "",
'name': move_line_obj.name or '',
'debit': debit,
'credit': credit,
'reconcile': reconcile_obj and reconcile_obj.name or '',
'invoice_id': invoice_id,
'ref': move_line_obj.ref
}
result.append(data)
if way == 'debit_to_credit':
result = sorted(result, key = lambda d: (d['invoice_id'], d['debit']))
else:
result = sorted(result, key = lambda d: (d['invoice_id']))
return result
jasper_report.report_jasper('report.reconcile.ledger.jasper.report', 'reconcile.ledger.report', parser=jasper_ledger_report)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:-
#MT_Totale_Ligne= round(stock_mouve['price_subtotal'],3)
#Product_id = stock_mouve['product_id']
#obj_UDM = self.pool.get('product.uom').browse(cr, uid, stock_mouve['product_uom'])
#obj_Location = self.pool.get('stock.location').browse(cr, uid, stock_mouve['location_dest_id'])
#udm=obj_UDM.name
#chantier=obj_Location.name
data={
'stat_path' :os.getcwd()+"/openerp/addons/office_stat/",
'header1':header1,
'header2':header2,
'raison_sociale':rs_fournisseur,
'matricule_fiscale':mat_fournisseur,
'ref_fournisseur':ref_fournisseur,
'num_BonReception':num_br,
'date_br':date_br,
'designation_article':designation_article_br,
'qte_article':qte_product,
'product_udm':udm,
'chantier':chantier,
'montant_article':MT_Totale_Ligne,
'user':obj_user.name,
}
result.append(data)
return result
jasper_report.report_jasper('report.jasper_br_non_facturer_grouper_print', 'stock.move', parser=jasper_client, )
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:c
import os
class onscreen_store_issue_slip(JasperDataParser.JasperDataParser):
def __init__(self, cr, uid, ids, data, context):
super(onscreen_store_issue_slip, self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val={}
val['issue_id'] = ids[0]
return val
def generate_records(self, cr, uid, ids, data, context):
print data,'afdssgsggsgfs'
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_store_issue_slip', 'kg.department.issue', parser=onscreen_store_issue_slip, )
import os
class onscreen_physical_stock_report(JasperDataParser.JasperDataParser):
def __init__(self, cr, uid, ids, data, context):
super(onscreen_physical_stock_report, self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return val
def generate_parameters(self, cr, uid, ids, data, context):
val={}
val['pi_id'] = ids[0]
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_physical_stock_report', 'kg.general.grn', parser=onscreen_physical_stock_report)
to_d1 = datetime.strptime(to_date,'%Y-%m-%d')
to_d2 = datetime.strftime(to_d1, '%d-%m-%Y')
from_date = date_from.encode('utf-8')
from_d1 = datetime.strptime(from_date,'%Y-%m-%d')
from_d2 = datetime.strftime(from_d1, '%d-%m-%Y')
val['to_date_range'] = to_d2
val['from_date_range'] = from_d2
val['date_from'] = date_from
val['date_to'] = date_to
val['user_id'] = uid
val['printed_by'] = str(printed)
val['print_date'] = p_date
if data['form']['division_id']:
val['division_id'] = division_id
val['division_name'] = division_name
else:
val['division_id'] = 0
val['division_name'] = 'ALL'
pass
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.jasper_production_register_report', 'kg.production.register', parser=jasper_production_register_report_print, )
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val = {}
rec = self.pool.get('kg.sale.cr.note').browse(cr, uid, ids[0])
val['credit_note_id'] = ids[0]
val['net_amt'] = rec.net_amt
print "net_amtnet_amtnet_amtnet_amt", val['net_amt']
text_amount = number_to_text_convert_india.amount_to_text_india(
val['net_amt'], "INR: ")
val['net_amt'] = text_amount
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_credit_note_print',
'kg.sale.cr.note',
parser=onscreen_credit_note_print)
def register_all(self, cr):
res = super(ir_actions_report_xml, self).register_all(cr)
cr.execute("SELECT *"
" FROM ir_act_report_xml r"
" INNER JOIN ir_model_data d"
" ON r.id = d.res_id"
" WHERE d.module = 'via_financial_reports'"
" AND d.model = 'ir.actions.report.xml'"
" AND POSITION('via_financial_reports/report/trial_balance/' IN report_file) != 1"
" AND POSITION('via_financial_reports/report/general_ledger/' IN report_file) != 1"
" ORDER BY r.id")
records = cr.dictfetchall()
class account_tree_parser(object):
def __init__(self, cr, uid, ids, data, context):
id_ = data['form']['id']
pool = pooler.get_pool(cr.dbname).get('via.financial.reports')
o = pool.browse(cr, uid, id_, context)
self.parameters = {}
if o.arg is None:
self.parameters['ARG'] = ''
else:
self.parameters['ARG'] = o.arg
self.parameters['ACCOUNT_TREE'] = o.account_tree
self.parameters['REPORT_PARAMETERS_LEFT'] = o.report_parameters_left
self.parameters['REPORT_PARAMETERS_RIGHT'] = o.report_parameters_right
self.parameters['REPORT_PARAMETERS'] = (o.report_parameters_left
+ "," + o.report_parameters_right)
if o.separator_nr is None:
self.parameters['SEPARATOR_NR'] = -1
else:
self.parameters['SEPARATOR_NR'] = o.separator_nr
self.parameters['USE_INDENTATION'] = o.use_indentation
self.parameters['OERP_USER'] = o.oerp_user.name
self.parameters['NO_WRAP'] = o.no_wrap
self.parameters['DISPLAY_MOVE'] = int(o.display_move)
if o.rpt_output == 'pdf' or o.name in ('General Ledger', 'General Ledger/Trial Balance'):
decimal_place = 0
else:
decimal_place = o.decimal_precision
if decimal_place > 0:
decimal_str = '.' + '0' * decimal_place
else:
decimal_str = ''
self.parameters['DECIMAL_PRECISION'] = (0 if o.rpt_output == 'pdf'
else o.decimal_precision)
self.parameters['DECIMAL_FORMAT_STRING'] = ',##0' + decimal_str
self.parameters['DECIMAL_ROUNDING_MODE'] = 'HALF_UP'
def get(self, key, default):
if key == 'parameters':
return self.parameters
else:
return default
from jasper_reports.jasper_report import report_jasper
for record in records:
name = 'report.%s' % record['report_name']
report_jasper(name, record['model'], account_tree_parser)
return res
to_d1 = datetime.strptime(to_date,'%Y-%m-%d')
to_d2 = datetime.strftime(to_d1, '%d-%m-%Y')
from_date = date_from.encode('utf-8')
from_d1 = datetime.strptime(from_date,'%Y-%m-%d')
from_d2 = datetime.strftime(from_d1, '%d-%m-%Y')
val['to_date_range'] = to_d2
val['from_date_range'] = from_d2
val['date_from'] = date_from
val['date_to'] = date_to
val['user_id'] = uid
val['printed_by'] = str(printed)
val['print_date'] = p_date
if data['form']['division_id']:
val['division_id'] = division_id
val['division_name'] = division_name
else:
val['division_id'] = 0
val['division_name'] = 'ALL'
pass
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.jasper_allotted_components_report', 'kg.allotted.components', parser=jasper_allotted_components_report_print, )
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
import os
class onscreen_gate_pass_report(JasperDataParser.JasperDataParser):
def __init__(self, cr, uid, ids, data, context):
super(onscreen_gate_pass_report, self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val={}
val['pass_id'] = ids[0]
return val
def generate_records(self, cr, uid, ids, data, context):
print data,'afdssgsggsgfs'
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_gate_pass_report', 'kg.gate.pass', parser=onscreen_gate_pass_report, )
to_d2 = datetime.strftime(to_d1, "%d-%m-%Y")
from_date = date_from.encode("utf-8")
from_d1 = datetime.strptime(from_date, "%Y-%m-%d")
from_d2 = datetime.strftime(from_d1, "%d-%m-%Y")
val["to_date_range"] = to_d2
val["from_date_range"] = from_d2
val["date_from"] = date_from
val["date_to"] = date_to
val["user_id"] = uid
val["printed_by"] = str(printed)
val["print_date"] = p_date
if data["form"]["division_id"]:
val["division_id"] = division_id
val["division_name"] = division_name
else:
val["division_id"] = 0
val["division_name"] = "ALL"
pass
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper(
"report.jasper_schedule_register_report", "kg.schedule.register", parser=jasper_schedule_register_report_print
)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
def send_mail(self, cr, uid, ids, context=None):
if context is None:
context = {}
attachments = []
form_obj = self.pool.get(
'mail.compose.message.product.datasheet').browse(cr,
uid,
ids[0],
context=context)
date = time.strftime('%Y-%m-%d %H:%M:%S')
sent_date = _('On %(date)s, ') % {'date': date}
sender = _('%(sender_name)s wrote:') % {
'sender_name': tools.ustr(form_obj.email_from or _('You'))
}
quoted_body = '> %s' % tools.ustr(
form_obj.body_text.replace('\n', "\n> ") or '')
body = '\n'.join(["\n", (sent_date + sender), quoted_body])
if form_obj.user_signature == 1:
body += "\n" + (self.pool.get('res.users').browse(
cr, uid, uid).signature or '')
subject = "%s" % (form_obj.subject)
msg_vals = {
'subject': form_obj.subject,
'date': time.strftime('%Y-%m-%d %H:%M:%S'),
'user_id': uid,
'model': 'product.product',
'res_id': context['active_id'],
'body_text': body,
'body_html': False,
'email_from': form_obj.email_from,
'email_to': form_obj.email_to,
'email_cc': '',
'email_bcc': '',
'subtype': 'plain',
#'headers': headers, # serialize the dict on the fly
'state': 'outgoing',
'auto_delete': True
}
email_msg_id = self.pool.get('mail.message').create(
cr, uid, msg_vals, context)
if form_obj.report_template:
jasper_class = report_jasper('report.product.datasheet.jasper',
'product.product',
parser=None)
(result,
format) = jasper_class.create(cr,
uid,
context['active_ids'], {
'model': 'product.product',
'id': context['active_ids'][0],
'ids': context['active_ids']
},
context=context)
attachment_data = {
'name': 'ficha_tecnica_' + time.strftime('%Y-%m-%d') + '.pdf',
'datas_fname':
'ficha_tecnica_' + time.strftime('%Y-%m-%d') + '.pdf',
'datas': result and result.encode('base64'),
'res_model': 'mail.message',
'res_id': email_msg_id,
}
attachments.append(
self.pool.get('ir.attachment').create(cr, uid, attachment_data,
context))
if attachments:
self.pool.get('mail.message').write(
cr,
uid,
email_msg_id, {'attachment_ids': [(6, 0, attachments)]},
context=context)
ok = self.pool.get('mail.message').send(cr,
uid, [email_msg_id],
context=context)
if ok == True:
product_obj = self.pool.get('product.product').browse(
cr, uid, context['active_ids'][0])
if form_obj.contact_ids:
for cont in form_obj.contact_ids:
if cont.partner_id:
partner_id = cont.partner_id.id
else:
partner_id = False
self.pool.get('product.sheet.shipments').create(
cr, uid, {
'partner_id': partner_id,
'contact_id': cont.id,
'date': time.strftime("%Y-%m-%d"),
'product_id': product_obj.id,
'revision': product_obj.last_revision
})
return {'type': 'ir.actions.act_window_close'}
self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val = {}
user_rec = self.pool.get('res.users').browse(cr, uid, uid)
cheque_ids = []
print "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
for item in ids:
cheque_ids.append(str(item))
val['cheque_id'] = ",".join(str(x) for x in ids)
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_custom_cheque_print',
'account.voucher',
parser=onscreen_custom_cheque_print)
for line in claim_obj.product_lines:
for pol in line.pol_ids:
if pol.order_id and pol.order_id.state != 'cancel' and (pol.remark or pol.remark_image_ids):
if pol.remark:
remark = pol.remark
remark = remark.replace('\t', ' ')
line_data = {
'sequence': line.sequence_no or '',
'product': line.product_id and line.product_id.name or '',
'remark': remark or '',
'id': line.order_id.id
}
lines.append(line_data)
if pol.remark_image_ids:
for image in pol.remark_image_ids:
img_data = {
'sequence': line.sequence_no or '',
'product_name': line.product_id and line.product_id.name or '',
'image': image.datas
}
image_lines.append(img_data)
lines = sorted(lines, key=lambda a: a['id'])
vals['lines'] = lines
vals['image_lines'] = image_lines
result.append(vals)
print result
return result
jasper_report.report_jasper('report.remarks.report.jasper', 'crm.lead', parser=remark_report)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
partner_code = partner_obj.partner_ac_code or ''
if partner_code:
partner_name = "%s\n%s" % (partner_code, partner_name)
partner_address = partner_pool._display_address(cr,
uid,
partner_obj,
context=context)
partner_address_list = partner_address.split("\n")
new_partner_address_list = []
for partner in partner_address_list:
if partner:
new_partner_address_list.append(partner)
partner_address = "\n".join(new_partner_address_list)
result.append({
'customer_name':
partner_name,
'partner_address':
partner_address and partner_address.upper() or '',
})
return result
jasper_report.report_jasper('report.subledger.jasper',
'subledger.print',
parser=subledger_report)
jasper_report.report_jasper('report.subledger.jasper.xls',
'subledger.print',
parser=subledger_report)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
'tr_start_date':
datetime.strptime(tr.start_date, '%Y-%m-%d'),
'tr_closing_date':
datetime.strptime(tr.closing_date, '%Y-%m-%d'),
'amount':
amount or "0.00",
'interest_rate':
tr.interest_rate / 100.00 or "0.00",
'duration':
tr.duration,
'int_clsoing':
intrest_clsoing or "0.00",
'int_today':
tr.interest_today or "0.00",
'purpose':
tr.note
}
result.append(vals)
else:
vals = {
'tr': "(TR #: %s)" % (tr_num),
}
result.append(vals)
return result
jasper_report.report_jasper('report.tr.report.jasper',
'tr.report.wizard',
parser=tr_report)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
# 'amt_available' : ((total_amt + add_total) - less_total) + od_limit or "0.00",
# 'total_less' : total_less or "0.00",
# 'net_funds' : ((total_amt + add_total) - less_total) + od_limit or "0.00",
# 'total_less' : total_less,
# }
# result.append(vals)
# else:
# vals = {
# 'report' : "%s OD A/C RECONCILIATION AS ON %s"%(data.get('account_id'),datetime.strptime(data.get('date'), "%Y-%m-%d").strftime("%d.%m.%Y")),
# 'balance_bank' : total_amt or "0.00",
# 'balance_book' : (total_amt + add_total) - less_total or "0.00",
# 'less_total' : less_total or "0.00",
# 'od_limit' : od_limit or "0.00",
# 'total_less' : total_less or "0.00",
# 'amt_available' : ((total_amt + add_total) - less_total) + od_limit or "0.00",
# 'net_funds' : ((total_amt + add_total) - less_total) + od_limit or "0.00",
# }
# result.append(vals)
# for r in result:
# if r.get('sub_report'):
# r.update({
# 'sub_report':sub_report
# })
result = sorted(result, key=operator.itemgetter('group'))
return result
jasper_report.report_jasper('report.daily_bank_reconciliation_jasper',
'daily.bank.reconciliation.wizard',
parser=daily_bank_reconciliation_report)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val = {}
user_rec = self.pool.get('res.users').browse(cr, uid, uid)
cr_date = datetime.now()
cr_date = datetime.strftime(cr_date, '%Y-%m-%d %H:%M:%S')
cr_date = datetime.strptime(cr_date, '%Y-%m-%d %H:%M:%S')
ist_time = cr_date + timedelta(minutes=330)
print_date = ist_time.strftime('%d/%m/%Y %H:%M:%S')
val['indent_id'] = ids[0]
val['printed_by'] = user_rec.partner_id.name
val['print_date'] = print_date
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_purchase_indent_report',
'purchase.requisition',
parser=onscreen_purchase_indent_report)
partner_obj = self.pool.get('res.partner').search(
self.cr, self.uid, [('id', '=', company_rec.partner_id.id)])
partner_rec = self.pool.get('res.partner').browse(
self.cr, self.uid, partner_obj[0])
partner_st = partner_rec.street
partner_st2 = partner_rec.street2
partner_zip = partner_rec.zip
partner_add = partner_st + "" + partner_st2 + "" + partner_zip
# account_rec = data['form']['account_id']
val['from_date'] = frm_rec
val['to_date'] = t_rec
val['account_id'] = 2
val['user_name'] = user_name
val['current_time'] = crt_time
val['t_date'] = t_d2
val['company_name'] = company_name
val['company_add'] = partner_add
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.jasper_profit_loss_report',
'res.users',
parser=profit_loss_report)
'other_allowance_label':
'Other Allowances [Air Tickets + Other if any]' or '',
'total_payable':
total_payable or '0.0',
'monthly_deduction':
less or '0.0',
'net_amount_payable':
total_payable - less or '0.0',
'leave_encashed':
payslip.leave_encashed or '0',
'leave_from':
leave_from_date,
'leave_to':
leave_to,
'other_allow':
False,
'leave_applied':
abs((leave_to - leave_from_date).days) + 1,
'from_month':
from_month or ''
}
result.append(vals)
return result
jasper_report.report_jasper('report.leave_salary_report_jasper',
'hr.payslip',
parser=leave_salary_report)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val={}
user_rec = self.pool.get('res.users').browse(cr,uid,uid)
dc_ids = []
for item in ids:
dc_ids.append(str(item))
print"dc_ids",dc_ids
print"idsidsids",ids
print"idsidsids",str(ids)
val['printed_by'] = user_rec.name
val['dc_id'] = ",".join(str(x) for x in ids)
print "val....................", val
return val
def generate_records(self, cr, uid, ids, data, context):
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_drawing_print_report', 'purchase.order', parser=onscreen_drawing_print_report)
total_deduction += line.total
else:
line_vals = {'name': '', 'total': '', 'display_bold': False}
vals['sub_report'].append(line_vals)
if payslip.other_allow_ids:
for other_allow in payslip.other_allow_ids:
other_vals = {
'other_name': other_allow.name,
'other_total': round(other_allow.amount),
}
vals['sub_report_other'].append(other_vals)
total_earning += other_allow.amount
else:
other_vals = {
'other_name': '',
'other_total': '',
}
vals['sub_report_other'].append(other_vals)
vals['total_earnings'] = round(total_earning)
vals['total_deduction'] = round(total_deduction)
vals['net_pay'] = round(total_earning) - round(total_deduction)
result.append(vals)
return result
jasper_report.report_jasper('report.payslip_report_jasper',
'hr.payslip',
parser=hatta_report_payslip)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
import os
class onscreen_mrn_report(JasperDataParser.JasperDataParser):
def __init__(self, cr, uid, ids, data, context):
super(onscreen_mrn_report, self).__init__(cr, uid, ids, data, context)
def generate_data_source(self, cr, uid, ids, data, context):
return 'records'
def generate_ids(self, cr, uid, ids, data, context):
return {}
def generate_properties(self, cr, uid, ids, data, context):
return {}
def generate_parameters(self, cr, uid, ids, data, context):
val={}
val['indent_id'] = ids[0]
return val
def generate_records(self, cr, uid, ids, data, context):
print data,'afdssgsggsgfs'
pool= pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper('report.onscreen_mrn_report', 'kg.depindent', parser=onscreen_mrn_report, )
company_rec = self.pool.get("res.company").browse(self.cr, self.uid, company_id[0])
company_name = company_rec.name
partner_obj = self.pool.get("res.partner").search(self.cr, self.uid, [("id", "=", company_rec.partner_id.id)])
partner_rec = self.pool.get("res.partner").browse(self.cr, self.uid, partner_obj[0])
partner_st = partner_rec.street
partner_st2 = partner_rec.street2
partner_zip = partner_rec.zip
partner_add = partner_st + "" + partner_st2 + "" + partner_zip
# account_rec = data['form']['account_id']
val["m_from_date"] = t_d4
val["m_to_date"] = t_d2
val["p_from_date"] = t_d6
val["p_to_date"] = t_d5
val["account_id"] = 2
val["user_name"] = user_name
val["current_time"] = crt_time
val["t_date"] = t_d2
val["company_name"] = company_name
val["company_add"] = partner_add
return val
def generate_records(self, cr, uid, ids, data, context):
pool = pooler.get_pool(cr.dbname)
return {}
jasper_report.report_jasper("report.jasper_sales_register_report", "res.users", parser=sales_register_report)
