keithsalisbury-subtrac 0.1.1

data/lib/subtrac/trac-plugins/clientsplugin/clients/api.py

@@ -0,0 +1,199 @@
+import time
+from trac.core import *
+from trac.env import IEnvironmentSetupParticipant
+from reportmanager import CustomReportManager
+
+class ClientsSetupParticipant(Component):
+    implements(IEnvironmentSetupParticipant)
+    
+    db_version_key = None
+    db_version = None
+    db_installed_version = None
+    
+    def __init__(self):
+        self.db_version_key = 'clients_plugin_version'
+        self.db_version = 5
+        self.db_installed_version = None
+
+        # Initialise database schema version tracking.
+        db = self.env.get_db_cnx()
+        cursor = db.cursor()
+        cursor.execute("SELECT value FROM system WHERE name=%s", (self.db_version_key,))
+        try:
+            self.db_installed_version = int(cursor.fetchone()[0])
+        except:
+            self.db_installed_version = 0
+            cursor.execute("INSERT INTO system (name,value) VALUES(%s,%s)",
+                           (self.db_version_key, self.db_installed_version))
+            db.commit()
+            db.close()
+
+    def system_needs_upgrade(self):
+        return self.db_installed_version < self.db_version
+    
+    def do_db_upgrade(self):
+        db = self.env.get_db_cnx()
+        cursor = db.cursor()
+
+        # Do the staged updates
+        try:
+            if self.db_installed_version < 2:
+                print 'Creating client table'
+                cursor.execute('CREATE TABLE client ('
+                               'name               TEXT,'
+                               'description        TEXT,'
+                               'changes_list       TEXT,'
+                               'changes_period     TEXT,'
+                               'changes_lastupdate INTEGER,'
+                               'summary_list       TEXT,'
+                               'summary_period     TEXT,'
+                               'summary_lastupdate INTEGER'
+                               ')')
+                # Import old Enums
+                cursor.execute('INSERT INTO client (name) '
+                               'SELECT name FROM enum WHERE type=%s', ('client',))
+                # Clean them out
+                cursor.execute('DELETE FROM enum WHERE type=%s', ('client',))
+            
+            if self.db_installed_version < 3:
+               print 'Updating clients table (v3)'
+               cursor.execute('ALTER TABLE client '
+                              'ADD COLUMN default_rate INTEGER')
+               cursor.execute('ALTER TABLE client '
+                              'ADD COLUMN currency     TEXT')
+            
+            if self.db_installed_version < 4:
+                print 'Updating clients table (v4)'
+                cursor.execute('CREATE TABLE client_events ('
+                               'name               TEXT,'
+                               'summary            TEXT,'
+                               'action             TEXT,'
+                               'lastrun            INTEGER'
+                               ')')
+                cursor.execute('CREATE TABLE client_event_summary_options ('
+                               'client_event       TEXT,'
+                               'client             TEXT,'
+                               'name               TEXT,'
+                               'value              TEXT'
+                               ')')
+                cursor.execute('CREATE TABLE client_event_action_options ('
+                               'client_event       TEXT,'
+                               'client             TEXT,'
+                               'name               TEXT,'
+                               'value              TEXT'
+                               ')')
+
+            if self.db_installed_version < 5:
+                print 'Updating clients table (v5)'
+                cursor.execute('INSERT INTO client_events '
+                               'SELECT "Weekly Summary", "Milestone Summary", "Send Email", MAX(summary_lastupdate) '
+                               'FROM client')
+                cursor.execute('INSERT INTO client_event_action_options '
+                               'SELECT "Weekly Summary", name, "Email Addresses", summary_list '
+                               'FROM client '
+                               'WHERE summary_list!=""')
+                cursor.execute('INSERT INTO client_events '
+                               'SELECT "Ticket Changes", "Ticket Change Summary", "Send Email", MAX(changes_lastupdate) '
+                               'FROM client')
+                cursor.execute('INSERT INTO client_event_action_options '
+                               'SELECT "Ticket Changes", name, "Email Addresses", changes_list '
+                               'FROM client '
+                               'WHERE changes_list!=""')
+                cursor.execute('CREATE TEMPORARY TABLE client_tmp ('
+                               'name               TEXT,'
+                               'description        TEXT,'
+                               'default_rate       INTEGER,'
+                               'currency           TEXT'
+                               ')')
+                cursor.execute('INSERT INTO client_tmp SELECT name, description, default_rate, currency FROM client')
+                cursor.execute('DROP TABLE client')
+                cursor.execute('CREATE TABLE client ('
+                               'name               TEXT,'
+                               'description        TEXT,'
+                               'default_rate       INTEGER,'
+                               'currency           TEXT'
+                               ')')
+                cursor.execute('INSERT INTO client SELECT name, description, default_rate, currency FROM client_tmp')
+                cursor.execute('DROP TABLE client_tmp')
+            
+            #if self.db_installed_version < 6:
+            #    print 'Updating clients table (v6)'
+            #    cursor.execute('...')
+            
+            # Updates complete, set the version
+            cursor.execute("UPDATE system SET value=%s WHERE name=%s", 
+                           (self.db_version, self.db_version_key))
+            db.commit()
+            db.close()
+        except Exception, e:
+            self.log.error("WorklogPlugin Exception: %s" % (e,));
+            db.rollback()
+
+    def do_reports_upgrade(self):
+        mgr = CustomReportManager(self.env, self.log)
+        r = __import__('reports', globals(), locals(), ['reports'])
+        
+        for report_group in r.reports:
+            rlist = report_group['reports']
+            group_title = report_group['title']
+            for report in rlist:
+                title = report['title']
+                new_version = report['version']
+                mgr.add_report(report["title"], 'Clients Plugin', \
+                               report['description'], report['sql'], \
+                               report['uuid'], report['version'],
+                               'Timing and Estimation Plugin',
+                               group_title)
+
+    def ticket_fields_need_upgrade(self):
+        section = 'ticket-custom'
+        return ('text' != self.config.get(section, 'client') \
+                or 'text' != self.config.get(section, 'clientrate'))
+    
+    def do_ticket_field_upgrade(self):
+        section = 'ticket-custom'
+        
+        self.config.set(section,'client', 'text')
+        self.config.set(section,'client.label', 'Client')
+
+        self.config.set(section,'clientrate', 'text')
+        self.config.set(section,'clientrate.label', 'Client Charge Rate')
+
+        self.config.save();
+
+
+    # IEnvironmentSetupParticipant methods
+    def environment_created(self):
+        """Called when a new Trac environment is created."""
+        if self.environment_needs_upgrade(None):
+            self.upgrade_environment(None)
+    
+    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.
+
+        """
+        return (self.system_needs_upgrade() \
+                or self.ticket_fields_need_upgrade())
+
+    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.
+        """
+        print 'ClientsPlugin needs an upgrade'
+        print ' * Upgrading db'
+        self.do_db_upgrade()
+        print ' * Upgrading reports'
+        self.do_reports_upgrade()
+
+        if self.ticket_fields_need_upgrade():
+            print ' * Upgrading fields'
+            self.do_ticket_field_upgrade()
+
+        print 'Done Upgrading'
+

