示例#1
0
文件: model.py 项目: wjchao9111/X
def get_object(Model, *args, **kwargs):
    try:
        if type(Model) == QuerySet or str(type(Model)) == "<class 'django.db.models.fields.related.RelatedManager'>":
            return Manager.get(Model, *args, **kwargs)
        return Manager.get(Model.objects, *args, **kwargs)
    except:
        return None
示例#2
0
        def get_queryset(self):
            if hasattr(self.instance, "detail_history"):
                from cyano.models import Revision

                #print "m2m history"

                try:
                    return self.instance._prefetched_objects_cache[self.prefetch_cache_name]
                except (AttributeError, KeyError):
                    db = self._db or router.db_for_read(self.instance.__class__, instance=self.instance)

                    ct_id = ContentType.objects.get_for_model(self.model).pk

                    queryset = Manager.get_queryset(self).using(db)._next_is_sticky().all()#.filter(**self.core_filters)

                    revision = Revision.objects.filter(
                        object_id__in=queryset,
                        content_type__pk=ct_id,
                        detail_id__lte=self.instance.detail_history).order_by("-detail").first()

                    data = []

                    if revision is not None:
                        new_data = json.loads(revision.new_data)
                        if self.prefetch_cache_name in new_data:
                            data = new_data[self.prefetch_cache_name]

                    ##print "History:", self.instance.detail_history, "Data:", data

                    queryset = queryset.filter(pk__in=data)

                    for item in queryset:
                        setattr(item, "detail_history", self.instance.detail_history)

                    #queryset = queryset.filter(pk__in = vals)
                    
                    ##print "Queryset:", queryset#, self.core_filters, self.target_field_name, self.source_field_name, self._fk_val
                    
                    return queryset
            else:
                queryset = super(HistoryManyRelatedManager, self).get_queryset()

            #print queryset
            return queryset
示例#3
0
class GeoManager(Manager.from_queryset(GeoQuerySet)):
    "Overrides Manager to return Geographic QuerySets."

    # This manager should be used for queries on related fields
    # so that geometry columns on Oracle and MySQL are selected
    # properly.
    use_for_related_fields = True

    # No need to bother member with the use_for_related_fields
    # deprecation for this manager which is itself deprecated.
    silence_use_for_related_fields_deprecation = True

    def __init__(self, *args, **kwargs):
        warnings.warn(
            "The GeoManager class is deprecated. Simply use a normal manager "
            "once you have replaced all calls to GeoQuerySet methods by annotations.",
            RemovedInDjango20Warning,
            stacklevel=2)
        super(GeoManager, self).__init__(*args, **kwargs)
示例#4
0
class HacsModelManager(Manager.from_queryset(HacsQuerySet)):
    """
    """

    def get_by_natural_key(self, slug, __restricted__=False):
        """
        :param slug:
        :param __restricted__
        :return:
        """
        if isinstance(slug, (list, tuple)):
            slug = slug[0]
        params = {
            "slug": slug
        }
        if __restricted__:
            params["__restricted__"] = __restricted__

        return self.get(**params)
示例#5
0
class Category(MPTTModel, TimeStampedModel, SoftDeletableModel):
    parent = TreeForeignKey('self', null=True, blank=True, related_name='children', verbose_name=_('parent category'),
                            on_delete=models.SET_NULL)
    name = models.CharField(_('name'), max_length=255, unique=True)
    cover = models.OneToOneField('covers.Cover', verbose_name=_('cover'), blank=True, null=True,
                                 on_delete=models.SET_NULL)
    slug = AutoSlugField(populate_from='name', max_length=255, allow_unicode=True, unique=True)
    description = models.TextField(_('description'), blank=True)

    objects = Manager()
    tree = TreeManager()

    class Meta:
        verbose_name = _('Category')
        verbose_name_plural = _('Categories')

    class MPTTMeta:
        order_insertion_by = ['created']

    def __str__(self):
        return self.name
示例#6
0
class AbstractOffer(AbstractImg):
    created_date = models.DateTimeField(_("Created date"), default=now)
    start_date = models.DateTimeField(_("Start date"), default=now)
    end_date = models.DateTimeField(_("End date"), default=now)
    title = std_text_field(_('Title'))
    text = models.TextField(verbose_name=_("Offer text"), blank=True)
    enabled = models.BooleanField(verbose_name=_("Enabled"), default=False)
    slug = models.CharField(verbose_name=_('URL-identifier'),
                            max_length=100,
                            blank=True)
    position = models.PositiveSmallIntegerField(verbose_name=_('Priority'),
                                                db_index=True,
                                                default=0,
                                                blank=True)

    objects = Manager()

    class Meta:
        verbose_name = _('Special Offer')
        verbose_name_plural = _('Special Offers')
        abstract = True
示例#7
0
class AgentPercent(models.Model):
    hotel = models.ForeignKey(Hotel)
    date = models.DateField(verbose_name=_("From date"), db_index=True)
    percent = models.DecimalField(verbose_name=_('Percent'),
                                  blank=True,
                                  decimal_places=1,
                                  max_digits=4,
                                  default=0,
                                  db_index=True)

    class Meta:
        verbose_name = _("Agent Percent")
        verbose_name_plural = _("Agent Percents")
        ordering = ("hotel", )

    objects = Manager()

    def __str__(self):
        return _(
            "For %(hotel)s on date %(date)s percent is %(percent)s") % dict(
                hotel=self.hotel.name, date=self.date, percent=self.percent)
示例#8
0
def prepare_translatable_model(sender, **kwargs):
    model = sender
    if not issubclass(model, TranslatableModel) or model._meta.abstract:
        return
    if not isinstance(model._default_manager, TranslationManager):
        raise ImproperlyConfigured(
            "The default manager on a TranslatableModel must be a "
            "TranslationManager instance or an instance of a subclass of "
            "TranslationManager, the default manager of %r is not." % model)

    if model._meta.proxy:
        model._meta.translations_accessor = model._meta.concrete_model._meta.translations_accessor
        model._meta.translations_model = model._meta.concrete_model._meta.translations_model
        model._meta.translations_cache = model._meta.concrete_model._meta.translations_cache

    if not hasattr(model._meta, 'translations_model'):
        raise ImproperlyConfigured(
            "No TranslatedFields found on %r, subclasses of "
            "TranslatableModel must define TranslatedFields." % model)

    #### Now we have to work ####

    # Ensure _base_manager cannot be TranslationManager despite use_for_related_fields
    # 1- it is useless unless default_class is overriden
    # 2- in that case, _base_manager is used for saving objects and must not be
    #    translation aware.
    base_mgr = getattr(model, '_base_manager', None)
    if base_mgr is None or isinstance(base_mgr, TranslationManager):
        assert django.VERSION < (1, 10)
        model.add_to_class('_base_manager', Manager())

    # Replace get_field_by_name with one that warns for common mistakes
    if django.VERSION < (1, 9) and not isinstance(
            model._meta.get_field_by_name, SmartGetFieldByName):
        model._meta.get_field_by_name = MethodType(
            SmartGetFieldByName(model._meta.get_field_by_name), model._meta)
    if not isinstance(model._meta.get_field, SmartGetField):
        model._meta.get_field = MethodType(
            SmartGetField(model._meta.get_field), model._meta)
