# !/usr/bin/env python
from random import randint
import thread

import web, json, time, re
import gv # Get access to ospy's settings
import urllib, urllib2
from urls import urls # Get access to ospy's URLs
from gpio_pins import set_output
from ospy import template_render
from webpages import ProtectedPage

urls.extend(['/wa', 'plugins.weather_adj.settings', '/wj', 'plugins.weather_adj.settings_json', '/uwa', 'plugins.weather_adj.update']) # Add a new url to open the data entry page.
gv.plugin_menu.append(['Weather-based Rain Delay', '/wa']) # Add this plugin to the home page plugins menu

def weather_to_delay(run_loop=False):
    if run_loop:
        time.sleep(randint(3, 10)) # Sleep some time to prevent printing before startup information

    while True:
        data = get_weather_options()
        if data["auto_delay"] != "off":
            print("Checking rain status...")
            weather = get_weather_data() if data['weather_provider'] == "yahoo" else get_wunderground_weather_data()
            delay = code_to_delay(weather["code"])
            if delay > 0:
                print("Rain detected: " + weather["text"] + ". Adding delay of " + str(delay))
                gv.sd['rd'] = float(delay)
                gv.sd['rdst'] = gv.now + gv.sd['rd'] * 3600 + 1 # +1 adds a smidge just so after a round trip the display hasn't already counted down by a minute.
                stop_onrain()
            elif delay == 0:

from urls import urls  # Get access to ospi's URLs
from ospy import template_render
from webpages import ProtectedPage
from helpers import get_rpi_revision

# I2C bus Rev Raspi RPI=1 rev1 RPI=0 rev0 
try:
    import smbus  # for PCF 8591
    ADC = smbus.SMBus(1 if get_rpi_revision() >= 2 else 0)
except ImportError:
    ADC = None

# Add a new url to open the data entry page.
urls.extend(['/pcf', 'plugins.pcf_8591_adj.settings',
             '/pcfj', 'plugins.pcf_8591_adj.settings_json',
             '/pcfa', 'plugins.pcf_8591_adj.update',
             '/pcfl', 'plugins.pcf_8591_adj.pcf_log',
             '/pcfr', 'plugins.pcf_8591_adj.delete_log'])

# Add this plugin to the home page plugins menu
gv.plugin_menu.append(['PCF8591 voltage and temperature settings ', '/pcf'])

################################################################################
# Main function loop:                                                          #
################################################################################


