keithsalisbury-subtrac 0.1.1

data/lib/subtrac/trac-plugins/timingandestimationplugin/scripts/trac_billing.py

@@ -0,0 +1,173 @@
+from datetime import datetime as dt
+import time
+from utils import mail
+import adw_tracdb as db
+
+#defaultUrl= "https://sekhemt.acceleration.net/ADW/"
+_defaultUrl= "https://10.10.10.219/projects"
+_htmlLocation = '/var/BigVisibleCharts/Billing'
+
+def cond ( boolExpr, trueResult, falseResult ):
+    """ This is the classic ?: operator from languages like C expressed in python (from dive into python)
+    """
+    return (boolExpr and [trueResult] or [falseResult])[0]
+
+
+
+def accumulator():
+    var = [0]
+    def fn(*params):
+        for param in params:
+            var[0] = var[0] + param
+        return var[0]
+    return fn
+
+def progn(*params):
+    return params[-1]
+
+def prinTrue(s):
+    print s
+    return True
+
+
+def wn (name, attribs, *children):
+    return "<%s %s>\n%s\n</%s>\n" % \
+           (name, \
+            ' '.join(['%s="%s"' % (key, val) for (key, val) in attribs.items()]), \
+            '\n'.join([str(c) for c in children]), \
+            name)
+
+def ticket_link (number, projUrl):
+    return wn('a' , {'href':'/'.join([projUrl,'ticket' ,str(number)])}, "#"+str(number))
+
+def milestone_link (name, projUrl):
+    name = str(name)
+    return wn('a' , {'href':'/'.join([projUrl,'milestone' ,name])}, name)
+
+def make_project_output(project, rs, totalAcc):
+    projAcc = accumulator()
+    projLink = '/'.join([_defaultUrl, project ])
+    
+    def make_cell(idx, val):
+        if(idx == rs.columnMap['ticket']):
+            val = ticket_link(val, projLink)
+        elif idx == rs.columnMap['milestone'] and val != '&nbsp;':
+            val = milestone_link(val, projLink)
+        elif idx == rs.columnMap['hours']:
+            projAcc(float(val))
+            totalAcc(float(val))
+        return wn('td', {}, val)
+    
+    return progn(wn('div', {},
+                    wn('h2', {},
+                       wn('a',{'href':projLink},project)),
+                    wn('table', {"cellspacing":"0", "border":"1", "cellpadding":"3"},
+                       wn('tr', {},
+                          *[wn('th',{}, name) for name in rs.columnNames]),
+                       *[wn('tr', {},
+                            *[make_cell(idx, val)
+                              for idx in range(0, len(row))
+                              for val in [row[idx]]])
+                         for row in rs.rows]),
+                    wn('span',{}, "Total: "+str(projAcc()))))
+
+def make_all_projects_output():
+    totalAcc = accumulator()
+    sql = """
+SELECT
+ CASE WHEN t.milestone IS NOT NULL and t.milestone <> '' THEN t.milestone
+ ELSE '&nbsp;'
+ END as milestone,
+ t.id as ticket,
+ SUM(newvalue) as hours,
+ t.summary as summary,
+ strftime('%m/%d/%Y %H:%M:%S', MAX(ticket_change.time), 'unixepoch', 'localtime') as [most-recent-update] ,
+ (SELECT CASE WHEN MAX(time) IS NOT NULL THEN strftime('%m/%d/%Y %H:%M:%S', MAX(time), 'unixepoch', 'localtime')
+       ELSE 'No previous bill date'
+       END as time FROM bill_date ) as [previous-bill-date]
+FROM ticket as t
+LEFT JOIN ticket_custom as billable on billable.ticket = t.id 
+  AND billable.name = 'billable'
+JOIN ticket_change on t.id = ticket_change.ticket
+  AND (
+     ticket_change.time >
+     (SELECT CASE WHEN MAX(time) IS NOT NULL THEN MAX(time)
+       ELSE 0
+       END as time FROM bill_date )
+) 
+WHERE ticket_change.field = 'hours' 
+    AND billable.value=1
+GROUP BY t.milestone, t.id
+"""
+
+    billingInfo = db.collectResultsFromAllTracs(sql);
+    projects_output = '\n'.join([make_project_output(project, rs, totalAcc)
+                                 for (project, rs) in billingInfo
+                                 if rs.rows ])
+    return wn('html', {},
+              wn('head', {}),
+              wn('body', {},
+                 projects_output,
+                 wn('span',{},"Total hours billed: "+str(totalAcc()))))
+
+
+def save_output_to_file(output, when=0):
+    if not when:
+        when = dt.now()
+    fname = '_'.join(["billing", str(when.year),
+                      str(when.month), str(when.day),
+                      str(when.hour), str(when.minute), ".html"])
+    p = "/".join([_htmlLocation, fname])
+    print "----"
+    print "Writing out billing information to '%s'" % p
+    print "----"
+    f = open(p, "w")
+    f.write(output)
+    f.close();
+
+
+
+def run_billing(emails="ryan@acceleration.net", when=0):    
+    if not when:
+        when = dt.now()
+    date = '/'.join([str(when.month), str(when.day), str(when.year)])
+    
+    print "Collecting output..."
+    output = make_all_projects_output()
+    save_output_to_file(output, when)
+    print "Emailing results to %s" % emails
+    if emails:
+        mail.mail(emails, 'Trac Billing - %s ' % date, output, html=True, fromEmail='trac-tickets@acceleration.net')
+    return output
+    
+    
+
+def add_bill_date(project, username="Timing and Estimation Plugin",  when=0):
+    now = time.time()
+    if not when:
+        when = now
+    when = int(when)
+    now = int(now)
+    sql = """
+    INSERT INTO bill_date (time, set_when, str_value)
+    VALUES (?, ?, strftime('%m/%d/%Y %H:%M:%S',?, 'unixepoch', 'localtime'))
+    """
+    db.executeNonQuery(project, sql, when, now, when)
+
+def mark_billing_date_in_all_projects(when=0 ):
+    print "Marking the bill date on all projects."
+    if not when:
+        when = time.time()
+    for project in db.projects:
+        try:
+            add_bill_date(project,  "Timing and Estimation Plugin",  when);
+            print "%s Succeeded." % project
+        except Exception, e:
+            print "* %s failed: %s" % (project , e.args)
+    print "Done marking bill dates"
+    
+
+
+             
+              
+        

