"Accept" : "application/json, text/javascript, */*; q=0.01",

"Content-Type": "application/x-www-form-urlencoded",

"Accept-Language" : "fr,fr-FR;q=0.8,en;q=0.6",

"User-Agent" : "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:59.0) Gecko/20100101 Firefox/59.0"

# boolean: to check that we are started, to prevent error messages when disabling or restarting the plugin

isStarted = None

# object: http connection

httpConn = None

# integer: index of the Linky device

iIndexUnit = 1

# string: name of the Linky device

sDeviceName = "Linky"

# string: description of the Linky device

sDescription = "Compteur Linky"

# integer: type (pTypeGeneral)

iType = 0xF3

# integer: subtype (sTypeManagedCounter)

iSubType = 0x21

# integer: switch type (Energy)

iSwitchType = 0

# string: step name of the state machine

sConnectionStep = None

# boolean: true if a step failed

bHasAFail = None

# dict: cookies

dCookies = None

# datetime: start date for short log

dateBeginHours = None

# datetime: end date for short log

dateEndHours = None

# datetime: start date for history

dateBeginDays = None

# datetime: end date for history

dateEndDays = None

# integer: number of days of data to grab for short log

iHistoryDaysForHoursView = None

# integer: number of days of data to grab for history

iHistoryDaysForDaysView = None

# integer: number of days left fot next batch of data

iDaysLeft = None

# datetime: backup end date

savedDateEndDays = None

# boolean: is this the batch of the most recent history

bFirstMonths = None

# string: username for Enedis website

sUser = None

# string: password for Enedis website

sPassword = None

# string: consumption to show = current week ("week"), the previous week ("lweek", the current month ("month"), the previous month ("lmonth"), or year ("year")

sConsumptionType = None

# boolean: auto accept terms

bAutoAcceptTerms = None

# integer: number of days for hours view

iHistoryDaysForHoursView = None

# integer: number of other view

iHistoryDaysForDaysView = None

# boolean: debug mode

iDebugLevel = None

# previous day

pday = None

# first day of month

fdmonth = None

# last day of previous month

ldpmonth = None

# first day of previous month

fdpmonth = None

# first day of week

fdweek = None

# last day of previous week

ldpweek = None

# first day of previous week

fdpweek = None

# first day of year

fdyear = None

def __init__(self):

self.isStarted = False

self.httpConn = None

self.sConnectionStep = "idle"

self.bHasAFail = False

def myDebug(self, message):

if self.iDebugLevel:

Domoticz.Log(message)

# Reset saved cookies

def resetCookies(self):

self.dCookies = {}

# Grab cookies found in Data["Headers"] and saves them for later user

def getCookies(self, Data):

if Data and ("Headers" in Data) and ("Set-Cookie" in Data["Headers"]):

# lCookies = re.findall("^(.*?)=(.*?)[;$]", Data["Headers"]["Set-Cookie"], re.MULTILINE)

cookiesLines = Data["Headers"]["Set-Cookie"]

# on old version of Domoticz, cookies is a multiline string

if isinstance(cookiesLines, str):

cookiesLines = cookiesLines.splitlines()

# for match in re.finditer("^(.*?)=(.*?)[;$]", Data["Headers"]["Set-Cookie"], re.MULTILINE):

for sCookiesLine in cookiesLines:

for match in re.finditer("^(.*?)=(.*?)[;$]", sCookiesLine):

self.dCookies[match.group(1)] = match.group(2)

# Write saved cookies in headers["Cookie"]

def setCookies(self, headers):

headers["Cookie"] = ""

for sKey, sValue in self.dCookies.items():

# Concatenate cookies

if headers["Cookie"]:

headers["Cookie"] += "; "

headers["Cookie"] += sKey + "=" + sValue

# get default headers

def initHeaders(self):

return dict(HEADERS)

# send login details though http connection

def login(self, username, password):

payload = {

'IDToken1': username,

'IDToken2': password,

'SunQueryParamsString': b64encode(b'realm=particuliers').decode(),

'encoded': 'true',

'gx_charset': 'UTF-8'

}

headers = self.initHeaders()

headers["Host"] = LOGIN_BASE_URI + ":" + BASE_PORT

