355 lines
11 KiB
Python
355 lines
11 KiB
Python
import time
|
|
from datetime import datetime
|
|
from calendar import monthrange
|
|
|
|
from netforce.model import Model, fields, get_model
|
|
from netforce.access import get_active_company
|
|
from netforce.utils import get_file_path
|
|
from . import utils
|
|
|
|
class ImportPayment(Model):
|
|
_name="import.clinic.payment"
|
|
_string="Clinic Payment"
|
|
_multi_company=True
|
|
|
|
def _get_name(self,ids,context={}):
|
|
res={}
|
|
for obj in self.browse(ids):
|
|
res[obj.id]=obj.type_id.name
|
|
return res
|
|
|
|
def _get_partner(self,ids,context={}):
|
|
res={}
|
|
for obj in self.browse(ids):
|
|
ptype=obj.type_id
|
|
contact_id=None
|
|
if ptype:
|
|
contact=ptype.contact_id
|
|
if contact:
|
|
contact_id=contact.id
|
|
res[obj.id]=contact_id
|
|
return res
|
|
|
|
_fields={
|
|
'name': fields.Char("Name",function="_get_name"),
|
|
'type_id': fields.Many2One("clinic.patient.type","Patient Type",required=True),
|
|
'hcode_id': fields.Many2One("clinic.hospital", "Hospital",required=True),
|
|
'date': fields.Date("Date"),
|
|
'date_from': fields.Date("From"),
|
|
'date_to': fields.Date("To"),
|
|
'file': fields.File("File"),
|
|
'max_row': fields.Integer("Max Row"),
|
|
'remain_row': fields.Integer("Pending"),
|
|
'total_row': fields.Integer("Total"),
|
|
'est_time': fields.Float("Estimate Time",scale=4),
|
|
'msg': fields.Text("Message"),
|
|
'done_qty': fields.Integer("Success"),
|
|
'fail_qty': fields.Integer("Other"),
|
|
'match_qty': fields.Integer("Match"),
|
|
'unmatch_qty': fields.Integer("UnMatch"),
|
|
'state': fields.Selection([['draft','Draft'],['confirmed','Confirmed'],['fail','Fail'],['success','Success']],'State'),
|
|
'payment_id': fields.Many2One("account.payment","Payment"),
|
|
'company_id': fields.Many2One("company","Company"),
|
|
'partner_id': fields.Many2One("partner","Fee Contact",function="_get_partner"),
|
|
}
|
|
|
|
def get_hcode_id(self,context={}):
|
|
hp_ids=get_model("clinic.hospital").search([])
|
|
hp_id=None
|
|
if hp_ids:
|
|
hp_id=hp_ids[0]
|
|
return hp_id
|
|
|
|
def _get_date_from(self,context={}):
|
|
datenow=time.strftime("%Y-%m-%d")
|
|
year,month,day=datenow.split("-")
|
|
return '%s-%s-01'%(year,month)
|
|
|
|
def _get_date_to(self,context={}):
|
|
datenow=datetime.now().strftime("%Y-%m-%d")
|
|
year,month,day=datenow.split("-")
|
|
weekday, total_day=monthrange(int(year), int(month))
|
|
return '%s-%s-%s'%(year,month,total_day)
|
|
|
|
def _get_patient_type(self,context={}):
|
|
st=get_model('clinic.setting').browse(1)
|
|
ptype=st.patient_type_id
|
|
ptype_id=None
|
|
if ptype:
|
|
ptype_id=ptype.id
|
|
return ptype_id
|
|
|
|
_defaults={
|
|
'date': lambda *a: time.strftime("%Y-%m-%d"),
|
|
'date_from': _get_date_from,
|
|
'date_to': _get_date_to,
|
|
'hcode_id': get_hcode_id,
|
|
'company_id': lambda *a: get_active_company(),
|
|
'type_id': _get_patient_type,
|
|
'max_row': 50,
|
|
'state': 'draft',
|
|
'is_uc': 0,
|
|
'node': 'HDBills',
|
|
'match_qty': 0,
|
|
'unmatch_qty': 0,
|
|
}
|
|
|
|
def get_patient_invoice(self,state="waiting_payment"):
|
|
print("getting patient invoice")
|
|
dom=[]
|
|
dom.append(['state','=',state])
|
|
invoices={}
|
|
for inv in get_model("account.invoice").search_browse(dom):
|
|
hd_case=inv.related_id
|
|
patient=hd_case.patient_id
|
|
key=(inv.date,patient.id)
|
|
invoices[key]={
|
|
'id': inv.id,
|
|
'amount_due': inv.amount_due,
|
|
'hd_case_id': hd_case.id,
|
|
}
|
|
return invoices
|
|
|
|
def get_patient_expense(self):
|
|
# XXX date_from, date_to
|
|
print("getting expense")
|
|
expenses={}
|
|
for exp in get_model("clinic.hd.case.expense").search_browse([]):
|
|
patient=exp.patient_id
|
|
hd_case=exp.hd_case_id
|
|
key=(exp.date,patient.id)
|
|
expenses[key]={
|
|
'id': exp.id,
|
|
'amount': exp.amount,
|
|
'patient_id': patient.id,
|
|
'hd_case_id': hd_case.id,
|
|
}
|
|
invoice=exp.invoice_id
|
|
if invoice:
|
|
expenses[key]['invoice_id']=invoice.id
|
|
payment=exp.payment_id
|
|
if payment:
|
|
expenses[key]['payment_id']=payment.id
|
|
|
|
return expenses
|
|
|
|
def get_all_patient(self):
|
|
print("getting patient")
|
|
patients={}
|
|
for pt in get_model("clinic.patient").search_read([[]],['name','hn','hn_no']):
|
|
key=pt['hn_no']
|
|
patients[key]={
|
|
'id': pt['id'],
|
|
'name': pt['name'],
|
|
}
|
|
return patients
|
|
|
|
|
|
def get_hd_case(self):
|
|
print("getting hd case")
|
|
hd_cases={}
|
|
for hd_case in get_model("clinic.hd.case").search_read([[]],['patient_id','date']):
|
|
patient_id=hd_case['patient_id'][0]
|
|
date=hd_case['date']
|
|
key=(date,patient_id)
|
|
hd_cases[key]={
|
|
'id': hd_case['id'],
|
|
}
|
|
return hd_cases
|
|
|
|
def get_hn_no(self,hn=""):
|
|
return ''.join(h for h in hn if h.isdigit())
|
|
|
|
def import_payment_pks(self,ids,context={}):
|
|
'''
|
|
step to import
|
|
1. select period : date from/to
|
|
2. select hospital code
|
|
2. select patient type
|
|
3. select file
|
|
- pks=> excel
|
|
- uc => xml
|
|
|
|
'''
|
|
obj=self.browse(ids)[0]
|
|
fname=obj.file
|
|
fpath=get_file_path(fname)
|
|
lines=utils.read_excel(fpath,show_datetime=False)
|
|
if not lines:
|
|
raise Exception("No data to import")
|
|
msg=""
|
|
dom=[]
|
|
dom.append(['date','>=',obj.date_from])
|
|
dom.append(['date','<=',obj.date_to])
|
|
expenses=get_model("clinic.hd.expense").search_browse(dom)
|
|
for line in lines:
|
|
pass
|
|
obj.write({
|
|
'total_row': len(lines),
|
|
'msg': msg,
|
|
})
|
|
|
|
return {
|
|
'next': {
|
|
'name': 'import_clinic_payment',
|
|
'mode': 'form',
|
|
'active_id': obj.id,
|
|
},
|
|
'flash': 'Import successfully'
|
|
}
|
|
|
|
def get_invoice_epobills(self,lines):
|
|
for line in lines:
|
|
hn=line.get('hn',"")
|
|
hn_no=self.get_hn_no(hn)
|
|
print(hn_no)
|
|
return lines
|
|
|
|
def get_invoice_hdbills(self,lines):
|
|
for line in lines:
|
|
date,time=line.get("dttran").split("T")
|
|
invno=line.get("invno")
|
|
hdrate=float(line.get("hdrate","0"))
|
|
hn=line.get('hn',"")
|
|
hn_no=self.get_hn_no(hn)
|
|
print(hn_no)
|
|
return lines
|
|
|
|
def import_payment_uc(self,ids,context={}):
|
|
obj=self.browse(ids)[0]
|
|
fname=obj.file
|
|
if "_" not in fname and len(fname.split("_")) <3:
|
|
raise Exception("File name should be HCODE_[EURSTM or UOCDSTM]_YYYYMMDD")
|
|
fpath=get_file_path(fname)
|
|
hcode,itype,date=fname.split("_")
|
|
node=''
|
|
if itype=='EURSTM':
|
|
node='EPOBills'
|
|
elif itype=='UOCDSTM':
|
|
node='HDBills'
|
|
else:
|
|
node='HDBills'
|
|
|
|
lines=utils.read_xml(fpath,node=node)
|
|
if itype=='EURSTM':
|
|
lines=self.get_invoice_epobills(lines)
|
|
elif itype=='UOCDSTM':
|
|
lines=self.get_invoice_hdbills(lines)
|
|
else:
|
|
lines=[]
|
|
if not lines:
|
|
raise Exception("No Data to import")
|
|
return {
|
|
'next': {
|
|
'name': 'import_clinic_payment',
|
|
'mode': 'form',
|
|
'active_id': obj.id,
|
|
},
|
|
'flash': 'Import succeffully',
|
|
}
|
|
|
|
def import_payment(self,ids,context={}):
|
|
obj=self.browse(ids)[0]
|
|
fname=obj.file
|
|
if not fname:
|
|
raise Exception("File not found")
|
|
patient_type=obj.type_id
|
|
res={}
|
|
if patient_type.code in ('S'):
|
|
res=self.import_payment_pks(ids,context)
|
|
elif patient_type.code in ('U'):
|
|
res=self.import_payment_uc(ids,context)
|
|
else:
|
|
raise Exception("No script to import payment for type %s"%patient_type.name)
|
|
return res
|
|
|
|
def approve(self,ids,context={}):
|
|
obj=self.browse(ids)[0]
|
|
partner=obj.partner_id
|
|
if not partner:
|
|
raise Exception("No contact on this patient")
|
|
company_id=get_active_company()
|
|
account_receivable_id=partner.account_receivable_id
|
|
if not account_receivable_id:
|
|
st=get_model('settings').browse(1)
|
|
account_receivable_id=st.account_receivable_id
|
|
if not account_receivable_id:
|
|
raise Exception("Not found account recieveable in account setting")
|
|
account_id=account_receivable_id.id
|
|
datenow=time.strftime("%Y-%m-%d")
|
|
vals={
|
|
"partner_id": partner.id,
|
|
"company_id": company_id,
|
|
"type": "in",
|
|
"pay_type": "invoice",
|
|
'date': datenow,
|
|
"account_id": account_id,
|
|
'related_id': "import.clinic.payment,%s"%obj.id,
|
|
'invoice_lines': [],
|
|
}
|
|
|
|
for mline in obj.match_lines:
|
|
inv=mline.invoice_id
|
|
if inv:
|
|
amt=inv.amount_due or 0.0
|
|
vals['invoice_lines'].append(('create',{
|
|
'type': 'invoice',
|
|
'account_id': account_id,
|
|
'invoice_id': inv.id,
|
|
'amount': amt,
|
|
}))
|
|
|
|
for umline in obj.unmatch_lines:
|
|
inv=mline.invoice_id
|
|
if inv:
|
|
amt=inv.amount_due or 0.0
|
|
vals['invoice_lines'].append(('create',{
|
|
'type': 'invoice',
|
|
'account_id': account_id,
|
|
'invoice_id': inv.id,
|
|
'amount': amt,
|
|
}))
|
|
|
|
payment=obj.payment_id
|
|
if payment:
|
|
for inv_line in payment.invoice_lines:
|
|
inv_line.delete()
|
|
payment.write(vals)
|
|
else:
|
|
payment_id=get_model("account.payment").create(vals,context={"type":"in"})
|
|
vals['payment_id']=payment_id
|
|
obj.write({
|
|
'payment_id': payment_id,
|
|
'state': 'approved',
|
|
})
|
|
|
|
#payment=get_model('account.payment').browse(payment_id)
|
|
#payment.post()
|
|
return {
|
|
'next': {
|
|
'name': 'import_clinic_payment',
|
|
'mode': 'form',
|
|
'active_id': obj.id,
|
|
},
|
|
'flash': '%s has been paid'%obj.type_id.name,
|
|
}
|
|
|
|
def to_draft(self,ids,context={}):
|
|
obj=self.browse(ids)[0]
|
|
obj.write({
|
|
'state': 'draft',
|
|
})
|
|
|
|
def onchange_type(self,context={}):
|
|
data=context['data']
|
|
is_uc=0
|
|
type_id=data['type_id']
|
|
ptype=get_model('clinic.patient.type').browse(type_id)
|
|
if ptype.code=='U':
|
|
is_uc=1
|
|
data['is_uc']=is_uc
|
|
return data
|
|
|
|
|
|
ImportPayment.register()
|