data/lib/subtrac/trac-plugins/clientsplugin/clients/client.py

@@ -0,0 +1,105 @@
+from trac.core import *
+from trac.web.chrome import add_stylesheet, ITemplateProvider
+from trac.web.api import IRequestFilter, ITemplateStreamFilter
+from trac.ticket.api import ITicketManipulator
+from trac.ticket.model import Ticket
+from trac.util.html import html, Markup
+
+from genshi.core import Markup
+from genshi.builder import tag
+from genshi.filters.transform import Transformer 
+
+from clients import model
+from StringIO import StringIO
+
+class ClientModule(Component):
+    """Allows for tickets to be assigned to particular clients."""
+    
+    implements(IRequestFilter, ITemplateStreamFilter, ITemplateProvider)
+    
+    # IRequestFilter methods
+    def pre_process_request(self, req, handler):
+        # Add Stylesheet here, so that the ticket page gets it too :)
+        add_stylesheet(req, "clients/clients.css")
+        return handler
+        
+    def post_process_request(self, req, template, data, content_type):
+        # Some ticket views do not actually load the data in this way
+        # e.g. action=history or action=diff
+        if not data or not data.has_key('fields'):
+            return template, data, content_type
+
+        newticket = req.path_info.startswith('/newticket')
+        if req.path_info.startswith('/ticket/') or newticket:
+            for field in data['fields']:
+                if 'client' == field['name']:
+                    field['type'] = 'select'
+                    field['options'] = []
+                    for client in model.Client.select(self.env):
+                        field['options'].append(client.name)
+                    if newticket:
+                        default_client = self.config.get('ticket', 'default_client')
+                        if default_client:
+                            data['ticket']['client'] = default_client
+                    break;
+        elif req.path_info.startswith('/query'):
+            if data['fields'].has_key('client'):
+                data['fields']['client']['type'] = 'select'
+                data['fields']['client']['options'] = []
+                for client in model.Client.select(self.env):
+                    data['fields']['client']['options'].append(client.name)
+        return template, data, content_type
+    
+    # ITemplateStreamFilter methods
+    def filter_stream(self, req, method, filename, stream, data):
+        newticket = req.path_info.startswith('/newticket')
+        if req.path_info.startswith('/ticket/') or newticket:
+            setdefaultrate = ''
+            if newticket:
+              setdefaultrate = "$('#field-client').trigger('change');"
+            
+            script = StringIO()
+            script.write("""
+              $(document).ready(function() {
+                $('#field-client').change(function() {
+                  """);
+            script.write('var clientrates = new Array();')
+            for client in model.Client.select(self.env):
+                script.write('clientrates["%s"] = %s;' % (client.name, client.default_rate or '""'))
+            script.write("""
+                  try { $('#field-clientrate').attr('value', clientrates[this.options[this.selectedIndex].value]); }
+                  catch (er) { }
+                });
+                %s
+             });""" % setdefaultrate);
+            stream |= Transformer('.//head').append(tag.script(script.getvalue(), type_='text/javascript'))
+        return stream
+    
+    # ITemplateProvider
+    def get_htdocs_dirs(self):
+        """Return the absolute path of a directory containing additional
+        static resources (such as images, style sheets, etc).
+        """
+        from pkg_resources import resource_filename
+        return [('clients', resource_filename(__name__, 'htdocs'))]
+    
+    def get_templates_dirs(self):
+        """Return the absolute path of the directory containing the provided
+        ClearSilver templates.
+        """
+        from pkg_resources import resource_filename
+        return [resource_filename(__name__, 'templates')]
+    
+    # ITicketManipulator methods
+    def prepare_ticket(self, req, ticket, fields, actions):
+        pass
+    
+    def validate_ticket(self, req, ticket):
+        # Todo validate client is valid
+        pass
+        #if req.args.get('action') == 'resolve':
+        #    links = TicketLinks(self.env, ticket)
+        #    for i in links.blocked_by:
+        #        if Ticket(self.env, i)['status'] != 'closed':
+        #            yield None, 'Ticket #%s is blocking this ticket'%i
+