sendData = {

"Verb" : "POST",

"URL" : API_ENDPOINT_LOGIN,

"Headers" : headers,

"Data" : dictToQuotedString(payload)

}

#self.dumpDictToLog(sendData)

# Reset cookies to get authentication cookie later

self.resetCookies()

# Send data

self.httpConn.Send(sendData)

# accept terms of use

def acceptTerms(self):

req_part = 'lincspartdisplaycdc_WAR_lincspartcdcportlet'

payload = {

'fm': 'Accepter'

}

headers = self.initHeaders()

headers["Host"] = API_BASE_URI + ":" + BASE_PORT

#Copy cookies

self.setCookies(headers)

sendData = {

"Verb" : "POST",

"URL" : API_ACCEPT_TERMS,

"Headers" : headers,

"Data" : dictToQuotedString(payload)

}

#self.dumpDictToLog(sendData)

self.httpConn.Send(sendData)

# ask data to Enedis website, based on a resource_id ("urlCdcHeure" or "urlCdcJour") and date (max 28 days at once)

def getData(self, resource_id, start_date, end_date):

#Domoticz.Log(resource_id + " " + str(end_date))

req_part = 'lincspartdisplaycdc_WAR_lincspartcdcportlet'

payload = {

'_' + req_part + '_dateDebut': datetimeToEnedisDateString(start_date),

'_' + req_part + '_dateFin': datetimeToEnedisDateString(end_date)

}

#Domoticz.Log("getData : " + datetimeToEnedisDateString(start_date) + " " + datetimeToEnedisDateString(end_date))

headers = self.initHeaders()

headers["Host"] = API_BASE_URI + ":" + BASE_PORT

#Copy cookies

self.setCookies(headers)

params = {

'p_p_id': req_part,

'p_p_lifecycle': 2,

'p_p_state': 'normal',

'p_p_mode': 'view',

'p_p_resource_id': resource_id,

'p_p_cacheability': 'cacheLevelPage',

'p_p_col_id': 'column-1',

'p_p_col_pos': 1,

'p_p_col_count': 2

}

sendData = {

"Verb" : "POST",

"URL" : API_ENDPOINT_DATA + "?" + dictToQuotedString(params),

"Headers" : headers,

"Data" : dictToQuotedString(payload)

}

#self.dumpDictToLog(sendData)

self.httpConn.Send(sendData)

# Create Domoticz device

def createDevice(self):

# Only if not already done

if not self.iIndexUnit in Devices:

Domoticz.Device(Name=self.sDeviceName, Unit=self.iIndexUnit, Type=self.iType, Subtype=self.iSubType, Switchtype=self.iSwitchType, Description=self.sDescription, Used=1).Create()

if not (self.iIndexUnit in Devices):

Domoticz.Error("Ne peut ajouter le dispositif Linky à la base de données. Vérifiez dans les paramètres de Domoticz que l'ajout de nouveaux dispositifs est autorisé")

return False

return True

# Create device and insert usage in Domoticz DB

def createAndAddToDevice(self, usage, Date):

if not self.createDevice():

return False

# -1.0 for counter because Linky doesn't provide absolute counter value via Enedis website

sValue = "-1.0;"+ str(usage) + ";" + str(Date)

self.myDebug("Mets dans la BDD la valeur " + sValue)

Devices[self.iIndexUnit].Update(nValue=0, sValue=sValue, Type=self.iType, Subtype=self.iSubType, Switchtype=self.iSwitchType)

return True

# Update value shown on Domoticz dashboard

def updateDevice(self, usage):

if not self.createDevice():

return False

# -1.0 for counter because Linky doesn't provide absolute counter value via Enedis website

sValue="-1.0;"+ str(usage)

self.myDebug("Mets sur le tableau de bord la valeur " + sValue)

Devices[self.iIndexUnit].Update(nValue=0, sValue=sValue, Type=self.iType, Subtype=self.iSubType, Switchtype=self.iSwitchType)

return True

# Show error in state machine context

def showStepError(self, hours, logMessage):

if hours:

Domoticz.Error(logMessage + " durant l'étape " + self.sConnectionStep + " de " + datetimeToEnedisDateString(self.dateBeginHours) + " à " + datetimeToEnedisDateString(self.dateEndHours))

else:

