class Post(models.Model):
# Django가 제공하는 기본 settings.AUTH_USER_MODEL와 연결되도록 수정
author = models.ForeignKey(settings.AUTH_USER_MODEL)
photo = CustomImageField(upload_to='post', blank=True)
video = models.ForeignKey('Video', blank=True, null=True)
created_date = models.DateTimeField(auto_now_add=True)
modified_date = models.DateTimeField(auto_now=True)
my_comment = models.OneToOneField('Comment',
blank=True,
null=True,
related_name='+')
like_users = models.ManyToManyField(
settings.AUTH_USER_MODEL,
related_name='like_posts',
through='PostLike',
)
class Meta:
ordering = [
'-pk',
]
def add_comment(self, user, content):
# 자신을 post로 갖고, 전달받은 user를 author로 가지며
# content를 content필드내용으로 넣는 Comment객체 생성
return self.comment_set.create(author=user, content=content)
@property
def like_count(self):
# 자신을 like하고 있는 user수 리턴
return self.like_users.count()
class Post(models.Model):
author = models.ForeignKey(settings.AUTH_USER_MODEL)
photo = CustomImageField(upload_to='post', blank=True)
video = models.ForeignKey('Video', blank=True, null=True) #(0627) 추가
created_date = models.DateTimeField(auto_now_add=True)
modified_date = models.DateTimeField(auto_now=True)
my_comment = models.OneToOneField(
'Comment', blank=True, null=True,
related_name='+') # Post 작성시 내용 (+는 역참조가 없음을 의미)
like_users = models.ManyToManyField(
settings.AUTH_USER_MODEL,
related_name='like_posts',
through=
'PostLike' # makemigrations는 가능하지만, migrate는 안되기 때문에 fake옵션을 주고 수정
)
class Meta:
ordering = [
'-pk',
]
def add_comment(self, user, content):
# 자신을 post로 갖고, 전달받은 user를 author로 가지며, content를 content 필드내용으로 넣는 Comment 객체를 생성
return self.comment_set.create(author=user, content=content)
@property
def like_count(self):
return self.like_users.count()
class Post(models.Model):
author = models.ForeignKey(settings.AUTH_USER_MODEL)
photo = CustomImageField(upload_to='post', blank=True)
video = models.ForeignKey('Video', blank=True, null=True)
created_date = models.DateTimeField(auto_now_add=True)
modified_date = models.DateTimeField(auto_now=True)
my_comment = models.OneToOneField('Comment',
related_name='+',
blank=True,
null=True)
like_users = models.ManyToManyField(
settings.AUTH_USER_MODEL,
related_name='like_posts',
through='PostLike',
)
class Meta:
ordering = [
'-pk',
]
def add_comment(self, user, content):
return self.comment_set.create(author=user, content=content)
def add_tag(self, tag_name):
tag, tag_created = Tag.objects.get_or_create(name=tag_name)
if not self.tags.filter(id=tag.id).exists():
self.tags.add(tag)
@property
def like_count(self):
return self.like_users.count()
class User(AbstractUser):
USER_TYPE_DJANGO = 'd'
USER_TYPE_FACEBOOK = 'f'
USER_TYPE_CHOICES = (
(USER_TYPE_DJANGO, 'Django'),
(USER_TYPE_FACEBOOK, 'Facebook'),
)
user_type = models.CharField(max_length=1,
choices=USER_TYPE_CHOICES,
default=USER_TYPE_DJANGO)
nickname = models.CharField(max_length=24, null=True, unique=True)
img_profile = CustomImageField(
upload_to='user',
blank=True,
# default_static_image='images/profile.png',
)
relations = models.ManyToManyField(
'self',
through='Relation',
symmetrical=False,
)
objects = UserManager()
def __str__(self):
return self.nickname or self.username
def follow(self, user):
if not isinstance(user, User):
raise ValueError('"user" argument must <User> class')
self.follow_relations.get_or_create(to_user=user)
def unfollow(self, user):
self.follow_relations.filter(to_user=user).delete()
def is_follow(self, user):
return self.follow_relations.filter(to_user=user).exists()
def is_follower(self, user):
return self.follower_relations.filter(from_user=user).exists()
def follow_toggle(self, user):
relation, relation_created = self.follow_relations.get_or_create(
to_user=user)
if not relation_created:
relation.delete()
else:
return relation
@property
def following(self):
relations = self.follow_relations.all()
return User.objects.filter(pk__in=relations.values('to_user'))
@property
def followers(self):
relations = self.follower_relations.all()
return User.objects.filter(pk__in=relations.values('from_user'))
class Post(models.Model):
title = models.CharField(max_length=100)
img_cover = CustomImageField(upload_to='post', blank=True,
default_static_image='images/no_image.png')
content = models.TextField(blank=True)
tags = models.ManyToManyField('Tag', blank=True)
created_date = models.DateTimeField(default=timezone.now)
def __str__(self):
return self.title
class User(AbstractBaseUser, PermissionsMixin):
email = models.EmailField(max_length=100, unique=True)
username = models.CharField(max_length=24)
profile_img = CustomImageField(
upload_to='user/%Y/%m/%d/',
blank=True,
default_static_image='images/profile.png',
)
gender = models.CharField(max_length=1, default='')
birth_year = models.IntegerField(validators=[MaxValueValidator(9999)],
default=0)
birth_month = models.IntegerField(validators=[MaxValueValidator(12)],
default=0)
birth_day = models.IntegerField(validators=[MaxValueValidator(31)],
default=0)
hobby = models.CharField(max_length=100, default='')
address = models.CharField(max_length=100, default='')
lat = models.DecimalField(max_digits=9, decimal_places=6, default=0)
lng = models.DecimalField(max_digits=9, decimal_places=6, default=0)
is_active = models.BooleanField(_('active'), default=True)
is_staff = models.BooleanField(default=False)
created_date = models.DateTimeField(auto_now_add=True)
modified_date = models.DateTimeField(auto_now=True)
objects = UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = []
def get_full_name(self):
# The user is identified by their email address
return self.email
def get_short_name(self):
# The user is identified by their email address
return self.email
def get_all_open_groups(self):
return self.open_group.all()
def get_all_like_groups(self):
return self.groupLike_set.all()
def get_all_joined_groups(self):
return self.joined_groups.all().exclude(author=self)
def __str__(self): # __unicode__ on Python 2
return self.email
@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def create_auth_token(sender, instance=None, created=False, **kwargs):
if created:
Token.objects.create(user=instance)
class Post(models.Model):
# Django가 제공하는 기본 User로 연결되도록 수정
author = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.CASCADE)
photo = CustomImageField(upload_to='post', blank=True)
# 나중에 만들어지는 클래스의 경우에는 ''를 붙이고 import를 하지 않는다.
video = models.ForeignKey('Video',
on_delete=models.CASCADE,
blank=True,
null=True)
created_date = models.DateTimeField(auto_now_add=True)
modified_date = models.DateTimeField(auto_now=True)
# related_name='+'로 지정할 경우 역참조를 생성하지 않는다
my_comment = models.OneToOneField('Comment',
related_name='+',
blank=True,
null=True)
like_users = models.ManyToManyField(
settings.AUTH_USER_MODEL,
through='PostLike',
related_name='like_posts',
# User에서 받아온 컬럼이 2개 있으므로 이름을 바꿔준다.
)
# 내림차순 정렬
class Meta:
ordering = [
'-pk',
]
def add_comment(self, user, content):
return self.comment_set.create(
author=user,
content=content,
)
# def add_tag(self, tag_name):
# # tags에 tag매개변수로 전달된 값str을
# # name으로 갖는 Tag 객체를 (이미 존재하면) 가져오고 없으면 생성하여 자신의 tags에 추가
# # 이 경우에는 get_or_create()를 사용!
# tag, tag_created = Tag.objects.get_or_create(name=tag_name)
# if not self.tags.filter(name=tag_name).exists():
# self.tags.add(tag)
def like_count(self):
# 자신을 like하고 있는 user수 리턴
return self.like_users.count()
def liked_username(self):
# 해당 post를 좋아하는 user들의 이름 나열
return '{}'.format(', '.join(
[i.username for i in self.like_users.all()]))
class Post(models.Model):
# 1. 이 Post를 좋아요 한 개수를 저장할 수 있는 필드(like_count)를 생성 -> migration
# 2. 이 Post에 연결된 PostLike의 개수를 가져와서 해당 필드에 저장하는 메서드 구현
# Django가 제공하는 기본 settings.AUTH_USER_MODEL와 연결되도록 수정
author = models.ForeignKey(settings.AUTH_USER_MODEL)
photo = CustomImageField(upload_to='post', blank=True)
video = models.ForeignKey('Video', blank=True, null=True)
created_date = models.DateTimeField(auto_now_add=True)
modified_date = models.DateTimeField(auto_now=True)
my_comment = models.OneToOneField('Comment',
blank=True,
null=True,
related_name='+')
like_users = models.ManyToManyField(
settings.AUTH_USER_MODEL,
related_name='like_posts',
through='PostLike',
)
like_count = models.PositiveIntegerField(default=0)
# 최근 post순으로 보이기
class Meta:
ordering = [
'-pk',
]
def add_comment(self, user, content):
# 자신을 post로 갖고, 전달받은 user를 author로 가지며
# content를 content필드내용으로 넣는 Comment객체 생성
return self.comment_set.create(author=user, content=content)
# 이 메서드를 적절한 곳에서 호출
def calc_like_count(self):
time.sleep(2)
self.like_count = self.like_users.count()
self.save()
@property
def comments(self):
"""my_comment 를 제외한 Comment 역참조 쿼리셋"""
if self.my_comment:
return self.comment_set.exclude(pk=self.my_comment.pk)
return self.comment_set.all()
class MyUser(AbstractUser):
""" 유저 모델, 모든 인증된 사용자는 책을 '사는 사람' 권한을 갖음 """
USER_TYPE_DJANGO = 'd'
USER_TYPE_FACEBOOK = 'f'
USER_TYPE_KAKAO = 'k'
USER_TYPE_CHOICES = ((USER_TYPE_DJANGO, 'Django'),
(USER_TYPE_FACEBOOK, 'Facebook'), (USER_TYPE_KAKAO,
'Kakao'))
username = models.EmailField(unique=True, )
USERNAME_FIELD = 'username'
my_photo = CustomImageField(max_length=255)
nickname = models.CharField(max_length=54, blank=False, unique=True)
phone = models.CharField(max_length=13, blank=True)
slug = models.CharField(max_length=56, blank=True)
user_type = models.CharField(max_length=1,
choices=USER_TYPE_CHOICES,
default=USER_TYPE_DJANGO)
wish_list = models.ManyToManyField('book.SellBookRegister',
through='member.BookWishList')
follow = models.ManyToManyField(settings.AUTH_USER_MODEL,
through='member.News')
objects = MyUserManager()
def email_token_generator(self,
user_pk,
size=35,
chars=string.ascii_uppercase + string.digits +
string.ascii_lowercase):
token = ''.join(random.choice(chars) for _ in range(size))
EmailToken.objects.get_or_create(user_id=user_pk, token=token)
return token
class Post(models.Model):
author = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.CASCADE)
image = CustomImageField(upload_to='post', blank=True)
video = models.ForeignKey('Video', blank=True, null=True)
like_users = models.ManyToManyField(
settings.AUTH_USER_MODEL,
through='PostLike',
related_name='like_posts',
)
created_date = models.DateTimeField(auto_now_add=True)
modified_date = models.DateTimeField(auto_now=True)
my_comment = models.OneToOneField('Comment',
blank=True,
null=True,
related_name='+')
like_count = models.PositiveIntegerField(default=0)
def __str__(self):
return '{}의 포스트'.format(self.author.username)
def add_comment(self, user, content):
return self.comment_set.create(
author=user,
content=content,
)
@property
def comments(self):
if self.my_comment:
return self.comment_set.exclude(pk=self.my_comment.pk)
return self.comment_set.all()
def calc_like_count(self):
time.sleep(1)
self.like_count = self.like_users.count()
self.save()
class Meta:
ordering = [
'-pk',
]
class Post(models.Model):
author = models.ForeignKey(settings.AUTH_USER_MODEL)
photo = CustomImageField(upload_to='post', blank=True)
video = models.ForeignKey('Video', blank=True, null=True)
created_date = models.DateTimeField(auto_now_add=True)
modified_date = models.DateTimeField(auto_now=True)
my_comment = models.OneToOneField('Comment',
blank=True,
null=True,
related_name='+')
like_users = models.ManyToManyField(
settings.AUTH_USER_MODEL,
related_name='like_posts',
through='PostLike',
)
like_count = models.PositiveIntegerField(default=0)
class Meta:
ordering = [
'-pk',
]
def add_comment(self, user, content):
# 자신을 post로 갖고, 전달받은 user를 author로 가지며
# content를 content필드내용으로 넣는 Comment객체 생성
return self.comment_set.create(author=user, content=content)
def calc_like_count(self):
self.like_count = self.like_users.count()
self.save()
@property
def comment(self):
if self.my_comment:
return self.comment_set.exclude(pk=self.my_comment.pk)
return self.comment_set.all()
class User(AbstractUser):
"""
동작
follow: 내가 다른 사람을 follow 함
unfollow: 내가 다른 사람에게 한 follow 를 취소함
속성
follower: 나를 follow 하고있는 사람
followers: 나를 follow 하고있는 사람들
following: 내가 follow 하고있는 사람들
friend: 나와 서로 follow하고 있는 관계의 사람
friends: 나와 서로 follow하고 있는 모든 관계
없음: 내가 follow 하고있는 사람 1명
"""
USER_TYPE_DJANGO = 'd'
USER_TYPE_FACEBOOK = 'f'
USER_TYPE_CHOICES = (
(USER_TYPE_DJANGO, 'Django'),
(USER_TYPE_FACEBOOK, 'Facebook'),
)
# 유저타입. 기본은 Django이며, 페이스북 로그인시 USER_TYPE_FACEBOOK값을 갖도록함
user_type = models.CharField(max_length=1, choices=USER_TYPE_CHOICES, default=USER_TYPE_DJANGO)
nickname = models.CharField(max_length=24, null=True, unique=True)
email = models.EmailField(null=True, unique=True)
img_profile = CustomImageField(
upload_to='member/',
# null=True, # text field가 아닐때에는 blank=True와 동시에 사용하면 안됨
blank=True,
# img_profile 이미지가 없을 경우 profile.png 파일이 보이게 CustomImageField를 오버라이드
# default_static_image='images/profile.png',
)
relations = models.ManyToManyField(
'self',
through='Relation',
through_fields=('from_user', 'to_user', 'blocked_user'),
symmetrical=False,
)
objects = UserManager()
def __str__(self):
return self.nickname or self.username
# return self.nickname if self.nickname else self.username
def follow(self, user):
if not isinstance(user, User):
raise ValueError('"user argument must <User> class')
# 해당 user를 follow하는 Relation을 생성한다.
# 이미 follow 상태일 경우 아무일도 하지 않음
# self로 주어진 User로 부터 Relation의 from_user에 해당하는 RelatedManager를 사용
self.follow_relations.get_or_create(to_user=user)
# Relation 모델의 매니저를 사용
# Relation.objects.get_or_create(
# from_user=self,
# to_user=user,
# )
def unfollow(self, user):
# 위의 반대
# is_follow = self.follow_relations.get(to_user=user)
# if not is_follow:
# is_follow.delete()
# return None
Relation.objects.filter(
from_user=self,
to_user=user,
).delete()
def follow_toggle(self, user):
if not isinstance(user, User):
raise ValueError('"user argument must <User> class')
r, t = self.follow_relations.get_or_create(to_user=user)
if not t:
r.delete()
else:
return r
def block_toggle(self, user):
if not isinstance(user, User):
raise ValueError('"user argument must <User> class')
if user in self.following:
self.follow_relations.get(to_user=user).delete()
r, t = self.follow_relations.get_or_create(blocked_user=user)
if not t:
r.delete()
else:
return r
def is_follow(self, user):
# 해당 user를 내가 follow하고 있는지 bool 반환
if not isinstance(user, User):
raise ValueError('"user argument must <User> class')
return self.follow_relations.filter(to_user=user).exists()
def is_follower(self, user):
# 해당 user가 나를 follow하고 있는지 bool
if not isinstance(user, User):
raise ValueError('"user argument must <User> class')
return self.follower_relations.filter(from_user=user).exists()
@property
def following(self):
relations = self.follow_relations.all()
return User.objects.filter(pk__in=relations.values('to_user'))
@property
def followers(self):
relations = self.follower_relations.all()
return User.objects.filter(pk__in=relations.values('from_user'))
@property
def blocking(self):
relations = self.follow_relations.all()
return User.objects.filter(pk__in=relations.values('blocked_user'))
class User(AbstractUser):
USER_TYPE_DJANGO = 'd'
USER_TYPE_FACEBOOK = 'f'
USER_TYPE_CHOICES = (
(USER_TYPE_DJANGO, 'Django'),
(USER_TYPE_FACEBOOK, 'Facebook'),
)
user_type = models.CharField(max_length=1,
choices=USER_TYPE_CHOICES,
default=USER_TYPE_DJANGO)
nickname = models.CharField(
max_length=24,
null=True,
unique=True,
)
img_profile = CustomImageField(upload_to='member',
blank=True,
default_static_image='images/profile.png')
relations = models.ManyToManyField(
'self',
through='Relation',
symmetrical=False,
)
email = models.EmailField(null=True, unique=True)
objects = UserManager()
def __str__(self):
return self.username
def follow(self, user):
if not isinstance(user, User):
raise ValueError('"user" argument must <User> class')
if self.from_self_relations.filter(to_user=user).exists():
relation = self.from_self_relations.get(to_user=user)
# 있으면 그게 블락인가?
if relation.relation_type == 'bl':
# 블락이라면 팔로우로 관계 변경 및 저장
relation.relation_type = 'fl'
relation.save()
else:
pass
else:
self.from_self_relations.create(to_user=user, relation_type='fl')
def unfollow(self, user):
Relation.objects.filter(from_user=self,
to_user=user,
relation_type='fl').delete()
def follow_toggle(self, user):
if not isinstance(user, User):
raise ValueError
# user를 팔로우하는 경우
# to self from user 관계가 있는가?
if self.from_self_relations.filter(to_user=user).exists():
relation = self.from_self_relations.get(to_user=user)
# 있으면 그게 블락인가?
if relation.relation_type == 'bl':
# 블락이라면 팔로우로 관계 변경 및 저장
relation.relation_type = 'fl'
relation.save()
# 팔로우라면 관계 삭제
else:
relation.delete()
# 관계가 없는 경우
else:
# 팔로우 관계 생성
return self.from_self_relations.create(to_user=user,
relation_type='fl')
def is_follow(self, user):
if not isinstance(user, User):
raise ValueError
return self.from_self_relations.filter(
Q(to_user=user) & Q(relation_type='fl')).exists()
def is_follower(self, user):
if not isinstance(user, User):
raise ValueError
return self.to_self_relations.filter(
Q(from_user=user) & Q(relation_type='fl')).exists()
def block_toggle(self, user):
if not isinstance(user, User):
raise ValueError
# user를 블락하는 경우
# to self from user 관계가 있는가?
if self.from_self_relations.filter(to_user=user).exists():
relation = self.from_self_relations.get(to_user=user)
# 있으면 그게 블락인가?
if relation.relation_type == 'bl':
# 블락이라면 블락 관계 삭제
relation.delete()
# 팔로우라면 블락으로 관계 변경 후 세이브
else:
relation.relation_type = 'bl'
relation.save()
# 관계가 없는 경우
else:
# 블락 관계 생성
return self.from_self_relations.create(to_user=user,
relation_type='bl')
def is_block(self, user):
if not isinstance(user, User):
raise ValueError
return self.from_self_relations.filter(
Q(to_user=user) & Q(relation_type='bl')).exists()
def is_blocked(self, user):
if not isinstance(user, User):
raise ValueError
return self.to_self_relations.filter(
Q(from_user=user) & Q(relation_type='bl')).exists()
@property
def following(self):
relations = self.from_self_relations.filter(relation_type='fl')
return User.objects.filter(pk__in=relations.values('to_user'))
@property
def followers(self):
relations = self.to_self_relations.filter(relation_type='fl')
return User.objects.filter(pk__in=relations.values('from_user'))
@property
def block(self):
relations = self.from_self_relations.filter(relation_type='bl')
return User.objects.filter(pk__in=relations.values('to_user'))
@property
def blocked(self):
relations = self.to_self_relations.filter(relation_type='bl')
return User.objects.filter(pk__in=relations.values('from_user'))
class MyGroup(models.Model):
GROUP_TYPE = (
('PUBLIC', 'Public'),
('PRIVATE', 'Private'),
('HIDDEN', 'Hidden'),
)
name = models.CharField(
max_length=24,
unique=True,
)
owner = models.ForeignKey(
settings.AUTH_USER_MODEL,
on_delete=models.PROTECT,
)
group_type = models.CharField(
max_length=10,
choices=GROUP_TYPE,
default='PUBLIC',
)
profile_img = CustomImageField(
upload_to='group',
blank=True,
default_static_image='images/no_group_img.png')
description = models.CharField(max_length=120, blank=True, null=True)
num_of_members = models.PositiveIntegerField(default=0)
tags = models.ManyToManyField('GroupTag', )
objects = MyGroupManager()
def __str__(self):
return 'Group : {}'.format(self.name)
def calc_num_of_members(self):
time.sleep(1)
self.num_of_members = self.member.count()
self.save()
def add_tag(self, input_tag):
if isinstance(input_tag, str):
# 입력받은 tag가 string object인 경우
for tag_str in input_tag.split(','):
tag_name = tag_str.strip()
tag, created = GroupTag.objects.get_or_create(name=tag_name)
self.tags.add(tag)
elif isinstance(input_tag, GroupTag):
# 입력받은 tag가 GroupTag instance인 경우
self.tags.add(input_tag)
elif isinstance(input_tag, QuerySet):
# 입력받은 tag가 QuerySet인 경우
for tag in input_tag:
if not isinstance(tag, GroupTag):
raise ValueError('입력된 QuerySet의 항목이 tag instance가 아닙니다.')
self.tags.add(tag)
else:
raise ValueError('잘못된 값을 입력했습니다.')
def remove_tag(self, input_tag):
if isinstance(input_tag, GroupTag):
# 입력받은 tag가 GroupTag instance인 경우
self.tags.remove(input_tag)
elif isinstance(input_tag, QuerySet):
# 입력받은 tag가 QuerySet인 경우
for tag in input_tag:
if not isinstance(tag, GroupTag):
raise ValueError('입력된 QuerySet의 항목이 tag instance가 아닙니다.')
self.tags.remove(tag)
else:
raise ValueError('잘못된 값을 입력했습니다.')
class User(AbstractUser):
"""
동작
follow : '자신'이 다른사람을 follow 함
unfollow : 내가 다른 사람들에게 한 follow를 취소함
속성
followers : 나를 follow 하는 사람들
follower : 나를 follow 하고 있는 사람
following : 내가 follow 하고 있는 사람들
friends : 나와 서로 follow하고 있는 관계
friends : 나와 서로 follow하고 있는 모든 관계
없음 : 내가 follow하고 있는 사람 1명
"""
# (0626) 유저모델을 AUTH_USER_MODEL로 사용하도록 settings.py에 설정
USER_TYPE_DJANGO = 'd'
USER_TYPE_FACEBOOK = 'f'
USER_TYPE_CHOICES = (
(USER_TYPE_DJANGO, 'Django'),
(USER_TYPE_FACEBOOK, 'Facebook'),
)
user_type = models.CharField(max_length=1,
choices=USER_TYPE_CHOICES,
default=USER_TYPE_DJANGO)
nickname = models.CharField(max_length=24, null=True, unique=True)
# (0623) 커스텀 이미지 필드로 바꿈
profile_image = CustomImageField(
upload_to='user',
blank=True,
# default_static_image='', # 디폴트값일때 넣어주는 이미지, 실제로는 FileField에는 이 키워드인자가 없다.
# 따라서, utils/custom_imagefiled.py에서 CustomImageField를 오버라이드해준다.
)
# (0622)
relations = models.ManyToManyField(
'self', # 유저테이블끼리의 인스턴스간 관계를 가리키기 위해 'self'를 사용
through='Relation', # member_relation 테이블이 새로 생긴다.
symmetrical=False,
)
# (0626)
# 위에서 만든 CustomUserManager를 objects속성으로 사용
# User.objects.create_facebook_user() 메서드 실행 가능
objects = UserManager()
def __str__(self):
return self.nickname or self.username
def follow(self, user):
# 매개변수로 전달된 user의 형(타입, = 클래스) 검사
if not isinstance(user, User):
raise ValueError('"user" argument must <User> class')
# 해당 user를 follow하는 Relation을 생성한다.
# 이미 follow 상태일 경우에는 아무일도 하지 않는다.
# Relation 모델의 Manager를 사용하는 방법
Relation.objects.get_or_create(from_user=self, to_user=user)
# self로 주어진 User로부터 Relation의 from_user에 해당하는 RelatedManger를 사용
# self.follow_realtions.get_or_create(to_user=user)
# user로 주어진 User로부터 Relation의 to_user에 해당하는 RelatedManager를 사용
# user.follow_relations.get_or_create(from_user=self)
def unfollow(self, user):
# 위의 반대 역할
Relation.objects.filter(from_user=self, to_user=user).delete()
def is_follow(self, user):
# 이미 follow 상태면 unfollow하고 있는지 bool 여부를 반환
# ModelManager.exists()를 사용
# Relation을 검색하면 됨.
return self.follow_relations.filter(to_user=user).exists()
def is_follower(self, user):
# 해당 유저가 나를 follow하고 있는지 bool여부를 반환
return self.follower_relations.filter(from_user=user).exists()
# return user.follow_relations.filter(to_user=self).exists()
def follow_toggle(self, user):
# 이미 follow상태면 unfollow, 아닐 경우 follow 상태로 만듬
relation, relation_created = self.follow_relations.get_or_create(
to_user=user)
if not relation_created:
relation.delete()
else:
return relation
@property
def following(self):
relations = self.follow_relations.all()
# __in은 쿼리셋 (?)
return User.objects.filter(pk__in=relations.values('to_user'))
@property
def followers(self):
relations = self.follower_relations.all()
# __in은 쿼리셋 (?)
return User.objects.filter(pk__in=relations.values('from_user'))
class User(AbstractUser):
"""
동작
follow : 내가 다른사람을 follow함
unfollow : 내가 다른사람에게 한 follow 취소
속성
follower : 나를 follow 하고 있는 사람들
follower : 나를 follow한 사람
following : 내가 follow하고 있는 사람
friend : 맞팔
friends : 복수 맞팔
없음 : 내가 follow하고 있는 사람 1 명
"""
# 이 User모델을 AUTH_USER_MODEL로 사용하도록 settings.py에 설정
# 유일한 nickname을 가지려면 blank=True가 아니라 null=True사용
# blank=True를 넣게 되면 2명 이상의 사용자가 닉네임을 입력하지 않을 때
# "" 값을 비교해버리므로 입력하지 않으면 계속 에러가 난다
# null=True로 하면 아예 없는 값이므로 비교자체가 불가능하다.
USER_TYPE_DJANGO = 'd'
USER_TYPE_FACEBOOK = 'f'
USER_TYPE_CHOICES = (
(USER_TYPE_DJANGO, 'Django'),
(USER_TYPE_FACEBOOK, 'Facebook'),
)
# 유저타입 기본은 Django, 페이스북 로그인시 USER_TYPE_FACEBOOK값을 갖도록 함.
user_type = models.CharField(max_length=1,
choices=USER_TYPE_CHOICES,
default=USER_TYPE_DJANGO)
nickname = models.CharField(max_length=24, null=True, unique=True)
img_profile = CustomImageField(
upload_to='user',
blank=True,
# 기본 설정 이미지를 세팅했지만 원하는 이미지를 추가로 넣어줄 수도 있다
# default_static_image='images/profile.png'
)
### self 상속
# M2M필드는 비대칭적이지만 self 상속하게 되면 대칭이 된다(following)
# 그리고 대칭관계라면 through로 참조, 역참조 관계를 알려주는 것이 아니라 방향성을 지정해줘야한다.
# symmetrical= False를 정해주면 역참조명이 생기는 것이 아니라 중간자모델의 필드간 관계가 동등해지고
# from_user와 to_user의 참조값이 대등하도록 related_name을 사용해줘야한다.
relations = models.ManyToManyField(
'self',
through='Relation',
symmetrical=False,
)
objects = UserManager()
def __str__(self):
# nickname이 None일 경우에는 username 반환
return self.nickname or self.username
# def post_count(self):
# return self.post_set.filter(author=self).count()
def follow(self, user):
# user가 User의 객체(형, 타입, =클래스)인지 검사
# is_authenticated는 인증여부이므로 상관없다. user객체인지 아닌지만 검사하면 됨.
if not isinstance(user, User):
raise ValueError
# 해당 user를 follow하는 Relation생성
# 이미 follow 상태일 경우 아무일도 하지 않음.
Relation.objects.get_or_create(from_user=self, to_user=user)
# self로 주어진 User로부터 Relation의 from_user에 해당하는 RelatedManager를 사용
# following시 가장 적합한 방법
self.follow_relation.get_or_create(to_user=user)
# user로 주어진 User로부터 Relation의 to_user에 해당하는 RelatedManager를 사용
user.follower_relation.get_or_create(from_user=self)
def unfollow(self, user):
# follow 메서드의 반대역할
Relation.objects.filter(
from_user=self,
to_user=user,
).delete()
def is_following(self, user):
# 해당 user를 내가 follow하고 있는지 bool 여부 반환
return Relation.objects.filter(from_user=self, to_user=user).exists()
# if status:
# return '{}가 {}를 팔로우하고 있습니다.'.format(self, user)
# else:
# return '{}가 {}를 팔로우하지 않았습니다.'.format(self, user)
def is_follower(self, user):
# 해당 user가 나를 follow하고 있는지 bool 여부 반환
return self.follower_relation.filter(from_user=user).exists()
def follow_toggle(self, user):
# 이미 follow상태면 unfollow로, 아니면 follow상태로 만듦
if not isinstance(user, User):
raise ValueError
following, follow_created = self.follow_relation.get_or_create(
to_user=user)
if not follow_created:
# Relation.objects.filter(from_user=self, to_user=user).delete()
following.delete()
return following
@property
def following(self):
# 내가 follow중인 User QuerySet
relation = self.follow_relation.all()
# 아래 코드는 위와 같다. 하지만 위쪽이 더 의미가 맞음.
# relation = Relation.objects.filter(from_user=self)
return User.objects.filter(pk__in=relation.values('to_user'))
@property
def follower(self):
# 나를 follow중인 User QuerySet
relation = self.follower_relation.all()
return User.objects.filter(pk__in=relation.values('from_user'))
class User(AbstractUser):
"""
동작
follow : 내가 다른사람을 follow함
unfollow : 내가 다른사람에게 한 follow를 취소함
속성
followers : 나를 follow하고 있는 사람들
follower : 나를 follow하고 있는 사람
following : 내가 follow하고 있는 사람들
friend : 나와 서로 follow하고 있는 관계
friends : 나와 서로 follow하고 있는 모든 관계
없음 : 내가 follow하고 있는 사람 1명
(나는 저 사람의 follower이다 또는 나는 저 사람을 follow하고 있다 라고 표현)
ex) 내가 박보영, 최유정, 고성현을 follow하고 고성현과 김수정은 나를 follow한다
나의 followers는 고성현, 김수정
나의 following은 박보영, 최유정
김수정은 나의 follower이다
나는 박보영의 follower다
나와 고성현은 friend관계이다
나의 friends는 고성현 1명이다
"""
# 이 User모델을 AUTH_USER_MODEL로 사용하도록 settings.py에 설정
USER_TYPE_DJANGO = 'd'
USER_TYPE_FACEBOOK = 'f'
USER_TYPE_CHOICES = (
(USER_TYPE_DJANGO, 'Django'),
(USER_TYPE_FACEBOOK, 'Facebook'),
)
# 유저타입. 기본은 Django이며, 페이스북 로그인시 USER_TYPE_FACEBOOK값을 갖도록 함
user_type = models.CharField(max_length=1,
choices=USER_TYPE_CHOICES,
default=USER_TYPE_DJANGO)
nickname = models.CharField(max_length=24, null=True, unique=True)
img_profile = CustomImageField(
upload_to='user',
blank=True,
# default_static_image='images/profile.png',
)
relations = models.ManyToManyField(
'self',
through='Relation',
symmetrical=False,
)
# 위에서 만든 CustomUserManager를 objects속성으로 사용
# User.objects.create_facebook_user()메서드 실행 가능
objects = UserManager()
def __str__(self):
return self.nickname or self.username
# return self.nickname if self.nickname else self.username
def follow(self, user):
# 매개변수로 전달된 user의 형(타입,=클래스) 검사
if not isinstance(user, User):
raise ValueError('"user" argument must <User> class')
# 해당 user를 follow하는 Relation을 생성한다
# 이미 follow상태일경우 아무일도 하지 않음
# self로 주어진 User로부터 Relation의 from_user에 해당하는 RelatedManager를 사용
self.follow_relations.get_or_create(to_user=user)
# Relation모델의 매니저를 사용
Relation.objects.get_or_create(from_user=self, to_user=user)
# user로 주어진 User로부터 Relation의 to_user에 해당하는 RelatedManager를 사용
user.follower_relations.get_or_create(from_user=self)
def unfollow(self, user):
# 위의 반대 역할
Relation.objects.filter(from_user=self, to_user=user).delete()
def is_follow(self, user):
# 해당 user를 내가 follow하고 있는지 bool여부를 반환
# ModelManager.exists()
return self.follow_relations.filter(to_user=user).exists()
def is_follower(self, user):
# 해당 user가 나를 follow하고 있는지 bool여부를 반환
return self.follower_relations.filter(from_user=user).exists()
def follow_toggle(self, user):
# 이미 follow상태면 unfollow로, 아닐경우 follow상태로 만듬
relation, relation_created = self.follow_relations.get_or_create(
to_user=user)
if not relation_created:
relation.delete()
else:
return relation
@property
def following(self):
# https://docs.djangoproject.com/en/1.11/ref/models/querysets/#in
relations = self.follow_relations.all()
return User.objects.filter(pk__in=relations.values('to_user'))
@property
def followers(self):
relations = self.follower_relations.all()
return User.objects.filter(pk__in=relations.values('from_user'))
class Group(models.Model):
hobby = models.CharField(max_length=100)
author = models.ForeignKey(
base.AUTH_USER_MODEL,
related_name='open_groups'
)
name = models.CharField(max_length=100, unique=True)
description = models.TextField()
image = CustomImageField(
upload_to='group/%Y/%m/%d',
blank=True,
)
like_users = models.ManyToManyField(
base.AUTH_USER_MODEL,
through='GroupLike',
related_name='like_groups',
)
address = models.CharField(max_length=100, default='')
lat = models.DecimalField(max_digits=9, decimal_places=6, default=0)
lng = models.DecimalField(max_digits=9, decimal_places=6, default=0)
created_date = models.DateTimeField(auto_now_add=True)
modified_date = models.DateTimeField(auto_now=True)
members = models.ManyToManyField(
base.AUTH_USER_MODEL,
related_name='joined_groups',
)
def __str__(self):
return self.name
def get_all_member(self):
return self.members.all().exclude(email=self.author.email)
def get_all_member_count(self):
return self.members.count()
def get_all_like_users(self):
return self.like_users.all()
def get_all_like_users_count(self):
return self.like_users.count()
def get_distance(self, origin_lat, origin_lng):
target_lat = self.lat
target_lng = self.lng
# return distance_calculator(origin_lat, origin_lng, target_lat, target_lng)
R = 6373.0
origin_lat = radians(origin_lat)
origin_lng = radians(origin_lng)
target_lat = radians(target_lat)
target_lng = radians(target_lng)
dlon = target_lng - origin_lng
dlat = target_lat - origin_lat
a = sin(dlat / 2) ** 2 + cos(origin_lat) * cos(target_lat) * sin(dlon / 2) ** 2
c = 2 * atan2(sqrt(a), sqrt(1 - a))
distance = R * c
# 1 = 1 km
# 0.5 = 5,00 m
return distance
class User(AbstractUser):
'''
동작
fallow : 내가 다른사람을 fallow
unfollow : 내가 다른사람에게 한 fallow를 취소함
속성
followers : 나를 fallow하고 있는 사람들
follower : 나를 fallow하고 있는 사람
following : 내가 fallow하고 있는 사람들
없음 : 내가 fallow하고 있는 사람 1명
ex) 내가 박보영, 최유정을 follow하고 고성현과 심수정은 나를 follow한다
나의 followers는 고성현, 김수정
나의 following은 박보영, 최유정
김수정은 나의 follower이다
나는 박보영의 follower다
나와 고성현은 friend단계이다
나의 friends는 고성현 1명이다.
'''
# 이 User모델을 AUTH_USER_MODEL로 사용하여
USER_TYPE_DJANGO = 'd'
USER_TYPE_FACEBOOK = 'f'
USER_TYPE_CHOICES = (
(USER_TYPE_DJANGO, 'Django'),
(USER_TYPE_FACEBOOK, 'Facebook'),
)
email = models.EmailField(null=True, unique=True)
user_type = models.CharField(max_length=1,
choices=USER_TYPE_CHOICES,
default=USER_TYPE_DJANGO)
nickname = models.CharField(max_length=24, null=True, unique=True)
img_profile = CustomImageField(upload_to='user', blank=True)
relations = models.ManyToManyField(
'self',
through='Relation',
symmetrical=False,
# default_static_image='images/profile.png',
)
relations = models.ManyToManyField(
'self',
through='Relation',
symmetrical=False,
)
objects = UserManager()
def __str__(self):
return self.nickname or self.username
def follow(self, user):
# 해당 user를 follow하는 relation을 생성한다.
# 이미 follow상태일경우 아무일도 하지 않음
if not isinstance(user, User):
raise ValueError('"user" argument must <User> class')
# Relation모델의 매니저를 사용
Relation.objects.get_or_create(
from_user=self,
to_user=user,
)
#
# # self로 주어진 user로부터 Relation의 from_user에 해당하는 RelatedManager를 사용
# self.follow_relations.get_or_create(
# to_user=user,
# )
# # self로 주어진 user로부터 Relation의 to_user에 해당하는 RelatedManager를 사용
# self.follower_relations.get_or_create(
# to_user=user,
# )
def unfollow(self, user):
# 위의 반대 역할
Relation.objects.filter(from_user=self, to_user=user).delete()
def is_follow(self, user):
# 해당 user를 내가 follow하고 있는지 bool여부를 반환
# ModelManager.exists()
return self.follow_relations.filter(to_user=user).exists()
def is_follower(self, user):
# 해당 user가 나를 follow하고 있는지 bool여부를 반환
return self.follower_relations.filter(from_user=user).exists()
def follow_toggle(self, user):
# 이미 follow상태면 unfollow로, 아닐경우 follow상태로 만듬
relation, relation_created = self.follow_relations.get_or_create(
to_user=user)
if not relation_created:
relation.delete()
else:
return relation
@property
def following(self):
# https://docs.djangoproject.com/en/1.11/ref/models/querysets/#in
relations = self.follow_relations.all()
return User.objects.filter(pk__in=relations.values('to_user'))
@property
def followers(self):
relations = self.follower_relations.all()
return User.objects.filter(pk__in=relations.values('from_user'))
class MyUser(AbstractBaseUser, PermissionsMixin):
"""
Email, password and nickname are required. Other fields are optional.
"""
email = models.EmailField(_('이메일'), unique=True)
username = models.CharField(_('이름'), max_length=12, blank=True)
nickname = models.CharField(_('닉네임'), max_length=16, unique=True)
profile_img = CustomImageField(
upload_to='member',
blank=True,
default_static_image='images/no_profile.png')
is_staff = models.BooleanField(
_('스태프 권한'),
default=False,
help_text=_('Admin page에 접속할 수 있는 권한을 부여합니다.'),
)
is_active = models.BooleanField(
_('계정 활성화'),
default=True,
help_text=_('계정을 삭제하지 않고 비활성화 시킬때 체크를 해제하십시오.'),
)
date_joined = models.DateTimeField(_('가입일자'), default=timezone.now)
relations = models.ManyToManyField('self',
through='UserRelation',
symmetrical=False)
group = models.ManyToManyField(
MyGroup,
through='Membership',
related_name='member',
)
objects = MyUserManager()
EMAIL_FIELD = 'email'
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['nickname']
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
ordering = ['-pk']
def clean(self):
super(MyUser, self).clean()
self.email = self.__class__.objects.normalize_email(self.email)
def get_full_name(self):
"유저의 이름(실명)을 반환합니다."
username = self.username
return username.strip()
def get_short_name(self):
"유저의 닉네임을 반환합니다. (Django admin page에서 사용)"
return self.nickname
def follow(self, user):
if not isinstance(user, MyUser):
raise ValueError("'user' 는 반드시 MyUser 인자여야 합니다")
self.following.get_or_create(to_user=user, )
def unfollow(self, user):
self.following.get(to_user=user, ).delete()
def follow_toggle(self, user):
relation, relation_created = self.following.get_or_create(to_user=user)
if not relation_created:
relation.delete()
else:
return relation
def is_follow(self, user):
# 해당 유저(self)가 입력받은 유저를 follow하고 있는지의 여부를 Boolean 값으로 반환
return self.following.filter(to_user=user).exists()
def is_follower(self, user):
# 해당 유저(self)가 입력받은 유저의 follower인지 여부를 Boolean 값으로 반환
return self.follower.filter(from_user=user).exists()
class User(AbstractUser):
objects = UserManager()
'''
동작
follow : 내가 다른 사람을 follow함
unfollow : 낵 다른사람에게 한 follow를 취소함
속성
follow : 내가 다른사람을 follow함
followers : 나를 follow하고 있는 사람들
follower : 나를 follow하고 있는 사람
friend : 서로 follow하고 있는 관계
friends : 나와 서로 follow하고 있는 모든 관계
없음 : 내가 follow하고 있는 사람 1명
following : 내가 follow하고 있는 사람들
'''
# 이 User모델을 AUTH_USER_MODEL로 사용하도록 settings.py에 설정
USER_TYPE_DJANGO = 'd'
USER_TYPE_FACEBOOK = 'f'
USER_TYPE_CHOICE = {
(USER_TYPE_DJANGO, 'django'),
(USER_TYPE_FACEBOOK, 'facebook'),
}
user_type = models.CharField(max_length=1,
choices=USER_TYPE_CHOICE,
default=USER_TYPE_DJANGO)
nickname = models.CharField(max_length=24, null=True, unique=True)
relations = models.ManyToManyField(
'self',
through='Relation',
symmetrical=False,
)
img_profile = CustomImageField(
upload_to='user',
blank=True,
)
def __str__(self):
return self.nickname or self.username
# return self.nickname if self.nickname else self.username
# def follow(self, user):
# if not isinstance(user, User):
# raise ValueError("user는 User형 클래스가 아닙니다.")
#
# created_relation, is_exist = self.follow_relations.get_or_create(to_user=user)
# if is_exist:
# return created_relation
# return '이미 팔로우 하셨습니다.'
#
# def unfollow(self, user):
# Relation.objects.filter(
# from_user=self,
# to_user=user,
# ).delete()
def is_follow(self, user):
return self.follow_relations.filter(to_user=user).exists()
def is_follower(self, user):
return self.follower_relations.filter(from_user=user).exists()
@require_POST
@login_required
def follow_toggle(self, user):
created_relation, is_exist = self.follow_relations.get_or_create(
to_user=user)
if is_exist:
return created_relation
else:
created_relation.delete()
return '언팔로우 했습니다.'
@property
def following(self):
relations = self.follow_relations.all()
return User.objects.filter(pk__in=relations.values('to_user_id'))
# return [i.to_user for i in self.follow_relations.all()]
@property
def follower(self):
relations = self.follower_relations.all()
return User.objects.filter(pk__in=relations.values('from_user_id'))
def block_toggle(self, user):
pass