示例#9
0
    def _prepare(cls):
        # TODO: How do we extend the parent classes classmethod properly?
        # super(CachedModel, cls)._prepare() errors
        opts = cls._meta
        opts._prepare(cls)

        if opts.order_with_respect_to:
            cls.get_next_in_order = curry(cls._get_next_or_previous_in_order, is_next=True)
            cls.get_previous_in_order = curry(cls._get_next_or_previous_in_order, is_next=False)
            setattr(opts.order_with_respect_to.rel.to, 'get_%s_order' % cls.__name__.lower(), curry(method_get_order, cls))
            setattr(opts.order_with_respect_to.rel.to, 'set_%s_order' % cls.__name__.lower(), curry(method_set_order, cls))

        # Give the class a docstring -- its definition.
        if cls.__doc__ is None:
            cls.__doc__ = "%s(%s)" % (cls.__name__, ", ".join([f.attname for f in opts.fields]))

        #if hasattr(cls, 'get_absolute_url'):
        #    cls.get_absolute_url = curry(cls.get_absolute_url, opts, cls.get_absolute_url)

        cls.add_to_class('cache', CacheManager())
        cls.add_to_class('nocache', Manager())
        cls.add_to_class('_default_manager', cls.nocache)
        dispatcher.send(signal=signals.class_prepared, sender=cls)
示例#10
0
class Color(models.Model):
    """
    Base color model
    """
    BASE_COLOR = 0
    CUSTOM_COLOR = 1
    TYPES = ((BASE_COLOR, 'Base color'), (CUSTOM_COLOR, 'User color'))
    type = models.PositiveIntegerField(choices=TYPES)
    # String color in hex
    hex = models.CharField(max_length=6)
    name = models.CharField(max_length=20)
    description = models.CharField(max_length=100, null=True, blank=True)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    # color manages
    objects = Manager()
    base_colors = BaseColorManager()
    custom_color = UserColorManager()

    def __str__(self):
        return f'{self.author.__str__()} - {super().__str__()}'

    class Meta:
        ordering = ('name', )
示例#11
0
    def verify(self, authors: Manager) -> VerifiedMessage:
        try:
            author = authors.get(email=self.sender_address)
        except ObjectDoesNotExist:
            raise AuthorUnknown(self.sender_address)
        if not author.pgp_public_key:
            raise AuthorNotVerifyable(author)

        expected_public_key = pgpy.PGPKey()
        expected_public_key.parse(author.pgp_public_key)

        # Mandatory: Verify Signature
        if not self._signature:
            raise NoSignature(self)

        attached_signature = pgpy.PGPSignature()
        attached_signature.parse(self._signature)

        # Verify signature
        if not (attached_signature.signer_fingerprint
                == expected_public_key.fingerprint):
            raise SignatureMismatch(expected_public_key.fingerprint,
                                    attached_signature.signer_fingerprint)

        # Optional: If a public key was attached, verify it for good measure
        if self._public_key:
            attached_pub_key = pgpy.PGPKey()
            attached_pub_key.parse(self._public_key)

            # Verify public Key
            if not expected_public_key.fingerprint == attached_pub_key.fingerprint:
                raise PublicKeyMismatch(expected_public_key, attached_pub_key)

        return VerifiedMessage(subject=self._message.get('subject'),
                               body=self._body,
                               author=author)
示例#12
0
class _ModelWithObjectsManagerAndDefaultMetaOptionsABC(Model):
    # docs.djangoproject.com/en/dev/ref/models/class/#objects
    objects: Manager = Manager()

    # docs.djangoproject.com/en/dev/ref/models/options/#model-meta-options
    class Meta:   # pylint: disable=too-few-public-methods
        """Metadata."""

        # docs.djangoproject.com/en/dev/ref/models/options/#abstract
        abstract: bool = True

        # docs.djangoproject.com/en/dev/ref/models/options/#app-label
        # app_label: str = '...'

        # docs.djangoproject.com/en/dev/ref/models/options/#base-manager-name
        base_manager_name: str = 'objects'

        # docs.djangoproject.com/en/dev/ref/models/options/#db-table
        # docs.djangoproject.com/en/dev/ref/models/options/#table-names
        # db_table: str = '...'

        # docs.djangoproject.com/en/dev/ref/models/options/#db-tablespace
        db_tablespace: str = ''

        # docs.djangoproject.com/en/dev/ref/models/options/#default-manager-name
        default_manager_name: str = 'objects'

        # docs.djangoproject.com/en/dev/ref/models/options/#default-related-name
        # default_related_name: str = '...'

        # docs.djangoproject.com/en/dev/ref/models/options/#get-latest-by
        # get_latest_by: Union[str, Sequence[str]] = ...

        # docs.djangoproject.com/en/dev/ref/models/options/#managed
        managed: bool = True

        # docs.djangoproject.com/en/dev/ref/models/options/#order-with-respect-to
        # order_with_respect_to: str = '...'

        # docs.djangoproject.com/en/dev/ref/models/options/#ordering
        ordering: Sequence[str] = ()

        # docs.djangoproject.com/en/dev/ref/models/options/#permissions
        permissions: Sequence[tuple[str, str]] = ()

        # docs.djangoproject.com/en/dev/ref/models/options/#default-permissions
        default_permissions: Sequence[str] = 'add', 'change', 'delete', 'view'

        # docs.djangoproject.com/en/dev/ref/models/options/#proxy
        proxy: bool = False

        # docs.djangoproject.com/en/dev/ref/models/options/#required-db-features
        required_db_features: Sequence[str] = ()

        # docs.djangoproject.com/en/dev/ref/models/options/#required-db-vendor
        # required_db_vendor: str = '...'

        # docs.djangoproject.com/en/dev/ref/models/options/#select-on-save
        select_on_save: bool = False

        # docs.djangoproject.com/en/dev/ref/models/options/#indexes
        indexes: Sequence[Index] = ()

        # DEPRECATED
        # docs.djangoproject.com/en/dev/ref/models/options/#unique-together
        # unique_together: Sequence[Union[str, Sequence[str]]] = ()

        # DEPRECATED
        # docs.djangoproject.com/en/dev/ref/models/options/#index-together
        # index_together: Sequence[Union[str, Sequence[str]]] = ()

        # docs.djangoproject.com/en/dev/ref/models/options/#constraints
        constraints: Sequence[BaseConstraint] = ()

        # docs.djangoproject.com/en/dev/ref/models/options/#verbose-name
        # verbose_name: str = '...'

        # docs.djangoproject.com/en/dev/ref/models/options/#verbose-name-plural
        # verbose_name_plural: str  = '...'

    def __str__(self) -> str:
        # pylint: disable=no-member
        return f'{self._meta.verbose_name} #{self.pk}'
示例#13
0
 def as_manager(cls):
     # Address the circular dependency between `Queryset` and `Manager`.
     from django.db.models.manager import Manager
     manager = Manager.from_queryset(cls)()
     manager._built_with_as_manager = True
     return manager
示例#14
0
class DeploymentManager(Manager.from_queryset(JobQuerySet)):
    def get_queryset(self):
        from ralph.deployment.deployment import deploy
        # TODO: test it
        return super().get_queryset().filter(
            transition__actions__name=deploy.__name__)
示例#15
0
 class InvalidModel(TranslatableModel):
     translations = TranslatedFields(translated=models.CharField(
         max_length=250))
     object = Manager()
