DateTimeModel.__str__() - Code Metrics - edoburu/django-parler - Measure and Improve Code Quality continuously with Scrutinizer

DateTimeModel.str() A
last analyzed 2016-06-17 16:03 UTC

↳ Parent: DateTimeModel

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	2
c	1
b	0
f	0
rs	10
cc	1

from __future__ import unicode_literals
from django.core.urlresolvers import reverse
from django.db import models
from django.utils.encoding import python_2_unicode_compatible
from parler.fields import TranslatedField
from parler.models import TranslatableModel, TranslatedFields, TranslatedFieldsModel
from parler.utils.context import switch_language


class ManualModel(TranslatableModel):
    shared = models.CharField(max_length=200, default='')


class ManualModelTranslations(TranslatedFieldsModel):
    master = models.ForeignKey(ManualModel, related_name='translations')
    tr_title = models.CharField(max_length=200)


@python_2_unicode_compatible
class SimpleModel(TranslatableModel):
    shared = models.CharField(max_length=200, default='')

    translations = TranslatedFields(
        tr_title = models.CharField("Translated Title", max_length=200)
    )

    def __str__(self):
        return self.tr_title


class CleanCharField(models.CharField):

    def clean(self, value, model_instance):
        super(CleanCharField, self).clean(value, model_instance)
        return value + "_cleanchar"


@python_2_unicode_compatible
class CleanFieldModel(TranslatableModel):
    shared = CleanCharField(max_length=200, default='')
    tr_title = TranslatedField()

    def __str__(self):
        return self.tr_title

    def clean(self):
        self.shared += "_cleanshared"


class CleanFieldModelTranslation(TranslatedFieldsModel):
    master = models.ForeignKey(
        CleanFieldModel, related_name='translations', null=True,
        default=1, on_delete=models.CASCADE)
    tr_title = CleanCharField("Translated Title", max_length=200)

    class Meta:
        unique_together = ('language_code', 'master')

    def clean(self):
        self.tr_title += "_cleantrans"


@python_2_unicode_compatible
class DateTimeModel(TranslatableModel):
    shared = models.CharField(max_length=200, default='')
    datetime = models.DateTimeField()

    translations = TranslatedFields(
        tr_title=models.CharField("Translated Title", max_length=200)
    )

    def __str__(self):
        return self.tr_title


@python_2_unicode_compatible
class AnyLanguageModel(TranslatableModel):
    shared = models.CharField(max_length=200, default='')
    tr_title = TranslatedField(any_language=True)

    translations = TranslatedFields(
        tr_title = models.CharField(max_length=200)
    )

    def __str__(self):
        return self.tr_title


@python_2_unicode_compatible
class EmptyModel(TranslatableModel):
    shared = models.CharField(max_length=200, default='')

    # Still tracks how many languages there are, but no actual translated fields exist yet.
    # This is useful when the model is a parent object for inlines. The parent model defines the language tabs.
    translations = TranslatedFields()

    def __str__(self):
        return self.shared


@python_2_unicode_compatible
class ArticleSlugModel(TranslatableModel):
    translations = TranslatedFields(
        slug = models.SlugField()
    )

    def __str__(self):
        return self.slug

    def get_absolute_url(self):
        with switch_language(self):
            return reverse('article-slug-test-view', kwargs={'slug': self.slug})


class AbstractModel(TranslatableModel):
    # Already declared, but not yet linkable to a TranslatedFieldsModel
    tr_title = TranslatedField(any_language=True)

    class Meta:
        abstract = True


class ConcreteModel(AbstractModel):
    translations = TranslatedFields(
        tr_title = models.CharField("Translated Title", max_length=200)
    )


class UniqueTogetherModel(TranslatableModel):
    translations = TranslatedFields(
        slug = models.SlugField(),
        meta = {
            'unique_together': [
                ('slug', 'language_code',),
            ]
        }
    )


class Level1(TranslatableModel):
    l1_translations = TranslatedFields(
        l1_title = models.CharField(max_length=200)
    )


class Level2(Level1):
    l2_translations = TranslatedFields(
        l2_title = models.CharField(max_length=200)
    )


class ProxyBase(TranslatableModel):
    base_translations = TranslatedFields(
        base_title = models.CharField(max_length=200)
    )