data/lib/subtrac/trac-plugins/clientsplugin/clients/events.py

@@ -0,0 +1,287 @@
+import md5
+import sys
+import time
+
+from trac.core import *
+
+from clients.summary import IClientSummaryProvider
+from clients.action import IClientActionProvider
+
+
+
+__all__ = ['ClientEvent']
+
+def simplify_whitespace(name):
+    """Strip spaces and remove duplicate spaces within names"""
+    return ' '.join(name.split())
+
+class ClientEventsSystem(Component):
+  summaries = ExtensionPoint(IClientSummaryProvider)
+  actions = ExtensionPoint(IClientActionProvider)
+
+  def get_summaries(self):
+    for summary in self.summaries:
+      yield summary.get_name()
+
+  def get_summary(self, name):
+    for summary in self.summaries:
+      if name == summary.get_name():
+        return summary
+    return None
+
+  def get_actions(self):
+    for action in self.actions:
+      yield action.get_name()
+
+  def get_action(self, name):
+    for action in self.actions:
+      if name == action.get_name():
+        return action
+    return None
+
+class ClientEvent(object):
+
+    def __init__(self, env, name=None, client=None, db=None):
+        self.env = env
+        if name:
+            name = simplify_whitespace(name)
+        if name:
+            if not db:
+                db = self.env.get_db_cnx()
+            cursor = db.cursor()
+            cursor.execute("SELECT summary, action, lastrun "
+                           "FROM client_events "
+                           "WHERE name=%s", (name,))
+            row = cursor.fetchone()
+            if not row:
+                raise TracError('Client Event %s does not exist.' % name)
+            self.md5 = md5.new(name).hexdigest()
+            self.name = self._old_name = name
+            self.summary = row[0] or ''
+            self.action = row[1] or ''
+            self.lastrun = row[2] or 0
+            self._load_options(client, db)
+        else:
+            self.name = self._old_name = None
+            self.summary = ''
+            self.action = ''
+            self.lastrun = 0
+
+
+    exists = property(fget=lambda self: self._old_name is not None)
+
+
+    def delete(self, db=None):
+        assert self.exists, 'Cannot deleting non-existent client event'
+        if not db:
+            db = self.env.get_db_cnx()
+            handle_ta = True
+        else:
+            handle_ta = False
+
+        cursor = db.cursor()
+        self.env.log.info('Deleting client event %s' % self.name)
+        cursor.execute("DELETE FROM client_events WHERE name=%s", (self.name,))
+
+        self.name = self._old_name = None
+
+        if handle_ta:
+            db.commit()
+
+    def insert(self, db=None):
+        assert not self.exists, 'Cannot insert existing client event'
+        system = ClientEventsSystem(self.env);
+        assert system.get_summary(self.summary) is not None , 'Invalid summary'
+        assert system.get_action(self.action) is not None, 'Invalid action'
+        self.name = simplify_whitespace(self.name)
+        assert self.name, 'Cannot create client event with no name'
+        if not db:
+            db = self.env.get_db_cnx()
+            handle_ta = True
+        else:
+            handle_ta = False
+
+        # Todo: verify client_event with that name does not currently exist...
+        cursor = db.cursor()
+        self.env.log.debug("Creating new client event '%s'" % self.name)
+        cursor.execute("INSERT INTO client_events (name,summary,action,lastrun) "
+                       "VALUES (%s,%s,%s,%s)",
+                       (self.name, self.summary, self.action, int(time.time())))
+
+        if handle_ta:
+            db.commit()
+
+    def _load_client_options(self, client, opttype, db):
+        assert self.exists, 'Cannot update non-existent client event'
+        assert opttype in ('summary', 'action'), 'Invalid options type'
+        system = ClientEventsSystem(self.env);
+        if 'summary' == opttype:
+          thing = system.get_summary(self.summary)
+          assert thing is not None , 'Invalid summary'
+          self.summary_description = thing.get_description()
+        else:
+          thing = system.get_action(self.action)
+          assert thing is not None, 'Invalid action'
+          self.action_description = thing.get_description()
+
+        options = {}
+        table = 'client_event_' + opttype + '_options'
+        cursor = db.cursor()
+        cursor.execute("SELECT name, value "
+                       "FROM " + table + " "
+                       "WHERE client_event=%s AND client=%s",
+                       (self._old_name, client or ''))
+        for name, value in cursor:
+          options[name] = value
+        rv = {}
+        for option in thing.options(client):
+          option['md5'] = md5.new(option['name']).hexdigest()
+          if options.has_key(option['name']):
+            option['value'] = options[option['name']]
+          else:
+            option['value'] = ''
+          rv[option['name']] = option
+        return rv
+
+
+    def _load_options(self, client, db):
+        self.summary_options = self._load_client_options(None, 'summary', db)
+        self.action_options = self._load_client_options(None, 'action', db)
+        if client:
+          self.summary_client_options = self._load_client_options(client, 'summary', db)
+          self.action_client_options = self._load_client_options(client, 'action', db)
+
+
+    def _update_client_options(self, client, opttype, options, db=None):
+        assert self.exists, 'Cannot update non-existent client event'
+        assert opttype in ('summary', 'action'), 'Invalid options type'
+        system = ClientEventsSystem(self.env);
+        if 'summary' == opttype:
+          thing = system.get_summary(self.summary)
+          assert thing is not None , 'Invalid summary'
+        else:
+          thing = system.get_action(self.action)
+          assert thing is not None, 'Invalid action'
+
+        if not db:
+            db = self.env.get_db_cnx()
+            handle_ta = True
+        else:
+            handle_ta = False
+
+        table = 'client_event_' + opttype + '_options'
+        cursor = db.cursor()
+        self.env.log.info('Updating client event "%s"' % self._old_name)
+        cursor.execute("DELETE FROM " + table + " "
+                       "WHERE client_event=%s AND client=%s",
+                       (self._old_name, client or ''))
+
+        valid_options = []
+        for option in thing.options(client):
+          valid_options.append(option['name'])
+        for option in options.values():
+          if option['name'] in valid_options:
+            cursor.execute("INSERT INTO " + table + " (client_event, client, name, value) "
+                           "VALUES (%s, %s, %s, %s)",
+                           (self._old_name, client or '', option['name'], option['value']))
+
+        if handle_ta:
+            db.commit()
+
+
+    def update_options(self, client=None, db=None):
+        assert self.exists, 'Cannot update non-existent client event'
+        if not db:
+            db = self.env.get_db_cnx()
+            handle_ta = True
+        else:
+            handle_ta = False
+
+        if client:
+          self._update_client_options(client, 'summary', self.summary_client_options, db)
+          self._update_client_options(client, 'action', self.action_client_options, db)
+        else:
+          self._update_client_options(None, 'summary', self.summary_options, db)
+          self._update_client_options(None, 'action', self.action_options, db)
+
+        if handle_ta:
+            db.commit()
+
+
+    def update(self, db=None):
+        assert self.exists, 'Cannot update non-existent client event'
+        self.name = simplify_whitespace(self.name)
+        assert self.name, 'Cannot update client event with no name'
+        if not db:
+            db = self.env.get_db_cnx()
+            handle_ta = True
+        else:
+            handle_ta = False
+
+        cursor = db.cursor()
+        self.env.log.info('Updating client event "%s"' % self._old_name)
+        cursor.execute("UPDATE client_events SET lastrun=%s "
+                       "WHERE name=%s",
+                       (int(self.lastrun), self._old_name))
+
+        if handle_ta:
+            db.commit()
+
+    def trigger(self, req, client, fromdate, todate, db=None):
+        assert self.exists, 'Cannot trigger a client event that does not exits'
+        system = ClientEventsSystem(self.env);
+        summary = system.get_summary(self.summary)
+        assert summary is not None , 'Invalid summary'
+        action = system.get_action(self.action)
+        assert action is not None, 'Invalid action'
+
+        if not summary.init(self, client):
+          self.env.log.info("Could not init summary")
+          return False
+        if not action.init(self, client):
+          self.env.log.info("Could not init action")
+          return False
+
+        self.env.log.debug("Performing action")
+        return action.perform(req, summary.get_summary(req, fromdate, todate))
+
+
+    def select(cls, env, client=None, db=None):
+        if not db:
+            db = env.get_db_cnx()
+        cursor = db.cursor()
+        cursor.execute("SELECT name, summary, action, lastrun "
+                       "FROM client_events "
+                       "ORDER BY name")
+        for name, summary, action, lastrun in cursor:
+            clev = cls(env)
+            clev.md5 = md5.new(name).hexdigest()
+            clev.name = clev._old_name = name
+            clev.summary = summary or ''
+            clev.action = action or ''
+            clev.lastrun = lastrun or 0
+            clev._load_options(client, db)
+            yield clev
+    select = classmethod(select)
+
+    def triggerall(cls, env, req, event, db=None):
+        if not db:
+            db = env.get_db_cnx()
+
+        try:
+          ev = cls(env, event, None, db)
+        except:
+          env.log.error("Could not run the event %s" % (event,))
+          return
+        #ev.lastrun = 1
+        now = int(time.time())
+
+        cursor = db.cursor()
+        cursor.execute("SELECT name FROM client ORDER BY name")
+        for client, in cursor:
+          env.log.info("Running event for client: %s" % (client, ))
+          clev = cls(env, event, client)
+          clev.trigger(req, client, ev.lastrun, now)
+        ev.lastrun = now
+        ev.update()
+    triggerall = classmethod(triggerall)