def login(store, username, password, client_using_tor): """ login returns a tuple (user_id, state, pcn) """ user = store.find( User, And(User.username == username, User.state != u'disabled')).one() if not user or not security.check_password(password, user.salt, user.password): log.debug("Login: Invalid credentials") GLSettings.failed_login_attempts += 1 raise errors.InvalidAuthentication if not client_using_tor and not GLSettings.memory_copy.accept_tor2web_access[ user.role]: log.err("Denied login request over Web for role '%s'" % user.role) raise errors.TorNetworkRequired log.debug("Login: Success (%s)" % user.role) user.last_login = datetime_now() return user.id, user.state, user.role, user.password_change_needed
def _getPackageBranch(self, owner, distribution, distroseries, sourcepackagename, branch): """Find a source package branch given its path segments. Only gets unofficial source package branches, that is, branches with names like ~jml/ubuntu/jaunty/openssh/stuff. """ origin = [ Branch, Join(Person, Branch.owner == Person.id), Join(SourcePackageName, Branch.sourcepackagename == SourcePackageName.id) ] return IStore(Branch).using(*origin).find( Branch, Person.name == owner, Branch.distroseriesID == Select( DistroSeries.id, And(DistroSeries.distribution == Distribution.id, DistroSeries.name == distroseries, Distribution.name == distribution)), SourcePackageName.name == sourcepackagename, Branch.name == branch).one()
def get_total_confirmed_value(self): """Returns the sum of all confirmed payments values This will consider all payments ignoring cancelled and preview ones, that is, if a payment is confirmed/reviewing/paid it will be summed. If you want to consider the preview ones too, use :meth:`.get_total_value` instead :returns: the total confirmed payments value """ payments = self.store.find( Payment, And( Payment.group_id == self.id, Not( In(Payment.status, [Payment.STATUS_CANCELLED, Payment.STATUS_PREVIEW])))) return self._get_payments_sum(payments, Payment.value)
def _create_main_query(self, state): item = state.value if item is None: return None kind, value = item.value.split(':') payment_view = self.search_spec if kind == 'status': if value == 'paid': return payment_view.status == Payment.STATUS_PAID elif value == 'not-paid': return payment_view.status == Payment.STATUS_PENDING elif value == 'late': tolerance = api.sysparam.get_int('TOLERANCE_FOR_LATE_PAYMENTS') return And( payment_view.status == Payment.STATUS_PENDING, payment_view.due_date < localtoday() - relativedelta(days=tolerance)) elif kind == 'category': return payment_view.category == value raise AssertionError(kind, value)
def has_late_payments(cls, store, person): """Checks if the provided person has unpaid payments that are overdue :param person: A :class:`person <stoqlib.domain.person.Person>` to check if has late payments :returns: True if the person has overdue payments. False otherwise """ tolerance = sysparam.get_int('TOLERANCE_FOR_LATE_PAYMENTS') query = And( cls.person_id == person.id, cls.status == Payment.STATUS_PENDING, cls.due_date < localtoday() - relativedelta(days=tolerance)) for late_payments in store.find(cls, query): sale = late_payments.sale # Exclude payments for external sales as they are handled by an # external entity (e.g. a payment gateway) meaning that they be # out of sync with the Stoq database. if not sale or not sale.is_external(): return True return False
def build_search_query(self, user, text): """Query parameters shared by search() and count_search_matches(). :returns: Storm ResultSet object """ # These classes are imported in this method to prevent an import loop. from lp.registry.model.product import Product, ProductSet from lp.registry.model.projectgroup import ProjectGroup from lp.registry.model.distribution import Distribution OtherPillarName = ClassAlias(PillarName) origin = [ PillarName, LeftJoin(OtherPillarName, PillarName.alias_for == OtherPillarName.id), LeftJoin(Product, PillarName.product == Product.id), LeftJoin(ProjectGroup, PillarName.projectgroup == ProjectGroup.id), LeftJoin(Distribution, PillarName.distribution == Distribution.id), ] conditions = SQL(''' PillarName.active = TRUE AND (PillarName.name = lower(%(text)s) OR Product.fti @@ ftq(%(text)s) OR lower(Product.title) = lower(%(text)s) OR Project.fti @@ ftq(%(text)s) OR lower(Project.title) = lower(%(text)s) OR Distribution.fti @@ ftq(%(text)s) OR lower(Distribution.title) = lower(%(text)s) ) ''' % sqlvalues(text=ensure_unicode(text))) columns = [ PillarName, OtherPillarName, Product, ProjectGroup, Distribution ] return IStore(PillarName).using(*origin).find( tuple(columns), And(conditions, ProductSet.getProductPrivacyFilter(user)))
def add_attachment(self, mlist, msg_id, counter, name, content_type, encoding, content): existing = self.db.find( Attachment.message_id, And( Attachment.list_name == unicode(mlist), Attachment.message_id == unicode(msg_id), Attachment.counter == counter, )).count() if existing: return attachment = Attachment() attachment.list_name = unicode(mlist) attachment.message_id = unicode(msg_id) attachment.counter = counter attachment.name = unicode(name) attachment.content_type = unicode(content_type) attachment.encoding = unicode( encoding) if encoding is not None else None attachment.content = content attachment.size = len(content) self.db.add(attachment) self.flush()
def delete_message_from_list(self, list_name, message_id): """Remove the given message for a specific list from the store. :param list_name: The fully qualified list name to which the message should be added. :param message: The Message-ID of the mesage to delete from the store. :raises LookupError: if there is no such message. """ msg = self.get_message_by_id_from_list(list_name, message_id) if msg is None: raise MessageNotFound(list_name, message_id) self.db.remove(msg) # Remove the thread if necessary thread = self.db.find( Thread, And( Thread.list_name == msg.list_name, Thread.thread_id == msg.thread_id, )).one() if len(thread.emails) == 0: self.db.remove(thread) self.flush()
def apply_patch(store): store.execute(""" CREATE TABLE stock_transaction_history( id serial NOT NULL PRIMARY KEY, te_id bigint UNIQUE REFERENCES transaction_entry(id), date timestamp, stock_cost numeric(20, 8) CONSTRAINT positive_cost CHECK (stock_cost >= 0), quantity numeric(20, 3), type int CONSTRAINT type_range CHECK (type >= 0 and type <= 15), object_id bigint, responsible_id bigint NOT NULL REFERENCES login_user(id) ON UPDATE CASCADE, product_stock_item_id bigint NOT NULL REFERENCES product_stock_item(id) ON UPDATE CASCADE ON DELETE CASCADE );""") res = store.execute("""SELECT id FROM login_user WHERE username='******'""").get_one() if not res: res = store.execute("""SELECT MIN(id) FROM login_user""").get_one() if res: user_id = res[0] # If the database is being created, there is no user and no stock items, # so this for will not be executed. for (item, sellable) in store.find((ProductStockItem, Sellable), And(ProductStockItem.storable_id == Storable.id, Storable.product_id == Product.id, Product.sellable_id == Sellable.id)): StockTransactionHistory(product_stock_item_id=item.id, date=TransactionTimestamp(), stock_cost=item.stock_cost, quantity=item.quantity, responsible_id=user_id, type=StockTransactionHistory.TYPE_IMPORTED, store=store)