← Back to branch summary

~launchpad-pqm/launchpad/devel

« back to all changes in this revision

Viewing changes to lib/lp/bugs/model/bugtask.py

  • Committer: Curtis Hovey
  • Date: 2011-12-24 17:49:30 UTC
  • mto: This revision was merged to the branch mainline in revision 14602.
  • Revision ID: curtis.hovey@canonical.com-20111224174930-xk1d5cvhyxq46ctf
Moved webapp to lp.services.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/lp/bugs/model/bugtask.py
71
71
    removeSecurityProxy,
72
72
    )
73
73
 
 
74
from canonical.config import config
 
75
from canonical.database.constants import UTC_NOW
 
76
from canonical.database.datetimecol import UtcDateTimeCol
 
77
from canonical.database.enumcol import EnumCol
 
78
from canonical.database.nl_search import nl_phrase_search
 
79
from canonical.database.sqlbase import (
 
80
    block_implicit_flushes,
 
81
    convert_storm_clause_to_string,
 
82
    cursor,
 
83
    quote,
 
84
    quote_like,
 
85
    SQLBase,
 
86
    sqlvalues,
 
87
    )
 
88
from lp.services.helpers import shortlist
 
89
from lp.services.database.lpstorm import IStore
 
90
from lp.services.searchbuilder import (
 
91
    all,
 
92
    any,
 
93
    greater_than,
 
94
    not_equals,
 
95
    NULL,
 
96
    )
 
97
from lp.services.webapp.interfaces import (
 
98
    DEFAULT_FLAVOR,
 
99
    ILaunchBag,
 
100
    IStoreSelector,
 
101
    MAIN_STORE,
 
102
    )
74
103
from lp.app.enums import ServiceUsage
75
104
from lp.app.errors import NotFoundError
76
105
from lp.app.interfaces.launchpad import ILaunchpadCelebrities
131
160
from lp.registry.model.pillar import pillar_sort_key
132
161
from lp.registry.model.sourcepackagename import SourcePackageName
133
162
from lp.services import features
134
 
from lp.services.config import config
135
 
from lp.services.database.constants import UTC_NOW
136
 
from lp.services.database.datetimecol import UtcDateTimeCol
137
163
from lp.services.database.decoratedresultset import DecoratedResultSet
138
 
from lp.services.database.enumcol import EnumCol
139
 
from lp.services.database.lpstorm import IStore
140
 
from lp.services.database.nl_search import nl_phrase_search
141
 
from lp.services.database.sqlbase import (
142
 
    block_implicit_flushes,
143
 
    convert_storm_clause_to_string,
144
 
    cursor,
145
 
    quote,
146
 
    quote_like,
147
 
    SQLBase,
148
 
    sqlvalues,
149
 
    )
150
 
from lp.services.helpers import shortlist
151
164
from lp.services.propertycache import (
152
165
    cachedproperty,
153
166
    get_property_cache,
154
167
    )
155
 
from lp.services.searchbuilder import (
156
 
    all,
157
 
    any,
158
 
    greater_than,
159
 
    not_equals,
160
 
    NULL,
161
 
    )
162
 
from lp.services.webapp.interfaces import (
163
 
    DEFAULT_FLAVOR,
164
 
    ILaunchBag,
165
 
    IStoreSelector,
166
 
    MAIN_STORE,
167
 
    )
168
168
from lp.soyuz.enums import PackagePublishingStatus
169
169
 
170
170
 
2041
2041
        #
2042
2042
        # XXX: kiko 2006-03-16:
2043
2043
        # Is this a good candidate for becoming infrastructure in
2044
 
        # lp.services.database.sqlbase?
 
2044
        # canonical.database.sqlbase?
2045
2045
        for arg_name, arg_value in standard_args.items():
2046
2046
            if arg_value is None:
2047
2047
                continue
2368
2368
                "BugTask.datecreated > %s" % (
2369
2369
                    sqlvalues(params.created_since,)))
2370
2370
 
 
2371
        orderby_arg, extra_joins = self._processOrderBy(params)
 
2372
        join_tables.extend(extra_joins)
 
2373
 
2371
2374
        query = " AND ".join(extra_clauses)
2372
2375
 
2373
2376
        if not decorators:
2383
2386
        else:
2384
2387
            with_clause = None