Domoticz.Error(logMessage + " durant l'étape " + self.sConnectionStep + " de " + datetimeToEnedisDateString(self.dateBeginDays) + " à " + datetimeToEnedisDateString(self.dateEndDays))

# Grab hours data inside received JSON data for short log

def exploreDataHours(self, Data):

self.dumpDictToLog(Data)

if Data and ("Data" in Data):

try:

dJson = json.loads(Data["Data"].decode())

except ValueError as err:

self.showStepError(True, "Les données reçues ne sont pas du JSON : " + str(err))

return False

except TypeError as err:

self.showStepError(True, "Le type de données reçues n'est pas JSON : " + str(err))

return False

except:

self.showStepError(True, "Erreur dans les données JSON : " + str(sys.exc_info()[0]))

return False

else:

if dJson and ("etat" in dJson) and ("erreurText" in dJson["etat"]):

self.showStepError(True, "Erreur reçue : " + html.unescape(dJson["etat"]["erreurText"]))

if dJson and ("etat" in dJson) and ("valeur" in dJson["etat"]) and (dJson["etat"]["valeur"] == "termine"):

try:

beginDate = enedisDateToDatetime(dJson["graphe"]["periode"]["dateDebut"])

endDate = enedisDateToDatetime(dJson["graphe"]["periode"]["dateFin"])

except (TypeError, ValueError) as err:

self.showStepError(True, "Erreur dans le format de donnée de date JSON : " + str(err))

return False

except:

self.showStepError(True, "Erreur dans la donnée de date JSON : " + str(sys.exc_info()[0]) + dJson["graphe"]["periode"]["dateDebut"] + dJson["graphe"]["periode"]["dateFin"])

return False

# We accumulate data because Enedis sends kWh for every 30 minutes and Domoticz expects data only for every hour

accumulation = 0.0

currentDay = -1

steps = 1.0

dataSeenToTheEnd = False

for index, data in enumerate(dJson["graphe"]["data"]):

try:

val = float(data["valeur"]) * 1000.0

except:

val = -1.0

if (val >= 0.0):

# Shift to +1 hour for Domoticz, because bars/hours for graph are shifted to -1 hour in Domoticz, cf. constructTime() call in WebServer.cpp

# Enedis and Domoticz doesn't set the same date for used energy, add offset

curDate = beginDate + timedelta(hours=1, minutes=((index+1)*30))

#Domoticz.Log("date " + datetimeToSQLDateTimeString(curDate) + " " + datetimeToSQLDateTimeString(endDate))

accumulation = accumulation + val

#Domoticz.Log("Value " + str(val) + " " + datetimeToSQLDateTimeString(curDate))

if curDate.minute == 0:

# Check that we had enough data, as expected

if curDate >= endDate:

#Domoticz.Log("Last val")

dataSeenToTheEnd = True

#Domoticz.Log("accumulation " + str(accumulation / steps) + " " + datetimeToSQLDateTimeString(curDate))

if not self.createAndAddToDevice(accumulation / steps, datetimeToSQLDateTimeString(curDate)):

return False

accumulation = 0.0

steps = 0.0

steps = steps + 1.0

if not dataSeenToTheEnd:

self.showStepError(True, "Données manquantes")

return dataSeenToTheEnd

elif dJson and ("etat" in dJson) and ("valeur" in dJson["etat"]):

self.showStepError(True, "Erreur à la réception de données JSON (code : " + str(dJson["etat"]["valeur"]) + ")")

else:

self.showStepError(True, "Erreur à la réception de données JSON")

else:

self.showStepError(True, "Aucune donnée reçue")

return False

def resetDayAccumulate(self, endDate):

self.pday = endDate.replace(hour=0, minute=0, second=0, microsecond=0)

endDate = self.pday + timedelta(days=1)

self.daysAccumulate = 0.0

self.fdmonth = endDate.replace(day=1)

self.ldpmonth = self.fdmonth - timedelta(days=1)

self.fdpmonth = self.ldpmonth.replace(day=1)

self.fdweek = endDate - timedelta(days=endDate.weekday())

self.ldpweek = self.fdweek - timedelta(days=1)

self.fdpweek = self.ldpweek - timedelta(days=6)

self.fdyear = endDate.replace(day=1,month=1)

