def groundlist():
"""所有土地信息列表"""
g.__setattr__('action','ground.groundlist')
page = int(request.form.get('page',1))
pagesize = int(request.form.get('page_size',10))
action = request.form.get('action','')
#查询条件
batch_name = int(request.form.get('batch_name',0))
county = int(request.form.get('county',0))
project_type = int(request.form.get('project_type',0))
industry_type = int(request.form.get('industry_type',0))
used_type = int(request.form.get('used_type',0))
ground_list = Ground.query
if batch_name:
ground_list = ground_list.filter_by(batch_name=batch_name)
if county:
ground_list = ground_list.filter_by(county=county)
if project_type:
ground_list = ground_list.filter_by(project_type=project_type)
if industry_type:
ground_list = ground_list.filter_by(industry_type=industry_type)
if used_type:
ground_list = ground_list.filter_by(used_type=used_type)
ground_list = ground_list.order_by('id desc').all()
# print Ground.query.filter(and_(filter_str)).order_by('id desc')
for ground in ground_list:
ground.match_target_type = match_target_type_resolution(ground.match_target_type)
if action == "export":
return redirect(ground_excel_created(ground_list))
print '*'*40,pagesize,page
pagination = Pagination(ground_list,page,pagesize)
groundlist = pagination.list()
return render_template('/ground/groundlist.html',
pagination=pagination,
page=page,
page_size=pagesize,
groundlist=groundlist,
batchlist = Batch.query.all(),
countys=COUNTY_CHOICES,
project_types=PROJECT_TYPE_CHOICES,
industry_types=INDUSTRY_TYPE_CHOICES,
used_types=GROUND_USE_TYPE_CHOICES,
_batch_name=batch_name,
_county=str(county),
_project_type=str(project_type),
_industry_type=str(industry_type),
_used_type=str(used_type)
)
def get(self, request):
q = self.get_search_contain([
'contact', 'lost_type', 'lost_time', 'lost_place',
'detailed_description'
])
all_recruit = models.Recruit.objects.filter(
q,
status='finding',
)
all_recruitment = models.Recruitment.objects.filter(
q,
status='finding',
)
all_recruits = chain(all_recruit, all_recruitment)
all_recruits = sorted(all_recruits,
key=lambda x: x.pub_time,
reverse=True)
query_params = copy.deepcopy(request.GET)
# 要想修改querydict对象要设置为True
query_params._mutable = True
# 把路径编码从<QueryDict: {'page': ['3']}>到page = 3
# print(query_parmas.urlencode())
# print(query_parmas)
pagination = Pagination(request, len(all_recruits), query_params, 8, 3)
return render(
request, 'user/recruit_list.html', {
'all_recruit': all_recruits[pagination.start:pagination.end],
'pages': pagination.show_li,
})
def init_paginaion(request, queryset):
# 初始化分页器
query_params = copy.deepcopy(request.GET) # QueryDict
current_page = request.GET.get('page', 1)
# per_page = config.per_page
# pager_page_count = config.pager_page_count
if isinstance(queryset, list):
all_count = len(queryset)
else:
all_count = queryset.count()
base_url = request.path_info
page_obj = Pagination(current_page, all_count, base_url, query_params)
query_set = queryset[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return query_set, page_html
def get(self, request):
q = self.get_search_condition(['qq', 'name', 'class_type'])
if request.path_info == reverse('customer'):
# 公户
all_customer = models.Customer.objects.filter(q, consultant__isnull=True)
else:
# 私户
all_customer = models.Customer.objects.filter(q, consultant=request.user)
# 分页保留搜索条件
print(request.GET.urlencode())
# query_params = copy.deepcopy(request.GET)
query_params = request.GET.copy()
# _mutable改为True，就可以修改URL
# query_params._mutable = True
# query_params['page']=1
page = Pagination(request, all_customer.count(), query_params, per_num=2)
# 生成按钮
add_btn, query_params = self.get_add_btn()
return render(request, 'crm/customer_list.html',
# {'all_customer': all_customer}
{'all_customer': all_customer[page.start:page.end], 'pagination': page.show_li,
'add_btn': add_btn, 'query_params': query_params}
)
def get(self, request, customer_id):
# customer_id为0则查询当前用户的全部咨询记录
if customer_id == '0':
all_consult_record = models.ConsultRecord.objects.filter(
consultant=request.user, delete_status=False)
# 否则查询当前用户的客户id为customer_id的咨询记录
else:
all_consult_record = models.ConsultRecord.objects.filter(
customer_id=customer_id,
consultant=request.user,
delete_status=False)
query_params = request.GET.copy()
# 分页功能
page = Pagination(request,
len(all_consult_record),
query_params,
each_page_data=10)
return render(
request, 'crm/sales/consult_record_list.html', {
'all_consult_record':
all_consult_record[page.data_start:page.data_end],
'all_tag':
page.show_li
})
def get(self, request):
filter_fields = ['company', 'contact_name', 'source']
search_conditions = self.get_search_conditions(filter_fields)
all_leads = models.Leads.objects.filter(search_conditions)
page = Pagination(request,
all_leads.count(),
per_num=2,
query_params=request.GET)
return render(
request, 'leads_list.html', {
'all_leads':
all_leads[page.get_slice_start:page.get_slice_end],
'page_li': page.show_li()
})
def get(self, request):
q = self.get_search_contion(['qq', 'name', 'last_consult_date'])
if request.path_info == reverse('customer'):
all_customer = models.Customer.objects.filter(
q, consultant__isnull=True)
else:
all_customer = models.Customer.objects.filter(
q, consultant=request.user)
query_params = request.GET.copy(
) # <QueryDict: {'query': ['alex'], 'page': ['2']}>
# query_params = copy.deepcopy(request.GET) # <QueryDict: {'query': ['alex'], 'page': ['2']}>
# query=alex
# print(request.GET.urlencode()) # query=alex&page=2
# query_params['page'] = 1
# print(request.GET.urlencode())
page = Pagination(
request,
all_customer.count(),
query_params,
)
# 生成添加按钮
add_btn, query_params = self.get_add_btn()
return render(
request, 'crm/consultant/customer_list.html', {
'all_customer': all_customer[page.start:page.end],
'pagination': page.show_li,
'add_btn': add_btn,
'query_params': query_params
})
def report(request):
if request.method == 'GET':
data_count = models.Report.objects.count()
page = Pagination(request.GET.get('p', 1), data_count)
result = models.Report.objects.order_by('-id').select_related(
'article_id', )[page.start:page.end]
page_str = page.page_str("/report.html")
return render(
request, 'backend_report.html', {
'result': result,
'page_str': page_str,
'data_count': data_count,
'menu_string': request.session['menu_string'],
})
def article(request, *args, **kwargs):
"""
文章管理
:param request:
:param args:
:param kwargs:
:return:
"""
blog_id = request.session['user_info']["blog__nid"]
condition = {}
for k, v in kwargs.items():
if v == '0':
pass
else:
condition[k] = v
condition['blog_id'] = blog_id
print(condition)
data_count = models.Article.objects.filter(**condition).count()
page = Pagination(request.GET.get('p', 1), data_count)
result = models.Article.objects.filter(**condition).order_by('-nid').only(
'nid', 'title', 'blog').select_related('blog')[page.start:page.end]
page_str = page.page_str(reverse('article', kwargs=kwargs))
category_list = models.Category.objects.filter(blog_id=blog_id).values(
'nid', 'title')
type_list = map(lambda item: {
'nid': item[0],
'title': item[1]
}, models.Article.type_choices)
kwargs['p'] = page.current_page
return render(
request, 'backend_article.html', {
'result': result,
'page_str': page_str,
'category_list': category_list,
'type_list': type_list,
'arg_dict': kwargs,
'data_count': data_count
})
def issues(request, project_id):
if request.method == 'GET':
# 筛选条件
allow_filter_name = ['issues_type', 'status', 'priority', ]
condition = {}
for name in allow_filter_name:
value_list = request.GET.getlist(name)
if not value_list:
continue
condition[f'{name}__in'] = value_list
queryset = models.Issues.objects.filter(project_id=project_id).filter(**condition)
page_object = Pagination(
current_page=request.GET.get('page'),
all_count=queryset.count(),
base_url=request.path_info,
query_params=request.GET,
per_page=10,
)
issues_object_list = queryset[page_object.start:page_object.end]
form = IssuesModelForm(request)
project_issues_type = models.IssuesType.objects.filter(project_id=project_id).values_list('id', 'title')
project_total_user = [(request.tracer.project.creator_id, request.tracer.project.creator.username)]
join_user = models.ProjectUser.objects.filter(project_id=project_id).values_list('user_id', 'user__username')
project_total_user.extend(join_user)
invite_form = InviteModelForm()
context = {'form': form,
'invite_form': invite_form,
'issues_object_list': issues_object_list,
'page_html': page_object.page_html(),
'filter_list': [
{'title': "问题类型", 'filter': CheckFilter('issues_type', project_issues_type, request)},
{'title': "状态", 'filter': CheckFilter('status', models.Issues.status_choices, request)},
{'title': "优先级", 'filter': CheckFilter('priority', models.Issues.priority_choices, request)},
{'title': "指派者", 'filter': SelectFilter('assign', project_total_user, request)},
{'title': "关注者", 'filter': SelectFilter('attention', project_total_user, request)},
]
}
return render(request, 'issues.html', context)
form = IssuesModelForm(request, data=request.POST)
if form.is_valid():
form.instance.creator = request.tracer.user
form.instance.project = request.tracer.project
form.save()
return JsonResponse({'status': True})
return JsonResponse({'status': False, 'error': form.errors})
def article_list(request):
fields_list = ['title', 'category__title', 'detail__content']
q = search_query(request, fields_list)
all_articles = models.Article.objects.filter(q, author=request.user_obj)
page = Pagination(request, all_articles.count())
return render(request, 'article_list.html',
{'all_articles': all_articles[page.start:page.end], 'page_html': page.page_html})
def blog_list(request):
# 查找所有blog
queryset = models.Blog.objects.all()
page_object = Pagination(current_page=request.GET.get('page'),
all_count=queryset.count(),
base_url=request.path_info,
query_params=request.GET,
per_page=50)
blog_object_list = queryset[page_object.start:page_object.end]
form = BlogListModelForm()
content = {
'blog_object_list': blog_object_list,
'page_html': page_object.page_html(),
'form': form
}
return render(request, 'blog_list.html', content)
def get(self, request):
filter_fields = ['name']
search_conditions = self.get_search_conditions(filter_fields)
all_potentials = models.Potentials.objects.filter(search_conditions)
page = Pagination(request,
all_potentials.count(),
per_num=2,
query_params=request.GET)
return render(
request, 'potentials_list.html', {
'all_potentials':
all_potentials[page.get_slice_start:page.get_slice_end],
'page_li':
page.show_li()
})
def series_list(request):
q = get_query(request, ['title'])
all_series = models.Series.objects.filter(q)
page = Pagination(request, all_series.count())
return render(request, 'series_list.html', {
"all_series": all_series[page.start:page.end],
"page_html": page.page_html
})
def get(self, request):
model = models.ClassList.objects.all()
present_page = request.GET.get("page", "1") # 当前页数
pag = Pagination(present_page, len(model), request.GET.copy(), 2)
return render(request, "teacher/class_list.html", {
"class_obj": model[pag.start:pag.end],
"ret": pag.page_html
})
def index(request):
# 查询所有的文章
all_article = models.Article.objects.filter(publish_status=True).order_by('-create_time')
# print(request.user_obj)
page = Pagination(request, all_article.count(), 5)
return render(request, 'index.html', {'all_article': all_article[page.start:page.end], 'page_html': page.page_html})
def tag(request):
# -----------------要有blog才可使用-----------------
blog_id = request.session['user_info']['blog__nid']
if blog_id is None:
return redirect("/backend/index.html")
# --------------------------------------------------
blog_id = request.session["user_info"]["blog__nid"]
# 分頁
data_count = models.Tag.objects.filter(blog_id=blog_id).count()
current_page = request.GET.get("p")
page_obj = Pagination(data_count, current_page, perPageItemNum=7)
page_str = page_obj.page_str("/backend/tag.html")
result = models.Tag.objects.filter(
blog_id=blog_id)[page_obj.start():page_obj.end()]
return render(request, "backend_tag.html", locals())
def archive(request, year, month):
post_list = Article.objects.filter(create_date__year=year,
create_date__month=month,
).order_by('-create_date')
title = str(year) + '年' + str(month) + '月文章'
page = Pagination(request, post_list.count(), 15)
return render(request, 'blog/list.html',
context={'post_list': post_list[page.start:page.end], 'title': title, 'page_html': page.page_html})
def host_list(request):
all_host = models.Host.objects.all()
page = Pagination(request.GET.get('page', '1'), all_host.count())
return render(request, 'host_list.html', {
'all_host': all_host[page.start:page.end],
'page_html': page.page_html
})
def customer_list(request):
print(request.POST)
if request.path_info == reverse('custmoer'):
all_customer = models.Customer.objects.filter(consultant__isnull=True) # 查询consultant等于空的
else:
all_customer = models.Customer.objects.filter(consultant=request.user) # 查询consultant等于当前登录的用户
page = Pagination(request, all_customer.count())
return render(request, 'crm/consultant/customer_list.html', {'all_customer': all_customer[page.start:page.end], 'pagination' : page.show_li})
def article(request, **kwargs):
user_info = request.session.get('user_info')
blog = Blog.objects.filter(user_id=user_info.get('id')).first()
type_list = Classification.objects.filter(blog=blog)
tag_list = Tags.objects.filter(blog=blog)
condition = {}
for k, v in kwargs.items():
kwargs[k] = int(v)
type_id = kwargs.get('type_id')
tag_id = kwargs.get('tag_id')
# print(type_id,tag_id)
if type_id == 0:
if tag_id == 0:
pass
else:
condition['tags'] = tag_id
else:
if tag_id == 0:
# Article.objects.filter(blog__classification=type_id)
pass
else:
condition['tags'] = tag_id
condition['article_classification_id'] = type_id
condition['blog'] = blog
# print(condition)
article_list = Article.objects.filter(**condition).order_by(
'-publish', '-id')
# article_list = Article.objects.filter(blog=blog,).values('tags','article_classification_id','title')
data_count = article_list.count()
page_obj = Pagination(data_count, request.GET.get('p'))
base_url = reverse('backend:backend_article',
kwargs={
'type_id': type_id,
'tag_id': tag_id
})
page_str = page_obj.page_str(base_url)
article_list = article_list[page_obj.start:page_obj.end]
context = {
'kwargs': kwargs,
'type_list': type_list,
'tag_list': tag_list,
'article_list': article_list,
'data_count': data_count,
'page_str': page_str
}
return render(request, 'backend_article.html', context)
def article_list(request):
# 应该是获取当前用户的文章
all_articles = models.Article.objects.filter(author=request.user_obj)
page = Pagination(request, all_articles.count(), 5)
return render(
request, 'article_list.html', {
'all_articles': all_articles[page.start:page.end],
'page_html': page.page_html
})
def get(self, request, *args, **kwargs):
q = self.search([])
payment = models.PaymentRecord.objects.filter(q, customer__consultant=request.user_obj, delete_status=False)
present_page = request.GET.get("page", "1") # 当前页数
pag = Pagination(present_page, len(payment), request.GET.copy(), 2)
# print(pag.page_num)
return render(request, "customer/payment_list.html",
{"payment_obj": payment[pag.start:pag.end], "ret": pag.page_html})
def resolve_premier_league_matches(self,
info,
date=None,
page=None,
per_page=None):
query = models.PremierLeagueMatch.objects.order_by('match_date')
if date:
query = filter_match_by_date(query, date)
return Pagination().get_paginated_results(query, page, per_page)
def tag(request):
blog_id = request.session['user_info']['blog__nid']
data_count = models.Category.objects.count()
page = Pagination(request.GET.get('p', 1), data_count)
result = models.Tag.objects.filter(blog_id=blog_id).order_by(
'-nid').select_related('blog')[page.start:page.end]
page_str = page.page_str("/tag.html")
article_list = models.Article.objects.filter(blog_id=blog_id)
return render(
request, 'backend_tag.html', {
'result': result,
'page_str': page_str,
'article_list': article_list,
'data_count': data_count,
'menu_string': request.session['menu_string']
})
def sortblog(request, str):
blogs = models.Blogs.objects.filter(blog_type_id__b_type=str)
page = Pagination(request, blogs.count())
return render(
request, 'blog/sort_blog.html', {
'str': str + '类',
'blogs': blogs[page.start:page.end],
'pagination': page.show_li
})
def user_list(request):
page = Pagination(request, len(users))
return render(request, 'user_list.html',
{
"data": users[page.start:page.end],
# 'total_num': range(page_start, page_end + 1)
'html_str': page.show_li
})
def index(request, *args, **kwargs):
"""
博客首页，展示全部博文
:param request:
:return:
"""
article_type_list = models.Article.type_choices
#print(article_type_list)
# print(kwargs)
if kwargs:
#print(kwargs) #{'article_type_id': '4'}
article_type_id = int(kwargs['article_type_id'])
base_url = reverse('index',kwargs=kwargs)
#print(base_url)
#print('aID',article_type_id)
else:
article_type_id = None
base_url = '/'
data_count = article_list = models.Article.objects.filter(**kwargs).count()
page_obj = Pagination(request.GET.get('p'),data_count)
article_list = models.Article.objects.filter(**kwargs).order_by('-nid')[page_obj.start:page_obj.end]
page_str = page_obj.page_str(base_url)
# print(request.session['user_info'])
return render(
request,
'index.html',
{
'article_list': article_list,
'article_type_id': article_type_id,
'article_type_list': article_type_list,
'page_str': page_str,
}
)
def index(request, *args, **kwargs):
'''
博客首页，展示全部博文
:param request:
:param args:
:param kwargs:
:return:
'''
article_type_list = models.Article.type_choices
if kwargs:
article_type_id = int(kwargs['article_type_id'])
base_url = reverse('index', kwargs=kwargs)
else:
article_type_id = None
base_url = '/'
if article_type_id == 5: ## 返回妹子图片
article_type_id = 5
meizi_list = models.MeiZi.objects.all()
return render(
request, 'meizi.html', {
'article_type_id': article_type_id,
'article_type_list': article_type_list
})
else:
# ## 得到全部的数据
data_count = article_list = models.Article.objects.filter(
**kwargs).count()
## 分页对象
page_obj = Pagination(1, data_count=data_count)
article_list = models.Article.objects.filter(**kwargs).order_by(
('-nid'))[page_obj.start:page_obj.end]
page_str = page_obj.page_str(base_url=base_url)
return render(
request, 'index.html', {
'article_list': article_list,
'article_type_id': article_type_id,
'article_type_list': article_type_list,
'page_str': page_str,
})
def myblogs(request):
if request.user.is_authenticated():
username = '******'.format(request.user)
blogs = models.Blogs.objects.filter(user_id__username=username)
page = Pagination(request, blogs.count())
return render(request, 'blog/myblogs.html', {
'blogs': blogs[page.start:page.end],
'pagination': page.show_li
})
return redirect(reverse('blog_login'))
def batchlist():
"""所有批次列表"""
g.__setattr__('action','batch.batchlist')
page = int(request.form.get('page',1))
pagesize = int(request.form.get('page_size',2))
action = request.form.get('action','')
#查询条件
_county = int(request.form.get('county',0))
_year = int(request.form.get('year',0))
print "<>"*40,_county,_year
batchlist = Batch.query
if _county:
batchlist = batchlist.filter_by(county=_county)
if _year:
batchlist = batchlist.filter_by(year=_year)
batchlist = batchlist.order_by('id desc').all()
print len(batchlist)
# print Ground.query.filter(and_(filter_str)).order_by('id desc')
if action == "export":
return redirect(batch_excel_created(batchlist))
pagination = Pagination(batchlist,page,pagesize)
batchlist = pagination.list()
print len(batchlist)
return render_template('/batch/batchlist.html',
pagination=pagination,
page=page,
page_size=pagesize,
batchlist=batchlist,
countys=COUNTY_CHOICES,
years=YEAR_CHOICES,
_county=str(_county),
_year=str(_year)
)
def article_list(request):
# 应该是获取当前用户的文章
from django.http.request import QueryDict
q = get_query(request, ['title', ])
all_articles = models.Article.objects.filter(q, author=request.user_obj)
page = Pagination(request, all_articles.count(), 2)
return render(request, 'article_list.html',
{'all_articles': all_articles[page.start:page.end], 'page_html': page.page_html})
def firstexalist():
"""初审信息列表"""
g.__setattr__("action", "examine.firstexalist")
page = int(request.form.get("page", 1))
pagesize = int(request.form.get("page_size", 10))
action = request.form.get("action", "")
# 查询条件
_county = int(request.form.get("county", 0))
inquirylist = Inquiry.query
if _county:
inquirylist = inquirylist.filter_by(project_address1=_county)
inquirylist = inquirylist.order_by("apply_time desc").all()
for inquiry in inquirylist:
inquiry.project_address2 = (
COUNTY_CHOICES.__getitem__(inquiry.project_address1 - 1)[1]
+ "-"
+ inquiry.project_address2_time.strftime("%Y-%m-%d")
)
inquiry.apply_time = inquiry.apply_time.strftime("%Y-%m-%d")
if action == "export":
return redirect(inquiry_excel_created(inquirylist))
pagination = Pagination(inquirylist, page, pagesize)
inquirylist = pagination.list()
return render_template(
"/examine/inquirylist.html",
inquirylist=inquirylist,
countys=COUNTY_CHOICES,
pagination=pagination,
_county=str(_county),
page=page,
page_size=pagesize,
)
def preexalist():
"""预审信息"""
g.__setattr__("action", "examine.preexalist")
page = int(request.form.get("page", 1))
pagesize = int(request.form.get("page_size", 10))
action = request.form.get("action", "")
# 查询条件
_county = int(request.form.get("county", 0))
reviewlist = Review.query
if _county:
reviewlist = reviewlist.filter_by(project_address1=_county)
reviewlist = reviewlist.order_by("apply_time desc").all()
for review in reviewlist:
review.project_address2 = (
COUNTY_CHOICES.__getitem__(review.project_address1 - 1)[1] + "-" + review.project_address2
)
review.examine_time = review.examine_time.strftime("%Y-%m-%d")
review.apply_time = review.apply_time.strftime("%Y-%m-%d")
if action == "export":
return redirect(review_excel_created(reviewlist))
pagination = Pagination(reviewlist, page, pagesize)
reviewlist = pagination.list()
return render_template(
"/examine/reviewlist.html",
reviewlist=reviewlist,
countys=COUNTY_CHOICES,
pagination=pagination,
page=page,
page_size=pagesize,
_county=str(_county),
)
