def progenyimg(request, pid=None):
num_show = 5
page_length = 30
min_pct = 30
role = getRole(request)
if 'newfamily' in request.GET:
family = request.GET['newfamily']
url = "%s?role=%s&family=%s" % (reverse('common:genera'), role, family)
return HttpResponseRedirect(url)
if not pid:
if 'pid' in request.GET:
pid = request.GET['pid']
pid = int(pid)
else:
pid = 0
try:
species = Species.objects.get(pk=pid)
except Species.DoesNotExist:
message = 'This hybrid does not exist! Use arrow key to go back to previous page.'
return HttpResponse(message)
genus = species.genus
des_list = AncestorDescendant.objects.filter(aid=pid).filter(pct__gt= min_pct)
des_list = des_list.order_by('-pct')
img_list = []
for x in des_list:
offspring = Hybrid.objects.get(pk=x.did.pid_id)
y = x.did.pid.get_best_img()
if y:
y.name = offspring.pid.namecasual()
y.pct = x.pct
y.image_dir = y.image_dir()
# y.image_file = y.image_file
# y.author = y.author
# y.source_url = y.source_url
if offspring.pollen_id:
y.pollen = offspring.pollen_id.pid
y.pollen_name = offspring.pollen_id.namecasual()
if offspring.seed_id:
y.seed = offspring.seed_id.pid
y.seed_name = offspring.seed_id.namecasual()
img_list.append(y)
total = len(img_list)
page_range, page_list, last_page, next_page, prev_page, page_length, page, first_item, last_item = mypaginator(
request, img_list, page_length, num_show)
write_output(request, species.textname())
context = {'img_list': page_list, 'species': species, 'tab': 'proimg', 'proimg': 'active',
'total': total,
'num_show': num_show, 'first': first_item, 'last': last_item, 'role': role,
'genus': genus, 'page': page,
'page_range': page_range, 'last_page': last_page, 'next_page': next_page, 'prev_page': prev_page,
'title': 'progenyimg', 'section': 'Public Area',
}
return render(request, 'orchidaceae/progenyimg.html', context)
def curate_newupload(request):
if request.user.is_authenticated and request.user.tier.tier < 2:
return HttpResponseRedirect('/')
file_list = UploadFile.objects.all().order_by('-created_date')
days = 7
num_show = 5
page_length = 20
page_range, page_list, last_page, next_page, prev_page, page_length, page, first_item, last_item = mypaginator(
request, file_list, page_length, num_show)
role = getRole(request)
family = Family.objects.get(pk='Bromeliaceae')
write_output(request)
context = {
'file_list': page_list,
'tab': 'upl',
'role': role,
'upl': 'active',
'days': days,
'family': family,
'page_range': page_range,
'last_page': last_page,
'num_show': num_show,
'page_length': page_length,
'page': page,
'first': first_item,
'last': last_item,
'next_page': next_page,
'prev_page': prev_page,
'app': app,
'title': 'curate_newupload',
'section': 'Curator Corner',
}
return render(request, "common/curate_newupload.html", context)
def information(request, pid=None):
role = getRole(request)
family = 'Orchidaceae'
if pid:
send_url = '/display/information/' + str(pid) + '/?family=' + str(
family) + '&role=' + role
else:
send_url = '/'
return HttpResponseRedirect(send_url)
def curate_pending(request):
# This page is for curators to perform mass delete. It contains all rank 0 photos sorted by date reverse.
if request.user.is_authenticated and request.user.tier.tier < 2:
return HttpResponseRedirect('/')
if not request.user.is_authenticated:
return HttpResponseRedirect('/login/')
ortype = ''
if 'type' in request.GET:
ortype = request.GET['type']
if not ortype:
ortype = 'species'
days = 7
if 'days' in request.GET:
days = int(request.GET['days'])
if not days:
days = 7
file_list = SpcImages.objects.filter(rank=0)
if days:
file_list = file_list.filter(modified_date__gte=timezone.now() -
timedelta(days=days))
file_list = file_list.order_by('-created_date')
num_show = 5
page_length = 100
page_range, page_list, last_page, next_page, prev_page, page_length, page, first_item, last_item = mypaginator(
request, file_list, page_length, num_show)
family = Family.objects.get(pk='Bromeliaceae')
role = getRole(request)
write_output(request)
title = 'curate_pending'
context = {
'file_list': page_list,
'type': ortype,
'tab': 'pen',
'role': role,
'pen': 'active',
'days': days,
'family': family,
'page_range': page_range,
'last_page': last_page,
'num_show': num_show,
'page_length': page_length,
'page': page,
'first': first_item,
'last': last_item,
'next_page': next_page,
'prev_page': prev_page,
'app': app,
'title': title,
}
return render(request, 'common/curate_pending.html', context)
def browse(request):
role = getRole(request)
if 'genus' in request.GET:
genus = request.GET.get('genus')
else:
genus = ''
family = 'Orchidaceae'
send_url = '/common/browse/?genus=' + str(genus) + '&family=' + str(
family) + '&role=' + role + '&display=checked'
return HttpResponseRedirect(send_url)
def curateinfospc(request, pid):
species = Species.objects.get(pk=pid)
genus = species.genus
accepted = Accepted.objects.get(pk=pid)
tab = 'ins'
if 'tab' in request.GET:
tab = request.GET['tab']
role = getRole(request)
distribution_list = Distribution.objects.filter(pid=species.pid)
if request.method == 'POST':
form = AcceptedInfoForm(request.POST, instance=accepted)
if form.is_valid():
spc = form.save(commit=False)
spc.pid = species
# TODO: Put these in form.clean methods
if spc.altitude:
spc.altitude = spc.altitude.replace("\"", "\'\'")
spc.altitude = spc.altitude.replace("\r", "<br>")
if spc.description:
spc.description = spc.description.replace("<br>", "")
# spc.description = spc.description.replace("\"", "\'\'")
spc.description = spc.description.replace("\r", "<br>")
if spc.culture:
spc.culture = spc.culture.replace("<br>", "")
spc.culture = spc.culture.replace("\"", "\'\'")
spc.culture = spc.culture.replace("\r", "<br>")
if spc.comment:
spc.comment = spc.comment.replace("<br>\r", "\r")
spc.comment = spc.comment.replace("\"", "\'\'")
spc.comment = spc.comment.replace("\r", "<br>")
if spc.history:
spc.history = spc.history.replace("<br>", "")
spc.history = spc.history.replace("\"", "\'\'")
spc.history = spc.history.replace("\r", "<br>")
if spc.etymology:
spc.etymology = spc.etymology.replace("<br>", "")
# spc.etymology = spc.etymology.replace("\"", "\'\'")
spc.etymology = spc.etymology.replace("\r", "<br>")
spc.operator = request.user
spc.save()
url = "%s?role=%s&family=%s" % (reverse('display:information', args=(species.pid,)), role, species.gen.family)
return HttpResponseRedirect(url)
else:
return HttpResponse("POST: Somethign's wrong")
else:
accepted = Accepted.objects.get(pk=species.pid)
form = AcceptedInfoForm(instance=accepted)
context = {'form': form, 'genus': genus, 'species': species,
'title': 'curateinfo', 'tab': 'ins', tab: 'active', 'distribution_list': distribution_list,
'role': role,}
return render(request, 'detail/curateinfospc.html', context)
def progeny(request, pid):
direct = ''
role = getRole(request)
if 'newfamily' in request.GET:
family = request.GET['newfamily']
url = "%s?role=%s&family=%s" % (reverse('common:genera'), role, family)
return HttpResponseRedirect(url)
else:
family = Family.objects.get(pk='Orchidaceae')
if 'direct' in request.GET:
direct = request.GET['direct']
try:
species = Species.objects.get(pk=pid)
except Species.DoesNotExist:
message = 'This hybrid does not exist! Use arrow key to go back to previous page.'
return HttpResponse(message)
genus = species.genus
#All descendants
des_list = AncestorDescendant.objects.filter(aid=pid)
# primary
prim_list = Hybrid.objects.filter(Q(seed_id=pid) | Q(pollen_id=pid)).values_list('pid', flat=True)
# Secondary
sec_list = Hybrid.objects.filter(Q(seed_id__in=prim_list) | Q(pollen_id__in=prim_list)).values_list('pid', flat=True)
prim_list = set(prim_list)
sec_list = set(sec_list)
if len(des_list) > 5000:
des_list = des_list.filter(pct__gt=40)
result_list = []
for x in des_list:
if x.did.pid.pid in prim_list:
result_list.append([x,'primary'])
elif x.did.pid.pid in sec_list:
result_list.append([x,'secondary'])
else:
result_list.append([x,''])
# total = des_list.count()
write_output(request, species.textname())
context = {'result_list': result_list, 'species': species, 'family': family,
'tab': 'pro', 'pro': 'active', 'genus': genus, 'direct': direct,
'title': 'progeny', 'section': 'Public Area', 'role': role,
}
return render(request, 'orchidaceae/progeny.html', context)
def uploadfile(request, pid):
role = getRole(request)
if request.user.tier.tier < 2 or not request.user.photographer.author_id:
message = 'You dont have access to upload files. Please update your profile to gain access. ' \
'Or contact [email protected]'
return HttpResponse(message)
species = Species.objects.get(pk=pid)
if species.get_num_img_by_author(request.user.photographer.get_authid()) > 2:
message = 'Each user may upload at most 3 private photos for each species/hybrid. ' \
'Please delete one or more of your photos before uploading a new one.'
return HttpResponse(message)
author, author_list = get_author(request)
try:
species = Species.objects.get(pk=pid)
except Species.DoesNotExist:
message = 'This name does not exist! Use arrow key to go back to previous page.'
return HttpResponse(message)
# app = species.gen.family.application
# Orchid is a speciel case
app = 'detail'
family = species.gen.family
if species.status == 'synonym':
synonym = Synonym.objects.get(pk=pid)
pid = synonym.acc_id
species = Species.objects.get(pk=pid)
form = UploadFileForm(initial={'author': request.user.photographer.author_id, 'role': role})
if request.method == 'POST':
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
write_output(request, species.textname())
spc = form.save(commit=False)
if isinstance(species, Species):
spc.pid = species
spc.type = species.type
spc.user_id = request.user
spc.text_data = spc.text_data.replace("\"", "\'\'")
spc.save()
url = "%s?role=%s&author=%s&family=%s" % (reverse('display:photos', args=(species.pid,)), role,
request.user.photographer.author_id, family)
return HttpResponseRedirect(url)
else:
return HttpResponse('save failed')
context = {'form': form, 'species': species, 'web': 'active',
'author_list': author_list, 'author': author, 'family': family,
'role': role, 'app': app, 'title': 'uploadfile'}
return render(request, app + '/uploadfile.html', context)
def dispatch(request):
pid = ''
send_url = ''
role = getRole(request)
if 'pid' in request.GET:
pid = request.GET['pid']
if 'family' in request.GET:
family = request.GET['family']
if pid:
species = Species
if family == 'Orchidaceae':
send_url = '/detail/information/' + str(pid) + '/'
elif family == 'Bromeliaceae':
send_url = '/bromeliaceae/advanced/?role=' + role
logger.error("send_url = " + send_url + " - family = " + family)
return HttpResponseRedirect(send_url)
def curate_newapproved(request):
# This page is for curators to perform mass delete. It contains all rank 0 photos sorted by date reverse.
species = ''
image = ''
ortype = 'species'
if request.user.is_authenticated and request.user.tier.tier < 2:
return HttpResponseRedirect('/')
if 'type' in request.GET:
ortype = request.GET['type']
# Request to change rank/quality
if 'id' in request.GET:
orid = int(request.GET['id'])
try:
image = SpcImages.objects.get(pk=orid)
except SpcImages.DoesNotExist:
species = ''
if image:
species = Species.objects.get(pk=image.pid_id)
days = 3
if 'days' in request.GET:
days = int(request.GET['days'])
file_list = SpcImages.objects.filter(rank__gt=0).exclude(approved_by=request.user)
if days:
file_list = file_list.filter(created_date__gte=timezone.now() - timedelta(days=days))
file_list = file_list.order_by('-created_date')
if species:
rank_update(request, species)
quality_update(request, species)
num_show = 5
page_length = 20
page_range, page_list, last_page, next_page, prev_page, page_length, page, first_item, last_item = mypaginator(
request, file_list, page_length, num_show)
family = ''
role = getRole(request)
write_output(request)
context = {'file_list': page_list, 'type': ortype,
'tab': 'pen', 'role': role, 'pen': 'active', 'days': days, 'family': family,
'page_range': page_range, 'last_page': last_page, 'num_show': num_show, 'page_length': page_length,
'page': page,
'first': first_item, 'last': last_item, 'next_page': next_page, 'prev_page': prev_page,
'app': app, 'title': 'curate_newapproved',
}
return render(request, 'common/curate_newapproved.html', context)
def progeny_old(request, pid):
alpha = ''
direct = ''
role = getRole(request)
if 'newfamily' in request.GET:
family = request.GET['newfamily']
url = "%s?role=%s&family=%s" % (reverse('common:genera'), role, family)
return HttpResponseRedirect(url)
if 'direct' in request.GET:
direct = request.GET['direct']
try:
species = Species.objects.get(pk=pid)
except Species.DoesNotExist:
message = 'This hybrid does not exist! Use arrow key to go back to previous page.'
return HttpResponse(message)
genus = species.genus
des_list = AncestorDescendant.objects.filter(aid=pid)
if len(des_list) > 5000:
des_list = des_list.filter(pct__gt=20)
if direct:
des_list = des_list.filter(Q(did__seed_id=pid) | Q(did__pollen_id=pid))
if 'alpha' in request.GET:
alpha = request.GET['alpha']
if alpha == 'ALL' or alpha == 'all':
alpha = ''
des_list = des_list.filter(did__pid__species__istartswith=alpha)
total = des_list.count()
write_output(request, species.textname())
context = {'des_list': des_list, 'species': species, 'total': total, 'alpha': alpha, 'alpha_list': alpha_list,
'tab': 'pro', 'pro': 'active', 'genus': genus, 'direct': direct,
'title': 'progeny', 'section': 'Public Area', 'role': role,
}
return render(request, 'orchidaceae/progeny_old.html', context)
def comments(request):
# Handle sort
sort = ''
if request.GET.get('sort'):
sort = request.GET['sort']
sort.lower()
from django.db.models import Max
comment_list = []
com_latest = Comment.objects.values('pid').annotate(latest=Max('created_date'))
if sort == '-latest':
com_latest = com_latest.order_by('-latest')
elif sort == 'latest':
com_latest = com_latest.order_by('latest')
for i in com_latest:
pid = i['pid']
date = i['latest'].date()
spc = Species.objects.get(pk=pid)
com = Comment.objects.filter(pid=pid).order_by('-created_date')[0]
memo = com.memo
if len(memo) > 80:
memo = memo[0: 80] + '...'
send_url = '/detail/' + str(spc.pid) + '/' + spc.type + "_detail"
item = [spc, date, memo, send_url]
comment_list.append(item)
if sort == '-name':
comment_list.sort(key=lambda k: (k[0].name()), reverse=True)
elif sort == 'name':
comment_list.sort(key=lambda k: (k[0].name()))
role = getRole(request)
write_output(request)
context = {'comment_list': comment_list, 'sort': sort, 'role': role,}
return render(request, 'detail/comments.html', context)
def reidentify(request, orid, pid):
source_file_name = ''
role = getRole(request)
old_species = Species.objects.get(pk=pid)
old_family = old_species.gen.family
if role != 'cur':
url = "%s?role=%s&family=%s" % (reverse(
'display:photos', args=(pid, )), role, old_family)
return HttpResponseRedirect(url)
if old_species.status == 'synonym':
synonym = Synonym.objects.get(pk=pid)
pid = synonym.acc_id
old_species = Species.objects.get(pk=pid)
form = SpeciesForm(request.POST or None)
old_img = SpcImages.objects.get(pk=orid)
if request.method == 'POST':
if form.is_valid():
new_pid = form.cleaned_data.get('species')
try:
new_species = Species.objects.get(pk=new_pid)
except Species.DoesNotExist:
url = "%s?role=%s&family=%s" % (reverse(
'display:photos', args=(pid, )), role, old_family)
return HttpResponseRedirect(url)
# If re-idenbtified to same genus. Just change pid
if new_species.genus == old_species.genus:
new_img = SpcImages.objects.get(pk=old_img.id)
new_img.pid = new_species
if source_file_name:
new_img.source_file_name = source_file_name
new_img.pk = None
else:
if old_img.image_file:
new_img = SpcImages(pid=new_species)
from_path = os.path.join(
settings.STATIC_ROOT,
old_img.image_dir() + old_img.image_file)
if new_species.gen.family.application == 'orchidaceae':
to_path = os.path.join(
settings.STATIC_ROOT, "utils/images/" +
str(new_species.gen.family.application) + "/" +
old_img.image_file)
else:
to_path = os.path.join(
settings.STATIC_ROOT,
"utils/images/" + str(new_species.gen.family) +
"/" + old_img.image_file)
os.rename(from_path, to_path)
else:
url = "%s?role=%s&family=%s" % (reverse(
'display:photos',
args=(new_species.pid, )), role, new_family)
return HttpResponseRedirect(url)
if source_file_name:
new_img.source_file_name = source_file_name
new_img.author = old_img.author
new_img.pk = None
new_img.source_url = old_img.source_url
new_img.image_url = old_img.image_url
new_img.image_file = old_img.image_file
new_img.name = old_img.name
new_img.awards = old_img.awards
new_img.variation = old_img.variation
new_img.form = old_img.form
new_img.text_data = old_img.text_data
new_img.description = old_img.description
new_img.created_date = old_img.created_date
# point to the new record, Who requested this change?
new_img.user_id = request.user
# ready to save
new_img.save()
# Delete old record
old_img.delete()
# write_output(request, old_species.textname() + " ==> " + new_species.textname())
url = "%s?role=%s&family=%s" % (reverse(
'display:photos',
args=(new_species.pid, )), role, str(new_species.gen.family))
return HttpResponseRedirect(url)
context = {
'form': form,
'species': old_species,
'img': old_img,
'role': 'cur',
'family': old_family,
}
return render(request, app + '/reidentify.html', context)
def approvemediaphoto(request, pid):
species = Species.objects.get(pk=pid)
if species.status == 'synonym':
synonym = Synonym.objects.get(pk=pid)
pid = synonym.acc_id
species = Species.objects.get(pk=pid)
# Only curator can approve
role = getRole(request)
if role != "cur":
message = 'You do not have privilege to approve photos.'
return HttpResponse(message)
if 'id' in request.GET:
orid = request.GET['id']
orid = int(orid)
else:
message = 'This photo does not exist! Use arrow key to go back to previous page.'
return HttpResponse(message)
try:
upl = UploadFile.objects.get(pk=orid)
except UploadFile.DoesNotExist:
msg = "uploaded file #" + str(orid) + "does not exist"
url = "%s?role=%s&msg=%s" % (reverse('display:photos', args=(species.pid,)), role, msg)
return HttpResponseRedirect(url)
old_name = os.path.join(settings.MEDIA_ROOT, str(upl.image_file_path))
tmp_name = os.path.join("/webapps/static/tmp/", str(upl.image_file_path))
filename, ext = os.path.splitext(str(upl.image_file_path))
if species.type == 'species':
spc = SpcImages(pid=species.accepted, author=upl.author, user_id=upl.user_id, name=upl.name, awards=upl.awards,
source_file_name=upl.source_file_name, variation=upl.variation, form=upl.forma, rank=0,
description=upl.description, location=upl.location, created_date=upl.created_date, source_url=upl.source_url)
spc.approved_by = request.user
hist = SpcImgHistory(pid=Accepted.objects.get(pk=pid), user_id=request.user, img_id=spc.id,
action='approve file')
newdir = os.path.join(settings.STATIC_ROOT, "utils/images/species")
image_file = "spc_"
else:
spc = HybImages(pid=species.hybrid, author=upl.author, user_id=upl.user_id, name=upl.name, awards=upl.awards,
source_file_name=upl.source_file_name, variation=upl.variation, form=upl.forma, rank=0,
description=upl.description, location=upl.location, created_date=upl.created_date, source_url=upl.source_url)
spc.approved_by = request.user
hist = HybImgHistory(pid=Hybrid.objects.get(pk=pid), user_id=request.user, img_id=spc.id, action='approve file')
newdir = os.path.join(settings.STATIC_ROOT, "utils/images/hybrid")
image_file = "hyb_"
image_file = image_file + str(format(upl.pid_id, "09d")) + "_" + str(format(upl.id, "09d"))
new_name = os.path.join(newdir, image_file)
if not os.path.exists(new_name + ext):
try:
shutil.copy(old_name, tmp_name)
shutil.move(old_name, new_name + ext)
except shutil.Error:
# upl.delete()
url = "%s?role=%s" % (reverse('display:photos', args=(species.pid,)), role)
return HttpResponseRedirect(url)
spc.image_file = image_file + ext
else:
i = 1
while True:
image_file = image_file + "_" + str(i) + ext
x = os.path.join(newdir, image_file)
if not os.path.exists(x):
try:
shutil.copy(old_name, tmp_name)
shutil.move(old_name, x)
except shutil.Error:
upl.delete()
url = "%s?role=%s" % (reverse('display:photos', args=(species.pid,)), role)
return HttpResponseRedirect(url)
spc.image_file = image_file
break
i += 1
spc.save()
hist.save()
upl.approved = True
upl.delete(0)
write_output(request, species.textname() + "-" + str(orid))
url = "%s?role=%s" % (reverse('display:photos', args=(species.pid,)), role)
return HttpResponseRedirect(url)
def reidentify(request, orid, pid):
family = Family.objects.get(pk='Orchidaceae')
source_file_name = ''
role = getRole(request)
if role != 'cur':
url = "%s?role=%s&family=%s" % (reverse('display:photos', args=(pid,)), role, family)
return HttpResponseRedirect(url)
old_species = Species.objects.get(pk=pid)
if old_species.status == 'synonym':
synonym = Synonym.objects.get(pk=pid)
pid = synonym.acc_id
old_species = Species.objects.get(pk=pid)
form = SpeciesForm(request.POST or None)
oldtype = old_species.type
logger.error(">>> oldspecies type = " + oldtype)
if old_species.type == 'hybrid':
old_img = HybImages.objects.get(pk=orid)
elif old_species.type == 'species':
old_img = SpcImages.objects.get(pk=orid)
else:
return HttpResponse("image id " + str(orid) + "does not exist")
if request.method == 'POST':
if form.is_valid():
new_pid = form.cleaned_data.get('species')
try:
new_species = Species.objects.get(pk=new_pid)
except Species.DoesNotExist:
url = "%s?role=%s&family=%s" % (reverse('display:photos', args=(pid,)), role, family)
return HttpResponseRedirect(url)
# If re-idenbtified to same type
if new_species.type == old_species.type:
if new_species.type == 'species':
new_img = SpcImages.objects.get(pk=old_img.id)
new_img.pid = new_species.accepted
else:
new_img = HybImages.objects.get(pk=old_img.id)
new_img.pid = new_species.hybrid
hist = ReidentifyHistory(from_id=old_img.id, from_pid=old_species, to_pid=new_species,
user_id=request.user, created_date=old_img.created_date)
if source_file_name:
new_img.source_file_name = source_file_name
new_img.pk = None
else:
if old_img.image_file:
if new_species.type == 'species':
new_img = SpcImages(pid=new_species.accepted)
from_path = "/webapps/static/utils/images/hybrid/" + old_img.image_file
to_path = "/webapps/static/utils/images/species/" + old_img.image_file
else:
new_img = HybImages(pid=new_species.hybrid)
from_path = "/webapps/static/utils/images/species/" + old_img.image_file
to_path = "/webapps/static/utils/images/hybrid/" + old_img.image_file
hist = ReidentifyHistory(from_id=old_img.id, from_pid=old_species, to_pid=new_species,
user_id=request.user, created_date=old_img.created_date)
os.rename(from_path, to_path)
else:
url = "%s?role=%s&family=%s" % (reverse('display:photos', args=(new_species.pid,)), role, family)
return HttpResponseRedirect(url)
if source_file_name:
new_img.source_file_name = source_file_name
new_img.author = old_img.author
new_img.pk = None
new_img.source_url = old_img.source_url
new_img.image_url = old_img.image_url
new_img.image_file = old_img.image_file
new_img.name = old_img.name
new_img.awards = old_img.awards
new_img.variation = old_img.variation
new_img.form = old_img.form
new_img.text_data = old_img.text_data
new_img.description = old_img.description
new_img.created_date = old_img.created_date
# point to a new record
# Who requested this change?
new_img.user_id = request.user
# ready to save
new_img.save()
hist.to_id = new_img.id
hist.save()
# Delete old record
old_img.delete()
write_output(request, old_species.textname() + " ==> " + new_species.textname())
url = "%s?role=%s&family=%s" % (reverse('display:photos', args=(new_species.pid,)), role, family)
return HttpResponseRedirect(url)
context = {'form': form, 'species': old_species, 'img': old_img, 'role': 'cur', 'family': family}
return render(request, 'detail/reidentify.html', context)
def curateinfohyb(request, pid):
if not request.user.is_authenticated:
return HttpResponseRedirect('/login/')
genus = ''
species = ''
if pid:
species = Species.objects.get(pk=pid)
if species.status == 'synonym':
synonym = Synonym.objects.get(pk=species.pid)
species = Species.objects.get(pk=synonym.acc_id)
genus = species.genus
if species.type == 'species':
url = "%s?tab=info" % (reverse('detail:curateinfospc', args=(species.pid,)),)
return HttpResponseRedirect(url)
tab = 'inh'
if 'tab' in request.GET:
tab = request.GET['tab']
role = getRole(request)
hybrid = Hybrid.objects.get(pk=species.pid)
if request.method == 'POST':
a = Hybrid.objects.get(pk=species.pid)
b = Species.objects.get(pk=species.pid)
form = HybridInfoForm(request.POST, instance=a)
spcform = RenameSpeciesForm(request.POST, instance=b)
if form.is_valid():
spcspc = spcform.save(commit=False)
spc = form.save(commit=False)
spc.pid = species
# TODO: Put these in form.clean_description etc... method
if spc.description:
spc.description = spc.description.replace("<br>", "")
spc.description = spc.description.replace("\"", "\'\'")
spc.description = spc.description.replace("\r", "<br>")
if spc.culture:
spc.culture = spc.culture.replace("<br>", "")
spc.culture = spc.culture.replace("\"", "\'\'")
spc.culture = spc.culture.replace("\r", "<br>")
if spc.comment:
spc.comment = spc.comment.replace("<br>\r", "\r")
spc.comment = spc.comment.replace("\"", "\'\'")
spc.comment = spc.comment.replace("\r", "<br>")
if spc.history:
spc.history = spc.history.replace("<br>", "")
spc.history = spc.history.replace("\"", "\'\'")
spc.history = spc.history.replace("\r", "<br>")
if spc.etymology:
spc.etymology = spc.etymology.replace("<br>", "")
spc.etymology = spc.etymology.replace("\"", "\'\'")
spc.etymology = spc.etymology.replace("\r", "<br>")
spcspc.save()
spc.save()
# url = "%s?role=%s&family=Orchidaceae" % (reverse('display:information', args=(pid,)), role)
url = "%s?role=%s&family=%s" % (reverse('display:information', args=(species.pid,)), role, species.gen.family)
return HttpResponseRedirect(url)
else:
return HttpResponse("POST: Somethign's wrong")
else:
form = HybridInfoForm(instance=hybrid)
spcform = RenameSpeciesForm(instance=species)
context = {'form': form, 'spcform': spcform, 'genus': genus, 'species': species,
'tab': 'inh', tab: 'active', 'title': 'curateinfo', 'role': role,
}
return render(request, 'detail/curateinfohyb.html', context)
def hybrid(request):
role = getRole(request)
family = ''
if 'newfamily' in request.GET:
family = request.GET['newfamily']
elif 'family' in request.GET:
family = request.GET['family']
# logger.error(">>> 1 Family = " + str(family))
if family != 'Orchidaceae':
send_url = '/common/hybrid/?family=' + str(family) + '&role=' + role
# print(send_url)
return HttpResponseRedirect(send_url)
type = 'hybrid'
family = Family.objects.get(family='Orchidaceae')
year = ''
year_valid = 0
author = originator = ''
seed, pollen = '', ''
# reqgenus = ''
msg = ''
syn = ''
spc = ''
total = 0
this_species_list = []
# Initialization
if 'spc' in request.GET:
spc = request.GET['spc']
if 'seed' in request.GET:
seed = request.GET['seed']
if 'pollen' in request.GET:
pollen = request.GET['pollen']
seed_genus, prev_seed_genus = getPrev(request, 'seed_genus', 'prev_seed_genus')
pollen_genus, prev_pollen_genus = getPrev(request, 'pollen_genus', 'prev_pollen_genus')
if 'syn' in request.GET:
syn = request.GET['syn']
if 'author' in request.GET:
author = request.GET['author']
if 'originator' in request.GET:
originator = request.GET['originator']
if 'alpha' in request.GET:
alpha = request.GET['alpha']
else:
alpha = ''
if alpha != 'ALL':
alpha = alpha[0:1]
if 'year' in request.GET:
year = request.GET['year']
if valid_year(year):
year_valid = 1
# if alpha or seed_genus or pollen_genus or seed or pollen:
reqgenus, prev_genus = getPrev(request,'genus', 'prev_genus')
if reqgenus or spc or seed or pollen or seed_genus or pollen_genus or year or author or originator or alpha:
genus, this_species_list, intragen_list = getPartialPid(reqgenus, 'hybrid', '')
if syn == 'N':
this_species_list = this_species_list.exclude(status='synonym')
else:
syn = 'Y'
if spc:
this_species_list = this_species_list.filter(species__icontains=spc)
if (reqgenus == prev_genus):
if seed_genus and pollen_genus:
this_species_list = this_species_list.filter(
Q(hybrid__seed_genus=seed_genus) & Q(hybrid__pollen_genus=pollen_genus) | Q(
hybrid__seed_genus=pollen_genus) & Q(hybrid__pollen_genus=seed_genus))
elif seed_genus:
this_species_list = this_species_list.filter(
Q(hybrid__seed_genus=seed_genus) | Q(hybrid__pollen_genus=seed_genus))
elif pollen_genus:
this_species_list = this_species_list.filter(Q(hybrid__seed_genus=pollen_genus)
| Q(hybrid__pollen_genus=pollen_genus))
if seed:
this_species_list = this_species_list.filter(Q(hybrid__seed_species__icontains=seed)
| Q(hybrid__pollen_species__icontains=seed))
if pollen:
this_species_list = this_species_list.filter(Q(hybrid__seed_species__icontains=pollen)
| Q(hybrid__pollen_species__icontains=pollen))
# Building pid ;list
if this_species_list:
if alpha:
if len(alpha) == 1:
this_species_list = this_species_list.filter(species__istartswith=alpha)
if author and not originator:
this_species_list = this_species_list.filter(author__icontains=author)
if author and originator:
this_species_list = this_species_list.filter(Q(author__icontains=author) | Q(originator__icontains=originator))
if originator and not author:
this_species_list = this_species_list.filter(originator__icontains=originator)
if year_valid:
year = int(year)
this_species_list = this_species_list.filter(year=year)
if this_species_list:
total = len(this_species_list)
else:
total = 0
if total > 5000:
msg = 'Your search request generated over 5000 names. Please refine your search criteria.'
this_species_list = this_species_list[0:5000]
total = 5000
genus_list = list(Genus.objects.exclude(status='synonym').values_list('genus', flat=True))
genus_list.sort()
write_output(request, str(reqgenus))
context = {'my_list': this_species_list, 'genus_list': genus_list, 'family': family,
'total': total, 'alpha_list': alpha_list, 'alpha': alpha,
'genus': reqgenus, 'year': year, 'syn': syn,
'author': author, 'originator': originator, 'seed': seed, 'pollen': pollen,
'seed_genus': seed_genus, 'pollen_genus': pollen_genus,
'role': role, 'title': 'taxonomy', 'msg': msg,
}
return render(request, 'orchidaceae/hybrid.html', context)
def compare(request, pid=None):
family = Family.objects.get(pk='Orchidaceae')
role = getRole(request)
if 'newfamily' in request.GET:
family = request.GET['newfamily']
url = "%s?role=%s&family=%s" % (reverse('common:genera'), role, family)
return HttpResponseRedirect(url)
# TODO: Use Species form instead
pid2 = species2 = genus2 = infraspr2 = infraspe2 = author2 = year2 = spc2 = gen2 = ''
spcimg1_list = spcimg2_list = []
if pid:
species = Species.objects.get(pk=pid)
else:
return HttpResponseRedirect('/')
genus = species.genus
# Handfle request. Should use SpcForm instead.
if 'species2' in request.GET:
spc2 = request.GET['species2']
spc2 = spc2.strip()
if 'genus2' in request.GET:
gen2 = request.GET['genus2']
gen2 = gen2.strip()
if 'infraspe2' in request.GET:
infraspe2 = request.GET['infraspe2']
infraspe2 = infraspe2.strip()
if 'infraspr2' in request.GET:
infraspr2 = request.GET['infraspr2']
infraspr2 = infraspr2.strip()
if 'author2' in request.GET:
author2 = request.GET['author2']
author2 = author2.strip()
if 'year2' in request.GET:
year2 = request.GET['year2']
if year2:
year2 = year2.strip()
if pid:
try:
species = Species.objects.get(pk=pid)
pid = species.pid
genus = species.genus
species1 = species
except Species.DoesNotExist:
return HttpResponseRedirect("/")
else:
return HttpResponse("/")
if gen2:
try:
genus2 = Genus.objects.get(genus__iexact=gen2)
except Genus.DoesNotExist:
# Fallback to initial species
message = "genus <b>" + gen2 + '</b> does not exist'
context = {'species1': species1, 'genus1': genus1,
'pid1': species1.pid,
'spcimg1_list': spcimg1_list,
'genus2': gen2, 'species2': spc2, 'infraspr2': infraspr2, 'infraspe2': infraspe2,
'message2': message,
'title': 'compare', 'tab': 'sbs', 'sbs': 'active', 'role': role}
return render(request, 'detail/compare.html', context)
if spc2:
species2 = Species.objects.filter(species__iexact=spc2).filter(genus__iexact=gen2)
if len(species2) == 0:
message = "species, <b>" + str(gen2) + ' ' + spc2 + '</b> does not exist'
context = {'species': species, 'genus': genus, 'pid': pid, # original
'genus1': species1.genus, 'species1': species1, 'spcimg1_list': spcimg1_list,
'genus2': gen2, 'species2': spc2,
'message2': message,
'title': 'compare', 'tab': 'sbs', 'sbs': 'active', 'role': role}
return render(request, 'detail/compare.html', context)
elif len(species2) > 1:
if infraspe2 and infraspr2:
species2 = species2.filter(infraspe__icontains=infraspe2).filter(infraspr__icontains=infraspr2)
else:
species2 = species2.filter(infraspe__isnull=True).filter(infraspr__isnull=True)
if year2:
species2 = species2.filter(year=year2)
if author2:
species2 = species2.filter(author=author2)
if len(species2) == 1: # Found unique species
species2 = species2[0]
pid2 = species2.pid
elif len(species2) > 1: # MULTIPLE SPECIES RETURNED
message = "species, <b>" + str(gen2) + ' ' + spc2 + '</b> returns more than one value. Please specify author name or year to narrow the search.'
context = {'species': species, 'genus': genus, 'pid': pid, # original
'genus2': gen2, 'species2': spc2, 'infraspr2': infraspr2, 'infraspe2': infraspe2,
'message2': message,
'title': 'compare', 'tab': 'sbs', 'sbs': 'active', 'role': role}
return render(request, 'detail/compare.html', context)
else: # length = 0
message = "species, <b>" + str(gen2) + ' ' + spc2 + '</b> returned none'
context = {'species': species, 'genus': genus, 'pid': pid, # original
'genus2': genus, 'species2': species2, 'infraspr2': infraspr2, 'infraspe2': infraspe2,
'message1': message,
'title': 'compare', 'tab': 'sbs', 'sbs': 'active', 'role': role}
return render(request, 'detail/compare.html', context)
else:
species2 = species2[0]
pid2 = species2.pid
else:
pid2 = ''
cross = ''
message1 = message2 = accepted1 = accepted2 = ''
if species2 and species2.status == 'synonym':
pid2 = species2.getAcc()
accepted2 = species2.getAccepted()
if pid2:
cross = Hybrid.objects.filter(seed_id=pid).filter(pollen_id=pid2)
if not cross:
cross = Hybrid.objects.filter(seed_id=pid2).filter(pollen_id=pid)
if cross:
cross = cross[0]
else:
cross = ''
if species.type == 'species':
spcimg1_list = SpcImages.objects.filter(pid=pid).filter(rank__lt=7).order_by('-rank', 'quality', '?')[0: 2]
else:
spcimg1_list = HybImages.objects.filter(pid=pid).filter(rank__lt=7).order_by('-rank', 'quality', '?')[0: 2]
if species2:
if species2.type == 'species':
spcimg2_list = SpcImages.objects.filter(pid=pid2).filter(rank__lt=7).order_by('-rank', 'quality', '?')[0: 2]
else:
spcimg2_list = HybImages.objects.filter(pid=pid2).filter(rank__lt=7).order_by('-rank', 'quality', '?')[0: 2]
msgnogenus = ''
if 'msgnogenus' in request.GET:
msgnogenus = request.GET['msgnogenus']
write_output(request, str(genus) + " " + str(species) + " vs " + str(genus2) + " " + str(species2))
context = {'pid': pid, 'genus': genus, 'species': species, 'family': family,
'pid2': pid2, 'accepted2': accepted2, # pid of accepted species
'spcimg1_list': spcimg1_list,
'genus2': genus2, 'species2': species2, 'spcimg2_list': spcimg2_list,
'cross': cross,
'msgnogenus': msgnogenus, 'message1': message1, 'message2': message2,
'title': 'compare', 'tab': 'sbs', 'sbs': 'active', 'role': role}
return render(request, 'detail/compare.html', context)
def information(request, pid=None):
role = getRole(request)
Genus, Species, Accepted, Hybrid, Synonym, Distribution, SpcImages, HybImages, app, family, subfamily, tribe, subtribe, UploadFile, Intragen = getModels(
request)
ps_list = pp_list = ss_list = sp_list = ()
if 'newfamily' in request.GET:
family = request.GET['newfamily']
url = "%s?role=%s&family=%s" % (reverse('common:genera'), role, family)
return HttpResponseRedirect(url)
max_items = 3000
ancspc_list = []
seedimg_list = []
pollimg_list = []
distribution_list = []
if not pid:
pid = 0
try:
species = Species.objects.get(pk=pid)
except Species.DoesNotExist:
return HttpResponseRedirect('/')
# If pid is a synonym, convert to accept
req_pid = pid
req_species = species
genus = species.gen
display_items = []
synonym_list = Synonym.objects.filter(acc=pid)
pid = species.pid
syn_list = ()
if species.status == 'synonym':
pid = species.getAcc()
species = Species.objects.get(pk=pid)
else:
# Get images of synonyms
syn_list = Synonym.objects.filter(acc_id=req_pid).values_list('spid')
if species.gen.family.family == 'Orchidaceae' and species.type == 'hybrid':
if req_pid != pid: # req_pid is a synonym, just show the synonym
images_list = HybImages.objects.filter(pid=pid).order_by(
'-rank', 'quality', '?')
else:
images_list = HybImages.objects.filter(
Q(pid=pid) | Q(pid__in=syn_list)).order_by(
'-rank', 'quality', '?')
accepted = species.hybrid
else:
if req_pid != pid: # req_pid is a synonym, just show the synonym
images_list = SpcImages.objects.filter(pid=req_pid).order_by(
'-rank', 'quality', '?')
else: # req_pid is accepted species, show the accepted photos and all of its synonyms photos
images_list = SpcImages.objects.filter(
Q(pid=pid) | Q(pid__in=syn_list)).order_by(
'-rank', 'quality', '?')
if species.type == 'species':
accepted = species.accepted
else:
accepted = species.hybrid
# Build display in main table
if images_list:
i_1, i_2, i_3, i_4, i_5, i_7, i_8 = 0, 0, 0, 0, 0, 0, 0
for x in images_list:
if x.rank == 1 and i_1 <= 0:
i_1 += 1
display_items.append(x)
elif x.rank == 2 and i_2 <= 0:
i_2 += 1
display_items.append(x)
elif x.rank == 3 and i_3 <= 1:
i_3 += 1
display_items.append(x)
elif x.rank == 4 and i_4 <= 3:
i_4 += 1
display_items.append(x)
elif x.rank == 5 and i_5 <= 3:
i_5 += 1
display_items.append(x)
elif x.rank == 7 and i_7 <= 2:
i_7 += 1
display_items.append(x)
elif x.rank == 8 and i_8 < 2:
i_8 += 1
display_items.append(x)
# Build parents display for Orchidaceae hybrid only
from orchidaceae.models import AncestorDescendant
seed_list = Hybrid.objects.filter(seed_id=species.pid).order_by(
'pollen_genus', 'pollen_species')
pollen_list = Hybrid.objects.filter(pollen_id=species.pid)
# Remove duplicates. i.e. if both parents are synonym.
temp_list = pollen_list
for x in temp_list:
if x.seed_status() == 'syn' and x.pollen_status() == 'syn':
pollen_list = pollen_list.exclude(pid=x.pid_id)
pollen_list = pollen_list.order_by('seed_genus', 'seed_species')
offspring_list = chain(list(seed_list), list(pollen_list))
offspring_count = len(seed_list) + len(pollen_list)
if offspring_count > max_items:
offspring_list = offspring_list[0:max_items]
if species.type == 'hybrid':
if accepted.seed_id and accepted.seed_id.type == 'species':
seed_obj = Species.objects.get(pk=accepted.seed_id.pid)
seedimg_list = SpcImages.objects.filter(pid=seed_obj.pid).filter(
rank__lt=7).filter(rank__gt=0).order_by(
'-rank', 'quality', '?')[0:3]
elif accepted.seed_id and accepted.seed_id.type == 'hybrid':
seed_obj = Hybrid.objects.get(pk=accepted.seed_id)
if seed_obj:
seedimg_list = HybImages.objects.filter(
pid=seed_obj.pid.pid).filter(rank__lt=7).filter(
rank__gt=0).order_by('-rank', 'quality', '?')[0:3]
assert isinstance(seed_obj, object)
if seed_obj.seed_id:
ss_type = seed_obj.seed_id.type
if ss_type == 'species':
ss_list = SpcImages.objects.filter(
pid=seed_obj.seed_id.pid).filter(
rank__lt=7).filter(rank__gt=0).order_by(
'-rank', 'quality', '?')[:1]
elif ss_type == 'hybrid':
ss_list = HybImages.objects.filter(
pid=seed_obj.seed_id.pid).filter(
rank__lt=7).filter(rank__gt=0).order_by(
'-rank', 'quality', '?')[:1]
if seed_obj.pollen_id:
sp_type = seed_obj.pollen_id.type
if sp_type == 'species':
sp_list = SpcImages.objects.filter(
pid=seed_obj.pollen_id.pid).filter(
rank__lt=7).filter(rank__gt=0).filter(
rank__lt=7).order_by(
'-rank', 'quality', '?')[:1]
elif sp_type == 'hybrid':
sp_list = HybImages.objects.filter(
pid=seed_obj.pollen_id.pid).filter(
rank__lt=7).filter(rank__gt=0).filter(
rank__lt=7).order_by(
'-rank', 'quality', '?')[:1]
# Pollen
if accepted.pollen_id and accepted.pollen_id.type == 'species':
pollen_obj = Species.objects.get(pk=accepted.pollen_id.pid)
pollimg_list = SpcImages.objects.filter(pid=pollen_obj.pid).filter(
rank__lt=7).filter(rank__gt=0).order_by(
'-rank', 'quality', '?')[0:3]
elif accepted.pollen_id and accepted.pollen_id.type == 'hybrid':
pollen_obj = Hybrid.objects.get(pk=accepted.pollen_id)
pollimg_list = HybImages.objects.filter(
pid=pollen_obj.pid.pid).filter(rank__lt=7).filter(
rank__gt=0).order_by('-rank', 'quality', '?')[0:3]
if pollen_obj.seed_id:
ps_type = pollen_obj.seed_id.type
if ps_type == 'species':
ps_list = SpcImages.objects.filter(
pid=pollen_obj.seed_id.pid).filter(rank__lt=7).filter(
rank__gt=0).order_by('-rank', 'quality', '?')[:1]
elif ps_type == 'hybrid':
ps_list = HybImages.objects.filter(
pid=pollen_obj.seed_id.pid).filter(rank__lt=7).filter(
rank__gt=0).order_by('-rank', 'quality', '?')[:1]
if pollen_obj.pollen_id:
pp_type = pollen_obj.pollen_id.type
if pp_type == 'species':
pp_list = SpcImages.objects.filter(
pid=pollen_obj.pollen_id.pid).filter(
rank__lt=7).filter(rank__gt=0).order_by(
'-rank', 'quality', '?')[:1]
elif pp_type == 'hybrid':
pp_list = HybImages.objects.filter(
pid=pollen_obj.pollen_id.pid).filter(
rank__lt=7).filter(rank__gt=0).order_by(
'-rank', 'quality', '?')[:1]
ancspc_list = AncestorDescendant.objects.filter(
did=species.pid).filter(anctype='species').order_by('-pct')
if ancspc_list:
for x in ancspc_list:
img = x.aid.get_best_img()
if img:
x.img = img.image_file
if req_species.status == 'synonym':
# if request pid is a synopnym, return the synonym instance
species = req_species
write_output(request, str(family))
context = {
'pid': species.pid,
'species': species,
'synonym_list': synonym_list,
'accepted': accepted,
'title': 'information',
'tax': 'active',
'q': species.name,
'type': 'species',
'genus': genus,
'display_items': display_items,
'distribution_list': distribution_list,
'family': family,
'offspring_list': offspring_list,
'offspring_count': offspring_count,
'max_items': max_items,
'seedimg_list': seedimg_list,
'pollimg_list': pollimg_list,
'ss_list': ss_list,
'sp_list': sp_list,
'ps_list': ps_list,
'pp_list': pp_list,
'app': app,
'role': role,
'ancspc_list': ancspc_list,
}
return render(request, "display/information.html", context)
def photos(request, pid=None):
Genus, Species, Accepted, Hybrid, Synonym, Distribution, SpcImages, HybImages, app, family, subfamily, tribe, subtribe, UploadFile, Intragen = getModels(
request)
role = getRole(request)
if 'newfamily' in request.GET:
family = request.GET['newfamily']
url = "%s?role=%s&family=%s" % (reverse('common:genera'), role, family)
return HttpResponseRedirect(url)
author, author_list = get_author(request)
if not pid and 'pid' in request.GET:
pid = request.GET['pid']
if pid:
pid = int(pid)
else:
pid = 0
try:
species = Species.objects.get(pk=pid)
except Species.DoesNotExist:
return HttpResponseRedirect('/')
if role == 'pri':
url = "%s?role=%s&family=%s" % (reverse(
'common:myphoto', args=(species.pid, )), role, family)
return HttpResponseRedirect(url)
variety = ''
tail = ''
private_list, public_list, upload_list, myspecies_list, myhybrid_list = getmyphotos(
author, app, species, Species, Synonym, UploadFile, SpcImages,
HybImages, role)
# Happened when a curator request an author photos
# if role == 'cur':
# if author:
# public_list = all_list.filter(rank__gt=0).filter(author=author)
# private_list = all_list.filter(rank=0).filter(author=author)
# else: # anonymous
# public_list = all_list.filter(rank__gt=0)
# upload_list = UploadFile.objects.filter(pid=species.pid)
# if role != 'cur':
# if author:
# upload_list = upload_list.filter(author=author)
if app == 'orchidaceae' and species.type == 'hybrid':
rank_update(request, HybImages)
quality_update(request, HybImages)
else:
rank_update(request, SpcImages)
quality_update(request, SpcImages)
# Handle Variety filter
if 'variety' in request.GET:
variety = request.GET['variety']
if variety == 'semi alba':
variety = 'semialba'
# Extract first term, possibly an infraspecific
parts = variety.split(' ', 1)
if len(parts) > 1:
tail = parts[1]
var = variety
if variety and tail:
public_list = public_list.filter(
Q(variation__icontains=var) | Q(form__icontains=var)
| Q(name__icontains=var)
| Q(source_file_name__icontains=var)
| Q(description__icontains=var)
| Q(variation__icontains=tail) | Q(form__icontains=tail)
| Q(name__icontains=tail) | Q(source_file_name__icontains=tail)
| Q(description__icontains=tail))
elif variety:
public_list = public_list.filter(
Q(variation__icontains=var) | Q(form__icontains=var)
| Q(name__icontains=var)
| Q(source_file_name__icontains=var)
| Q(description__icontains=var))
if public_list:
if var == "alba":
public_list = public_list.exclude(variation__icontains="semi")
public_list = public_list.order_by('-rank', 'quality', '?')
if private_list:
private_list = private_list.order_by('created_date')
write_output(request, str(family))
context = {
'species': species,
'author': author,
'author_list': author_list,
'family': family,
'variety': variety,
'pho': 'active',
'tab': 'pho',
'app': app,
'public_list': public_list,
'private_list': private_list,
'upload_list': upload_list,
'myspecies_list': myspecies_list,
'myhybrid_list': myhybrid_list,
'role': role,
'title': 'photos',
'namespace': 'display',
}
return render(request, 'display/photos.html', context)
def genera(request):
family = 'Orchidaceae'
min_lengenus_req = 2
year = ''
genustype = ''
formula1 = ''
formula2 = ''
status = ''
sort = ''
prev_sort = ''
sf_obj = ''
t = ''
t_obj = ''
st_obj = ''
role = getRole(request)
alpha = ''
if 'alpha' in request.GET:
alpha = request.GET['alpha']
if 'sf' in request.GET:
sf = request.GET['sf']
if sf:
sf_obj = Subfamily.objects.get(pk=sf)
if 't' in request.GET:
t = request.GET['t']
if t:
try:
t_obj = Tribe.objects.get(pk=t)
except Tribe.DoesNotExist:
pass
if not sf_obj:
try:
sf_obj = Subfamily.objects.get(pk=t_obj.subfamily) # back fill subfamily
except Subfamily.DoesNotExist:
pass
if 'st' in request.GET:
st = request.GET['st']
if st:
try:
st_obj = Subtribe.objects.get(pk=st)
except Subtribe.DoesNotExist:
pass
if st_obj:
if not t:
try:
t_obj = Tribe.objects.get(pk=st_obj.tribe.tribe)
except Tribe.DoesNotExist:
pass
if not sf_obj and st_obj.subfamily:
try:
sf_obj = Subfamily.objects.get(pk=st_obj.subfamily)
except Subtribe.DoesNotExist:
pass
# Remove genus choide if subfamily, tribe or subtribe is chosen
if 'genustype' in request.GET:
genustype = request.GET['genustype']
if not genustype:
genustype = 'all'
if 'formula1' in request.GET:
formula1 = request.GET['formula1']
if 'formula2' in request.GET:
formula2 = request.GET['formula2']
if 'status' in request.GET:
status = request.GET['status']
genus_list = Genus.objects.all()
if status == 'synonym':
genus_list = genus_list.filter(status='synonym')
elif genustype == 'hybrid':
genus_list = genus_list.filter(type='hybrid').exclude(status='synonym')
if formula1 != '' or formula2 != '':
genus_list = genus_list.filter(description__icontains=formula1).filter(description__icontains=formula2)
elif genustype == 'species':
# If an intrageneric is chosen, start from beginning.
genus_list = genus_list.filter(type='species').exclude(status='synonym')
if sf_obj or t_obj or st_obj:
if sf_obj and t_obj and st_obj:
genus_list = genus_list.filter(subfamily=sf_obj.subfamily).filter(
tribe=t_obj.tribe).filter(subtribe=st_obj.subtribe)
elif sf_obj and t_obj and not st_obj:
genus_list = genus_list.filter(subfamily=sf_obj.subfamily).filter(tribe=t_obj.tribe)
elif sf_obj and st_obj and not t_obj:
genus_list = genus_list.filter(subfamily=sf_obj.subfamily).filter(subtribe=st_obj.subtribe)
elif sf_obj and not st_obj and not t_obj:
genus_list = genus_list.filter(subfamily=sf_obj.subfamily)
elif t_obj and st_obj and not sf_obj:
genus_list = genus_list.filter(tribe=t_obj.tribe).filter(st=st_obj.subtribe)
elif t_obj and not st_obj and not sf_obj:
genus_list = genus_list.filter(tribe=t_obj.tribe)
elif st_obj and not t_obj and not sf_obj:
genus_list = genus_list.filter(subtribe=st_obj.subtribe)
if alpha and len(alpha) == 1:
genus_list = genus_list.filter(genus__istartswith=alpha)
total = genus_list.count()
# Get Alliances
sf_list = Subfamily.objects.filter(family=family).filter(num_genus__gt=0)
t_list = Tribe.objects.all()
if sf_obj:
t_list = t_list.filter(subfamily=sf_obj.subfamily)
st_list = Subtribe.objects.all()
if t_obj:
st_list = st_list.filter(tribe=t_obj.tribe)
elif sf_obj:
st_list = st_list.filter(subfamily=sf_obj.subfamily)
sf_list = sf_list.order_by('subfamily')
t_list = t_list.order_by('tribe')
st_list = st_list.order_by('subtribe')
genus_lookup = Genus.objects.filter(pid__gt=0).filter(type='species')
context = {'my_list': genus_list, 'total': total, 'genus_lookup': genus_lookup, 'family':family,
'sf_obj': sf_obj, 'sf_list': sf_list, 't_obj': t_obj, 't_list': t_list,
'st_obj': st_obj, 'st_list': st_list,
'title': 'taxonomy', 'genustype': genustype, 'status': status,
'formula1': formula1, 'formula2': formula2, 'alpha': alpha, 'alpha_list': alpha_list,
'sort': sort, 'prev_sort': prev_sort, 'role': role,
}
write_output(request)
return render(request, 'orchidaceae/genera.html', context)
def ancestor(request, pid=None):
if not pid:
if 'pid' in request.GET:
pid = request.GET['pid']
pid = int(pid)
else:
pid = 0
role = getRole(request)
sort = ''
prev_sort = ''
state = ''
if request.GET.get('state'):
state = request.GET['state']
sort.lower()
try:
species = Species.objects.get(pk=pid)
except Species.DoesNotExist:
message = 'This hybrid does not exist! Use arrow key to go back to previous page.'
return HttpResponse(message)
genus = species.gen
if request.GET.get('sort'):
sort = request.GET['sort']
sort.lower()
if sort:
if request.GET.get('prev_sort'):
prev_sort = request.GET['prev_sort']
if prev_sort == sort:
if sort.find('-', 0) >= 0:
sort = sort.replace('-', '')
else:
sort = '-' + sort
else:
# sort = '-' + sort
prev_sort = sort
# List of ancestors in the left panel
anc_list = AncestorDescendant.objects.filter(did=pid)
if sort:
if sort == 'pct':
anc_list = anc_list.order_by('-pct')
elif sort == '-pct':
anc_list = anc_list.order_by('pct')
elif sort == 'img':
anc_list = anc_list.order_by('-aid__num_image')
elif sort == '-img':
anc_list = anc_list.order_by('aid__num_image')
elif sort == 'name':
anc_list = anc_list.order_by('aid__genus', 'aid__species')
elif sort == '-name':
anc_list = anc_list.order_by('-aid__genus', '-aid__species')
for x in anc_list:
x.anctype = "orchidaceae:" + x.anctype
context = {'species': species, 'anc_list': anc_list,
'genus': genus,
'anc': 'active', 'tab': 'anc',
'sort': sort, 'prev_sort': prev_sort,
'title': 'ancestor', 'role': role, 'state': state,
}
write_output(request, species.textname())
return render(request, 'orchidaceae/ancestor.html', context)
def species(request):
role = getRole(request)
family = ''
if 'newfamily' in request.GET:
family = request.GET['newfamily']
elif 'family' in request.GET:
family = request.GET['family']
if family != 'Orchidaceae':
send_url = '/common/species/?family=' + str(family) + '&role=' + role
# print(send_url)
return HttpResponseRedirect(send_url)
family = Family.objects.get(pk='Orchidaceae')
spc = reqgenus = ''
msg = ''
type = 'species'
alpha = ''
subfamily = ''
tribe = ''
subtribe = ''
subfamily_list = []
tribe_list = []
subtribe_list = []
subfamily_obj = ''
tribe_obj = ''
subtribe_obj = ''
syn = ''
genus = ''
this_species_list = []
total = 0
# max_page_length = 1000
# Initialize
if 'genus' in request.GET:
reqgenus = request.GET['genus']
if 'alpha' in request.GET:
alpha = request.GET['alpha']
if 'syn' in request.GET:
syn = request.GET['syn']
if 'subfamily' in request.GET:
subfamily = request.GET['subfamily']
if subfamily:
subfamily_obj = Subfamily.objects.get(subfamily=subfamily)
if 'tribe' in request.GET:
tribe = request.GET['tribe']
if tribe:
tribe_obj = Tribe.objects.get(tribe=tribe)
if 'subtribe' in request.GET:
subtribe = request.GET['subtribe']
if subtribe:
tribe_obj = Subtribe.objects.get(subtribe=subtribe)
if alpha != 'ALL':
alpha = alpha[0: 1]
# initialize subfamily, tribe subtribe
# Get list of affected genus
genus_list = Genus.objects.all()
# Start building th elist
if reqgenus or alpha or subfamily or tribe or subtribe:
genus, this_species_list, intragen_list = getPartialPid(reqgenus, type, '')
# if not subfamily and not reqgenus:
# subfamily = 'Epidendroideae'
if subfamily:
genus_list = genus_list.filter(subfamily=subfamily)
if tribe:
genus_list = genus_list.filter(tribe=tribe)
if subtribe:
genus_list = genus_list.filter(subtribe=subtribe)
genus_list = genus_list.values_list('pid',flat=True)
# logger.error(">>> 1 this species list = " + str(len(this_species_list)))
if syn == 'N':
this_species_list = this_species_list.exclude(status='synonym')
else:
syn = 'Y'
# logger.error(">>> 1 this species list = " + str(len(this_species_list)))
if this_species_list:
this_species_list = this_species_list.filter(gen__in=genus_list)
if alpha:
if len(alpha) == 1:
this_species_list = this_species_list.filter(species__istartswith=alpha)
total = len(this_species_list)
if total > 5000:
msg = 'Your search request generated over 5000 names. Please refine your search criteria.'
this_species_list = this_species_list[0:5000]
total = 5000
subfamily_list = Subfamily.objects.filter(family=family).filter(num_genus__gt=0).order_by('subfamily')
if subfamily_obj:
tribe_list = Tribe.objects.filter(subfamily=subfamily_obj.subfamily).order_by('tribe')
if tribe_obj:
subtribe_list = Subtribe.objects.filter(tribe=tribe_obj.tribe).order_by ('subtribe')
elif subfamily_obj:
subtribe_list = Subtribe.objects.filter(subfamily=subfamily_obj.subfamily).order_by ('subtribe')
write_output(request, str(genus))
context = {'page_list': this_species_list, 'alpha_list': alpha_list, 'alpha': alpha, 'spc': spc,
'role': role, 'total': total, 'family': family, 'genus': genus,
'subfamily': subfamily, 'subfamily_list': subfamily_list,
'tribe': tribe, 'tribe_list': tribe_list,
'subtribe': subtribe, 'subtribe_list': subtribe_list,
'msg': msg,
'syn': syn,
'title': 'taxonomy', 'type': 'species'
}
return render(request, 'orchidaceae/species.html', context)
def uploadweb(request, pid, orid=None):
if not request.user.is_authenticated:
return HttpResponseRedirect('/login/')
if request.user.is_authenticated and request.user.tier.tier < 2:
message = 'You dont have access to upload files. Please update your profile to gain access.'
return HttpResponse(message)
sender = 'web'
try:
species = Species.objects.get(pk=pid)
except Species.DoesNotExist:
return HttpResponse(redirect_message)
# The photo
if species.status == 'synonym':
synonym = Synonym.objects.get(pk=pid)
pid = synonym.acc_id
species = Species.objects.get(pk=pid)
role = getRole(request)
if request.method == 'POST':
if species.type == 'hybrid':
accepted = species.hybrid
form = UploadHybWebForm(request.POST)
elif species.type == 'species':
accepted = species.accepted
form = UploadSpcWebForm(request.POST)
else:
return HttpResponse("image id " + str(orid) + "does not exist")
if form.is_valid():
spc = form.save(commit=False)
if not spc.author and not spc.credit_to:
return HttpResponse("Please select an author, or enter a new name for credit allocation.")
spc.user_id = request.user
spc.pid = accepted
spc.text_data = spc.text_data.replace("\"", "\'\'")
if orid and orid > 0:
spc.id = orid
# set rank to 0 if private status is requested
if spc.is_private is True or request.user.tier.tier < 3:
spc.rank = 0
# If new author name is given, set rank to 0 to give it pending status. Except curator (tier = 3)
if spc.author.user_id and request.user.tier.tier < 3:
if (spc.author.user_id.id != spc.user_id.id) or role == 'pri':
spc.rank = 0
if spc.image_url == 'temp.jpg':
spc.image_url = None
if spc.image_file == 'None':
spc.image_file = None
if spc.created_date == '' or not spc.created_date:
spc.created_date = timezone.now()
spc.save()
# logger.error(" family = " + str(species.gen.family))
url = "%s?role=%s&family=%s" % (reverse('display:photos', args=(species.pid,)),role, species.gen.family)
write_output(request, species.textname())
return HttpResponseRedirect(url)
if not orid: # upload, initialize author. Get image count
if species.type == 'species':
form = UploadSpcWebForm(initial={'author': request.user.photographer.author_id})
else:
form = UploadHybWebForm(initial={'author': request.user.photographer.author_id})
img = ''
else: # update. initialize the form iwht current image
if species.type == 'species':
img = SpcImages.objects.get(pk=orid)
if not img.image_url:
sender = 'file'
img.image_url = "temp.jpg"
else:
sender = 'web'
form = UploadSpcWebForm(instance=img)
else:
img = HybImages.objects.get(pk=orid)
if not img.image_url:
img.image_url = "temp.jpg"
sender = 'file'
else:
sender = 'web'
form = UploadHybWebForm(instance=img)
context = {'form': form, 'img': img, 'sender': sender,
'species': species, 'loc': 'active',
'family': species.gen.family,
'role': role, 'title': 'uploadweb'}
return render(request, 'detail/uploadweb.html', context)
def ancestrytree(request, pid=None):
if not pid:
if 'pid' in request.GET:
pid = request.GET['pid']
pid = int(pid)
else:
pid = 0
role = getRole(request)
try:
species = Species.objects.get(pk=pid)
except Species.DoesNotExist:
message = 'This hybrid does not exist! Use arrow key to go back to previous page.'
return HttpResponse(message)
hybrid = species
s = p = ss = sp = ps = pp = sss = ssp = sps = spp = pss = psp = pps = ppp = ssss = sssp = ssps = sspp = spss =\
spsp = spps = sppp = psss = pssp = psps = pspp = ppss = ppsp = ppps = pppp = None
spc = ''
if species.type == 'hybrid':
hybrid.img = hybdir + get_random_img(hybrid)
if species.hybrid.seed_id and species.hybrid.seed_id.type == 'species':
s = Accepted.objects.get(pk=species.hybrid.seed_id)
s.type = 'species'
s.parent = 'seed'
s.year = s.pid.year
s.img = spcdir + get_random_img(s.pid)
# tree_list = tree_list + (s,)
elif species.hybrid.seed_id and species.hybrid.seed_id.type == 'hybrid':
s = Hybrid.objects.get(pk=species.hybrid.seed_id)
s.type = 'hybrid'
s.parent = 'seed'
s.year = s.pid.year
img = s.pid.get_best_img()
if img:
s.img = hybdir + img.image_file
else:
s.img = imgdir + 'noimage_light.jpg'
# tree_list = tree_list + (s,)
# SS
if s and s.seed_id and s.seed_id.type == 'species':
ss = Accepted.objects.get(pk=s.seed_id)
ss.type = 'species'
ss.parent = 'seed'
ss.year = ss.pid.year
ss.img = spcdir + get_random_img(ss.pid)
# tree_list = tree_list + (ss,)
elif s.seed_id and s.seed_id.type == 'hybrid':
ss = Hybrid.objects.get(pk=s.seed_id)
ss.type = 'hybrid'
ss.parent = 'seed'
ss.year = s.pid.year
ss.img = hybdir + get_random_img(ss.pid)
# tree_list = tree_list + (ss,)
# SSS
if ss.seed_id and ss.seed_id.type == 'species':
sss = Accepted.objects.get(pk=ss.seed_id)
sss.type = 'species'
sss.parent = 'seed'
sss.year = sss.pid.year
sss.img = spcdir + get_random_img(sss.pid)
# tree_list = tree_list + (sss,)
elif ss.seed_id and ss.seed_id.type == 'hybrid':
sss = Hybrid.objects.get(pk=ss.seed_id)
sss.type = 'hybrid'
sss.parent = 'seed'
sss.year = sss.pid.year
sss.img = hybdir + get_random_img(sss.pid)
else:
s = None
# SSP
if ss.pollen_id and ss.pollen_id.type == 'species':
ssp = Accepted.objects.get(pk=ss.pollen_id)
ssp.type = 'species'
ssp.parent = 'pollen'
ssp.year = ssp.pid.year
ssp.img = spcdir + get_random_img(ssp.pid)
# tree_list = tree_list + (ssp,)
elif ss.pollen_id and ss.pollen_id.type == 'hybrid':
ssp = Hybrid.objects.get(pk=ss.pollen_id)
ssp.type = 'hybrid'
ssp.parent = 'pollen'
ssp.year = ssp.pid.year
ssp.img = hybdir + get_random_img(ssp.pid)
# tree_list = tree_list + (ssp,)
# SSPS
if s and s.pollen_id and s.pollen_id.type == 'species':
sp = Accepted.objects.get(pk=s.pollen_id)
sp.type = 'species'
sp.parent = 'pollen'
sp.year = sp.pid.year
sp.img = spcdir + get_random_img(sp.pid)
# tree_list = tree_list + (sp,)
elif s and s.pollen_id and s.pollen_id.type == 'hybrid':
sp = Hybrid.objects.get(pk=s.pollen_id)
sp.type = 'hybrid'
sp.parent = 'seed'
sp.year = sp.pid.year
sp.year = sp.pid.year
sp.img = hybdir + get_random_img(sp.pid)
# tree_list = tree_list + (sp,)
if sp.seed_id and sp.seed_id.type == 'species':
sps = Accepted.objects.get(pk=sp.seed_id)
sps.type = 'species'
sps.year = sps.pid.year
sps.img = spcdir + get_random_img(sps.pid)
# tree_list = tree_list + (sps,)
elif sp.seed_id and sp.seed_id.type == 'hybrid':
sps = Hybrid.objects.get(pk=sp.seed_id)
sps.type = 'hybrid'
sps.year = sps.pid.year
sps.img = hybdir + get_random_img(sps.pid)
# tree_list = tree_list + (sps,)
if sp.pollen_id and sp.pollen_id.type == 'species':
spp = Accepted.objects.get(pk=sp.pollen_id)
spp.type = 'species'
spp.year = spp.pid.year
spp.img = spcdir + get_random_img(spp.pid)
# tree_list = tree_list + (spp,)
elif sp.pollen_id and sp.pollen_id.type == 'hybrid':
spp = Hybrid.objects.get(pk=sp.pollen_id)
spp.type = 'hybrid'
spp.year = spp.pid.year
spp.img = hybdir + get_random_img(spp.pid)
# tree_list = tree_list + (spp,)
# else:
# s = ''
# P - pollenparent
if species.hybrid.pollen_id and species.hybrid.pollen_id.type == 'species':
p = Accepted.objects.get(pk=species.hybrid.pollen_id)
p.type = p.pid.type
p.parent = 'pollen'
p.year = p.pid.year
p.img = spcdir + get_random_img(p.pid)
# tree_list = tree_list + (s,)
elif species.hybrid.pollen_id and species.hybrid.pollen_id.type == 'hybrid':
p = Hybrid.objects.get(pk=species.hybrid.pollen_id)
p.type = 'hybrid'
p.parent = 'pollen'
p.year = p.pid.year
p.img = hybdir + get_random_img(p.pid)
# tree_list = tree_list + (s,)
# SS
if p.seed_id and p.seed_id.type == 'species':
ps = Accepted.objects.get(pk=p.seed_id)
ps.type = 'species'
ps.parent = 'seed'
ps.year = ps.pid.year
ps.img = spcdir + get_random_img(ps.pid)
# tree_list = tree_list + (ss,)
elif p.seed_id and p.seed_id.type == 'hybrid':
ps = Hybrid.objects.get(pk=p.seed_id)
ps.type = 'hybrid'
ps.parent = 'seed'
ps.year = ps.pid.year
ps.img = hybdir + get_random_img(ps.pid)
# tree_list = tree_list + (ss,)
# SSS
if ps.seed_id and ps.seed_id.type == 'species':
pss = Accepted.objects.get(pk=ps.seed_id)
pss.type = 'species'
pss.parent = 'seed'
pss.year = pss.pid.year
pss.img = spcdir + get_random_img(pss.pid)
# tree_list = tree_list + (sss,)
elif ps.seed_id and ps.seed_id.type == 'hybrid':
pss = Hybrid.objects.get(pk=ps.seed_id)
pss.type = 'hybrid'
pss.parent = 'seed'
pss.year = pss.pid.year
pss.img = hybdir + get_random_img(pss.pid)
# tree_list = tree_list + (sss,)
# SSSS
# SSP
if ps.pollen_id and ps.pollen_id.type == 'species':
psp = Accepted.objects.get(pk=ps.pollen_id)
psp.type = 'species'
psp.parent = 'pollen'
psp.year = psp.pid.year
psp.img = spcdir + get_random_img(psp.pid)
# tree_list = tree_list + (ssp,)
elif ps.pollen_id and ps.pollen_id.type == 'hybrid':
psp = Hybrid.objects.get(pk=ps.pollen_id)
psp.type = 'hybrid'
psp.parent = 'pollen'
psp.year = psp.pid.year
psp.img = hybdir + get_random_img(psp.pid)
# -- SP
if p.pollen_id and p.pollen_id.type == 'species':
pp = Accepted.objects.get(pk=p.pollen_id)
pp.type = 'species'
pp.parent = 'pollen'
pp.year = pp.pid.year
pp.img = spcdir + get_random_img(pp.pid)
# tree_list = tree_list + (sp,)
elif p.pollen_id and p.pollen_id.type == 'hybrid':
pp = Hybrid.objects.get(pk=p.pollen_id)
pp.type = 'hybrid'
pp.parent = 'pollen'
pp.year = pp.pid.year
pp.img = hybdir + get_random_img(pp.pid)
# tree_list = tree_list + (sp,)
if pp.seed_id and pp.seed_id.type == 'species':
pps = Accepted.objects.get(pk=pp.seed_id)
pps.type = 'species'
pps.img = spcdir + get_random_img(pps.pid)
pps.parent = 'seed'
pps.year = pps.pid.year
# tree_list = tree_list + (sps,)
elif pp.seed_id and pp.seed_id.type == 'hybrid':
pps = Hybrid.objects.get(pk=pp.seed_id)
pps.type = 'hybrid'
pps.img = hybdir + get_random_img(pps.pid)
pps.parent = 'seed'
pps.year = pps.pid.year
# tree_list = tree_list + (sps,)
if pp.pollen_id and pp.pollen_id.type == 'species':
ppp = Accepted.objects.get(pk=pp.pollen_id)
ppp.type = 'species'
ppp.img = spcdir + get_random_img(ppp.pid)
ppp.parent = 'pollen'
ppp.year = ppp.pid.year
# tree_list = tree_list + (spp,)
elif pp.pollen_id and pp.pollen_id.type == 'hybrid':
ppp = Hybrid.objects.get(pk=pp.pollen_id)
ppp.type = 'hybrid'
ppp.img = hybdir + get_random_img(ppp.pid)
ppp.parent = 'pollen'
ppp.year = ppp.pid.year
# tree_list = tree_list + (spp,)
context = {'species': species,
'spc': spc, 'tree': 'active', 'tab': 'tree',
's': s, 'ss': ss, 'sp': sp, 'sss': sss, 'ssp': ssp, 'sps': sps, 'spp': spp,
'ssss': ssss, 'sssp': sssp, 'ssps': ssps, 'sspp': sspp, 'spss': spss, 'spsp': spsp, 'spps': spps,
'sppp': sppp,
'p': p, 'ps': ps, 'pp': pp, 'pss': pss, 'psp': psp, 'pps': pps, 'ppp': ppp,
'psss': psss, 'pssp': pssp, 'psps': psps, 'pspp': pspp, 'ppss': ppss, 'ppsp': ppsp, 'ppps': ppps,
'pppp': pppp,
'title': 'ancestrytree', 'role': role,
}
write_output(request, species.textname())
return render(request, 'orchidaceae/ancestrytree.html', context)
def createhybrid(request):
genus1 = genus2 = species1 = species2 = ''
if 'pid1' in request.GET:
pid1 = request.GET['pid1']
try:
species1 = Species.objects.get(pk=pid1)
except Species.DoesNotExist:
return HttpResponse(redirect_message)
if species1.status == 'synonym':
species1 = species1.getAccepted()
if 'pid2' in request.GET:
pid2 = request.GET['pid2']
try:
species2 = Species.objects.get(pk=pid2)
except Species.DoesNotExist:
return HttpResponse(redirect_message)
else:
species2 = ''
if species2.status == 'synonym':
species2 = species2.getAccepted()
spc1 = species1.species
if species1.infraspe:
spc1 += ' ' + species1.infraspe
spc2 = species2.species
if species2.infraspe:
spc2 += ' ' + species2.infraspe
else:
return HttpResponse(redirect_message)
role = getRole(request)
if not role or role != 'cur':
send_url = '/detail/compare/' + str(pid1) + '/'
return HttpResponseRedirect(send_url)
import datetime
# Now create the new species objects
# # Get nothogenus
# # First, find all genus ancestors of both
gen1 = species1.gen.pid
gen2 = species2.gen.pid
parent1 = GenusRelation.objects.get(gen=gen1)
parent2 = GenusRelation.objects.get(gen=gen2)
parentlist1 = parent1.get_parentlist()
parentlist2 = parent2.get_parentlist()
parentlist = parentlist1 + parentlist2
parentlist = list(dict.fromkeys(parentlist))
parentlist.sort()
# Look for genus with this parent list
result_list = GenusRelation.objects.all()
genus = ''
for x in result_list:
a = x.get_parentlist()
a.sort()
if a == parentlist:
genus = x.genus
break
if not genus:
msgnogenus = "404"
genus1 = species1.genus
genus2 = species2.genus
send_url = '/detail/compare/' + str(pid1) + '/?msgnogenus=' + msgnogenus + '&genus1=' + genus1 + \
'&genus2=' + genus2 + '&species1=' + str(species1) + '&species2=' + str(species2)
return HttpResponseRedirect(send_url)
# Create Species instance
spcobj = Species()
spcobj.genus = genus
spcobj.species = spc1 + '-' + spc2
spcobj.pid = Hybrid.objects.filter(pid__gt=900000000).filter(pid__lt=999999999).order_by('-pid')[0].pid_id + 1
spcobj.source = 'INT'
spcobj.type = 'hybrid'
spcobj.status = 'nonregistered'
datetime_obj = datetime.datetime.now()
spcobj.year = datetime_obj.year
spcobj.save()
spcobj = Species.objects.get(pk=spcobj.pid)
# Now create Hybrid instance
hybobj = Hybrid()
hybobj.pid = spcobj
hybobj.seed_genus = species1.genus
hybobj.pollen_genus = species2.genus
hybobj.seed_species = spc1
hybobj.pollen_species = spc2
if species1.status == 'synonym':
hybobj.seed_id = species1.getAccepted()
else:
hybobj.seed_id = species1
if species2.status == 'synonym':
hybobj.pollen_id = species2.getAccepted()
else:
hybobj.pollen_id = species2
hybobj.save()
if genus1 and genus2:
write_output(request, str(genus1) + " " + str(species1) + " vs " + str(genus2) + " " + str(species2))
else:
write_output(request)
return HttpResponseRedirect("/display/photos/" + str(spcobj.pid) + "/?role=" + role + "&genus2=" + species2.genus + "&family=" + str(species2.gen.family))
def uploadweb(request, pid, orid=None):
sender = 'web'
try:
species = Species.objects.get(pk=pid)
except Species.DoesNotExist:
return HttpResponse(redirect_message)
# For Other application only
family = species.gen.family
app = family.application
if species.status == 'synonym':
synonym = Synonym.objects.get(pk=pid)
pid = synonym.acc_id
species = Species.objects.get(pk=pid)
role = getRole(request)
if request.method == 'POST':
form = UploadSpcWebForm(request.POST)
if form.is_valid():
spc = form.save(commit=False)
if not spc.author and not spc.credit_to:
return HttpResponse(
"Please select an author, or enter a new name for credit allocation."
)
spc.user_id = request.user
spc.pid = species
spc.text_data = spc.text_data.replace("\"", "\'\'")
if orid and orid > 0:
spc.id = orid
# set rank to 0 if private status is requested
if spc.is_private is True or request.user.tier.tier < 3:
spc.rank = 0
# If new author name is given, set rank to 0 to give it pending status. Except curator (tier = 3)
if spc.author.user_id and request.user.tier.tier < 3:
if (spc.author.user_id.id != spc.user_id.id) or role == 'pri':
spc.rank = 0
if spc.image_url == 'temp.jpg':
spc.image_url = None
if spc.image_file == 'None':
spc.image_file = None
if spc.created_date == '' or not spc.created_date:
spc.created_date = timezone.now()
spc.save()
url = "%s?role=cur&family=%s" % (reverse(
'display:photos', args=(species.pid, )), species.gen.family)
write_output(request, species.textname())
return HttpResponseRedirect(url)
if not orid: # upload, initialize author. Get image count
if species.type == 'species':
form = UploadSpcWebForm(
initial={'author': request.user.photographer.author_id})
else:
form = UploadHybWebForm(
initial={'author': request.user.photographer.author_id})
img = ''
else: # update. initialize the form iwht current image
img = SpcImages.objects.get(pk=orid)
if not img.image_url:
sender = 'file'
img.image_url = "temp.jpg"
else:
sender = 'web'
form = UploadSpcWebForm(instance=img)
context = {
'form': form,
'img': img,
'sender': sender,
'loc': 'active',
'species': species,
'family': family,
'role': role,
'app': app,
'title': 'uploadweb'
}
return render(request, app + '/uploadweb.html', context)