#Domoticz.Log(str(endDate) + " " + str(self.fdmonth) + " " + str(self.ldpmonth) + " " + str(self.fdpmonth) + " " + str(self.fdweek) + " " + str(self.ldpweek) + " " + str(self.fdpweek) + " " + str(self.fdyear))

def dayAccumulate(self, curDate, val):

if self.sConsumptionType == "week":

if (curDate >= self.fdweek):

#Domoticz.Log(str(curDate) + " " + str(val) + " " + str(self.daysAccumulate))

self.daysAccumulate = self.daysAccumulate + val

elif self.sConsumptionType == "lweek":

if (self.fdpweek <= curDate <= self.ldpweek):

#Domoticz.Log(str(curDate) + " " + str(val) + " " + str(self.daysAccumulate))

self.daysAccumulate = self.daysAccumulate + val

elif self.sConsumptionType == "month":

if (curDate >= self.fdmonth):

#Domoticz.Log(str(curDate) + " " + str(val) + " " + str(self.daysAccumulate))

self.daysAccumulate = self.daysAccumulate + val

elif self.sConsumptionType == "lmonth":

if (self.fdpmonth <= curDate <= self.ldpmonth):

#Domoticz.Log(str(curDate) + " " + str(val) + " " + str(self.daysAccumulate))

self.daysAccumulate = self.daysAccumulate + val

elif self.sConsumptionType == "year":

if (curDate >= self.fdyear):

#Domoticz.Log(str(curDate) + " " + str(val) + " " + str(self.daysAccumulate))

self.daysAccumulate = self.daysAccumulate + val

elif curDate == self.pday:

#Domoticz.Log(str(curDate) + " " + str(self.pday) + " " + str(val) + " " + str(self.daysAccumulate))

self.daysAccumulate = val;

# Grab days data inside received JSON data for history

def exploreDataDays(self, Data):

self.dumpDictToLog(Data)

if Data and "Data" in Data:

try:

dJson = json.loads(Data["Data"].decode())

except ValueError as err:

self.showStepError(False, "Les données reçues ne sont pas du JSON : " + str(err))

return False

except TypeError as err:

self.showStepError(False, "Le type de données reçues n'est pas JSON : " + str(err))

return False

except:

self.showStepError(False, "Erreur dans les données JSON : " + str(sys.exc_info()[0]))

return False

else:

if dJson and ("etat" in dJson) and ("erreurText" in dJson["etat"]):

self.showStepError(False, "Erreur reçue : " + html.unescape(dJson["etat"]["erreurText"]))

if dJson and ("etat" in dJson) and ("valeur" in dJson["etat"]) and (dJson["etat"]["valeur"] == "termine"):

try:

beginDate = enedisDateToDatetime(dJson["graphe"]["periode"]["dateDebut"])

endDate = enedisDateToDatetime(dJson["graphe"]["periode"]["dateFin"])

except ValueError as err:

self.showStepError(False, "Erreur dans le format de donnée de date JSON : " + str(err))

return False

except:

self.showStepError(False, "Erreur dans la donnée de date JSON : " + str(sys.exc_info()[0]))

return False

for index, data in enumerate(dJson["graphe"]["data"]):

try:

val = float(data["valeur"]) * 1000.0

except:

val = -1.0

if (val >= 0.0):

curDate = beginDate + timedelta(days=index)

self.dayAccumulate(curDate, val)

#Domoticz.Log("Value " + str(val) + " " + datetimeToSQLDateString(curDate))

#self.dumpDictToLog(values)

if not self.createAndAddToDevice(val, datetimeToSQLDateString(curDate)):

return False

return True

elif dJson and ("etat" in dJson) and ("valeur" in dJson["etat"]):

self.showStepError(False, "Erreur à la réception de données JSON (code : " + str(dJson["etat"]["valeur"]) + ")")

else:

self.showStepError(False, "Erreur à la réception de données JSON")

else:

self.showStepError(False, "Aucune donnée reçue")

return False

# Update dashboard with accumulated value

def updateDashboard(self):

return self.updateDevice(self.daysAccumulate)

# Calculate days and date left for next batch

def calculateDaysLeft(self):

# No more than 28 days at once

self.iDaysLeft = self.iDaysLeft - 28

if self.iDaysLeft <= 0:

daysToGet = self.iDaysLeft + 28