class PCFSender(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.daemon = True

import gv  # Get access to ospi's settings, gv = global variables
from urls import urls  # Get access to ospi's URLs
from ospi import template_render
from webpages import ProtectedPage

gv.use_gpio_pins = False  # Signal OSPi to not use GPIO pins

# Load the Raspberry Pi GPIO (General Purpose Input Output) library
try:
    import RPi.GPIO as GPIO
except IOError:
    pass

# Add a new url to open the data entry page.
urls.extend(['/rb', 'plugins.relay_board.settings',
	'/rbj', 'plugins.relay_board.settings_json',
	'/rbu', 'plugins.relay_board.update']) 

# Add this plugin to the home page plugins menu
gv.plugin_menu.append(['Relay Board', '/rb'])

params = {}

# Read in the parameters for this plugin from it's JSON file
def load_params():
    global params
    try:
        with open('./data/relay_board.json', 'r') as f:  # Read the settings from file
            params = json.load(f)
    except IOError: #  If file does not exist create file with defaults.
        params = {

""" SIP plugin uses mqtt plugin to broadcast station status every time it changes.
"""
__author__ = "Daniel Casner <[email protected]>"

import web  # web.py framework
import gv  # Get access to SIP's settings
from urls import urls  # Get access to SIP's URLs
from sip import template_render  #  Needed for working with web.py templates
from webpages import ProtectedPage  # Needed for security
from blinker import signal # To receive station notifications
import json  # for working with data file
from plugins import mqtt

# Add new URLs to access classes in this plugin.
urls.extend([
    '/zone2mqtt-sp', 'plugins.mqtt_zones.settings',
    '/zone2mqtt-save', 'plugins.mqtt_zones.save_settings'
    ])
gv.plugin_menu.append(['MQTT zone broadcaster', '/zone2mqtt-sp'])

class settings(ProtectedPage):
    """Load an html page for entering plugin settings.
    """
    def GET(self):
        settings = mqtt.get_settings()
        zone_topic = settings.get('zone_topic', gv.sd[u'name'] + '/zones')
        return template_render.mqtt_zones(zone_topic, "")  # open settings page

class save_settings(ProtectedPage):
    """Save user input to json file.
    Will create or update file when SUBMIT button is clicked
    CheckBoxes only appear in qdict if they are checked.

    return float(s)
  except:
    return 0

def mkdir_p(path):
    try:
        os.makedirs(path)
    except OSError as exc:  # Python >2.5
        if exc.errno == errno.EEXIST and os.path.isdir(path):
            pass
        else:
            raise

# Add a new url to open the data entry page.
urls.extend(['/lwa',  'plugins.weather_level_adj.settings',
             '/lwj',  'plugins.weather_level_adj.settings_json',
             '/luwa', 'plugins.weather_level_adj.update'])

# Add this plugin to the home page plugins menu
gv.plugin_menu.append(['Weather-based Water Level', '/lwa'])


################################################################################
# Main function loop:                                                          #
################################################################################

class WeatherLevelChecker(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.daemon = True
        self.start()

#!/usr/bin/env python

import web, json, time
import gv  # Get access to ospi's settings
from urls import urls  # Get access to ospi's URLs

try:
    from apscheduler.scheduler import (
        Scheduler,
    )  # This is a non-standard module. Needs to be installed in order for this feature to work.
except ImportError:
    print "The Python module apscheduler could not be found."
    pass

urls.extend(
    ["/ma", "plugins.monthly_adj.monthly_percent", "/uma", "plugins.monthly_adj.update_percents"]
)  # Add a new url to open the data entry page.

gv.plugin_menu.append(["Monthly Adjust", "/ma"])  # Add this plugin to the home page plugins menu

try:
    sched = Scheduler()
    sched.start()  # Start the scheduler
except NameError:
    pass


def set_wl():
    """Adjust irrigation time by percent based on historical climate data."""
    f = open("./data/levels.json", "r")  # Read the monthly percentages from file
    levels = json.load(f)

#!/usr/bin/env python

import web, json, time
import gv # Get access to ospi's settings
from urls import urls # Get access to ospi's URLs
try:
    from apscheduler.scheduler import Scheduler #This is a non-standard module. Needs to be installed in order for this feature to work.
except ImportError:
    pass

urls.extend(['/ma', 'plugins.monthly_adj.monthly_percent', '/uma', 'plugins.monthly_adj.update_percents']) # Add a new url to open the data entry page.
try:
    sched = Scheduler()
    sched.start() # Start the scheduler
except NameError:
    pass    
 
def set_wl():
    """Adjust irrigation time by percent based on historical climate data.""" 
    f = open('./data/levels.json', 'r') # Read the monthly percentages from file
    levels = json.load(f)
    f.close()
    mon = time.localtime().tm_mon # Get current month.
    gv.sd['wl'] = levels[mon-1] # Set the water level% (levels list is zero based).
    print 'Setting water level to {}%'.format(gv.sd['wl'])
    return

class monthly_percent:
    """Load an html page for entering monthly irrigation time adjustments"""
    def __init__(self):
        self.render = web.template.render('templates/')

    daysWatched = d
    metrics=m
    return
    
try:
    from apscheduler.scheduler import Scheduler #This is a non-standard module. Needs to be installed in order for this feature to work.
except ImportError:
    pass

try:
    sched = Scheduler()
    sched.start() # Start the scheduler
except NameError:
    pass    

urls.extend(['/auto', 'plugins.auto_program.auto_program', '/uap', 'plugins.auto_program.update_auto_program', '/rap', 'plugins.auto_program.start_auto_program']) # Add a new url to open the data entry page
gv.plugin_menu.append(['Auto-Program', '/auto']) # Add this plugin to the home page plugins menu
    
def runAutoProgram():
    global daysWatched
    global metrics
    days=[0,0]
    zone_history=[]

    wx_settings.checkRain()
    if not gv.sd['en']: return # check operation status
    if gv.sd['rd'] or (gv.sd['urs'] and gv.sd['rs']): # If rain delay or rain detected by sensor then exit
        return

    # this routine will create a new program for today based on historical rainfall total and last 7 day watering
    try:

import thread
import json
import time

import web
import gv  # Get access to sip's settings
from urls import urls  # Get access to sip's URLs
from sip import template_render
from webpages import ProtectedPage


# Add a new url to open the data entry page.
urls.extend([
    '/cama', 'plugins.california_monthly.monthly_percent',
    '/cauma', 'plugins.california_monthly.update_percents',
    '/cacalcma', 'plugins.california_monthly.calc_percents'
])

# Add this plugin to the home page plugins menu
gv.plugin_menu.append(['California Monthly', '/cama'])


def set_wl(run_loop=False):
    """Adjust irrigation time by percent based on historical California climate data."""
    if run_loop:
        time.sleep(2)  # Sleep some time to prevent printing before startup information

    last_month = 0
    while True:
        try:

from blinker import signal
import web, json, time
import gv  # Get access to ospi's settings, gv = global variables
from urls import urls  # Get access to ospi's URLs
from ospi import template_render
from webpages import ProtectedPage
import picamera
from time import sleep
import os
import errno

# Add a new url to open the data entry page.
urls.extend(['/ca', 'plugins.camera.settings',
	'/caj', 'plugins.camera.settings_json',
	'/cau', 'plugins.camera.update',
        '/cap', 'plugins.camera.pic', 
        '/captz', 'plugins.camera.ptz']) 

# Add this plugin to the home page plugins menu
gv.plugin_menu.append(['Camera', '/ca'])

params = {}

# Read in the parameters for this plugin from it's JSON file
def load_params():
    global params
    try:
        with open('./data/camera.json', 'r') as f:  # Read the settings from file
            params = json.load(f)
    except IOError: #  If file does not exist create file with defaults.

load_params()
image_path = os.path.join('.', 'static', 'images')

try:
    os.makedirs(image_path)
except OSError as exc:  # Python >2.5
    if exc.errno == errno.EEXIST and os.path.isdir(image_path):
        pass
    else:
        raise

try:
    # Add a new url to open the data entry page if camera working
    if 'plugins.camera' not in urls:
        urls.extend(['/ca', 'plugins.camera.view_camera',
            '/cau', 'plugins.camera.change_camera',
            '/cap', 'plugins.camera.pic', 
            '/captz', 'plugins.camera.ptz']) 

        # Add this plugin to the home page plugins menu
        gv.plugin_menu.append(['Camera', '/ca'])

    take_picture('camera.jpg')

except:
    pass

zones = signal('zone_change')
zones.connect(on_zone_change)

################################################################################
# Web pages:                                                                   #

import web
import gv  # Get access to ospi's settings
from urls import urls  # Get access to ospi's URLs
from ospi import template_render
from webpages import ProtectedPage, WebPage, load_and_save_remote, message_base, validate_remote, get_ip_to_base
from helpers import jsave, get_ip, read_log, reboot, get_remote_sensor_boards, update_upnp, update_hostname, update_tza, mkdir_p
from system_update import checker as updatechecker
import subprocess

disable_substations = False
# Add a new url to open the data entry page.  DO THIS AFTER possible error exit in initialize_fm_pins()
if 'plugins.substations' not in urls:
    if gv.sd['master']:
        urls.extend(['/suslv',  'plugins.substations.view_substations',
                     '/suslj',  'plugins.substations.join_master',
                     '/susde',  'plugins.substations.delete_substation',
                     '/suset',  'plugins.substations.set_substation',
                     '/susle',  'plugins.substations.execute_substation'])
    if gv.sd['slave']:
        urls.extend(['/susldr',  'plugins.substations.slave_data_request'])
        urls.extend(['/suiface',  'plugins.substations.slave_iface'])

    urls.extend(['/surrsd',  'plugins.substations.receive_remote_sensor_data'])
    urls.extend(['/surzd',  'plugins.substations.remote_zone_data'])

    if not gv.sd['slave'] and not gv.sd['master']:
        disable_substations = True

    # Add this plugin to the home page plugins menu
    #gv.plugin_menu.append(['Substations', '/sua'])

import json
import time

import web
import gv  # Get access to ospi's settings
from urls import urls  # Get access to ospi's URLs
from ospi import template_render
from webpages import ProtectedPage


# Add a new url to open the data entry page.
urls.extend(
    [
        "/cama",
        "plugins.california_monthly.monthly_percent",
        "/cauma",
        "plugins.california_monthly.update_percents",
        "/cacalcma",
        "plugins.california_monthly.calc_percents",
    ]
)

# Add this plugin to the home page plugins menu
gv.plugin_menu.append(["California Monthly", "/cama"])


def set_wl(run_loop=False):
    """Adjust irrigation time by percent based on historical California climate data."""
    if run_loop:
        time.sleep(2)  # Sleep some time to prevent printing before startup information

    last_month = 0

# !/usr/bin/env python
from random import randint
import thread
import json
import time

import web
import gv  # Get access to ospy's settings
from urls import urls  # Get access to ospy's URLs
from ospy import template_render
from webpages import ProtectedPage


# Add a new url to open the data entry page.
urls.extend(['/ma', 'plugins.monthly_adj.monthly_percent', '/uma', 'plugins.monthly_adj.update_percents'])

# Add this plugin to the home page plugins menu
gv.plugin_menu.append(['Monthly Adjust', '/ma'])


def set_wl(run_loop=False):
    """Adjust irrigation time by percent based on historical climate data."""
    if run_loop:
        time.sleep(randint(3, 10))  # Sleep some time to prevent printing before startup information

    last_month = 0
    while True:
        with open('./data/levels.json', 'r') as f:  # Read the monthly percentages from file
            levels = json.load(f)
        month = time.localtime().tm_mon  # Get current month.
        if month != last_month:

# !/usr/bin/env python

import time

import gv
from gpio_pins import GPIO, pin_relay
from urls import urls
import web
from webpages import ProtectedPage


urls.extend(['/tr', 'plugins.relay.toggle_relay'])  # Add a new url for this plugin.

gv.plugin_menu.append(['Test Relay', '/tr'])  # Add this plugin to the home page plugins menu


class toggle_relay(ProtectedPage):
    """Test relay by turning it on for a short time, then off."""
    def GET(self):
        try:
            GPIO.output(pin_relay, GPIO.HIGH)  # turn relay on
            time.sleep(3)
            GPIO.output(pin_relay, GPIO.LOW)  # Turn relay off
        except Exception:
            pass
        raise web.seeother('/')  # return to home page

import time
import subprocess
import sys
import traceback

import web
import gv  # Get access to ospi's settings
from urls import urls  # Get access to ospi's URLsimport errno
from ospi import template_render
from webpages import ProtectedPage
from helpers import restart


# Add a new url to open the data entry page.
urls.extend(['/UPs', 'plugins.system_update.status_page',
             '/UPsr', 'plugins.system_update.refresh_page',
             '/UPu', 'plugins.system_update.update_page',
             '/UPr', 'plugins.system_update.restart_page'])

# Add this plugin to the home page plugins menu
gv.plugin_menu.append(['System update', '/UPs'])


class StatusChecker(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.daemon = True
        self.start()
        self.started = Event()
        self._done = Condition()

        self.status = {

from webpages import ProtectedPage
from threading import Thread

# gv.pd Reference
###########################
# 0: On or Off
# 1: Weekly (127) or interval
# 2: Something to do with interval (0 if weekly)
# 3: Start time in minutes from 00:00 hours (300 == 5:00 AM)
# 4: End time in minutes from 00:00 hours (720 == 12:00 PM)
# 5: Reccuring length in mins
# 6: Duration in seconds
# 7: Bitwise value of the stations the program applies to

# Add a new url to open the data entry page.
urls.extend(['/ss', 'plugins.sunrise_sunset.sunrise_sunset', '/uss', 'plugins.sunrise_sunset.update'])

# Add this plugin to the home page plugins menu
gv.plugin_menu.append(['Sunrise Sunset', '/ss'])

class SunriseSunset(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.daemon = True
        self.start()
        self.status = ''
        self._sleep_time = 0

    def add_status(self, msg):
        if self.status:
            self.status += '\n' + msg

"""
__author__ = "Daniel Casner <[email protected]>"

import web  # web.py framework
import gv  # Get access to SIP's settings
from urls import urls  # Get access to SIP's URLs
from sip import template_render  #  Needed for working with web.py templates
from webpages import ProtectedPage  # Needed for security
from blinker import signal # To receive station notifications
from helpers import schedule_stations
import json  # for working with data file
from plugins import mqtt

# Add new URLs to access classes in this plugin.
urls.extend([
    '/mr1-sp', 'plugins.mqtt_schedule.settings',
    '/mr1-save', 'plugins.mqtt_schedule.save_settings'
    ])
gv.plugin_menu.append(['MQTT scheduler', '/mr1-sp'])

class settings(ProtectedPage):
    """Load an html page for entering plugin settings.
    """
    def GET(self):
        settings = mqtt.get_settings()
        zone_topic = settings.get('schedule_topic', gv.sd[u'name'] + '/schedule')
        return template_render.mqtt_schedule(zone_topic, "")  # open settings page

class save_settings(ProtectedPage):
    """Save user input to json file.
    Will create or update file when SUBMIT button is clicked
    CheckBoxes only appear in qdict if they are checked.

#!/usr/bin/env python
'''Pulses a selected circuit with a 2.5 Hz signal for 30 sec
to discover the location of a valve'''
import web
from time import sleep
import gv # Get access to ospi's settings
from urls import urls # Get access to ospi's URLs
from ospi import template_render  #  Needed for working with web.py templates
from helpers import stop_stations, jsave
from webpages import ProtectedPage  # Needed for security
from gpio_pins import set_output


urls.extend([
             '/puls', 'plugins.pulse_cct.pulse',
             '/puls-run', 'plugins.pulse_cct.p_run',
             '/puls-stop', 'plugins.pulse_cct.p_stop',
             '/puls-sen', 'plugins.pulse_cct.p_save_enabled'
             ]) 
gv.plugin_menu.append(['Pulse Circuit', '/puls']) # Add this plugin to the home page plugins menu

stop = True

def chatter(cct):
    stop_stations()
    t = 0
    for cnt in range(150):      
        t = 1 - t #  toggle cct
        gv.srvals[cct] = t      
        set_output()
        sleep(0.2)
        if stop:

import time

import web
import gv  # Get access to ospi's settings
from urls import urls  # Get access to ospi's URLs
from ospi import template_render
from webpages import ProtectedPage
from helpers import restart

installed = []

# Add new url(s).
urls.extend([
            '/plugins', 'plugins.plugin_manager.plugins',
            '/upd-plugins', 'plugins.plugin_manager.update_plugins',
            '/browse-plugins', 'plugins.plugin_manager.browse_plugins',
            '/inst-plugins', 'plugins.plugin_manager.install_plugins',
            '/pmr', 'plugins.plugin_manager.restart_page'
             ])

# Add this plugin to the home page plugins menu
gv.plugin_menu.append(['Manage Plugins', '/plugins'])

def get_permissions():
    global installed
    try:
        permissions = []
        files = subprocess.check_output(['ls', 'plugins'])
        installed = [f for f in list(files.split('\n')) if re.match('[^_].+\.py$', f)]
        pm = installed.index('plugin_manager.py')
        del installed[pm] #  Remove this plugin from list