示例#16
0
文件: base.py 项目: oucsaw/silver
class BillingDocument(models.Model):
    objects = Manager.from_queryset(BillingDocumentQuerySet)()

    class STATES(object):
        DRAFT = 'draft'
        ISSUED = 'issued'
        PAID = 'paid'
        CANCELED = 'canceled'

    STATE_CHOICES = Choices(
        (STATES.DRAFT, _('Draft')), (STATES.ISSUED, _('Issued')),
        (STATES.PAID, _('Paid')), (STATES.CANCELED, _('Canceled')))

    series = models.CharField(max_length=20,
                              blank=True,
                              null=True,
                              db_index=True)
    number = models.IntegerField(blank=True, null=True, db_index=True)
    customer = models.ForeignKey('Customer')
    provider = models.ForeignKey('Provider')
    archived_customer = JSONField()
    archived_provider = JSONField()
    due_date = models.DateField(null=True, blank=True)
    issue_date = models.DateField(null=True, blank=True, db_index=True)
    paid_date = models.DateField(null=True, blank=True)
    cancel_date = models.DateField(null=True, blank=True)
    sales_tax_percent = models.DecimalField(
        max_digits=4,
        decimal_places=2,
        validators=[MinValueValidator(0.0)],
        null=True,
        blank=True)
    sales_tax_name = models.CharField(max_length=64, blank=True, null=True)
    currency = models.CharField(choices=currencies,
                                max_length=4,
                                default='USD',
                                help_text='The currency used for billing.')
    pdf = models.FileField(null=True,
                           blank=True,
                           editable=False,
                           storage=_storage,
                           upload_to=documents_pdf_path)
    state = FSMField(choices=STATE_CHOICES,
                     max_length=10,
                     default=STATES.DRAFT,
                     verbose_name="State",
                     help_text='The state the invoice is in.')

    _last_state = None

    class Meta:
        abstract = True
        unique_together = ('provider', 'series', 'number')
        ordering = ('-issue_date', 'series', '-number')

    def __init__(self, *args, **kwargs):
        super(BillingDocument, self).__init__(*args, **kwargs)
        self._last_state = self.state

    def _issue(self, issue_date=None, due_date=None):
        if issue_date:
            self.issue_date = datetime.strptime(issue_date, '%Y-%m-%d').date()
        elif not self.issue_date and not issue_date:
            self.issue_date = timezone.now().date()

        if due_date:
            self.due_date = datetime.strptime(due_date, '%Y-%m-%d').date()
        elif not self.due_date and not due_date:
            delta = timedelta(days=PAYMENT_DUE_DAYS)
            self.due_date = timezone.now().date() + delta

        if not self.sales_tax_name:
            self.sales_tax_name = self.customer.sales_tax_name
        if not self.sales_tax_percent:
            self.sales_tax_percent = self.customer.sales_tax_percent

        if not self.number:
            self.number = self._generate_number()

        self.archived_customer = self.customer.get_archivable_field_values()

        self._save_pdf(state=self.STATES.ISSUED)

    @transition(field=state, source=STATES.DRAFT, target=STATES.ISSUED)
    def issue(self, issue_date=None, due_date=None):
        self._issue(issue_date=issue_date, due_date=due_date)

    def _pay(self, paid_date=None):
        if paid_date:
            self.paid_date = datetime.strptime(paid_date, '%Y-%m-%d').date()
        if not self.paid_date and not paid_date:
            self.paid_date = timezone.now().date()

        self._save_pdf(state=self.STATES.PAID)

    @transition(field=state, source=STATES.ISSUED, target=STATES.PAID)
    def pay(self, paid_date=None):
        self._pay(paid_date=paid_date)

    def _cancel(self, cancel_date=None):
        if cancel_date:
            self.cancel_date = datetime.strptime(cancel_date,
                                                 '%Y-%m-%d').date()
        if not self.cancel_date and not cancel_date:
            self.cancel_date = timezone.now().date()

        self._save_pdf(state=self.STATES.CANCELED)

    @transition(field=state, source=STATES.ISSUED, target=STATES.CANCELED)
    def cancel(self, cancel_date=None):
        self._cancel(cancel_date=cancel_date)

    def clone_into_draft(self):
        copied_fields = {
            'customer': self.customer,
            'provider': self.provider,
            'currency': self.currency,
            'sales_tax_percent': self.sales_tax_percent,
            'sales_tax_name': self.sales_tax_name
        }

        clone = self.__class__._default_manager.create(**copied_fields)
        clone.state = self.STATES.DRAFT

        # clone entries too
        for entry in self._entries:
            entry_clone = entry.clone()
            document_type_name = self.__class__.__name__.lower()
            setattr(entry_clone, document_type_name, clone)
            entry_clone.save()

        clone.save()

        return clone

    def clean(self):
        super(BillingDocument, self).clean()

        # The only change that is allowed if the document is in issued state
        # is the state chage from issued to paid
        # !! TODO: If _last_state == 'issued' and self.state == 'paid' || 'canceled'
        # it should also be checked that the other fields are the same bc.
        # right now a document can be in issued state and someone could
        # send a request which contains the state = 'paid' and also send
        # other changed fields and the request would be accepted bc. only
        # the state is verified.
        if self._last_state == self.STATES.ISSUED and\
           self.state not in [self.STATES.PAID, self.STATES.CANCELED]:
            msg = 'You cannot edit the document once it is in issued state.'
            raise ValidationError({NON_FIELD_ERRORS: msg})

        if self._last_state == self.STATES.CANCELED:
            msg = 'You cannot edit the document once it is in canceled state.'
            raise ValidationError({NON_FIELD_ERRORS: msg})

        # If it's in paid state => don't allow any changes
        if self._last_state == self.STATES.PAID:
            msg = 'You cannot edit the document once it is in paid state.'
            raise ValidationError({NON_FIELD_ERRORS: msg})

    def save(self, *args, **kwargs):
        if not self.series:
            self.series = self.default_series

        # Generate the number
        if not self.number and self.state != BillingDocument.STATES.DRAFT:
            self.number = self._generate_number()

        # Add tax info
        if not self.sales_tax_name:
            self.sales_tax_name = self.customer.sales_tax_name
        if not self.sales_tax_percent:
            self.sales_tax_percent = self.customer.sales_tax_percent

        self._last_state = self.state
        super(BillingDocument, self).save(*args, **kwargs)

    def _generate_number(self, default_starting_number=1):
        """Generates the number for a proforma/invoice."""
        default_starting_number = max(default_starting_number, 1)

        documents = self.__class__._default_manager.filter(
            provider=self.provider, series=self.series)
        if not documents.exists():
            # An invoice/proforma with this provider and series does not exist
            if self.series == self.default_series:
                return self._starting_number
            else:
                return default_starting_number
        else:
            # An invoice with this provider and series already exists
            max_existing_number = documents.aggregate(
                Max('number'))['number__max']
            if max_existing_number:
                if self._starting_number and self.series == self.default_series:
                    return max(max_existing_number + 1, self._starting_number)
                else:
                    return max_existing_number + 1
            else:
                return default_starting_number

    def series_number(self):
        if self.series:
            if self.number:
                return "%s-%d" % (self.series, self.number)
            else:
                return "%s-draft-id:%d" % (self.series, self.pk)

        else:
            return "draft-id:%d" % self.pk

    series_number.short_description = 'Number'
    series_number = property(series_number)

    def __unicode__(self):
        return u'%s %s => %s [%.2f %s]' % (
            self.series_number, self.provider.billing_name,
            self.customer.billing_name, self.total, self.currency)

    @property
    def updateable_fields(self):
        return [
            'customer', 'provider', 'due_date', 'issue_date', 'paid_date',
            'cancel_date', 'sales_tax_percent', 'sales_tax_name', 'currency'
        ]

    @property
    def admin_change_url(self):
        url_base = 'admin:{app_label}_{klass}_change'.format(
            app_label=self._meta.app_label,
            klass=self.__class__.__name__.lower())
        url = reverse(url_base, args=(self.pk, ))
        return '<a href="{url}">{display_series}</a>'.format(
            url=url, display_series=self.series_number)

    @property
    def _entries(self):
        # entries iterator which replaces the invoice/proforma from the DB with
        # self. We need this in _generate_pdf so that the data in PDF has the
        # lastest state for the document. Without this we get in template:
        #
        # invoice.issue_date != entry.invoice.issue_date
        #
        # which is obviously false.
        document_type_name = self.__class__.__name__  # Invoice or Proforma
        kwargs = {document_type_name.lower(): self}
        entries = DocumentEntry.objects.filter(**kwargs)
        for entry in entries:
            if document_type_name.lower() == 'invoice':
                entry.invoice = self
            if document_type_name.lower() == 'proforma':
                entry.proforma = self
            yield (entry)

    def _generate_pdf(self, state=None):
        customer = Customer(**self.archived_customer)
        provider = Provider(**self.archived_provider)
        if state is None:
            state = self.state

        context = {
            'document': self,
            'provider': provider,
            'customer': customer,
            'entries': self._entries,
            'state': state
        }

        provider_state_template = '{provider}/{kind}_{state}_pdf.html'.format(
            kind=self.kind, provider=self.provider.slug, state=state).lower()
        provider_template = '{provider}/{kind}_pdf.html'.format(
            kind=self.kind, provider=self.provider.slug).lower()
        generic_state_template = '{kind}_{state}_pdf.html'.format(
            kind=self.kind, state=state).lower()
        generic_template = '{kind}_pdf.html'.format(kind=self.kind).lower()
        _templates = [
            provider_state_template, provider_template, generic_state_template,
            generic_template
        ]

        templates = []
        for t in _templates:
            templates.append('billing_documents/' + t)

        template = select_template(templates)

        file_object = HttpResponse(content_type='application/pdf')
        generate_pdf_template_object(template, file_object, context)

        return file_object

    def _save_pdf(self, state=None):
        file_object = self._generate_pdf(state)

        if file_object:
            pdf_content = ContentFile(file_object)
            filename = '{doc_type}_{series}-{number}.pdf'.format(
                doc_type=self.__class__.__name__,
                series=self.series,
                number=self.number)

            if self.pdf:
                self.pdf.delete()
            self.pdf.save(filename, pdf_content, True)
        else:
            raise RuntimeError(_('Could not generate invoice pdf.'))

    def serialize_hook(self, hook):
        """
        Used to generate a skinny payload.
        """

        return {'hook': hook.dict(), 'data': {'id': self.id}}