else:

daysToGet = 28

self.dateBeginDays = self.savedDateEndDays - timedelta(days=daysToGet+2)

self.dateEndDays = self.savedDateEndDays - timedelta(days=1)

self.savedDateEndDays = self.dateBeginDays

#Domoticz.Log("Dates : " + datetimeToSQLDateTimeString(self.dateBeginDays) + " " + datetimeToSQLDateTimeString(self.dateEndDays) + " " + datetimeToSQLDateTimeString(self.savedDateEndDays))

# Calculate next complete grab, for tomorrow between 5 and 6 am if tomorrow is true, for next hour otherwise

def setNextConnection(self, tomorrow):

if tomorrow:

self.nextConnection = datetime.now() + timedelta(days=1)

self.nextConnection = self.nextConnection.replace(hour=5)

else:

self.nextConnection = datetime.now() + timedelta(hours = 1)

# Randomize minutes to lower load on Enedis website

#randint makes domoticz crash on RPI

#self.nextConnection = self.nextConnection + timedelta(minutes=randint(0, 59), seconds=randint(0, 59))

# We take microseconds to randomize

minutesRand = round(datetime.now().microsecond / 10000) % 60

self.nextConnection = self.nextConnection + timedelta(minutes=minutesRand)

# Handle the connection state machine

def handleConnection(self, Data = None):

# First and last step

if self.sConnectionStep == "idle":

Domoticz.Log("Récupération des données...")

# Reset failed state

self.bHasAFail = False

if self.httpConn and self.httpConn.Connected():

self.httpConn.Disconnect()

self.httpConn = Domoticz.Connection(Name="HTTPS connection", Transport="TCP/IP", Protocol="HTTPS", Address=LOGIN_BASE_URI, Port=BASE_PORT)

self.myDebug("Connect")

self.sConnectionStep = "logconnecting"

self.httpConn.Connect()

# Connected, we need to log in

elif self.sConnectionStep == "logconnecting":

if not self.httpConn.Connected():

Domoticz.Error("Connexion échouée au login")

self.sConnectionStep = "idle"

self.bHasAFail = True

else:

self.sConnectionStep = "logconnected"

self.login(self.sUser, self.sPassword)

# Connected, check that the authentication cookie has been received

elif self.sConnectionStep == "logconnected":

if self.httpConn and self.httpConn.Connected():

self.httpConn.Disconnect()

self.dumpDictToLog(Data)

# Grab cookies from received data, if we have "iPlanetDirectoryPro", we're good

self.getCookies(Data)

if ("iPlanetDirectoryPro" in self.dCookies) and self.dCookies["iPlanetDirectoryPro"]:

# Proceed to data page

self.sConnectionStep = "getcookies"

self.httpConn = Domoticz.Connection(Name="HTTPS connection", Transport="TCP/IP", Protocol="HTTPS", Address=API_BASE_URI, Port=BASE_PORT)

self.httpConn.Connect()

else:

Domoticz.Error("Login échoué, réessaiera plus tard")

self.sConnectionStep = "idle"

self.bHasAFail = True

# If we are connected, we must show the authentication cookie

elif self.sConnectionStep == "getcookies":

if not self.httpConn.Connected():

Domoticz.Error("Connexion échouée à la lecture des cookies")

self.sConnectionStep = "idle"

self.bHasAFail = True

else:

self.getCookies(Data)

self.sConnectionStep = "dataconnecting"

# Dummy action to show that we have the authentication cookie

self.getData("urlCdcJour", self.dateBeginDays, self.dateEndDays)

# We are now connected to data page, ask for hours data

elif self.sConnectionStep == "dataconnecting" or self.sConnectionStep == "dataconnecting2":

if not self.httpConn.Connected():

Domoticz.Error("Connexion échouée à la réception des premières données")

self.sConnectionStep = "idle"

self.bHasAFail = True

else:

self.getCookies(Data)

strData = ""

if Data and ("Data" in Data):

strData = Data["Data"].decode();

if "terms_of_use" in strData:

if self.bAutoAcceptTerms:

Domoticz.Status("Auto-accepting new terms of use")

self.acceptTerms()

self.sConnectionStep = "dataconnecting"

else:

