clinic/netforce_clinic/models/dialyzer.py

import time

from netforce.model import Model, fields, get_model
from netforce.access import get_active_company, get_active_user, set_active_user

class Dialyzer(Model):
    _name="clinic.dialyzer"
    _string="Dialyzer"
    _audit_log=True
    _name_field="number"
    _multi_company=True
    
    _fields={
        "number": fields.Char("Number",required=True,search=True),
        'ref': fields.Char("Ref."),
        "description": fields.Text("Description",search=True),
        "date": fields.Date("Create Date",search=True),
        "use_time": fields.Integer("Use Time"),
        "max_use_time": fields.Integer("Max Use Time"),
        "exp_date": fields.Date("Expiry Date",search=True),
        "dialyzer_type": fields.Selection([("low","low flux"),("high","high flux"),("dbl","dbl hifulx")],"Dialyzer Type"),
        "state": fields.Selection([("new","New"),("active","Active"),("drop","Drop"),("expire","Expire"),('cancelled','Cancelled')],"Status"),
        "comments": fields.One2Many("message","related_id","Comments"),
        "company_id": fields.Many2One("company","Company"),
        'product_id': fields.Many2One("product", "Product",required=True),
        "pickings": fields.One2Many("stock.picking","related_id","Pickings"),
        "patient_id": fields.Many2One("clinic.patient","Patient"),
        "visit_id": fields.Many2One("clinic.visit","Visit"),
        "hd_case_id": fields.Many2One("clinic.hd.case","HD Case"),
        "hd_cases": fields.One2Many("clinic.hd.case","dlz_id","HD Case"), #TODO funtion to get hd case
    }

    def _get_number(self,context={}):
        while 1:
            seq_name='Clinic Dialyzer'
            seq_id=get_model("sequence").find_sequence(name=seq_name)
            if not seq_id:
                raise Exception("Can not found sequence %s"%seq_name)
            num=get_model("sequence").get_next_number(seq_id,context=context)
            if not num:
                return None
            user_id=get_active_user()
            set_active_user(1)
            res=self.search([["number","=",num]])
            set_active_user(user_id)
            if not res:
                return num
            get_model("sequence").increment_number(seq_id,context=context)
    
    def _get_product(self,context={}):
        categ_ids=get_model("product.categ").search([['name','=','Dialyzer']])
        product_id=None
        found=False
        for prod in get_model("product").search_browse([]):
            if found:
                break
            if prod.categ_id.id in categ_ids:
                product_id=prod.id
                found=True
                break
        if not product_id:
            raise Exception("No Product with category 'Dialyzer'")
        return product_id

    _defaults={
        "state": "new",
        "date": lambda *a: time.strftime("%Y-%m-%d"),
        'number': '/',
        "max_use_time": 10,
        "use_time": 0,
        "company_id": lambda *a: get_active_company(),
        'product_id': _get_product,
        'dialyzer_type': 'low',
    }
    _order="date desc,number desc"

    def void(self,ids,context={}):
        obj=self.browse(ids)[0]
        obj.write({"state":"voided"})

    def confirm(self,ids,context={}):
        id=ids[0]
        obj=self.browse(id)
        patient=obj.patient_id
        #if not patient:
            #raise Exception("Patient is required")
        partner=patient.partner_id
        if not partner:
            raise Exception("Contact not for this patient")
        ship_address_id=None
        for address in partner.addresses:
            if address.type=="shipping":
                ship_address_id=address.id
                break
        if not ship_address_id:
            patient.simple_address()
            #raise Exception("contact %s dont'have address with type shipping"%partner.name)
        st=get_model("clinic.setting").browse(1)
        journal=st.stock_journal_id
        if not journal:
            raise Exception("Not found stock journal")

        pick_vals={
            "type": "out",
            'journal_id': journal.id,
            "ref": obj.number,
            "related_id": "clinic.dialyzer,%s"%obj.id,
            "partner_id": obj.patient_id.partner_id.id,
            "ship_address_id": ship_address_id,
            "lines": [],
            "state": "draft",
        }

        res=get_model("stock.location").search([["type","=","customer"]])
        if not res:
            raise Exception("Customer location not found")
        cust_loc_id=res[0]

        prod=obj.product_id
        wh_loc_id=prod.location_id.id # product -> tab inventory -> warehouse filed
        if not wh_loc_id:
            res=get_model("stock.location").search([["type","=","internal"]])
            if not res:
                raise Exception("Warehouse not found")
            wh_loc_id=res[0]
        line_vals={
            "product_id": prod.id,
            "qty": 1,
            "uom_id": prod.uom_id.id,
            "location_from_id": wh_loc_id,
            "location_to_id": cust_loc_id,
        }
        pick_vals["lines"].append(("create",line_vals))
        if not pick_vals["lines"]:
            return {
                "flash": "Nothing left to deliver",
            }
        picking_obj=get_model("stock.picking")
        pick_id=picking_obj.create(pick_vals,context={"pick_type": "out"})
        pick=picking_obj.browse(pick_id)
        pick.set_done([pick_id])
        number=obj.number.replace("/","")
        if not number:
            number=self._get_number(context)
        obj.write({
            "number": number,
            "state": "active",
            })
        return {
            'next':{
               'name': 'clinic_dialyzer',
               'mode': 'form',
               'active_id': obj.id
            },
            'flash': 'Dializer %s is confirmed'%(obj.number),
        }
        print("Done!")

    def delete(self,ids,context={}):
        for obj in self.browse(ids):
            if obj.state != 'new':
                raise Exception("Can not delete Dializer %s because state is not 'new'"%obj.number)
        super().delete(ids)
    
    def cancel(self,ids,context={}):
        obj=self.browse(ids[0])
        for pick in obj.pickings:
            pick.to_draft(context)
            pick.delete()
        obj.write({
            'state': 'cancelled',
        })
        return {
            'next':{
               'name': 'clinic_dialyzer',
               'mode': 'form',
               'active_id': obj.id
            },
            'flash': 'Dializer %s is cancelled'%(obj.number),
        }
    
    def renew(self,ids,context={}):
        obj=self.browse(ids[0])
        # XXX
        if obj.use_time > obj.max_use_time:
            raise Exception("No long to use it (use time > max use time")
        obj.cancel()
        obj.write({"state": "new"})

    def drop(self,ids,context={}):
        obj=self.browse(ids[0])
        obj.write({"state": "drop"})
        

    def copy(self,ids,context={}):
        obj=self.browse(ids[0])
        vals={
            'patient_id': obj.patient_id.id,
            'pickings':[],
        }
        new_id=self.create(vals,context=context)
        new_obj=self.browse(new_id)
        return {
            'next':{
               'name': 'clinic_dialyzer',
               'mode': 'form',
               'active_id': new_id,
            },
            'flash': 'Dializer %s is copy to %s'%(obj.number,new_obj.number),
        }
        

Dialyzer.register()