示例#17
0
def prepare_translatable_model(sender, **kwargs):
    model = sender
    if not issubclass(model, TranslatableModel) or model._meta.abstract:
        return
    if not isinstance(model._default_manager, TranslationManager):
        raise ImproperlyConfigured(
            "The default manager on a TranslatableModel must be a "
            "TranslationManager instance or an instance of a subclass of "
            "TranslationManager, the default manager of %r is not." % model)

    # If this is a proxy model, get the concrete one
    concrete_model = model._meta.concrete_model if model._meta.proxy else model

    # Find the instance of TranslatedFields in the concrete model's dict
    # We cannot use _meta.get_fields here as app registry is not ready yet.
    found = None
    for relation in list(concrete_model.__dict__.keys()):
        try:
            obj = getattr(model, relation)
            if django.VERSION >= (1, 8):
                shared_model = obj.related.field.model._meta.shared_model
            else:
                shared_model = obj.related.model._meta.shared_model
        except AttributeError:
            continue
        if shared_model is concrete_model:
            if found:
                raise ImproperlyConfigured(
                    "A TranslatableModel can only define one set of "
                    "TranslatedFields, %r defines more than one: %r on %r "
                    "and %r on %r and possibly more" %
                    (model, obj, obj.related.model, found,
                     found.related.model))
            # Mark as found but keep looking so we catch duplicates and raise
            found = obj

    if not found:
        raise ImproperlyConfigured(
            "No TranslatedFields found on %r, subclasses of "
            "TranslatableModel must define TranslatedFields." % model)

    #### Now we have to work ####

    contribute_translations(model, found.related)

    # Ensure _base_manager cannot be TranslationManager despite use_for_related_fields
    # 1- it is useless unless default_class is overriden
    # 2- in that case, _base_manager is used for saving objects and must not be
    #    translation aware.
    base_mgr = getattr(model, '_base_manager', None)
    if base_mgr is None or isinstance(base_mgr, TranslationManager):
        model.add_to_class('_base_manager', Manager())

    # Replace get_field_by_name with one that warns for common mistakes
    if django.VERSION < (1, 9) and not isinstance(
            model._meta.get_field_by_name, SmartGetFieldByName):
        model._meta.get_field_by_name = MethodType(
            SmartGetFieldByName(model._meta.get_field_by_name), model._meta)
    if not isinstance(model._meta.get_field, SmartGetField):
        model._meta.get_field = MethodType(
            SmartGetField(model._meta.get_field), model._meta)

    # Attach save_translations
    post_save.connect(model.save_translations, sender=model, weak=False)
示例#18
0
 def as_manager(cls):  # to refverify
     # Address the circular dependency between `Queryset` and `Manager`.
     from django.db.models.manager import Manager
     manager = Manager.from_queryset(cls)()
     manager._built_with_as_manager = True
     return manager
示例#19
0
class Node(TimeStampedModel):
    name = models.CharField(max_length=255)
    parent = models.ForeignKey('self', null=True)
    objects = Manager.from_queryset(ExtendedQuerySet)()
示例#20
0
class ModelWithMultipleManagers(models.Model):
    gender = models.SmallIntegerField()
    objects = Manager()
    men = MenManager()
    women = WomenManager()
示例#21
0
class GameManager(Manager.from_queryset(GameQuerySet)):
    pass
示例#22
0
class TreeManager(Manager.from_queryset(TreeQuerySet)):
    pass
示例#23
0
class _ModelWithObjectsManagerAndDefaultMetaOptionsMixInABC(Model):
    # https://docs.djangoproject.com/en/dev/ref/models/class/#objects
    # https://docs.djangoproject.com/en/dev/ref/models/class/#django.db.models.Model.objects
    objects = Manager()

    # https://docs.djangoproject.com/en/dev/ref/models/options/#model-meta-options
    class Meta:
        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.abstract
        abstract = True

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.app_label
        # TODO: *** Django 2 Cannot Interpolate %(app_label), etc. ***
        # *** so must explicitly set this in non-abstract sub-classes ***
        # app_label = '%(app_label)s'

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.base_manager_name
        base_manager_name = 'objects'

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.db_table
        # https://docs.djangoproject.com/en/dev/ref/models/options/#table-names
        # TODO: *** Django 2 Cannot Interpolate %(app_label), etc. ***
        # *** so must explicitly set this in non-abstract sub-classes ***
        db_table = '"%(app_label)s_%(object_name)s"'  # note: except for Oracle, quotes have no effect

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.db_tablespace
        db_tablespace = None

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.default_manager_name
        default_manager_name = 'objects'

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.default_related_name
        # TODO: *** Django 2 Cannot Interpolate %(app_label), etc. ***
        # *** so must explicitly set this in non-abstract sub-classes ***
        default_related_name = '%(model_name)ss'

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.get_latest_by
        get_latest_by = None

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.managed
        managed = True

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.order_with_respect_to
        order_with_respect_to = None

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.ordering
        ordering = None

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.permissions
        permissions = ()

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.default_permissions
        default_permissions = \
            'add', \
            'change', \
            'delete', \
            'view'

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.proxy
        proxy = False

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.required_db_features
        required_db_features = ()

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.required_db_vendor
        required_db_vendor = 'postgresql'

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.select_on_save
        select_on_save = False

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.indexes
        indexes = ()

        # (MAY BE DEPRECATED)
        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.unique_together
        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.index_together

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.constraints
        constraints = ()

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.verbose_name
        # TODO: *** Django 2 Cannot Interpolate %(app_label), etc. ***
        verbose_name = '%(object_name)s'

        # https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.verbose_name_plural
        # TODO: *** Django 2 Cannot Interpolate '%(app_label)', etc. ***
        # *** so must explicitly set this in non-abstract sub-classes ***
        verbose_name_plural = '%(object_name)ss'
示例#24
0
 def manager_method_get_query_set (self, cls) :
     _queryset = manager_django.get_query_set(cls)
     return self.attach_create_index(_queryset)