Domoticz.Error("Vous devez acceptez les conditions d'utilisation en vous rendant sur https://" + LOGIN_BASE_URI)

self.sConnectionStep = "idle"

self.bHasAFail = True

else:

self.dumpDictToLog(Data)

# Dummy action again to show that we have the authentication cookie

if self.sConnectionStep == "dataconnecting":

self.sConnectionStep = "dataconnecting2"

else:

self.sConnectionStep = "getdatadays"

self.resetDayAccumulate(self.dateEndDays)

# Ask data for days

self.getData("urlCdcJour", self.dateBeginDays, self.dateEndDays)

# Now we should received data for real

elif self.sConnectionStep == "getdatadays":

if not self.httpConn.Connected():

self.showStepError(False, "Récupération des données pour la vue par jours")

self.sConnectionStep = "idle"

self.bHasAFail = True

else:

# Analyse data for days

if not self.exploreDataDays(Data):

self.bHasAFail = True

if self.iDaysLeft > 0:

self.calculateDaysLeft()

self.sConnectionStep = "getdatadays"

self.getData("urlCdcJour", self.dateBeginDays, self.dateEndDays)

else:

if not self.updateDashboard():

self.bHasAFail = True

# user set Mode1 to 0, he doesn't want to grab hours data

if self.iHistoryDaysForHoursView < 1:

self.sConnectionStep = "idle"

Domoticz.Log("Done")

else:

self.sConnectionStep = "getdatahours"

self.getData("urlCdcHeure", self.dateBeginHours, self.dateEndHours)

# Ask data for hours

elif self.sConnectionStep == "getdatahours":

if not self.httpConn.Connected():

self.showStepError(True, "Récupération des données pour la vue par heures")

self.sConnectionStep = "idle"

self.bHasAFail = True

else:

# Analyse data for hours

if not self.exploreDataHours(Data):

self.bHasAFail = True

self.sConnectionStep = "idle"

Domoticz.Log("Fait")

# Next connection time depends on success

if self.sConnectionStep == "idle":

if self.bHasAFail:

self.setNextConnection(False)

Domoticz.Log("Prochaine connexion : " + datetimeToSQLDateTimeString(self.nextConnection))

def dumpDictToLog(self, dictToLog):

if self.iDebugLevel:

if isinstance(dictToLog, dict):

self.myDebug("Dict details ("+str(len(dictToLog))+"):")

for x in dictToLog:

if isinstance(dictToLog[x], dict):

self.myDebug("--->'"+x+" ("+str(len(dictToLog[x]))+"):")

for y in dictToLog[x]:

if isinstance(dictToLog[x][y], dict):

for z in dictToLog[x][y]:

self.myDebug("----------->'" + z + "':'" + str(dictToLog[x][y][z]) + "'")

else:

self.myDebug("------->'" + y + "':'" + str(dictToLog[x][y]) + "'")

else:

self.myDebug("--->'" + x + "':'" + str(dictToLog[x]) + "'")

else:

self.myDebug("Received no dict: " + str(dictToLog))

def onStart(self):

self.myDebug("onStart called")

Domoticz.Log("Ce plugin est compatible avec Domoticz version 3.9517 et plus récent, mais la vue par heure peut ne pas fonctionner avec la version 4.9700")

self.sUser = Parameters["Username"]

self.sPassword = Parameters["Password"]

self.iHistoryDaysForHoursView = Parameters["Mode1"]

self.iHistoryDaysForDaysView = Parameters["Mode2"]

self.bAutoAcceptTerms = Parameters["Mode4"] == "True"

self.sConsumptionType = Parameters["Mode5"]

try:

self.iDebugLevel = int(Parameters["Mode3"])

except ValueError:

self.iDebugLevel = 0

if self.iDebugLevel > 1:

Domoticz.Debugging(1)

# History for short log is 7 days max (default to 7)

try:

self.iHistoryDaysForHoursView = int(self.iHistoryDaysForHoursView)

except:

self.iHistoryDaysForHoursView = 7

if self.iHistoryDaysForHoursView < 0:

self.iHistoryDaysForHoursView = 0

elif self.iHistoryDaysForHoursView > 7:

self.iHistoryDaysForHoursView = 7

# History for short log is 7 days max (default to 366)

try:

