# -*- coding: utf-8 -*
import ast
import datetime
import json
import re
import uuid
import logging
import base64
import subprocess
import tempfile
import easywebdav
import os
import os.path


from odoo import api, fields, models, _
from odoo import tools
from . import dss_settings
from odoo.exceptions import ValidationError
from datetime import date
from datetime import datetime
from dateutil.relativedelta import relativedelta
from pyffmpeg import FFmpeg
from tuya_iot import TuyaOpenAPI, TUYA_LOGGER
from tuya_connector import TuyaOpenAPI, TUYA_LOGGER
import sys

TUYA_LOGGER.setLevel(logging.DEBUG)
_logger = logging.getLogger(__name__)

class dsscontracts(models.Model):

    @api.model
    def _get_default_project(self):
        _logger.debug("Ermittelte Id aus Context :  %s" % (self.env.context.get('active_id')))
        ds =  self.env['dss.projects'].search([('id','=',self.env.context.get('active_id'))],limit=1)
        return ds

    def _default_work_state(self):
        ds=self.env['dss.workstate'].search([('statusname','=','Neu')],limit=1).id
        _logger.debug(ds)
        return ds

    def _default_work_state_color(self):
        ds=self.env['dss.workstate'].search([('statusname','=','Neu')],limit=1).color
        _logger.info(ds)
        return ds

    def _default_todo_state(self):
        ds=self.env['dss.todostate'].search([('statusnr','=','0')],limit=1).id
        if not ds : ds = 1
        _logger.debug(ds)
        #        ds =
        return ds

    def _default_get_ads_last_ad(self):
        _logger.info('finding Standard ad '+self.id)
        ds = self.env['dss.ads'].search([('contract','=',self.id),('ad_is_lastpos','=',True)],limit=1)
        if not ds:
            ds = self.env['dss.ads'].search([('contract','=',self.id)],limit=1)
        return ds

    _name = "dss.contracts"
    _description = "DigitalSignage Vertraege"
    _rec_name = "contract_auto_name"
    _inherit = ['mail.thread','mail.activity.mixin','dss.triggermodel']
    uuid = fields.Char(default=lambda self: self._default_uuid(), required=True, readonly=True, copy=False, string='UUID')
    cruuid = fields.Char(related='uuid')
    contract_id = fields.Char("Kundennummer",store=True,tracking=True)
    contract_name = fields.Char('Kurzbezeichnung', required=True,tracking=True)
    contract_state = fields.Many2one('dss.contractstate',group_expand='_read_group_stage_ids',tracking=True)
    contract_state_color = fields.Char(related='contract_state.color',store=True)
    contract_state_order = fields.Integer(related='contract_state.order',store=True)
    contract_auto_id = fields.Char("Kundennummer",tracking=True,help="Wird berechnet aus Projektnummer + Kunden ID")
    contract_auto_name = fields.Char('Vertragskennug',tracking=True,help="Wird berechnet aus Kundennummer + Vertragskennung")

    contract_payment_done = fields.Boolean('Zahlungeingang erfolgt',tracking=True)
    contract_payment_done_date = fields.Date('Zahlungeingang Datum',tracking=True)

    contract_receipt_done_multi = fields.Boolean('Mehrere Rechnungen nötig ?', tracking=True)
    contract_receipt_done = fields.Boolean('Rechnungstellung erfolgt',tracking=True)
    contract_receipt_number = fields.Char("Rechnungsnummer",tracking=True)
    contract_receipt_done_date = fields.Date('Rechnungsdatum',tracking=True)
    contract_receipt_done_until_date = fields.Date('Zahlungsziel', tracking=True)

    remark = fields.Html('Bemerkung',tracking=True)

    contract_writer = fields.Many2one('res.partner', tracking=True)
    vertragssumme = fields.Float('Vertragssumme :', tracking=True)
    provisionstyp = fields.Many2one('dss.provisionstypen', tracking=True)
    provisionsteilcalc  = fields.Float('Berechnete Provision :',computed='_compute_prov')
    provisions = fields.Many2many('dss.provision',tracking=True)
    provisionspayedpercent  = fields.Float('Ausgezahlte Provision % :',computed='_compute_provisionspayedpercent')
    grafiker = fields.Many2one('res.partner', placeholder="wenn vom Projekt abweichend", domain="['&',('dssinternpartner','=',True),('dssinternpartner_grafik','=',True)]", tracking=True, string="abw. Grafiker",help="Grafiker nur wenn abweichend vom Projektgrafiker")

    contract_remark = fields.Html('Vertragshinweise',tracking=True)

    project = fields.Many2one('dss.projects' , string='Project', store=True,tracking=True)
    project_id = fields.Integer(related='project.projectid', string='Project ID')
    projectIid = fields.Integer('Project IID',tracking=True)
    project_ad_structure = fields.Many2one(related='project.grundsystem_default_adstructure', string='Aufbau')
    project_grundsystem_typ = fields.Char(related='project.grundsystem_typ', tracking=True)
    project_grafiker = fields.Many2one(related="project.project_grafiker",tracking=True)

    client = fields.Many2one('res.partner',string="Kunde (wenn angelegt)",domain="['&',('dsspartner','=',True),('dsspartner_werbung','=',True)]",tracking=True,help="Nur zu Benutzen wenn Kunden als Kontakt angelegt wurde")
    client_id = fields.Char(string="KundenID (2Stellen)",help="Nur der 2 stellige letzte Teil der Kundennummer",tracking=True)
    client_uuid = fields.Char(related="client.dss_uuid")
    contact_street = fields.Char(related="client.street")
    contact_street2 = fields.Char(related="client.street2")
    contact_zip = fields.Char(related="client.zip")
    contact_city = fields.Char(related="client.city")
    contact_state_id = fields.Many2one(related="client.state_id")
    contact_country_id = fields.Many2one(related="client.country_id")
    contact_telefon = fields.Char(related="client.phone")
    contact_mobil = fields.Char(related="client.mobile")
    contact_email = fields.Char(related="client.email")
    contact_web = fields.Char(related="client.website")
    contact_company_name = fields.Char(related="client.name")
    contact_name  = fields.Char(related="client.company_name")
    contact_dsspartner_vorname = fields.Char(related="client.dsspartner_name")
    contact_dsspartner_name = fields.Char(related="client.dsspartner_vorname")

    parent_id = fields.Many2one('dss.contracts', string='Parent Task', index=True,tracking=True)

    client_short_company = fields.Char('Firmenname Kunde',tracking=True)
    client_short_vorname = fields.Char('Vorname Kunde',tracking=True)
    client_short_name = fields.Char('Name Kunde',tracking=True)
    client_short_strasse = fields.Char('Strasse Kunde',tracking=True)
    client_short_plz = fields.Char('PLZ Kunde',tracking=True)
    client_short_ort = fields.Char('Ort Kunde',tracking=True)
    client_short_land = fields.Many2one('res.country','Land Kunde',tracking=True)
    client_short_email = fields.Char('Email Kunde',tracking=True)
    client_short_telefon = fields.Char('Telefon Kunde',tracking=True)
    client_short_mobil = fields.Char('Mobilfunk Kunde',tracking=True)
    client_short_website = fields.Char('Webseite Kunde',tracking=True)

    client_other_projects = fields.Many2many('dss.projects',string='Weitere Projekte',tracking=True)

    werbe_feld_selected = fields.Many2many('dss.advertisefields',string='Werbefelder',tracking=True)
    shortwerbe_feld_selected = fields.Char(related='werbe_feld_selected.feldname',string='Werbefelder',tracking=True)
    cutshortwerbe_feld_selected = fields.Char(string='gekürzte Felder',compute='_compute_cutshort')

    #    need_media = fields.Many2many('dss.mediarelations','mediarelations_contract_rel','contract_id','mediarelations_id',string='benötigte Medien')
    last_media = fields.Many2many('dss.mediarelations',string='Medien',domain="[('isreference','=',False)]")
    #    last_media = fields.Many2many('dss.mediarelations','mediarelations_ad_relations','contract_id','mediarelations_id',string='Medien')
    need_media = fields.Many2many('dss.mediarelations','contract',string='Medien',domain="[('isreference','=',True)]")
    #    need_media_computed = fields.One2many('dss.mediarelations','field',compute='_get_media_list')
    #    need_media_computed = fields.One2many('dss.mediarelations','uuid',domain="[('field','in',werbe_feld_selected)]")

    main_runtime = fields.Integer('Gesamtlaufzeit',tracking=True)
    split_runtime_count = fields.Integer('Laufzeit Teilungen',tracking=True)
    split_runtime_time = fields.Integer('Laufzeit Sekunden',tracking=True)

    contract_date = fields.Date('Vertragsdatum',tracking=True)
    start_date = fields.Date('Start/Auslief.datum',tracking=True)
    contract_cancel_mon = fields.Integer('Kündigungsfrist Monaten',tracking=True)
    contract_cancel_date = fields.Date('Kündigungsfrist Errechnet', tracking=True)
    contract_auto_extend = fields.Boolean('autom. V.Verlängerung',tracking=True)
    contract_auto_extend_time = fields.Char('Verl. Monate',tracking=True)

    runtimesystem = fields.Selection([('M','Monatslaufzeit'),('T','Tagelaufzeit'), ('E','Eventlaufzeit'), ('S','Sonderlaufzeit')],tracking=True)
    runtime_m = fields.Integer('Laufzeit',tracking=True)
    runtime_bonus_m = fields.Integer('zusätzl. Laufzeit',tracking=True)
    runtime_t = fields.Integer('Laufzeit',tracking=True)
    runtime_bonus_t = fields.Integer('zusätzl. Laufzeit',tracking=True)
    runtime_events = fields.Many2many('dss.eventdays',tracking=True)
    runtime_bonus_e = fields.Integer('zusätzl. Events',tracking=True)
    runtime_divers = fields.Char('Laufzeit',tracking=True)
    runtime_finish = fields.Date('LaufzeitEnde',tracking=True)
    runtime_calendar_event = fields.Integer('Kalendereintrag ID',tracking=True)

    paymentsystems = fields.Many2one('dss.paysystems',string='Abrechnungsart',tracking=True)
    paymentinterval = fields.Many2one('dss.payintervals',string='Abrechnungsinterval',tracking=True)
    intern_info_payment_off = fields.Boolean('Keine Zahl-Benachrichtigungen',tracking=True)

    base_ad = fields.Many2one('dss.ads',tracking=True)
    ads = fields.One2many('dss.ads','contract',tracking=True)
    ads_last_ad = fields.Many2one('dss.ads', help="letzte Werbekampagne",computed='_default_get_ads_last_ad',store=True)
    ads_last_state = fields.Many2one(related='ads_last_ad.ad_state', string="Zuständigkeit letzt Kamp",help="Zuständigkeit/Status des letzten Werbekampagnen Eintrags",store=True,readonly=False,group_expand='_expand_ads_last_state')
    ads_last_state_color =  fields.Char(related='ads_last_ad.ad_state_color')
    ads_last_state_text =  fields.Char(related='ads_last_ad.ad_state_text',store=True,readonly=False)
    ads_last_work_state = fields.Many2one(related='ads_last_ad.work_state', string="Arbeitschritt letzt Kamp",help="Arbeitsstatus des letzten Werbekampagnen Eintrags",store=True,readonly=False,group_expand='_expand_ads_last_work_state')
    ads_last_work_state_color =  fields.Char(related='ads_last_ad.work_state_color')
    ads_last_work_state_text =  fields.Char(related='ads_last_ad.work_state_text',store=True,readonly=False)
    ads_last_work_state_info = fields.Char(related='ads_last_ad.work_state_info',store=True,readonly=False)
    ads_last_todo_state = fields.Many2one(related='ads_last_ad.todo_state',string="Aufgabe letzt Kamp", help="Aufgabenstatus des letzten Werbekampagnen Eintrags",store=True,readonly=False,group_expand='_expand_ads_last_todo_state')
    ads_last_todo_state_until = fields.Date(related='ads_last_ad.todo_state_until')
    ads_last_todo_state_color =  fields.Char(related='ads_last_ad.todo_state_color')
    ads_last_todo_state_text =  fields.Char(related='ads_last_ad.todo_state_text',store=True,readonly=False)

    vnnox_zugang_erstellt = fields.Boolean('Vnnox Zugang ?',tracking=True)
    vnnox_zugang_username = fields.Char('Vnnox Username',tracking=True)
    vnnox_zugang_password = fields.Char('Vnnox Passwort',tracking=True)
    vnnox_zugang_gesendet = fields.Boolean('Vnnox Zugang gesendet?',tracking=True)

    xibo_zugang_erstellt = fields.Boolean('Xibo Zugang ?',tracking=True)
    xibo_zugang_username = fields.Char('Xibo Username',tracking=True)
    xibo_zugang_password = fields.Char('Xibo Passwort',tracking=True)
    xibo_zugang_gesendet = fields.Boolean('Xibo Zugang gesendet?',tracking=True)

    lmw_zugang_erstellt = fields.Boolean('LMW Zugang ?',tracking=True)
    lmw_zugang_username = fields.Char('LMW Username',tracking=True)
    lmw_zugang_password = fields.Char('LMW Passwort',tracking=True)
    lmw_zugang_gesendet = fields.Boolean('LMW Zugang gesendet?',tracking=True)

    wflow_korrekturabzug = fields.Boolean('Korekturabzug gesendet ?',tracking=True)
    wflow_ausstahlung = fields.Boolean('Eingespielt/Ausgestahlt ?',tracking=True)
    wflow_aenderung = fields.Boolean('Änderung durchgeführt ?',tracking=True)

    info_account_changes = fields.Boolean('Benachrichtigen bei Accountänderungen',tracking=True)
    info_spot_changes = fields.Boolean('Benachrichtigen bei Spotänderungen',tracking=True)
    info_contract_changes = fields.Boolean('Benachrichtigen bei Vertragsänderungen',tracking=True)
    info_partner_changes = fields.Boolean('Benachrichtigen bei Partneränderungen',tracking=True)
    info_partner = fields.Many2one('res.partner','Benachrichtigung an : ',tracking=True)

    #    work_state =  fields.Many2one('dss.workstate',default=_default_work_state,tracking=True)
    #    work_state_color =  fields.Char(related='work_state.color')
    #    work_state_text =  fields.Char(related='work_state.statusname')
    work_state_info =  fields.Char('Zusatzinfo',tracking=True)

    #    todo_state =  fields.Many2one('dss.todostate',default=_default_todo_state,tracking=True)
    #    todo_state_color =  fields.Char(related='todo_state.color')
    #    todo_state_text =  fields.Char(related='todo_state.statusname')
    #    todo_state_info =  fields.Char('Zusatzinfo',tracking=True)
    #    todo_state_until =  fields.Date('Abarbeiten bis',tracking=True)

    cloudlink = fields.Char('Cloud Verzeichnis',help='Verzeichnis für den Kunde innerhalb des Projekt Ordners')


    @api.depends('vertragssumme')
    def _compute_prov(self):
        _logger.info('contract Provision Berechnung : C_' + str(self.id));
        if self.provisionstyp.provisionbase == 'VSUM':
            if not self.provisionstyp.provisioncalc:
               prozent=self.provisionstyp.provisionprozent
               basis=self.vertragssumme
               value = (basis/100)*prozent
               self.provisionsteilcalc = value

    def _compute_provisionspayedpercent(self):
        addval = 0
        for prov in self.provisions:
            _logger.info('contract Provision Payed_part  : C_' + str(self.id)+' / '+str(prov.provisionprozent));
            addval = addval + prov.provisionprozent
        _logger.info('Contract Provision payed : C_' + str(self.id)+' V '+str(addval));
        self.provisionspayedpercent = addval

    @api.onchange('provisionstyp')
    def _onchange_provtype(self):
        self._compute_prov()
        self._compute_provisionspayedpercent()

    @api.onchange('vertragssumme')
    def _onchange_vsumme(self):
        self._compute_prov()
        self._compute_provisionspayedpercent()

    @api.model
    def _expand_ads_last_work_state(self,states,domain,order):
        if dss_settings.dssSettings._get_settingvalue(self,'show_expand_contract_group_ad_work_state'):
            state_ids = self.env['dss.workstate'].search([])
            return state_ids
        else:
            return self.ads_last_work_state


    @api.model
    def _expand_ads_last_todo_state(self,states,domain,order):
        if dss_settings.dssSettings._get_settingvalue(self,'show_expand_contract_group_ad_todo_state'):
            state_ids = self.env['dss.todostate'].search([])
            return state_ids
        else:
            return self.ads_last_todo_state

    @api.model
    def _expand_ads_last_state(self,states,domain,order):
        if dss_settings.dssSettings._get_settingvalue(self,'show_expand_contract_group_ad_state'):
            state_ids = self.env['dss.adstate'].search([])
            return state_ids
        else:
            return self.ads_last_state

    @api.constrains('client_id')
    def _check_client_id(self) :
        for record in self :
            if len(record.client_id) != 2 :
                _logger.debug("Kundenid muss 2 Stellen haben %s" % (record.client_id))
                raise ValidationError(_("KundenID muss 2 Stellen haben"))

    @api.onchange('client_id')
    def _onchange_client_id(self):
        for record in self :
            if record.contract_name == '' :
                cname = 'unbekannter Kunden'
            else:
                cname = record.contract_name
            resstr = "%s%s %s" % (record.project_id,record.client_id,cname)
            cidstr = "%s%s" % (record.project_id,record.client_id)
            if resstr is None :
                resstr = 'nicht ermittelbar'
        _logger.info('Contract_client_id_change : C_' + str(self.id) + ' - '+str(cidstr)+' vs. '+str(self.contract_auto_id)+'/'+str(resstr)+' vs '+str(self.contract_auto_name));
        self.contract_auto_name = resstr
        self.contract_auto_id = cidstr

    @api.onchange('project_id')
    def _onchange_project_id(self):
        for record in self :
            if record.contract_name == '' :
                cname = 'unbekannter Kunden'
            else:
                cname = record.contract_name
            resstr = "%s%s %s" % (record.project_id,record.client_id,cname)
            cidstr: String = "%s%s" % (record.project_id,record.client_id)
            if resstr is None :
                resstr = 'nicht ermittelbar'
        _logger.info('project_id_change : C_' + str(self.id) + ' - '+str(cidstr)+' vs. '+str(self.contract_auto_id)+'/'+str(resstr)+' vs '+str(self.contract_auto_name));
        self.contract_auto_name = resstr
        self.contract_auto_id = cidstr

    @api.onchange('contract_name')
    def _onchange_contract_name(self):
        for record in self :
            if record.contract_name == '' :
                cname = 'unbekannter Kunden'
            else:
                cname = record.contract_name
            resstr = "%s%s %s" % (record.project_id,record.client_id,cname)
            cidstr = "%s%s" % (record.project_id, record.client_id)
            if resstr is None :
                resstr = 'nicht ermittelbar'
        _logger.info('Contract_Name_Change : C_' + str(self.id) + ' - '+str(cidstr)+' vs. '+str(self.contract_auto_id)+'/'+str(resstr)+' vs '+str(self.contract_auto_name));
        if not self.contract_auto_name:
            self.contract_auto_name = resstr
        if not self.contract_auto_id:
            self.contract_auto_id = cidstr
        if self.contract_auto_id == "":
            self.contract_auto_id = cidstr


    def jumpcloud(self):
        urlbase=str(self.env['dss.settings'].search([], limit=1).def_cloud_url_base)
        _logger.info("Cloud Open Link Urlbase DB " + str(urlbase))
        if not urlbase:
            urlbase = 'https://cloud.logumedia.de/index.php/apps/files/?dir=';
        _logger.info("Cloud Open Link Urlbase Used " + str(urlbase))
        url=str(urlbase)+str(dss_settings.dssSettings._get_path_converted(self,self.project.cloudlink,self.project))+str(dss_settings.dssSettings._get_path_converted(self,self.cloudlink,self))
        _logger.info("Cloud Open Link " + str(url))
        return {
            'type': 'ir.actions.act_url',
            'url': str(url),
            'target': 'new',
        }


    @api.onchange('contract_auto_id')
    def _onchange_contract_auto_id(self):
        for record in self :
            if record.contract_name == '' :
                cname = 'unbekannter Kunden'
            else:
                cname = record.contract_name
            resstr = "%s%s %s" % (record.project_id,record.client_id,cname)
            cidstr = "%s%s" % (record.project_id, record.client_id)
            if resstr is None:
                resstr = 'nicht ermittelbar'
        _logger.info('Contract_auto_id_change : C_' + str(self.id) + ' - '+str(cidstr)+' vs. '+str(self.contract_auto_id)+'/'+str(resstr)+' vs '+str(self.contract_auto_name));
        if not self.contract_auto_name:
            self.contract_auto_name = resstr
        if not self.contract_auto_id:
            self.contract_auto_id = cidstr
        if self.contract_auto_id == "":
            self.contract_auto_id = cidstr

    #    @api.model
    #    def create(self,vals):
    #        vals['projectid'] = self.env.context.get('active_id')
    #        project = self.env('dss.projects').search(['id','=',vals['projectid']])
    #        vals['project'] = project('projektname');
    #        contract=super().create(vals)
    #        return contract

    def action_info_click_ls(self):
        view=self.env.ref("DigitalSignage.dss_contracts_infofeld_form")
        return {
            'type': 'ir.actions.act_window',
            'view_mode': 'form' ,
            'view_id': view.id,
            'res_model': 'dss.contracts' ,
            'target': 'new' ,
            'display_name' : 'Text ändern',
            'views':[(view.id,'form')],
            'res_id': self.id ,
        }

    def action_state_click_ls(self):
        view=self.env.ref("DigitalSignage.dss_contracts_viewstate_ls_form")
        return {
            'type': 'ir.actions.act_window',
            'view_mode': 'form' ,
            'view_id': view.id,
            'res_model': 'dss.contracts' ,
            'target': 'new' ,
            'display_name' : 'Status ändern',
            'views':[(view.id,'form')],
            'res_id': self.id ,
        }

    def action_state_click_lws(self):
        view=self.env.ref("DigitalSignage.dss_contracts_viewstate_lws_form")
        return {
            'type': 'ir.actions.act_window',
            'view_mode': 'form' ,
            'view_id': view.id,
            'res_model': 'dss.contracts' ,
            'target': 'new' ,
            'display_name' : 'Status ändern',
            'views':[(view.id,'form')],
            'res_id': self.id ,
        }

    def action_state_click_lds(self):
        view=self.env.ref("DigitalSignage.dss_contracts_viewstate_lds_form")
        return {
            'type': 'ir.actions.act_window',
            'view_mode': 'form' ,
            'view_id': view.id,
            'res_model': 'dss.contracts' ,
            'target': 'new' ,
            'display_name' : 'Status ändern',
            'views':[(view.id,'form')],
            'res_id': self.id ,
        }

