keithsalisbury-subtrac 0.1.4 → 0.1.5

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

@@ -1,105 +0,0 @@
-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

@@ -1,287 +0,0 @@
-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)

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

@@ -1,71 +0,0 @@
-from trac.core import *
-from trac.perm import PermissionSystem
-#from trac.ticket.model import AbstractEnum
-#from trac.ticket.admin import AbstractEnumAdminPage
-from trac.ticket.admin import TicketAdminPanel
-
-
-from clients.events import ClientEvent, ClientEventsSystem
-
-from trac.util.datefmt import utc, parse_date, get_date_format_hint, \
-                              get_datetime_format_hint
-from trac.web.chrome import add_link, add_script
-
-
-class ClientEventsAdminPanel(TicketAdminPanel):
-    
-    _type = 'clientevents'
-    _label = ('Client Events', 'Client Events')
-
-    # TicketAdminPanel methods
-    def _render_admin_panel(self, req, cat, page, event):
-        # Detail view?
-        if event:
-            clev = ClientEvent(self.env, event)
-            if req.method == 'POST':
-                if req.args.get('save'):
-                    # Client Events are not saved... just deleted or viewed...
-                    for option in clev.summary_options:
-                      arg = 'summary-option-%s' % clev.summary_options[option]['md5']
-                      clev.summary_options[option]['value'] = req.args.get(arg)
-                    for option in clev.action_options:
-                      arg = 'action-option-%s' % clev.action_options[option]['md5']
-                      clev.action_options[option]['value'] = req.args.get(arg)
-                    clev.update_options()
-                    req.redirect(req.href.admin(cat, page))
-                elif req.args.get('cancel'):
-                    req.redirect(req.href.admin(cat, page))
-
-            add_script(req, 'common/js/wikitoolbar.js')
-            data = {'view': 'detail', 'event': clev}
-
-        else:
-            if req.method == 'POST':
-                # Add Client
-                if req.args.get('add') and req.args.get('name'):
-                    clev = ClientEvent(self.env)
-                    clev.name = req.args.get('name')
-                    clev.summary = req.args.get('summary')
-                    clev.action = req.args.get('action')
-                    clev.insert()
-                    req.redirect(req.href.admin(cat, page))
-
-                # Remove clients
-                elif req.args.get('remove') and req.args.get('sel'):
-                    sel = req.args.get('sel')
-                    sel = isinstance(sel, list) and sel or [sel]
-                    if not sel:
-                        raise TracError('No client event selected')
-                    db = self.env.get_db_cnx()
-                    for name in sel:
-                        clev = ClientEvent(self.env, name, db=db)
-                        clev.delete(db=db)
-                    db.commit()
-                    req.redirect(req.href.admin(cat, page))
-
-            data = {'view': 'list',
-                    'events': ClientEvent.select(self.env),
-                    'summaries': ClientEventsSystem(self.env).get_summaries(),
-                    'actions': ClientEventsSystem(self.env).get_actions()}
-
-        return 'admin_client_events.html', data