Include annotations in bundle search results.

charmworld/views/api/__init__.py

 __metaclass__ = type
 
 from datetime import (
     datetime,
     timedelta,
 )
 from email.utils import parseaddr
 from inspect import getargspec
 from os.path import (
     join,
@@ skipping 177 matching lines @@
                 self._format_related(payload['data'], payload['weight'])
                 for payload in value]
         f_provides = {}
         for key, value in r_provides.items():
             f_provides[key] = [
                 self._format_related(payload['data'], payload['weight'])
                 for payload in value]
         return f_requires, f_provides
 
     @classmethod
-    def _format_charm(cls, charm, extra_data={}):
+    def _format_charm(cls, charm, annotations=None):
         """Format the charm for API consumers."""
         mapping = {
             'summary': 'summary',
             'name': 'name',
             'description': 'description',
             'owner': 'owner',
             'downloads': 'downloads',
             'downloads_in_past_30_days': 'downloads_in_past_30_days',
             'distro_series': 'series',
             'revision': 'revision',
@@ skipping 30 matching lines @@
                 'provides': charm.provides,
                 'requires': charm.requires,
             },
             'options': charm.options,
             'files': [join(entry['subdir'], entry['filename'])
                       for entry in charm.files.values()],
             'is_approved': charm.promulgated,
             'tested_providers': tested_providers,
             'is_subordinate': charm.subordinate
         })
-        annotations = extra_data.get('annotations')
         if annotations is not None:
             output.update({'annotations': annotations})
         return output
 
     @classmethod
     def _format_related(cls, charm_data, weight, _now=None):
         if _now is None:
             now = datetime.utcnow()
         else:
             now = _now
@@ skipping 185 matching lines @@
         mongo_bundle = db.bundles.find_one({'_id': bundle.id})
         mongo_services = mongo_bundle['data']['services']
         service_data = bundle_dict.get('data')
         # Now load the charm information we require for the services in the
         # bundle.
         for service, data in bundle.data['services'].iteritems():
             description = BundledCharmDescription(
                 service, data, service_data.get('series'))
             charm = resolve_charm_from_description(db, description)
             if charm:
+                annotations = mongo_services[service].get('annotations')
                 formatted = cls._format_charm(
-                    Charm(charm), mongo_services[service])
+                    Charm(charm), annotations=annotations)
                 bundle_dict['charm_metadata'][service] = formatted
-
+                if 'annotations' not in data:
+                    data['annotations'] = annotations
         return bundle_dict
 
     def _find_bundle(self, path):
         try:
             bundle_id, trailing, bundle_bits = self._parse_bundle_id(path)
         except ValueError:
             bundle = bundle_id = trailing = bundle_bits = None
         else:
             if bundle_bits['owner'] and bundle_bits['version']:
                 # We have all 4 parts needed, just use the ID.
                 query = {'_id': bundle_id}
             elif bundle_bits['owner']:
                 # This URL includes the owner, basket name, and bundle name.
                 # The specified bundle may be promulgated or not.
                 owner = bundle_bits['owner'][1:]  # Strip the tilde.
                 query = {
                     'owner': owner,
                     'basket_name': bundle_bits['basket'],
-                    'name': bundle_bits['bundle']
+                    'name': bundle_bits['bundle'],
                 }
             else:
                 query = {
                     'basket_name': bundle_bits['basket'],
                     'name': bundle_bits['bundle'],
-                    'promulgated': True
+                    'promulgated': True,
                 }
 
             bundle = Bundle.from_query(query, self.request.db)
         return bundle_id, trailing, bundle
 
     def charm(self, path=None, **kwargs):
         """Retrieve a charm according to its API ID (the path prefix)."""
         if path is None:
             raise HTTPNotFound(self.request.path)
         charm_id, trailing, charm_data = self._find_charm(path)
@@ skipping 337 matching lines @@
                     'series': series,
                     'name': name,
                 }, sort=[('store_data.revision', pymongo.DESCENDING)])
         if charm is not None:
             api_id = self._get_api_id(Charm(charm))
             # Charm ID should match up to, but not including the revision.
             revisionless_charm_id = charm_id.split('-', 1)[0]
             if not api_id.startswith(revisionless_charm_id):
                 charm = None
         return charm_id, trailing, charm