def product_ajax_save(request):
if request.method == "POST":
productForm = ProductForm(request.POST, prefix='product')
if productForm.is_valid():
product = productForm.save()
product.user = request.user
product.save()
cdsForm = CdsForm(request.POST, prefix='cds')
cdsForm.full_clean()
initialDict = cdsForm.cleaned_data
initialDict['product'] = product
updatedCdsForm = CdsForm(initial=initialDict, prefix='cds')
t = loader.get_template('databaseInput/cdsInputTab.html')
c = RequestContext(request, {
'form': updatedCdsForm,
})
return JsonResponse({'html': t.render(c)})
else:
t = loader.get_template('databaseInput/addProduct.html')
c = RequestContext(request, {
'form': productForm,
})
return JsonResponse({'html': t.render(c)}, ERROR)
def origin_ajax_save(request):
if request.method == "POST":
originForm = OriginForm(request.POST, prefix='origin')
if originForm.is_valid():
origin = originForm.save()
origin.user = request.user
origin.save()
cdsForm = CdsForm(request.POST, prefix='cds')
cdsForm.full_clean()
initialDict = cdsForm.cleaned_data
initialDict['origin'] = origin
updatedCdsForm = CdsForm(initial=initialDict, prefix='cds')
t = loader.get_template('databaseInput/cdsInputTab.html')
c = RequestContext(request, {
'form': updatedCdsForm,
})
return JsonResponse({'html': t.render(c)})
else:
t = loader.get_template('databaseInput/addOrigin.html')
c = RequestContext(request, {
'form': originForm,
})
return JsonResponse({'html': t.render(c)}, ERROR)
def change_password(request):
if request.method == "POST" and "oldpw" in request.POST and "newpw" in request.POST:
if not request.user.check_password(request.POST['oldpw']):
return JsonResponse({"field": "oldpw"}, ERROR)
else:
request.user.set_password(request.POST['newpw'])
request.user.save()
return JsonResponse({})
def part_import(request):
"""API to import a part via AJAX"""
if request.method == 'GET' and 'part' in request.GET:
name = request.GET.get('part', '')
try:
part = Part(name)
record = part.to_seq_record()
Gene.add(record, 'BB', request.user)
except Exception, e:
return JsonResponse(e.message, ERROR)
return JsonResponse('ok')
def save_cds_domains(request):
if request.method == "POST":
DomainFormSet = inlineformset_factory(Cds, Domain, form=DomainForm)
cdsForm = CdsForm(request.POST, prefix='cds')
if cdsForm.is_valid():
cds = cdsForm.save(commit=False)
cds.user = request.user
domainFormSet = DomainFormSet(request.POST, instance=cds)
if domainFormSet.is_valid():
cds.save()
domains = domainFormSet.save(commit=False)
for domain in domains:
domain.user = request.user
domain.save()
domainFormSet.save_m2m()
#if successful, render cds input form with clean form again!
t = loader.get_template('databaseInput/cdsInputTab.html')
cdsForm = CdsForm(prefix='cds')
c = RequestContext(
request, {
'form':
cdsForm,
'isAjax':
True,
'djangoSuccess':
'<strong>Well done!</strong> Successfully added new coding sequence into database!'
})
return JsonResponse({'html': t.render(c)})
else:
t = loader.get_template('databaseInput/domainInput.html')
c = RequestContext(request, {
'domainFormSet': domainFormSet,
})
return JsonResponse({'html': t.render(c)}, ERROR)
else:
# if cds form does not validate, return original page again..with appropriate error alert
# this view is just in case and should not be returned under normal circumstances
# as javascript checks for changes in input after prediction as well
t = loader.get_template('databaseInput/cdsInputTab.html')
c = RequestContext(
request, {
'form':
cdsForm,
'isAjax':
True,
'djangoError':
'<strong>Woops..</strong>It appears the original Cds got tampered with after domain prediction. Please fix your input and try again!'
})
return JsonResponse({'html': t.render(c)})
else:
# should not be accessed via get request
return HttpResponseBadRequest()
def set_features(request, fid):
"""Save a fragment's features"""
if request.method == 'POST':
try:
g = get_gene(request.user, fid)
feats = request.POST.get('features')
if feats:
write_features(g, feats)
return JsonResponse('Done')
return JsonResponse('No features provided', ERROR)
except ObjectDoesNotExist:
JsonResponse("Fragment with ID='%s' does not exist" % fid, ERROR)
raise Http404
def get_fragment(request, fid):
"""Return a small amount of information about the fragment"""
try:
fid = int(fid)
except ValueError:
return JsonResponse("Invalid fragment id: %s" % fid, ERROR)
g = get_gene(request.user, fid)
return JsonResponse({
'id': fid,
'name': g.name,
'desc': g.description,
'length': g.length(),
'viewable': g.viewable
})
def domain_prediction(request):
if request.method == "POST":
cdsForm = CdsForm(request.POST, prefix='cds')
if cdsForm.is_valid():
cds = cdsForm.save(commit=False)
#test_task = cds.predictDomains.delay()
task = cds.predictDomains.delay()
return JsonResponse({'taskId': task.id})
else:
t = loader.get_template('databaseInput/cdsInputTab.html')
c = RequestContext(request, {
'form': cdsForm,
'isAjax': True,
})
return JsonResponse({'html': t.render(c)}, ERROR)
def get_sequence(request, fid):
"""Stream the sequence in blocks of 1kB by default"""
try:
chunk_size = int(request.GET.get('chunk_size', 1024))
except ValueError:
return JsonResponse(
"ERROR: Invalid chunk_size '%s'." %
request.GET.get('chunk_size', 1024), ERROR)
pad_char = request.GET.get('pad_char', ' ')
g = get_gene(request.user, fid)
if g:
resp = HttpResponse(chunk_sequence(g, chunk_size, pad_char),
mimetype="text/plain")
return resp
return JsonResponse('Could Not Stream Sequence', ERROR)
def list_fragments(request):
"""Return metadata of all fragments owned by a user"""
args = {'owner': request.user, 'viewable__in': ['L', 'G']}
try:
if 'type[]' in request.POST:
args['annotations__key__exact'] = 'part_type'
args['annotations__value__in'] = request.POST.getlist('type[]')
frags = Gene.objects.select_related('annotations').filter(**args)
else:
frags = Gene.objects.filter(**args)
except ObjectDoesNotExist:
return JsonResponse('Could not read fragments', ERROR)
ret = []
for f in frags:
ret.append(read_meta(f))
return JsonResponse(ret)
def do_msa(request):
if request.method == "POST":
cdsForm = CdsForm(request.POST, prefix="cds")
#import pdb;pdb.set_trace()
if cdsForm.is_valid():
cds = cdsForm.save()
# let's modify request.POST, so that the user still gets a
# response, even if module number has not been entered yet
post = request.POST.copy()
post[u'domains-module'] = u'0'
# prefix for domainForm extracted from DomainFormSet by JS
domainForm = DomainForm(post, prefix="domains")
if domainForm.is_valid():
initialDict = domainForm.cleaned_data
del initialDict['substrateSpecificity']
initialDict['cds'] = cds
domain = Domain.objects.create(**initialDict)
task = domain.align_same_type.delay()
return JsonResponse({'taskId': task.id})
t = loader.get_template('databaseInput/MSA_test.html')
c = RequestContext(request, {'jsonMSA': MSA})
domain.delete()
cds.delete()
return HttpResponse(t.render(c))
else:
return HttpResponse("") #think of how to best handle errors..
else:
return HttpResponse("")
def fragment_clipping(request, cid, cfid):
con = get_construct(request.user, cid)
if con:
try:
cf = con.cf.get(id=cfid)
except:
return JsonResponse('Could not find ConstructFragment(%s)' % cfid,
ERROR)
t = loader.get_template('gibson/fragment_clipping.html')
d = {
'feature_list': cf.fragment.features.all(),
'cfid': cfid,
'from_absolute': not cf.start_is_relative(),
'to_absolute': not cf.end_is_relative(),
'length': cf.fragment.length(),
'max': cf.fragment.length() - 1,
}
if cf.start_is_relative():
d['start_feat'] = cf.start_feature.id
d['start_offset'] = cf.start_offset
if cf.end_is_relative():
d['end_feat'] = cf.end_feature.id
d['end_offset'] = cf.end_offset
c = RequestContext(request, d)
return HttpResponse(t.render(c))
raise Http404
def peptide_add(request):
if request.method == 'POST':
form = NRPForm(request.POST, prefix='nrp')
if form.is_valid():
c = form.save(commit=False)
c.owner = request.user
c.save()
return JsonResponse({'url': reverse('peptides') })
t = loader.get_template('designerGui/peptideform.html')
con = NRP.objects.all().filter(owner=request.user)
c = RequestContext(request, {
'NRPform':form,
})
return JsonResponse({'html': t.render(c),}, ERROR)
else:
return HttpResponseNotFound()
def manual_add(request):
"""Add a fragment manually"""
if request.method == 'GET':
meta = MetaForm(request.GET)
seq = SequenceForm(request.GET)
if meta.is_valid() and seq.is_valid():
record = SeqRecord(seq.cleaned_data['seq'],
name=meta.cleaned_data['name'],
id=meta.cleaned_data['name'],
description=meta.cleaned_data['desc'])
Gene.add(record, 'MN', request.user)
return JsonResponse('OK')
#figure out what the errors where
errors = meta.errors
errors.update(seq.errors)
return JsonResponse(errors, ERROR)
raise Http404
def entrez_summary(request):
""" Handle JSON Entrez summary request"""
if request.method == 'GET' and 'id' in request.GET:
id = request.GET['id']
db = request.GET.get('database',
'nucleotide') #assume nucleotide by default
#fetch summary information for the id
handle = Entrez.esummary(db=db, id=id)
record = Entrez.read(handle)
if record is None or len(record) < 1:
return JsonResponse(
"Error: Could not get summary information for id '%s'" % id,
ERROR)
return JsonResponse(record[0])
raise Http404
def get_features(request, fid):
"""Get a fragment's features"""
g = get_gene(request.user, fid)
return JsonResponse({
'feats': read_features(g),
'alpha': get_alphabet(),
'length': len(g.sequence),
})
def peptide_delete(request, cid):
peptide = NRP.objects.get(owner = request.user, pk = cid)
if peptide:
peptide.fullDelete()
if request.is_ajax():
return JsonResponse('/peptides')
return HttpResponseRedirect('/peptides')
else:
return HttpResponseNotFound()
def construct_delete(request, cid):
con = get_construct(request.user, cid)
if con:
con.delete()
if request.is_ajax():
return JsonResponse('/gibthon')
return HttpResponseRedirect('/gibthon')
else:
return HttpResponseNotFound()
def construct_add(request):
if request.method == 'POST':
rp = fix_request(request.POST)
form = ConstructForm(rp)
if form.is_valid():
c = form.save()
c.owner = request.user
c.save()
return JsonResponse({
'url': '/gibthon/%s/' % c.id,
})
t = loader.get_template('gibson/constructform.html')
con = Construct.objects.all().filter(owner=request.user)
c = RequestContext(request, {
'construct_form': form,
})
return JsonResponse({
'html': t.render(c),
}, ERROR)
else:
return HttpResponseNotFound()
def entrez_search(request):
""" Handle JSON Entrez search request"""
if request.method == 'GET': # and request.is_ajax():
query = request.GET.get('query', '')
db = request.GET.get('database',
'nucleotide') #assume nucleotide by default
if query != '' and query != None:
#fetch a list of Ids which match
handle = Entrez.esearch(db=db, term=query)
record = Entrez.read(handle)
ids = record['IdList']
if len(ids) == 0:
return JsonResponse(
"No results for search '%s' on database '%s'." %
(query, db), ERROR)
else:
return JsonResponse(ids)
else:
return JsonResponse("Error: Blank search query", ERROR)
raise Http404
def entrez_import(request):
"""Handle a request to import an ID"""
if request.method == 'GET' and 'id' in request.GET:
id = request.GET['id']
db = request.GET.get('database',
'nucleotide') #assume nucleotide by default
handle = Entrez.efetch(db=db, id=id, rettype="gb")
records = SeqIO.parse(handle, 'gb')
for r in records:
if len(Gene.objects.filter(name=r.name, owner=request.user)) == 0:
Gene.add(r, 'NT', request.user)
return JsonResponse("Imported id '%s' from Entrez." % id)
raise Http404
def set_meta(request, fid):
"""Update a fragment's metadata"""
if request.method == 'POST':
try:
g = get_gene(request.user, fid)
meta = {
'name': request.POST.get('name'),
'desc': request.POST.get('desc'),
}
meta['annots'] = []
for i in range(0, len(request.POST) - 2):
m = request.POST.getlist('annots[%s][]' % i)
if m:
meta['annots'].append(m)
print 'meta = %s' % meta
if meta:
write_meta(g, meta)
return get_meta(request, fid)
return JsonResponse("No metadata supplied.", ERROR)
except ObjectDoesNotExist:
return JsonResponse("Fragment with ID='%s' does not exist." % fid,
ERROR)
raise Http404
def getConstruct(request, pid):
nrp = NRP.objects.get(owner=request.user, pk=pid)
if not nrp.designed:
return makeConstruct(request, pid)
elif nrp.construct is None or nrp.construct.fragments.count() == 0:
con = nrp.makeConstruct()
con = nrp.construct
constructId = con.pk
designTabLink = reverse('design_tab', kwargs= {'cid' : constructId})
primerTabLink = reverse('primers', kwargs= {'cid' : constructId})
domainSequenceTabLink = reverse('domainSequence', kwargs = {'pid' : pid})
return JsonResponse({"constructId": constructId,
'designTabLink': designTabLink,
'primerTabLink': primerTabLink,
'domainSequenceTablLink': domainSequenceTabLink})
def get_predicted_domain_formset(request, task_id):
if request.method == "POST":
initialDict = AsyncResult(task_id).get()
t = loader.get_template('databaseInput/domainInput.html')
DomainFormSet = inlineformset_factory(Cds,
Domain,
form=DomainForm,
extra=len(initialDict))
c = RequestContext(request, {
'domainFormSet': DomainFormSet(initial=initialDict),
})
#return HttpResponse(t.render(c))
return JsonResponse({
'html': t.render(c),
})
def celery_task_log(request, task_id):
task = AsyncResult(task_id)
out = dict()
if task.ready() and task.successful():
out = {'status': 'SUCCESS'}
elif task.ready() and task.failed():
out = {'status': 'FAILED', 'output': str(task.result)}
elif task.status == "log":
if 'log' in task.result:
task_log = task.result['log']
else:
task_log = []
out = {'status': 'log', 'output': task_log}
else:
out = {'status': task.status}
out['taskId'] = task_id
return JsonResponse(out)
def processLibrary(request, pid):
if request.method == 'POST':
data = json.loads(request.body)
monomers = []
haveUseAll = -1
i = 0
for m in data['as']:
monomers.append(m[0])
if len(m) > 1 and m[1] == True:
haveUseAll = i
i += 1
if haveUseAll != -1:
for m in data['as']:
del m[1:]
substrates = get_available_substrates(monomers, True, data['curatedonly'], haveUseAll)
scaffold = data['as'][haveUseAll][0]
for s in substrates:
if s.pk != scaffold:
data['as'][haveUseAll].append(s.pk)
nrp = NRP.objects.get(owner=request.user, pk=pid)
return JsonResponse({'taskId': nrp.makeLibrary.delay(data['as'], data['curatedonly']).id})
def construct_fragment(request, cid):
con = get_construct(request.user, cid)
if con and not request.is_ajax():
t = loader.get_template('gibson/constructfragment.html')
cf_list = con.cf.all()
feature_list = [FeatureListForm(cf, con) for cf in cf_list]
list = zip(cf_list, feature_list)
c = RequestContext(request, {'list': list})
return HttpResponse(t.render(c))
if con and request.is_ajax():
cf_list = con.cf.all()
frag_list = [{
'fid': cf.fragment.id,
'cfid': cf.id,
'name': cf.fragment.name,
'desc': cf.fragment.description,
'length': abs(cf.end() - cf.start()),
} for cf in cf_list]
return JsonResponse(frag_list)
return HttpResponseNotFound()
def get_available_monomers(request):
if request.method == 'POST' and "monomer[]" in request.POST:
monomers = request.POST.getlist("monomer[]")
if 'selected' in request.POST:
selected = int(request.POST['selected'])
else:
selected = None
aas = get_available_substrates(monomers, toBool(request.POST['current']), toBool(request.POST['curatedonly']), selected)
else:
aas = filter(lambda x: x.can_be_added(), Substrate.objects.exclude(user__username='******'))
json = {}
minid = float("Inf")
for aa in aas:
if aa.parent is None:
name = aa.name
if aa.name[0:2].upper() == 'L-' or aa.name[0:2].upper() == 'D-':
name = aa.name[2:]
if aa.pk in json:
key = aa.pk
elif aa.enantiomer is not None and aa.enantiomer.pk in json:
key = aa.enantiomer.pk
else:
key = None
if aa.enantiomer is None:
chirality = 'N'
else:
chirality = aa.chirality
if key is not None:
if key < minid:
minid = key
json[key][chirality.lower() + "id"] = aa.pk
json[key][chirality+'Children'] = [{"text": c.name, "id": c.pk} for c in aa.child.all()]
#names[name]['name'] = name
else:
json[aa.pk] = {"id": aa.pk, chirality.lower() + "id": aa.pk, 'text': name, aa.chirality+'Children': [{"text": c.name, "id": c.pk} for c in aa.child.all()]}
jsonlist = json.values()
jsonlist.sort(lambda x,y: cmp(x['text'], y['text']))
return JsonResponse({"monomers": json, "monomerslist": jsonlist})
def makeConstruct(request,pid):
nrp = NRP.objects.get(owner=request.user, pk=pid)
nrp.designed = False
return JsonResponse({'taskId': nrp.designDomains.delay(toBool(request.POST['curatedonly'])).id})
def apply_clipping(request, cid, cfid):
con = get_construct(request.user, cid)
if con:
try:
cf = con.cf.get(id=cfid)
except:
return JsonResponse('Could not find ConstructFragment(%s)' % cfid,
ERROR)
try:
f_type = request.POST['from_type'].lower()
t_type = request.POST['to_type'].lower()
if f_type == 'absolute':
start = int(request.POST['from_abs'])
if start < 0 or start > cf.fragment.length() - 1:
raise ValueError('"start" must be within range [0:%i]' %
cf.fragment.length() - 1)
if cf.start_offset != start or cf.start_feature != None:
cf.start_offset = start
cf.start_feature = None
con.processed = False
elif f_type == 'relative':
start = int(request.POST['from_rel'])
start_fid = int(request.POST['start_feat'])
print "available ids are %s" % [
feat.id for feat in cf.fragment.features.all()
]
start_feature = cf.fragment.features.get(id=start_fid)
if cf.start_offset != start or cf.start_feature != start_feature:
cf.start_offset = start
cf.start_feature = start_feature
con.processed = False
else:
raise ValueError('"f_type" must be "absolute" or "relative"')
if t_type == 'absolute':
end = int(request.POST['to_abs'])
if end < 0 or end > cf.fragment.length() - 1:
raise ValueError('"end" must be within range [0:%i]' %
cf.fragment.length() - 1)
if cf.end_offset != end or cf.end_feature != None:
cf.end_offset = end
cf.end_feature = None
con.processed = False
elif t_type == 'relative':
end = int(request.POST['to_rel'])
end_fid = int(request.POST['end_feat'])
end_feature = cf.fragment.features.get(id=end_fid)
if cf.end_offset != end or cf.end_feature != end_feature:
cf.end_offset = end
cf.end_feature = end_feature
con.processed = False
else:
raise ValueError('"t_type" must be "absolute" or "relative"')
except KeyError as e:
return JsonResponse('Value required for "%s"' % e.message, ERROR)
except ValueError as e:
return JsonResponse('ValueError: %s' % e.message, ERROR)
except ObjectDoesNotExist as e:
return JsonResponse(
'DoesNotExist: %s (%s)' % (e.message, start_fid), ERROR)
cf.save()
con.save()
return JsonResponse('OK')
raise Http404
