def get(self):
user = users.get_current_user()
if not user:
return self.redirect('/admin/index')
page = self.request.get('page')
try:
page = int(page) - 1
except:
page = 0
userid = self.request.get('userid')
datas = User.get_by_id(long(userid))
paginator = ObjectPaginator(datas.picture_set, PICTUREPAGE)
if page >= paginator.pages:
page = paginator.pages - 1
params = {
"datas": paginator.get_page(page),
"pages": range(1, paginator.pages + 1),
"page": page + 1,
"userid": datas
}
fpath = os.path.join(os.path.dirname(__file__), 'template/admin/user',
'showpicture.html')
html = template.render(fpath, params)
self.response.out.write(html)
return
def get(self):
user = users.get_current_user()
if not user:
return self.redirect('/admin/index')
page = self.request.get('page')
zoomFlg = self.request.get('zoomFlg')
searchLabel = self.request.get('searchLabel')
try:
page = int(page) - 1
except:
page = 0
if searchLabel != "":
datas = Picture.gql("WHERE label =:1", searchLabel)
else:
datas = Picture.all()
paginator = ObjectPaginator(datas, PAGE)
if page >= paginator.pages:
page = paginator.pages - 1
params = {
"datas": paginator.get_page(page),
"pages": range(1, paginator.pages + 1),
"page": page + 1,
'zoomFlg': zoomFlg,
'searchLabel': searchLabel
}
fpath = os.path.join(os.path.dirname(__file__),
'template/admin/picture', 'list.html')
html = template.render(fpath, params)
self.response.out.write(html)
return
def buildListHTML(self, pageNumber, propertyName, parent):
modelClass, modelClassName = self.modelClass, self.modelClassName
modelClassDisplayName = modelClass.getPrettyClassName()
if propertyName and parent:
gql = 'WHERE %s = :1 ORDER BY %s' % (propertyName,
modelClass.NAME_PROPERTY)
#logging.debug(gql + '(' + parent + ')')
models = (propertyName and modelClass.gql(
gql, db.get(parent))) or modelClass.get()
else:
models = modelClass.all()
paginator = ObjectPaginator(models, 10, orphans=2)
if paginator.pages < pageNumber:
pageNumber = paginator.pages
pageNumber0 = pageNumber - 1
models = paginator.get_page(pageNumber0)
firstOnPage, lastOnPage, numModels = \
paginator.first_on_page(pageNumber0), paginator.last_on_page(pageNumber0), paginator.hits
hasPreviousPage, hasNextPage = \
paginator.has_previous_page(pageNumber0), paginator.has_next_page(pageNumber0)
previousPage, nextPage = pageNumber - 1, pageNumber + 1
listItems = []
for model in models:
modelToListItemHTML = \
lambda model, s=self, p=parent, pn=propertyName: s.modelToListItemHTML(model,p,pn)
cacheKey = 'listItemHTML' + parent
self.modelClass.setEntityCacheFunctionForKey(
modelToListItemHTML, cacheKey)
listItems.append(model.getEntityCache(cacheKey))
listItems = '\n'.join(listItems)
return self.renderManagementTemplate(locals(), 'List.html')
def _getPagenator(selection, page):
try:
current = int(page)
except:
current = 1
paginator = ObjectPaginator(selection, PAGESIZE)
maxpage = paginator.pages + 1
if current >= maxpage:
current = maxpage - 1
elif current <= 0:
current = 1
if(current > PAGERANGE):
start = current - round(PAGERANGE / 2)
else:
start = 1
end = start + PAGERANGE
if end > maxpage:
end = maxpage
paginator.items = paginator.get_page(current - 1)
paginator.range = range(start, end)
paginator.current = current
paginator.previous = current - 1
paginator.next = current + 1
return paginator
def __init__(self, searchResults, handler, title, user):
self.user, self.handler = user, handler
self.rootNode = rootNode = ElementTree.Element('SearchResults')
ElementTree.ElementTree.__init__(self, rootNode)
rootNode.set('title', title)
rootNode.set('pagelessUrl', self.getPagelessUrlFromHandler(handler))
# Don't limit the number of results if viewing the characters in a campaign.
hitsPerPage = handler.request.get('campaign', None) and 100 or self.HITS_PER_PAGE
paginator = ObjectPaginator(searchResults, hitsPerPage, orphans=self.ORPHANS_PER_PAGE)
pageNumber = int(handler.request.get('p', '1'))
numPages = paginator.pages
pageNumber = min(numPages, pageNumber)
pageNumber0 = pageNumber - 1
firstOnPage, lastOnPage, numResults = \
paginator.first_on_page(pageNumber0), paginator.last_on_page(pageNumber0), paginator.hits
firstOnPage = lastOnPage and firstOnPage or 0 # so firstOnPage isn't 1 when there are 0 results
localVars = locals()
for thisVar in ('numResults', 'numPages', 'pageNumber', 'firstOnPage', 'lastOnPage'):
rootNode.set(thisVar, str(localVars[thisVar]))
try:
[ self.addResult(thisResult, user) for thisResult in paginator.get_page(pageNumber0) ]
except AttributeError:
raise
raise RuntimeError, 'expecting searchResults, got %(searchResults)r' % locals()
def getModelPageNumber(self, model):
modelKey = model.key()
allModels = self.modelClass.get()
paginator = ObjectPaginator(allModels, 10, orphans=2)
for pageNumber in range(paginator.pages):
for thisModel in paginator.get_page(pageNumber):
if thisModel.key() == modelKey:
return pageNumber
def changes(request,
asset_type=None,
asset_id=None,
current_user=True,
page_number=0,
num_per_page=10):
"""Return a paginated list of recent asset changes,
filtered in the following ways:
- If 'asset_type' and 'asset_id' are supplied, this limits
the changes to those from a single asset.
- If 'current_user' is set, this only shows changes to objects
that are owned by the currently logged-in user.
This returns a JSON result which is used by client-side
pagination code.
"""
changes = models.AssetChangeset.objects.all()
if asset_id is not None:
changes = changes.filter(
content_type=ContentType.objects.get_for_model(
get_asset_by_type(asset_type)),
object_id=int(asset_id),
)
if current_user:
changes = changes.extra(
tables=["accounts_userasset"],
where=[
"accounts_userasset.content_type_id = accounts_assetchangeset.content_type_id",
"accounts_userasset.object_id = accounts_assetchangeset.object_id",
"accounts_userasset.user_id = %d" % request.user.id
],
)
paginator = ObjectPaginator(changes.order_by('-id'),
num_per_page=num_per_page,
orphans=num_per_page / 2)
return {
'remaining':
paginator.hits - paginator.last_on_page(page_number),
'html':
smart_unicode(
loader.render_to_string(
'accounts/asset_changes.html',
RequestContext(
request, {
'changesets': paginator.get_page(page_number),
'show_asset_name': asset_id is None,
}))),
}
def list(self, request, queryset, page=None):
"""
Renders a list of model objects to HttpResponse.
"""
template_name = '%s/%s_list.html' % (self.template_dir,
queryset.model._meta.module_name)
if self.paginate_by:
paginator = ObjectPaginator(queryset, self.paginate_by)
if not page:
page = request.GET.get('page', 1)
try:
page = int(page)
object_list = paginator.get_page(page - 1)
except (InvalidPage, ValueError):
if page == 1 and self.allow_empty:
object_list = []
else:
raise Http404
c = RequestContext(
request, {
'%s_list' % self.template_object_name: object_list,
'is_paginated': paginator.pages > 1,
'results_per_page': self.paginate_by,
'has_next': paginator.has_next_page(page - 1),
'has_previous': paginator.has_previous_page(page - 1),
'page': page,
'next': page + 1,
'previous': page - 1,
'last_on_page': paginator.last_on_page(page - 1),
'first_on_page': paginator.first_on_page(page - 1),
'pages': paginator.pages,
'hits': paginator.hits,
}, self.context_processors)
else:
object_list = queryset
c = RequestContext(
request, {
'%s_list' % self.template_object_name: object_list,
'is_paginated': False
}, self.context_processors)
if not self.allow_empty and len(queryset) == 0:
raise Http404
# Hide unexposed fields
for obj in object_list:
self._hide_unexposed_fields(obj, self.expose_fields)
c.update(self.extra_context)
t = self.template_loader.get_template(template_name)
return HttpResponse(t.render(c), mimetype=self.mimetype)
def __init__(self,
queryset,
request=None,
pageno=1,
paginate_by=15,
urlprefix='',
urlnames=urlnames):
if isinstance(queryset, QuerySet):
self.queryset = queryset
else:
self.queryset = QuerysetWrapper(queryset)
self.paginate_by = paginate_by
self.request = request
self.urlprefix = urlprefix
self.urlname = urlnames
self.pageno = pageno
paginator = ObjectPaginator(self.queryset, paginate_by)
lastpage = math.ceil(1.0 * self.queryset.count() / paginate_by)
if self.request:
page = self.request.GET.get('page', 1)
else:
page = self.pageno
try:
if isinstance(page, str):
if not page.isdigit():
page = 'last'
page = lastpage
page = int(page)
if page > lastpage:
page = lastpage
object_list = paginator.get_page(page - 1)
except (InvalidPage, ValueError):
object_list = []
self.is_paginated = paginator.pages > 1
self.results_per_page = paginate_by
self.has_next = paginator.has_next_page(page - 1)
self.has_previous = paginator.has_previous_page(page - 1)
self.page = page
self.next = page + 1
self.previous = page - 1
self.pages = paginator.pages
self.hits = paginator.hits
self.object_list = object_list
def list(self, request, queryset, page=None):
"""
Renders a list of model objects to HttpResponse.
"""
if self.paginate_by:
paginator = ObjectPaginator(queryset, self.paginate_by)
if not page:
page = request.GET.get('page', 1)
try:
page = int(page)
object_list = paginator.get_page(page - 1)
except (InvalidPage, ValueError):
if page == 1 and self.allow_empty:
object_list = []
else:
return self.error(request, 404)
else:
object_list = list(queryset)
return HttpResponse(self.render(object_list), self.mimetype)
def get_results(self, request):
paginator = ObjectPaginator(self.query_set,
self.lookup_opts.admin.list_per_page)
# Get the number of objects, with admin filters applied.
try:
result_count = paginator.hits
# Naked except! Because we don't have any other way of validating
# "params". They might be invalid if the keyword arguments are
# incorrect, or if the values are not in the correct type (which would
# result in a database error).
except:
raise IncorrectLookupParameters
# Get the total number of objects, with no admin filters applied.
# Perform a slight optimization: Check to see whether any filters were
# given. If not, use paginator.hits to calculate the number of objects,
# because we've already done paginator.hits and the value is cached.
if isinstance(self.query_set._filters,
models.Q) and not self.query_set._filters.kwargs:
full_result_count = result_count
else:
full_result_count = self.manager.count()
can_show_all = result_count <= MAX_SHOW_ALL_ALLOWED
multi_page = result_count > self.lookup_opts.admin.list_per_page
# Get the list of objects to display on this page.
if (self.show_all and can_show_all) or not multi_page:
result_list = list(self.query_set)
else:
try:
result_list = paginator.get_page(self.page_num)
except InvalidPage:
result_list = ()
self.result_count = result_count
self.full_result_count = full_result_count
self.result_list = result_list
self.can_show_all = can_show_all
self.multi_page = multi_page
self.paginator = paginator
def generatePagination(baseUrl, attrs, objects, pageSize):
"""generates division to pages of objects
:Parameters:
baseUrl: base url where pages should point
attrs: attributes to put to other page links (should contain current page number)
objects: all objects to split to pages
pageSize: number of objects to display on one page
:Return:
tuple (htmlCode, objectSubset): htmlCode contains links to other pages and current page num
objectSubset is subset of objects for current page
"""
html = ""
try:
page = int(attrs['page']) - 1
except KeyError:
page = 0
baseAddr = generateAddress(baseUrl, attrs, 'page')
pagination = ObjectPaginator(objects, pageSize)
if page < 0 or page >= pagination.pages:
page = 0
html += "page " + str(page + 1) + " of " + str(pagination.pages) + "<br/>"
html += "pages: "
for pgnum in pagination.page_range:
html += " "
if pgnum -1 == page:
html += str(pgnum)
else:
html += "<a href=\""+ baseAddr + "page=" + str(pgnum) + "&\">" + \
str(pgnum) + "</a>"
html += " "
return (html, pagination.get_page(page))
def __init__(self, searchResults, handler, title, user):
self.user, self.handler = user, handler
self.rootNode = rootNode = ElementTree.Element('SearchResults')
ElementTree.ElementTree.__init__(self, rootNode)
pagelessUrl = self.getPagelessUrlFromHandler(handler)
# Don't limit the number of results if viewing the characters in a campaign.
hitsPerPage = handler.request.get('campaign',
None) and 100 or self.HITS_PER_PAGE
pageNumber = int(handler.request.get('p', '1'))
paginator = ObjectPaginator(searchResults,
hitsPerPage,
orphans=self.ORPHANS_PER_PAGE)
numResults = paginator.count
if numResults:
page = paginator.page(pageNumber)
object_list = page.object_list
firstOnPage, lastOnPage, numPages = page.start_index(
), page.end_index(), paginator.num_pages
else:
object_list = []
firstOnPage = lastOnPage = 0
numPages = 1
localVars = locals()
for thisVar in ('title', 'pagelessUrl', 'numResults', 'numPages',
'pageNumber', 'firstOnPage', 'lastOnPage'):
rootNode.set(thisVar, str(localVars[thisVar]))
try:
[self.addResult(thisResult, user) for thisResult in object_list]
except AttributeError:
raise
raise RuntimeError, 'expecting searchResults, got %(searchResults)r' % locals(
)
def object_list(request,
queryset,
paginate_by=None,
page=None,
allow_empty=False,
template_name=None,
template_loader=loader,
extra_context=None,
context_processors=None,
template_object_name='object',
mimetype=None):
"""
Generic list of objects.
Templates: ``<app_label>/<model_name>_list.html``
Context:
object_list
list of objects
is_paginated
are the results paginated?
results_per_page
number of objects per page (if paginated)
has_next
is there a next page?
has_previous
is there a prev page?
page
the current page
next
the next page
previous
the previous page
pages
number of pages, total
hits
number of objects, total
last_on_page
the result number of the last of object in the
object_list (1-indexed)
first_on_page
the result number of the first object in the
object_list (1-indexed)
"""
if extra_context is None: extra_context = {}
queryset = queryset._clone()
if paginate_by:
paginator = ObjectPaginator(queryset, paginate_by)
if not page:
page = request.GET.get('page', 1)
try:
page = int(page)
object_list = paginator.get_page(page - 1)
except (InvalidPage, ValueError):
if page == 1 and allow_empty:
object_list = []
else:
raise Http404
c = RequestContext(
request, {
'%s_list' % template_object_name: object_list,
'is_paginated': paginator.pages > 1,
'results_per_page': paginate_by,
'has_next': paginator.has_next_page(page - 1),
'has_previous': paginator.has_previous_page(page - 1),
'page': page,
'next': page + 1,
'previous': page - 1,
'last_on_page': paginator.last_on_page(page - 1),
'first_on_page': paginator.first_on_page(page - 1),
'pages': paginator.pages,
'hits': paginator.hits,
}, context_processors)
else:
c = RequestContext(request, {
'%s_list' % template_object_name: queryset,
'is_paginated': False
}, context_processors)
if not allow_empty and len(queryset) == 0:
raise Http404
for key, value in extra_context.items():
if callable(value):
c[key] = value()
else:
c[key] = value
if not template_name:
model = queryset.model
template_name = "%s/%s_list.html" % (model._meta.app_label,
model._meta.object_name.lower())
t = template_loader.get_template(template_name)
return HttpResponse(t.render(c), mimetype=mimetype)
def get(self):
self.session = Session()
if CheckAuth(self) is False:
return DoAuth(self, '/writer/overview')
site_domain = Datum.get('site_domain')
site_domain_sync = Datum.get('site_domain_sync')
site_name = Datum.get('site_name')
site_author = Datum.get('site_author')
site_slogan = Datum.get('site_slogan')
site_analytics = Datum.get('site_analytics')
if site_domain is None:
site_domain = os.environ['HTTP_HOST']
Datum.set('site_domain', os.environ['HTTP_HOST'])
if site_domain_sync is None:
site_domain_sync = os.environ['HTTP_HOST']
Datum.set('site_domain_sync', os.environ['HTTP_HOST'])
articles = memcache.get('writer_articles')
if articles is None:
articles = Article.all().order('-created')
memcache.set('writer_articles', articles, 86400)
paginator = ObjectPaginator(articles, PAGE_SIZE)
try:
page = int(self.request.get('page', 0))
articles = paginator.get_page(page)
except InvalidPage:
articles = paginator.get_page(int(paginator.pages - 1))
if paginator.pages > 1:
is_paginated = True
else:
is_paginated = False
if site_domain is None or site_name is None or site_author is None:
site_configured = False
else:
site_configured = True
if is_paginated:
self.session['page'] = page
urls = memcache.get('writer_urls')
if urls is None:
everything = Article.all().order('-title_url')
urls = []
for article in everything:
urls.append(article.title_url)
memcache.set('writer_urls', urls, 86400)
template_values = {
'site_configured': site_configured,
'is_paginated': is_paginated,
'page_size': PAGE_SIZE,
'page_has_next': paginator.has_next_page(page),
'page_has_previous': paginator.has_previous_page(page),
'page': page,
'next': page + 1,
'previous': page - 1,
'pages': paginator.pages,
'articles': articles,
'articles_total': len(articles),
'page_range': range(0, paginator.pages),
'urls': urls
}
if site_analytics is not None:
template_values['site_analytics'] = site_analytics
if site_domain_sync is None:
q = site_domain
else:
q = site_domain + ' OR ' + site_domain_sync
mentions_web = memcache.get('mentions_web')
if mentions_web is None:
try:
mentions_web = feedparser.parse(
'http://blogsearch.google.com/blogsearch_feeds?hl=en&q=' +
urllib.quote('link:' + Datum.get('site_domain')) +
'&ie=utf-8&num=10&output=atom')
memcache.add('mentions_web', mentions_web, 600)
except:
mentions_web = None
if mentions_web is not None:
template_values['mentions_web'] = mentions_web.entries
mentions_twitter = memcache.get('mentions_twitter')
if mentions_twitter is None:
try:
result = urlfetch.fetch(TWITTER_API_ROOT + 'search.json?q=' +
urllib.quote(q))
if result.status_code == 200:
mentions_twitter = simplejson.loads(result.content)
memcache.add('mentions_twitter', mentions_twitter, 600)
except:
mentions_twitter = None
if mentions_twitter is not None:
if len(mentions_twitter['results']) > 0:
template_values['mentions_twitter'] = mentions_twitter[
'results']
template_values['system_version'] = VERSION
if 'message' in self.session:
template_values['message'] = self.session['message']
del self.session['message']
path = os.path.join(os.path.dirname(__file__), 'tpl', 'writer',
'overview.html')
self.response.out.write(template.render(path, template_values))
def get(self):
user = users.get_current_user()
if not user:
return self.redirect('/admin/index')
cookie = SimpleCookie(os.environ.get('HTTP_COOKIE', ''))
#############PICTURE#######################
picturepage = self.request.get('picturepage')
if picturepage == '':
if cookie.has_key('picturepage'):
picturepage = cookie['picturepage'].value.decode('utf-8')
else:
cookie['picturepage'] = picturepage.encode('utf-8')
cookie['picturepage']['expires'] = 3600
try:
picturepage = int(picturepage) - 1
except:
picturepage = 0
userid = self.request.get('userid')
datas = User.get_by_id(long(userid))
params = {'datas': datas}
paginator = ObjectPaginator(datas.picture_set, PICTUREPAGE)
if picturepage >= paginator.pages:
picturepage = paginator.pages - 1
##############PICTURE_END#####################
##############ALBUM#########################
albumpage = self.request.get('albumpage')
if albumpage == '':
if cookie.has_key('albumpage'):
albumpage = cookie['albumpage'].value.decode('utf-8')
else:
cookie['albumpage'] = albumpage.encode('utf-8')
cookie['albumpage']['expires'] = 3600
print cookie.output()
try:
albumpage = int(albumpage) - 1
except:
albumpage = 0
albumpaginator = ObjectPaginator(datas.album_set, ALBUMPICTURE)
if albumpage >= albumpaginator.pages:
albumpage = albumpaginator.pages - 1
params = {
"datas": paginator.get_page(picturepage),
"picturepages": range(1, paginator.pages + 1),
"picturepage": picturepage + 1,
"userid": datas,
"albumdatas": albumpaginator.get_page(albumpage),
"albumpages": range(1, albumpaginator.pages + 1),
"albumpage": albumpage + 1
}
fpath = os.path.join(os.path.dirname(__file__), 'template/admin/user',
'showalbum.html')
html = template.render(fpath, params)
self.response.out.write(html)
return
def get(self):
user = users.get_current_user()
if user is None:
return self.redirect('/index')
else:
logout_link = users.create_logout_url(PROTOCOLHTTP + DOMAIN +
"/index")
page = self.request.get('page')
zoomFlg = self.request.get('zoomFlg')
searchLabel = self.request.get('searchLabel')
picturHandlerePage = self.request.get('picturHandlerePage')
delFlg = self.request.get('delFlg')
cookie = SimpleCookie(os.environ.get('HTTP_COOKIE', ''))
if delFlg != "1":
if searchLabel != "":
cookie['picturHandlerePage'] = ""
cookie['searchLabel'] = searchLabel.encode('utf-8')
cookie['searchLabel']['expires'] = 3600
print cookie.output()
else:
if cookie.has_key('searchLabel'):
searchLabel = cookie['searchLabel'].value.decode('utf-8')
else:
searchLabel = ""
picturHandlerePage = ""
cookie['searchLabel'] = ""
cookie['picturHandlerePage'] = ""
print cookie.output()
#############PICTURE#######################
if picturHandlerePage == '':
if cookie.has_key('picturHandlerePage'):
picturHandlerePage = cookie['picturHandlerePage'].value.decode(
'utf-8')
else:
cookie['picturHandlerePage'] = picturHandlerePage.encode('utf-8')
cookie['picturHandlerePage']['expires'] = 3600
print cookie.output()
try:
picturHandlerePage = int(picturHandlerePage) - 1
except:
picturHandlerePage = 0
email = user.email()
userData = db.GqlQuery("SELECT * FROM User WHERE email='" + email +
"'")
for user in userData:
userid = user.key().id()
userDatas = User.get_by_id(long(userid))
userPictureDatas = userDatas.picture_set
datas = list()
keyList = list()
for PictureData in userPictureDatas:
keyList.append(PictureData.key().id())
if searchLabel != "":
PictureDatas = Picture.gql("WHERE label =:1", searchLabel)
for PictureData in PictureDatas:
if PictureData.key().id() in keyList:
datas.append(PictureData)
else:
for upd in userPictureDatas:
datas.append(upd)
datas.sort(key=operator.attrgetter('registerDate'))
datas.reverse()
pictureCount = len(datas)
pagerFlg = 0
if pictureCount > PAGE:
pagerFlg = 1
lastPage = int(math.ceil(float(pictureCount) / PAGE))
if picturHandlerePage > lastPage:
picturHandlerePage = lastPage
#pager
#now page picturepage+1
#last page paginator.pages+1
page1 = 1
if picturHandlerePage + 1 > 2:
page1 = picturHandlerePage + 1 - 1
elif picturHandlerePage + 1 > 3:
page1 = picturHandlerePage + 1 - 2
if picturHandlerePage + 1 == lastPage + 1:
page1 = page1 - 3
elif picturHandlerePage == lastPage + 1:
page1 = page1 - 2
if page1 < 2:
page1 = 2
pages = range(page1 - 1, lastPage + 1)
paginator = ObjectPaginator(datas, PAGE)
if picturHandlerePage >= paginator.pages:
picturHandlerePage = paginator.pages - 1
if user:
loginFlg = 1
params = {
"datas": paginator.get_page(picturHandlerePage),
"pages": pages,
"page": picturHandlerePage + 1,
"prev": picturHandlerePage,
"next": picturHandlerePage + 2,
"pagerFlg": pagerFlg,
"lastpage": lastPage,
'zoomFlg': zoomFlg,
'searchLabel': searchLabel,
'loginFlg': loginFlg,
'logout_link': logout_link
}
fpath = os.path.join(os.path.dirname(__file__),
'template/user/picture', 'list.html')
html = template.render(fpath, params)
self.response.out.write(html)
return
def get(self):
try:
user = users.get_current_user()
formList = [
'searchValue',
'prefecture',
'line',
'station',
'category',
'hicategory',
'searchflg'
]
formData={}
cnt = 0
cateFlg = 0
noneFlg = 0
searchFlg = 0
stationFlg = 0
for roopList in formList:
if self.request.get(roopList) !="":
cnt += 1
formData[roopList] = self.request.get(roopList)
if formData["category"] =="":
if formData["hicategory"] != "":
formData["category"] = formData["hicategory"]
cookie = SimpleCookie(os.environ.get('HTTP_COOKIE', ''))
if formData["searchflg"] == "1":
cookie["searchValue"]=""
cookie["prefecture"]=""
cookie["line"]=""
cookie["station"]=""
if formData["searchValue"] != "":
cookie["searchValue"] = formData["searchValue"].encode('utf-8')
cookie['searchValue']['expires'] = 3600
else:
if cookie.has_key("searchValue"):
formData["searchValue"] = cookie["searchValue"].value.decode('utf-8')
if formData["prefecture"] != "":
cookie["prefecture"] = formData["prefecture"].encode('utf-8')
cookie["prefecture"]["expires"] = 3600
else:
if cookie.has_key("prefecture"):
formData["prefecture"] = cookie["prefecture"].value.decode('utf-8')
if formData["line"] != "":
cookie["line"] = formData["line"].encode('utf-8')
cookie["line"]["expires"] = 3600
else:
if cookie.has_key("line"):
formData["line"] = cookie["line"].value.decode('utf-8')
if formData["station"] != "":
cookie["station"] = formData["station"].encode('utf-8')
cookie["station"]["expires"] = 3600
else:
if cookie.has_key("station"):
formData["station"] = cookie["station"].value.decode('utf-8')
print cookie.output()
#Defaulut
todayTime = str(date.today())
yesterdayTime = date.today()-timedelta(1)
AlbumDatas = list()
if formData["searchValue"] == "" and formData["prefecture"] == "" and formData["line"] == "" and formData["station"] == "":
return self.redirect('/index')
else:
validataKey = list()
searchlist = list()
if formData["searchValue"] != "":
searchlist2 = formData['searchValue'].split(' ')
for sc in searchlist2:
if sc!='':
searchlist.append(sc)
if formData["prefecture"] !="":
prefectureData = Prefecture.gql("WHERE prefecture_name = :1", formData["prefecture"])
for pd in prefectureData:
if pd.prefecture_number != 1:
if len(pd.prefecture_name) == 3:
prefecture = pd.prefecture_name[0:2]
if len(pd.prefecture_name)== 4:
prefecture = pd.prefecture_name[0:3]
searchlist.append(prefecture)
if formData["line"] !="" and formData["station"] =="":
searchlist.append(formData["line"])
if formData["station"] !="":
searchlist.append(formData["station"])
cnt = len(searchlist)
if cnt == 1:
gqlAlbumDatas = Album.gql("WHERE search_index =:1", searchlist[0])
else:
i = 0
searchVal = ""
sqlString = ""
slList = list()
for sl in searchlist:
i+=1
if i==1:
sqlString = "search_index =:"+str(i)
else:
sqlString += " AND search_index =:"+str(i)
slList.append(sl)
if cnt == 2:
gqlAlbumDatas = Album.gql("WHERE "+sqlString, slList[0],slList[1])
elif cnt == 3:
gqlAlbumDatas = Album.gql("WHERE "+sqlString, slList[0],slList[1],slList[2])
elif cnt == 4:
gqlAlbumDatas = Album.gql("WHERE "+sqlString, slList[0],slList[1],slList[2],slList[3])
elif cnt == 5:
gqlAlbumDatas = Album.gql("WHERE "+sqlString, slList[0],slList[1],slList[2],slList[3],slList[4])
elif cnt == 6:
gqlAlbumDatas = Album.gql("WHERE "+sqlString, slList[0],slList[1],slList[2],slList[3],slList[4],slList[5])
elif cnt == 7:
gqlAlbumDatas = Album.gql("WHERE "+sqlString, slList[0],slList[1],slList[2],slList[3],slList[4],slList[5],slList[6])
elif cnt == 8:
gqlAlbumDatas = Album.gql("WHERE "+sqlString, slList[0],slList[1],slList[2],slList[3],slList[4],slList[5],slList[6],slList[7])
elif cnt >= 9:
gqlAlbumDatas = Album.gql("WHERE "+sqlString, slList[0],slList[1],slList[2],slList[3],slList[4],slList[5],slList[6],slList[7],slList[8])
elif cnt >= 10:
gqlAlbumDatas = Album.gql("WHERE "+sqlString, slList[0],slList[1],slList[2],slList[3],slList[4],slList[5],slList[6],slList[7],slList[8],slList[9])
for AlbumData in gqlAlbumDatas:
AlbumDatas.append(AlbumData)
if formData["category"] != "" or formData["category"] == "populer":
filterDatas = list()
if formData["category"] =="today":
for data in AlbumDatas:
strTime = ""
strTime = str(data.updateDate)
if strTime[0:10] == todayTime:
filterDatas.append(data)
if formData["category"] =="spring":
for data in AlbumDatas:
if data.season == 2:
filterDatas.append(data)
elif formData["category"] =="summer":
for data in AlbumDatas:
if data.season == 3:
filterDatas.append(data)
elif formData["category"] =="fall":
for data in AlbumDatas:
if data.season == 4:
filterDatas.append(data)
elif formData["category"] =="winter":
for data in AlbumDatas:
if data.season == 5:
filterDatas.append(data)
elif formData["category"] =="recentPopuler":
kako = date.today()-timedelta(30)
for data in AlbumDatas:
if data.updateDate > kako:
filterDatas.append(data)
AlbumDatas = list()
AlbumDatas = filterDatas
datas = list()
for AlbumData in AlbumDatas:
if AlbumData.user.name is not None:
if AlbumData.user.name !="":
AlbumData.user.nickname = AlbumData.user.name
if AlbumData.picture_counter !=0:
PcaDatas = PictureConnectAlbum.gql("WHERE album = :1 ORDER BY album", AlbumData)
pictureid = 0;
for PcaData in PcaDatas:
try:
PictureDatas = PcaData.picture
pictureid = int(PictureDatas.key().id())
if(pictureid != 0):
break
except:
pictureid=0
if pictureid != 0:
AlbumData.pictureid = pictureid
datas.append(AlbumData)
strList = list()
for data in datas:
if len(data.recital) > 22:
da = data.recital[0:22]
da +="..."
data.subrecital = da
if len(data.title) > 8:
da2 = data.title[0:8]
da2 +="..."
data.subtitle = da2
datas.sort(key=operator.attrgetter('watch_counter'))
datas.reverse()
page = self.request.get("page")
try:
page = int(page) - 1
except:
page = 0
albumCount = len(datas)
pagerFlg = 0
if albumCount > PAGE:
pagerFlg = 1;
lastPage = int(math.ceil(float(albumCount)/PAGE))
if page > lastPage:
page = lastPage
paginator = ObjectPaginator(datas,PAGE)
if page>=paginator.pages:
page = paginator.pages - 1
if user is not None:
loginFlg = 1
#pager
#now page picturepage+1
#last page paginator.pages+1
page1 = 1
if page+1 > 2:
page1 = page+1-1
elif page+1 > 3:
page1 = page+1-2
if page+1 == lastPage+1:
page1 = page1-3
elif page == lastPage+1:
page1 = page1-2
if page1 < 2:
page1 = 2
pages = range(page1-1,lastPage+1)
################selext box######################
PreDatas = Prefecture.all()
prelist = list()
lineDatas = list()
StationDatas = list()
for pd in PreDatas:
prelist.append(pd)
prelist.sort(key=operator.attrgetter("prefecture_number"))
if formData["prefecture"] !="":
lineDatas = self.createLine(formData["prefecture"])
if formData["line"] !="":
StationDatas = self.createStation(formData["line"])
#################create login#######################
user = users.get_current_user()
loginFlg = ""
user_top_link = ""
logout_link = ""
if user is not None:
loginFlg = 1
logout_link = users.create_logout_url(PROTOCOLHTTP+DOMAIN+"/index")
else:
user_top_link = users.create_login_url(PROTOCOLHTTPS+DOMAIN+"/user")
#################create map#######################
prefectureData = Prefecture.gql("WHERE prefecture_number = :1 order by prefecture_number", 26)
for pd in prefectureData:
if pd.prefecture_number != 1:
if len(pd.prefecture_name) == 3:
prefecture = pd.prefecture_name[0:2]
if len(pd.prefecture_name)== 4:
prefecture = pd.prefecture_name[0:3]
gqlAlbumDatas = Album.gql("WHERE search_index =:1 limit 0, 100", prefecture)
sortList = list()
for AlbumData in gqlAlbumDatas:
try:
if AlbumData.picture_counter > 0:
sortList.append(AlbumData)
except:
continue
sortList.sort(key=operator.attrgetter('watch_counter'))
AlbumDatas = list()
AlbumDatas2 = list()
for AlbumData in sortList:
if AlbumData.latitude is not None and AlbumData.longitude is not None:
AlbumDatas2.append(AlbumData)
params = {
"datas" : paginator.get_page(page),
"pages" : pages,
"page" : page+1,
"prev" : page,
"next" : page+2,
"pagerFlg" : pagerFlg,
"lastpage" : lastPage,
"category" : formData["category"],
"searchValue" : formData["searchValue"],
"prefecture" : formData["prefecture"],
"line" : formData["line"],
"station" : formData["station"],
"hicategory" : formData["hicategory"],
"searchflg" : formData["searchflg"],
"AlbumDatas" : AlbumDatas2,
"PreDatas" : prelist,
"lineDatas" : lineDatas,
"user_top_link" : user_top_link,
"logout_link" : logout_link,
"loginFlg" : loginFlg,
"StationDatas" : StationDatas
}
fpath = os.path.join(os.path.dirname(__file__),'template/user','indexsearch.html')
html = template.render(fpath,params)
self.response.out.write(html)
except:
self.errorFunc()