class ProxyModel(ProxyBase):
    proxy_translations = TranslatedFields(
        proxy_title = models.CharField(max_length=200)
    )

    class Meta:
        proxy = True


class DoubleModel(TranslatableModel):
    shared = models.CharField(max_length=200, default='')


class DoubleModelTranslations(TranslatedFieldsModel):
    master = models.ForeignKey(DoubleModel, related_name='base_translations')
    l1_title = models.CharField(max_length=200)


class DoubleModelMoreTranslations(TranslatedFieldsModel):
    master = models.ForeignKey(DoubleModel, related_name='more_translations')
    l2_title = models.CharField(max_length=200)


class RegularModel(models.Model):
    # Normal model without translations. Test how replacing the field works.
    original_field = models.CharField(default="untranslated", max_length=255)


class CharModel(TranslatableModel):
    id = models.CharField(max_length=45, primary_key=True)


class CharModelTranslation(TranslatedFieldsModel):
    master = models.ForeignKey(CharModel)
    tr_title = models.CharField(max_length=200)


class ForeignKeyTranslationModel(TranslatableModel):
    translations = TranslatedFields(
        translated_foreign = models.ForeignKey('RegularModel'),
    )
    shared = models.CharField(max_length=200)


class TranslationRelated(TranslatableModel):
    shared = models.CharField(max_length=200)
    translation_relations = TranslatedField()


class TranslationRelatedTranslation(TranslatedFieldsModel):
    master = models.ForeignKey(TranslationRelated, related_name='translations')
    title = models.CharField(max_length=200)
    m2m_regular = models.ManyToManyField(RegularModel)


class TranslationRelatedRelation(models.Model):
    translation = models.ForeignKey(TranslationRelatedTranslation, related_name='translation_relations')
    name = models.CharField(max_length=200)