data/lib/subtrac/trac-plugins/timingandestimationplugin/scripts/utils/mail.py

@@ -0,0 +1,164 @@
+"""
+Helper library to ease emailing.
+"""
+
+
+
+import smtplib
+import email
+from email import Encoders
+from email.Utils import formatdate
+from email.Message import Message
+from email.MIMEAudio import MIMEAudio
+from email.MIMEBase import MIMEBase
+from email.MIMEMultipart import MIMEMultipart
+from email.MIMEImage import MIMEImage
+from email.MIMEText import MIMEText
+import mimetypes
+
+FROMEMAIL = 'ryan@acceleration.net'
+SERVER = 'mail.acceleration.net'
+
+def rawEmail(toList, msg, server=SERVER, fromEmail=FROMEMAIL):
+
+    s = smtplib.SMTP(server)
+    smtpresult = s.sendmail(fromEmail, toList, msg)
+
+    if smtpresult:
+        errstr = ""
+        for recip in smtpresult.keys():
+            errstr = """Could not delivery mail to: %s
+
+Server said: %s
+%s
+
+%s""" % (recip, smtpresult[recip][0], smtpresult[recip][1], errstr)
+        raise smtplib.SMTPException, errstr
+
+
+def processTo(to):
+    """
+    helper function that processes a string or list of addresses.
+
+    returns (list of addresses, comma-delimited string of addresses)
+    
+    The first is used for rawEmail, and the second is used when creating
+    headers.
+    """
+    toList = []
+    if type(to) is list:
+        toList = to[:]
+        to = ", ".join(to)
+    else:
+        toList = [to]
+
+    return (toList, to)
+
+def mail(to, subject, message, html=False, fromEmail=FROMEMAIL, server=SERVER):
+    """
+    Simplifies the emailing process, sending plaintext emails.
+
+    to: accepts a list of emails or a single email.
+
+    returns nothing, or throws an smtplib.SMTPException if there is a problem.
+    """
+    toList, to = processTo(to)
+
+    htmlHeader = '\n'
+
+    if html:
+        htmlHeader = 'Content-Type: text/html; charset=ISO-8859-1\n\n'
+
+    msg = '''To: %s
+From: %s
+Subject: %s
+Date: %s
+%s
+%s
+    ''' % (to, fromEmail, subject, formatdate(), htmlHeader, message)
+
+    rawEmail(toList, msg, fromEmail=fromEmail, server=server)
+
+
+def sms_me(subject, message):
+    " sends an email to ryan's phone "
+    mail('sms-ryan@acceleration.net', subject, message)
+
+def emailHtml(to, subject, message):
+    toList, to = processTo(to)
+    msg = MIMEMultipart()
+    msg['Subject'] = subject
+    msg['To'] = to
+    msg['From'] = fromEmail
+    msg['Date'] = formatdate()
+    msg.preamble = 'You are not using a MIME-aware reader\n'
+    msg.epilogue = ''
+
+    #add the main message
+    msg.attach(MIMEText(message))
+    
+    rawEmail(toList, msg.as_string())
+
+def emailFile(to, subject, message, filePath, mimeType=None, fromEmail=FROMEMAIL, server=SERVER):
+    """
+    sends an email attachment to the given address or list of addesses.
+    
+    if the mimeType is not specified, it uses mimetypes.guess_type to determine it.
+    """
+    toList, to = processTo(to)
+
+    msg = MIMEMultipart()
+    msg['Subject'] = subject
+    msg['To'] = to
+    msg['From'] = fromEmail
+    msg['Date'] = formatdate()
+    msg.preamble = 'You are not using a MIME-aware reader\n'
+    msg.epilogue = ''
+
+    #add the main message
+    msg.attach(MIMEText(message))
+    
+    if type(filePath) is list:
+        for f in filePath:
+            addFile(f, msg, mimeType)
+    else:
+        addFile(filePath, msg, mimeType)
+
+    rawEmail(toList, msg.as_string(), server=server, fromEmail=fromEmail)
+
+def addFile(filePath, message, mimeType=None):
+    if mimeType is None:
+        mimeType = mimetypes.guess_type(filePath)[0]
+     
+    maintype, subtype = mimeType.split('/', 1)
+
+    def processFactory(mimeRunner, openMethod):
+        def proc(path, subtype):
+            fp = open(path, openMethod)
+            fileMsg = mimeRunner(fp.read(), _subtype = subtype)
+            fp.close()
+            return fileMsg
+        
+        return proc
+    
+    messageMaker = {'text':processFactory(MIMEText, 'r'),
+                    'image':processFactory(MIMEImage, 'rb'),
+                    'audio':processFactory(MIMEAudio, 'rb')}
+    
+    
+    
+    fMsg = None
+    if messageMaker.has_key(maintype):
+        fMsg = messageMaker[maintype](filePath, subtype)
+    else:
+        fp = open(filePath, 'rb')
+        fMsg = MIMEBase(maintype, subtype)
+        fMsg.set_payload(fp.read())
+        fp.close()
+        # Encode the payload using Base64
+        Encoders.encode_base64(fMsg)
+        
+    if fMsg is not None:
+        fMsg.add_header('Content-Disposition', 'attachment', filename=filePath)        
+        message.attach(fMsg)
+            

