# -*- coding: utf-8 -*-

##############################################################################
#
#    TicTac allows several HR functionalities. This program bases on Odoo v. 8. Copyright
#    (C) 2018 ITIS www.itis.de commissioned by Wikimedia Deutschland e.V.
#
#    This program is free software: you can redistribute it and/or modify it under the
#    terms of the GNU Affero General Public License as published by the Free Software
#    Foundation, either version 3 of the License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful, but WITHOUT ANY
#    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
#    PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License along with
#    this program. If not, see <https://www.gnu.org/licenses/>.
#
##############################################################################

from openerp import models, api, fields, _
from openerp.tools import float_round
from openerp.tools import DEFAULT_SERVER_DATETIME_FORMAT, DEFAULT_SERVER_DATE_FORMAT
from openerp.exceptions import Warning
from datetime import datetime, timedelta
from calendar import monthrange
from dateutil.relativedelta import relativedelta
from openerp import http
from openerp.addons.web.controllers import main as parent_controller
from openerp.http import request, serialize_exception as _serialize_exception
import logging
import re
logger = logging.getLogger(__name__)
import pdb
import logging
logger = logging.getLogger(__name__)

number_select = [(x,str('x')) for x in range(1,7)]

class employee_overtime_count(models.Model):

    _name = 'employee.overtime.count'
    _rec_name = "emp_overtime_count"

    emp_overtime_count = fields.Float(string='Overtime Count')
    employee_id = fields.Many2one('hr.employee',string="Employee")

class resource_calendar(models.Model):
    _inherit = 'resource.calendar'

    hourly_basis = fields.Boolean(string="Hourly Basis")

class itis_contract_type(models.Model):

    _name = 'itis.contract.type'

    name = fields.Char(string="Art")

class planned_job(models.Model):

    _name = 'planned.job'

    name = fields.Char(string="Planstellen")

class itis_confession(models.Model):

    _name = 'itis_confession'

    name = fields.Char(string="Bezeichnung")

class leave_time(models.Model):

    _name = 'leave.time'

    active = fields.Boolean(string="Active")
    fullday_start_time = fields.Integer(string="Start Time")
    fullday_end_time = fields.Integer(string="End Time")
    halfday_morning_start_time = fields.Integer(string="Start Time")
    halfday_morning_end_time = fields.Integer(string="End Time")
    halfday_afternoon_start_time = fields.Integer(string="Start Time")
    halfday_afternoon_end_time = fields.Integer(string="End Time")

class itis_employee_children(models.Model):

    _name = 'itis_employee_children'

    name = fields.Char(string="Name")
    birth_date = fields.Date(string="Geburtsdatum")
    parent_id = fields.Many2one('hr.employee',string="Mitarbeiter")

class itis_limitation_reason(models.Model):

    _name = 'itis_limitation_reason'

    name = fields.Char(string="Bezeichnung")


class itis_hr_contact(models.Model):

    _name = 'itis.hr.contact'

    name = fields.Char(index=True, required=1)
    street = fields.Char()
    street2 = fields.Char()
    zip = fields.Char(change_default=True)
    city = fields.Char()
    state_id = fields.Many2one("res.country.state", string='State', ondelete='restrict')
    country_id = fields.Many2one('res.country', string='Country', ondelete='restrict')
    email = fields.Char()
    phone = fields.Char()
    fax = fields.Char()
    mobile = fields.Char()

class itis_hr_employee_fte(models.Model):

    _name = 'hr.employee.fte'

    emp_id = fields.Many2one('hr.employee', string='Employee')
    department_id = fields.Many2one('hr.department', string='Department')
    fte = fields.Float(string="FTE", digits=(5, 3))

class health_insurance(models.Model):

    _name = 'hr.health.insurance'

    name = fields.Char(string='Name')

class falimy_status(models.Model):

    _name = 'hr.family.status'

    name = fields.Char(string='Status')

class hr_payroll_structure(models.Model):
    _inherit = 'hr.payroll.structure'

    base_on_hours = fields.Boolean(string="Base on Hours")


