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)