1			from __future__ import unicode_literals
2			from django.core.urlresolvers import reverse
3			from django.db import models
4			from django.utils.encoding import python_2_unicode_compatible
5			from parler.fields import TranslatedField
6			from parler.models import TranslatableModel, TranslatedFields, TranslatedFieldsModel
7			from parler.utils.context import switch_language
8
9
10			class ManualModel(TranslatableModel):
11			shared = models.CharField(max_length=200, default='')
12
13
14			class ManualModelTranslations(TranslatedFieldsModel):
15			master = models.ForeignKey(ManualModel, related_name='translations')
16			tr_title = models.CharField(max_length=200)
17
18
19			@python_2_unicode_compatible
20			class SimpleModel(TranslatableModel):
21			shared = models.CharField(max_length=200, default='')
22
23			translations = TranslatedFields(
24			tr_title = models.CharField("Translated Title", max_length=200)
25			)
26
27			def __str__(self):
28			return self.tr_title
29
30
31			class CleanCharField(models.CharField):
32
33			def clean(self, value, model_instance):
34			super(CleanCharField, self).clean(value, model_instance)
35			return value + "_cleanchar"
36
37
38			@python_2_unicode_compatible
39			class CleanFieldModel(TranslatableModel):
40			shared = CleanCharField(max_length=200, default='')
41			tr_title = TranslatedField()
42
43			def __str__(self):
44			return self.tr_title
45
46			def clean(self):
47			self.shared += "_cleanshared"
48
49
50			class CleanFieldModelTranslation(TranslatedFieldsModel):
51			master = models.ForeignKey(
52			CleanFieldModel, related_name='translations', null=True,
53			default=1, on_delete=models.CASCADE)
54			tr_title = CleanCharField("Translated Title", max_length=200)
55
56			class Meta:
57			unique_together = ('language_code', 'master')
58
59			def clean(self):
60			self.tr_title += "_cleantrans"
61
62
63			@python_2_unicode_compatible
64			class DateTimeModel(TranslatableModel):
65			shared = models.CharField(max_length=200, default='')
66			datetime = models.DateTimeField()
67
68			translations = TranslatedFields(
69			tr_title=models.CharField("Translated Title", max_length=200)
70			)
71
72			def __str__(self):
73			return self.tr_title
74
75
76			@python_2_unicode_compatible
77			class AnyLanguageModel(TranslatableModel):
78			shared = models.CharField(max_length=200, default='')
79			tr_title = TranslatedField(any_language=True)
80
81			translations = TranslatedFields(
82			tr_title = models.CharField(max_length=200)
83			)
84
85			def __str__(self):
86			return self.tr_title
87
88
89			@python_2_unicode_compatible
90			class EmptyModel(TranslatableModel):
91			shared = models.CharField(max_length=200, default='')
92
93			# Still tracks how many languages there are, but no actual translated fields exist yet.
94			# This is useful when the model is a parent object for inlines. The parent model defines the language tabs.
95			translations = TranslatedFields()
96
97			def __str__(self):
98			return self.shared
99
100
101			@python_2_unicode_compatible
102			class ArticleSlugModel(TranslatableModel):
103			translations = TranslatedFields(
104			slug = models.SlugField()
105			)
106
107			def __str__(self):
108			return self.slug
109
110			def get_absolute_url(self):
111			with switch_language(self):
112			return reverse('article-slug-test-view', kwargs={'slug': self.slug})
113
114
115			class AbstractModel(TranslatableModel):
116			# Already declared, but not yet linkable to a TranslatedFieldsModel
117			tr_title = TranslatedField(any_language=True)
118
119			class Meta:
120			abstract = True
121
122
123			class ConcreteModel(AbstractModel):
124			translations = TranslatedFields(
125			tr_title = models.CharField("Translated Title", max_length=200)
126			)
127
128
129			class UniqueTogetherModel(TranslatableModel):
130			translations = TranslatedFields(
131			slug = models.SlugField(),
132			meta = {
133			'unique_together': [
134			('slug', 'language_code',),
135			]
136			}
137			)
138
139
140			class Level1(TranslatableModel):
141			l1_translations = TranslatedFields(
142			l1_title = models.CharField(max_length=200)
143			)
144
145
146			class Level2(Level1):
147			l2_translations = TranslatedFields(
148			l2_title = models.CharField(max_length=200)
149			)
150
151
152			class ProxyBase(TranslatableModel):
153			base_translations = TranslatedFields(
154			base_title = models.CharField(max_length=200)
155			)
156
157
158			class ProxyModel(ProxyBase):
159			proxy_translations = TranslatedFields(
160			proxy_title = models.CharField(max_length=200)
161			)
162
163			class Meta:
164			proxy = True
165
166
167			class DoubleModel(TranslatableModel):
168			shared = models.CharField(max_length=200, default='')
169
170
171			class DoubleModelTranslations(TranslatedFieldsModel):
172			master = models.ForeignKey(DoubleModel, related_name='base_translations')
173			l1_title = models.CharField(max_length=200)
174
175
176			class DoubleModelMoreTranslations(TranslatedFieldsModel):
177			master = models.ForeignKey(DoubleModel, related_name='more_translations')
178			l2_title = models.CharField(max_length=200)
179
180
181			class RegularModel(models.Model):
182			# Normal model without translations. Test how replacing the field works.
183			original_field = models.CharField(default="untranslated", max_length=255)
184
185
186			class CharModel(TranslatableModel):
187			id = models.CharField(max_length=45, primary_key=True)
188
189
190			class CharModelTranslation(TranslatedFieldsModel):
191			master = models.ForeignKey(CharModel)
192			tr_title = models.CharField(max_length=200)
193
194
195			class ForeignKeyTranslationModel(TranslatableModel):
196			translations = TranslatedFields(
197			translated_foreign = models.ForeignKey('RegularModel'),
198			)
199			shared = models.CharField(max_length=200)
200
201
202			class TranslationRelated(TranslatableModel):
203			shared = models.CharField(max_length=200)
204			translation_relations = TranslatedField()
205
206
207			class TranslationRelatedTranslation(TranslatedFieldsModel):
208			master = models.ForeignKey(TranslationRelated, related_name='translations')
209			title = models.CharField(max_length=200)
210			m2m_regular = models.ManyToManyField(RegularModel)
211
212
213			class TranslationRelatedRelation(models.Model):
214			translation = models.ForeignKey(TranslationRelatedTranslation, related_name='translation_relations')
215			name = models.CharField(max_length=200)
216

edoburu / django-parler

DateTimeModel.__str__() A last analyzed 2016-06-17 16:03 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

DateTimeModel.str() A
last analyzed 2016-06-17 16:03 UTC