#        return {
            #'effect':{
#                'fadeout':'slow',
#                'message':'Status Geklickt',
#                'type':'rainbow_man',
#            }
#        }
    ''

    @api.model
    def _default_uuid(self):
        return str(uuid.uuid4())

    @api.model
    def _getdefwscolor(self):
        return str('#ffffff')

    @api.model
    def _read_group_stage_ids(self,stages,domain,order):
        contract_state_ids = self.env['dss.contractstate'].search([],order='order')
        return contract_state_ids

    @api.model
    def _default_client_id(self):
        return str("00")

    def pyaction_dss_contract_goto_partner(self):
        fullname = str(self.client_short_vorname) + ' ' +str(self.client_short_name)

    def pyaction_dss_contract_make_partner(self):
        fullname = str(self.client_short_vorname) + ' ' +str(self.client_short_name)
        myplz=self.client_short_plz
        result = self.env['res.partner'].create({'name':fullname,
                                                 'company_name': self.client_short_company,
                                                 'dsspartner_vorname':self.client_short_vorname,
                                                 'dsspartner_name':self.client_short_name,
                                                 'dsspartner':True,
                                                 'dsspartner_werbung':True,
                                                 'street':self.client_short_strasse,
                                                 'city':self.client_short_ort,
                                                 'zip':myplz,
                                                 'phone':self.client_short_telefon,
                                                 'mobile':self.client_short_mobil,
                                                 'email':self.client_short_email,
                                                 'is_company':False})
        result.country_id = self.client_short_land
        _logger.info('Creating Contact ' + str(result) + ' ' + str(fullname))
        self.client = result