data/lib/subtrac/trac-plugins/timingandestimationplugin/setup.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+
+from setuptools import setup
+
+PACKAGE = 'timingandestimationplugin'
+
+setup(name=PACKAGE,
+      description='Plugin to make Trac support time estimation and tracking with permissions',
+      keywords='trac plugin estimation timetracking permissions',
+      version='0.7.8',
+      url='http://www.trac-hacks.org/wiki/TimingAndEstimationPlugin',
+      license='http://www.opensource.org/licenses/mit-license.php',
+      author='Russ Tyndall at Acceleration.net',
+      author_email='russ@acceleration.net',
+      long_description="""
+      This Trac 0.11 plugin provides support for Time estimation and tracking,
+      and permissions to view and set those fields
+
+      See http://trac-hacks.org/wiki/TimingAndEstimationPlugin for details.
+      """,
+      packages=[PACKAGE],
+      package_data={PACKAGE : ['templates/*.html', 'htdocs/js/*', 'htdocs/*.css', 'htdocs/*.js']},
+      entry_points={'trac.plugins': '%s = %s' % (PACKAGE, PACKAGE)})
+
+
+#### FINANCIAL CONTRIBUTERS ####
+#
+# Obsidian Software: http://www.obsidiansoft.com/
+#   Enterprise Solutions for Functional Processor 
+#   Design Verification
+#
+################################
+
+#### AUTHORS ####
+## Primary Author:
+## Russell Tyndall
+## Acceleration.net
+## russ@acceleration.net
+## trac-hacks user: bobbysmith007
+
+##
+
+## Alessio Massaro
+## trac-hacks user: masariello
+## Helped Get Reports working in postgres
+## and started moving toward generic work
+## rather than hours
+
+## kkurzweil@lulu.com
+## helped postegresql db backend compatiblity
+
+## jonas
+## made it so that base_url was unnecessary
+
+## Colin Guthrie
+## trac-hacks user: coling
+## Refactored the custom reports code to make it
+##  easy for other plugins to provide reports to
+##  compliment those provided by default
+## Added Javascript that improves Ticket UI
+
+## Dave Abrahams <dave@boost-consulting.com>
+##
+## Genshi filters to remove T&E reports from the
+## standard reports page, where they display errors
+
+## Greg Troxel
+##
+## Updated the post commit hooks to be inline with upstream trac

