source: trunk/plugins/tickettypedsystem/ticketsystem/tickettypes/util.py @ 415

# -*- coding: utf-8 -*-
#
# Copyright 2008 Optaros, Inc

from trac.core import Component, ExtensionPoint, implements
from ticketsystem.inireader import TicketConfigurationReader
from ticketsystem.api import IOperationsProvider

class TicketMetadataProvider(Component):
    
    def __init__(self, *args, **kwargs):
        # init the parent
        super(TicketMetadataProvider, self).__init__(*args, **kwargs)
        self.reader = TicketConfigurationReader(self.env)

    def get_defined_realms(self):
        return self.reader.get_resources()
    
    def get_ticket_types(self, resource):
        return self.reader.get_groupings(resource)
        
    def get_relationship_filters(self, resource, type):
        # see if the resource has metadata
        if resource.realm in self.reader.get_resources(): 
            return self.reader.get_relationships(resource, type)
        return None
    
    def get_field_filters(self, resource, type):
        # see if the resource has metadata
        if resource.realm in self.reader.get_resources(): 
            return self.reader.get_filters_for_grouping(resource, type)
        return None
    
    def get_ticket_group_field(self, resource):
        return self.reader.get_groupings(resource)[0]


class OperationsSystem(Component):
    operations = ExtensionPoint(IOperationsProvider)
    pass

class SynchronizeFields(Component):
    
    implements(IOperationsProvider)
    
    def get_operation_name(self):
        return 'synchronize'
    
    def register_for_events(self):
        yield 'change'
        yield 'create'
    
    def run(self, args):
        """
        Make the resources have the same values of there attributes.
        
        @param args: tuple 
        list[trac.resource.Resource], list[String] 
        tickets, ticket field names
        @return list[trac.resource.Resource]
        """
        resources, attributes = args
        # create the store data dictionary 
        data = dict.fromkeys(attributes, 
                               dict.fromkeys([res.id for res in resources], 
                                               dict()))
        # init  the data dictionary
        for attribute in data.keys() :
            for resource in resources :
                if data[attribute][resource.id].has_key(resource[attribute]) :
                    data[attribute][resource.id][resource[attribute]] += 1
                else :
                    data[attribute][resource.id][resource[attribute]] = 1
        
        # create a store for the min values
        values = dict().fromkeys(attributes)
        
        def get_min_key(d):
            # get the first values
            min_key = d.keys()[0]
            min_value = d[d.keys()[0]]
            # get the min
            for key in d.keys():
                if min_value > d[key] :
                    min_value = d[key]
                    min_key = key
            return min_key
        
        # synchronize all resources to the same unique value
        for attribute in data.keys() :
            for resource in data[attribute].keys() :
                values[attribute] = get_min_key(data[attribute][resource])
        
        # copy the values 
        for resource in resources :
            for att in attributes :
                resource[att] = values[att]
        
        return resources
    
class CopyFields(Component):
    
    implements(IOperationsProvider)
    
    def get_operation_name(self):
        return 'copy'
    
    def register_for_events(self):
        yield 'change'
        yield 'create'
    
    def run(self, args):
        from_resource, to_resources, attributes = args
        pass
    
class SumFields(Component):
    
    implements(IOperationsProvider)
    
    def get_operation_name(self):
        return 'sum'
    
    def register_for_events(self):
        yield 'change'
        yield 'create'
    
    def run(self, args):
        resource, from_resources, attribute = args
        pass

class AvgFields(Component):
    
    implements(IOperationsProvider)
    
    def get_operation_name(self):
        return 'avg'
    
    def register_for_events(self):
        yield 'change'
        yield 'create'
        
    def run(self, args):
        resource, from_resources, attribute = args

class ProcentFields(Component):
    
    implements(IOperationsProvider)
    
    def get_operation_name(self):
        return 'procent'
    
    def register_for_events(self):
        yield 'change'
        yield 'create'
            
    def run(self, args):
        resource, from_resources, attribute =args