def post_tweet_view(request):
if request.method == 'POST':
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_tweet = Tweet.objects.create(body=data.get('body'),
time_posted=datetime.now(),
tweeter=request.user)
mentions = re.findall(r'@(\w+)', data.get('body'))
if mentions:
users = TwitterUser.objects.all()
for mention in mentions:
if TwitterUser.objects.get(username=mention):
Notification.objects.create(
notifying_tweet=new_tweet,
user_notified=TwitterUser.objects.get(
username=mention))
if new_tweet:
tweeter = request.user
tweeter.num_of_tweets += 1
tweeter.save()
return HttpResponseRedirect(reverse('homepage'))
form = TweetForm()
return render(request, 'generic_form.html', {'form': form})
def tweet_view(request):
if not request.user.is_authenticated:
return HttpResponseRedirect(reverse('home'))
form = TweetForm()
usernames = [user.username for user in TwitterUser.objects.all()]
if request.method == "POST":
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
message = data.get("message")
word_list = message.split()
users = {
w
for word in word_list if word.startswith("@") and (
w := word[1:]) in usernames and w != request.user.username
}
author = request.user
if users:
tweet = Tweet.objects.create(message=message, author=author)
for user in users:
assigned_user = TwitterUser.objects.get(username=user)
Notification.objects.create(
username_assigned=assigned_user, tweet=tweet)
else:
Tweet.objects.create(message=message, author=author)
return HttpResponseRedirect(reverse("home"))
return render(request, "tweet.html", {"form": form})
def create_tweet(request):
context = {}
notify = Notification.objects.filter(reciever=request.user,
read=False).count()
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_data = Tweet.objects.create(user=request.user, body=data['body'])
# __author__ = "Recieved help from my facilitator Elizabeth"
notifications = re.findall(r'@(\S+)', data['body'])
for string in notifications:
user = TwitterUser.objects.filter(username=string).first()
if user:
Notification.objects.create(read=False,
content_type=new_data,
reciever=user)
print(notifications)
return HttpResponseRedirect(
reverse('tweet:tweet_details', args=[new_data.id]))
form = TweetForm()
context.update({
'form': form,
'heading_three':
'Tell everybody what you\'re up to! What\'s new? What\'s changed?',
'notify': notify
})
return render(request, 'forms/generic.html', context)
def index(request):
tweets = None
users = None
notifications = None
if request.method == 'POST':
form = TweetForm(request.POST)
if form.is_valid():
tweet = form.save(commit=False)
tweet.created_by = TwitterUser.objects.get(id=request.user.id)
tweet.save()
notify(tweet)
try:
following = list(request.user.following.all())
users = TwitterUser.objects.all()
following.append(request.user)
notifications = Notification.objects.filter(recipient=request.user)
tweets = Tweet.objects \
.filter(created_by__in=following) \
.order_by('-created_at')
except Exception:
pass
return render(request, 'index/index.html', {
'form': TweetForm(),
'tweets': tweets,
'users': users,
'notifications': notifications
})
def tweetform_view(request):
html = "tweetform.html"
if request.method == "POST":
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
newTweet = Tweet(tweetbody=data['tweetbody'],
date_filed=data['date_filed'],
author=request.user)
newTweet.save()
# This newTweet['tweetbody'] is reaching into db
# if '@' in newTweet['tweetbody']:
pattern = re.search("@[\w\d]+", newTweet.tweetbody)
if pattern is not None:
pattern = pattern.group(0)[1:]
target_user = TwitterUser.objects.get(username=pattern)
Notification.objects.create(
target_user=target_user,
tweet=newTweet,
)
baseProfile = TwitterUser.objects.get(username=request.user)
newTweet.twittuser.add(baseProfile)
return HttpResponseRedirect(reverse("homepage"))
form = TweetForm()
return render(request, html, {"form": form})
def new_tweet_view(request):
notification_count = notification_new_count(request)
if request.method == "POST":
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_tweet = Tweet.objects.create(
body=data.get("body"),
author=request.user,
)
mentions = re.findall(r"@(\w+)", data.get("body"))
if mentions:
for mention in mentions:
matched_user = TwitterUser.objects.get(username=mention)
if matched_user:
Notification.objects.create(
n_receiver=matched_user,
tracked_tweet=new_tweet,
)
return HttpResponseRedirect(reverse("homepage"))
form = TweetForm()
return render(
request,
"new_tweet_view.html",
{
"form": form,
"notification_count": notification_count,
},
)
def post(self, request):
form = TweetForm(request.POST)
if form.is_valid():
tweet = form.save(commit=False)
tweet.user = request.user
tweet.save()
messages.success(request, "Added")
return redirect('homepage')
messages.warning(request, "Error")
return redirect("homepage")
def post(self, request, username):
form = TweetForm(request.POST)
if form.is_valid():
user = User.objects.get(username=username)
tweet = Tweet(text=form.cleaned_data['text'], user=user, country=form.cleaned_data['country'])
tweet.save()
words = form.cleaned_data['text'].split(" ")
for word in words:
if word[0] == "#":
hashtag, created = HashTag.objects.get_or_create(name=word[1:])
hashtag.tweet.add(tweet)
return HttpResponseRedirect('/user/'+username)
def add_tweet_view(request):
number_tweets = len(Tweet.objects.filter(twitter_user=request.user.id))
user_notifications = Notification.objects.filter(
tweeted_user=request.user)
if len(user_notifications) > 0:
notification_tweet = user_notifications
else:
notification_tweet = ''
number_notifications = len(notification_tweet)
if Relationship.objects.filter(from_person=request.user):
number_following = len(Relationship.objects.filter(
from_person=request.user))
else:
number_following = 0
if request.method == "POST":
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_tweet = Tweet.objects.create(
body=data.get('body'),
twitter_user=request.user
)
if '@' in new_tweet.body:
# extract the username
split_body = new_tweet.body.split()
extracted_username = ''
for word in split_body:
if word.startswith('@'):
extracted_username = word.replace('@', '')
notification_user = TwitterUser.objects.filter(
username=extracted_username).first()
Notification.objects.create(
tweeted_user=notification_user,
notification_tweets_id=new_tweet.id
)
return HttpResponseRedirect(
reverse("tweetview", args=[new_tweet.id])
)
form = TweetForm()
return render(
request, "add_tweet.html",
{"form": form,
"profile_user": request.user,
"number_notifications": number_notifications,
"number_tweets": number_tweets,
"number_following": number_following}
)
def add_tweet_view(request):
if request.method == "POST":
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
tweet = Tweet.objects.create(
text=data.get('text'),
user=request.user,
)
return HttpResponseRedirect(reverse("index"))
form = TweetForm()
return render(request, "generic_form.html", {"form": form})
def post(self, request, username):
form = TweetForm(self.request.POST)
if form.is_valid():
user = User.objects.get(username=username)
tweet = Tweet(text=form.cleaned_data['text'],
user=user,
country=form.cleaned_data['country'])
tweet.save()
words = form.cleaned_data['text'].split(" ")
for word in words:
if word[0] == "#":
hashtag, created = HashTag.objects.get_or_create(name=word[1:])
hashtag.tweet.add(tweet)
return HttpResponseRedirect('/user/'+username)
def new_tweet(request):
if request.user.is_authenticated:
html = "new_tweet_form.html"
form = TweetForm()
if request.method == "POST":
filled_form = TweetForm(request.POST)
if filled_form.is_valid():
data = filled_form.cleaned_data
Tweet.objects.create(tweet=data['tweet'],
author=request.user,
creation_date=datetime.now())
create_notifications(Tweet.objects.last())
return HttpResponseRedirect(
request.GET.get('next', reverse('homepage')), )
return render(request, html, {"form": form})
def post(self, request):
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
tweet = Tweet.objects.create(text = data.get('text'),
user_tweeted = request.user)
notification = re.findall(r"@([\w]+)", data.get('text'))
if notification:
for username in notification:
user = TwitterUser.objects.get(username=username)
Notification.objects.create(notification_tweet = tweet,
notification_user = user,
)
return redirect('/')
else:
return render(request, 'tweet_form.html', {"form": form})
def create(request):
if request.POST:
form = TweetForm(request.POST)
if form.is_valid():
a = form.save()
messages.add_message(request , messages.SUCCESS , 'Your tweet was added')
return HttpResponseRedirect('/tweets/all')
else:
form = TweetForm()
args = {}
args.update(csrf(request))
args['form'] = form
return render_to_response('create_tweet.html', args)
def get(self, request, username):
params = dict()
userProfile = User.objects.get(username=username)
try:
userFollower = UserFollower.objects.get(user=userProfile)
if userFollower.followers.filter(username=request.user.username).exists():
params["following"] = True
else:
params["following"] = False
except:
userFollower = []
form = TweetForm(initial={'country': 'Global'})
search_form = SearchForm()
tweets = Tweet.objects.filter(user=userProfile).order_by('-created_date')
paginator = Paginator(tweets, TWEET_PER_PAGE)
page = request.GET.get('page')
try:
tweets = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
tweets = paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
tweets = paginator.page(paginator.num_pages)
params["tweets"] = tweets
params["profile"] = userProfile
params["form"] = form
params["search"] = search_form
return render(request, 'profile.html', params)
def get(self, request):
all_tweets = Tweet.objects.all().order_by('-created')
all_comments = Comments.objects.all().order_by('-created_comment')
form = TweetForm()
return render(request, 'tweet/Homepage.html', context={"all_tweets": all_tweets,
"form": form,
"all_comments": all_comments})
def profile(request, username):
if request.user.is_authenticated:
user = User.objects.get(username=username)
if request.method == 'POST':
if 'tweetform' in request.POST:
form = TweetForm(data=request.POST)
infoform = PersonalInfoForm()
if form.is_valid():
tweet = form.save(commit=False)
tweet.user = request.user
tweet.save()
redirecturl = request.POST.get('redirect', '/')
return redirect(redirecturl)
else:
infoform = PersonalInfoForm(request.POST, request.FILES)
form = TweetForm()
if infoform.is_valid():
profile = request.user.twitterprofile
if infoform.cleaned_data.get('profile_picture'):
photo = infoform.cleaned_data.get('profile_picture')
x = infoform.cleaned_data.get('p_x')
y = infoform.cleaned_data.get('p_y')
w = infoform.cleaned_data.get('p_width')
h = infoform.cleaned_data.get('p_height')
profile.crop_profile_picture(photo, x, y, w, h)
if infoform.cleaned_data.get('banner_picture'):
photo = infoform.cleaned_data.get('banner_picture')
x = infoform.cleaned_data.get('b_x')
y = infoform.cleaned_data.get('b_y')
w = infoform.cleaned_data.get('b_width')
h = infoform.cleaned_data.get('b_height')
profile.crop_banner_picture(photo, x, y, w, h)
profile.username = infoform.cleaned_data.get('username')
profile.biography = infoform.cleaned_data.get('biography')
profile.save()
redirecturl = request.POST.get('redirect', '/')
return redirect(redirecturl)
else:
form = TweetForm()
infoform = PersonalInfoForm()
return render(request, 'profile.html', {
'form': form,
'infoform': infoform,
'user': user
})
else:
return redirect('/')
def tweet_form(request):
pings = Notification.objects.filter(receiver=request.user)
if request.method == "POST":
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
tweet = Tweet.objects.create(body=data['body'],
tweeter=request.user)
if '@' in data['body']:
recipient = re.findall(r'@(\w+)', data.get('body'))
for receipt in recipient:
message = Notification.objects.create(
msg_content=tweet,
receiver=TwitterUser.objects.get(username=receipt))
return HttpResponseRedirect(reverse('homepage'))
form = TweetForm()
return render(request, "generic_form.html", {"form": form, "pings": pings})
def add_tweet(request, id):
if request.method == "POST":
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = MyUser.objects.get(id=id)
users = MyUser.objects.all()
tweet = Tweet.objects.create(tweet=data['tweet'], author=user)
notify = re.findall(r'@(\w+)', data['tweet'])
for user in notify:
Notification.objects.create(
receiver=MyUser.objects.get(displayname=user),
tweet=tweet,
)
return HttpResponseRedirect(reverse('homepage'))
form = TweetForm()
return render(request, 'addtweet.html', {'form': form})
def get(self, request, username):
params = dict()
user = User.objects.get(username=username)
tweets = Tweet.objects.filter(user=user)
form = TweetForm(initial={'country': 'Global'})
params["tweets"] = tweets
params["user"] = user
params["form"] = form
return render(request, 'profile.html', params)
def post_tweet(request):
if request.method == "POST":
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
twitteruser = request.user
messagebox = Tweet.objects.create(messagebox=data['messagebox'],
this_user=twitteruser)
# notification
if '@' in messagebox.messagebox:
username = re.findall(r'@(\w+)', messagebox.messagebox)
for user in username:
target = TwitterUser.objects.get(username=user)
Notification.objects.create(notified_tweet=messagebox,
target_user=target)
return HttpResponseRedirect(reverse('homepage'))
form = TweetForm()
return render(request, 'tweet.html', {'form': form})
def tweet_form(request):
if request.method == "POST":
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_tweet = Tweet.objects.create(
body=data.get("body"),
author=request.user,
)
reg = re.findall(r'@(\w{1,})', data.get("body"))
for r in reg:
match = TwitterUser.objects.filter(username=r)
if match:
Notification.objects.create(user_notified=match.first(),
tweet_notification=new_tweet)
return HttpResponseRedirect(reverse("homepage"))
form = TweetForm()
return render(request, "new_tweet.html", {"form": form})
def add_tweet(request):
if request.method == "POST":
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
Tweets.objects.create(
text=data['text'],
author=request.user,
)
all_users = re.findall(r'@(\w+)', data['text'])
for pinged in all_users:
Notifications.objects.create(
pinged_user=TwitterUser.objects.get(username=pinged),
text=text,
)
return HttpResponseRedirect(reverse('homepage'))
form = TweetForm()
return render(request, 'addtweet.htm', {"form": form})
def feed(request):
userids = []
for user in request.user.twitterprofile.follows.all():
userids.append(user.id)
userids.append(request.user.id)
tweets = Tweet.objects.filter(user_id__in=userids)[0:25]
form = TweetForm()
return render(request, 'feed.html', {'tweets': tweets, 'form': form})
def add_tweet_view(request):
if request.method == 'POST':
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
tweet_post = Tweet.objects.create(
tweet=data['tweet'],
tweet_maker=request.user
)
if "@" in data['tweet']:
recipients = re.findall(r'@(\w+)', data.get("tweet"))
for recipient in recipients:
match_user = TwitterUser.objects.get(username=recipient)
if match_user:
message = Notification.objects.create(msg_content=tweet_post, receiver=match_user)
return HttpResponseRedirect(reverse('homepage'))
form = TweetForm()
return render(request, 'generic_form.html', {'form': form})
def get(self, request):
tweets = TweetMessage.objects.filter(user=request.user)
num_notif = NotificationModel.objects.filter(user=request.user,
viewed=False).count()
form = TweetForm()
return render(request, 'tweet/tweet.html', {
'form': form,
'tweets': tweets,
'num_notif': num_notif
})
def create_tweet_view(request):
if request.method == "POST":
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
tweetpost = TweetModel.objects.create(
body=data['body'],
author=request.user,
)
if "@" in data['body']:
recipients = re.findall(r'@(\w+)', data.get('body'))
for recipient in recipients:
match_user = TwitUser.objects.get(username=recipient)
if match_user:
message = Notification.objects.create(
message_content=tweetpost, receiver=match_user)
return HttpResponseRedirect(reverse("homepage"))
form = TweetForm()
return render(request, 'base.html', {"form": form})
def post(self, request):
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
msg = TweetMessage.objects.create(
user=CustomUser.objects.get(username=request.user.username),
body=data['body'],
)
users = re.findall(r'@\S+', msg.body)
if users:
for i in users:
try:
if CustomUser.objects.get(username=i[1:]):
NotificationModel.objects.create(
user=CustomUser.objects.get(username=i[1:]),
tweet=msg)
except CustomUser.DoesNotExist:
continue
return HttpResponseRedirect(reverse('homepage'))
def tweet_form_view(request):
if request.method == "POST":
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_tweet = Tweet.objects.create(
description=data.get('description'), author=request.user)
mentions = re.findall(r'@(\w+)', data.get('description'))
if mentions:
users = MyUser.objects.all()
for mention in mentions:
matched_user = MyUser.objects.get(username=mention)
if matched_user:
Notification.objects.create(
sender=matched_user,
notif_tweets=new_tweet,
)
return HttpResponseRedirect(reverse("home"))
form = TweetForm()
return render(request, "signup_form.html", {"form": form})
def profiles(request, username):
if request.user.is_authenticated:
user = User.objects.get(username=username)
if request.method == "POST":
form = TweetForm(data=request.POST)
if form.is_valid()
tweet = form.save(commit=False)
tweet.user = request.user
tweet.save()
redirecturl = request.POST.get("redirect", "/")
return redirect(redirecturl)
else:
form = TweetForm()
return render(request, "profile.html", {"user": user, "form": form})
else:
return redirect("/")
def follows(request, username):
user = User.objects.get(username=username)
tweeterprofiles = user.tweeterprofile.follows
return render(request, "users.html", {"title": "Follows", "tweeterprofiles": tweeterprofiles})
def followers(request, username):
user = User.objects.get(username=username)
tweeterprofiles = user.tweeterprofile.followed_by
return render(request, "user.html", {"title": "Followers", "tweeterprofiles": tweeterprofiles})
def create_tweet_view(request):
if request.method == 'POST':
form = TweetForm(request.POST)
if form.is_valid():
data = form.cleaned_data
posted_tweet = Tweet.objects.create(
user=request.user,
message=data['message'],
)
mentioned_users = re.findall('@([a-zA-Z0-9_]*)', data['message'])
if mentioned_users:
for mentioned_user in mentioned_users:
matched_user = TwitterUser.objects.get(
username=mentioned_user)
if matched_user:
Notification.objects.create(
user_mentioned=matched_user,
tweet=posted_tweet,
)
return redirect("/")
form = TweetForm()
return render(request, "create_tweet_form.html", {'form': form})
def profile(request, username):
if request.user.is_authenticated:
user = User.objects.get(username=username)
if request.method == 'POST':
form = TweetForm(data=request.POST)
if form.is_valid():
data = form.cleaned_data
user = request.user
tweet = Tweet.objects.create(body=data['body'])
user.profile.tweets.add(tweet)
redirecturl = request.POST.get('redirect', '/')
return redirect(redirecturl)
else:
form = TweetForm()
return render(request, 'profile.html', {'form': form, 'user': user})
else:
return redirect('/')
def post_tweet(request, message=None, *args, **kwargs):
"""
post tweet and re-direct user to the main page
"""
tweet_content = request.POST['content']
tweet_form = TweetForm({'content': tweet_content})
if tweet_form.is_valid():
if is_dirty(content=tweet_content):
messages.add_message(request, messages.ERROR, 'Shame on you')
#save tweet
tweet = tweet_form.save(commit=False)
tweet.created_by = request.user
tweet.save()
else:
brand_corrected = brand_correct_tweet(content=request.POST['content'])
brand_corrected_tweet = brand_corrected[0]
brand_corrected_flag = brand_corrected[1]
if brand_corrected_flag:
request.session.__setitem__('brand_corrected_tweet', brand_corrected_tweet)
request.session.__setitem__('content', request.POST['content'])
return HttpResponseRedirect(reverse('index'))
else:
# post tweet to twitter
post_status = post_to_twitter(content=request.POST['content'])
if post_status['success']:
messages.add_message(request, messages.SUCCESS, post_status['message'])
# save tweet
tweet = tweet_form.save(commit=False)
tweet.created_by = request.user
tweet.tweet_id = post_status['id']
if not is_dirty(content=tweet_content):
tweet.is_dirty = True
tweet.save()
else:
messages.add_message(request, messages.ERROR, post_status['message'])
return HttpResponseRedirect(reverse('index'))
