def index_page(request):
check = check_if_auth_user(request)
current_user = None
user_class = None
if check:
cursor = connection.cursor()
user_class = request.session["user_class"]
if user_class == 'E':
query = "SELECT * FROM User_expert WHERE `User_expert`.'user_id' = %s"
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'user_id' = %s"
cursor.execute(query, [
check,
])
result = namedtuplefetchall(cursor)
current_user = result[0]
cursor = connection.cursor()
cursor.execute(
"SELECT * FROM post_post ORDER BY `post_post`.'timestamp' desc")
result = namedtuplefetchall(cursor)
context_data = {
"all_posts": result,
"user": current_user,
"user_class": user_class,
}
return render(request, "index.html", context_data)
def posts_create(request):
check = check_if_auth_user(request)
if not check:
messages.error(request, "Perform login first to create new post")
return redirect("home:welcome")
current_user = User.objects.filter(user_id=check)[0]
if request.method == "POST":
title = request.POST.get('item_title')
disc = request.POST.get('item_disc')
category = request.POST.get('item_category')
image = request.FILES['item_image']
price = request.POST.get('item_price')
reason_post = request.POST.get('reason_item')
new_post = Post(title=title,
author=current_user,
reason_post=reason_post,
description=disc,
category=category,
image=image,
price=price)
new_post.save()
messages.success(request, "New Post Created")
return redirect(new_post.getAbsoluteURL())
contextData = {
"user": current_user,
"category": home.views.CATEGORIES,
}
return render(request, "createPost.html", contextData)
def search_database(request, id):
check = check_if_auth_user(request)
current_user = None
user_class = None
if check:
cursor = connection.cursor()
user_class = request.session["user_class"]
if user_class == 'E':
query = "SELECT * FROM User_expert WHERE `User_expert`.'user_id' = %s"
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'user_id' = %s"
cursor.execute(query, [
check,
])
result = namedtuplefetchall(cursor)
current_user = result[0]
if not current_user:
messages.error(request, "Please login first.")
return redirect("home:welcome")
if int(id) > 3:
messages.error(request, "This is not a searchable query. Redirecting.")
return redirect(reverse("home:query", kwargs={"id": id}))
search_query = request.GET.get('search_query')
if not search_query:
messages.error(request, "Enter a suitable query. Try again")
return redirect(reverse("home:query", kwargs={"id": id}))
search_query += '%'
# '%' because it will search for a pattern using LIKE op
cursor.execute(QUERY_DICT[int(id)],
[search_query, search_query, search_query])
result = namedtuplefetchall(cursor)
result_header = [col[0] for col in cursor.description]
if not result:
messages.error(request, "No records match. Try again")
result_farmers = []
if int(id) == 3:
query = "SELECT * FROM User_farmer"
cursor.execute(query, [])
result_farmers = namedtuplefetchall(cursor)
context_data = {
"user": current_user,
"user_class": user_class,
"query_id": id,
"result_header": result_header,
"result": result,
"result_farmers": result_farmers,
}
return render(request, "query.html", context_data)
def register_crop(request):
check = check_if_auth_user(request)
current_user = None
user_class = None
if check:
cursor = connection.cursor()
user_class = request.session["user_class"]
if user_class == 'E':
query = "SELECT * FROM User_expert WHERE `User_expert`.'user_id' = %s"
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'user_id' = %s"
cursor.execute(query, [check, ])
result = namedtuplefetchall(cursor)
current_user = result[0]
if current_user is None:
messages.error(request, "Perform Login first")
return redirect("home:welcome")
if user_class == 'E':
messages.error(request, "Sorry, but only farmers are allowed to register their crops.")
return redirect("home:welcome")
query = "SELECT crop_id, name FROM crop_crop";
cursor.execute(query, [])
result = namedtuplefetchall(cursor)
all_crops_dict = {x.name:x.crop_id for x in result}
all_crop_names = [x.name for x in result]
if request.method == "POST":
name = request.POST.get('crop_name')
remark = request.POST.get('crop_remark')
cursor = connection.cursor()
query = "SELECT * FROM crop_cropfarmer WHERE `crop_cropfarmer`.'crop_id' = %s and `crop_cropfarmer`.'farmer_id' = %s"
cursor.execute(query, [all_crops_dict[name], current_user.auto_id])
result = namedtuplefetchall(cursor)
if result:
messages.error(request,"You have already registered this crop. Delete previous and re-register")
return redirect("crop:register")
# Data modifying operation - commit required
query = "INSERT INTO crop_cropfarmer('crop_id', 'farmer_id', 'remark') Values(%s, %s, %s)"
cursor.execute(query, [all_crops_dict[name], current_user.auto_id, remark])
transaction.commit()
messages.success(request, "Crop succesfully registered.")
return redirect("crop:detail")
context_data={
"crop_names" : all_crop_names,
}
return render(request,"register_crop.html",context_data)
def faq(request):
check = check_if_auth_user(request)
current_user = None
if check:
current_user = User.objects.filter(user_id = check)[0]
context_data = {
"user" : current_user,
}
return render(request, "FAQ.html",context_data)
def posts_detail(request, id=None):
instance = get_object_or_404(Post, id=id)
check = check_if_auth_user(request)
current_user = None
if check:
current_user = User.objects.filter(user_id=check)[0]
contextData = {
"user": current_user,
"post_obj": instance,
}
return render(request, "showPost.html", contextData)
def posts_delete(request, id=None):
check = check_if_auth_user(request)
if not check:
messages.error(request, "Perform login first to delete any post")
return redirect("home:welcome")
current_user = User.objects.filter(user_id=check)[0]
instance = get_object_or_404(Post, id=id)
if instance.author != current_user:
messages.error(request, "You can't delete this post.")
else:
instance.delete()
messages.success(request, "Post successfully deleted")
return redirect("home:welcome")
def index_page(request):
global CATEGORIES
check = check_if_auth_user(request)
current_user = None
if check:
current_user = User.objects.filter(user_id = check)[0]
context_data = {
"user" : current_user,
"all_posts" : Post.objects.all(),
"category" : CATEGORIES
}
return render(request, "index.html" , context_data)
def category_result(request,id = None):
check = check_if_auth_user(request)
if not check:
messages.error(request,"Perform login first to see any particular posts")
return redirect("home:welcome")
current_user = User.objects.filter(user_id = check)[0]
req_cate = category_match(int(id))
results = Post.objects.filter(category=req_cate)
context_data = {
"user" : current_user,
}
return posts_list(request, results, context_data)
def query_resolve(request, id=None):
if not QUERY_DICT.has_key(int(id)):
messages.error(request, "Wrong query given. Please try again.")
return redirect("home:welcome")
check = check_if_auth_user(request)
current_user = None
user_class = None
if check:
cursor = connection.cursor()
user_class = request.session["user_class"]
if user_class == 'E':
query = "SELECT * FROM User_expert WHERE `User_expert`.'user_id' = %s"
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'user_id' = %s"
cursor.execute(query, [
check,
])
result = namedtuplefetchall(cursor)
current_user = result[0]
if not current_user:
messages.error(request, "Please login first.")
return redirect("home:welcome")
result = None
result_header = None
result_farmers = None
if int(id) > 3:
if user_class == 'F':
messages.error(request, "Only experts allowed for these queries.")
return redirect("home:welcome")
query = QUERY_DICT[int(id)]
if int(id) == 4:
query = query % current_user.location_id
cursor.execute(query)
result = namedtuplefetchall(cursor)
result_header = [col[0] for col in cursor.description]
context_data = {
"user": current_user,
"user_class": user_class,
"query_id": id,
"result_header": result_header,
"result": result,
"result_farmers": result_farmers,
}
return render(request, "query.html", context_data)
def weather_query(request, id):
check = check_if_auth_user(request)
current_user = None
if check:
cursor = connection.cursor()
if request.session["user_class"] == 'E':
query = "SELECT * FROM User_expert WHERE `User_expert`.'user_id' = %s"
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'user_id' = %s"
cursor.execute(query, [
check,
])
result = namedtuplefetchall(cursor)
current_user = result[0]
if current_user is None:
messages.error(request, "Perform Login first")
return redirect("home:welcome")
if request.session["user_class"] == 'F':
messages.error(
request,
"Sorry, only experts are allowed to study location's weather.")
return redirect("home:welcome")
query = "SELECT * FROM location_location WHERE `location_location`.loc_id = %s"
cursor.execute(query, [
id,
])
result = namedtuplefetchall(cursor)
if not result:
messages.error(request, "Such location doesn't exist.")
return redirect("home:welcome")
location = result[0]
query = "SELECT * FROM location_weather WHERE `location_weather`.'location_id' = %s ORDER BY `location_weather`.'date_record' DESC"
cursor.execute(query, [
id,
])
result = namedtuplefetchall(cursor)
context_data = {
"user": current_user,
"location": location,
"weather_info": result[:10], # Only recent 10 records will be shown
}
return render(request, "location.html", context_data)
def feedback(request):
if request.method == "POST":
feedback=feedback_data(improvements=request.POST.get('improvements'),complain=request.POST.get('complaint'))
feedback.save()
messages.success(request, "FeedBack Submitted")
return redirect("home:welcome")
else:
check = check_if_auth_user(request)
current_user = None
if check:
current_user = User.objects.filter(user_id = check)[0]
context_data = {
"user" : current_user,
}
return render(request,"feedback.html",context_data)
def posts_delete(request, id=None):
check = check_if_auth_user(request)
current_user = None
if check:
cursor = connection.cursor()
if request.session["user_class"] == 'E':
query = "SELECT * FROM User_expert WHERE `User_expert`.'user_id' = %s"
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'user_id' = %s"
cursor.execute(query, [check, ])
result = namedtuplefetchall(cursor)
current_user = result[0]
if current_user is None:
messages.error(request, "Perform Login first")
return redirect("home:welcome")
cursor = connection.cursor()
query = "SELECT * FROM post_post WHERE `post_post`.'post_id' = %s"
cursor.execute(query, [id, ])
result = namedtuplefetchall(cursor)
if not result:
messages.error(request,"Given post was not found")
return redirect("home:welcome")
instance = result[0]
if request.session["user_class"] == 'E':
if current_user.auto_id != instance.author_expert_id:
messages.error(request,"You can not delete this post!")
return redirect(reverse("post:detail", kwargs={ "id":instance.post_id}))
else:
if current_user.auto_id != instance.author_farmer_id:
messages.error(request,"You can not delete this post!")
return redirect(reverse("post:detail", kwargs={ "id":instance.post_id}))
# Data modifying operation - commit required
query = "DELETE from post_post WHERE `post_post`.'post_id' = %s"
cursor.execute(query, [id,])
transaction.commit()
messages.success(request,"Post successfully deleted")
return redirect("home:welcome")
def begin_chat(request, id = None):
check = check_if_auth_user(request)
if not check:
messages.error(request, "Perform login first to start chatting")
return redirect("home:welcome")
current_user = User.objects.filter(user_id = check)[0]
other_user = get_object_or_404(User, auto_id = id)
sql = """SELECT * FROM chat_start_chat
WHERE chat_sender='{0}' and chat_reciever='{1}'
OR chat_sender='{1}' and chat_reciever='{0}';"""
chat_list = Chat.objects.raw(sql.format(current_user.user_id,other_user.user_id))
context_data = {
"user" : current_user,
"other_user" : other_user,
"chatmessage_list": chat_list,
}
return render(request, "chat.html",context_data)
def crop_delete(request, id=None):
check = check_if_auth_user(request)
current_user = None
user_class = None
if check:
cursor = connection.cursor()
user_class = request.session["user_class"]
if user_class == 'E':
query = "SELECT * FROM User_expert WHERE `User_expert`.'user_id' = %s"
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'user_id' = %s"
cursor.execute(query, [check, ])
result = namedtuplefetchall(cursor)
current_user = result[0]
if current_user is None:
messages.error(request, "Perform Login first")
return redirect("home:welcome")
if user_class == 'E':
messages.error(request, "Sorry, but only farmers are allowed to delete their crops.")
return redirect("home:welcome")
cursor = connection.cursor()
query = "SELECT * FROM crop_cropfarmer WHERE `crop_cropfarmer`.'crop_id' = %s and `crop_cropfarmer`.'farmer_id' = %s"
cursor.execute(query, [id, current_user.auto_id])
result = namedtuplefetchall(cursor)
if not result:
messages.error(request,"Given crop was not found")
return redirect("home:welcome")
instance = result[0]
# Data modifying operation - commit required
query = "DELETE from crop_cropfarmer WHERE `crop_cropfarmer`.'crop_id' = %s and `crop_cropfarmer`.'farmer_id' = %s"
cursor.execute(query, [id, current_user.auto_id])
transaction.commit()
messages.success(request,"Your crop was successfully deleted")
return redirect("crop:detail")
def posts_update(request, id=None):
check = check_if_auth_user(request)
if not check:
messages.error(request, "Perform login first to edit any post")
return redirect("home:welcome")
current_user = User.objects.filter(user_id=check)[0]
instance = get_object_or_404(Post, id=id)
if instance.author.user_id != current_user.user_id:
messages.error(
request,
"You can't edit this post." + str(instance.author.user_id))
return redirect("home:welcome")
contextData = {
"user": current_user,
"post_obj": instance,
"category": home.views.CATEGORIES,
}
if request.method == "POST":
title = request.POST.get('item_title')
disc = request.POST.get('item_disc')
category = request.POST.get('item_category')
image = request.FILES['item_image']
price = request.POST.get('item_price')
reason_post = request.POST.get('reason_item')
if reason_post == "lostfound":
price = 0
instance.title = title
instance.description = disc
instance.category = category
instance.image = image
instance.price = price
instance.reason_post = reason_post
instance.save()
messages.success(request, "Post updated")
return redirect(instance.getAbsoluteURL())
return render(request, "editPost.html", contextData)
def about_us(request):
check = check_if_auth_user(request)
current_user = None
user_class = None
if check:
cursor = connection.cursor()
user_class = request.session["user_class"]
if user_class == 'E':
query = "SELECT * FROM User_expert WHERE `User_expert`.'user_id' = %s"
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'user_id' = %s"
cursor.execute(query, [
check,
])
result = namedtuplefetchall(cursor)
current_user = result[0]
context_data = {
"user": current_user,
}
return render(request, "aboutus.html", context_data)
def view_crops(request):
check = check_if_auth_user(request)
current_user = None
user_class = None
if check:
cursor = connection.cursor()
user_class = request.session["user_class"]
if user_class == 'E':
query = "SELECT * FROM User_expert WHERE `User_expert`.'user_id' = %s"
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'user_id' = %s"
cursor.execute(query, [check, ])
result = namedtuplefetchall(cursor)
current_user = result[0]
if current_user is None:
messages.error(request, "Perform Login first")
return redirect("home:welcome")
if user_class == 'E':
messages.error(request, "Sorry, but only farmers are allowed here.")
return redirect("home:welcome")
query = """
SELECT `crop_cropfarmer`.'crop_id', `crop_cropfarmer`.remark,
`crop_crop`.name as crop_name, `crop_crop`.family,
`crop_disease`.name as dis_name, `crop_disease`.category
FROM crop_cropfarmer
INNER JOIN `crop_crop` ON `crop_cropfarmer`.'crop_id' = `crop_crop`.'crop_id'
LEFT JOIN `crop_disease` ON `crop_cropfarmer`.'disease_id' = `crop_disease`.'dis_id'
WHERE `crop_cropfarmer`.'farmer_id' = %s
"""
cursor.execute(query, [current_user.auto_id, ])
result = namedtuplefetchall(cursor)
context_data={
"crop_objects_and_diseases" : result,
}
return render(request, "view_crops.html", context_data)
def query_result(request):
check = check_if_auth_user(request)
if not check:
messages.error(request,"Perform login first to see any particular posts")
return redirect("home:welcome")
current_user = User.objects.filter(user_id = check)[0]
query = request.GET.get("search_query")
if not query:
messages.error(request, "Enter some query first")
return redirect("home:welcome")
results = Post.objects.filter(title__icontains=query)
results = results | Post.objects.filter(author__name__icontains=query)
results = results | Post.objects.filter(description__icontains=query)
# sql = """
# SELECT * FROM post_post
# WHERE title LIKE '%s' OR description LIKE '%s' OR price LIKE '%s'
# """ % (query , query ,query)
# results = list(Post.objects.raw(sql))
context_data = {
"user" : current_user,
}
return posts_list(request, results, context_data)
def see_chats(request):
check = check_if_auth_user(request)
if not check:
messages.error(request,"Perform login first to see any chats")
return redirect("home:welcome")
current_user = User.objects.filter(user_id = check)[0]
objects = Chat.objects.filter(chat_sender=current_user.user_id)
objects = objects | Chat.objects.filter(chat_reciever=current_user.user_id)
objects.order_by('-timestamp')
msg_user_list = defaultdict(int)
# result = objects.annotate(msg_count=Count('chat_sender'))
for obj in objects:
if obj.chat_sender == current_user.user_id:
temp = User.objects.filter(user_id = obj.chat_reciever)[0]
msg_user_list[temp]+=1
else:
temp = User.objects.filter(user_id = obj.chat_sender)[0]
msg_user_list[temp]+=1
context_data = {
"chatList" : dict(msg_user_list),
"user" : current_user,
}
return render(request, "chatList.html", context_data)
def posts_detail(request,id=None):
check = check_if_auth_user(request)
current_user = None
user_class = None
if check:
cursor = connection.cursor()
user_class = request.session["user_class"]
if user_class == 'E':
query = "SELECT * FROM User_expert WHERE `User_expert`.'user_id' = %s"
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'user_id' = %s"
cursor.execute(query, [check, ])
result = namedtuplefetchall(cursor)
current_user = result[0]
if current_user is None:
messages.error(request, "Perform Login first")
return redirect("home:welcome")
cursor = connection.cursor()
query = "SELECT * FROM post_post WHERE `post_post`.'post_id' = %s"
cursor.execute(query, [id, ])
result = namedtuplefetchall(cursor)
if not result:
messages.error(request,"Given post was not found")
return redirect("home:welcome")
instance = result[0]
author = None
for elem in result:
if elem.author_expert_id:
query = "SELECT * FROM User_expert WHERE `User_expert`.'auto_id' = %s"
cursor.execute(query, [elem.author_expert_id, ])
result_ = namedtuplefetchall(cursor)
author = result_[0]
if elem.author_farmer_id:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'auto_id' = %s"
cursor.execute(query, [elem.author_farmer_id, ])
result_ = namedtuplefetchall(cursor)
author = result_[0]
if request.method == "POST":
cmnt = request.POST.get('comment')
if user_class == 'F':
query = "INSERT INTO post_comment('timestamp', 'text', 'author_farmer_id', 'post_id') VALUES(%s, %s, %s, %s)"
else:
query = "INSERT INTO post_comment('timestamp', 'text', 'author_expert_id', 'post_id') VALUES(%s, %s, %s, %s)"
cursor.execute(query, [datetime.datetime.now(), cmnt, current_user.auto_id, id])
transaction.commit()
query = "SELECT * FROM post_comment WHERE `post_comment`.'post_id' = %s"
cursor.execute(query, [id, ])
comments = namedtuplefetchall(cursor)
comments_and_authors = []
for comment in comments:
if comment.author_expert_id:
query = "SELECT * FROM User_expert WHERE `User_expert`.'auto_id' = %s"
cursor.execute(query, [comment.author_expert_id, ])
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'auto_id' = %s"
cursor.execute(query, [comment.author_farmer_id, ])
result = namedtuplefetchall(cursor)
comments_and_authors.append((comment, result[0]))
context_data={
"post_obj" : instance,
"author" : author,
"comments_and_authors": comments_and_authors,
"user_class": user_class,
"user": current_user,
}
return render(request, "view_post.html", context_data)
def posts_update(request,id=None):
check = check_if_auth_user(request)
current_user = None
if check:
cursor = connection.cursor()
if request.session["user_class"] == 'E':
query = "SELECT * FROM User_expert WHERE `User_expert`.'user_id' = %s"
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'user_id' = %s"
cursor.execute(query, [check, ])
result = namedtuplefetchall(cursor)
current_user = result[0]
if current_user is None:
messages.error(request, "Perform Login first")
return redirect("home:welcome")
cursor = connection.cursor()
query = "SELECT * FROM post_post WHERE `post_post`.'post_id' = %s"
cursor.execute(query, [id, ])
result = namedtuplefetchall(cursor)
if not result:
messages.error(request,"Given post was not found")
return redirect("home:welcome")
instance = result[0]
if request.session["user_class"] == 'E':
if current_user.auto_id != instance.author_expert_id:
messages.error(request,"You can not edit this post!")
return redirect(reverse("post:detail", kwargs={ "id":instance.post_id}))
else:
if current_user.auto_id != instance.author_farmer_id:
messages.error(request,"You can not edit this post!")
return redirect(reverse("post:detail", kwargs={ "id":instance.post_id}))
if request.method == "POST":
title = request.POST.get('post_title')
disc = request.POST.get('post_disc')
category = request.POST.get('post_category')
try:
image = request.FILES['post_image']
except Exception:
image = None
# Remove previous image (if any) from MEDIA_ROOT/ path
if instance.image:
remove_from_dir(MEDIA_ROOT, instance.image)
if image:
full_filename = os.path.join(MEDIA_ROOT, image.name)
fout = open(full_filename, 'wb+')
image_read = image.read()
file_content = ContentFile(image_read)
# Iterate through the chunks.
for chunk in file_content.chunks():
fout.write(chunk)
fout.close()
image_64_encode = base64.encodestring(image_read)
cursor = connection.cursor()
# Data modifying operation - commit required
if image:
query = "UPDATE post_post SET 'title' = %s, 'description' = %s, 'category' = %s, 'updated' = %s, 'image' = %s, 'image_db' = %s WHERE `post_post`.'post_id' = %s"
cursor.execute(query, [title, disc, category, datetime.datetime.now(), image.name, image_64_encode, id])
else:
query = "UPDATE post_post SET 'title' = %s, 'description' = %s, 'category' = %s, 'updated' = %s, 'image' = NULL, 'image_db' = NULL WHERE `post_post`.'post_id' = %s"
cursor.execute(query, [title, disc, category, datetime.datetime.now(), id])
transaction.commit()
messages.success(request, "Your post was successfully updated.")
return redirect(reverse("post:detail", kwargs={ "id":id}))
context_data={
"post_obj": instance,
"category" : POST_CATEGORIES,
}
return render(request, "create_edit_post.html", context_data)
def posts_create(request):
check = check_if_auth_user(request)
current_user = None
if check:
cursor = connection.cursor()
if request.session["user_class"] == 'E':
query = "SELECT * FROM User_expert WHERE `User_expert`.'user_id' = %s"
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'user_id' = %s"
cursor.execute(query, [check, ])
result = namedtuplefetchall(cursor)
current_user = result[0]
if current_user is None:
messages.error(request, "Perform Login first")
return redirect("home:welcome")
if request.method == "POST":
title = request.POST.get('post_title')
disc = request.POST.get('post_disc')
category = request.POST.get('post_category')
try:
image = request.FILES['post_image']
except Exception:
image = None
cursor = connection.cursor()
if image:
full_filename = os.path.join(MEDIA_ROOT, image.name)
fout = open(full_filename, 'wb+')
image_read = image.read()
file_content = ContentFile(image_read)
# Iterate through the chunks.
for chunk in file_content.chunks():
fout.write(chunk)
fout.close()
image_64_encode = base64.encodestring(image_read)
# Data modifying operation - commit required
if image:
if request.session["user_class"] == 'E':
query = "INSERT INTO post_post('title', 'description', 'category', 'timestamp', 'updated', 'author_expert_id', 'image', 'image_db') Values(%s, %s, %s, %s, %s, %s, %s, %s)"
else:
query = "INSERT INTO post_post('title', 'description', 'category', 'timestamp', 'updated', 'author_farmer_id', 'image', 'image_db') Values(%s, %s, %s, %s, %s, %s, %s, %s)"
cursor.execute(query, [title, disc, category, datetime.datetime.now(), datetime.datetime.now(), current_user.auto_id, image.name, image_64_encode])
else:
if request.session["user_class"] == 'E':
query = "INSERT INTO post_post('title', 'description', 'category', 'timestamp', 'updated', 'author_expert_id') Values(%s, %s, %s, %s, %s, %s)"
else:
query = "INSERT INTO post_post('title', 'description', 'category', 'timestamp', 'updated', 'author_farmer_id') Values(%s, %s, %s, %s, %s, %s)"
cursor.execute(query, [title, disc, category, datetime.datetime.now(), datetime.datetime.now(), current_user.auto_id])
transaction.commit()
messages.success(request, "New Post Created")
return redirect("home:welcome")
context_data={
"category" : POST_CATEGORIES,
}
return render(request,"create_edit_post.html",context_data)
def tag_disease(request, id=None, crop_id=None):
check = check_if_auth_user(request)
current_user = None
user_class = None
if check:
cursor = connection.cursor()
user_class = request.session["user_class"]
if user_class == 'E':
query = "SELECT * FROM User_expert WHERE `User_expert`.'user_id' = %s"
else:
query = "SELECT * FROM User_farmer WHERE `User_farmer`.'user_id' = %s"
cursor.execute(query, [check, ])
result = namedtuplefetchall(cursor)
current_user = result[0]
if current_user is None:
messages.error(request, "Perform Login first")
return redirect("home:welcome")
if user_class == 'F':
messages.error(request, "Sorry, but only experts are allowed to tag diseases.")
return redirect("home:welcome")
query = """
SELECT `crop_cropfarmer`.'crop_id', `crop_cropfarmer`.farmer_id,
`crop_crop`.name as crop_name, `crop_crop`.family,
`crop_disease`.name as dis_name, `crop_disease`.category
FROM crop_cropfarmer
INNER JOIN `crop_crop` ON `crop_cropfarmer`.'crop_id' = `crop_crop`.'crop_id'
LEFT JOIN `crop_disease` ON `crop_cropfarmer`.'disease_id' = `crop_disease`.'dis_id'
WHERE `crop_cropfarmer`.'farmer_id' = %s
"""
cursor.execute(query, [id, ])
crops_and_diseases = namedtuplefetchall(cursor)
query = """
SELECT dis_id, name
FROM crop_disease
"""
cursor.execute(query, [])
result = namedtuplefetchall(cursor)
disease_map = {x.name : x.dis_id for x in result}
if request.method == "POST":
disease_name = request.POST.get('disease_name')
print "sda"
if disease_name:
cursor = connection.cursor()
# Data modifying operation - commit required
if disease_map.has_key(disease_name):
query = """
UPDATE crop_cropfarmer SET disease_id = %s
WHERE `crop_cropfarmer`.'farmer_id' = %s and `crop_cropfarmer`.'crop_id' == %s"""
cursor.execute(query, [disease_map[disease_name], id, crop_id])
else:
query = """
UPDATE crop_cropfarmer SET disease_id = NULL
WHERE `crop_cropfarmer`.'farmer_id' = %s and `crop_cropfarmer`.'crop_id' == %s"""
cursor.execute(query, [id, crop_id])
transaction.commit()
messages.success(request, "Successfully updated the disease tag.")
return redirect(reverse("crop:disease", kwargs={ "id":id}))
context_data={
"crop_objects_and_diseases" : crops_and_diseases,
"user_class": user_class,
"disease_names": disease_map.keys(),
}
return render(request, "view_crops.html", context_data)