self.iHistoryDaysForDaysView = int(self.iHistoryDaysForDaysView)

except:

self.iHistoryDaysForDaysView = 366

if self.iHistoryDaysForDaysView < 28:

self.iHistoryDaysForDaysView = 28

elif self.iHistoryDaysForDaysView > 100000:

self.iHistoryDaysForDaysView = 100000

if (self.sConsumptionType == "month") and (self.iHistoryDaysForDaysView < 32) :

self.iHistoryDaysForDaysView = 32

if (self.sConsumptionType == "lmonth") and (self.iHistoryDaysForDaysView < 63) :

self.iHistoryDaysForDaysView = 63

if (self.sConsumptionType == "year") and (self.iHistoryDaysForDaysView < 366) :

self.iHistoryDaysForDaysView = 366

Domoticz.Log("Adresse e-mail mise à " + self.sUser)

if self.sPassword:

Domoticz.Log("Mot de passe entré")

else:

Domoticz.Log("Mot de passe laissé vide")

Domoticz.Log("Consommation à montrer sur le tableau de bord mis à " + self.sConsumptionType)

Domoticz.Log("Accepter automatiquement les conditions d'utilisation mis à " + str(self.bAutoAcceptTerms))

Domoticz.Log("Nombre de jours à récupérer pour la vue par heures mis à " + str(self.iHistoryDaysForHoursView))

Domoticz.Log("Nombre de jours à récupérer pour les autres vues mis à " + str(self.iHistoryDaysForDaysView))

Domoticz.Log("Debug mis à " + str(self.iDebugLevel))

# most init

self.__init__()

Domoticz.Log("Si vous ne voyez pas assez de données dans la vue par heures, augmentez le paramètre Log des capteurs qui se trouve dans Réglages / Paramètres / Historique des logs")

if self.createDevice():

self.nextConnection = datetime.now()

else:

self.setNextConnection(False)

# Now we can enabling the plugin

self.isStarted = True

def onStop(self):

Domoticz.Debug("onStop called")

# prevent error messages during disabling plugin

self.isStarted = False

def onConnect(self, Connection, Status, Description):

Domoticz.Debug("onConnect called")

if self.isStarted and (Connection == self.httpConn):

self.handleConnection()

def onMessage(self, Connection, Data):

Domoticz.Debug("onMessage called")

# if started and not stopping

if self.isStarted and (Connection == self.httpConn):

self.handleConnection(Data)

def onDisconnect(self, Connection):

Domoticz.Debug("onDisconnect called")

def onHeartbeat(self):

Domoticz.Debug("onHeartbeat() called")

if datetime.now() > self.nextConnection:

#self.savedDateEndDays = self.nextConnection

self.savedDateEndDays = datetime.combine(self.nextConnection, time.min)

# We immediatly program next connection for tomorrow, if there is a problem, we will reprogram it sooner

self.setNextConnection(True)

self.dateBeginHours = self.savedDateEndDays - timedelta(days=self.iHistoryDaysForHoursView)

self.dateEndHours = self.savedDateEndDays

#Domoticz.Log("Hours : " + datetimeToSQLDateTimeString(self.savedDateEndDays) + " " + datetimeToSQLDateTimeString(self.dateBeginHours) + " " + datetimeToSQLDateTimeString(self.dateEndHours))

self.iDaysLeft = self.iHistoryDaysForDaysView

self.calculateDaysLeft()

result = ""

for sKey, sValue in dParams.items():

if result:

result += "&"

result += sKey + "=" + quote(str(sValue))

for x in Parameters:

if Parameters[x] != "":

self.myDebug( "'" + x + "':'" + str(Parameters[x]) + "'")

self.myDebug("Device count: " + str(len(Devices)))

for x in Devices:

self.myDebug("Device: " + str(x) + " - " + str(Devices[x]))

self.myDebug("Device ID: '" + str(Devices[x].ID) + "'")

self.myDebug("Device Name: '" + Devices[x].Name + "'")

self.myDebug("Device iValue: " + str(Devices[x].iValue))

self.myDebug("Device sValue: '" + Devices[x].sValue + "'")

self.myDebug("Device LastLevel: " + str(Devices[x].LastLevel))

#Buggy

#return datetime.strptime(datetimeStr, "%d/%m/%Y")

#Not buggy ?