示例#25
0
class Event(StatusModel):
    """ Events
        * draft - totally invisible
        * planning - only event description is shown
        * active - event is scheduled, speakers also visible
        * archived - event passed, registration is disabled
    """
    STATUS = Choices(
        'planning',
        'active',
        'archived',
        'draft',
    )

    name = models.CharField(u'Название', max_length=1024)
    number = models.SmallIntegerField(u'Номер', blank=True, null=True)
    description = models.TextField(u'Описание', blank=True)
    image = models.ImageField(u'Изображение',
                              upload_to='events',
                              null=True,
                              blank=True)
    date = models.DateTimeField(u'Начало', blank=True, null=True)
    venue = models.ForeignKey('Venue', blank=True, null=True)
    sponsors = models.ManyToManyField('Sponsor',
                                      verbose_name=u'Спонсоры',
                                      blank=True)
    registration_link = models.URLField(u'Ссылка на событие', blank=True)
    streaming_url = models.URLField(u'Ссылка на трансляцию', blank=True)
    streaming_embed = models.TextField(
        u'Embed трансляции',
        blank=True,
        help_text='html с ютуба или другого источника')
    manual_on_air = models.NullBooleanField(
        u'Включить трансляцию',
        default=None,
        help_text=u'Включается автоматически за полчаса до начала и идёт 4 часа.'
        u' Нужно, для тестирования в другое время.')

    # Deprecated:
    timepad_id = models.IntegerField(u'ID события на Timepad',
                                     blank=True,
                                     default=0,
                                     editable=False)
    votable = models.BooleanField(u'Включить голосование',
                                  default=False,
                                  editable=False)

    objects = Manager()
    visible = QueryManager(
        status__in=[STATUS.planning, STATUS.active, STATUS.archived])
    future = QueryManager(status__in=[STATUS.planning, STATUS.active])

    def __str__(self):
        if self.number:
            return u'{0} №{1}'.format(self.name, self.number)
        else:
            return self.name

    def __repr__(self):
        return '<Event №%s>' % self.number

    @permalink
    def get_absolute_url(self):
        return 'event', [self.number]

    @property
    def is_active(self):
        return self.status == self.STATUS.active

    def days_delta(self):
        if not self.date:
            return None
        delta = (self.date.date() - datetime.datetime.today().date()).days
        if delta < 0:
            return None  # passed
        if delta >= 0:
            return delta

    @property
    def on_air(self):
        if self.manual_on_air is not None:
            return self.manual_on_air
        datetime_start = self.date - datetime.timedelta(minutes=30)
        datetime_stop = self.date + datetime.timedelta(
            hours=4)  # Actually meetups are not that long
        return datetime_start <= datetime.datetime.now() <= datetime_stop

    def get_registration_url(self):
        if self.timepad_id:
            return 'https://moscowdjango.timepad.ru/event/%s/' % self.timepad_id
        if self.registration_link:
            return self.registration_link

    @classmethod
    def spotlight(cls, with_drafts=False):
        """ Last active or last planned or last archived
        """
        try:
            if with_drafts:
                return Event.objects.latest()
            return Event.future.latest()
        except Event.DoesNotExist:
            return None

    class Meta:
        verbose_name = u'Событие'
        verbose_name_plural = u'События'
        get_latest_by = 'number'
        ordering = ['-date']
示例#26
0
文件: managers.py 项目: paltman/api
class ResourceGroupManager(Manager.from_queryset(ResourceGroupQuerySet)):
    pass
示例#27
0
class Hotel(AbstractName, AbstractGeo, HotelPoints):
    register_date = models.DateTimeField(_("Register from"), default=now)
    email = models.CharField(verbose_name=_("Email"),
                             blank=True,
                             max_length=75)
    phone = models.CharField(max_length=100,
                             verbose_name=_('Phone'),
                             blank=True)
    fax = models.CharField(max_length=100, verbose_name=_('Fax'), blank=True)
    website = models.URLField(max_length=150,
                              verbose_name=_('Website'),
                              blank=True)
    contact_email = models.CharField(verbose_name=_("Contact Email"),
                                     blank=True,
                                     max_length=75)
    contact_name = models.CharField(max_length=100,
                                    verbose_name=_('Contact Name'),
                                    blank=True)
    room_count = models.IntegerField(_('Count of Rooms'),
                                     blank=True,
                                     default=0)
    option = models.ManyToManyField(HotelOption,
                                    verbose_name=_('Hotel Options'),
                                    blank=True)
    starcount = models.IntegerField(_("Count of Stars"),
                                    choices=STAR_CHOICES,
                                    default=UNKNOWN_STAR,
                                    db_index=True)
    choice = models.IntegerField(_("Type of Hotel"),
                                 choices=HOTEL_CHOICES,
                                 default=HOTEL_HOTEL,
                                 editable=False,
                                 db_index=True)
    admins = models.ManyToManyField(settings.AUTH_USER_MODEL,
                                    verbose_name=_('Hotel Admins'),
                                    blank=True)
    point = models.DecimalField(_("Point of hotel"),
                                editable=False,
                                default=0,
                                decimal_places=1,
                                max_digits=4,
                                db_index=True)
    best_offer = models.BooleanField(verbose_name=_("Best offer"),
                                     default=False,
                                     db_index=True)
    in_top10 = models.BooleanField(verbose_name=_("In top 10"),
                                   default=False,
                                   db_index=True)
    current_amount = models.DecimalField(verbose_name=_('Current amount'),
                                         default=0,
                                         max_digits=20,
                                         decimal_places=3,
                                         db_index=True)
    booking_terms = models.TextField(verbose_name=_("Booking terms"),
                                     blank=True)
    schema_transit = models.TextField(verbose_name=_("Schema of transit"),
                                      blank=True)
    booking_terms_en = models.TextField(
        verbose_name=_("Booking terms(English)"), blank=True)
    schema_transit_en = models.TextField(
        verbose_name=_("Schema of transit(English)"), blank=True)
    payment_method = models.ManyToManyField(PaymentMethod,
                                            verbose_name=_('Payment methods'),
                                            blank=True)
    updated_date = models.DateTimeField(_("Updated date"),
                                        null=True,
                                        blank=True)
    condition_cancellation = models.TextField(
        verbose_name=_("Condition cancellation"), blank=True)
    condition_cancellation_en = models.TextField(
        verbose_name=_("Condition cancellation(English)"), blank=True)
    paid_services = models.TextField(verbose_name=_("Paid services"),
                                     blank=True)
    paid_services_en = models.TextField(
        verbose_name=_("Paid services(English)"), blank=True)
    time_on = models.CharField(max_length=5,
                               verbose_name=_('Time on'),
                               blank=True)
    time_off = models.CharField(max_length=5,
                                verbose_name=_('Time off'),
                                blank=True)
    work_on_request = models.BooleanField(verbose_name=_("Work on request"),
                                          default=False,
                                          db_index=True)
    hoteltype = models.ForeignKey(HotelType,
                                  verbose_name=_('Hotel type'),
                                  null=True,
                                  blank=True,
                                  db_index=True)
    addon_city = models.ForeignKey(City,
                                   verbose_name=_('Main city'),
                                   related_name='main_city',
                                   null=True,
                                   blank=True,
                                   db_index=True)

    class Meta:
        verbose_name = _("Hotel")
        verbose_name_plural = _("Hotels")
        ordering = ("name", )

    objects = Manager()

    def get_address(self):
        if get_language() == 'en':
            if self.address_en:
                return self.address_en
        return self.address

    def get_schema_transit(self):
        if get_language() == 'en':
            if self.schema_transit_en:
                return self.schema_transit_en
        return self.schema_transit

    def get_booking_terms(self):
        if get_language() == 'en':
            if self.booking_terms_en:
                return self.booking_terms_en
        return self.booking_terms

    def get_condition_cancellation(self):
        if get_language() == 'en':
            if self.condition_cancellation_en:
                return self.condition_cancellation_en
        return self.condition_cancellation

    def get_paid_services(self):
        if get_language() == 'en':
            if self.paid_services_en:
                return self.paid_services_en
        return self.paid_services

    @property
    def metadesc(self):
        r = self.description
        if get_language() == 'en' and self.description_en:
            r = self.description_en
        return r.split('. ')[0] + '.'

    def get_count_stars_hotels(self):
        qs = Hotel.objects.filter(city=self.city)
        two = qs(starcount=TWO_STAR).count()
        three = qs(starcount=THREE_STAR).count()
        four = qs(starcount=FOUR_STAR).count()
        five = qs(starcount=FIVE_STAR).count()
        return [two, three, four, five]

    def fulladdress(self):
        return "%s, %s" % (self.address, self.city.name)

    def in_city(self):
        return Hotel.objects.filter(city=self.city).count()

    def in_system(self):
        return Hotel.objects.all().count()

    def stars(self):
        if self.starcount == -10:
            return None
        elif self.starcount == -1:
            return 'apartaments'
        elif self.starcount == -2:
            return 'hostel'
        elif not self.starcount:
            return 'mini'
        else:
            return range(0, int(self.starcount))

    def all_room_options(self):
        return RoomOption.objects.filter(
            enabled=True, room__hotel=self).select_related().order_by(
                'category', 'position', 'name').distinct()

    def get_absolute_url(self):
        return reverse('hotel_detail',
                       kwargs={
                           'city': self.city.slug,
                           'slug': self.slug
                       })

    def get_cabinet_url(self):
        return reverse('cabinet_info',
                       kwargs={
                           'city': self.city.slug,
                           'slug': self.slug
                       })

    def get_current_percent(self):
        try:
            return AgentPercent.objects.filter(hotel=self).filter(
                date__lte=now()).order_by('-date')[0].percent
        except IndexError as ierr:
            return None

    def get_percent_on_date(self, on_date):
        return AgentPercent.objects.filter(hotel=self).filter(
            date__lte=on_date).order_by('-date')[0].percent

    @property
    def min_current_amount(self):
        return self.amount_on_date(now())

    def amount_on_date(self, on_date):
        result = PlacePrice.objects.filter(settlement__room__hotel=self, settlement__enabled=True, date=on_date).\
            aggregate(Min('amount'))
        amount = result['amount__min']
        if amount:
            return amount
        return 0

    def save(self, *args, **kwargs):
        if not self.slug:
            if not self.pk:
                super(Hotel, self).save(*args, **kwargs)
            self.slug = self.pk
        else:
            self.slug = self.slug.strip().replace(' ', '-')
            if Hotel.objects.filter(
                    slug=self.slug,
                    city=self.city).exclude(pk=self.pk).count():
                self.slug = self.pk
        self.updated_date = now()
        super(Hotel, self).save(*args, **kwargs)

    def update_hotel_amount(self):
        amount = self.min_current_amount
        if amount:
            self.current_amount = amount
        else:
            self.current_amount = 0
        self.save()

    def tourism_places(self):
        places = Tourism.objects.raw(
            places_near_object(self, settings.TOURISM_PLACES_RADIUS,
                               'address_tourism'))
        all_places = []
        for p in places:
            all_places.append(p.id)
        return Tourism.objects.filter(pk__in=all_places).order_by('category')

    def complete_booking_users_id(self):
        # TODO Check status of bookings
        users_id = Booking.objects.filter(hotel=self).values_list('user',
                                                                  flat=True)
        return users_id

    def __str__(self):
        # noinspection PyBroadException
        try:
            return _("%(hotel)s :: %(city)s") % {
                'hotel': self.get_name,
                'city': self.city.get_name,
            }
        except:
            return self.name

    def available_rooms_for_guests_in_period(self, guests, from_date, to_date):
        # Find available rooms for this guests count and for searched dates
        need_days = (to_date - from_date).days
        date_period = (from_date, to_date - timedelta(days=1))
        rooms_with_amount = SettlementVariant.objects.filter(enabled=True, settlement__gte=guests,
            room__hotel=self, placeprice__date__range=date_period, placeprice__amount__gt=0).\
            annotate(num_days=Count('pk')).\
            filter(num_days__gte=need_days).order_by('room__pk').values_list('room__pk', flat=True).distinct()
        room_not_avail = Room.objects.filter(pk__in=rooms_with_amount,
            availability__date__range=date_period, availability__min_days__gt=need_days).\
            annotate(num_days=Count('pk')).filter(num_days__gt=0).order_by('pk').\
            values_list('pk', flat=True).distinct()
        rooms = Room.objects.exclude(pk__in=room_not_avail).filter(pk__in=rooms_with_amount,
            availability__date__range=date_period, availability__placecount__gt=0).\
            annotate(num_days=Count('pk')).filter(num_days__gte=need_days)
        return rooms
