def search(request):
queryset = Post.objects.all()
query = request.GET.get('q')
blog = get_blog()
category_count = get_category_count(blog)
most_recent = Post.objects.filter(blog=blog).filter(
featured=True).order_by('-timestamp')[:3]
if query:
queryset = queryset.filter(blog=blog).filter(
Q(title__icontains=query) | Q(overview__icontains=query)
| Q(content__icontains=query)).distinct()
paginator = Paginator(queryset, 4)
page_request_var = 'page'
page = request.GET.get(page_request_var)
try:
paginated_queryset = paginator.page(page)
except PageNotAnInteger:
paginated_queryset = paginator.page(1)
except EmptyPage:
paginated_queryset = paginator.page(paginator.num_pages())
context = {
"active_classes": get_language_classes(),
"queryset": paginated_queryset,
"most_recent": most_recent,
"page_request_var": page_request_var,
"category_count": category_count,
}
return render(request, 'blog.html', context)
def categories(request, id):
blog = get_blog()
category_count = get_category_count(blog)
most_recent = Post.objects.filter(blog=blog).filter(
featured=True).order_by('-timestamp')[:3]
queryset = Post.objects.filter(blog=blog).filter(featured=True).filter(
categories__id=id)
paginated_queryset = None
page_request_var = None
if (queryset.exists()):
paginator = Paginator(queryset, 4)
page_request_var = 'page'
page = request.GET.get(page_request_var)
try:
paginated_queryset = paginator.page(page)
except PageNotAnInteger:
paginated_queryset = paginator.page(1)
except EmptyPage:
paginated_queryset = paginator.page(paginator.num_pages())
context = {
"active_classes": get_language_classes(),
"queryset": paginated_queryset,
"most_recent": most_recent,
"page_request_var": page_request_var,
"category_count": category_count,
}
return render(request, 'blog.html', context)
def index(request):
price_list = jd_phone_info.objects[:200]
#获取手机品牌
#name price
reg =re.compile(r'(.*?)\s',re.S)
#此处找出手机购买次数排名前十的列表
names=[]
prices=[]
for i in jd_phone_info.objects.all():
#用正则获取手机品牌的前几个字
pn = reg.findall(i.product_name)
prices.append(i.product_price)
try:
p_name=pn[0]
names.append(p_name)
except:
pass
c=Counter(names)
m=c.most_common(10)#list,显示前十
count =len(price_list)#一共多少
per_pages=10#定义每一页多少条
paginator = Paginator(price_list,per_pages)#一页10条
paginator.num_pages =math.ceil(count/per_pages)#向上取整，取最近的一个整数
page = request.GET.get('page')
try:
rows = paginator.page(page)
except PageNotAnInteger:
rows = paginator.page(1)#不是整数的时候就设置为１
except EmptyPage:
rows = paginator.page(paginator.num_pages)#
return render(request,'phone/index.html',context={"count":count,"rows":rows,"names":names,"prices":prices,"pn":m})
def SearchFunc(request): #검색용
if request.method == 'POST':
s_type = request.POST.get('s_type')
s_value = request.POST.get('s_value')
if s_type == 'title':
datas = BoardTab.objects.filter(title__contains=s_value).order_by(
'-id') # 칼럼명 __ contains는 like 연산자 처럼 작업됌
elif s_type == 'name':
datas = BoardTab.objects.filter(
name__contains=s_value).order_by('-id')
paginator = Paginator(datas, 5) # 한페이지당 5 행 출력
page = request.GET.get('page')
try:
data = paginator.page(page)
except PageNotAnInteger:
data = paginator.page(1)
except EmptyPage:
data = paginator.page(paginator.num_pages())
return render(request, 'board.html', {'data': data})
def person_list(request):
title = "Liste des personnes"
selected = "persons"
person_list = Person.objects.all().filter(inactif=False)
if request.method == "POST":
form = PersonSearchForm(request.POST)
if form.is_valid():
nom_form = form.cleaned_data["nom"]
type_person_form = form.cleaned_data["type_person"]
if type_person_form is not None:
if type_person_form == "ADOPTANTE":
person_list = person_list.filter(is_adoptante=True)
if type_person_form == "FA":
person_list = person_list.filter(is_famille=True)
if type_person_form == "BENEVOLE":
person_list = person_list.filter(is_benevole=True)
if nom_form is not None:
person_list = person_list.filter(nom__icontains=nom_form)
else:
form = PersonSearchForm()
# Pagination : 10 éléments par page
paginator = Paginator(person_list.order_by("-date_mise_a_jour"), 10)
try:
page = request.GET.get("page")
if not page:
page = 1
persons = paginator.page(page)
except EmptyPage:
# Si on dépasse la limite de pages, on prend la dernière
persons = paginator.page(paginator.num_pages())
return render(request, "gestion_association/person/person_list.html",
locals())
def search_visite(request):
selected = "visites"
visites = VisiteMedicale.objects.all()
if request.method == "POST":
form = VisiteSearchForm(request.POST)
if form.is_valid():
date_min_form = form.cleaned_data["date_min"]
date_max_form = form.cleaned_data["date_max"]
if date_min_form:
visites = visites.filter(date__gte=date_min_form)
if date_max_form:
visites = visites.filter(date__lte=date_max_form)
else:
form = VisiteSearchForm()
# Pagination : 10 éléments par page
paginator = Paginator(visites.order_by('-date_mise_a_jour'), 10)
try:
page = request.GET.get("page")
if not page:
page = 1
visites = paginator.page(page)
except EmptyPage:
# Si on dépasse la limite de pages, on prend la dernière
visites = paginator.page(paginator.num_pages())
return render(request, "admin_interface/visite_list.html", locals())
def ListFunc(request):
#이렇게 해도 되지만 html에서 처리 할 때 리턴타입이 튜플이므로 {{키.0}} 식으로 처리
#ORM은 복잡한 쿼리문 실행을 못하기 때문에 그럴 경우에 사용하는 것이 좀더 효율적
#sql = 'select * from sangdata'
#conn = Mysql.connect()
#cursor = conn.cursor()
#cursor.execute(sql)
#datas = cursor.fetchall()
'''
페이징 처리 안 된 일반적인 상태
datas = Sangdata.objects.all() #ORM일 경우 리턴타입이 QuerySet -> {{키.컬럼명}}
return render(request, 'list.html', {'sangpums':datas})
'''
'''페이지 나누기 기능은 list2.html에서 출력'''
datas = Sangdata.objects.all().order_by('-code') #code desc
paginater = Paginator(datas, 5) #페이지당 5개씩 보기
try:
page = request.GET['page']
except:
page = 1
try:
data = paginater.page(page)
except PageNotAnInteger:
data = paginater.page(1) #페이지 변수가 숫자가 아닌 경우 1페이지로
except EmptyPage:
data = paginater.page(paginater.num_pages()) #페이지가 없는 경우
#개별 페이지 표시용 작업
allpage = range(paginater.num_pages + 1)
#print(allPage)
return render(request, 'list2.html', {'sangpums':data, 'allpage':allpage})
def search_sejour(request):
selected = "sejours"
sejours = Sejour.objects.all().filter(annule=False)
if request.method == "POST":
form = SejourSearchForm(request.POST)
if form.is_valid():
base_url = reverse('sejours')
query_string = form.data.urlencode()
url = '{}?{}'.format(base_url, query_string)
return redirect(url)
else:
form = SejourSearchForm()
date_debut_min_form = request.GET.get("date_debut_min", "")
date_debut_max_form = request.GET.get("date_debut_max", "")
date_fin_min_form = request.GET.get("date_fin_min", "")
date_fin_max_form = request.GET.get("date_fin_max", "")
proprietaire_form = request.GET.get("proprietaire", "")
cohabitation_form = request.GET.get("cohabitation", "")
if date_debut_min_form:
sejours = sejours.filter(
date_arrivee__gte=parse_date(date_debut_min_form))
form.fields["date_debut_min"].initial = date_debut_min_form
if date_debut_max_form:
sejours = sejours.filter(
date_arrivee__lte=parse_date(date_debut_max_form))
form.fields["date_debut_max"].initial = date_debut_max_form
if date_fin_min_form:
sejours = sejours.filter(
date_depart__gte=parse_date(date_fin_min_form))
form.fields["date_fin_min"].initial = date_fin_min_form
if date_fin_max_form:
sejours = sejours.filter(
date_depart__lte=parse_date(date_fin_max_form))
form.fields["date_fin_max"].initial = date_fin_max_form
if proprietaire_form:
sejours = sejours.filter(proprietaire=proprietaire_form)
form.fields["proprietaire"].initial = proprietaire_form
if cohabitation_form:
sejours = sejours.filter(cohabitation=cohabitation_form)
form.fields["cohabitation"].initial = cohabitation_form
#loading des objets liés pour améliorer la perf
sejours = sejours.select_related('proprietaire').prefetch_related(
'animaux')
# Pagination : 10 éléments par page
paginator = Paginator(sejours.order_by('-date_mise_a_jour'), 10)
try:
page = request.GET.get("page")
if not page:
page = 1
sejours = paginator.page(page)
except EmptyPage:
# Si on dépasse la limite de pages, on prend la dernière
sejours = paginator.page(paginator.num_pages())
return render(request, "admin_interface/sejour_list.html", locals())
def ListFunc(request):
'''
#sql문 사용
config = {
'host':'127.0.0.1',
'user':'******',
'password':'******',
'database':'test',
'port':3306,
'charset':'utf8',
'use_unicode':True
}
conn = MySQLdb.connect(**config)
sql = "select * from sangdata"
cursor = conn.cursor()
cursor.execute(sql)
datas = cursor.fetchall()
print(type(datas)) # tuple
'''
#장고의 ORM 지원메소드 사용
''' 페이징처리가 없는 경우
datas = Sangdata.objects.all()
#print(type(datas)) # django.db.models.query.QuerySet
return render(request, 'list.html', {'sangpums':datas})
'''
# 페이지 나누기 ----------
datas = Sangdata.objects.all().order_by('-code')
paginator = Paginator(datas, 3) # 한 페이지 당 3행씩 출력
try:
page = request.GET.get('page')
except:
page = 1
try:
data = paginator.page(page)
except PageNotAnInteger: # page 변수가 정수가 아닐 때
data = paginator.page(1)
except EmptyPage: # page가 받아지지 않은 경우
data = paginator.page(paginator.num_pages())
# 개별 페이지 표시용
allpage = range(paginator.num_pages + 1)
return render(request, 'list2.html', {
'sangpums': data,
'allpage': allpage
})
def index3(request):
user_list = PropertyMaster.objects.all()
page = request.GET.get('page', 1)
paginator = Paginator(user_list, 200)
try:
users = paginator.page(page)
except PageNotAnInteger:
users = paginator.page(1)
except EmptyPage:
users = paginator.page(paginator.num_pages(10))
return render(request, 'user_list.html', {'users': users})
def ListFunc(request):
datas = BoardTab.objects.all().order_by('-gnum', 'onum')
#return render(request,'board.html',{'data':datas})
paginator = Paginator(datas, 2) #페이징
page = request.GET.get('page')
try:
data = paginator.page(page)
except PageNotAnInteger:
data = paginator.page(1)
except EmptyPage:
data = paginator.page(paginator.num_pages())
return render(request, 'board.html', {'data': data})
def ListFunc(request):
datas = BoardTab.objects.all().order_by("-id")
""" 페이지 나누기 """
paginator = Paginator(datas, 5) # datas에 대해 5개씩 페이지 나눔을 함.
page = request.GET.get("page")
try:
data = paginator.page(page)
except PageNotAnInteger: # 페이지가 없을 때
data = paginator.page(1)
except EmptyPage:
data = paginator.page(paginator.num_pages())
return render(request, "board.html", {"datas":data}) # data는 page지만 값도 같이 넘어감.
def ListFunc(request):
#datas = BoardTab.objects.all().order_by('-id')
datas = BoardTab.objects.all().order_by(
'-gnum', 'onum') # -gnum = ex)새 글이 첫 번 째로 보이기 함, onum = [RE]가 아래 있게 함
#return render(request, 'board.html', {'data':datas})
paginator = Paginator(datas, 5) # 페이징 한 페이지에 5개
page = request.GET.get('page')
try:
data = paginator.page(page)
except PageNotAnInteger:
data = paginator.page(1)
except EmptyPage:
data = paginator.page(paginator.num_pages())
return render(request, 'board.html', {'data': data})
def list(request):
# return HttpResponse('欢迎访问我的主页')
post_list = Posts.objects.all()
#分页
ps = Paginator(post_list, 8)
pn = request.GET.get('page')
try:
post_list = ps.page(pn)
except PageNotAnInteger:
post_list = ps.page(1)
except EmptyPage:
post_list = ps.page(ps.num_pages())
return render(request, 'blog/list.html',context={
'post_list':post_list
})
def OrderList(request): # 주문 관리 페이지 리스트
st = request.GET['msg']
if st == 'all': # 전체 목록으로 선택했을 떄
odatas = Order.objects.all().order_by('-id')
else: # 배송, 주문, 완료 목록으로 선택했을 때
odatas = Order.objects.filter(state=st).order_by('-id')
total_len = len(odatas) # 전체 목록 갯수
paginator = Paginator(odatas, 5)
try:
page = request.GET.get('page')
except:
page = 1
try:
data = paginator.page(page)
except PageNotAnInteger: # 페이지가 정수가 아닌 경우
data = paginator.page(1)
except EmptyPage: # 페이지가 받아지지 않을 경우
data = paginator.page(paginator.num_pages())
index = data.number - 1
max_index = len(paginator.page_range)
start_index = index - 2 if index >= 2 else 0
if index < 2:
end_index = 5 - start_index
else:
end_index = index + 3 if index <= max_index - 3 else max_index
page_range = list(paginator.page_range[start_index:end_index])
state = {0: '주문', 1: '배송', 2: '완료'}
return render(
request, 'order_list.html', {
'order_data': data,
'ostate': state,
'st': st,
'page_range': page_range,
'total_len': total_len,
'max_index': max_index
})
def posts(request):
posts = Post.objects.filter(active=True)
myFilter = PostFilter(request.GET, queryset=posts)
posts = myFilter.qs
page = request.GET.get('page')
paginator = Paginator(posts, 3)
try:
posts = paginator.page(page)
except PageNotAnInteger:
posts = paginator.page(1)
except EmptyPage:
posts = paginator.page(paginator.num_pages())
context = {'posts':posts, 'myFilter':myFilter}
return render(request, 'base/posts.html', context)
def Alert(request):
dfp = pd.read_csv("rishu.csv")
df = pd.read_csv("core/rishuAlert2.csv")
if request.method == 'GET':
view_state = request.GET.get('view_state')
types = request.GET.get('types')
view_percentage = request.GET.get('view_percentage')
x = 1 - float(get_float(view_percentage) / 100)
print("Rishuuu", x)
# akp1 =True
akp2 = True
akp3 = True
print("Available Field", view_state)
# (1) Condition for State , County and City
if (view_state and view_percentage) is not None:
print(df)
print(dfp)
akp1 = compute_county_wise_price(df, dfp, view_state, x)
# print(df1)
df1 = dfp.loc[akp1, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
df1 = dfp
print("DF1", df1)
json_records = df1.reset_index().to_json(orient='records')
data = []
data = json.loads(json_records)
page = request.GET.get('page', 1)
paginator = Paginator(data, 500)
try:
users = paginator.page(page)
except PageNotAnInteger:
users = paginator.page(1)
except EmptyPage:
users = paginator.page(paginator.num_pages(10))
return render(request, 'bootstrap_form.html', {'users': users})
def ListFunc(request):
'''
conn = ''
sql = 'select * from sangdata'
cursor = conn.cursor()
cursor.excute(sql)
datas = cursor.fetchall() return type이 tuple 이므로 {{키.0}}
'''
# --페이지 나누기 기능은 list2.html 로 출력
datas = Sangdata.objects.all().order_by(
'-code') #ORM return type 이 QuerySet
paginator = Paginator(datas, 5)
#페이징설정
try:
page = request.GET.get('page')
except:
page = 1
try:
data = paginator.page(page)
except PageNotAnInteger:
data = paginator.page(1)
except EmptyPage:
data = paginator.page(paginator.num_pages())
# 개별 페이지 표시용 작업
allpage = range(paginator.num_pages + 1)
print('allpage:', allpage)
return render(
request,
'list2.html',
{
'sangpums': data,
'allpage': allpage
},
)
def SangpumFunc(request): # 상품 리스트
sdatas = Stock.objects.all().order_by('id')
total_len = len(sdatas) # 전체 목록 갯수
paginator = Paginator(sdatas, 25)
try:
page = request.GET.get('page')
except:
page = 1
try:
data = paginator.page(page)
except PageNotAnInteger: # 페이지가 정수가 아닌 경우
data = paginator.page(1)
except EmptyPage: # 페이지가 받아지지 않을 경우
data = paginator.page(paginator.num_pages())
index = data.number - 1
max_index = len(paginator.page_range) # 최대 페이지
start_index = index - 2 if index >= 2 else 0 # 페이징에서 첫번째로 보여질 페이지
# 페이징에서 마지막에 보여질 페이지
if index < 2:
end_index = 5 - start_index
else:
end_index = index + 3 if index <= max_index - 3 else max_index
# 보여지는 페이지
page_range = list(paginator.page_range[start_index:end_index])
state = {0: '주문', 1: '배송', 2: '완료'}
return render(
request, 'sangpum_list.html', {
'sangpum_data': data,
'ostate': state,
'page_range': page_range,
'total_len': total_len,
'max_index': max_index
})
def SearchFunc(request): #검색용
if request.method == "POST":
s_type = request.POST.get('s_type')
s_value = request.POST.get('s_value')
if s_type == "title":
datas = BoardTab.objects.filter(
title__contains=s_value).order_by('-id')
elif s_type == "name":
datas = BoardTab.objects.filter(
name__contains=s_value).order_by('-id').order_by('-id')
paginator = Paginator(datas, 1)
page = request.GET.get('page')
try:
data = paginator.page(page)
except PageNotAnInteger:
data = paginator.page(1)
except EmptyPage:
data = paginator.page(paginator.num_pages())
return render(request, 'board.html', {'data': data})
def StockList(request): # 재고 목록
sdatas = Stock.objects.all().order_by('-id')
total_len = len(sdatas)
paginator = Paginator(sdatas, 5)
try:
page = request.GET.get('page')
except:
page = 1
try:
data = paginator.page(page)
except PageNotAnInteger: # 페이지가 정수가 아닌 경우
data = paginator.page(1)
except EmptyPage: # 페이지가 받아지지 않을 경우
data = paginator.page(paginator.num_pages())
index = data.number - 1
max_index = len(paginator.page_range)
start_index = index - 2 if index >= 2 else 0
if index < 2:
end_index = 5 - start_index
else:
end_index = index + 3 if index <= max_index - 3 else max_index
page_range = list(paginator.page_range[start_index:end_index])
return render(
request, 'stock_list.html', {
'stock_data': data,
'page_range': page_range,
'total_len': total_len,
'max_index': max_index
})
def search_proprietaire(request):
selected = "proprietaires"
proprietaire_list = Proprietaire.objects.all().filter(inactif=False)
if request.method == "POST":
form = ProprietaireSearchForm(request.POST)
if form.is_valid():
nom_form = form.cleaned_data["nom"]
prenom_form = form.cleaned_data["prenom"]
ville_form = form.cleaned_data["ville"]
telephone_form = form.cleaned_data["telephone"]
if nom_form is not None:
proprietaire_list = proprietaire_list.filter(
user__last_name__icontains=nom_form)
if prenom_form is not None:
proprietaire_list = proprietaire_list.filter(
user__first_name__icontains=prenom_form)
if ville_form is not None:
proprietaire_list = proprietaire_list.filter(
ville__icontains=ville_form)
if telephone_form is not None:
proprietaire_list = proprietaire_list.filter(
telephone__icontains=telephone_form)
else:
form = ProprietaireSearchForm()
# Pagination : 10 éléments par page
paginator = Paginator(proprietaire_list.order_by('-date_mise_a_jour'), 10)
try:
page = request.GET.get("page")
if not page:
page = 1
proprietaires = paginator.page(page)
except EmptyPage:
# Si on dépasse la limite de pages, on prend la dernière
proprietaires = paginator.page(paginator.num_pages())
return render(request, "admin_interface/proprietaire_list.html", locals())
def get(self, request, pk):
book = get_object_or_404(Book, pk=pk)
review_list = book.reviews.all()
paginator = Paginator(review_list, self.paginate_by)
page_number = request.GET.get(self.page_kwarg)
try:
page = paginator.page(page_number)
except PageNotAnInteger:
page = paginator.page(1)
except EmptyPage:
page = paginator.page(paginator.num_pages())
first_url = "?{pkw}={n}".format(pkw=self.page_kwarg, n=1)
last_url = "?{pkw}={n}".format(pkw=self.page_kwarg,
n=paginator.num_pages)
if page.has_previous():
prev_url = "?{pkw}={n}".format(pkw=self.page_kwarg,
n=page.previous_page_number())
else:
prev_url = None
if page.has_next():
next_url = "?{pkw}={n}".format(pkw=self.page_kwarg,
n=page.next_page_number())
else:
next_url = None
context = {
'is_paginated': page.has_other_pages(),
'first_page_url': first_url,
'last_page_url': last_url,
'next_page_url': next_url,
'paginator': paginator,
'previous_page_url': prev_url,
'book': book,
'review_list': page,
}
return render(request, self.template_name, context)
def post_list(request, tag_slug=None):
posts = Post.objects.filter(published_date__lte=timezone.now())\
.order_by('created_date')
tag = None
if tag_slug:
tag = get_object_or_404(Tag, slug=tag_slug)
posts = posts.filter(tags__in=[tag])
paginator = Paginator(posts, 2) # 3 posts in each page
page = request.GET.get('page')
try:
posts = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer deliver the first page
posts = paginator.page(1)
except EmptyPage:
# If page is out of range deliver last page of results
posts = paginator.page(paginator.num_pages())
return render(request, 'blog/post/post_list.html', {
'page': page,
'posts': posts,
'tag': tag
})
def show(request):
testemail()
print("DODIDDONE")
# print("Email Starting")
# E_mail()
df = pd.read_csv("bckp.csv")
# pd.df['created_at'].date()
if request.method == 'GET':
title_contains_query = request.GET.get('title_contains')
if title_contains_query is None:
title_contains_query = ""
else:
title_contains_query = request.GET.get('title_contains').title()
print("pyyyyyyy", title_contains_query)
id_exact_query = request.GET.get('id_exact')
title_or_author_query = request.GET.get('title_or_author')
view_count_min = request.GET.get('view_count_min')
view_count_max = request.GET.get('view_count_max')
date_min = request.GET.get('date_min')
date_max = request.GET.get('date_max')
Udate_min = request.GET.get('date_min2')
Udate_max = request.GET.get('date_max2')
view_acres = request.GET.get('view_acres')
status = request.GET.get('status')
title2_contains_query = request.GET.get('title2_contains')
view_state = request.GET.get('view_state')
types = request.GET.get('types')
view_percentage = request.GET.get('view_percentage')
Descrpt = request.GET.get('Descrpt')
print("Anshul Dta ", Descrpt)
print("DAte HAI NAA ", date_min)
print(date_min)
# akp1 = df['state']== 'Anji'
akp1 = True
akp2 = True
akp3 = True
if title_contains_query and title_or_author_query and view_count_min and view_count_max and date_min and date_max and Udate_min and Udate_max and view_acres and status and types:
redirect('show3')
# df['lwPropertyId']=, 'address', 'city', 'state', 'county', 'zip', 'price', 'acres', "Rate", "Url",'types', 'status', 'created_at', 'updated_at']]
print("Available Field", title_contains_query)
# (1) Condition for State , County and City
if title_contains_query is not None:
# rishu=df['created_at'].dt.date()
# print("Date rishu",rishu)
akp1 = (df['state'] == title_contains_query) | (
df['city'] == title_contains_query) | (df['county']
== title_contains_query)
# df['created_at'] = df['created_at'].strftime('%m-%d-%Y')
# df['created_at'] = pd.to_datetime(df["created_at"].dt.strftime('%Y-%m'))
# created_at = data_within_date2(df)
# print("CRETED AT ",created_at)
# print(df1)
# created_at =get_date(created_at)
# print(created_at)
df1 = df.loc[akp1, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
df1 = df
# pd.to_datetime(df['created_at']).apply(lambda x: x.date())
print("DF1", df1)
# (2) Condition for Types
if types is not None:
# df['created_at']=pd.to_datetime(df['created_at']).apply(lambda x: x.date())
akp2 = (df1['types'].str.contains(types, na=False))
# akp2 = (df1['types'] == types)
df2 = df1.loc[akp2, [
"lwPropertyId", 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
df2 = df1
# pd.to_datetime(df['created_at']).apply(lambda x: x.date())
print("DF2", df2)
# (3) Condition for Status
if status is not "":
print(status)
# df['created_at'] = pd.to_datetime(df['created_at']).apply(lambda x: x.date())
akp3 = (df2['status'] == status)
# pd.to_datetime(df['created_at']).apply(lambda x: x.date())
df3 = df2.loc[akp3, [
"lwPropertyId", 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
df3 = df2
# df['created_at'] = pd.to_datetime(df['created_at']).apply(lambda x: x.date())
print("DF3", df3)
# print(view_acres)
# (4) Condition For Min Price :
if view_count_min is not None:
# df['created_at'] = pd.to_datetime(df['created_at']).apply(lambda x: x.date())
pd.to_datetime(df['created_at']).apply(lambda x: x.date())
akp4 = df3['price'] >= get_float(view_count_min)
df4 = df3.loc[akp4, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
# df['created_at'] = pd.to_datetime(df['created_at']).apply(lambda x: x.date())
df4 = df3
print("DF4", df4)
# (5) Condition For Max Price :
if view_count_max is "100000":
# df['created_at'] = pd.to_datetime(df['created_at']).apply(lambda x: x.date())
print("word", view_count_max)
akp5 = df4['price'] <= get_float(view_count_max)
df5 = df4.loc[akp5, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
print("Hello", view_count_max)
# df['created_at']=pd.to_datetime(df['created_at']).apply(lambda x: x.date())
df5 = df4
print("DF5", df5)
#(6) Condition for Area :
if view_acres is not None:
# df['created_at']=pd.to_datetime(df['created_at']).apply(lambda x: x.date())
akp6 = df5['acres'] >= get_float(view_acres)
df6 = df5.loc[akp6, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
# print(df5)
else:
# df['created_at'] = pd.to_datetime(df['created_at']).apply(lambda x: x.date())
df6 = df5
print("DF6", df6)
# (7) Condition For Publish Date :
if date_min is "2000-01-01" and date_max is "2050-01-01":
# df['created_at']=pd.to_datetime(df['created_at']).apply(lambda x: x.date())
print("RishuuuDAte")
print(date_min)
print(date_max)
akp7 = data_within_date(df6, date_min, date_max)
df7 = df6.loc[akp7, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
print("NA Date", date_min)
# df['created_at'] = pd.to_datetime(df['created_at']).apply(lambda x: x.date())
df7 = df6
print("DF7", df7)
# (7) Condition For Update Date :
if Udate_min is "2000-01-01" and Udate_max is "2050-01-01":
akp8 = data_within_date(df7, Udate_min, Udate_max)
df8 = df7.loc[akp8, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
print("NA Date", Udate_min)
# df7['created_at']=pd.to_datetime(df['created_at']).apply(lambda x: x.date())
df8 = df7
print("DF8", df8)
# df8['created_at']=pd.to_datetime(df['created_at']).apply(lambda x: x.date())
df9 = df8.sort_values(by="created_at", ascending=False)
print("Ansjiuu")
print(df9)
# df9 = df8.loc[akp9, ['lwPropertyId', 'address', 'city', 'state', 'county', 'zip', 'price', 'acres', "Rate", "Url",'types', 'status', 'created_at', 'updated_at']]
print("Rishuuu@", df9)
# download(df8)
# testrishu(df8)
print("DFFFFFFDFSGDGDGD", df9)
# anji23 = df9['created_at']=pd.to_datetime(df['created_at']).apply(lambda x: x.date())
# print("Indian Army",anji23)
df9.to_csv(r'static/CheapLandSearch.csv', index=False)
json_records = df9.reset_index().to_json(orient='records')
# data2 =df8
data = []
data = json.loads(json_records)
data2 = data
# psg(request,data)
getfile(request, data)
# print("ANJI",data)
if title_contains_query is None:
title_contains_query = ""
anji = '?title_contains=' + title_contains_query
page = request.GET.get('page')
page2 = anji + "1"
count = request.GET.get('count', 100)
print("ARnay", title_contains_query)
# if request.GET.get(request.method == 'GET'+'/page',1) :
# anji= '?title_contains=Texas&view_count_min=&w=&date_min=2000-05-05&date_max=2050-05-05&types=&date_min2=2000-05-05&date_max2=2000-05-05&status=&view_acres='
print(anji)
types = ""
status = ""
paginator = Paginator(data, 2000)
# page = request.GET.get('?title_contains=Texas&view_count_min=&view_count_max=&date_min=2000-05-05&date_max=2050-05-05&types=&date_min2=2000-05-05&date_max2=2000-05-05&status=&view_acres=&page')
# page = request.GET.get('title_contains')
# page = request.GET.get('title_contains=Texas&view_count_min=&view_count_max=&date_min=2000-05-05&date_max=2050-05-05&types=&date_min2=2000-05-05&date_max2=2000-05-05&status=&view_acres&page', 3)
# paginator = Paginator(data, 500)
print("Anshul", title_contains_query)
try:
print(page)
users = paginator.get_page(page)
except PageNotAnInteger:
users = paginator.page(1)
except EmptyPage:
users = paginator.page(paginator.num_pages(10))
# qs = PropertyMaster.objects.all()
# d=Description.objects.create(Descrpt=Descrpt)
# d.save()
print("OKKKKK")
context = {
'users': users,
# 'anji': anji23,
'title_contains': title_contains_query,
'view_count_min': view_count_min,
'view_count_max': view_count_max,
'date_max': date_max,
'date_min': date_min,
'date_min2': Udate_min,
'date_max2': Udate_max,
'view_acres': view_acres,
'status': status,
'types': types,
# 'Descrpt' : Descrpt,
}
return render(request, 'bootstrap_form.html', context)
def OrderListSearch(request): # 주문 목록 검색
st = request.GET['msg']
s_type = request.GET['type']
s_value = request.GET['value']
print(st, s_type, s_value)
try:
if st == 'all': # 전체 목록으로 선택했을 때
if s_type == 'cname': # 구매자로 검색 했을 떄
odatas = Order.objects.filter(
ord_cid__cus_mail__contains=s_value).order_by('-id')
elif s_type == 'pname': # 상품명으로 검색했을 떄
odatas = Order.objects.filter(
ord_pid_id__st_name__contains=s_value).order_by('-id')
else: # 배송, 주문, 완료 목록으로 선택했을 때
if s_type == 'cname': # 구매자로 검색 했을 떄
odatas = Order.objects.filter(
ord_cid__cus_mail__contains=s_value,
state=st).order_by('-id')
elif s_type == 'pname': # 상품명으로 검색했을 떄
odatas = Order.objects.filter(
ord_pid_id__st_name__contains=s_value,
state=st).order_by('-id')
except:
odatas = ""
total_len = len(odatas) # 전체 목록 갯수
paginator = Paginator(odatas, 5)
try:
page = request.GET.get('page')
except:
page = 1
try:
data = paginator.page(page)
except PageNotAnInteger: # 페이지가 정수가 아닌 경우
data = paginator.page(1)
except EmptyPage: # 페이지가 받아지지 않을 경우
data = paginator.page(paginator.num_pages())
index = data.number - 1
max_index = len(paginator.page_range)
start_index = index - 2 if index >= 2 else 0
if index < 2:
end_index = 5 - start_index
else:
end_index = index + 3 if index <= max_index - 3 else max_index
page_range = list(paginator.page_range[start_index:end_index])
state = {0: '주문', 1: '배송', 2: '완료'}
search = {'st': st, 'type': s_type, 'value': s_value}
return render(
request, 'order_search_list.html', {
'order_data': data,
'ostate': state,
'st': search,
'page_range': page_range,
'total_len': total_len,
'max_index': max_index
})
def Alert(request):
dfp = pd.read_csv("rishu777.csv")
df = pd.read_csv("Alert2.csv")
if request.method == 'GET':
title_contains_query = request.GET.get('title_contains')
id_exact_query = request.GET.get('id_exact')
title_or_author_query = request.GET.get('title_or_author')
view_count_min = request.GET.get('view_count_min')
view_count_max = request.GET.get('view_count_max')
date_min = request.GET.get('date_min')
date_max = request.GET.get('date_max')
Udate_min = request.GET.get('date_min2')
Udate_max = request.GET.get('date_max2')
view_acres = request.GET.get('view_acres')
status = request.GET.get('status')
title2_contains_query = request.GET.get('title2_contains')
view_state = request.GET.get('view_state')
types = request.GET.get('types')
view_percentage = request.GET.get('view_percentage')
rto = RatioDetails.objects.create(state=view_state,
percentage=view_percentage)
rto.save()
print("Done")
print(view_percentage)
x = 1 - float(get_float(view_percentage) / 100)
print("Rishuuu", x)
# akp1 =True
akp2 = True
akp3 = True
print("Available Field", view_state)
# (1) Condition for State , County and City
if (view_state and view_percentage) is not None:
print(df)
print(dfp)
akp1 = compute_county_wise_price(df, dfp, view_state, x)
# print(df1)
df1 = dfp.loc[akp1, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
df1 = dfp
print("DF1", df1)
print("ALert", df1)
# df1.to_csv('')
df1.to_csv(r'static/CheapLandSearchALert.csv', index=False)
json_records = df1.reset_index().to_json(orient='records')
data = []
data = json.loads(json_records)
data2 = data
# psg(request,data)
getfile(request, data)
# print("ANJI",data)
# if title_contains_query is None:
# title_contains_query = ""
# anji = '?title_contains=' + title_contains_query
page = request.GET.get('page')
# page2 = anji + "1"
count = request.GET.get('count', 100)
# print("ARnay", title_contains_query)
# if request.GET.get(request.method == 'GET'+'/page',1) :
# anji= '?title_contains=Texas&view_count_min=&w=&date_min=2000-05-05&date_max=2050-05-05&types=&date_min2=2000-05-05&date_max2=2000-05-05&status=&view_acres='
# print (anji)
types = ""
view_state = "State"
paginator = Paginator(data, 2000)
# page = request.GET.get('?title_contains=Texas&view_count_min=&view_count_max=&date_min=2000-05-05&date_max=2050-05-05&types=&date_min2=2000-05-05&date_max2=2000-05-05&status=&view_acres=&page')
# page = request.GET.get('title_contains')
# page = request.GET.get('title_contains=Texas&view_count_min=&view_count_max=&date_min=2000-05-05&date_max=2050-05-05&types=&date_min2=2000-05-05&date_max2=2000-05-05&status=&view_acres&page', 3)
# paginator = Paginator(data, 500)
print("Anshul", view_state)
try:
print(page)
users = paginator.get_page(page)
except PageNotAnInteger:
users = paginator.page(1)
except EmptyPage:
users = paginator.page(paginator.num_pages(10))
# qs = PropertyMaster.objects.all()
context = {
'users': users,
'view_state': view_state,
'view_percentage': view_percentage,
'types': types,
}
return render(request, 'bootstrap_form.html', context)
def show(request):
df = pd.read_csv("core/rishu.csv")
if request.method == 'GET':
title_contains_query = request.GET.get('title_contains')
id_exact_query = request.GET.get('id_exact')
title_or_author_query = request.GET.get('title_or_author')
view_count_min = request.GET.get('view_count_min')
view_count_max = request.GET.get('view_count_max')
date_min = request.GET.get('date_min')
date_max = request.GET.get('date_max')
Udate_min = request.GET.get('date_min2')
Udate_max = request.GET.get('date_max2')
view_acres = request.GET.get('view_acres')
status = request.GET.get('status')
title2_contains_query = request.GET.get('title2_contains')
view_state = request.GET.get('view_state')
types = request.GET.get('types')
view_percentage = request.GET.get('view_percentage')
akp1 = df['state'] == 'Anji'
# akp1 =True
akp2 = True
akp3 = True
print("Available Field", title_contains_query)
# (1) Condition for State , County and City
if title_contains_query is not None:
akp1 = (df['state'] == title_contains_query) | (
df['city'] == title_contains_query) | (df['county']
== title_contains_query)
# print(df1)
df1 = df.loc[akp1, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
df1 = df
print("DF1", df1)
# (2) Condition for Types
if types is not None:
akp2 = (df1['types'].str.contains(types, na=False))
# akp2 = (df1['types'] == types)
df2 = df1.loc[akp2, [
"lwPropertyId", 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
df2 = df1
print("DF2", df2)
# (3) Condition for Status
if status is not "":
print(status)
akp3 = (df2['status'] == status)
# akp2 = (df1['status'] == types)
df3 = df2.loc[akp3, [
"lwPropertyId", 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
df3 = df2
print("DF3", df3)
# print(view_acres)
# (4) Condition For Min Price :
if view_count_min is not None:
akp4 = df3['price'] >= get_float(view_count_min)
df4 = df3.loc[akp4, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
df4 = df3
print("DF4", df4)
# (5) Condition For Max Price :
if view_count_max is "100000":
print("word", view_count_max)
akp5 = df4['price'] <= get_float(view_count_max)
df5 = df4.loc[akp5, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
print("Hello", view_count_max)
df5 = df4
print("DF5", df5)
#(6) Condition for Area :
if view_acres is not None:
akp6 = df5['acres'] >= get_float(view_acres)
df6 = df5.loc[akp6, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
# print(df5)
else:
df6 = df5
print("DF6", df6)
# (7) Condition For Publish Date :
if date_min is "2000-01-01" and date_max is "2050-01-01":
print("RishuuuDAte")
print(date_min)
print(date_max)
akp7 = data_within_date(df6, date_min, date_max)
df7 = df6.loc[akp7, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
print("NA Date", date_min)
df7 = df6
print("DF7", df7)
# (7) Condition For Update Date :
if Udate_min is "2000-01-01" and Udate_max is "2050-01-01":
akp8 = data_within_date(df7, Udate_min, Udate_max)
df8 = df7.loc[akp8, [
'lwPropertyId', 'address', 'city', 'state', 'county', 'zip',
'price', 'acres', "Rate", "Url", 'types', 'status',
'created_at', 'updated_at'
]]
else:
print("NA Date", Udate_min)
df8 = df7
print("DF8", df8)
json_records = df7.reset_index().to_json(orient='records')
data = []
data = json.loads(json_records)
page = request.GET.get('page', 1)
paginator = Paginator(data, 5000)
try:
users = paginator.page(page)
except PageNotAnInteger:
users = paginator.page(1)
except EmptyPage:
users = paginator.page(paginator.num_pages(10))
return render(request, 'bootstrap_form.html', {'users': users})
def question(request):
if request.user.is_authenticated:
#Grabs the questions form the db and orders them by id in desc fashion so the newest are first
cid = request.GET.get('cid', '')
qData = questions.objects.get_queryset().filter(
course_id=cid).order_by('-pk')
page = request.GET.get('page', 1)
cName = course.objects.get(id=cid)
user = request.user
query = request.GET.get('query')
emptyPostCheck = request.POST.get('query')
filterCategory = 'All'
if request.GET.get('filterCategory'):
filterCategory = request.GET.get('filterCategory')
if not courseusers.objects.filter(
user_id=user.id,
course_id=cid).exists() and not course.objects.filter(
user_id=user.id, id=cid).exists():
return redirect('courses')
if request.method == "POST":
if request.POST.get('Logout') == "Logout":
logout(request)
return HttpResponseRedirect('/')
elif request.POST.get('Edit') == 'Edit':
return HttpResponseRedirect('/editAccount/')
elif 'del' in request.POST:
qid = request.POST.get('del')
delQuestion(qid)
if request.POST.get('filterCategory'):
filterCategory = request.POST.get('filterCategory')
query = ''
if request.POST.get('query'):
query = request.POST.get('query')
if filterCategory != 'All':
qData = qData.filter(category=filterCategory)
else:
qData = questions.objects.get_queryset().filter(
course_id=cid).order_by('-pk')
if emptyPostCheck == '':
query = ''
qData = questions.objects.get_queryset().filter(
course_id=cid).order_by('-pk')
if query and query != '' and query != 'None':
qData = qData.filter(
Q(question__icontains=query) | Q(comment__icontains=query))
#Paginator created to limit page display to 10 data items per page
paginator = Paginator(qData, 10)
try:
fquestions = paginator.page(page)
except PageNotAnInteger:
fquestions = paginator.page(1)
except EmptyPage:
fquestions = paginator.page(paginator.num_pages())
return render(
request, 'CourseGuru_App/question.html', {
'content': fquestions,
'user': user,
'courseID': cid,
'courseName': cName,
'filterCategory': filterCategory,
'query': query
})
else:
return HttpResponseRedirect('/')
def search_animal(request):
animals = Animal.objects.all()
selected = "animals"
title = "Liste des animaux"
if request.method == "POST":
form = AnimalSearchForm(request.POST)
if form.is_valid():
nom_form = form.cleaned_data["nom"]
identification_form = form.cleaned_data["identification"]
type_form = form.cleaned_data["type"]
sterilise_form = form.cleaned_data["sterilise"]
sans_fa_form = form.cleaned_data["sans_fa"]
statuts_form = form.cleaned_data["statuts"]
date_naissance_min = form.cleaned_data["date_naissance_min"]
date_naissance_max = form.cleaned_data["date_naissance_max"]
date_prochaine_visite_min = form.cleaned_data["date_prochaine_visite_min"]
date_prochaine_visite_max = form.cleaned_data["date_prochaine_visite_max"]
date_vermifuge_min = form.cleaned_data["date_vermifuge_min"]
date_vermifuge_max = form.cleaned_data["date_vermifuge_max"]
if nom_form:
animals = animals.filter(nom__icontains=nom_form)
if type_form:
animals = animals.filter(type=type_form)
if identification_form:
animals = animals.filter(identification__icontains=identification_form)
if sterilise_form:
animals = animals.filter(sterilise=sterilise_form)
if sans_fa_form and sans_fa_form == OuiNonChoice.OUI.name:
animals = animals.filter(famille__isnull=True)
if sans_fa_form and sans_fa_form == OuiNonChoice.NON.name:
animals = animals.filter(famille__isnull=False)
if statuts_form:
animals = animals.filter(statut__in=statuts_form)
if date_naissance_min:
animals = animals.filter(date_naissance__gte=date_naissance_min)
if date_naissance_max:
animals = animals.filter(date_naissance__lte=date_naissance_max)
if date_prochaine_visite_min:
animals = animals.filter(date_prochain_vaccin__gte=date_prochaine_visite_min)
if date_prochaine_visite_max:
animals = animals.filter(date_prochain_vaccin__lte=date_prochaine_visite_max)
if date_vermifuge_min:
animals = animals.filter(date_vermifuge__gte=date_vermifuge_min)
if date_vermifuge_max:
animals = animals.filter(date_vermifuge__lte=date_vermifuge_max)
else:
form = AnimalSearchForm()
# Le champ statut est initialisé, il faut appliquer le filtre dessus
statuts_form = form["statuts"].value()
animals = animals.filter(statut__in=statuts_form)
# Pagination : 20 éléments par page
paginator = Paginator(animals.order_by("-date_mise_a_jour"), 20)
try:
page = request.GET.get("page")
if not page:
page = 1
animal_list = paginator.page(page)
except EmptyPage:
# Si on dépasse la limite de pages, on prend la dernière
animal_list = paginator.page(paginator.num_pages())
return render(request, "gestion_association/animal/animal_list.html", locals())
