def test_sale_with_discount(client, sale_payload, store): sale_payload['products'][0]['quantity'] = 10 sale_payload['payments'][0]['value'] = 100 sale_payload['discount_value'] = 25 response = client.post('/sale', json=sale_payload) sale = store.find(Sale).order_by(Desc(Sale.open_date)).first() assert response.status_code == 201 assert sale.get_total_sale_amount() == currency('75') assert sale.discount_value == currency('25')
def translators(self): """See `ILanguage`.""" from lp.registry.model.person import ( Person, PersonLanguage, ) return IStore(Language).using( Join(Person, LanguageSet._getTranslatorJoins(), Person.id == PersonLanguage.personID), ).find( Person, PersonLanguage.language == self, ).order_by(Desc(KarmaCache.karmavalue))
def test_limitsGroupedByOrderDirection(self): # limitsGroupedByOrderDirection() returns a sequence of # (expressions, memos), where expressions is a list of # ORDER BY expressions which either are all instances of # PropertyColumn, or are all instances of Desc(PropertyColumn). # memos are the related limit values. resultset = self.makeStormResultSet() range_factory = StormRangeFactory(resultset, self.logError) order_by = [ Person.id, Person.datecreated, Person.name, Person.display_name ] limits = [1, datetime(2011, 7, 25, 0, 0, 0), 'foo', 'bar'] result = range_factory.limitsGroupedByOrderDirection(order_by, limits) self.assertEqual([(order_by, limits)], result) order_by = [ Desc(Person.id), Desc(Person.datecreated), Desc(Person.name), Desc(Person.display_name) ] result = range_factory.limitsGroupedByOrderDirection(order_by, limits) self.assertEqual([(order_by, limits)], result) order_by = [ Person.id, Person.datecreated, Desc(Person.name), Desc(Person.display_name) ] result = range_factory.limitsGroupedByOrderDirection(order_by, limits) self.assertEqual([(order_by[:2], limits[:2]), (order_by[2:], limits[2:])], result)
def preloadDataForBMPs(branch_merge_proposals, user): # Utility to load the data related to a list of bmps. # Circular imports. from lp.code.model.branch import Branch from lp.code.model.branchcollection import GenericBranchCollection from lp.registry.model.product import Product from lp.registry.model.distroseries import DistroSeries ids = set() source_branch_ids = set() person_ids = set() for mp in branch_merge_proposals: ids.add(mp.id) source_branch_ids.add(mp.source_branchID) person_ids.add(mp.registrantID) person_ids.add(mp.merge_reporterID) branches = load_related( Branch, branch_merge_proposals, ("target_branchID", "prerequisite_branchID", "source_branchID")) # The stacked on branches are used to check branch visibility. GenericBranchCollection.preloadVisibleStackedOnBranches(branches, user) if len(branches) == 0: return # Pre-load PreviewDiffs and Diffs. preview_diffs = IStore(BranchMergeProposal).find( PreviewDiff, PreviewDiff.branch_merge_proposal_id.is_in(ids)).order_by( PreviewDiff.branch_merge_proposal_id, Desc(PreviewDiff.date_created)).config( distinct=[PreviewDiff.branch_merge_proposal_id]) load_related(Diff, preview_diffs, ['diff_id']) for previewdiff in preview_diffs: cache = get_property_cache(previewdiff.branch_merge_proposal) cache.preview_diff = previewdiff # Add source branch owners' to the list of pre-loaded persons. person_ids.update(branch.ownerID for branch in branches if branch.id in source_branch_ids) # Pre-load Person and ValidPersonCache. list( getUtility(IPersonSet).getPrecachedPersonsFromIDs( person_ids, need_validity=True)) # Pre-load branches' data. load_related(SourcePackageName, branches, ['sourcepackagenameID']) load_related(DistroSeries, branches, ['distroseriesID']) load_related(Product, branches, ['productID']) GenericBranchCollection.preloadDataForBranches(branches)
def extractTrendingHashtags(store, limit=10, duration=None): """Extract information about trending hashtags and store it in FluidDB. @param store: The storm store to query and to save our result to. @param limit: Optionally, the number of objects to retrieve. @param duration: Optionally, the recent time period to look at when determining which hashtags are trending. Default is 28 days. The storm query below results in SQL like: SELECT COUNT(DISTINCT comments.object_id) AS count, about_tag_values.value, array_agg(ROW(comments.username, comments.creation_time)) FROM about_tag_values, comment_object_link, comments WHERE about_tag_values.value LIKE '#%' AND about_tag_values.object_id = comment_object_link.object_id AND comments.object_id = comment_object_link.comment_id AND comments.creation_time >= '2012-11-09 07:42:40'::TIMESTAMP AND CHAR_LENGTH(about_tag_values.value) >= 2 GROUP BY about_tag_values.value ORDER BY count DESC LIMIT 10 """ duration = timedelta(days=28) if duration is None else duration startTime = datetime.utcnow() - duration count = Alias(Count(Comment.objectID, distinct=True)) result = store.find( (count, AboutTagValue.value, Func('array_agg', Row(Comment.username, Comment.creationTime))), Like(AboutTagValue.value, u'#%'), AboutTagValue.objectID == CommentObjectLink.objectID, Comment.objectID == CommentObjectLink.commentID, Comment.creationTime >= startTime, Func('CHAR_LENGTH', AboutTagValue.value) >= 2) result.group_by(AboutTagValue.value) result.order_by(Desc(count)) result.config(limit=limit) data = [{ 'count': count, 'usernames': _sortUsernames(usernames), 'value': hashtag } for count, hashtag, usernames in result] user = getUser(u'fluidinfo.com') tagValues = TagValueAPI(user) objectID = ObjectAPI(user).create(u'fluidinfo.com') tagValues.set( {objectID: { u'fluidinfo.com/trending-hashtags': json.dumps(data) }}) store.commit()
def __set__(self, obj, value): if obj._self_in_database is None: spph = Store.of(obj.distribution).find( SourcePackagePublishingHistory, SourcePackagePublishingHistory.distroseriesID == DistroSeries.id, DistroSeries.distributionID == obj.distribution.id, SourcePackagePublishingHistory.sourcepackagenameID == obj.sourcepackagename.id).order_by( Desc(SourcePackagePublishingHistory.id)).first() obj._new(obj.distribution, obj.sourcepackagename, is_upstream_link_allowed(spph)) setattr(obj._self_in_database, self.attrname, value)
def source_mirror_freshness(self): """See IDistributionMirror""" store = Store.of(self) mirror = store.find( MirrorDistroSeriesSource, And(MirrorDistroSeriesSource.distribution_mirror == self, MirrorDistroSeriesSource.freshness != MirrorFreshness.UNKNOWN)).order_by( Desc(MirrorDistroSeriesSource.freshness)).first() if not mirror: return None else: return mirror.freshness
def test_lifecycle(self): """Test with an option that's part of the default sort. Sorting on LIFECYCYLE moves the lifecycle reference to the first element of the output.""" # Check that this isn't a no-op. lifecycle_order = BranchListingView._listingSortToOrderBy( BranchListingSort.LIFECYCLE) self.assertSortsEqual([ Desc(Branch.lifecycle_status), Asc(Product.name), Asc(Owner.name), Asc(Branch.name) ], lifecycle_order)
def _getBySubscriber(self, subscriber, archive, current_only, with_active_tokens): """Return all the subscriptions for a person. :param subscriber: An `IPerson` for whom to return all `ArchiveSubscriber` records. :param archive: An optional `IArchive` which restricts the results to that particular archive. :param current_only: Whether the result should only include current subscriptions (which is the default). :param with_active_tokens: Indicates whether the tokens for the given subscribers subscriptions should be included in the resultset. By default the tokens are not included in the resultset. """ # Grab the extra Storm expressions, for this query, # depending on the params: extra_exprs = self._getExprsForSubscriptionQueries( archive, current_only) origin = [ ArchiveSubscriber, Join(TeamParticipation, TeamParticipation.teamID == ArchiveSubscriber.subscriber_id) ] if with_active_tokens: result_row = (ArchiveSubscriber, ArchiveAuthToken) # We need a left join with ArchiveSubscriber as # the origin: origin.append( LeftJoin( ArchiveAuthToken, And( ArchiveAuthToken.archive_id == ArchiveSubscriber.archive_id, ArchiveAuthToken.person_id == subscriber.id, ArchiveAuthToken.date_deactivated == None))) else: result_row = ArchiveSubscriber # Set the main expression to find all the subscriptions for # which the subscriber is a direct subscriber OR is a member # of a subscribed team. # Note: the subscription to the owner itself will also be # part of the join as there is a TeamParticipation entry # showing that each person is a member of the "team" that # consists of themselves. store = Store.of(subscriber) return store.using(*origin).find( result_row, TeamParticipation.personID == subscriber.id, *extra_exprs).order_by(Desc(ArchiveSubscriber.date_created))
def _parse_orderBy(cls, orderBy): result = [] if not isinstance(orderBy, (tuple, list)): orderBy = (orderBy, ) for item in orderBy: if isinstance(item, basestring): desc = item.startswith("-") if desc: item = item[1:] item = cls._attr_to_prop.get(item, item) if desc: item = Desc(item) result.append(item) return tuple(result)
def getReleasesAndPublishingHistory(self): """See `IDistributionSourcePackage`.""" store = Store.of(self.distribution) result = store.find( (SourcePackageRelease, SourcePackagePublishingHistory), SourcePackagePublishingHistory.distroseries == DistroSeries.id, DistroSeries.distribution == self.distribution, SourcePackagePublishingHistory.archiveID.is_in( self.distribution.all_distro_archive_ids), SourcePackagePublishingHistory.sourcepackagename == self.sourcepackagename, SourcePackageRelease.id == SourcePackagePublishingHistory.sourcepackagereleaseID) result.order_by(Desc(SourcePackageRelease.id), Desc(SourcePackagePublishingHistory.datecreated), Desc(SourcePackagePublishingHistory.id)) # Collate the publishing history by SourcePackageRelease. dspr_pubs = [] for spr, pubs in itertools.groupby(result, operator.itemgetter(0)): dspr_pubs.append((DistributionSourcePackageRelease( distribution=self.distribution, sourcepackagerelease=spr), [spph for (spr, spph) in pubs])) return dspr_pubs
def _update_sintegra_data(self): data = self._driver.get_sintegra() if data is None: return store = new_store() # coupon_start and coupon_end are actually, start coo, and current coo. coupon_start = data.coupon_start coupon_end = data.coupon_end # 0 means that the start coo isn't known, fetch # the current coo from the the database and add 1 # TODO: try to avoid this hack if coupon_start == 0: results = store.find(FiscalDayHistory, station=self._printer.station).order_by( Desc(FiscalDayHistory.emission_date)) if results.count(): coupon_start = results[0].coupon_end + 1 else: coupon_start = 1 # Something went wrong or no coupons opened during the day if coupon_end <= coupon_start: store.commit(close=True) return station = store.fetch(self._printer.station) day = FiscalDayHistory( store=store, emission_date=data.opening_date, station=station, serial=unicode(data.serial), # 1 -> 001, FIXME: should fix stoqdrivers serial_id=int(data.serial_id), coupon_start=coupon_start, coupon_end=coupon_end, crz=data.crz, cro=data.cro, reduction_date=TransactionTimestamp(), period_total=data.period_total, total=data.total) for code, value, type in data.taxes: FiscalDayTax(fiscal_day_history=day, code=unicode(code), value=value, type=unicode(type), store=store) store.commit(close=True)
def findRelatedArchives(self, exclude_archive=None, archive_purpose=ArchivePurpose.PPA, required_karma=0): """See `IDistributionSourcePackage`.""" extra_args = [] # Exclude the specified archive where appropriate if exclude_archive is not None: extra_args.append(Archive.id != exclude_archive.id) # Filter by archive purpose where appropriate if archive_purpose is not None: extra_args.append(Archive.purpose == archive_purpose) # Include only those archives containing the source package released # by a person with karma for this source package greater than that # specified. if required_karma > 0: extra_args.append(KarmaTotalCache.karma_total >= required_karma) store = Store.of(self.distribution) results = store.find( Archive, Archive.distribution == self.distribution, Archive._enabled == True, Archive._private == False, SourcePackagePublishingHistory.archive == Archive.id, (SourcePackagePublishingHistory.status == PackagePublishingStatus.PUBLISHED), (SourcePackagePublishingHistory.sourcepackagerelease == SourcePackageRelease.id), (SourcePackagePublishingHistory.sourcepackagename == self.sourcepackagename), # Ensure that the package was not copied. SourcePackageRelease.upload_archive == Archive.id, # Next, the joins for the ordering by soyuz karma of the # SPR creator. KarmaTotalCache.person == SourcePackageRelease.creatorID, *extra_args) # Note: If and when we later have a field on IArchive to order by, # such as IArchive.rank, we will then be able to return distinct # results. As it is, we cannot return distinct results while ordering # by a non-selected column. results.order_by(Desc(KarmaTotalCache.karma_total), Archive.id) return results
def get_previous_build(self, tree, host, compiler, revision): from buildfarm.sqldb import Cast cur_build = self.get_build(tree, host, compiler, revision) result = self.store.find(StormBuild, Cast(StormBuild.tree, "TEXT") == Cast(tree, "TEXT"), Cast(StormBuild.host, "TEXT") == Cast(host, "TEXT"), Cast(StormBuild.compiler, "TEXT") == Cast(compiler, "TEXT"), Cast(StormBuild.revision, "TEXT") != Cast(revision, "TEXT"), StormBuild.id < cur_build.id) result = result.order_by(Desc(StormBuild.id)) prev_build = result.first() if prev_build is None: raise NoSuchBuildError(tree, host, compiler, revision) return prev_build
def listSharesToUpdate(self, since=None): zs = getUtility(IZStorm).get("tilde") zs.rollback() for home, status in itertools.groupby( zs.using(Home, LeftJoin( HomeState, Home.id == HomeState.id, )).find((Home, HomeState)).order_by(Home.id, Desc(HomeState.ts)), operator.itemgetter(0)): status = [s.copy() for h, s in status if s is not None] if ((len(status) > 1) or (home.active and not status) or (status and not home.match(status[0]))): yield home.copy(), status
def get_build(self, tree, host, compiler, revision=None, checksum=None): from buildfarm.sqldb import Cast expr = [ Cast(StormBuild.tree, "TEXT") == Cast(tree, "TEXT"), Cast(StormBuild.host, "TEXT") == Cast(host, "TEXT"), Cast(StormBuild.compiler, "TEXT") == Cast(compiler, "TEXT"), ] if revision is not None: expr.append(Cast(StormBuild.revision, "TEXT") == Cast(revision, "TEXT")) if checksum is not None: expr.append(Cast(StormBuild.checksum, "TEXT") == Cast(checksum, "TEXT")) result = self.store.find(StormBuild, *expr).order_by(Desc(StormBuild.upload_time)) ret = result.first() if ret is None: raise NoSuchBuildError(tree, host, compiler, revision) return ret
def get_a_fucking_random_submission(self, store): aits = store.find(InternalTip) self.failIfEqual( aits.count(), 0, "in our Eternal Mangekyō Sharingan, no InternalTip are available") rits = store.find(ReceiverTip) self.failIfEqual( rits.count(), 0, "in our Eternal Mangekyō Sharingan, no ReceiverTip are available") # just because # storm.exceptions.UnorderedError: Can't use first() on unordered result set rits.order_by(Desc(ReceiverTip.id)) return serialize_receivertip(rits.first())
def test_sale_with_delivery(mock_can_emit_nfe, client, sale_payload_new_client, example_creator, store): sale_payload_new_client['delivery'] = { 'freight_type': 'cif', 'price': 15, 'transporter': { 'cnpj': '23335270000159', 'name': 'Stoq Tecnologia', 'address': { 'street': 'Rua Rui Barbosa', 'streetnumber': 2000, 'district': 'Centro', 'postal_code': '13560-120', 'is_main_address': True, 'city_location': { 'country': 'Brazil', 'state': 'SP', 'city': 'São Carlos', }, } }, 'volumes': { 'kind': 'Caixas', 'quantity': 1, 'net_weight': 2, 'gross_weight': 3, } } response = client.post('/sale', json=sale_payload_new_client) sale = store.find(Sale).order_by(Desc(Sale.open_date)).first() assert response.status_code == 201 assert sale.get_total_sale_amount() == 25 assert len(list(sale.deliveries)) == 1 delivery = list(sale.deliveries)[0] assert delivery.transporter == sale.transporter assert delivery.transporter.person.company.cnpj == '23.335.270/0001-59' assert delivery.transporter.person.name == 'Stoq Tecnologia' assert delivery.transporter.person.address.street == 'Rua Rui Barbosa' assert delivery.freight_type == 'cif' assert delivery.address.street == 'Rua Aquidaban' assert delivery.volumes_kind == 'Caixas' assert delivery.volumes_quantity == 1 assert delivery.volumes_net_weight == 2 assert delivery.volumes_gross_weight == 3
def get_group_info(gid): """Get infos about the specified group. Includes: - participants in the group (ID, nickname & stats) - current DJ (ID & nickname) - info about last track """ group = g.store.get(Group, gid) if group is None: raise helpers.BadRequest(errors.INVALID_GROUP, "group does not exist") userdict = dict() for user in group.users: userdict[user.id] = {'nickname': user.nickname} # Search for the last track that was played. results = g.store.find(GroupEvent, (GroupEvent.event_type == events.PLAY) & (GroupEvent.group == group)) track = None play_event = results.order_by(Desc(GroupEvent.created)).first() if play_event is not None: artist = play_event.payload.get('artist') title = play_event.payload.get('title') row = g.store.find(Track, (Track.artist == artist) & (Track.title == title)).one() image = row.image if row is not None else None track = { 'artist': artist, 'title': title, 'image': image, } for entry in play_event.payload.get('stats', []): if entry.get('uid') in userdict: uid = entry['uid'] userdict[uid]['score'] = entry.get('score') userdict[uid]['predicted'] = entry.get('predicted', True) users = list() for key, val in userdict.iteritems(): users.append({ 'uid': key, 'nickname': val.get('nickname'), 'score': val.get('score'), 'predicted': val.get('predicted', True) }) master = None if group.master is not None: master = {'uid': group.master.id, 'nickname': group.master.nickname} return jsonify(name=group.name, track=track, master=master, users=users)
def consecutive_failure_count(self): """See `ICodeImport`.""" # This SQL translates as "how many code import results have there been # for this code import since the last successful one". # This is not very efficient for long lists of code imports. last_success = Func( "coalesce", Select(CodeImportResult.id, And( CodeImportResult.status.is_in( CodeImportResultStatus.successes), CodeImportResult.code_import == self), order_by=Desc(CodeImportResult.id), limit=1), 0) return Store.of(self).find(CodeImportResult, CodeImportResult.code_import == self, CodeImportResult.id > last_success).count()
def get_messages_list(store, user_id, tip_id): rtip = access_tip(store, user_id, tip_id) msglist = store.find(Message, Message.receivertip_id == rtip.id) msglist.order_by(Desc(Message.creation_date)) content_list = [] for msg in msglist: content_list.append(receiver_serialize_message(msg)) if not msg.visualized and msg.type == u'whistleblower': log.debug("Marking as readed message [%s] from %s" % (msg.content, msg.author)) msg.visualized = True return content_list
def cleanup(interval, verbose): thresh = datetime.datetime.fromtimestamp(time.time() - interval * 60 * 60) store = uutils.get_store() for group in store.find(Group, Group.is_active == True): # Iterate over all active groups. last_event = store.find(GroupEvent, GroupEvent.group == group).order_by( Desc(GroupEvent.created)).first() if (last_event is None and group.created < thresh or last_event is not None and last_event.created < thresh): # Group is old and has no event, or last event is old. if verbose: print "deactivating group %d (%s)" % (group.id, group.name) group.is_active = False for user in group.users: user.group = None store.commit()
def get_anomaly_history(store, limit): anomalies = store.find(Anomalies).order_by(Desc(Anomalies.date))[:limit] anomaly_history = [] for _, anomaly in enumerate(anomalies): anomaly_entry = dict({ 'date': datetime_to_ISO8601(anomaly.date), 'alarm': anomaly.alarm, 'events': [], }) for event_name, event_amount in anomaly.events.iteritems(): anomaly_entry['events'].append({ 'name': event_name, 'amount': event_amount, }) anomaly_history.append(anomaly_entry) return anomaly_history
def getRecentRevisionsForProduct(product, days): """See `IRevisionSet`.""" # Here to stop circular imports. from lp.code.model.branch import Branch from lp.code.model.branchrevision import BranchRevision revision_subselect = Select(Min(Revision.id), revision_time_limit(days)) # Only look in active branches. result_set = Store.of(product).find( (Revision, RevisionAuthor), Revision.revision_author == RevisionAuthor.id, revision_time_limit(days), BranchRevision.revision == Revision.id, BranchRevision.branch == Branch.id, Branch.product == product, Branch.lifecycle_status.is_in(DEFAULT_BRANCH_STATUS_IN_LISTING), BranchRevision.revision_id >= revision_subselect) result_set.config(distinct=True) return result_set.order_by(Desc(Revision.revision_date))
def test_whereExpressions__two_sort_columns_asc_desc(self): """If the ascending sort column c1, the descending sort column c2 and the memo values m1, m2 are specified, whereExpressions() returns two expressions where the first expression is c1 == m1 AND c2 < m2 and the second expression is c1 > m1 """ resultset = self.makeStormResultSet() range_factory = StormRangeFactory(resultset, self.logError) [where_clause_1, where_clause_2] = range_factory.whereExpressions( [Person.id, Desc(Person.name)], [1, 'foo']) self.assertEqual("Person.id = ? AND ((Person.name) < (E'foo'))", compile(where_clause_1)) self.assertEqual('(Person.id) > (1)', compile(where_clause_2))
def getUnlandedSourceBranchRevisions(self): """See `IBranchMergeProposal`.""" store = Store.of(self) source = SQL("""source AS (SELECT BranchRevision.branch, BranchRevision.revision, Branchrevision.sequence FROM BranchRevision WHERE BranchRevision.branch = %s and BranchRevision.sequence IS NOT NULL ORDER BY BranchRevision.branch DESC, BranchRevision.sequence DESC LIMIT 10)""" % self.source_branch.id) where = SQL("""BranchRevision.revision NOT IN (SELECT revision from BranchRevision AS target where target.branch = %s and BranchRevision.revision = target.revision)""" % self.target_branch.id) using = SQL("""source as BranchRevision""") revisions = store.with_(source).using(using).find( BranchRevision, where) return list( revisions.order_by(Desc(BranchRevision.sequence)).config(limit=10))
def _refresh_slaves(self): empty_slave = self._slaves.pop(None, None) # If an image was set in the empty slave, promote it if empty_slave is not None and empty_slave.image_model is not None: self._slaves[empty_slave.image_model] = empty_slave empty_slave = None # If there is no empty slave, or the old one was promoted, # create a new one if empty_slave is None: empty_slave = ImageSlave(self.store, None, self.model, visual_mode=self.visual_mode) empty_slave.connect('image-changed', self._on_image_slave__image_changed) # We need to reorganize the slaves because the order might have changed slaves = self._slaves.copy() self._slaves.clear() images = self.model.images.order_by(Desc(Image.is_main), Image.create_date) for image in images: slave = slaves.pop(image, None) if slave is None: slave = ImageSlave(self.store, image, self.model, visual_mode=self.visual_mode) slave.connect('image-changed', self._on_image_slave__image_changed) slave.update_view() self._slaves[image] = slave # The empty slave is the last one self._slaves[None] = empty_slave # Remove slaves of removed images for removed in slaves.values(): removed.disconnect_by_func(self._on_image_slave__image_changed) self._organize(force=True)
def get_FormValues(self, getall=True): id_form = int(self.context.forms_id) form = self.request.form if 'data_inicial' in form.keys(): data_inicial = self.str2datetime( form.get('data_inicial')) + timedelta(days=0) else: data_inicial = self.str2datetime(self.get_data_inicial()) if 'data_final' in form.keys(): data_final = self.str2datetime( form.get('data_final')) - timedelta(days=-1) else: data_final = self.str2datetime(self.get_data_final()) self.data_instance = ModelsFormInstance().store.find( ModelsFormInstance, ModelsFormInstance.forms_id == id_form, ModelsFormInstance.date_creation >= data_inicial, ModelsFormInstance.date_creation <= data_final, ).order_by(Desc(ModelsFormInstance.date_creation)) self.ids_instances = [int(i.instance_id) for i in self.data_instance] L_value = [] self.data_values = ModelsFormValues().store.find( ModelsFormValues, ModelsFormValues.forms_id == id_form, ModelsFormValues.date_creation >= data_inicial, ModelsFormValues.date_creation <= data_final, ModelsFormValues.instance_id.is_in(self.ids_instances)) for item in self.data_instance: data = self.data_values.find( ModelsFormValues.instance_id == int(item.instance_id)) if data.count() > 0: L_value.append(data) L = [] for item in L_value: if self.checkItem(item, form): L.append(item) return L
def test_sale_with_package_surcharge_in_price(mock_can_emit_nfe, client, sale_payload, example_creator, store): child1 = example_creator.create_product(price=88, description='child1', stock=5, code='98') child2 = example_creator.create_product(price=8, description='child2', stock=5, code='99') # But in a package, they have special prices package = example_creator.create_product(price=20, description=u'package', is_package=True) example_creator.create_product_component(product=package, component=child1, price=10) example_creator.create_product_component(product=package, component=child2, price=5, component_quantity=2) sale_payload['products'] = [{ 'id': package.id, 'price': '25', # the regular price is 20, but we are selling at a surcharge 'quantity': 1, }] response = client.post('/sale', json=sale_payload) sale = store.find(Sale).order_by(Desc(Sale.open_date)).first() assert response.status_code == 201 assert sale.get_total_sale_amount() == 25 items = list(sale.get_items()) item1 = list(filter(lambda i: i.sellable == child1.sellable, items))[0] item2 = list(filter(lambda i: i.sellable == child2.sellable, items))[0] assert item1.price == Decimal('12.50') assert item2.price == Decimal('6.25') assert item2.quantity == 2
def getTopContributors(self, category=None, limit=None): """See IKarmaContext.""" from lp.registry.model.person import Person store = IStore(Person) if IProduct.providedBy(self): condition = KarmaCache.productID == self.id elif IDistribution.providedBy(self): condition = KarmaCache.distributionID == self.id elif IProjectGroup.providedBy(self): condition = KarmaCache.projectID == self.id else: raise AssertionError("Not a product, project or distribution: %r" % self) if category is not None: category = category.id contributors = store.find( (Person, KarmaCache.karmavalue), KarmaCache.personID == Person.id, KarmaCache.categoryID == category, condition).order_by( Desc(KarmaCache.karmavalue)).config(limit=limit) return list(contributors)