class itis_hr_employee(models.Model):

    _inherit = 'hr.employee'

    surname = fields.Char(string="Vorname")
    second_name = fields.Char(string="Nachname")
    birth_name = fields.Char(string="Geburtsname")
    taxclass = fields.Selection(selection=[(1,'Steuerklasse 1'),(2,'Steuerklasse 2'),(3,'Steuerklasse 3'),(4,'Steuerklasse 4'),(5,'Steuerklasse 5'),(6,'Steuerklasse 6')], string="Steuerklasse")
    confession = fields.Many2one('itis_confession', string="Konfession")
    health_insurance = fields.Many2one('hr.health.insurance', string="Krankenkasse")
    disability = fields.Selection([('no','nein'),('yes','Ja')], string="Schwerbehinderung")
    disability_limited_until = fields.Date(string="Befristet bis")
    fte = fields.Float(string="FTE", compute="_compute_fte", digits=(5, 3))
    sign_permission = fields.Char(string="Zeichnungsbefugnis")
    active_employee = fields.Boolean(string="Aktiv")
    emergency_contact = fields.Many2one('itis.hr.contact', string='Notfallkontakt')
    emergency_contact2 = fields.Many2one('itis.hr.contact', string='zweiter Notfallkontakt')
    children_ids = fields.One2many('itis_employee_children', 'parent_id', string='Kinder')
    five_years = fields.Date(string="5-Jahres-Jubiläum")
    bereich = fields.Many2one('hr.department', string="Bereich")
    overtime_count = fields.Float(string='Overtime Count')
    fte_ids = fields.One2many('hr.employee.fte', 'emp_id', string="FTEs")
    family_status = fields.Many2one('hr.family.status',string='Familienstand')
    initial_date = fields.Date(string='Ersteintrittsdatum')
    temp_contract_end_date = fields.Date(string='Enddatum befristeter Vertrag',compute="_compute_contract_end_date",multi="contract_end_date")
    wage_info = fields.Text(string='Wage Information')

    br_member = fields.Selection([('no','nein'),('yes','Ja')], string="BR Mitglied")
    position = fields.Char(string="Position")
    planned_job_id = fields.Many2one('planned.job',string='Planstellen')

    employee_meeting_id = fields.Many2one('employee.meeting',compute="_compute_next_emp_meeting",string='Next Meeting')
    employee_instruction_id = fields.Many2one('employee.instruction',compute="_compute_next_emp_instruction_meeting",string='Next Instruction Meeting')

    employee_overtime_id = fields.Many2one('employee.overtime.count',string="Overtime Count New")
    computed_overtime_count = fields.Float(string='Overtime Count',compute="_compute_overtime_count")

    executive_employee = fields.Boolean(string="Executive Employee")
    contract_type = fields.Many2one('hr.contract.type',string="Type", compute="get_active_contract_data", multi="contract_data")
    contract_wage = fields.Float(string="Wage", compute="get_active_contract_data", multi="contract_data")
    contract_leaves = fields.Float(string="Leaves", compute="get_active_contract_data", multi="contract_data")
    contract_notes = fields.Text(string="Notes", compute="get_active_contract_data", multi="contract_data")
    contract_limitation_reason = fields.Many2one('itis_limitation_reason',string="Reason of Limitation", compute="_compute_contract_end_date", multi="contract_end_date")

    contract_working_hours = fields.Many2one('resource.calendar',string="Working Hours", compute="get_active_contract_data", multi="contract_data")
    contract_trial_end_date = fields.Date(string="Trial End Date", compute="get_active_contract_data", multi="contract_data")

    last_ma_conversation_date = fields.Date(string='Last Meeting', compute="_compute_last_emp_meeting")
    # last_ma_conversation= fields.Many2one('employee.meeting',compute="_compute_last_emp_meeting",string='Last Meeting',help='Use to give most recent meeting in the past')
    compensation_at_vz = fields.Float(string="Compensation At VZ", compute="get_active_contract_data", multi="contract_data")
    remuneration_incl_ag_costs = fields.Float(string="Vergütung inkl. AG Kosten (25%)", compute="get_active_contract_data", multi="contract_data")
    last_contract_changed_wage = fields.Float(string="Last Contract Changed Wage", compute="get_active_contract_data", multi="contract_data")
    last_contract_changed_date = fields.Date(string="Last Contract Change Date", compute="get_active_contract_data", multi="contract_data")

    # the below field is use to calculate the employee wage base on the hour as well as normal wage.It called on the scheduler once in the day.
    emp_wage_cal = fields.Float(string="Wage")

    @api.model
    def get_monthly_employee_data(self):
        """Call from Scheduler, Use to generate monthly employee data report and send it via email to work council"""

        logger.info("---In the get_monthly_employee_data cron--")
        today_date = datetime.today().date()
        last_month_date = today_date -  relativedelta(months= 1)
        hr_employee_brw = self.search([('executive_employee','=',False),('active','=',True)],order='id')
        if hr_employee_brw:
            logger.info("---Records to get %s" %hr_employee_brw)
            # call the subfunction to generate the .csv report
            context = self.env['employee.data.export'].with_context(for_work_council=True).export_csv_subfunction(hr_employee_brw)
            if context:
                # create attachement record of the related csv file
                ir_attachment = self.env['ir.attachment']
                file_name ='employee_data_report_'+str(last_month_date)+'_'+str(today_date)+'.csv'
                attachment_data = {
                        'name': file_name,
                        'datas_fname':file_name,
                        'datas':context.get('default_name'),
                        'res_model': 'email.template',
                    }
                ir_attachment_brw = ir_attachment.create(attachment_data)

                #template = self.env.ref('itis_hr_extend.email_template_monthly_employee_data', False)
                template = False #Added by IT IS to disable email sending.
                if ir_attachment_brw and template:
                    logger.info("---Template found and send a mail")
                    template.write({'attachment_ids': [(6, 0, [ir_attachment_brw.id])]}) # link a attachment to email template
                    template.send_mail(hr_employee_brw[0].id)# send a mail with attachment
                    template.write({'attachment_ids': [(3, ir_attachment_brw.id)]})# to unlink the attachment from template after sending a email


    @api.model
    def open_emp_data_tree(self):
        """Add view for the employee data report,called from the server action"""
        filter_employee_ids = []
        today_date = datetime.today().date()
        hr_contract = self.env['hr.contract']
        hr_employee_recs = self.env['hr.employee'].search([('user_id','!=',False),('parent_id','!=',False)])
        if hr_employee_recs:
            for hr_employee_rec in hr_employee_recs:
                active_contract_brw = hr_contract.search([('employee_id','=',hr_employee_rec.id),
                                        ('date_start','<=',today_date),'|',('date_end','>=',today_date),('date_end','=',False)],limit=1)
                if active_contract_brw:
                    filter_employee_ids.append(hr_employee_rec.id)
                    if active_contract_brw.struct_id.base_on_hours:
                        self.calculate_emp_wage(hr_employee_rec,active_contract_brw)
                    else:
                        hr_employee_rec.write({'emp_wage_cal':active_contract_brw.wage})
        # print"filter_employee_ids----",filter_employee_ids

        domain = "[('id', 'in', " + str(filter_employee_ids) + ")]"
        tree_view_id = self.env.ref('itis_hr_extend.hr_emp_data_tree').id
        value = {
            'domain': domain,
            'name': 'Personalübersicht',
            'view_type': 'form',
            'view_mode': 'tree',
            'res_model': 'hr.employee',
            'view_id': tree_view_id,
            'type': 'ir.actions.act_window'
        }
        return value

    def calculate_emp_wage(self,hr_employee_rec,active_contract_brw):
        """to calculate the monthly wage base on the hours salary structure
        """
        logger.info("---hr_employee_rec %s" %hr_employee_rec)
        gross_salary = 0.0
        hr_payslip = self.env['hr.payslip']
        year = datetime.today().year
        month = datetime.today().month
        selected_month_range,num_day = monthrange(year,month)
        period_start_date =  datetime.today().date().replace(day=1)
        period_end_date = datetime.today().date().replace(day=num_day)

        contract_date_start = datetime.strptime(active_contract_brw.date_start,'%Y-%m-%d').date()
        if active_contract_brw.date_end:
            contract_date_end = datetime.strptime(active_contract_brw.date_end,'%Y-%m-%d').date()
        else:
            contract_date_end = datetime.today().date()

        if contract_date_start <= period_start_date:
            period_contract_start_date =period_start_date
        else:
            period_contract_start_date =contract_date_start

        if contract_date_end >= period_end_date:
            period_contract_end_date =period_end_date
        else:
            period_contract_end_date =contract_date_end

        logger.info("---period_contract_start_date %s" %period_contract_start_date)
        logger.info("---period_contract_end_date %s" %period_contract_end_date)
        # print"period_contract_start_date---------",period_contract_start_date
        # print"period_contract_end_date---------",period_contract_end_date


        # #To check for the date and values
        if period_contract_start_date > period_contract_end_date:
            period_contract_end_date = period_contract_start_date
            #period_contract_end_date = period_contract_start_date

        period_contract_start_date = str(period_contract_start_date)
        period_contract_end_date = str(period_contract_end_date)

        payslip_values = {'employee_id':active_contract_brw.employee_id.id,'date_from':period_contract_start_date,'date_to':period_contract_end_date,
                          'contract_id':active_contract_brw.id,'struct_id':active_contract_brw.struct_id.id,'journal_id':1 }


        hr_payslip_brw=hr_payslip.sudo().create(payslip_values)

        res = self.pool.get('hr.payslip').onchange_employee_id(self._cr, self._uid, [], period_contract_start_date, period_contract_end_date,
                                   active_contract_brw.employee_id.id, active_contract_brw.id, None)
        if res and res.get('value'):
            value = res.get('value')
            worked_days_line_ids = value.get('worked_days_line_ids')
            for line_rec in worked_days_line_ids:
                line_rec.update({'payslip_id':hr_payslip_brw.id})
                self.env['hr.payslip.worked_days'].create(line_rec)
        hr_payslip_brw.compute_sheet()
        for data in hr_payslip_brw.details_by_salary_rule_category:
            if data.code == "NET":
                gross_salary = data.total
        print"gross_salary-------",gross_salary
        if gross_salary:
            hr_employee_rec.write({'emp_wage_cal':gross_salary})
        hr_payslip_brw.unlink()


    @api.one
    def get_active_contract_data(self):
        """
        Functional fields to get the data from the currently active contract

        """
        today_date = datetime.today().date()
        hr_contract = self.env['hr.contract']
        # active_contract_brw = self.env['hr.contract'].search([('id','=',1)],limit=1)
        active_contract_brw = hr_contract.search([('employee_id','=',self.id),('date_start','<=',today_date),'|',('date_end','>=',today_date),('date_end','=',False)],limit=1)
        if active_contract_brw:
            self.contract_type = active_contract_brw.type_id.id
            self.contract_wage = active_contract_brw.wage
            self.contract_working_hours = active_contract_brw.working_hours
            self.contract_leaves = active_contract_brw.base_leaves
            # self.remuneration_incl_ag_costs = round(active_contract_brw.wage*1.25,2)
            self.remuneration_incl_ag_costs = round(self.emp_wage_cal*1.25,2)
            self.contract_notes = active_contract_brw.notes

            contract_trial_end_date_condition = False
            if not active_contract_brw.trial_date_end:
                contract_trial_end_date_condition = True
            if active_contract_brw.trial_date_end:
                trial_date_end = datetime.strptime(active_contract_brw.trial_date_end, DEFAULT_SERVER_DATE_FORMAT).date()
                if trial_date_end < datetime.today().date():
                    contract_trial_end_date_condition = True
            if contract_trial_end_date_condition:
                #search for the new contract
                new_contracts = hr_contract.search([('employee_id','=',self.id),('date_start','>',active_contract_brw.date_start)],order='date_start')
                for new_contract in new_contracts:
                    if new_contract.trial_date_end:
                        new_trial_date_end = datetime.strptime(new_contract.trial_date_end, DEFAULT_SERVER_DATE_FORMAT).date()
                        if new_trial_date_end >= datetime.today().date():
                            self.contract_trial_end_date = new_contract.trial_date_end
                            break
            else:
                self.contract_trial_end_date = active_contract_brw.trial_date_end

            if self.fte:
                # self.compensation_at_vz = round(active_contract_brw.wage/self.fte,2)
                self.compensation_at_vz = round(self.emp_wage_cal/self.fte,2)

            #Add a condition to search for the old contract and check for the change in the contract wage
            old_contracts = hr_contract.search([('employee_id','=',self.id),('date_start','<',active_contract_brw.date_start)],order='date_start desc')
            # print"old_contract-------",old_contracts,self.id
            middel_contracts =[]
            for old_contract in old_contracts:
                if old_contract.wage!= active_contract_brw.wage:
                    self.last_contract_changed_wage =old_contract.wage
                    # print"middel------",middel_contracts
                    if middel_contracts:
                        for middel_contract in middel_contracts:
                            if middel_contract.wage != old_contract.wage:
                                self.last_contract_changed_date = middel_contract.date_start
                                # break

                    else:
                        self.last_contract_changed_date = active_contract_brw.date_start
                        break
                else:
                    middel_contracts.append(old_contract)



    @api.one
    def _compute_overtime_count(self):
        """computed field, to calculate overtime from the new field"""
        emp_overtime_count = 0.0
        if self.employee_overtime_id:
            emp_overtime_count = self.employee_overtime_id.emp_overtime_count
        self.computed_overtime_count = emp_overtime_count

    @api.model
    def create(self,values):
        employee_overtime_count = self.env['employee.overtime.count']
        res = super(itis_hr_employee, self).create(values)
        for hr_employee in res:
            emp_count_rec = employee_overtime_count.create({'employee_id':hr_employee.id,'emp_overtime_count':0.0})
            hr_employee.write({'employee_overtime_id':emp_count_rec.id})
        return res


    @api.model
    def update_new_overtime_field(self):
        """ Scheduler, Use to update new overtime field. """
        employee_overtime_count = self.env['employee.overtime.count']
        hr_employee = self.env['hr.employee']
        emp_over_count_recs = employee_overtime_count.search([])
        if emp_over_count_recs:emp_over_count_recs.unlink()
        for employee_rec in hr_employee.search([('user_id','!=',False)]):
            emp_count_rec = employee_overtime_count.create({'employee_id':employee_rec.id,'emp_overtime_count':employee_rec.overtime_count})
            employee_rec.write({'employee_overtime_id':emp_count_rec.id})

    @api.one
    def _compute_contract_end_date(self):
        """this function is to calculate the end date of all the contract when there is end date and no gap in contracts"""
        contract_end_date = False
        limitation_reason = False
        if self:
            hr_contract_record = self.env['hr.contract'].search([('employee_id','=',self.id)],order='date_end')
            if hr_contract_record:
                if len(hr_contract_record) ==1:
                    if hr_contract_record[0].date_end:
                        contract_end_date = hr_contract_record[0].date_end
                else:
                    end_date=[]
                    for hr_contract_brw in hr_contract_record:
                        if hr_contract_brw.date_end:
                            # end_date.append(hr_contract_brw.date_end)  ###---new code

                            ###----old code commented
                            next_date_start = datetime.strptime(hr_contract_brw.date_end,DEFAULT_SERVER_DATE_FORMAT).date() + timedelta(days=1)
                            hr_contract_record_new = self.env['hr.contract'].search([('employee_id','=',self.id),('date_start','=',next_date_start)],limit=1)
                            if hr_contract_record_new:
                                if hr_contract_record_new.date_end:
                                    end_date.append(hr_contract_record_new.date_end)
                                else:
                                    end_date=[]
                            else:
                                end_date.append(hr_contract_brw.date_end)
                                break
                            ###---old code is commented END----##
                    if end_date:
                        end_date.sort(reverse=True)
                        if datetime.strptime(end_date[0],DEFAULT_SERVER_DATE_FORMAT).date() >= datetime.today().date():
                            contract_end_date = end_date[0]

        if contract_end_date:
            hr_contract_record_new = self.env['hr.contract'].search([('employee_id','=',self.id),('date_end','=',contract_end_date)],limit=1)
            if hr_contract_record_new:
                limitation_reason = hr_contract_record_new.limitation_reason
        # print"contract_end_date------",contract_end_date
        self.contract_limitation_reason = limitation_reason
        self.temp_contract_end_date = contract_end_date

    @api.onchange("initial_date")
    def onchange_initial_date(self):
        """use to calculate 5 year date for the anniversary when initial date is set"""

        five_year_date =False
        if self.initial_date:
            date_start = datetime.strptime(self.initial_date,DEFAULT_SERVER_DATE_FORMAT).date()
            five_year_date = date_start + relativedelta(years=+5)
        self.five_years = five_year_date

    @api.one
    def _compute_last_emp_meeting(self):
        """
        This computed function is use to find out the mosta recent employee meeting in the past base on the date
        :return:meeting id

        """
        employee_meeting_env ,employee_meeting_brw= self.env['employee.meeting'],False
        employee_meeting_brw = employee_meeting_env.search([('employee_id','=',self.id),('meeting_date', '<=', datetime.today().date())],order='meeting_date desc')
        if employee_meeting_brw:employee_meeting_brw=employee_meeting_brw[0]
        self.last_ma_conversation_date=employee_meeting_brw.meeting_date

    @api.one
    def _compute_next_emp_meeting(self):
        """
        This computed function is use to find out the next employee meeting base on the date
        :return:meeting id
        """

        employee_meeting_env ,employee_meeting_brw= self.env['employee.meeting'],False
        employee_meeting_brw = employee_meeting_env.search([('employee_id','=',self.id),('meeting_date', '>=', datetime.today().date())],order='meeting_date')
        if employee_meeting_brw:employee_meeting_brw=employee_meeting_brw[0]
        self.employee_meeting_id=employee_meeting_brw

    @api.one
    def _compute_next_emp_instruction_meeting(self):
        """
        This computed function is use to find out the next employee instruction meeting base on the date
        :return:instruction meeting id
        """
        employee_instruction_env ,employee_instruction_brw= self.env['employee.instruction'],False
        employee_instruction_brw = employee_instruction_env.search([('employee_id','=',self.id),('meeting_date', '>=', datetime.today().date())],order='meeting_date')
        if employee_instruction_brw:employee_instruction_brw=employee_instruction_brw[0]
        self.employee_instruction_id=employee_instruction_brw

    @api.multi
    def open_ld_change(self):
        return {
            'name': "Last Day Update",
            'res_model': 'ot.change',
            'type': 'ir.actions.act_window',
            'view_mode': 'form',
            'view_type': 'form',
            'target': 'new',
            'context': {'from_ld_change': True}
        }

    @api.multi
    def open_ot_change(self):
        return {
            'name': "Overtime Count Update",
            'res_model': 'ot.change',
            'type': 'ir.actions.act_window',
            'view_mode': 'form',
            'view_type': 'form',
            'target': 'new',
            'context': {'from_ot_change': True}
        }

    @api.multi
    def open_leaved_day_change(self):
        return {
            'name': "Leave Days Update",
            'res_model': 'ld.change',
            'type': 'ir.actions.act_window',
            'view_mode': 'form',
            'view_type': 'form',
            'target': 'new',
            'context': {'current_year':True}
        }

    #for SOW17
    @api.multi
    def open_nextyear_leaved_day_change(self):
        """Add a logic to give ability to change leave day for the next year.
            User can only change it after May month
        """
        if datetime.today().month <6:
            raise Warning(_("You can only change next year leave after May month"))
        return {
            'name': "Next Year Leave Days Update",
            'res_model': 'ld.change',
            'type': 'ir.actions.act_window',
            'view_mode': 'form',
            'view_type': 'form',
            'target': 'new',
            'context': {'next_year':True}
        }

    #for SOW17
    @api.multi
    def open_nextyear_add_day_change(self):
        """Add a logic to give ability to change additional leave day for the next year.
            User can only change it after May month
        """
        if datetime.today().month <6:
            raise Warning(_("You can only change additional leave days for next year after May month"))
        return {
            'name': "Last Day Update",
            'res_model': 'ot.change',
            'type': 'ir.actions.act_window',
            'view_mode': 'form',
            'view_type': 'form',
            'target': 'new',
            'context': {'from_ld_change': True,'next_year':True}
        }

    @api.multi
    def update_overtime_count(self, ot_time, reason):

        # old_ot = self.overtime_count
        # self.write({'overtime_count': ot_time})
        old_ot = self.employee_overtime_id.emp_overtime_count
        self.employee_overtime_id.write({'emp_overtime_count': ot_time})
        leave_journal_obj = self.env['hr.leave.journal']
        # ot_change = ot_time - self.overtime_count
        ot_change = ot_time - self.employee_overtime_id.emp_overtime_count
        values = {
            'employee_id':self.id,
            'year': datetime.today().year,
            'year_type': 'actual',
            'type': 'manual',
            'leave_type':'hours',
            'leave_days': ot_change,
            'name': reason + ' ' + self.name + ' ' + datetime.now().strftime('%d%m%Y %H:%M:%S'),
        }
        leave_journal_obj.create(values)
        msg = _("Overtime has been chagned from <b>%s</b> to <b>%s</b>.<br/>Reason : %s") % \
                    (str(old_ot), str(ot_time), reason)
        self.message_post(body=msg)
        return True

    @api.multi
    def update_leave_day(self, leave_day, reason):
        """Use to update additional leaves"""
        leave_journal_obj = self.env['hr.leave.journal']
        old_additional_day = self.additional_leave_days
        # Added for SOW17
        if self.env.context.get("next_year", False):
            year_type = 'next'
            year = datetime.today().year+1
            old_additional_day = self.additional_leave_days_ny
            leave_days = leave_day - self.additional_leave_days_ny
        else:
            year_type = 'actual'
            year = datetime.today().year
            self.write({'additional_leave_days': leave_day})
            leave_days = leave_day - self.additional_leave_days
        values = {
            'employee_id':self.id,
            'year': year,
            'year_type': year_type,
            'type': 'additional',
            'leave_type':'days',
            'leave_days': leave_days,
            'name': reason + ' ' + self.name + ' ' + datetime.now().strftime('%d%m%Y %H:%M:%S'),
        }
        leave_journal_obj.create(values)

        msg = _("Additional leave has been changed from <b>%s</b> to <b>%s</b>.<br/>Reason : %s") % \
                    (str(old_additional_day), str(leave_day), reason)
        self.message_post(body=msg)
        return True

    def onchange_department_id(self, cr, uid, ids, department_id, context=None):
        value = super(itis_hr_employee,self).onchange_department_id(cr, uid, ids, department_id, context=context)
        value['value']['bereich'] = False
        if department_id:
            department = self.pool.get('hr.department').browse(cr, uid, department_id)
            value['value']['bereich'] = department.parent_id.id
        return value

    @api.one
    def _compute_fte(self):
        contract_obj = self.pool.get('hr.contract')
        contract_ids = contract_obj.search(self._cr, self._uid, [('employee_id', '=', self.id), ('date_start', '<=', datetime.today().date()), '|', ('date_end', '>=', datetime.today().date()),('date_end','=',False)])
        if len(contract_ids) < 1:
            self.fte = 0
        elif len(contract_ids) > 1:
            self.fte = 0
            raise Warning(_("There are 2 contracts assigned to this employee."))
        else:
            work_plan = contract_obj.browse(self._cr, self._uid, contract_ids[0]).working_hours
            weekly_hours = 0.0
            if not work_plan:
                self.fte = 0
            for attendance_id in work_plan.attendance_ids:
                weekly_hours += attendance_id.hour_to - attendance_id.hour_from
            icp_obj = self.env['ir.config_parameter'].sudo()
            fte_base = icp_obj.get_param("fte.base")
            self.fte = float_round(weekly_hours / float(fte_base), precision_digits = 4)

    #add a logic for the 1stjune scheduler for leave calculation request on SOW17
    @api.model
    def june_year_change_calc_days(self):
        """Use for calculation of the leave day for the next year base on the valid contract"""

        leave_journal_obj = self.env['hr.leave.journal']
        contract_obj = self.env['hr.contract']
        error_obj = self.env['itis.leave.days.calc.error']
        logger.info("---------In the Jun calculation vacation cron--------")
        year = datetime.today().year #current year #2018
        next_year = int(year) + 1 #next year #2019

        for employee in self.search([('active','=',True)]):
            # print('employee--name----',employee.name)
            contract_ids_unlimited = contract_obj.search([('employee_id','=',employee.id),('date_start','<=',datetime.strptime('01-01-'+str(next_year),'%d-%m-%Y')), ('date_end','=',False)])
            contract_ids_limited = contract_obj.search([('employee_id','=',employee.id),('date_start','<=',datetime.strptime('01-01-'+str(next_year),'%d-%m-%Y')), ('date_end', '>=', datetime.strptime('01-01-'+str(next_year),'%d-%m-%Y'))])
            contract_ids_future = contract_obj.search([('employee_id','=',employee.id),('date_start','>',datetime.strptime('01-01-'+str(next_year),'%d-%m-%Y')), '|', ('date_end', '>=', datetime.strptime('01-01-'+str(next_year),'%d-%m-%Y')),('date_end','=',False)])
            error = False
            #contract_used = False
            #contract_id_used = False
            if len(contract_ids_limited) > 1 or len(contract_ids_unlimited) > 1:
                error = _('Mehr als ein Vertrag zum 01.Januar')
            elif not contract_ids_future:
                if not contract_ids_unlimited and len(contract_ids_limited)==1:
                    leave_days_next_year = contract_ids_limited[0].calculate_leave_days(None,next_year)[0]
                    #contract_used = contract_ids_limited[0]
                elif len(contract_ids_unlimited)==1 and not contract_ids_limited:
                    leave_days_next_year = contract_ids_unlimited[0].calculate_leave_days(None,next_year)[0]
                    #contract_used = contract_ids_unlimited[0]
                elif len(contract_ids_unlimited) > 0 and len(contract_ids_limited) > 0:
                    error = _('Mehr als ein Vertrag zum 01.Januar')
                else:
                    error = _('Kein Vertrag am 01.Januar vorhanden')
            else:
                if len(contract_ids_unlimited) > 0:
                    error = _('Überschneidende Verträge')
                elif not contract_ids_limited and len(contract_ids_future) == 1:
                    leave_days_next_year = contract_ids_future[0].calculate_leave_days(None,next_year)[0]
                    #contract_used = contract_ids_future[0]
                else:
                    answer = self.get_leave_days_from_multiple_contracts(contract_ids_limited.ids or [],contract_ids_future.ids or [],next_year)
                    # print('answer-------',answer)
                    if 'leave_days' in answer:
                        leave_days_next_year = answer['leave_days']
                    elif 'error' in answer:
                        error = answer['error']
                    else:
                        error = _('Fehler in Berechnung')
            #if contract_used:
            #    contract_id_used = contract_used.id
            if not error:
                values_next_year_actual = {
                    'employee_id': employee.id,
                    'year': next_year,
                    'year_type': 'next',
                    'type': 'calculate',
                    'leave_type':'days',
                    'leave_days': leave_days_next_year,
                    'name': _('Berechnung Urlaub zu Jahresbeginn') + str(datetime.today().date()),
                    #'contract_id': contract_id_used,
                }
                leave_journal_obj.create(values_next_year_actual)
            else:
                values_error = {
                    'name': employee.id,
                    'year': next_year,
                    'error': error,
                }
                error_obj.create(values_error)
        pass

    @api.model
    # @api.multi
    def year_change_calc_days(self):
        """
        Imp Note :: This scheduler should run in Dec month.Else remaining leave will have 0 value in it.
        """
        leave_journal_obj = self.env['hr.leave.journal']
        contract_obj = self.env['hr.contract']
        error_obj = self.env['itis.leave.days.calc.error']
        logger.info("---------In the year_change_calc_days cron--------")

        if datetime.today().month == 12 or datetime.today().month == 11:
            year = datetime.today().year
        else:
            year = int(datetime.today().year)-1 #2018
        # year = datetime.today().year
        next_year = int(year) + 1 #2019

        for employee in self.search([('active','=',True)]):
            # print('Employee Name-------',employee.name)
            remaining_leaves = employee.sum_leaves
            addtional_leave = employee.additional_leave_days_ny
            contract_leave = employee.leave_days_ny

            remaining_part_leave = 0.0
            # remaining_part_leave2 = 0.0

            #calculation for the last year leave and total vacation
            if employee.approved_leaves_ny >0.0: #check for the approved leave is there or not.

                #check there is approve leave till march, if it is there reduce it from remaining leave
                if employee.approved_leaves_till_march_ny >0.0:

                    if remaining_leaves > employee.approved_leaves_till_march_ny:
                        remaining_leaves -=employee.approved_leaves_till_march_ny
                    else: #else get a part of it
                        remaining_part_leave = employee.approved_leaves_till_march_ny-remaining_leaves
                        remaining_leaves = 0.0
                    #
                    # if employee.additional_leave_days_ny >0.0: #check for the additional leave
                    #     if remaining_part_leave <=employee.additional_leave_days_ny:
                    #         addtional_leave -=remaining_part_leave
                    #         remaining_part_leave =0.0
                    #     else:
                    #         remaining_part_leave = remaining_part_leave - employee.additional_leave_days_ny
                    #         addtional_leave =0.0
                    #
                    # contract_leave = employee.leave_days_ny - remaining_part_leave

                #check there is approve leave after march, if it is there add it in the remaining_part_leave
                if employee.approved_leaves_after_march_ny >0.0:
                    remaining_part_leave += employee.approved_leaves_after_march_ny
                    # if employee.approved_leaves_after_march_ny <=addtional_leave:
                    #     addtional_leave -=employee.approved_leaves_after_march_ny
                    #     remaining_part_leave2 =0.0
                    # else:
                    #     remaining_part_leave2 = employee.approved_leaves_after_march_ny - addtional_leave
                    #     addtional_leave =0.0
                    #
                    # contract_leave = contract_leave - remaining_part_leave2

            # print"Additional leave-------",addtional_leave
            # print"remaining_leaves-------",remaining_leaves
            # print"contract_leave-------",contract_leave
            # print"Approve leave-------",remaining_part_leave
            # print"sum leave----",contract_leave+remaining_leaves+addtional_leave-remaining_part_leave

            #for leave that is remaining in last year carry forward to next year
            #maintain for current year for info purpose
            #differentiate by last_year_carry_fwd
            values = {
                'employee_id': employee.id,
                'year': year,
                'year_type': 'actual',
                'type': 'leave',
                'leave_type':'days',
                'leave_days': employee.sum_leaves,
                'last_year_carry_fwd':True,
                'name': _('Resturlaub zum Jahreswechsel') + str(datetime.today().date()),
            }
            leave_journal_obj.create(values)

            #for leave that is remaining in last year carry forward to next year
            values_next_year_last = {
                'employee_id': employee.id,
                'year': next_year,
                'year_type': 'last',
                'type': 'calculate',
                'leave_type':'days',
                'leave_days': remaining_leaves,
                'name': _('Umwandlung Resturlaub') + str(datetime.today().date()),
            }
            leave_journal_obj.create(values_next_year_last)

            #for leave base on contract calculated base on june scheduler values
            values_next_year_actual = {
                'employee_id': employee.id,
                'year': next_year,
                'year_type': 'actual',
                'type': 'calculate',
                'leave_type':'days',
                'leave_days': contract_leave,
                'name': _('Berechnung Urlaub zu Jahresbeginn') + str(datetime.today().date()),
                }
            leave_journal_obj.create(values_next_year_actual)

            #to add following year additional leave to current year SOW17
            if addtional_leave > 0.0:
                values_next_year_additional = {
                'employee_id': employee.id,
                'year': next_year,
                'year_type': 'actual',
                'type': 'additional',
                'leave_type':'days',
                'leave_days': addtional_leave,
                'name': _('Berechnung Urlaub zu Jahresbeginn') + str(datetime.today().date()),
                }
                leave_journal_obj.create(values_next_year_additional)

            #for leave approve leave in following year which approve in preceding year carry forward
            values_next_year_last = {
                'employee_id': employee.id,
                'year': next_year,
                'year_type': 'actual',
                'type': 'leave',
                'leave_type':'days',
                'leave_days': remaining_part_leave,
                'name': _('Abgegoltene Urlaubstage') + str(datetime.today().date()),
            }
            leave_journal_obj.create(values_next_year_last)

            #To send an email to employee for the remaining leave
            if remaining_leaves>0.0:
                template = self.env.ref('itis_hr_extend.email_template_remaining_leave_notification', False)
                if template:
                    email_cc_list  = self.get_cc_emails(employee) #to get a cc email address from hr manager,
                    template.with_context(remaining_leaves=remaining_leaves,email_cc = email_cc_list).send_mail(employee.id)

            # Commented as requested on SOW17
            # values_next_year_additional = {
            #     'employee_id': employee.id,
            #     'year': next_year,
            #     'year_type': 'actual',
            #     'type': 'additional',
            #     'leave_type':'days',
            #     'leave_days': employee.additional_leave_days,
            #     'name': _('Berechnung Urlaub zu Jahresbeginn') + str(datetime.today().date()),
            # }
            # leave_journal_obj.create(values_next_year_additional)

            #Below logic is commented as it is transfer to the 1st june scheduler SOW17
            # leave_days_next_year = 0
            # contract_ids_unlimited = contract_obj.search([('employee_id','=',employee.id),('date_start','<=',datetime.strptime('01-01-'+str(next_year),'%d-%m-%Y')), ('date_end','=',False)])
            # contract_ids_limited = contract_obj.search([('employee_id','=',employee.id),('date_start','<=',datetime.strptime('01-01-'+str(next_year),'%d-%m-%Y')), ('date_end', '>=', datetime.strptime('01-01-'+str(next_year),'%d-%m-%Y'))])
            # contract_ids_future = contract_obj.search([('employee_id','=',employee.id),('date_start','>',datetime.strptime('01-01-'+str(next_year),'%d-%m-%Y')), '|', ('date_end', '>=', datetime.strptime('01-01-'+str(next_year),'%d-%m-%Y')),('date_end','=',False)])
            # error = False
            # if len(contract_ids_limited) > 1 or len(contract_ids_unlimited) > 1:
            #     error = _('Mehr als ein Vertrag zum 01.Januar')
            # elif not contract_ids_future:
            #     if not contract_ids_unlimited and len(contract_ids_limited)==1:
            #         leave_days_next_year = contract_ids_limited[0].calculate_leave_days(None,next_year)[0]
            #     elif len(contract_ids_unlimited)==1 and not contract_ids_limited:
            #         leave_days_next_year = contract_ids_unlimited[0].calculate_leave_days(None,next_year)[0]
            #     elif len(contract_ids_unlimited) > 0 and len(contract_ids_limited) > 0:
            #         error = _('Mehr als ein Vertrag zum 01.Januar')
            #     else:
            #         error = _('Kein Vertrag am 01.Januar vorhanden')
            # else:
            #     if len(contract_ids_unlimited) > 0:
            #         error = _('Überschneidende Verträge')
            #     elif not contract_ids_limited and len(contract_ids_future) == 1:
            #         leave_days_next_year = contract_ids_future[0].calculate_leave_days(None,next_year)[0]
            #     else:
            #         answer = self.get_leave_days_from_multiple_contracts(contract_ids_limited.ids or [],contract_ids_future.ids or [],next_year)
            #         if 'leave_days' in answer:
            #             leave_days_next_year = answer['leave_days']
            #         elif 'error' in answer:
            #             error = answer['error']
            #         else:
            #             error = _('Fehler in Berechnung')
            # if not error:
            #     values_next_year_actual = {
            #         'employee_id': employee.id,
            #         'year': next_year,
            #         'year_type': 'actual',
            #         'type': 'calculate',
            #         'leave_type':'days',
            #         'leave_days': leave_days_next_year,
            #         'name': _('Berechnung Urlaub zu Jahresbeginn') + str(datetime.today().date()),
            #     }
            #     leave_journal_obj.create(values_next_year_actual)
            # else:
            #     values_error = {
            #         'name': employee.id,
            #         'year': next_year,
            #         'error': error,
            #     }
            #     error_obj.create(values_error)
        return

    @api.model
    def get_leave_days_from_multiple_contracts(self,contracts1,contracts2,year):
        contract_obj = self.env['hr.contract']
        values = {}
        error = False
        contracts1.extend(contracts2)
        contracts = contract_obj.browse(contracts1)
        if len(contracts) == 1:
            values['start_date'] = contracts[0].start_date
            values['end_date'] = contracts[0].start_date
            leave_days = contracts[0].calculate_leave_days(values,year)[0]
        elif len(contracts) > 1:
            contractvalues = {}
            for contract in contracts:
                workplan_days = 0
                weekdays = {}
                for attendance in contract.working_hours.attendance_ids:
                    if attendance.dayofweek not in weekdays:
                        weekdays[attendance.dayofweek] = True
                workplan_days = len(weekdays)
                contractvalues[contract] = {
                    'date_start' : contract.date_start,
                    'date_end': contract.date_end,
                    'workplan_days': workplan_days,
                    'base_leaves': contract.base_leaves
                }
            contractvalues_sorted = sorted(contractvalues.items(), key=lambda x: x[1]['date_start'])
            date_start = False
            date_end = False
            workplan_days = False
            base_leaves = False
            for contract in contractvalues_sorted:
                if not workplan_days:
                    workplan_days = contract[1]['workplan_days']
                if not base_leaves:
                    base_leaves = contract[1]['base_leaves']
                if not date_start:
                    date_start = contract[1]['date_start']
                if not date_end:
                    date_end = contract[1]['date_end']
                else:
                    if workplan_days == contract[1]['workplan_days']:
                        if base_leaves == contract[1]['base_leaves']:
                            if (datetime.strptime(contract[1]['date_start'], DEFAULT_SERVER_DATE_FORMAT)-datetime.strptime(date_end, DEFAULT_SERVER_DATE_FORMAT)).days ==1:
                                date_end = contract[1]['date_end']
                            else:
                                error = _('Fehler automatische Kalkulation durch keine durchgängigen Arbeitsverträge')
                                break
                        else:
                            error = _('Fehler automatische Kalkulation durch Änderung Urlaubsanspruch')
                            break
                    else:
                        error = _('Fehler automatische Kalkulation durch Änderung Wochenarbeitstage')
                        break
            if not error:
                values = {
                    'date_start':date_start,
                }
                leave_days = contract[0].calculate_leave_days(values,year)[0]
        if error:
            return{'error':error}
        else:
            return {'leave_days':leave_days}

    @api.model
    def leave_request_state_change(self,employee):
        year = datetime.today().year
        leave_to_date = datetime.strptime('31-12-'+str(year),'%d-%m-%Y').date()
        leave_from_date = datetime.strptime('01-01-'+str(year),'%d-%m-%Y').date()
        leaves_ids =self.env['hr.holidays'].search([('employee_id','=',employee.id),('state','in',['draft','confirm'])]).ids
        logger.info("-Employee --------" +str(employee.id))
        # print'employee----',employee.name
        # print'leaves_ids----',leaves_ids
        for leave_id in leaves_ids:
            leave = self.env['hr.holidays'].browse(leave_id)
            from_dt = datetime.strptime(leave.date_from, DEFAULT_SERVER_DATETIME_FORMAT).date()
            to_dt = datetime.strptime(leave.date_to, DEFAULT_SERVER_DATETIME_FORMAT).date()
            if leave_to_date >= to_dt and leave_from_date <= from_dt:

                if leave.state=='draft':
                    logger.info("-draft------" +str(leave.id))
                    self._cr.execute("update hr_holidays set state = 'cancel' where id = %s",(leave.id,))
                    template = self.env.ref('itis_hr_extend.email_template_draft_leave_cancel', False)
                    if template:
                        email_cc_list  = self.get_cc_emails(employee) #to get a cc email address from hr manager,
                        template.with_context(date_from=from_dt,date_to =to_dt,email_cc = email_cc_list).send_mail(leave.id)

                if leave.state =='confirm':
                    logger.info("-confirm------" +str(leave.id))
                    try:
                        if leave.employee_id.parent_id:
                            if leave.employee_id.parent_id.user_id:
                                leave.sudo(user=leave.employee_id.parent_id.user_id.id).holidays_validate()
                        else:
                            leave.holidays_validate()
                    except:
                        pass
                    if leave.state =='validate':
                        template = self.env.ref('itis_hr_extend.email_template_toapprove_leave_approve', False)
                        if template:
                            email_cc_list  = self.get_cc_emails(employee) #to get a cc email address from hr manager,
                            template.with_context(date_from=from_dt,date_to =to_dt,email_cc = email_cc_list).send_mail(leave.id)

    @api.model
    def get_cc_emails(self,employee):
        groups = [self.env.ref('base.group_hr_manager').id]
        cc_list = []
        groups_env = self.env['res.groups']
        cc_emails=''
        for group in groups_env.browse(groups):
            for user in group.users:
                if user.login and user.email and re.match('[^@]+@[^@]+\.[^@]+', user.login):

                    if employee and employee.user_id.id != user.id:
                        cc_list.append(user)

        if employee.parent_id and employee.parent_id.user_id and employee.parent_id.user_id.email:
            if employee.parent_id.user_id not in cc_list:
                cc_list.append(employee.parent_id.user_id)
        # print"CC list--------",cc_list
        for i in cc_list:
            cc_emails += i.email+','
        # print('cc_emails-----',cc_emails)
        return cc_emails

    @api.model
    def delete_last_year_leave_days(self):
        """This scheduler is of no use. Not sure why it is added.
        I have added a logic for the make draft leave of this year to cancel and to approve leave with approve.
        Imp Note :: This scheduler should run in Dec month.
        """
        leave_journal_obj = self.env['hr.leave.journal']
        contract_obj = self.env['hr.contract']
        logger.info("---------In the delete last year leave cron--------")
        for employee in self.search([]):
            if not employee.active:
                continue
            to_delete_days = employee.leave_days_last_year - employee.approved_leaves
            if to_delete_days > 0:
                to_delete_days * -1
                values = {
                    'employee_id': employee.id,
                    'year': datetime.today().year,
                    'year_type': 'actual',
                    'type': 'calculate',
                    'leave_type':'days',
                    'leave_days': to_delete_days,
                    'name': _('Verfall Resturlaub') + str(datetime.today().date()),
                }
                leave_journal_obj.create(values)

            #function use to make draft leave of last year rejected and to approve with approve state
            self.leave_request_state_change(employee)

        return