示例#28
0
class OrderBookSwaps(models.Model):
    STATE_CREATED = 'created'
    STATE_ACTIVE = 'active'
    STATE_EXPIRED = 'expired'
    STATE_POSTPONED = 'postponed'
    STATE_DONE = 'done'
    STATE_CANCELLED = 'cancelled'
    STATE_HIDDEN = 'hidden'

    ORDER_STATES = (
        (STATE_CREATED, 'CREATED'),
        (STATE_ACTIVE, 'ACTIVE'),
        (STATE_EXPIRED, 'EXPIRED'),
        (STATE_POSTPONED, 'POSTPONED'),
        (STATE_DONE, 'DONE'),
        (STATE_CANCELLED, 'CANCELLED'),
        (STATE_HIDDEN, 'HIDDEN'),
    )

    name = models.CharField(max_length=512, null=True, default='')
    memo_contract = models.CharField(max_length=70,
                                     null=True,
                                     default=_get_memo)
    network = models.ForeignKey(Network,
                                on_delete=models.PROTECT,
                                related_name='orders',
                                default=1)
    contract_address = models.CharField(max_length=255,
                                        verbose_name='Contract address',
                                        default='')
    # base_coin_id = models.IntegerField(default=0)
    base_address = models.CharField(max_length=50, null=True, default='')
    base_limit = models.DecimalField(
        max_digits=50,
        decimal_places=18,
    )
    # quote_coin_id = models.IntegerField(default=0)
    quote_address = models.CharField(max_length=50, null=True, default='')
    quote_limit = models.DecimalField(
        max_digits=50,
        decimal_places=18,
    )
    user = models.ForeignKey(
        User,
        on_delete=models.PROTECT,
        related_name='orders',
    )
    owner_address = models.CharField(max_length=50, null=True, default='')
    exchange_user = models.CharField(max_length=512, null=True, default='')
    broker_fee = models.BooleanField(default=False)
    broker_fee_address = models.CharField(max_length=50, null=True, default='')
    broker_fee_base = models.FloatField(null=True, default=0)
    broker_fee_quote = models.FloatField(null=True, default=0)
    min_base_wei = models.CharField(max_length=512, null=True, default='')
    min_quote_wei = models.CharField(max_length=512, null=True, default='')
    base_amount_contributed = models.DecimalField(max_digits=MAX_WEI_DIGITS,
                                                  decimal_places=0,
                                                  default=0)
    base_amount_total = models.DecimalField(max_digits=MAX_WEI_DIGITS,
                                            decimal_places=0,
                                            default=0)
    quote_amount_contributed = models.DecimalField(max_digits=MAX_WEI_DIGITS,
                                                   decimal_places=0,
                                                   default=0)
    quote_amount_total = models.DecimalField(max_digits=MAX_WEI_DIGITS,
                                             decimal_places=0,
                                             default=0)
    public = models.BooleanField(default=True)
    unique_link = models.CharField(max_length=50,
                                   null=True,
                                   unique=True,
                                   default=_get_unique_link)
    created_date = models.DateTimeField(auto_now_add=True)
    stop_date = models.DateTimeField(default=timezone.now)
    contract_state = models.CharField(
        max_length=63,
        choices=ORDER_STATES,
        default=STATE_CREATED,
    )
    state = models.CharField(
        max_length=63,
        choices=ORDER_STATES,
        default=STATE_CREATED,
    )
    state_changed_at = models.DateTimeField(auto_now_add=True)
    whitelist = models.BooleanField(default=False)
    whitelist_address = models.CharField(max_length=50, null=True)
    swap_ether_contract = models.ForeignKey(Contract, null=True)
    is_exchange = models.BooleanField(default=False)
    notification = models.BooleanField(default=False)
    notification_email = models.CharField(max_length=50, null=True, default='')
    notification_telegram_name = models.CharField(max_length=50,
                                                  null=True,
                                                  default='')
    comment = models.TextField(default='')
    is_rubic_order = models.BooleanField(default=False)
    rubic_initialized = models.BooleanField(default=False)
    is_displayed = models.BooleanField(default=True)
    is_closed_by_limiter = models.BooleanField(default=False)
    # ! ---
    swaped_on_uniswap = models.BooleanField(default=False)
    # --
    # !--- Managers
    objects = Manager()
    public_active_orders = PublicActiveOrdersManager(state=STATE_ACTIVE)

    # ---

    class Meta:
        indexes = (models.Index(fields=[
            'id',
            'unique_link',
        ]), )

    def __str__(self):
        return f'Order "{self.name}" (unique link: {self.unique_link})'

    @check_transaction
    def msg_deployed(self):
        self.state = self.STATE_ACTIVE
        self.contract_state = self.STATE_ACTIVE
        self.save()
        if self.user.email:
            swaps_link = '{protocol}://{url}/public-v3/{unique_link}'.format(
                protocol=SITE_PROTOCOL,
                unique_link=self.unique_link,
                url=SWAPS_URL)
            sendEMail(swaps_deploed_subject,
                      swaps_deploed_message.format(swaps_link=swaps_link),
                      [self.user.email])

    def finalized(self):
        self.state = self.STATE_DONE
        self.contract_state = self.STATE_DONE
        self.state_changed_at = datetime.utcnow()
        self.save()

    def cancelled(self):
        self.state = self.STATE_CANCELLED
        self.contract_state = self.STATE_CANCELLED
        self.state_changed_at = datetime.utcnow()
        self.save()

    def deposit_order(self, message):
        msg_amount = message['amount']
        base_address = self.base_address.lower()
        quote_address = self.quote_address.lower()
        if message['token'] == base_address or message[
                'token'] == quote_address:
            if message['token'] == self.base_address:
                self.base_amount_contributed += msg_amount
                self.base_amount_total += msg_amount
            else:
                self.quote_amount_contributed += msg_amount
                self.quote_amount_total += msg_amount

            self.save()

    def refund_order(self, message):
        msg_amount = message['amount']
        base_address = self.base_address.lower()
        quote_address = self.quote_address.lower()
        if message['token'] == base_address or message[
                'token'] == quote_address:
            if message['token'] == self.base_address:
                self.base_amount_contributed -= msg_amount
            else:
                self.quote_amount_contributed -= msg_amount

            self.save()

    def save(self, *args, **kwargs):
        self.base_address = self.base_address.lower()
        self.quote_address = self.quote_address.lower()
        self.owner_address = self.owner_address.lower()
        self.broker_fee_address = self.broker_fee_address.lower()

        return super().save(*args, **kwargs)