#        action = self.env['ir.actions.act_window'].with_context({'default_contractid': self.id})._for_xml_id('DigitalSignage.act_dss_project_view_contract')
#        action['display_name'] = self.contract_name
        #        action['domain'] = '[["projectid","=","4"]]'
        #        context = action['context'].replace('', str(self.id))
        #        context = ast.literal_eval(context)
        #        context.update({
        #            'create': self.active,
        #            'active_test': self.active
        #            })
        #        action['context'] = context
#        return action

    def pyaction_dss_contract_addcalendar_runtime(self):
        event = {
            'start': self.runtime_finish.strftime('%Y-%m-%d %H:%M:%S'),
            'stop': self.runtime_finish.strftime('%Y-%m-%d %H:%M:%S'),
            'duration': 24,
            'allday': True,
            'partner_ids': (4,self.env['dss.settings'].search([],limit=1).contact_runtime_user.partner_id.id),
            'name': 'Vertragsablauf '+self.contract_auto_name,
            'description': 'Vertragsablauf '+self.contract_auto_name+' im Projekt '+self.project.projektname,
            'user_id': self.env['dss.settings'].search([],limit=1).contact_runtime_user.id
        }
        _logger.debug('linking new event ' + str(event) + ' ' + str(self.uuid))
        self.runtime_calendar_event=self.env['calendar.event'].create(event).id
        return ""

    def pyaction_dss_contract_addcalendar_rf_runtime(self):
        self.env['calendar.event'].search([('id', '=', self.runtime_calendar_event)]).unlink()
        event = {
            'start': self.runtime_finish.strftime('%Y-%m-%d %H:%M:%S'),
            'stop': self.runtime_finish.strftime('%Y-%m-%d %H:%M:%S'),
            'duration': 24,
            'allday': True,
            'partner_ids': (4,self.env['dss.settings'].search([],limit=1).contact_runtime_user.partner_id.id),
            'name': 'Vertragsablauf '+self.contract_auto_name,
            'description': 'Vertragsablauf '+self.contract_auto_name+' im Projekt '+self.project.projektname,
            'user_id': self.env['dss.settings'].search([],limit=1).contact_runtime_user.id
        }
        _logger.debug('linking new event ' + str(event) + ' ' + str(self.uuid))
        self.runtime_calendar_event=self.env['calendar.event'].create(event).id
        return ""

    def pyaction_dss_contract_calc_runtime(self):
        if self.start_date:
            startdatum= self.start_date
        else:
            startdatum= self.contract_date
        if startdatum :
            if self.runtimesystem == "M":
                bmonths = 0
                bmonths = self.runtime_m+self.runtime_bonus_m
                if bmonths > 12:
                    addyears=bmonths//12
                else:
                    addyears = 0
                addmonths = bmonths - (addyears*12)
                enddatum = startdatum + relativedelta(months=addmonths,years=addyears,days=-1)
            elif self.runtimesystem == "T":
                enddatum = startdatum +  relativedelta(days=self.runtime_t-1)
                enddatum = enddatum + relativedelta(days=self.runtime_t)
            elif self.runtimesystem == "E":
                enddatum = startdatum
                if self.runtime_events:
                    mydate = startdatum
                    for event in self.runtime_events:
                        if mydate.strftime('%Y-%m-%d') < event.eventenddate.strftime('%Y-%m-%d'):
                             mydate = event.eventenddate
                    enddatum = mydate
            elif self.runtimesystem == "S":
                enddatum = self.runtime_finish

            self.runtime_finish = enddatum

            if not self.contract_cancel_mon:
                cancelmonths = 0
            else:
                cancelmonths = self.contract_cancel_mon

            self.contract_cancel_date = enddatum - relativedelta(months=cancelmonths)

    def pyaction_dss_contract_calc_runtime_end(self):
        if self.start_date:
            startdatum= self.start_date
        else:
            startdatum= self.contract_date
        if startdatum :
            if self.runtimesystem == "M":
                bmonths = 0
                bmonths = self.runtime_m+self.runtime_bonus_m
                if bmonths > 12:
                    addyears=bmonths//12
                else:
                    addyears = 0
                addmonths = bmonths - (addyears*12)
                enddatum = startdatum + relativedelta(months=addmonths,years=addyears,days=-1)
            elif self.runtimesystem == "T":
                enddatum = startdatum +  relativedelta(days=self.runtime_t-1)
                enddatum = enddatum + relativedelta(days=self.runtime_t)
            elif self.runtimesystem == "E":
                enddatum = startdatum
                if self.runtime_events:
                    mydate = startdatum
                    for event in self.runtime_events:
                        if mydate.strftime('%Y-%m-%d') < event.eventenddate.strftime('%Y-%m-%d'):
                             mydate = event.eventenddate
                    enddatum = mydate
            elif self.runtimesystem == "S":
                enddatum = self.runtime_finish

            if not self.contract_cancel_mon:
                cancelmonths = 0
            else:
                cancelmonths = self.contract_cancel_mon

            self.contract_cancel_date = enddatum - relativedelta(months=cancelmonths)

    def pyopen_provadd_form_view(self):
        _logger.info('Open Add Provision')
        view=self.env.ref("DigitalSignage.dss_provision_add_form")
        self._compute_prov()
        provision=self.env['dss.provision'].create({'contract':self.id,'provisiongesamt':self.provisionsteilcalc,'paydate':date.today()})
        _logger.info('Open Add Provision '+str(view)+' P_'+str(provision))