2385
2388
        return (
2386
 
            query, clauseTables, decorator, join_tables,
 
2389
            query, clauseTables, orderby_arg, decorator, join_tables,
2387
2390
            has_duplicate_results, with_clause)
2388
2391
 
2389
2392
    def buildUpstreamClause(self, params):
2641
2644
                    SpecificationBug.specification %s)
2642
2645
                """ % search_value_to_where_condition(linked_blueprints)
2643
2646
 
2644
 
    def buildOrigin(self, join_tables, prejoin_tables, clauseTables,
2645
 
                    start_with=BugTask):
 
2647
    def buildOrigin(self, join_tables, prejoin_tables, clauseTables):
2646
2648
        """Build the parameter list for Store.using().
2647
2649
 
2648
2650
        :param join_tables: A sequence of tables that should be joined
2661
2663
        and in clauseTables. This method ensures that each table
2662
2664
        appears exactly once in the returned sequence.
2663
2665
        """
2664
 
        origin = [start_with]
 
2666
        origin = [BugTask]
2665
2667
        already_joined = set(origin)
2666
2668
        for table, join in join_tables:
2667
2669
            if table is None or table not in already_joined:
2689
2691
        :param args: optional additional BugTaskSearchParams instances,
2690
2692
        """
2691
2693
        orig_store = store = IStore(BugTask)
2692
 
        [query, clauseTables, bugtask_decorator, join_tables,
 
2694
        [query, clauseTables, orderby, bugtask_decorator, join_tables,
2693
2695
        has_duplicate_results, with_clause] = self.buildQuery(params)
2694
2696
        if with_clause:
2695
2697
            store = store.with_(with_clause)
2696
 
        orderby_expression, orderby_joins = self._processOrderBy(params)
2697
2698
        if len(args) == 0:
2698
2699
            if has_duplicate_results:
2699
2700
                origin = self.buildOrigin(join_tables, [], clauseTables)
2700
 
                outer_origin = self.buildOrigin(
2701
 
                     orderby_joins, prejoins, [])
 
2701
                outer_origin = self.buildOrigin([], prejoins, [])
2702
2702
                subquery = Select(BugTask.id, where=SQL(query), tables=origin)
2703
2703
                resultset = store.using(*outer_origin).find(
2704
2704
                    resultrow, In(BugTask.id, subquery))
2705
2705
            else:
2706
 
                origin = self.buildOrigin(
2707
 
                    join_tables + orderby_joins, prejoins, clauseTables)
 
2706
                origin = self.buildOrigin(join_tables, prejoins, clauseTables)
2708
2707
                resultset = store.using(*origin).find(resultrow, query)
2709
2708
            if prejoins:
2710
2709
                decorator = lambda row: bugtask_decorator(row[0])
2711
2710
            else:
2712
2711
                decorator = bugtask_decorator
2713
2712
 
2714
 
            resultset.order_by(orderby_expression)
 
2713
            resultset.order_by(orderby)
2715
2714
            return DecoratedResultSet(resultset, result_decorator=decorator,
2716
2715
                pre_iter_hook=pre_iter_hook)
2717
2716
 
2721
2720
 
2722
2721
        decorators = [bugtask_decorator]
2723
2722
        for arg in args:
2724
 
            [query, clauseTables, decorator, join_tables,
 
2723
            [query, clauseTables, ignore, decorator, join_tables,
2725
2724
             has_duplicate_results, with_clause] = self.buildQuery(arg)
2726
2725
            origin = self.buildOrigin(join_tables, [], clauseTables)
2727
2726
            localstore = store
2746
2745
                bugtask = decorator(bugtask)
2747
2746
            return bugtask
2748
2747
 
2749
 
        origin = self.buildOrigin(
2750
 
            orderby_joins, prejoins, [],
2751
 
            start_with=Alias(resultset._get_select(), "BugTask"))
 
2748
        origin = [Alias(resultset._get_select(), "BugTask")]
2752
2749
        if prejoins:
 
2750
            origin += [join for table, join in prejoins]
2753
2751
            decorator = prejoin_decorator
2754
2752
        else:
2755
2753
            decorator = simple_decorator
2756
2754
 
2757
2755
        result = store.using(*origin).find(resultrow)
2758
 
        result.order_by(orderby_expression)
 
2756
        result.order_by(orderby)
2759
2757
        return DecoratedResultSet(result, result_decorator=decorator,
2760
2758
            pre_iter_hook=pre_iter_hook)
2761
2759