class Person(PolymorphicModel):
name = models.CharField(_('name'), max_length=100)
gender = models.CharField(_('gender'),
max_length=2,
blank=True,
null=True,
choices=(
('m', _('male')),
('f', _('female')),
))
short_bio = models.TextField(_('short bio'), blank=True, null=True)
short_bio_en = models.TextField(_('short bio (EN)'), blank=True, null=True)
bio = MartorField(_('biography'), blank=True, null=True)
bio_en = MartorField(_('biography (EN)'), blank=True, null=True)
reporter = models.ForeignKey(User,
verbose_name=_('reporter'),
blank=True,
null=True,
on_delete=models.SET_NULL)
added = models.DateTimeField(_('added time'), auto_now_add=True)
modified = models.DateTimeField(_('modified time'), auto_now=True)
def __str__(self):
return self.name
class Meta:
verbose_name = _('person')
verbose_name_plural = _('people')
ordering = ('name', )
class Resume(Model):
title = CharField(max_length=50, default='resume')
whoami = MartorField()
services = MartorField()
experiences = models.ManyToManyField(Experience, blank=True)
def __str__(self):
return 'Resume'
class Post(models.Model):
author = models.ForeignKey(User, on_delete=models.CASCADE,
blank=True, null=True)
title = models.CharField(max_length=200)
description = MartorField()
wiki = MartorField(blank=True)
def __str__(self):
return self.title
class Article(models.Model):
tips = models.CharField(verbose_name=u"声明",
max_length=10,
editable=True,
blank=True,
null=True,
default=u"Develop")
# author = models.TextField(verbose_name=u"作者", blank=True, null=True, editable=True, default=u"佚名")
author = models.ForeignKey(
User,
verbose_name=u"作者",
on_delete=models.DO_NOTHING,
)
title = models.CharField(
verbose_name=u"标题",
max_length=25,
blank=False,
null=False,
)
calendar = models.DateField(verbose_name=u"发布时间", auto_now_add=True)
update = models.DateTimeField(verbose_name=u"最后更新", auto_now=True)
numerous = models.IntegerField(verbose_name=u"点击数量",
editable=True,
blank=True,
default=100)
display = models.BooleanField(
verbose_name=u"展示",
default=True,
)
group = models.ForeignKey(ArticleGroup,
on_delete=models.CASCADE,
verbose_name=u"文章类型")
# 采用markdown存储
# thumbnail = models.URLField(verbose_name=u"缩略图")
thumbnail_content = MartorField(verbose_name=u"缩略文字",
blank=True,
max_length=300)
content = MartorField(verbose_name=u"内容详情",
blank=True,
max_length=sys.maxsize)
def __str__(self):
return self.title
# def get_absolute_url(self):
# return const.get_absolute_url('api:details', args=[self.id])
def group_name(self):
return self.group.__str__()
def increase_views(self):
self.numerous += 1
self.save(update_fields=['numerous'])
class Event(MultilingualModel):
site = models.ForeignKey(Site, on_delete=models.CASCADE)
title_tr = models.CharField(max_length=40)
title_en = models.CharField(max_length=40)
content_tr = MartorField()
content_en = MartorField()
class Meta:
ordering = ['site', '-pk']
def __str__(self):
return '{} - {}'.format(self.site.name, self.title)
class Case(models.Model):
name = models.CharField(_('case name'), max_length=250)
name_en = models.CharField(_('case name (EN)'), max_length=250, blank=True, null=True)
slug = models.SlugField(blank=True, null=True)
no = models.CharField(_('file number'), max_length=20)
court = models.ForeignKey(Court, verbose_name=_('court'), on_delete=models.CASCADE)
filing_date = models.DateField(_('case filing date'), blank=True, null=True) # iddianame tarihi
opening_date = models.DateField(_('case opening date'), blank=True, null=True) # dava acilis tarihi
defendant_count = models.PositiveIntegerField(_('defendant count'), blank=True, null=True)
journalist_defendant_count = models.PositiveIntegerField(_('journalist defendant count'), blank=True, null=True)
coup_related = models.BooleanField(_('coup attempt related'), default=False)
journalists = models.ManyToManyField(Journalist, through='CaseJournalist')
plaintiff = models.ManyToManyField(Plaintiff, verbose_name=_('plaintiff'), blank=True)
prosecutor = models.ForeignKey(Prosecutor, verbose_name=_('indictment prosecutor'),
blank=True, null=True, on_delete=models.SET_NULL)
summary = MartorField(_('case summary'), blank=True, null=True)
summary_en = MartorField(_('case summary (EN)'), blank=True, null=True)
order = models.PositiveSmallIntegerField(_('order'), default=0)
related_cases = models.ManyToManyField('self', verbose_name=_('related cases'), blank=True)
reporter = models.ForeignKey(User, verbose_name=_('reporter'), blank=True, null=True, on_delete=models.SET_NULL)
publish = models.BooleanField(_('publish'), default=False)
added = models.DateTimeField(_('added time'), auto_now_add=True)
modified = models.DateTimeField(_('modified time'), auto_now=True)
def __str__(self):
return self.name
def save(self, **kwargs):
if not self.slug:
self.slug = slugify(self.name)
return super().save(**kwargs)
def get_absolute_url(self):
return reverse('case_detail', args=[self.id])
def status(self):
return self.casestatus_set.last()
def notes(self):
return self.casenote_set.filter(type__publish=True).filter(journalist__isnull=True)
def get_journalists(self):
return self.journalists.filter(publish=True)
class Meta:
verbose_name = _('case')
verbose_name_plural = _('cases')
ordering = ('slug', 'order', '-modified',)
class Author(models.Model):
# A User can have multiple author roles (or pseudonyms)
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE,
blank=False, null=False)
name = models.CharField(max_length=64, blank=False, null=False, unique=True)
# Each user profile will have a field where they can tell other users
# something about themselves. This field will be empty when the user
# creates their account, so we specify `blank=True`.
bio_text = MartorField(blank=True)
# In addition to the `bio` field, each user may have a profile image or
# avatar. Similar to `bio`, this field is not required. It may be blank.
avatar = models.URLField(blank=True)
objects = AuthorManager()
def __str__(self):
return self.name
def bio_html(self):
""" Return the markdownified biography of this author """
return SafeString(markdownify(self.bio_text))
class UserRequest(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL,
related_name="+",
on_delete=models.CASCADE)
title = models.CharField(max_length=255,
help_text="What is being requested?")
request_type = models.IntegerField(choices=REQUEST_TYPES, null=False)
acquired = models.BooleanField(default=False)
cost = models.DecimalField(
max_digits=6,
decimal_places=2,
help_text=
"Leave blank, if no associated cost, or add estimated cost if not sure.",
)
description = MartorField(
help_text=
"detail of what is being requested, and where it can be purchased.")
created_date = models.DateTimeField(default=timezone.now)
def request_type_string(self):
return REQUEST_TYPES[self.request_type][1]
def get_absolute_url(self):
return reverse("requests_detail", kwargs={"pk": self.pk})
class Meta:
ordering = ("acquired", "created_date")
class Question(models.Model):
author = models.ForeignKey(User, related_name='questions')
title = models.CharField(max_length=255, null=False)
text = MartorField()
category = models.ForeignKey(QuestionCategory, related_name='questions', null=True)
created = models.DateTimeField(editable=False)
modified = models.DateTimeField()
def get_absolute_url(self):
return reverse_lazy('question:question', kwargs={'pk': self.id})
def save(self, *args, **kwargs):
""" On save, update timestamps """
if not self.id:
self.created = timezone.now()
self.modified = timezone.now()
return super(type(self), self).save(*args, **kwargs)
def __str__(self):
return 'Question #{} by @{}: "{}"'.format(self.pk, self.author.username, self.title[:20])
def count_likes(self):
return Like.objects\
.filter(content_type=ContentType.objects.get(model='question'), object_id=self.id)\
.count()
class Meta:
verbose_name = "question"
verbose_name_plural = "questions"
class Post(models.Model):
post_subject = models.CharField(max_length=POST_SUBJECT_SIZE, null=True)
message = MartorField(
max_length=MESSAGE_FIELD_SIZE,
help_text=f'Maximum length is {MESSAGE_FIELD_SIZE} characters',
)
topic = models.ForeignKey(Topic,
on_delete=models.CASCADE,
related_name='posts')
created_by = models.ForeignKey(User,
on_delete=models.CASCADE,
related_name='posts')
created_at = models.DateTimeField(auto_now_add=True)
updated_by = models.ForeignKey(User,
on_delete=models.CASCADE,
related_name='+',
null=True)
updated_at = models.DateTimeField(null=True)
allowed_editor = models.ManyToManyField(User, blank=True)
def get_message_as_markdown(self):
return self.message
def __str__(self):
return Truncator(self.post_subject).chars(30)
class BlogPost(models.Model):
objects = models.Manager() # The default manager.
published = PublishedManager() # Our custom manager.
title = models.CharField(max_length=250, help_text="Give a clear title for the post")
slug = models.SlugField(max_length=100, unique=True)
show = models.BooleanField('BlogPost Enabled/Disabed', default=True)
author = models.ForeignKey(settings.AUTH_USER_MODEL, blank=True, related_name='blogauthor', default = User)
body = MartorField('Body of the blog post')
allow_comments = models.BooleanField('allow comments', default=True)
tags = TaggableManager(blank = True)
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
def save(self):
if not self.id:
# Newly created object, so set slug
self.slug = slugify(self.title)
super(BlogPost, self).save()
def get_absolute_url(self):
return reverse('blog:blog_detail', args=[self.pk, self.slug])
class Meta:
ordering = ('-created',)
def __str__(self):
return self.title
class Story(models.Model):
""" Holds a single story content """
author = models.ForeignKey('authors.Author', verbose_name=_("Pseudonym"),
on_delete=models.PROTECT)
title = models.CharField(max_length=64, null=False, blank=False)
tagline = models.CharField(max_length=64, blank=True)
text = MartorField(null=False, blank=False)
published_at = models.DateTimeField(default=None, null=True, blank=True, db_index=True)
hidden_at = models.DateTimeField(default=None, null=True, blank=True)
inspired_by = models.ForeignKey('self', default=None, null=True, blank=True,
on_delete=models.PROTECT)
language = models.CharField(_('language'),
max_length=5,
choices=settings.LANGUAGES,
default=settings.LANGUAGE_CODE[:2],
help_text=_('Story language.'))
objects = StoryManager()
def __str__(self):
return self.title
def read_time(self):
return _("Short read")
def html(self):
""" Return the html version of the markdown. Wraps it as a SafeString so it will
display without being escaped. This should probably be done and cached somewhere
and let this method do a lookup for the cached version. An alternative would be to
double the storage in the DB but that could mean having to update the whole DB if we
fix something about martor. Storing this in a memcached instance would probably
be better """
# TODO: Store the results in memcached for speed
return SafeString(markdownify(self.text))
class ArticleTranslation(models.Model):
article = models.ForeignKey(Article,
on_delete=models.CASCADE,
related_name='translations')
language = models.CharField(max_length=2, choices=settings.LANGUAGES)
title = models.CharField(max_length=255)
content = MartorField()
formatted_content = models.TextField(editable=False)
# Store the formatted_content field with all tags removed (for description)
unformatted_content = models.TextField(editable=False)
last_modified = models.DateField(auto_now=True)
class Meta:
unique_together = ('article', 'language')
def __str__(self):
return "{}—{}".format(self.article.title, self.get_language_display())
def save(self, *args, **kwargs):
# Parse markdown and cache it.
self.formatted_content = markdownify(self.content)
self.unformatted_content = strip_tags(self.formatted_content)
super().save(*args, **kwargs)
def get_absolute_url(self):
return reverse('article', args=[self.article.slug
]) + '?language=' + self.language
class Post(models.Model):
title = models.CharField(max_length=240)
subtitle = models.CharField(max_length=39, null=True, blank=True)
body = MartorField()
slug = models.SlugField(default="", editable=False, max_length=70)
published = models.BooleanField(default=False)
enable_preview = models.BooleanField(default=False)
date_added = models.DateTimeField(default=timezone.now)
def save(self, *args, **kwargs):
self.slug = slugify(self.title, allow_unicode=True)
if self.published:
self.enable_preview = False
super().save(*args, **kwargs)
update_google()
def get_absolute_url(self):
kwargs = {"slug": self.slug}
return reverse("postdetail", kwargs=kwargs)
def __str__(self):
if self.enable_preview:
pub = "preview"
else:
pub = "published" if self.published else "unpublished"
return f"{self.id} | {self.title} | {pub} | {self.get_absolute_url()}"
class Page(models.Model):
PAGE_STATUS_CHOICE = (
('1', 'Published'),
('0', 'UnPublished'),
)
page_name = models.CharField(max_length=255)
page_body = MartorField(default='')
page_author = models.ForeignKey(User, on_delete=models.CASCADE)
page_date = models.DateTimeField('page date')
page_status = models.CharField(max_length=1, choices=PAGE_STATUS_CHOICE, default='1')
page_header = VersatileImageField(
'Header',
upload_to='page',
default='',
blank=True,
width_field='page_header_image_width',
height_field='page_header_image_height',
ppoi_field='page_header_ppoi'
)
page_header_image_height = models.PositiveIntegerField(
'Image Height',
blank=True,
null=True
)
page_header_image_width = models.PositiveIntegerField(
'Image Width',
blank=True,
null=True
)
page_header_ppoi = PPOIField(
'Image PPOI'
)
def __str__(self):
return self.page_name
class Post(models.Model):
title = models.CharField(_('Title'), max_length=255)
slug = models.SlugField(max_length=127)
description = models.TextField(_('Short description'), blank=True)
markdown = MartorField(_('Text'))
lang = models.CharField(_('Language'),
max_length=2,
choices=settings.LANGUAGES)
category = models.ForeignKey('Category',
null=True,
on_delete=models.SET_NULL)
page_views = models.PositiveIntegerField(_('Page views'), default=0)
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
is_published = models.BooleanField(_('Is published'), default=False)
class Meta:
verbose_name = _('Post')
verbose_name_plural = _('Posts')
def __str__(self):
return self.title
def get_absolute_url(self):
if self.lang == 'ru':
return '/{}/'.format(self.slug)
else:
return '/{}/{}/'.format(self.lang, self.slug)
class Post(models.Model):
topic = models.ForeignKey(Topic,
related_name='posts',
on_delete=models.CASCADE)
post = MartorField()
slug = models.SlugField(blank=True, max_length=200)
created_by = models.ForeignKey(get_user_model(),
related_name='posts',
on_delete=models.CASCADE)
updated_by = models.ForeignKey(get_user_model(),
related_name="+",
on_delete=models.CASCADE,
blank=True,
null=True)
created_on = models.DateTimeField(auto_now_add=True)
updated_on = models.DateTimeField(auto_now_add=True)
objects = models.Manager()
def __str__(self):
return self.post
def save(self, *args, **kwargs):
self.slug = slugify(self.topic)
return super().save(*args, **kwargs)
def get_post_as_markdown(self):
return mark_safe(markdown(self.post, safe_mode='escape'))
class Recipe(models.Model):
title = models.CharField(max_length=254,
unique=True,
verbose_name=_('title'))
tags = models.ManyToManyField('Tag', blank=True, verbose_name=_('tags'))
ingredient_units = models.ManyToManyField('IngredientUnit',
through='IngredientInRecipe',
blank=True,
verbose_name=_('ingredients'))
recipe = MartorField(blank=True, verbose_name=_('recipe'))
popularity = models.PositiveIntegerField(default=0)
class Meta:
ordering = ['-popularity', 'title']
verbose_name = _('recipe')
verbose_name_plural = _('recipes')
def __str__(self):
return self.title
def tag_list(self):
return ', '.join(self.tags.all().values_list('name', flat=True))
def get_absolute_url(self):
return reverse('recipe', args=[str(self.id)])
def get_add_to_cart_url(self):
return reverse('add_to_cart', args=[str(self.id), 0])[:-1]
tag_list.short_description = _('tags')
class Remember(core_models.TimeStampedModel):
"""Remember Model"""
user = models.ForeignKey(
"users.User", related_name="remembers", on_delete=models.CASCADE
)
STAGE_1WEEK = "7"
STAGE_2WEEK = "14"
STAGE_1MONTH = "30"
STAGE_2MONTH = "60"
STAGE_3MONTH = "90"
STAGE_6MONTH = "180"
STAGE_1YEAR = "360"
REMEMBER_STAGE = (
(STAGE_1WEEK, "1 Week"),
(STAGE_2WEEK, "2 Week"),
(STAGE_1MONTH, "1 Month"),
(STAGE_2MONTH, "2 Month"),
(STAGE_3MONTH, "3 Month"),
(STAGE_6MONTH, "6 Month"),
(STAGE_1YEAR, "1 Year"),
)
stage = models.CharField(max_length=7, choices=REMEMBER_STAGE, default=STAGE_1WEEK)
showing_date = models.DateField(
"Showing Date", default=datetime.today() + timedelta(days=7)
)
remember = MartorField()
# slug = models.SlugField(unique=True, max_length=100)
tags = TaggableManager(blank=True)
class Post(Signable):
title = models.CharField(
'제목',
max_length=100,
help_text='제목',
null=False,
blank=False,
)
subtitle = models.CharField(
'부제목',
max_length=100,
help_text='부제목',
null=True,
blank=True,
)
contents = MartorField(
'컨텐츠',
help_text='html contents',
null=False,
blank=True,
)
# contents = models.TextField(
# '컨텐츠',
# help_text='html contents',
# null=False,
# blank=True,
# )
secret = models.BooleanField(default=False, )
class Element(models.Model):
__element_related_name__ = None
uid = models.UUIDField(unique=True, default=uuid.uuid4, editable=False)
title = models.CharField(blank=True,
null=True,
max_length=255,
unique=True)
description = MartorField(blank=True, null=True)
tags = models.CharField(blank=True, null=True, max_length=255)
renderer = models.CharField(blank=True, null=True, max_length=512)
links = models.ManyToManyField('self',
symmetrical=False,
through='ElementLink',
through_fields=('node', 'sibbling'))
@classmethod
def cast(cls, element, raise_exception=False):
child_field_name = cls.__element_related_name__ or cls.__name__.lower()
if raise_exception:
return getattr(element, child_field_name)
return getattr(element, child_field_name, None)
@classmethod
def defines(cls, element):
child_field_name = cls.__element_related_name__ or cls.__name__.lower()
return hasattr(element, child_field_name)
def __str__(self):
return str(self.uid)
class Author(models.Model):
name = models.CharField(max_length=100)
bio = MartorField(blank=True)
formatted_bio = models.TextField(editable=False)
twitter = models.CharField(max_length=15,
blank=True,
null=True,
help_text='Username (without the @)')
slug = models.SlugField(
unique=True,
help_text="Please do not change this after the author is live.")
is_male = models.BooleanField(default=True)
def __str__(self):
return self.name
def get_articles(self):
return self.articles.filter(published=True)
def get_absolute_url(self):
return reverse('author', args=[self.slug])
def save(self, *args, **kwargs):
# Parse markdown and cache it.
self.formatted_bio = markdownify(self.bio)
super().save(*args, **kwargs)
class Post(AbstractCreateUpdateModel):
"""
blog post information
"""
category = models.ForeignKey(PostCategory,
on_delete=models.CASCADE,
related_name='post_category')
author = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.SET_NULL,
null=True)
title = models.CharField(max_length=120)
content = MartorField()
draft = models.BooleanField(default=False)
read_count = models.IntegerField(default=0)
# read_time = models.TimeField(null=True, blank=True)
class Meta:
db_table = 'post'
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse("posts:detail", kwargs={"id": self.id})
def get_markdown(self):
content = self.content
markdown_text = markdown(content)
return mark_safe(markdown_text)
class MarkdownPage(models.Model):
title_fr = models.CharField(max_length=255)
title_vo = models.CharField(max_length=255)
description_fr = models.TextField()
description_vo = models.TextField()
tags = models.ManyToManyField(Tag)
body_fr = MartorField()
body_vo = MartorField()
created_at = models.DateTimeField(auto_now_add=True, editable=False)
updated_at = models.DateTimeField()
def __str__(self):
return f'"{self.title_fr} | {self.title_vo}" (page {self.pk})'
class Meta:
abstract = True
class LogEntry(models.Model):
user = models.ForeignKey(User,
on_delete=models.CASCADE,
related_name="logentry_user")
creation_dt = models.DateTimeField(auto_now_add=True)
project = models.ForeignKey(Project,
null=True,
blank=True,
on_delete=models.CASCADE)
content = MartorField(null=False, blank=False)
def __str__(self):
return self.content
class Meta:
db_table = 'pl_logentry'
ordering = [
'-creation_dt',
]
def edit_url(self):
return reverse('edit-entry', args=[self.pk])
def delete_url(self):
return reverse(
'delete-entry',
args=[self.pk],
)
class Page(models.Model):
title = models.CharField(max_length=255)
slug = AutoSlugField(populate_from='title', max_length=255)
published = models.BooleanField()
order = models.PositiveIntegerField(
help_text="Set the order this page will appear in the nav.", default=0)
meta_description = models.TextField(
help_text="Text for meta tag description and social cards (SEO)",
blank=True,
null=True)
content = MartorField(blank=True, null=True)
internal_notes = models.TextField(
help_text="A place to leave notes – this won't show up on page.",
blank=True,
null=True)
objects = PageManager()
class Meta:
ordering = ('order', )
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse('page', args=[self.slug])
class Template(models.Model):
code = models.CharField(
max_length=16,
verbose_name='Code',
help_text='A short code (16 chars) as identifier for the template.',
unique=True
)
name = models.CharField(
max_length=64,
verbose_name='Name',
help_text="A human readable title for the Smart License template."
)
description = models.CharField(
max_length=255,
verbose_name='Description',
help_text="A short description of Smart License template."
)
template = MartorField(
verbose_name='Template',
help_text="The tamplate data itself (Markdown/Jinja).",
)
class Meta:
verbose_name = "Smart License Template"
verbose_name_plural = "Smart License Templates"
def __str__(self):
return self.name
class Article(models.Model):
authors = models.ManyToManyField(Author, related_name="articles")
cats = models.ManyToManyField(Cat, related_name="articles")
slug = models.SlugField(max_length=63, unique=True)
title = models.CharField(max_length=255)
content = MartorField()
img = models.ImageField()
date = models.DateField()
featured = models.BooleanField(default=False)
draft = models.BooleanField(default=True)
pop = models.IntegerField(default=0)
objects = models.Manager()
nondraft = NondraftManager()
def __str__(self):
return self.title
def to_search(self):
return ArticleIndex(
meta={"id": self.pk},
authors=" ".join([a.name for a in self.authors.all()]),
cats=" ".join([c.name for c in self.cats.all()]),
title=self.title,
content=self.content,
date=self.date)
class Meta:
ordering = ["-featured", "-date", "-pk"]
class Question(models.Model):
title = models.CharField(max_length=100)
writer = models.ForeignKey(
User,
null=True,
on_delete=models.SET_NULL
)
content = MartorField()
category = models.ForeignKey(Category, on_delete=models.CASCADE)
sub_category = models.ForeignKey(
SubCategory,
null=True,
on_delete=models.SET_NULL
)
published = models.DateTimeField(auto_now_add=True)
recommend = models.IntegerField(default=0)
recommended_person = models.ManyToManyField(User, blank=True, related_name='question_recommanded_person')
tags = models.ManyToManyField(Tag, blank=True)
comments = models.ManyToManyField(Comment, blank=True)
answers = models.ManyToManyField(Answer, blank=True)
def get_comment_count(self):
return self.comments.all().count()
def __str__(self):
return '[' + str(self.category) + '] ' + self.title
class Element(PolymorphicModel):
design = models.ForeignKey(Design, on_delete=models.CASCADE)
element_type = models.ForeignKey(ElementType, on_delete=models.PROTECT)
name = models.CharField(max_length=50, unique=True)
description = MartorField(default="", blank=True)
observation_date = models.DateField(
null=True,
blank=True,
help_text="If empty, an unexisting element (to be added).",
)
permanence = models.PositiveSmallIntegerField(
null=True, blank=True, choices=settings.PERMANENCE_CHOICES)
is_risky = models.BooleanField(default=False)
objects = ElementManager()
class Meta:
ordering = ["name"]
def __str__(self):
return self.name
@property
def all_tags(self):
return self.element_type.tags.all() | self.tags.all()