示例#29
0
class Room(AbstractName):
    option = models.ManyToManyField(RoomOption,
                                    verbose_name=_('Availability options'),
                                    blank=True)
    hotel = models.ForeignKey(Hotel,
                              verbose_name=_('Hotel'),
                              null=True,
                              blank=True)
    places = models.IntegerField(_("Place Count"),
                                 choices=PLACES_CHOICES,
                                 default=PLACES_UNKNOWN,
                                 db_index=True)
    typefood = models.IntegerField(_("Type of food"),
                                   choices=TYPEFOOD,
                                   default=TYPEFOOD_RO,
                                   db_index=True)
    surface_area = models.PositiveSmallIntegerField(
        verbose_name=_('Surface area (m2)'), default=0, db_index=True)

    class Meta:
        verbose_name = _("Room")
        verbose_name_plural = _("Rooms")

    objects = Manager()

    def __str__(self):
        try:
            return _("%(room)s :: %(places)s :: %(hotel)s") % {
                'room': self.get_name,
                'places': self.places,
                'hotel': self.hotel.get_name
            }
        except:
            return self.name

    @property
    def metadesc(self):
        r = self.description
        if get_language() == 'en' and self.description_en:
            r = self.description_en
        return r.split('. ')[0] + '.'

    @property
    def min_current_amount(self):
        return self.amount_on_date(now())

    def amount_on_date(self, on_date, guests=None):
        result = PlacePrice.objects.filter(settlement__room=self, settlement__enabled=True, date=on_date).\
            aggregate(Min('amount'))
        amount = result['amount__min']
        if amount:
            return amount
        return 0

    def amount_date_guests(self, on_date, guests):
        # noinspection PyBroadException
        try:
            s = SettlementVariant.objects.select_related().filter(room=self, enabled=True, settlement__gte=guests).\
                order_by('settlement')[0]
            return s.amount_on_date(on_date)
        except:
            return None

    def discount_on_date(self, on_date):
        # noinspection PyBroadException
        try:
            return Discount.objects.get(room=self, date=on_date).discount
        except:
            return None

    def settlement_on_date_for_guests(self, on_date, guests):
        result = SettlementVariant.objects.filter(room=self, enabled=True, settlement__gte=guests).\
            aggregate(Min('settlement'))
        return result['settlement__min']

    def active_settlements(self):
        return SettlementVariant.objects.filter(
            room=self, enabled=True).order_by('settlement')

    def get_absolute_url(self):
        return reverse('room_detail',
                       kwargs={
                           'city': self.hotel.city.slug,
                           'slug': self.hotel.slug,
                           'pk': self.pk
                       })

    def active_discounts(self):
        discounts = RoomDiscount.objects.filter(room=self, discount__enabled=True).\
            values_list('discount__pk', flat=True).distinct()
        return Discount.objects.filter(pk__in=discounts).order_by('pk')

    def inactive_discounts(self):
        discounts = RoomDiscount.objects.filter(room=self, discount__enabled=True).\
            values_list('discount__pk', flat=True).distinct()
        return Discount.objects.filter(hotel=self.hotel).exclude(
            pk__in=discounts).order_by('pk')

    @property
    def simple_discount(self):
        result, created = SimpleDiscount.objects.get_or_create(room=self)
        return result
示例#30
0
class Payment(models.Model):
    objects = Manager.from_queryset(PaymentQuerySet)()

    amount = models.DecimalField(
        decimal_places=2,
        max_digits=8,
        validators=[MinValueValidator(Decimal('0.00'))])
    due_date = models.DateField(null=True, blank=True, default=None)

    class Status(object):
        Unpaid = 'unpaid'
        Pending = 'pending'
        Paid = 'paid'
        Canceled = 'canceled'

        FinalStatuses = [Paid, Canceled]

    STATUS_CHOICES = ((Status.Unpaid, _('Unpaid')),
                      (Status.Pending, _('Pending')), (Status.Paid, _('Paid')),
                      (Status.Canceled, _('Canceled')))
    status = FSMField(max_length=8,
                      choices=STATUS_CHOICES,
                      default=Status.Unpaid)

    customer = models.ForeignKey(Customer)
    provider = models.ForeignKey(Provider)
    proforma = models.OneToOneField("Proforma",
                                    null=True,
                                    blank=True,
                                    related_name='proforma_payment')
    invoice = models.OneToOneField("Invoice",
                                   null=True,
                                   blank=True,
                                   related_name='invoice_payment')
    visible = models.BooleanField(default=True)
    currency = models.CharField(choices=currencies,
                                max_length=4,
                                default='USD',
                                help_text='The currency used for billing.')
    currency_rate_date = models.DateField(blank=True, null=True)

    @transition(field='status',
                source=[Status.Unpaid, Status.Pending],
                target=Status.Canceled)
    def cancel(self):
        pass

    @transition(field='status', source=Status.Unpaid, target=Status.Pending)
    def process(self):
        pass

    @transition(field='status',
                source=(Status.Unpaid, Status.Pending),
                target=Status.Paid)
    def succeed(self):
        pass

    @transition(field='status', source=Status.Pending, target=Status.Unpaid)
    def fail(self):
        pass

    def clean(self):
        document = self.invoice or self.proforma
        if document:
            if document.provider != self.provider:
                raise ValidationError(
                    'Provider doesn\'t match with the one in documents.')

            if document.customer != self.customer:
                raise ValidationError(
                    'Customer doesn\'t match with the one in documents.')

        if self.invoice and self.proforma:
            if self.invoice.proforma != self.proforma:
                raise ValidationError('Invoice and proforma are not related.')

    def _log_unsuccessful_transition(self, transition_name):
        logger.warning(
            '[Models][Payment]: %s', {
                'detail': 'Couldn\'t %s payment' % transition_name,
                'payment_id': self.id,
                'customer_id': self.customer.id
            })

    @property
    def is_overdue(self):
        if self.status == Payment.Status.Unpaid and self.days_left <= 0:
            return True

        return False

    @property
    def days_left(self):
        return (self.due_date - date.today()).days

    def __unicode__(self):
        return '#%0#5d' % self.pk

    def diff(self, other_payment):
        changes = {}
        for attr in [
                'amount', 'due_date', 'status', 'customer', 'provider',
                'proforma', 'invoice', 'visible', 'currency',
                'currency_rate_date'
        ]:
            if not hasattr(other_payment, attr) or not hasattr(self, attr):
                continue

            current = getattr(self, attr, None)
            other = getattr(other_payment, attr, None)

            if current != other:
                changes[attr] = {'from': current, 'to': other}

        return changes