data/lib/subtrac/trac-plugins/timingandestimationplugin/timingandestimationplugin/__init__.py

@@ -0,0 +1 @@
+from api import *

data/lib/subtrac/trac-plugins/timingandestimationplugin/timingandestimationplugin/api.py

@@ -0,0 +1,292 @@
+import re
+import dbhelper
+import time
+from tande_filters import *
+from reports_filter import *
+from blackmagic import *
+from ticket_daemon import *
+from ticket_webui import *
+from usermanual import *
+from ticket_policy import *
+from trac.log import logger_factory
+from trac.ticket import ITicketChangeListener, Ticket
+from trac.core import *
+from trac.env import IEnvironmentSetupParticipant
+from trac.perm import IPermissionRequestor, PermissionSystem
+from webui import *
+from query_webui import *
+from reportmanager import CustomReportManager
+from statuses import *
+from reports import all_reports
+from sets import Set
+
+## report columns
+## id|author|title|query|description
+
+class TimeTrackingSetupParticipant(Component):
+    """ This is the config that must be there for this plugin to work:
+
+        [ticket-custom]
+        totalhours = text
+        totalhours.value = 0
+        totalhours.label = Total Hours
+
+        billable = checkbox
+        billable.value = 1
+        billable.label = Is this billable?
+
+        hours = text
+        hours.value = 0
+        hours.label = Hours to Add
+
+        estimatedhours = text
+        estimatedhours.value = 0
+        estimatedhours.label = Estimated Hours?
+
+        internal = checkbox
+        internal.value = 0
+        internal.label = Internal?
+
+        """
+    implements(IEnvironmentSetupParticipant)
+    db_version_key = None
+    db_version = None
+    db_installed_version = None
+
+    """Extension point interface for components that need to participate in the
+    creation and upgrading of Trac environments, for example to create
+    additional database tables."""
+    def __init__(self):
+        # Setup logging
+        self.statuses_key = 'T&E-statuses'
+        self.db_version_key = 'TimingAndEstimationPlugin_Db_Version'
+        self.db_version = 8
+        # Initialise database schema version tracking.
+        self.db_installed_version = dbhelper.get_system_value(self, \
+            self.db_version_key) or 0
+
+    def environment_created(self):
+        """Called when a new Trac environment is created."""
+        if self.environment_needs_upgrade(None):
+            self.upgrade_environment(None)
+
+
+    def system_needs_upgrade(self):
+        return self.db_installed_version < self.db_version
+
+    def do_db_upgrade(self):
+        if self.db_installed_version < 1:
+            print "Creating bill_date table"
+            sql = """
+            CREATE TABLE bill_date (
+            time integer,
+            set_when integer,
+            str_value text
+            );
+            """
+            dbhelper.execute_non_query(self,  sql)
+
+
+        if self.db_installed_version < 5:
+            if dbhelper.db_table_exists(self, 'report_version'):
+                print "Dropping report_version table"
+                sql = "DELETE FROM report " \
+                    "WHERE author=%s AND id IN (SELECT report FROM report_version)"
+                dbhelper.execute_non_query(self, sql, 'Timing and Estimation Plugin')
+
+                sql = "DROP TABLE report_version"
+                dbhelper.execute_non_query(self, sql)
+
+        #version 6 upgraded reports
+
+
+        if self.db_installed_version < 7:
+            field_settings = "field settings"
+            self.config.set( field_settings, "fields", "billable, totalhours, hours, estimatedhours, internal" )
+            self.config.set( field_settings, "billable.permission", "TIME_VIEW:hide, TIME_RECORD:disable" )
+            self.config.set( field_settings, "hours.permission", "TIME_VIEW:remove, TIME_RECORD:disable" )
+            self.config.set( field_settings, "estimatedhours.permission", "TIME_RECORD:disable" )
+            self.config.set( field_settings, "internal.permission", "TIME_RECORD:hide")
+
+        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        # This statement block always goes at the end this method
+        dbhelper.set_system_value(self, self.db_version_key, self.db_version)
+        self.db_installed_version = self.db_version
+        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+            
+
+    def reports_need_upgrade(self):
+        mgr = CustomReportManager(self.env, self.log)
+        db_reports = mgr.get_version_hash_by_group(CustomReportManager.TimingAndEstimationKey)
+        py_reports = {}
+        for report_group in all_reports:
+            for report in report_group['reports']:
+                py_reports[report['uuid']]= report['version']
+        
+        diff = [(uuid, version) for (uuid, version) in py_reports.items()
+                if not db_reports.has_key(uuid) or int(db_reports[uuid]) < int(version)]
+                
+        if len(diff) > 0:
+            self.log.debug ("T&E needs upgrades for the following reports: %s" %
+                            (diff, ))
+        return len(diff) > 0
+
+    def do_reports_upgrade(self, force=False):
+        self.log.debug( "Beginning Reports Upgrade");
+        mgr = CustomReportManager(self.env, self.log)
+        statuses = get_statuses(self)
+        stat_vars = status_variables(statuses)
+
+        for report_group in all_reports:
+            rlist = report_group["reports"]
+            group_title = report_group["title"]
+            for report in rlist:
+                title = report["title"]
+                new_version = report["version"]
+
+                sql = report["sql"].replace('#STATUSES#', stat_vars)
+                mgr.add_report(report["title"], "Timing and Estimation Plugin", \
+                               "Reports Must Be Accessed From the Management Screen",
+                               sql, report["uuid"], report["version"],
+                               CustomReportManager.TimingAndEstimationKey,
+                               group_title, force)
+
+    def ticket_fields_need_upgrade(self):
+        ticket_custom = "ticket-custom"
+        return not ( self.config.get( ticket_custom, "totalhours" ) and \
+                         self.config.get( ticket_custom, "hours" ) and \
+                         self.config.get( ticket_custom, "totalhours.order") and \
+                         self.config.get( ticket_custom, "hours.order") and \
+                         self.config.get( ticket_custom, "estimatedhours.order") and \
+                         self.config.get( ticket_custom, "estimatedhours") and \
+                         self.config.get( ticket_custom, "internal") and \
+                         "InternalTicketsPolicy" in self.config.getlist("trac", "permission_policies"))
+
+    def do_ticket_field_upgrade(self):
+        ticket_custom = "ticket-custom"
+
+        if not self.config.get(ticket_custom,"totalhours"):
+            self.config.set(ticket_custom,"totalhours", "text")
+            self.config.set(ticket_custom,"totalhours.order", "4")
+            self.config.set(ticket_custom,"totalhours.value", "0")
+            self.config.set(ticket_custom,"totalhours.label", "Total Hours")
+
+
+        if not self.config.get(ticket_custom,"billable"):
+            self.config.set(ticket_custom,"billable", "checkbox")
+            self.config.set(ticket_custom,"billable.value", "1")
+            self.config.set(ticket_custom,"billable.order", "3")
+            self.config.set(ticket_custom,"billable.label", "Billable?")
+
+        if not self.config.get(ticket_custom,"hours"):
+            self.config.set(ticket_custom,"hours", "text")
+            self.config.set(ticket_custom,"hours.value", "0")
+            self.config.set(ticket_custom,"hours.order", "2")
+            self.config.set(ticket_custom,"hours.label", "Add Hours to Ticket")
+
+        if not self.config.get(ticket_custom,"estimatedhours"):
+            self.config.set(ticket_custom,"estimatedhours", "text")
+            self.config.set(ticket_custom,"estimatedhours.value", "0")
+            self.config.set(ticket_custom,"estimatedhours.order", "1")
+            self.config.set(ticket_custom,"estimatedhours.label", "Estimated Number of Hours")
+
+        if not self.config.get( ticket_custom, "internal"):
+            self.config.set(ticket_custom, "internal", "checkbox")
+            self.config.set(ticket_custom, "internal.value", "0")
+            self.config.set(ticket_custom, "internal.label", "Internal?")
+            self.config.set(ticket_custom,"internal.order", "5")
+
+        if "InternalTicketsPolicy" not in self.config.getlist("trac", "permission_policies"):
+            perms = ["InternalTicketsPolicy"]
+            other_policies = self.config.getlist("trac", "permission_policies")
+            if "DefaultPermissionPolicy" not in other_policies:
+                perms.append("DefaultPermissionPolicy")
+            perms.extend( other_policies )
+            self.config.set("trac", "permission_policies", ', '.join(perms))
+
+        self.config.save();
+
+    def needs_user_man(self):
+        maxversion = dbhelper.get_scalar(self, "SELECT MAX(version) FROM wiki WHERE name like %s", 0,
+                                         user_manual_wiki_title)
+        if (not maxversion) or maxversion < user_manual_version:
+            return True
+        return False
+
+    def do_user_man_update(self):
+
+        when = int(time.time())
+        sql = """
+        INSERT INTO wiki (name,version,time,author,ipnr,text,comment,readonly)
+        VALUES ( %s, %s, %s, 'Timing and Estimation Plugin', '127.0.0.1', %s,'',0)
+        """
+        dbhelper.execute_non_query(self, sql,
+                                   user_manual_wiki_title,
+                                   user_manual_version,
+                                   when,
+                                   user_manual_content)
+
+
+    def environment_needs_upgrade(self, db):
+        """Called when Trac checks whether the environment needs to be upgraded.
+
+        Should return `True` if this participant needs an upgrade to be
+        performed, `False` otherwise.
+
+        """
+        self.log.debug("NEEDS UP?: sys:%s, rep:%s, stats:%s, fields:%s, man:%s" % \
+                       ((self.system_needs_upgrade()),
+                        (self.reports_need_upgrade()),
+                        (self.have_statuses_changed()),
+                        (self.ticket_fields_need_upgrade()),
+                        (self.needs_user_man())))
+        return (self.system_needs_upgrade()) or \
+               (self.reports_need_upgrade()) or \
+               (self.have_statuses_changed()) or \
+               (self.ticket_fields_need_upgrade()) or \
+               (self.needs_user_man())
+
+    def upgrade_environment(self, db):
+        """Actually perform an environment upgrade.
+
+        Implementations of this method should not commit any database
+        transactions. This is done implicitly after all participants have
+        performed the upgrades they need without an error being raised.
+        """
+        def p(s):
+            print s
+            return True
+        print "Timing and Estimation needs an upgrade"
+        p("Upgrading Database")
+        self.do_db_upgrade()
+        p("Upgrading reports")
+        self.do_reports_upgrade(force=self.have_statuses_changed())
+
+        #make sure we upgrade the statuses string so that we dont need to always rebuild the
+        # reports
+        stats = get_statuses(self)
+        val = ','.join(list(stats))
+        dbhelper.set_system_value(self, self.statuses_key, val)
+
+        if self.ticket_fields_need_upgrade():
+            p("Upgrading fields")
+            self.do_ticket_field_upgrade()
+        if self.needs_user_man():
+            p("Upgrading usermanual")
+            self.do_user_man_update()
+        print "Done Upgrading"
+
+    def have_statuses_changed(self):
+        """get the statuses from the last time we saved them,
+        compare them to the ones we have now (ignoring '' and None),
+        if we have different ones, throw return true
+        """
+        s = dbhelper.get_system_value(self, self.statuses_key)
+        if not s:
+            return True
+        sys_stats = get_statuses(self)
+        s = s.split(',')
+        sys_stats.symmetric_difference_update(s)
+        sys_stats.difference_update(['', None])
+        return len(sys_stats) > 0