1263 lines
66 KiB
Python
Executable File
1263 lines
66 KiB
Python
Executable File
# -*- coding: utf-8 -*
|
|
|
|
# Test
|
|
# Test2
|
|
|
|
import ast
|
|
import datetime
|
|
import json
|
|
import re
|
|
import uuid
|
|
from .dsslogger import OdooCustomLogger
|
|
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 . import dss_ads
|
|
from odoo.exceptions import ValidationError
|
|
from odoo.exceptions import UserError
|
|
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
|
|
from webdav4.client import Client
|
|
from webdav4.fsspec import WebdavFileSystem
|
|
import sys
|
|
|
|
TUYA_LOGGER.setLevel(logging.DEBUG)
|
|
|
|
logging.setLoggerClass(OdooCustomLogger)
|
|
_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
|
|
|
|
|
|
def _getkorrColor(self):
|
|
_logger.info('Contract get Color ')
|
|
for record in self:
|
|
record.korrectur_color = "#000000"
|
|
return "#000000"
|
|
|
|
_name = "dss.contracts"
|
|
_description = "DigitalSignage Vertraege"
|
|
_rec_name = "contract_auto_name"
|
|
_inherit = ['mail.thread','dss.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_name = fields.Char(related='contract_state.statusname',string='Vertragsstatus - Text',store=True)
|
|
contract_state_color = fields.Char(related='contract_state.color',string='Vertragsstatus - Farbe',store=True)
|
|
contract_state_order = fields.Integer(related='contract_state.order',string='Vertragsstatus - Reihenfolge',store=True)
|
|
contract_state_minimal_kanban = fields.Boolean(related='contract_state.kanban_display_minimal',string='Kanban mininmal',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)
|
|
contract_writer_mailcc = fields.Boolean('Vertragsschr. Mail CC ?', tracking=True)
|
|
vertragssumme = fields.Float('Vertragssumme :', tracking=True)
|
|
provisionstyp = fields.Many2one('dss.provisionstypen', tracking=True)
|
|
provisionsteilcalc = fields.Float('Berechnete Provision :')
|
|
provisions = fields.Many2many('dss.provision', tracking=True)
|
|
provisionspayedpercent = fields.Float('Ausgezahlte Provision % :',compute='_compute_provisionspayedpercent')
|
|
grafiker = fields.Many2one('res.partner', domain="['&',('dssinternpartner','=',True),('dssinternpartner_grafik','=',True)]", tracking=True, string="abw. Grafiker",help="Grafiker nur wenn abweichend vom Projektgrafiker")
|
|
real_grafiker = fields.Char('Grafiker tatsächlich', tracking=True)
|
|
|
|
contract_remark = fields.Html('Vertragshinweise',tracking=True)
|
|
|
|
project = fields.Many2one('dss.projects' , string='Project', store=True,tracking=True)
|
|
project_name = fields.Char(related='project.name')
|
|
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_grundsystem_typ_cloud_contract_template = fields.Char(related='project.grundsystem_default_cloud_structure_contract', tracking=True)
|
|
project_grafiker = fields.Many2one(related="project.project_grafiker",tracking=True)
|
|
project_system_uuid = fields.Char(related='project.grundsystemnameuuid', tracking=True)
|
|
|
|
run_trigger = fields.Boolean(tracking=True)
|
|
run_uni_trigger = fields.Boolean(tracking=True)
|
|
run_uni_sub_trigger = fields.Boolean(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.company_name")
|
|
contact_name = fields.Char(related="client.name")
|
|
contact_dsspartner_vorname = fields.Char(related="client.dsspartner_vorname")
|
|
contact_dsspartner_name = fields.Char(related="client.dsspartner_name")
|
|
|
|
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)
|
|
|
|
client_invoices = fields.Many2many('dss.invoices',string='Rechnungsliste',tracking=True,domain='[("invoiceclientnr","=",contract_auto_id)]')
|
|
|
|
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')
|
|
|
|
werbe_feld_selected_btn_img = fields.Binary(related="werbe_feld_selected.btn_image_bin",string='Buttonbild',tracking=True)
|
|
werbe_feld_selected_btn_img_base64 = fields.Char(related="werbe_feld_selected.btn_image_bin_base64")
|
|
werbe_feld_selected_btn_pos_x = fields.Integer(related="werbe_feld_selected.btn_pos_x", tracking=True)
|
|
werbe_feld_selected_btn_pos_y = fields.Integer(related="werbe_feld_selected.btn_pos_y", tracking=True)
|
|
werbe_feld_selected_btn_pos_w = fields.Integer(related="werbe_feld_selected.btn_pos_w", tracking=True)
|
|
werbe_feld_selected_btn_pos_h = fields.Integer(related="werbe_feld_selected.btn_pos_h", tracking=True)
|
|
werbe_feld_selected_btn_name = fields.Char(related="werbe_feld_selected.btn_name",tracking=True)
|
|
|
|
# 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('Gesamtcliplänge',tracking=True)
|
|
split_runtime_count = fields.Integer('Clip Teilungen',tracking=True)
|
|
split_runtime_time = fields.Integer('Cliplänge Sekunden',tracking=True)
|
|
|
|
contract_date = fields.Date('Vertragsdatum',tracking=True)
|
|
start_date = fields.Date('Start/Auslief.datum',tracking=True,help="Datum des geplanten Startes der 1. Kampagne. Also die Uraustrahlung!")
|
|
contract_cancel_mon = fields.Integer('Kündigungsfrist Monaten',tracking=True)
|
|
contract_cancel_date = fields.Date('Kündigungsfrist Errechnet', tracking=True)
|
|
contract_iscanceled = fields.Boolean('Vertrag gekündigt',tracking=True)
|
|
contract_iscanceled_date = fields.Date('Vertrag gekündigt am',tracking=True)
|
|
contract_auto_extend = fields.Boolean('autom. V.Verlängerung',tracking=True)
|
|
contract_auto_extend_time = fields.Char('Verl. Monate',tracking=True)
|
|
scan_vertrag = fields.Binary('Datei')
|
|
scan_vertrag_filename = fields.Char("Dateiname") # Hilft, den Dateinamen zu speichern
|
|
|
|
no_cancel_calc = fields.Boolean('Berechnungen verbieten',tracking=True)
|
|
|
|
runtimesystem = fields.Selection([('M','Monatslaufzeit'),('T','Tagelaufzeit'), ('E','Eventlaufzeit'), ('S','Sonderlaufzeit')],tracking=True)
|
|
runtime_m = fields.Integer('Laufzeit Monate',tracking=True)
|
|
runtime_bonus_m = fields.Integer('zusätzl. Laufzeit Monate',tracking=True)
|
|
runtime_t = fields.Integer('Laufzeit Tage',tracking=True)
|
|
runtime_bonus_t = fields.Integer('zusätzl. Laufzeit Tage',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",compute='_default_get_ads_last_ad',store=True)
|
|
ads_last_adtype = fields.Selection(related='ads_last_ad.adtype')
|
|
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',readonly=False)
|
|
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)
|
|
ads_last_date_zuarbeit = fields.Date(related='ads_last_ad.date_zuarbeit',readonly=False)
|
|
ads_last_date_korrekturabzug = fields.Date(related='ads_last_ad.date_korrekturabzug',readonly=False)
|
|
ads_last_date_korrekturfreigabe_ablauf = fields.Date(related='ads_last_ad.date_korrekturfreigabe_ablauf',readonly=False)
|
|
ads_last_date_korrekturfreigabe_ablauf_erfolgt = fields.Boolean(related='ads_last_ad.korrekturfreigabe_ablauf_erfolgt',readonly=False)
|
|
ads_last_date_korrekturfreigabe = fields.Date(related='ads_last_ad.date_korrekturfreigabe',readonly=False)
|
|
ads_last_date_start_planed = fields.Date(related='ads_last_ad.date_start_planed',readonly=False,help="Datum des geplanten Startes der Aktuell gültigen Kampagne !")
|
|
ads_last_date_start_real = fields.Date(related='ads_last_ad.date_start_real',readonly=False,help="Datum des wirklichen Startes der Aktuell gültigen Kampagne !")
|
|
ads_last_date_remove_planed = fields.Date(related='ads_last_ad.date_remove_planed',readonly=False)
|
|
ads_last_date_remove_real = fields.Date(related='ads_last_ad.date_remove_real',readonly=False)
|
|
ads_last_date_start_real_mail_send = fields.Boolean(related='ads_last_ad.date_start_real_mail_send',string='Kampagnen Startmail', tracking=True)
|
|
ads_last_date_start_real_mail_data = fields.Date(related='ads_last_ad.date_start_real_mail_data', tracking=True)
|
|
korrectur_color = fields.Char(string='Korrektur Text Color nach Status',compute=_getkorrColor)
|
|
ads_last_date_korrekturfreigabe_ablauf_auto_cancel = fields.Boolean(related='ads_last_ad.korrekturfreigabe_ablauf_auto_cancel', tracking=True)
|
|
|
|
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)
|
|
vnnox_playlist_checked = fields.Boolean('Vnnox Liste geprüft ?',tracking=True)
|
|
vnnox_playlist_checked_empty = fields.Boolean('Vnnox Liste war leer ?',tracking=True)
|
|
vnnox_playlist_checked_date = fields.Date('Vnnox Liste geprüft am ',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_marker_1 = fields.Boolean('Markierung 1 aktiv',tracking=True)
|
|
work_marker_2 = fields.Boolean('Markierung 2 aktiv',tracking=True)
|
|
work_marker_3 = fields.Boolean('Markierung 3 aktiv',tracking=True)
|
|
work_marker_4 = fields.Boolean('Markierung 4 aktiv',tracking=True)
|
|
|
|
marker_list = fields.Many2many('dss.marker', string='vorhandene Marker', 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')
|
|
|
|
|
|
web_contract = fields.Many2one('dss.web_contracts' , string='Web_Vertrag', store=True,tracking=True)
|
|
tv_reach_PLZ = fields.Char(string='Reichweite PLZ',tracking=True)
|
|
ads_radius_PLZ = fields.Integer('Umkreis PLZ in Km',tracking=True)
|
|
ads_count_perYear = fields.Selection([('30000','30.000'),('60000','60.000'),('120000','120.000'),('1000000','1.000.000')],'Einblendungen alt',tracking=True)
|
|
ads_count_perYear2 = fields.Integer('Einblendungen',tracking=True)
|
|
ads_topics = fields.Many2many('dss.contracts_ads_topics', string='Themenliste', tracking=True)
|
|
ads_topics_text = fields.Char('Themenliste gesamt',compute='_compute_themenliste')
|
|
|
|
@api.depends('ads_topics')
|
|
def _compute_themenliste(self):
|
|
# _logger.info('Contract Themenliste Berechnung : C_' + str(self.id))
|
|
for record in self:
|
|
if record.ads_topics:
|
|
record.ads_topics_text = ', '.join(record.ads_topics.mapped('thema'))
|
|
else:
|
|
record.ads_topics_text = ''
|
|
|
|
@api.onchange('ads_last_date_korrekturabzug')
|
|
def _ads_last_date_korrekturabzug_change(self):
|
|
_logger.info('Korrekturabzug änderung C')
|
|
for record in self:
|
|
_logger.info('Korrekturabzug änderung C: C_' + str(self.id) + 'K_' + str(record.id)+' / '+str(record.ads_last_date_korrekturabzug)+' / '+str(record._origin.ads_last_date_korrekturabzug))
|
|
autodays=0
|
|
if record.ads_last_date_korrekturabzug:
|
|
_logger.info('Korrekturabzug Änderung erfolgt C: C_' + str(self.id) + 'K_' + str(record.id))
|
|
autodays=self.env['dss.settings'].search([],limit=1).freigabe_auto_time
|
|
record.ads_last_date_korrekturfreigabe_ablauf = record.ads_last_date_korrekturabzug + relativedelta(days=autodays)
|
|
|
|
|
|
@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):
|
|
_logger.info('project_id_change_1 : C_' + str(self) + ' - '+str(self.project))
|
|
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('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):
|
|
_logger.info('Get Columns Contract State '+ str(stages)+' / ' + str(domain)+' / '+str(domain[0])+' / '+str(len(domain[0])))
|
|
if (len(domain[0]) > 1):
|
|
_logger.info('get Columns Contract State ' + str(domain)+' / '+str(domain[0]))
|
|
Pid = domain[0][2]
|
|
else:
|
|
_logger.info('get Columns Contract State ' + str(domain)+' / '+str(domain[1][2]))
|
|
Pid = domain[1][2]
|
|
Myproject=self.env['dss.projects'].search([("id","=",Pid)])
|
|
contract_state_ids = self.env['dss.contractstate'].search(["|",("systemtypdefault","=",True),("systemtypuuid","=",Myproject.grundsystemnameuuid)],order='order')
|
|
# contract_state_ids = self.env['dss.contractstate'].search([],order='order')
|
|
_logger.info('get Columns Contract State ' + str(contract_state_ids)+' / '+str(self.project_system_uuid)+' / '+str(self)+' / '+str(stages)+' / '+str(domain)+' / '+str(Myproject))
|
|
return contract_state_ids
|
|
|
|
@api.model
|
|
def _read_group_system_ids(self, stages, domain, order):
|
|
_logger.info('Get Columns System State ' + str(stages)+' / '+str(domain)+' / '+str(order))
|
|
project_system_ids = self.env['dss.systemtypen'].search([('open_close_standard_state','=',False)], order='order')
|
|
return project_system_ids
|
|
|
|
@api.model
|
|
def fields_view_get(self,cr,uid,view_id=None,view_type='form',context=None, toolbar=False, submenu=False):
|
|
_logger.info('Fields View Get ' + str(cr)+' / '+str(uid)+' / '+str(view)+' / '+str(parent))
|
|
if context is None:
|
|
context={}
|
|
return res
|
|
|
|
@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.ads_last_date_start_real:
|
|
startdatum= self.ads_last_date_start_real
|
|
elif self.ads_last_date_start_planed:
|
|
startdatum= self.ads_last_date_start_planed
|
|
elif 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.ads_last_date_start_real:
|
|
startdatum= self.ads_last_date_start_real
|
|
elif self.ads_last_date_start_planed:
|
|
startdatum= self.ads_last_date_start_planed
|
|
elif 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)+' - P_'+str(kamp.parent_ad))
|
|
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':self.ads_last_ad.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 setRealGrafiker(self):
|
|
#for record in self:
|
|
#if self.grafiker:
|
|
#record.real_Grafiker="Test"
|
|
#return "Test"
|
|
# else:
|
|
# return self.project_grafiker
|
|
|
|
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'] = '[["id","=","'+str(self.id)+'"]]'
|
|
# 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):
|
|
#raise UserError(_("Inhalt : "+str(self.id)+" - "+str(self.contract_name)+" - "+str(self.client_id)))
|
|
newid =self.id
|
|
self.contract_auto_id = str(self.project_id) + str(self.client_id)
|
|
self.contract_auto_name = str(self.project_id) + str(self.client_id) + ' ' + str(self.contract_name)
|
|
projectcloudpath = self.project.cloudlink
|
|
if not projectcloudpath:
|
|
self.cloudlink = str(dss_settings.dssSettings.getprojectpath(self,self.project))+str(dss_settings.dssSettings.getClientpath(self,self))
|
|
else:
|
|
if projectcloudpath[0] != '$':
|
|
self.cloudlink = str(projectcloudpath)+str(dss_settings.dssSettings.getClientpath(self,self))
|
|
else:
|
|
self.cloudlink = str(dss_settings.dssSettings.getprojectpath(self,self.project))+str(dss_settings.dssSettings.getClientpath(self,self))
|
|
action = (self.env["confirmation.wizard"].confirm_message(_("Ist die Bezeichnung des neuen Kunden : "+self.contract_auto_name+" richtig ?( "+str(self.cloudlink)+" ) (Cloudornder wird entsprechend angelegt) !"),title="Bitte bestätigen",method="createcontract",records=self,callback_params={"template":self.id})
|
|
)
|
|
if action:
|
|
return action
|
|
|
|
def create_cloud_structure_client(self, newClient):
|
|
_logger.info("Create Cloud Structure for Client "+str(newClient.id)+" - "+str(newClient.cloudlink))
|
|
cloudpath = str(newClient.cloudlink)
|
|
client = Client("https://cloud.logumedia.de/remote.php/dav/files/OdooDav/", auth=("odooClient@logumedia.de", "lm2020#OdooDav"))
|
|
_logger.info("Neuer Cloud Path : "+str(cloudpath))
|
|
try:
|
|
#client.mkdir(new_folder)
|
|
#_logger.info("Make Cloud Path : "+str(new_folder))
|
|
_logger.info("Create Standard Cloud Structure for Client "+str(newClient.id)+" - "+str(newClient.cloudlink))
|
|
client.copy(newClient.project_grundsystem_typ_cloud_contract_template+'/',cloudpath)
|
|
_logger.info("Make Standard Cloud Path : "+str(cloudpath+'/'+str(newClient.project_grundsystem_typ_cloud_contract_template)))
|
|
except Exception as e:
|
|
_logger.info("Make Cloud Path error : "+str(e))
|
|
return True
|
|
|
|
|
|
def createcontract(self,template):
|
|
newid = template
|
|
newClient = self.env['dss.contracts'].search([('id','=',newid)])
|
|
dsscontracts.create_cloud_structure_client(self,newClient)
|
|
_logger.info('Neu angelegt : '+str(self.id)+' - '+str(self.contract_name)+' - '+str(self.client_id))
|
|
action = self.env['ir.actions.act_window'].with_context({'default_projectid': self.id})._for_xml_id('DigitalSignage.action_open_create_contract_new_edit')
|
|
action['domain'] = '[["id","=","'+str(newid)+'"]]'
|
|
action['res_id'] = newid
|
|
return action
|
|
|
|
|
|
def py_jump_last_ad(self):
|
|
for record in self:
|
|
self.tokampagne()
|
|
|
|
def _track_template(self, changes):
|
|
res = super()._track_template(changes)
|
|
self.trigger_track_template(changes, self)
|
|
return res
|
|
|
|
|
|
def py_open_contract_form_view(self):
|
|
return {'name': 'Budget Edit',
|
|
'domain': [],
|
|
'res_model': 'dss.contracts',
|
|
'type': 'ir.actions.act_window',
|
|
'view_mode': 'form',
|
|
'view_type': 'form',
|
|
'res_id': self.id,
|
|
# 'target': 'new',
|
|
}
|
|
|
|
def pyaction_vnoxx_action1(self):
|
|
return ""
|
|
|
|
def pyaction_vnoxx_action2(self):
|
|
return ""
|
|
|
|
def pyaction_vnoxx_action3(self):
|
|
return ""
|
|
|
|
def pyaction_dss_contract_update_partner(self):
|
|
self.client.company_name = self.client_short_company
|
|
self.client.dsspartner_vorname = self.client_short_vorname
|
|
self.client.dsspartner_name = self.client_short_name
|
|
self.client.dsspartner = True,
|
|
self.client.dsspartner_werbung = True
|
|
self.client.street = self.client_short_strasse
|
|
self.client.city = self.client_short_ort
|
|
self.client.zip = self.client_short_plz
|
|
self.client.phone = self.client_short_telefon
|
|
self.client.mobile = self.client_short_mobil
|
|
self.client.email = self.client_short_email
|
|
|
|
def pyaction_dss_contract_update_short_from_partner(self):
|
|
self.client_short_company=self.client.company_name
|
|
self.client_short_vorname=self.client.dsspartner_vorname
|
|
self.client_short_name=self.client.dsspartner_name
|
|
self.client_short_strasse=self.client.street
|
|
self.client_short_ort=self.client.city
|
|
self.client_short_plz=self.client.zip
|
|
self.client_short_telefon=self.client.phone
|
|
self.client_short_mobil=self.client.mobile
|
|
self.client_short_email=self.client.email
|
|
|
|
|
|
def buildText(self):
|
|
_logger.info('Build Text for Contract : C_'+str(self.id))
|
|
|
|
if self.project_id:
|
|
projekt_id = self.project_id
|
|
else:
|
|
projekt_id = '000'
|
|
|
|
if self.project_name:
|
|
projekt = self.project_name
|
|
else:
|
|
projekt = 'Unbekannt'
|
|
|
|
if self.contract_name:
|
|
vertrag_name = self.contract_name
|
|
else:
|
|
vertrag_name = 'Unbekannt'
|
|
|
|
if self.contract_auto_id:
|
|
vertrag_id = self.contract_auto_id
|
|
else:
|
|
vertrag_id = 'XXXXX'
|
|
|
|
if self.client_short_vorname:
|
|
vname = self.client_short_vorname
|
|
else:
|
|
vname = 'Unbekannt'
|
|
|
|
if self.client_short_name:
|
|
name = self.client_short_name
|
|
else:
|
|
name = 'Unbekannt'
|
|
|
|
if self.client_short_strasse:
|
|
vstrasse = self.client_short_strasse
|
|
else:
|
|
vstrasse = 'Unbekannt'
|
|
|
|
if self.client_short_plz:
|
|
vplz = self.client_short_plz
|
|
else:
|
|
vplz = '00000'
|
|
|
|
if self.client_short_ort:
|
|
vort = self.client_short_ort
|
|
else:
|
|
vort = 'unbekannt'
|
|
|
|
vplz_vort = '%s %s' % (vplz,vort)
|
|
|
|
if self.client_short_email:
|
|
vemail = 'ist per Email über %s zu erreichen' % (self.client_short_email)
|
|
else:
|
|
vemail = 'ist nicht per Email zu erreichbar'
|
|
|
|
if self.client_short_telefon:
|
|
vtelefon = 'ist per Telefon unter %s zu erreichen' % (self.client_short_telefon)
|
|
else:
|
|
vtelefon = 'ist nicht per Telefon zu erreichen'
|
|
|
|
if self.client_short_mobil:
|
|
vmobil = 'ist per Mobiltelefon unter %s zu erreichen' % (self.client_short_mobil)
|
|
else:
|
|
vmobil = 'ist nicht per Mobiltelefon zu erreichen'
|
|
|
|
textprojekt= 'Es ist im Projekt %s_%s ' % (projekt_id,projekt)
|
|
|
|
vertragkopftext = 'ein Vertrag mit der Kundennummer %s und der Vertragskennung %s.' % (vertrag_id,vertrag_name)
|
|
|
|
kundentext = 'Dieser Kunde heisst %s %s und wohnt in der %s in %s. Der Kunde %s und %s und %s' % (vname,name,vstrasse,vplz_vort,vemail,vtelefon,vmobil)
|
|
|
|
if self.client_short_mobil:
|
|
vmobil = 'ist per Mobiltelefon unter %s zu erreichen' % (self.client_short_mobil)
|
|
else:
|
|
vmobil = 'ist nicht per Mobiltelefon zu erreichen'
|
|
|
|
if self.start_date:
|
|
startzeit = self.start_date.strftime('%d.%m.%Y')
|
|
else:
|
|
startzeit = 'unbekannt'
|
|
|
|
if self.contract_date:
|
|
startzeit = self.contract_date.strftime('%d.%m.%Y')
|
|
|
|
if self.runtime_finish:
|
|
if self.runtime_finish < date.today():
|
|
endzeit = 'Er ist bereits abgelaufen am %s' % (self.runtime_finish.strftime('%d.%m.%Y'))
|
|
else:
|
|
endzeit = 'Er endet am %s' % (self.runtime_finish.strftime('%d.%m.%Y'))
|
|
else:
|
|
endzeit = 'unbekannt'
|
|
|
|
laufzeitmodel = 'Laufzeitmodell unbekannt'
|
|
if self.runtimesystem == 'M':
|
|
laufzeitmodel = 'eine monatliche Laufzeit mit %s Monaten und %s Monaten Bonus' % (self.runtime_m,self.runtime_bonus_m)
|
|
elif self.runtimesystem == 'T':
|
|
laufzeitmodel = 'eine tägliche Laufzeit mit %s Tagen ' % (self.runtime_t)
|
|
elif self.runtimesystem == 'E':
|
|
laufzeitmodel = 'eine ereignisabhängige Laufzeit mit %s Ereignissen' % (len(self.runtime_events))
|
|
elif self.runtimesystem == 'S':
|
|
if self.runtime_finish:
|
|
laufzeitmodel = 'ein stichtagsabhängig Laufzeit bis zum %s' % (self.runtime_finish.strftime('%d.%m.%Y'))
|
|
else:
|
|
laufzeitmodel = 'ein stichtagsabhängig Laufzeit unbekannt'
|
|
|
|
kuendigungsfrist = 'Die Kündigungsfrist beträgt %s Monate' % (self.contract_cancel_mon)
|
|
if self.contract_cancel_date:
|
|
kuendigungsfrist = 'Die Kündigungsfrist beträgt %s Monate und endet am %s' % (self.contract_cancel_mon,self.contract_cancel_date.strftime('%d.%m.%Y'))
|
|
if self.contract_cancel_date < date.today():
|
|
kuendigungsfrist = 'Die Kündigungsfrist beträgt %s Monate und endet am %s' % (self.contract_cancel_mon,self.contract_cancel_date.strftime('%d.%m.%Y'))
|
|
|
|
|
|
vertragtext = 'Der Vertrag hat die Vertragskennung %s und ist am %s begonnen. Der Vertrag hat %s . %s. %s' % (vertrag_id,startzeit,laufzeitmodel,endzeit,kuendigungsfrist)
|
|
|
|
|
|
text = textprojekt + " "+vertragkopftext + kundentext + '. '+ vertragtext
|
|
|
|
|
|
return text
|
|
raise ValidationError((text))
|
|
|
|
_logger.info('Build Text for Contract : C_'+str(self.id)+' - '+str(text))
|
|
return text
|
|
|
|
def buildallText(self):
|
|
_logger.info('Build all Text for Contract : C_'+str(self))
|
|
if self and "all" in str(self[0]):
|
|
self = self.env['dss.contracts'].search([])
|
|
if not self:
|
|
raise ValidationError(_("The first record contains 'all' in its string representation."))
|
|
|
|
all_contract_text = ''
|
|
contracts = []
|
|
for record in self:
|
|
_logger.info('Build Text for Contract : C_'+str(record.id))
|
|
singletext = ' Ein Vertrag mit der ID '+str(record.id)+': '+record.buildText()
|
|
contracts += [singletext]
|
|
_logger.info('Build Text for Contract : C_'+str(record.id)+' - '+str(singletext))
|
|
all_contract_text += singletext
|
|
|
|
#raise ValidationError((all_contract_text))
|
|
return contracts
|
|
|
|
@api.model
|
|
def newwizzard(self,id):
|
|
project = self.env['dss.projects'].search([('id', '=', id)], limit=1)
|
|
_logger.info("Create new Contract Wizard - Project : "+str(project))
|
|
action = self.env["ir.actions.actions"]._for_xml_id("DigitalSignage.action_open_create_contract")
|
|
action['context'] = {'default_project': project.id}
|
|
|
|
|
|
return action
|