def save(self, *args, **kwargs):
if not self.id:
super(Issue, self).save()
if not self.author.landlord and self.author.phone:
client = TwilioRestClient(settings.TWILLIO_ACCOUNT,
settings.TWILLIO_TOKEN)
message = client.sms.messages.create(
to=self.house.landlord.phone,
from_="+441827231000",
body="Issue Raised: " + self.title + " on " +
self.house.name)
post = Post()
post.text = "The issue '" + self.title + "' has been raised"
post.posted_by = self.author
post.save()
if self.resolved:
super(Issue, self).save()
for user in self.house.user_set.all():
if user.phone:
client = TwilioRestClient(settings.TWILLIO_ACCOUNT,
settings.TWILLIO_TOKEN)
message = client.sms.messages.create(
to=user.phone,
from_="+441827231000",
body="The issue '" + self.title +
"' has been resolved.")
post = Post()
post.text = "The issue '" + self.title + " has been resolved"
post.posted_by = self.house.landlord
post.save()
else:
super(Issue, self).save()
def save_posts(data_posts, id_users):
cleaned_posts = []
id_posts = {}
for obj in data_posts:
if not id_users[obj["userId"]]:
continue
obj["user"] = id_users[obj["userId"]]
id_posts[obj["id"]] = obj["id"]
cleaned_posts.append(
Post(title=obj["title"], body=obj["body"], user=obj["user"]))
response_posts = Post.objects.bulk_create(cleaned_posts,
ignore_conflicts=True)
response_posts = remove_unvalid_objects(response_posts)
response_posts = Post.objects.order_by('-pk')[:len(response_posts)]
response_posts = list(reversed(response_posts))
id_posts = bind_id_with_objects(id_posts, response_posts)
return id_posts, response_posts
def newthread(request, sid):
def default_post_page(error=None):
return render(request, 'newthread.html', {
'error': error,
'section': Section.objects.get(id=sid)
})
current_user = request.user
title = request.POST.get('title')
content = request.POST.get('content')
if content == '' or title == '':
return default_post_page('No title or content supplied')
if not content or not title:
return default_post_page()
try:
section = Section.objects.get(id=sid)
except:
# no section
return default_post_page()
# create a thread if needed
thread = Thread(title=title, creator=current_user, section=section)
thread.save()
post = Post(thread=thread, content=content, author=current_user)
post.save()
next = request.GET.get('next', reverse('thread', args=[thread.id]))
return redirect(next)
def new_post():
form = PostForm()
if form.validate_on_submit():
post = Post(title=form.title.data, content=form.content.data, author=current_user)
db.session.add(post)
db.session.commit()
flash('Your post has been created!', 'success')
return redirect(url_for('main.home'))
return render_template('create_post.html', title='New Post', form=form, legend='New Post')
def test_follow_posts(self):
# create four users
u1 = User(username='******', email='*****@*****.**')
u2 = User(username='******', email='*****@*****.**')
u3 = User(username='******', email='*****@*****.**')
u4 = User(username='******', email='*****@*****.**')
db.session.add_all([u1, u2, u3, u4])
# create four posts
now = datetime.utcnow()
p1 = Post(body="post from john",
author=u1,
timestamp=now + timedelta(seconds=1))
p2 = Post(body="post from susan",
author=u2,
timestamp=now + timedelta(seconds=4))
p3 = Post(body="post from mary",
author=u3,
timestamp=now + timedelta(seconds=3))
p4 = Post(body="post from david",
author=u4,
timestamp=now + timedelta(seconds=2))
db.session.add_all([p1, p2, p3, p4])
db.session.commit()
# setup the followers
u1.follow(u2) # john follows susan
u1.follow(u4) # john follows david
u2.follow(u3) # susan follows mary
u3.follow(u4) # mary follows david
db.session.commit()
# check the followed posts of each user
f1 = u1.followed_posts().all()
f2 = u2.followed_posts().all()
f3 = u3.followed_posts().all()
f4 = u4.followed_posts().all()
self.assertEqual(f1, [p2, p4, p1])
self.assertEqual(f2, [p2, p3])
self.assertEqual(f3, [p3, p4])
self.assertEqual(f4, [p4])
def create_fake_posts(number=10):
Post.objects.all().delete()
for i in range(number):
instance = Post(title=fake.sentence(),
abstract=fake.text(),
body=fake.text(),
public=True)
instance.save()
instance.comments.set(get_random_comments(i))
instance.tags.set(get_random_tags(i))
time.sleep(2)
print("post %s added" % i)
def save_post(self, pid, person, created_time, photo, text, latitude,
longitude, network):
post = Post(id=pid,
author=person,
dateOfCreation=created_time,
photo=photo,
text=text[:120],
latitude=latitude,
longitude=longitude,
network=network)
post.save()
return post
def home():
form = PostForm()
if form.validate_on_submit():
post = Post(fact=form.fact.data,
source=form.source.data,
author=current_user)
db.session.add(post)
db.session.commit()
flash('Your post has been added!', 'success')
return redirect(url_for('home'))
posts = Post.query.order_by(Post.date_posted.desc()).all()
return render_template('home.html',
form=form,
posts=posts,
current_user=current_user)
def create_posts(count=100):
from random import seed, randint
import forgery_py
seed()
user_count = User.query.count()
for i in range(count):
u = User.query.offset(randint(0, user_count -1)).first()
p = Post(
title = forgery_py.lorem_ipsum.sentence(),
body = forgery_py.lorem_ipsum.sentences(randint(1,3)),
author_id=u.id
)
db.session.add(p)
db.session.commit()
return '{} Posts created'.format(Post.query.count())
def postSave(self,
msg,
parent_post=None,
audio_URL=None,
attachments=None,
attachmentsName=None):
"""-- Save a message as *POST*
:param msg: The text of a message.
:param parent_post: The parent post if it is a comment.
:param audio_URL: URL to the audio file.
:param attachments: URLs to attachments.
:param attachmentsName: Names of attachments.
"""
postuser = self.socket.session['DjangoUser']
textcontent = msg
# activity to assign post to
activityType = self.socket.session['roomType']
activityID = self.socket.session['roomNumber']
# validation and save
if len(textcontent) > 0:
mess = Post(text=textcontent)
mess.creator = postuser
if parent_post:
mess.parent_post = Post.objects.get(pk=parent_post)
if audio_URL:
mess.audio_URL = audio_URL
if mess:
mess.save()
# print "message successfully saved to database"
# bind message to the document
if attachments:
for attachment in attachments:
# accessURL is "media/documents/filename"
targetDoc = Document.objects.filter(
accessURL=attachment)[0]
targetDoc.content_object = mess
targetDoc.save()
# save mess with that activity
activity = self.socket.session['DjangoRoom']
activity.posts.add(mess)
return mess
else:
return False
def handle(self, *args, **kwargs):
locale.setlocale(locale.LC_ALL, 'ru_RU.UTF-8')
resp = requests.get(DATA_URL)
data = json.loads(resp.text)
Post.objects.bulk_create([
Post(post_id=int(item['id']),
category=item['category'],
from_whom=item['from'],
title=item['title'],
text=item['text'],
thedate=datetime.datetime.strptime(item['thedate'],
'%d %B %Y года'))
for item in data['items']
],
ignore_conflicts=True)
def post(request):
current_user = request.user
try:
tid = int(request.POST.get('tid'))
except:
return render_error(request, 'No thread id supplied')
content = request.POST.get('content')
if not content:
return render_error(request, 'No content supplied')
thread = Thread.objects.get(id=tid)
post = Post(thread=thread, content=content, author=current_user)
post.save()
next = request.GET.get('next', reverse('thread', args=[thread.id]))
return redirect(next)
def bot_process(user_id, data):
print(data)
number_of_users = data["number_of_users"]
max_posts_per_user = data["max_posts_per_user"]
max_likes_per_user = data["max_likes_per_user"]
# algorithm is not ideal,
# because users can like their own posts,
# but for the sake of better readability was decided to make it so
new_users_ids_start = User.objects.last().id + 1
new_users_ids_end = new_users_ids_start + number_of_users - 1
new_users_ids_range = range(new_users_ids_start, new_users_ids_end + 1)
User.objects.bulk_create(
User.objects.initialize_user(**get_random_user_data())
for _ in range(number_of_users))
new_posts_ids_start = Post.objects.last().id + 1
posts = Post.objects.bulk_create(
Post(user_id=user_id, **get_random_post_data())
for _ in range(random.randint(0, max_likes_per_user))
for user_id in new_users_ids_range)
new_posts_ids_end = new_posts_ids_start + len(posts) - 1
new_posts_ids_range = range(new_posts_ids_start, new_posts_ids_end + 1)
Like.objects.bulk_create(
Like(user_id=user_id, **get_random_like_data(new_posts_ids_range))
for _ in range(random.randint(0, max_posts_per_user))
for user_id in new_users_ids_range)
channel_layer = get_channel_layer()
# Sends message to channels group in order to inform user
async_to_sync(channel_layer.group_send)(f'ws_bot_{user_id}', {
'type': 'message_from_bot',
"message": "work is done"
})
return None
def index():
form = PostForm()
if form.validate_on_submit():
language = guess_language(form.post.data)
if language == 'UNKNOWN' or len(language) > 5:
language = ''
post = Post(body=form.post.data,
author=current_user,
language=language)
db.session.add(post)
db.session.commit()
flash('Your post is now live!')
return redirect(url_for('index'))
page = request.args.get('page', 1, type=int)
posts = current_user.followed_posts().paginate(
page, app.config['POSTS_PER_PAGE'], False)
return render_template('index.html',
title='Home',
form=form,
posts=posts.items)
def post(self, request):
image = request.POST.get('image')
caption = request.POST.get('caption')
public = request.POST.get('status')
poster = request.POST.get('post_by')
post = Post()
post.poster_id = poster
post.caption = caption
post.public = public == "public"
post.save()
if image != "":
type, content = image.split(";base64,")
_, ext = type.split('/')
image = ContentFile(base64.b64decode(content),
"{}.{}".format(post.id, ext))
post.post_image = image
post.save()
return Response("success")
def save_results(self, instagram_results):
"""
Implement yourself to work out what to do with each extract batch of posts
:param instagram_results: A list of Instagram Posts
"""
for result in instagram_results:
if not self.already_saved(result.post_id):
post = Post()
post.enterprise = self.get_enterprise(result.hashtags())
post.username = result.user.id
post.user_display_name = result.user.bio
post.text = result.processed_text()
tz = pytz.timezone("UTC")
post.date_posted = datetime.fromtimestamp(
result.created_at, tz)
post.external_id = result.post_id
if result.is_video:
post.file = self.get_video(result.code)
else:
post.file = result.display_src
post.save()
def post_create(req):
page = "post-create-page"
if req.method == 'GET':
context = {
'current_user': req.user,
'form': PostForm(),
'page': page,
}
return render(req, 'post-create.html', context)
creator_obj = req.user.userprofile
creator_post = Post(creator=creator_obj)
form = PostForm(req.POST, req.FILES, instance=creator_post)
if form.is_valid():
form.save()
return redirect('post list')
context = {
'form': form,
'current_user': req.user,
'page': page,
}
return render(req, 'post-create.html', context)
def save_post():
form = PostForm(request.form)
if request.method == 'POST' and form.validate():
blog = Routes.response_sql()
title = form.title.data
content = form.content.data
p = Post(
title=title,
content=content,
blog_id=blog.id_blog,
create_date=datetime.datetime.now(),
update_date=datetime.datetime.now(),
status=1,
)
if 'tag' in request.form.keys() and request.form['tag'] != '':
tag_post = request.form['tag'].split()
tag_list = list()
for tag in tag_post:
tag_query = Tag.query.filter_by(name=tag_post)
if tag_query.count() == 1:
id_tag = tag_query.first().id_tag
else:
tag_model = Tag(
name=tag,
create_date=datetime.datetime.now(),
update_date=datetime.datetime.now(),
status=1,
)
tag_list += [tag_model]
if len(tag_list) > 0:
db.session.add_all(tag_list)
db.session.commit()
id_tag = db.session.query(Tag).order_by(
Tag.id_tag.desc()).first().id_tag
p.tag_id = id_tag
db.session.add(p)
db.session.commit()
return redirect(url_for('admin.default'))
def create_post(title, body, user):
post = Post(title=title, body=body, author=user)
post.save()
return post.toJSON()
def insert_post(title, body, original_link):
newpost = Post(title=title, content=body, original_link=original_link)
session.add(newpost)
session.commit()
def test(request):
template = """
<strong>{0}:</strong><br>
Result: {1}<br>
<hr>
"""
response = "<h1>TESTE:</h1>"
Imagem(
seq_imagem=1,
des_hash=hashlib.sha1("foo").hexdigest(),
nom_imagem=hashlib.sha1("foo").hexdigest() + ".jpg",
des_diretorio="/2015/01/07/",
dat_cadastro=timezone.now(),
).save()
response = response + template.format('Imagem',
Imagem.objects.get(seq_imagem=1))
Usuario(seq_usuario=1,
seq_imagem=Imagem(seq_imagem=1),
cod_usuario="clagomess",
nom_usuario=u"Cláudio Gomes",
des_email="*****@*****.**",
des_senha=hashlib.sha1("010203").hexdigest(),
dat_cadastro=timezone.now(),
dat_ultimo_acesso=timezone.now()).save()
response = response + template.format('Usuario',
Usuario.objects.get(seq_usuario=1))
Post(seq_post=1,
seq_usuario=Usuario(seq_usuario=1),
cod_post=base64.b64encode(
timezone.now().strftime("%H%M%S%f")).replace("=", ''),
des_post=u"Olá Amiguinhos!",
dat_post=timezone.now()).save()
response = response + template.format('Post', Post.objects.get(seq_post=1))
Like(seq_like=1,
seq_post=Post(seq_post=1),
seq_usuario=Usuario(seq_usuario=1)).save()
response = response + template.format('Like', Like.objects.get(seq_like=1))
Notificacao(seq_notificacao=1,
seq_usuario=Usuario(seq_usuario=1),
dat_notificacao=timezone.now()).save()
response = response + template.format(
'Notificacao', Notificacao.objects.get(seq_usuario=1))
Seguidor(seq_seguidor=1,
seq_usuario_seguidor=Usuario(seq_usuario=1),
seq_usuario_seguido=Usuario(seq_usuario=1),
dat_seguidor=timezone.now()).save()
response = response + template.format('Seguidor',
Seguidor.objects.get(seq_seguidor=1))
return HttpResponse(response)