示例#31
0
class Booking(MoneyBase, AbstractIP):
    user = models.ForeignKey(settings.AUTH_USER_MODEL,
                             verbose_name=_('User'),
                             blank=True,
                             null=True)
    date = models.DateTimeField(verbose_name=_("Creation date"), default=now)
    system_id = models.IntegerField(_("ID in system"), default=0)
    from_date = models.DateField(_("From"))
    to_date = models.DateField(_("To"))
    settlement = models.ForeignKey(SettlementVariant,
                                   verbose_name=_('Settlement Variant'),
                                   null=True,
                                   on_delete=models.SET_NULL)
    settlement_txt = models.CharField(
        verbose_name=_("Settlement Variant in text"),
        max_length=255,
        blank=True)
    hotel = models.ForeignKey(Hotel,
                              verbose_name=_('Hotel'),
                              blank=True,
                              null=True,
                              on_delete=models.SET_NULL)
    hotel_txt = models.CharField(verbose_name=_("Hotel in text"),
                                 max_length=255,
                                 blank=True)
    status = models.IntegerField(_("Booking status"),
                                 choices=STATUS_CHOICES,
                                 default=STATUS_UNKNOWN)
    first_name = models.CharField(verbose_name=_("First name"), max_length=100)
    middle_name = models.CharField(verbose_name=_("Middle name"),
                                   max_length=100,
                                   blank=True)
    last_name = models.CharField(verbose_name=_("Last name"), max_length=100)
    phone = models.CharField(max_length=100,
                             verbose_name=_('Phone'),
                             blank=True)
    email = models.CharField(_('E-mail'), blank=True, max_length=100)
    uuid = models.CharField(verbose_name=_("Unique ID"),
                            max_length=64,
                            blank=True,
                            editable=False)
    commission = models.DecimalField(verbose_name=_('Commission'),
                                     default=0,
                                     max_digits=20,
                                     decimal_places=3)
    hotel_sum = models.DecimalField(verbose_name=_('Hotel Sum'),
                                    default=0,
                                    max_digits=20,
                                    decimal_places=3)
    card_number = models.CharField(verbose_name=_("Card number"),
                                   max_length=16,
                                   blank=True)
    card_valid = models.CharField(verbose_name=_("Card valid to"),
                                  max_length=5,
                                  blank=True)
    card_holder = models.CharField(verbose_name=_("Card holder"),
                                   max_length=50,
                                   blank=True)
    card_cvv2 = models.CharField(
        verbose_name=_("Card verification value(CVV2)"),
        max_length=4,
        blank=True)
    payment_method = models.ForeignKey(PaymentMethod,
                                       verbose_name=_('Payment method'),
                                       null=True)
    enabled = models.BooleanField(verbose_name=_('Enabled'),
                                  default=False,
                                  db_index=True)
    guests = models.PositiveSmallIntegerField(_("Guests"),
                                              db_index=True,
                                              default=0)
    btype = models.IntegerField(_("Booking type"),
                                choices=BOOKING_CHOICES,
                                default=BOOKING_UNKNOWN)
    bdiscount = models.PositiveSmallIntegerField(
        verbose_name=_('Discount percent'), default=0, db_index=True)
    typefood = models.IntegerField(_("Type of food"),
                                   choices=TYPEFOOD,
                                   db_index=True,
                                   null=True)
    freecancel = models.PositiveSmallIntegerField(
        verbose_name=_('Free cancel days'), default=0, db_index=True)
    penaltycancel = models.DecimalField(
        verbose_name=_('Penalty for cancellation'),
        default=0,
        max_digits=20,
        decimal_places=3)
    comment = models.TextField(verbose_name=_("Client comment"),
                               blank=True,
                               default='')
    amount_no_discount = models.DecimalField(
        verbose_name=_('Amount without discount'),
        default=0,
        max_digits=22,
        decimal_places=5,
        db_index=True)
    cancel_time = models.DateTimeField(
        verbose_name=_("Time/date of cancellation"), blank=True, null=True)

    objects = Manager()

    class Meta:
        ordering = ("-date", )
        verbose_name = _("Booking")
        verbose_name_plural = _("Bookings")

    def __str__(self):
        return "Booking - %s" % self.pk

    @property
    def days(self):
        return (self.to_date - self.from_date).days

    @property
    def freecancel_before(self):
        if self.freecancel > 0:
            return self.from_date - timedelta(days=self.freecancel)
        return False

    @property
    def allow_penalty(self):
        if self.freecancel_before and self.hotel and self.btype == BOOKING_GB:
            offset = self.hotel.city.time_offset
            for_time = self.hotel.time_on
            for_time1 = time(int(for_time[:2]), int(for_time[3:5]))
            if now() > datetime.combine(self.freecancel_before,
                                        for_time1) - timedelta(hours=offset):
                return True
        return False

    def get_absolute_url(self):
        if not self.uuid:
            self.save()
        return reverse('booking_hotel_detail', kwargs={'slug': self.uuid})

    def get_client_url(self):
        if not self.uuid:
            self.save()
        return reverse('booking_user_detail', kwargs={'slug': self.uuid})

    @property
    def room_day_cost(self):
        return self.amount / self.days

    @property
    def room_day_cost_no_amount(self):
        if self.amount_no_discount > 0:
            return self.amount_no_discount / self.days
        if self.bdiscount > 0:
            return ((self.amount * 100) / (100 - self.bdiscount)) / self.days
        return self.room_day_cost

    def save(self, *args, **kwargs):
        if not self.uuid:
            self.uuid = uuid4()
        if self.system_id < 1:
            new_id = random.randint(100000000, 999999999)
            while Booking.objects.filter(system_id=new_id).count() > 0:
                new_id = random.randint(100000000, 999999999)
            self.system_id = new_id
        super(Booking, self).save(*args, **kwargs)
示例#32
0
class HorizontalManager(Manager.from_queryset(QuerySet)):
    use_for_related_fields = True
    use_in_migrations = True

    def __init__(self):
        super(HorizontalManager, self).__init__()
示例#33
0
class Child(TimeStampedModel):
    name = models.CharField(max_length=255)
    parent = models.ForeignKey(Parent, null=True, on_delete=models.CASCADE)
    objects = Manager.from_queryset(ExtendedQuerySet)()