class itis_hr_contract(models.Model):

    _inherit = 'hr.contract'

    itis_contract_type = fields.Many2one('itis.contract.type', string="Art")
    limitation_reason = fields.Many2one('itis_limitation_reason', string="Befristungsgrund")
    base_leaves = fields.Float(string="Urlaubsanspruch", default="20")

class itis_hr_department(models.Model):

    _inherit = 'hr.department'

    planned_fte = fields.Float('Planned FTE')
    account_id = fields.Many2one('account.analytic.account',string="Analytic Account")

    def name_get(self, cr, uid, ids, context=None):
        if context is None:
            context = {}
        if not ids:
            return []
        reads = self.read(cr, uid, ids, ['name','parent_id'], context=context)
        res = []
        for record in reads:
            name = record['name']
            # if record['parent_id']:
            #     name = record['parent_id'][1]+' / '+name
            res.append((record['id'], name))
        return res


class itis_leave_days_calc_error(models.Model):
    _name = 'itis.leave.days.calc.error'

    name = fields.Many2one('hr.employee', string='Mitarbeiter')
    year = fields.Integer(string='Jahr')
    error = fields.Char(string='Fehlermeldung')

class MyFilter(parent_controller.DataSet):

    @http.route(['/web/dataset/call_kw', '/web/dataset/call_kw/<path:path>'], type='json', auth="user")
    def call_kw(self, model, method, args, kwargs, path=None):
        return_value = self._call_kw(model, method, args, kwargs)
        if model == "hr.employee":
            cr, uid, context = request.cr, request.uid, request.context
            if isinstance(return_value,list):
                for data in return_value:
                    if isinstance(data,dict):
                        if data.get("message_ids",False):
                            res_users_obj = request.registry["res.users"]
                            ir_model_obj = request.registry["ir.model.data"]
                            res_user_data = res_users_obj.browse(cr,uid,[uid],context)
                            xml_list = []
                            group_ids = []
                            for group in res_user_data.groups_id:
                                group_ids.append(group.id)
                            model_ids = ir_model_obj.search(cr,uid,[['model','=','res.groups'],['res_id','in',group_ids]],0,False,False,context)
                            model_data = ir_model_obj.browse(cr,uid,model_ids,context)
                            for value in model_data:
                                xml_list.append(value.name)
                            if "group_hr_manager" in xml_list or "group_hr_payroll_manager" in xml_list or "group_hr_user" in xml_list or uid == 1:
                                continue
                            else:
                                data["message_ids"] = []

        return return_value