#        self.provisions=[(4,[provision.id])]
        return {
            'type': 'ir.actions.act_window',
            'view_mode': 'form' ,
            'view_type': 'form' ,
            'view_id': view.id,
            'res_model': 'dss.provision' ,
            'target': 'new' ,
            'display_name' : 'Neu Provision einfügen',
            'views':[(view.id,'form')],
            'res_id':provision.id,
        }

    def tokampagne(self):
        _logger.info('Click auf Werbekampagne : C_'+str(self.id)+' - prüfe Letzte Aktuelle Kampagne')
        #        action = self.env['ir.actions.act_window'].with_context({'default_contractid': self.id})._for_xml_id('DigitalSignage.action_dss_ads_view')
        #        context = action['context']
        ds = self.env['dss.ads'].search([('contract','=',self.id),('ad_is_lastpos','=',True)],limit=1)
        if not ds:
            _logger.info('Click auf Werbekampagne : C_'+str(self.id)+' - keine letzte Kampagne')
            ds = self.env['dss.ads'].search([('contract','=',self.id)],limit=1)
        else:
            _logger.info('Click auf Werbekampagne : C_'+str(self.id)+'A_'+str(ds.id)+' - Kampagne gefunden ')
        self.ads_last_ad = ds
        # prüfen ob Contract_autoname
        resstr = ''
        if not self.contract_auto_name:
            _logger.info('Click auf Werbekampagne : C_'+str(self.id)+'A_'+str(ds.id)+' - Kein Contract_autoname ')
            if self.contract_name == '':
                cname = 'unbekannter Kunden'
            else:
                cname = self.contract_name
            resstr = "%s%s %s" % (self.project_id, self.client_id, cname)
            if not resstr:
                resstr = 'nicht ermittelbar'
            _logger.debug(resstr)
            self.contract_auto_name = resstr
            _logger.info('Click auf Werbekampagne : C_' + str(self.id) + 'A_' + str(ds.id) + ' - Contract_autoname gesetzt '+ str(resstr))
        # prüfen ob LetzteKampagne medien hat
        _logger.info('Click auf Werbekampagne : C_'+str(self.id)+'A_'+str(ds.id)+' - Suche evtl Medien der Kampagne ')
        medias = self.env['dss.mediarelations'].search(['&',('contract','=',self.id),('ad','=',ds.id)])
        if medias:
            _logger.info('Click auf Werbekampagne : C_'+str(self.id)+'A_'+str(ds.id)+' - Medien gefunden '+str(medias.ids))
            self.write({'last_media': [(6,0,medias.ids)]})
        else:
            _logger.info('Click auf Werbekampagne : C_'+str(self.id)+'A_'+str(ds.id)+' - Keine Medien gefunden ')

        # Medien erzeugen wenn nicht vorhanden
        _logger.info('Click auf Werbekampagne : C_'+str(self.id)+' Suche Kampagne allgemein ')
        kampagne=self.env['dss.ads'].search([('contract','=',self.id)],limit=1)
        if not kampagne:
            _logger.info('Click auf Werbekampagne : C_'+str(self.id)+' kein kampagne')
            defadstate = self.env['dss.adstate'].search([('func','=','STD')],limit=1)
            if not defadstate :
                _logger.info('Click auf Werbekampagne : C_'+str(self.id)+' kein defstate')
                defadstateid = 1
            else:
                defadstateid = defadstate.id
            kampagne = self.env['dss.ads'].create({'contract': self.id, 'project': self.project.id, 'adname': 'WK '+self.contract_auto_name,'adtype':'MAIN','ad_state':defadstateid})
            self.ads_last_ad = kampagne.id
            _logger.info('Click auf Werbekampagne : C_'+str(self.id)+' Kampagne erstellt A_'+str(kampagne.id))
            kampagne.parent_ad = kampagne.id
            mediaids = []
            if not self.werbe_feld_selected:
                _logger.info('Prüfe Medien : C_' + str(self.id) + 'A_' + str(
                    kamp.id) + ' Keine Felder im Vertrag')
                raise ValidationError(_("Vertrag hat keine Felder ! Kampagnen benötigen Felder - auch virtuelle"))
            else:
                for feld in self.werbe_feld_selected:
                    if not feld:
                        _logger.info('Prüfe Medien : C_' + str(self.id) + 'A_' + str(
                            kamp.id) + ' Keine Felder im Vertrag')
                        raise ValidationError(_("Vertrag hat keine Felder ! Kampagnen benötigen Felder - auch virtuelle"))
                    else:
                        for media in feld.mediastructure.medias:
                            if not media:
                                _logger.info('Prüfe Medien : C_'+str(self.id)+'K_'+str(kampagne.id)+' Kein Medium in MedienStructur von F_'+str(feld.id)+'M_'+str(media.id))
                            else:
                                newmedia=self.env['dss.mediarelations'].create({'field':feld.id,'contract':self.id,'project':self.project.id,'field_uuid':feld.uuid,'ad':kampagne.id, 'relname': media.medianame,
                                                                                'mediatype': media.id})
                                _logger.info('Prüfe Medien : C_'+str(self.id)+'K_'+str(kampagne.id)+' setze Vertrag für  Medium : '+str(newmedia.contract)+'/'+str(newmedia.ad))
                                mediaids.append(newmedia.id)
                kampagne.write({'need_media': [(6,0,mediaids)]})
                _logger.info('Click auf Werbekampagne : C_'+str(self.id)+'/'+str(kampagne.id)+' setze Media '+str(kampagne.need_media))
        else:
            _logger.info('Click auf Werbekampagne : C_'+str(self.id)+' mind. 1 Kampagne vorhanden A_'+str(kampagne.id))
            kampagnen=self.env['dss.ads'].search([('contract','=',self.id)])
            _logger.info('Prüfe Medien : C_'+str(self.id)+' alle Kamp : '+str(kampagnen))
            for kamp in kampagnen:
                _logger.info('Prüfe Medien : C_'+str(self.id)+'A_'+str(kamp.id))
                if kamp:
                    mediaids = []
                    medias = self.env['dss.mediarelations'].search([('ad','=',kamp.id)])
                    if not medias:
                        _logger.info('Prüfe Medien : C_'+str(self.id)+'A_'+str(kamp.id)+' keine Medien gefunden !')
                        if not self.werbe_feld_selected:
                            _logger.info('Prüfe Medien : C_' + str(self.id) + 'A_' + str(
                                kamp.id) + ' Keine Felder im Vertrag')
                            raise ValidationError(
                                _("Vertrag hat keine Felder ! Kampagnen benötigen Felder - auch virtuelle"))
                        else:
                            for feld in self.werbe_feld_selected:
                                if not feld:
                                    _logger.info('Prüfe Medien : C_' + str(self.id) + 'A_' + str(
                                        kamp.id) + ' Keine Felder im Vertrag')
                                    raise ValidationError(_("Vertrag hat keine Felder ! Kampagnen benötigen Felder - auch virtuelle"))
                                else:
                                    for media in feld.mediastructure.medias:
                                        if not media:
                                            _logger.info('Prüfe Medien : C_'+str(self.id)+'A_'+str(kamp.id)+' Kein Medium in der Struktur F_'+str(feld.id)+'M_'+str(feld.mediastructure.id))
                                        else:
                                            newmedi = self.env['dss.mediarelations'].create(
                                                {  'field': feld.id, 'contract': self.id, 'project': self.project.id,
                                                   'field_uuid': feld.uuid, 'ad': kamp.id, 'relname':media.medianame,'mediatype':media.id})
                                            _logger.info('Prüfe Medien : C_'+str(self.id)+'A_'+str(kamp.id)+' Erstelle Medium : M_'+str(media.id)+' -> '+str(newmedi.id))
                                    _logger.info('Prüfe Medien : C_'+str(self.id)+'A_'+str(kamp.id)+' Medien evtl erstellt ! ')
                            medias = self.env['dss.mediarelations'].search([('ad','=',kamp.id)])
                            _logger.info('Click auf Werbekampagne : C_'+str(self.id)+'A_'+str(kamp.id)+' neue Media '+str(mediaids))
                            kamp.write({'need_media': [(6,0,medias.ids)]})
                    #                           self.write({'need_media': [(5,0,0)]})
                    #                           _logger.info('Click auf Werbekampagne : C_'+str(self.id)+'K_'+str(kamp.id)+' setze Media '+str(kamp.need_media))
                    else:
                        _logger.info('Prüfe Medien : C_'+str(self.id)+'A_'+str(kamp.id)+' Medien gefunden !')
                        if not self.werbe_feld_selected:
                            _logger.info('Prüfe Medien : C_' + str(self.id) + 'A_' + str(
                                kamp.id) + ' Keine Felder im Vertrag')
                            raise  ValidationError(
                                _("Vertrag hat keine Felder ! Kampagnen benötigen Felder - auch virtuelle"))
                        else:
                            for feld in self.werbe_feld_selected:
                                _logger.info('Prüfe Medien : C_' + str(self.id) + 'A_' + str(kamp.id)+'F_'+str(feld.id))
                                if not feld:
                                    _logger.info('Prüfe Medien : C_' + str(self.id) + 'A_' + str(
                                        kamp.id) + ' Keine Felder im Vertrag')
                                    raise ValidationError(_("Vertrag hat keine Felder ! Kampagnen benötigen Felder - auch virtuelle"))
                                else:
                                    for media in feld.mediastructure.medias:
                                        if not media:
                                            _logger.info('Prüfe Medien : C_' + str(self.id) + 'A_' + str(
                                                kamp.id) + ' Kein Medium in der Struktur F_' + str(feld.id) + 'M_' + str(
                                                feld.mediastructure.id))
                                        else:
                                            _logger.info('Prüfe Medien : C_' + str(self.id) + 'A_' + str(kamp.id) + 'F_' + str(
                                                feld.id) + 'M_' + str(media.id))
                                            existmedia = self.env['dss.mediarelations'].search(['&',('ad','=',kamp.id),('mediatype','=',media.id),('field','=',feld.id)])
                                            if not existmedia:
                                                newmedi = self.env['dss.mediarelations'].create(
                                                    {'field': feld.id, 'contract': self.id, 'project': self.project.id,
                                                     'field_uuid': feld.uuid, 'ad': kamp.id, 'relname': media.medianame,
                                                     'mediatype': media.id})
                                                _logger.info('Prüfe Medien : C_' + str(self.id) + 'A_' + str(
                                                    kamp.id) + ' Erstelle Medium : M_' + str(media.id) + ' -> ' + str(
                                                    newmedi.id))
                            #                        mediaids.append(medias.ids)
                            _logger.info('Click auf Werbekampagne : C_'+str(self.id)+'A_'+str(kamp.id)+' gefundene Media '+str(mediaids))
                            kampagne=self.env['dss.ads'].browse(kamp.id)
                            _logger.info('Click auf Werbekampagne : C_'+str(self.id)+'A_'+str(kamp.id)+' gefundene Media '+str(mediaids)+' Kampagne '+str(kampagne))
                            if kampagne.need_media != medias:
                                _logger.info('Click auf Werbekampagne : C_'+str(self.id)+'A_'+str(kamp.id)+' Media unterschiede - setze Media '+str(mediaids)+'/'+str(kampagne.need_media))
                            else:
                                _logger.info('Click auf Werbekampagne : C_'+str(self.id)+'A_'+str(kamp.id)+' Media gleich '+str(kampagne.need_media))
                else:
                    _logger.info('Prüfe Medien : C_'+str(self.id)+'A_'+str(kamp.id)+' Keine Kampagne gefunden !')
        #        _logger.info('Click auf Werbekampagne : '+str(self.id)+' 4 '+str(kampagne.id))
        return {
            'type': 'ir.actions.act_window',
            'view_type':'form',
            'view_mode':'form,tree',
            'res_model':'dss.ads',
            'target':'current',
            'context':'{"kampagne_id":'+str(kampagne.id)+',"show_project_update":True}',
            'context':'',
            'res_id':kampagne.id,
            'display_name' : 'Änderung zur Werbekampagne '+kampagne.parent_ad.adname,
            'domain':'[("id","=","context[kampagne_id]")]'
        }
    def setFirstKampagne(self):
        for record in self:
            if record.contract_auto_id:
                record.tokampagne()
    def setTreeStandardValues(self):
        for record in self:
            if record.contract_name == '':
                cname = 'unbekannter Kunden'
            else:
                cname = record.contract_name
            resstr = "%s%s %s" % (record.project_id, record.client_id, cname)
            cidstr = "%s%s" % (record.project_id, record.client_id)
            if resstr is None:
                resstr = 'nicht ermittelbar'
            _logger.info('Set Standard Values  : C_' + str(record.id) + ' - ' + str(cidstr) + ' vs. ' + str(
                record.contract_auto_id) + '/' + str(resstr) + ' vs ' + str(record.contract_auto_name));
            if not record.contract_auto_name:
                record.contract_auto_name = resstr
            if not record.contract_auto_id:
                record.contract_auto_id = cidstr
            if record.contract_auto_id == "":
                record.contract_auto_id = cidstr


    def setStandardValues(self):
        for record in self:
            if record.contract_name == '':
                cname = 'unbekannter Kunden'
            else:
                cname = record.contract_name
            resstr = "%s%s %s" % (record.project_id, record.client_id, cname)
            cidstr = "%s%s" % (record.project_id, record.client_id)
            if resstr is None:
                resstr = 'nicht ermittelbar'
        _logger.info('Set Standard Values  : C_' + str(self.id) + ' - ' + str(cidstr) + ' vs. ' + str(
            self.contract_auto_id) + '/' + str(resstr) + ' vs ' + str(self.contract_auto_name));
        if not self.contract_auto_name:
            self.contract_auto_name = resstr
        if not self.contract_auto_id:
            self.contract_auto_id = cidstr
        if self.contract_auto_id == "":
            self.contract_auto_id = cidstr

    @api.depends('shortwerbe_feld_selected')
    @api.onchange('werbe_feld_selected')
    def _compute_cutshort(self):
        for rec in self:
            if rec.werbe_feld_selected:
                shorty = ""
                for f in rec.werbe_feld_selected:
                    try:
                        if not shorty:
                            shorty = str(f.feldname)
                        else:
                            shorty = shorty+','+str(f.feldname)
                    except:
                        _logger.info('Werbefeldberechnung Exception  : C_' + str(rec.id))
                rec.cutshortwerbe_feld_selected = str(shorty)
            else:
                rec.cutshortwerbe_feld_selected = 'unb.'
                _logger.info('Werbefeldberechnung kein Inhalt für : C_' + str(rec.id) + ' - ' + str(rec.shortwerbe_feld_selected))


    def pyaction_view_contract(self):
        view = self.env.ref('DigitalSignage.dss_main_contracts_form')
        _logger.debug('Click auf Vertrag : '+str(self.id))
        return {
            'type': 'ir.actions.act_window',
            'view_mode': 'form' ,
            'view_id': view.id,
            'res_model': 'dss.contracts' ,
            'target': 'current' ,
            'display_name' : self.contract_name,
            'views':[(view.id,'form')],
            'res_id': self.id ,
        }

    def pyaction_new_contract_kanban(self):
        action = self.env['ir.actions.act_window'].with_context({'default_contractid': self.id})._for_xml_id('DigitalSignage.action_dss_project_new_contract_kanban')
        action['display_name'] = self.contract_name
        #        action['domain'] = '[["projectid","=","4"]]'
        #        context = action['context'].replace('', str(self.id))
        #        context = ast.literal_eval(context)
        #        context.update({
        #            'create': self.active,
        #            'active_test': self.active
        #            })
        #        action['context'] = context
        return action

    def pyaction_dss_project_make_contract(self):
        action = self.env['ir.actions.act_window'].with_context({'default_projectid': self.id})._for_xml_id('DigitalSignage.action_dss_project_view_contract')
        return action


    def py_jump_last_ad(self):
        for record in self:
            self.tokampagne()


    def trigger_action_init(self):
        _logger.info('Contract Cron Running - Start '+str(self)+' start searching')
        jobcontracts = self.env['dss.contracts'].search([('run_trigger', '=', True)])
        _logger.info('Contract Cron Running - Start '+str(self)+' '+str(len(jobcontracts))+' Triggergruppen gefunden')
        for record in jobcontracts:
            if not record:
                _logger.info('Contract Cron Running No Contracts Delivered - searching')
            else:
              _logger.info('Contract Cron Running C_' + str(record.id) + ' Starte Triggerprüfung')
              if record.run_trigger:
                  _logger.info('Contract Cron Running C_' + str(record.id) + ' Prüfe Triggergruppe TG_' + str(record.triggergroup.id))
                  triggergroup = record.triggergroup
                  if not triggergroup:
                      _logger.info('Contract Cron Running C_' + str(record.id) + ' Triggergruppe TG_' + str(record.triggergroup.id)+' nicht gefunden !')
                      pass
                  else:
                      for trigger in triggergroup.triggers:
                          if not trigger:
                              pass
                              _logger.info('Contract Cron Running C_' + str(record.id) + ' Triggerprüfung : Keine Trigger in Gruppe !')
                          else:
                              _logger.info('Contract Cron Running C_' + str(record) + ' in Triggergruppe TG_' + str(record.triggergroup)+' Prüfe Trigger T_'+str(trigger))
                              if trigger._check_trigger():
                                  _logger.info('Contract Cron Trigger T_' + str(trigger)+' executed ')


            _logger.info('Contract Cron Running - Finished')