api/plugins/tasks.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
########################################################################

"""
This is the node task registry class for Apache Warble
"""

import uuid
import re
import time
import json

""" Warble task class """
class task(object):
    
    def __init__(self, session, taskid = None, taskrow = None):
        """ Loads a task from the registry or inits a new one """
        self._data = {}
        self.session = session
        self.conn = session.DB.sqlite.open('nodetasks.db')
        
        # task variables
        self.id = None
        self.type = None
        self.category = 0
        self.enabled = True
        self.muted = False
        self.payload = {}
        self.name = None
        
        # Load a task by ID
        if taskid:
            doc = None
            nc = self.conn.cursor()
            # Load by Task ID?
            if re.match(r"^[0-9]+$", str(taskid)):
                self.id = int(taskid)
                nc.execute("SELECT * FROM `tasks` WHERE `id` = ? LIMIT 1", (taskid,))
                doc = nc.fetchone()
                
            if doc:
                self.id = doc['id']
                self.type = doc['type']
                self.category = doc['category']
                self.enabled = True if doc['enabled'] == 1 else False
                self.muted = True if doc['muted'] == 1 else False
                self.payload = json.loads(doc['payload'])
                self.ipv6 = False # TODO!
                self.name = doc['name']
            else:
                raise Exception("No such task found in registry")
        
        # Or load a task by data row?
        elif taskrow:
            doc = taskrow
            self.id = doc['id']
            self.type = doc['type']
            self.category = doc['category']
            self.enabled = True if doc['enabled'] == 1 else False
            self.muted = True if doc['muted'] == 1 else False
            self.payload = json.loads(doc['payload'])
            self.ipv6 = False # TODO!
            self.name = doc['name']
        
        
    def save(self):
        """ Saves or updates a task in the registry """
        nc = self.conn.cursor()
        # Save a new task?
        if not self.id:
            nc.execute("INSERT INTO `tasks` (`type`, `category`, `enabled`, `muted`, `payload`, `name`) VALUES (?, ?, ?, ?, ?, ?)",
                    (self.type, self.category, 1 if self.enabled else 0, 1 if self.muted else 0, json.dumps(self.payload), self.name, )
                )
        # Update existing task?
        else:
            nc.execute("UPDATE `tasks` SET `type` = ?, `category` = ?, `enabled` = ?, `muted` = ?, `payload` = ?, `name` = ? WHERE `id` = ? LIMIT 1",
                    (self.type, self.category, 1 if self.enabled else 0, 1 if self.muted else 0, json.dumps(self.payload), self.name, self.id, )
                )
        self.conn.commit()
    
    def remove(self):
        """ Removes a task from the registry """
        nc = self.conn.cursor()
        if self.id:
            nc.execute("DELETE FROM `tasks` WHERE `id` = ? LIMIT 1", (self.id, ))
            self.conn.commit()
            
    def accesslevel(self, user):
        """ Determines if a user can view/edit a task or not """
        aclcon = session.DB.sqlite.open('nodeacl.db')
        cur = aclcon.cursor()
        cur.execute("SELECT * FROM `nodeacl` WHERE `catid` = ? AND `userid` = ? LIMIT 1", (self.category, user['userid'], ))
        acl = cur.fetchone()
        if acl:
            return ['none', 'read', 'write', 'admin'][acl['access']]
        else:
            return 'none'
        aclcon.close()
        
    def __del__(self):
        # shut off sqlite connection
        if self.conn:
            self.conn.close()

    def __enter__(self):
        pass
    def __exit__(self, exception_type, exception_value, traceback):
        del self
        
        
"""
  id:           integer primary key   # ID of category
    name:         text                  # Name of category
    description:  text                  # Short description of category
    settings:     text                  # Notification settings (JSON blob to allow for customizations)
"""
    
""" Warble task category class """
class category(object):
    
    def __init__(self, session, catid = None):
        """ Loads a category from the registry or inits a new one """
        self._data = {}
        self.session = session
        self.conn = session.DB.sqlite.open('nodecats.db')
        
        # category variables
        self.id = None
        self.name = None
        self.description = None
        self.settings = {}
        self.tasks = []
        
        # Load existing category?
        if catid:
            doc = None
            nc = self.conn.cursor()
            # Load by Cat ID?
            if re.match(r"^[0-9]+$", str(catid)):
                self.id = int(catid)
                nc.execute("SELECT * FROM `nodecats` WHERE `id` = ? LIMIT 1", (catid,))
                doc = nc.fetchone()
            if doc:
                self.id = doc['id']
                self.name = doc['name']
                self.description = doc['description']
                self.settings = json.loads(doc['settings'])
                
                # Load tasks in category
                taskcon = session.DB.sqlite.open('nodetasks.db')
                cur = taskcon.cursor()
                cur.execute("SELECT * FROM `nodetasks` WHERE `category` = ?", (self.id, ))
                for row in cur.fetchall():
                    t = task(session, taskrow = row)
                    self.tasks.append(t)
                taskcon.close()
            else:
                raise Exception("No such category found in registry")
        
        
    def save(self):
        """ Saves or updates a category in the registry """
        nc = self.conn.cursor()
        # Save a new category?
        if not self.id:
            nc.execute("INSERT INTO `nodecats` (`name`, `description`, `settings`) VALUES (?, ?, ?)",
                    (self.name, self.description, json.dumps(self.settings), )
                )
        # Update existing category?
        else:
            nc.execute("UPDATE `nodecats` SET `name` = ?, `description` = ?, `settings` = ? WHERE `id` = ? LIMIT 1",
                    (self.name, self.description, json.dumps(self.settings), self.id, )
                )
        self.conn.commit()
    
    def remove(self):
        """ Removes a category from the registry """
        nc = self.conn.cursor()
        if self.id:
            nc.execute("DELETE FROM `nodecats` WHERE `id` = ? LIMIT 1", (self.id, ))
            self.conn.commit()
            
    def accesslevel(self, user):
        """ Determines if a user can view/edit a category or not """
        aclcon = session.DB.sqlite.open('nodeacl.db')
        cur = aclcon.cursor()
        cur.execute("SELECT * FROM `nodeacl` WHERE `catid` = ? AND `userid` = ? LIMIT 1", (self.id, user['userid'], ))
        acl = cur.fetchone()
        if acl:
            return ['none', 'read', 'write', 'admin'][acl['access']]
        else:
            return 'none'
        aclcon.close()
        
    def __del__(self):
        # shut off sqlite connection
        if self.conn:
            self.conn.close()

    def __enter__(self):
        pass
    def __exit__(self, exception_type, exception_value, traceback):
        del self
    
# Wrapper for getting all tasks:
def all(session):
    tlist = []
    taskcon = session.DB.sqlite.open('nodetasks.db')
    cur = taskcon.cursor()
    cur.execute("SELECT * FROM `nodetasks` WHERE 1")
    for row in cur.fetchall():
        t = task(session, taskrow = row)
        tlist.append(t)
    taskcon.close()
    return tlist

# Wrapper for getting ACL for a user
def cataccess(session):
    aclcon = session.DB.sqlite.open('nodeacl.db')
    cur = aclcon.cursor()
    cur.execute("SELECT * FROM `nodeacl` WHERE `userid` = ? LIMIT 1", (session.user['userid'], ))
    acl = {}
    for row in cur.fetchall():
        acl[row['catid']] = ['none', 'read', 'write', 'admin'][row['access']]
    aclcon.close()
    return acl