def add_resource(): if request.method == 'GET': return render_template("form.html", action="Add", resource={}, tag="", message="") data = request.form.to_dict(flat=True) data['owner_id'] = current_user.id #print data message = valid_resource_time(data['available_start'], data['available_end']) if len(data['name']) == 0: message = "name can't be empty" if message != "": return render_template("form.html", action="Add", resource={}, tag="", message=message) resource = Resource() resource.deserialize(data) tag_list = data['tag'].split() for tag_name in tag_list: tag = db.session.query(Tag).filter_by(value=tag_name.lower()).first() if not tag: tag = Tag(tag_name.lower()) db.session.add(tag) resource.tags.append(tag) db.session.add(resource) try: db.session.commit() except: db.session.rollback() return redirect(url_for('.get_resources', id=resource.id))
def retrieve(request, uri): resource = None try: resource = Resource.objects.get(uri=uri) if not resource.retrieved: result = resource.source.getManager().get(uri) except ObjectDoesNotExist: result = None for repository in Repository.objects.all(): result = repository.getManager().get(uri) if result is not None: if result is not None: resource = Resource( uri = uri, source = repository, ) resource.save() break if resource is None: return JSONResponse([]) if not resource.retrieved and result is not None: resource = attach_content(resource, result) return JSONResponse(resource)
def test_model_eq(self): resource1 = Resource(ID=1, name="Resource1", resource_type="ROOM") resource2 = Resource(ID=1, name="Resource1", resource_type="ROOM") resource3 = Resource(ID=1, name="Resource3", resource_type="ROOM") self.assertEqual(resource1, resource2) self.assertNotEqual(resource1, resource3) date = QtCore.QDate.currentDate() start_time = QtCore.QTime(8, 0) end_time = QtCore.QTime(9, 0) start = QtCore.QDateTime(date, start_time) end = QtCore.QDateTime(date, end_time) reservation1 = Reservation(ID=1, resource=resource1, start=start, end=end) reservation2 = Reservation(ID=1, resource=resource2, start=start, end=end) reservation3 = Reservation(ID=1, resource=resource3, start=start, end=end) self.assertEqual(reservation1, reservation2) self.assertNotEqual(reservation1, reservation3)
def get(self): user = users.get_current_user() if user: url = users.create_logout_url(self.request.uri) url_linktext = 'Logout' # retrieve reservations by current user now_time = datetime.now() - timedelta(minutes=300) reservation_by_curr_user = Reservation.query(ndb.AND(Reservation.user == user.email(), Reservation.end_time > now_time)) \ .fetch() if reservation_by_curr_user: reservation_by_curr_user = sorted(reservation_by_curr_user, key=lambda r: r.start_time) # retrieve all resources in system sorted_resources = Resource.query().order( -Resource.last_reservation_time) # retrieve resources owned by current user resources_owned = Resource.query(Resource.owner == user.email()) template_values = { 'user': user, 'reservation_by_curr_user': reservation_by_curr_user, 'sorted_resources': sorted_resources, 'resources_owned': resources_owned, 'url': url, 'url_linktext': url_linktext, } template = JINJA_ENVIRONMENT.get_template('index.html') self.response.write(template.render(template_values)) else: self.redirect(users.create_login_url(self.request.uri))
def test_strings(self): lo2 = self.lo0 url = 'http://www.google.com/' r = Resource(objective=lo2, url=url) r.full_clean() r.save() rs = ResourceSubmission(user=self.u1, resource=r, type='c') rs.full_clean() rs.save() self.assertTrue(' created ' in str(rs)) self.assertEquals(rs.type_str(), 'Created') rs = ResourceSubmission(user=self.u1, resource=r, type='f') rs.full_clean() rs.save() self.assertTrue(' flagged ' in str(rs)) self.assertEquals(rs.type_str(), 'Inappropriate') rs = ResourceSubmission(user=self.u2, resource=r, type='v') rs.full_clean() rs.save() self.assertTrue(' voted on ' in str(rs)) self.assertEquals(rs.type_str(), 'Up-voted')
def post(self, request): self.query_dict = {'classgroup': request.DATA.get('classgroup')} self.verify_membership() resource_type = request.DATA.get('resource_type') if resource_type != "vertical": raise Http404 resource = Resource(resource_type=resource_type, user=request.user, classgroup=self.cg) resource.save() renderer = ResourceRenderer(resource, user=request.user, static_data={ 'request': request, 'author_post_link': '/api/resources/author/' }) html = renderer.author_view().get_html() return Response({'html': html, 'display_name': resource.display_name})
def get(self): if users.get_current_user(): url = users.create_logout_url(self.request.uri) url_linktext = 'Logout' else: url = users.create_login_url(self.request.uri) url_linktext = 'Login' self.redirect(users.create_login_url(self.request.uri)) user = users.get_current_user() # query resources created by the current user resource_query = Resource.query(user == Resource.author).order(-Resource.lastReserveDate) resources = resource_query.filter().fetch() resources = None if Resource: if Resource.lastReserveDate: resource_query = Resource.query(user == Resource.author).order(-Resource.lastReserveDate) resources = resource_query.fetch() elif Resource.modDate: resource_query = Resource.query(user == Resource.author).order(-Resource.modDate) resources = resource_query.fetch() nowStr = datetime.now().strftime('%Y-%m-%d %H:%M:%S') now = datetime.strptime(nowStr, '%Y-%m-%d %H:%M:%S') template_values = { 'resources': resources, 'user': user, 'url': url, 'url_linktext': url_linktext, 'now': now } template = JINJA_ENVIRONMENT.get_template('myResource.html') self.response.write(template.render(template_values))
def workspace_test(): print_data('workspaces objects', br=False) for index in range(3): w = Workspace() w.name = 'New workspace name' w.description = 'Some new description' w.save() workspaces = Workspace.all() print_data('new objects -> model.all()', workspaces) w.name = 'Updated name' w.save() workspaces = Workspace.all() print_data('UPDATED -> model.all()', workspaces) workspaces = Workspace.get(id=w.id, name=w.name) print_data('GET -> model.get()', [workspaces]) workspaces = Workspace.filter(name='New workspace name') print_data('FILTER -> model.filter()', workspaces) for index in range(2): o = Application() o.workspace_id = w.guid o.save() a = View() a.application_id = o.guid a.save() a = Resource() a.application_id = o.guid a.save() for index in range(3): o = Widget() o.workspace_id = w.guid o.save() for index in range(3): o = DataSource() o.workspace_id = w.guid o.save() objects = Workspace.all() + Resource.all() + Application.all() + Widget.all() + DataSource.all() + View.all() print_data('All objects in db', objects) # [w.delete() for w in Workspace.all()] workspaces = Workspace.all() print_data('cleaned', workspaces) workspaces = Workspace.filter(include_deleted=True) print_data('cleaned with deleted if exists', workspaces) objects = Workspace.all() + Resource.all() + Application.all() + Widget.all() + DataSource.all() + View.all() print_data('no objects left', objects)
def save(self, data: Dict): self.validate(data) try: resource = Resource(data) resource.save() except ValueError as err: raise ValidationError(message=str(err))
def test_bad_url(self): bad_urls = ('ftp://*****:*****@example.com/', 'http://*****:*****@example.com/', 'http://foo', ) for (bad_url, i) in zip(bad_urls, range(len(bad_urls))): r = Resource(objective=self.lo0, url=bad_url) self.assertRaises(ValidationError, lambda: r.full_clean())
def api_resources(*, page='1'): page_index = get_page_index(page) num = yield from Resource.findNumber('count(id)') p = Page(num, page_index) if num == 0: return dict(page=p, resources=()) resources = yield from Resource.findAll(orderBy='created_at desc', limit=(p.offset, p.limit)) return dict(page=p, resources=resources)
def add_new_resource(request): title = request.POST.get('title', '').strip() type = request.POST.get('type') # to image: filename, to video: id attach = request.POST.get('attach', '').strip() # check params if not _check_login(request): return HttpResponse(json.dumps({'success': -1, 'error_msg': "请登录后操作!"})) if len(title) <= 0: return HttpResponse(json.dumps({'success': -1, 'error_msg': "资源标题不能为空!"})) if len(title) >= 1000: return HttpResponse(json.dumps({'success': -1, 'error_msg': "资源标题过长,只能1000个字符!"})) if len(attach) <= 0: return HttpResponse(json.dumps({'success': -1, 'error_msg': "请上传一个视频或者图片!"})) if type not in ('image', 'video'): return HttpResponse(json.dumps({'success': -1, 'error_msg': "资源类型不支持!"})) if type == 'image' and not default_storage.exists(os.path.join(config.get_config('SHAREHP_UPLOAD_DIR'), attach)): return HttpResponse(json.dumps({'success': -1, 'error_msg': "服务器图片丢失,请重新上传!"})) if type == 'video': video_info = cache.get_video_info(attach) if not video_info: return HttpResponse(json.dumps({'success': -1, 'error_msg': "服务器视频丢失,请重新上传!"})) # build filed data try: if type == 'image': thumbnail, content = _deal_image_resource(attach) else: thumbnail, content = _deal_video_resource(video_info) except QiniuUploadFileError: logger.error('Fail to add new resource, uploading image error!\n') return HttpResponse(json.dumps({'success': -1, 'error_msg': "服务器异常,请稍后再试!"})) # 保存资源 current_date = datetime.now() resource = Resource( gmt_create=current_date, gmt_modify=current_date, user_id=_get_current_userid(request), title=title, type=type, thumbnail=thumbnail, content=content, up=0, down=0, comments=0, status='enabled' ) resource.save() cache.set_last_resource_id(resource.id) # important return HttpResponse(json.dumps({'success': 0, 'data': {}}))
def getCollage(): collage = "%s/scripts/img/mincportfolio.png" % (access.server_url) try: result = None if Resource.all().count() == 1: for resource in Resource.all(): result = resource.resource_key.key() collage = "%s/serve/%s" % (access.server_url, result) return collage else: return collage except: return collage
def serve(request, resource): verb = request.method if verb == "GET": try: entry = Resource.objects.get(key=resource) return HttpResponse("<p> " + str(entry.value) + "</p>" + out) except Resource.DoesNotExist: return HttpResponseNotFound("ERROR: Entrada no disponible") elif verb == "PUT": entry = Resource(key=resource, value=request.body) entry.save() return HttpResponse("Entrada insertada correctamente")
def handle_create(request, resource_type): ''' handle FHIR create operation ''' correctible = (request.format == 'xml') valid, search_elements = fhir_parser.parse_resource( resource_type, request.data, correctible) if not valid: return fhir_error.inform_bad_request() resource = Resource(resource_type, request.data, owner_id=request.authorizer.email) index_resource(resource, search_elements) return resource.as_response(request, created=True)
def put(self): """Uploads a file.""" path = self.request_path parent_path = os.path.dirname(path) # anything at this path already? existing_resource = Resource.get_by_path(path) if existing_resource: existing_resource.delete_recursive() # fetch parent if parent_path: parent = Resource.get_by_path(parent_path) if not parent or not parent.is_collection: return self.response.set_status( 409, "Conflict") # must create parent folder first else: parent = Resource.root() logging.info("Creating resource at %s" % path) data = ResourceData(blob=self.request.body) data.put() resource = Resource(path=path, parent_resource=parent, data=data) resource.content_length = len(self.request.body) resource.put() self.response.set_status(201, 'Created')
def saveResource(request): #print("Test") resources = Resource.objects.all() #print(resources.length) resoID = resources.__len__() + 1 #print(ResoID) name = request.GET["Name"] lat = request.GET["Lat"] lng = request.GET["Lng"] skills = request.GET["Skills"] newResource = Resource(ResoID=resoID,Name=name,Lat=lat,Lng=lng,Skills=skills) newResource.save() return HttpResponse("OK")
def create_resource(): """Creates a new todo and returns JSON of that created todo""" new_resource = Resource( name=request.json["name"], url=request.json["url"], description=request.json["description"], login_required=request.json["login_required"], api_available=request.json["api_available"], country_of_origin=request.json["country_of_origin"], documentation_url=request.json["documentation_url"], keywords=request.json["keywords"]) db.session.add(new_resource) db.session.commit() response_json = jsonify(resource=new_resource.serialize()) return (response_json, 201)
def test_1(self): """Basic creation of Resource, disallowing same URL+objective combination""" lo1 = self.lo0 url1 = 'http://127.0.0.1/foo.html' r1 = Resource(objective=lo1, url=url1) self.assertEquals(r1.votes, 0) self.assertEquals(r1.inappropriate_flags, 0) r1.save() when_added = r1.when_added now = datetime.datetime.now() when_added = when_added.replace(tzinfo=None) self.assertTrue(now - when_added < datetime.timedelta(seconds=5)) r2 = Resource(objective=lo1, url=url1) self.assertRaises(IntegrityError, lambda: r2.save())
def update_resources(self): for course in self.current_courses: self.open_with_session(course.url) for a in self.page.select('#region-main a[href]'): url = a['href'] mod = { 'nombre': a.get_text(), 'url': url, 'enviado': False, 'idMateria': course.idMateria, 'idTipoRecurso': self._identifiy_type_of_resource(url) } if Resource.not_loaded(mod): Resource.insert(mod) print(f'OK - {course.idMateria} -> {course.nombre}')
def get(self): resource_id = self.request.get('id') resource = Resource.query(Resource.id == resource_id).get() reservations = Reservation.query( Reservation.resource_id == resource_id).fetch() header = '<?xml version="1.0" encoding="UTF-8" ?>' tag_owner = '<owner>{}</owner>'.format(resource.owner) tag_name = '<name>{}</name>'.format(resource.name) tag_start = '<start_time>{}</start_time>'.format( resource.available_start_time) tag_end = '<end_time>{}</end_time>'.format(resource.available_end_time) tags_reservation = [] for r in reservations: t = {} t['user'] = '******'.format(r.user) t['start'] = '<reservedAt>{}</reservedAt>'.format(r.start_time) tags_reservation.append(t) template_values = { 'header': header, 'owner': tag_owner, 'name': tag_name, 'start_time': tag_start, 'end_time': tag_end, 'reservations': tags_reservation, } template = JINJA_ENVIRONMENT.get_template('rss.html') self.response.write(template.render(template_values))
def get_all(self): resources = [] self.cursor.execute('SELECT * FROM resources ORDER BY name COLLATE NOCASE') rows = self.cursor.fetchall() for row in rows: resources.append(Resource(row=row)) return resources
def fetch_request_token(self, oauth_consumer, oauth_callback): logger.warning("!!! In MockOAuthDataStore.fetch_request_token args: %s"%locals()) if oauth_consumer.key != self.consumer.key: raise OAuthError('Consumer key does not match.') # OAuth 1.0a: if there is a callback, check its validity callback = None callback_confirmed = False if oauth_callback: if oauth_callback != OUT_OF_BAND: if check_valid_callback(oauth_callback): callback = oauth_callback callback_confirmed = True else: raise oauth.OAuthError('Invalid callback URL.') #not going to implement scope just yet-so just hard code this for now resource = Resource.all().filter("name =","default")[0] #try: # resource = Resource.objects.get(name=self.scope) #except: # raise OAuthError('Resource %s does not exist.' % escape(self.scope)) self.request_token = Token.create_token(consumer=self.consumer, token_type=Token.REQUEST, timestamp=self.timestamp, resource=resource, callback=callback, callback_confirmed=callback_confirmed) return self.request_token
def add(): if not g.user.is_authenticated(): return render_template('add.html') if request.method == 'GET': return render_template('add.html') resource_type = request.form['resource_type'] url = request.form['url'].strip() resource = Resource.query.filter_by(resource_type=resource_type, url=url).first() if resource is not None: flash('service already registered (%s, %s)' % (resource_type, url), 'danger') if 'resource_type' in request.args: rtype = request.args.get('resource_type') return redirect(url_for('add', resource_type=rtype)) return redirect(url_for('add')) [title, success, response_time, message, start_time] = run_test_resource(resource_type, url) resource_to_add = Resource(current_user, resource_type, title, url) run_to_add = Run(resource_to_add, success, response_time, message, start_time) DB.session.add(resource_to_add) DB.session.add(run_to_add) try: DB.session.commit() flash('service registered (%s, %s)' % (resource_type, url), 'success') except Exception, err: DB.session.rollback() flash(str(err), 'danger')
def get(self): if users.get_current_user(): url = users.create_logout_url(self.request.uri) url_linktext = 'Logout' else: self.redirect(users.create_login_url(self.request.uri)) user = users.get_current_user() nowStr = datetime.now().strftime('%Y-%m-%d %H:%M:%S') now = datetime.strptime(nowStr, '%Y-%m-%d %H:%M:%S') tagIDStr = self.request.get('tag') resources = None if tagIDStr != "" and Resource and Resource.tags: if Resource.tags: resource_query_byTags = Resource.query(tagIDStr == Resource.tags) if Resource.lastReserveDate: resource_inOrder = resource_query_byTags.order(-Resource.lastReserveDate) if resource_inOrder: resources = resource_inOrder.fetch() template_values = { 'user': user, 'url': url, 'url_linktext': url_linktext, 'resources': resources, 'now': now } template = JINJA_ENVIRONMENT.get_template('tag.html') self.response.write(template.render(template_values))
def store_scene_json(): from models import Resource from docs import Blob from application import db json_data = json.loads(request.data) data = json_data['scene'] name = json_data['name'] type = 'scene' tags = 'scene json plain' blob_key = Blob(json.dumps(data)).save() resource = Resource(name=name, type=type, blob_key=blob_key, tags=tags) db.session.add(resource) db.session.commit() resource_url = url_for('resource.get_by_name', resource_name=name) resource_url_base64 = base64.encodestring(resource_url) view_url = url_for('player', path=resource_url_base64) result = json.dumps({ "success": True, "data": { "resource_url": resource_url, "base64_resource_url": resource_url_base64, "resource_id": resource.id, "view_url": view_url } }) return result
def restore_object(self, attrs, instance=None): user = self.context['request'].user classgroup = attrs.get('classgroup') name = attrs.get('name') attributes = ['data', 'approved'] if instance is None: instance = Resource(user=user, classgroup=classgroup, name=alphanumeric_name(name), display_name=name) instance.save() else: if instance.user != user: raise serializers.ValidationError("Class name is already taken.") instance = set_attributes(attributes, attrs, instance) return instance
def get(self): """Downloads a file.""" path = self.request_path resource = Resource.get_by_path(path) if not resource: return self.response.set_status(404, "Not Found") if resource.is_collection: template_values = { 'path': path, 'prefix': self._prefix, 'resources': [ child for child in resource.children if not child.display_name.startswith('.') ] } template_path = os.path.join(os.path.dirname(__file__), 'templates/collection.html') self.response.out.write( template.render(template_path, template_values)) else: # deliver the file data self.response.headers[ 'Content-Type'] = resource.content_type_or_default self.response.out.write(resource.data.blob)
def payoutResources(camps): """ Grabs all of the camp type structures and gives resources to owners.""" # TODO: If this starts to become costly, look into optimizing this via # Keys-only queries. logging.info('called it') # map the players that need to updated into a cache. players_to_update = {} # Map the resources that need to be updated into a cache. resources_to_update = {} for camp in camps: logging.info('camp: ' + str(camp)) # TODO: Add some contested area checking. # TODO: Add error checking on all of this. # Get the player who owns camp, first from the cache, then the store. owner_key = camp.owner_key owner = None if owner_key in players_to_update: owner = players_to_update[owner_key] else: owner = camp.owner_key.get() tile_resource = camp.harvesting_camp_data.tile_resource_key.get() template_key = tile_resource.resource_template # If the player already has the resource, up the quantity. for resource_key in owner.resources: # Get the resource from the cache first, otherwise get it from store. resource = None if resource_key in resources_to_update: logging.info('getting resource from dict') resource = resources_to_update[resource_key] else: logging.info('getting resource from resource_key: ' + str(resource_key)) resource = resource_key.get() if not resource: logging.error('Resource is None. Key is: ' + str(resource_key)) continue if resource.resource_template == template_key: resource.quantity += determineHarvestRate(tile_resource) resources_to_update[resource_key] = resource # In python, if you break a for loop, the else does not trigger. # This is the for/else logic... # http://book.pythontips.com/en/latest/for_-_else.html break # If the player doesn't already have the resource, create one. else: # TODO: Find out if there is a way to put_multi this resource. owner.resources.append( Resource( resource_template=template_key, quantity=determineHarvestRate(tile_resource)).put()) players_to_update[owner_key] = owner # Now all of the resources and players to update should be ready to be put. entities_to_put = players_to_update.values( ) + resources_to_update.values() ndb.put_multi(entities_to_put)
def add_from_csv(txt_file): f = open(txt_file, 'r') content = f.readlines() f.close() print len(content) # read each line in the tab-separated txt file and add the a resource for that line for line in content: line = line.strip().split('\t') if line[10]: description = line[10] else: description = "No description available" resource = Resource(subject=line[0], topic=line[1], name=line[2], link=line[3], instructor=line[4], college=line[5], lecture_notes=line[6] == "TRUE", videos=line[7] == "TRUE", assignments=line[8] == "TRUE", book=line[9] == "TRUE", description=description) db.session.add(resource) db.session.commit()
def fetch(self, msg): qres = msg.get('qres') keep_file = msg.get('keep_file') keep_tempfile = msg.get('keep_tempfile') request = Request(self, qres.url, keep_file=keep_file, keep_tempfile=keep_tempfile) request.fetch() res = Resource( url=qres.url, level=qres.level, context=qres.context, status_code=request.status_code, content_type=request.content_type, content_length=request.content_length, ) msg = { 'qres': qres, 'res': res, 'filepath': request.tempfile, } self.fetch_results.put(msg)
def test_get_reservations(self): customer = Customer(name='Teemu Teekkari', email='teemu.teekkari@aalto fi') service1 = Service(name='service1', price=10.0, duration=60.0, description='service1 description') service2 = Service(name='service1', price=10.0, duration=60.0, description='service1 description') self.db.save(service1) self.db.save(service2) added_reservations = [] date = QtCore.QDate.currentDate() resource = Resource(name="Resource1", resource_type="ROOM") for x in range(8, 19): start_time = QtCore.QTime(x, 0) end_time = QtCore.QTime(x, 59) start = QtCore.QDateTime(date, start_time) end = QtCore.QDateTime(date, end_time) new_reservation = Reservation(customer=customer, resource=resource, start=start, end=end, services=[service1, service2]) self.db.save(new_reservation) added_reservations.append(new_reservation) reservations = self.db.get_reservations() for i in range(len(reservations)): self.assertEqual(reservations[i], added_reservations[i])
def accept(self): name = self.name.text() resource_type = self.resource_type.text() if name: if self.resource: resource = Resource(ID=self.resource.ID, name=name, resource_type=resource_type) else: resource = Resource(name=name, resource_type=resource_type) self.database.save(resource) self.information = MessageDialog("Resource added", icon=QtWidgets.QMessageBox.Information) self.information.show() self.close() self.parent.update() else: self.information = MessageDialog("Please fill in name.") self.information.show()
def api_create_resource(request, *, name, employee_id, email, introduce): check_admin(request) if not name or not name.strip(): raise APIValueError('name', 'name cannot be empty.') if not employee_id or not employee_id.strip(): raise APIValueError('employee_id', 'employee_id cannot be empty.') if not email or not email.strip(): raise APIValueError('email', 'email cannot be empty.') if not introduce or not introduce.strip(): raise APIValueError('introduce', 'introduce cannot be empty.') resource = Resource(name=name.strip(), employee_id=employee_id.strip(), image=request.__user__.image, email=email.strip(), introduce=introduce.strip()) yield from resource.save() return resource
def mkcol(self): """Creates a subdirectory, given an absolute path.""" path = self.request_path parent_path = os.path.dirname(path) # check for duplicate if Resource.exists_with_path(path): return self.response.set_status(405, "Method Not Allowed") # fetch parent if parent_path: parent = Resource.get_by_path(parent_path) if not parent: return self.response.set_status( 409, "Conflict") # must create parent folder first else: parent = Resource.root() logging.info("Creating dir at %s" % path) collection = Resource(path=path, parent_resource=parent, is_collection=True) collection.put() self.response.set_status(201, 'Created')
def put(self): """Uploads a file.""" path = self.request_path parent_path = os.path.dirname(path) # anything at this path already? existing_resource = Resource.get_by_path(path) if existing_resource: existing_resource.delete_recursive() # fetch parent if parent_path: parent = Resource.get_by_path(parent_path) if not parent or not parent.is_collection: return self.response.set_status(409, "Conflict") # must create parent folder first else: parent = Resource.root() logging.info("Creating resource at %s" % path) data = ResourceData(blob=self.request.body) data.put() resource = Resource(path=path, parent_resource=parent, data=data) resource.content_length = len(self.request.body) resource.put() self.response.set_status(201, "Created")
def post(self): resource_id = self.request.get('id') resource_name = self.request.get('name') start_time = time( *map(int, self.request.get('available_start_time').split(':'))) start_time = datetime.combine(datetime.today(), start_time) duration = int(self.request.get('duration')) resource = Resource.query(Resource.id == resource_id).get() end_time = start_time + timedelta(minutes=duration) # check time format and availability has_error = False msg = '' # error check if end_time < start_time: has_error = True msg = 'Error, wrong format of start time or duration. Please return to former page to enter correctly.' elif resource.available_start_time > start_time or \ resource.available_end_time < end_time: has_error = True msg = 'Error, resource not available during the selected period. Please return to former page to enter another time period.' else: reservations = Reservation.query( Reservation.resource_id == resource_id).fetch() for r in reservations: if not (end_time <= r.start_time or start_time >= r.end_time): has_error = True msg = 'Error, reservation conflict. Please return to former page to enter another time period.' if has_error: template = JINJA_ENVIRONMENT.get_template('newReservation.html') template_values = {'msg': msg} self.response.write(template.render(template_values)) else: # add reservation if no error reservation = Reservation() reservation.id = str(uuid.uuid4()) reservation.user = str(users.get_current_user().email()) reservation.start_time = start_time reservation.duration = duration reservation.end_time = end_time reservation.resource_id = resource_id reservation.resource_name = resource_name reservation.put() resource.last_reservation_time = datetime.now() - timedelta( minutes=300) resource.num_reserved += 1 resource.put() t.sleep(1) send_mail(resource, reservation) self.redirect('/')
def get_resources(self): # TODO(Ling): Implement multiple pages. # TODO(Ling): Add KeyProperty to Tag model. all_resources = Resource.query().fetch() data = [] for resource in all_resources: if self.tag.key in resource.tag_keys: data.append(resource) return data
def saveResource(request): #print("Test") resources = Resource.objects.all() #print(resources.length) resoID = resources.__len__() + 1 #print(ResoID) name = request.GET["Name"] lat = request.GET["Lat"] lng = request.GET["Lng"] skills = request.GET["Skills"] newResource = Resource(ResoID=resoID, Name=name, Lat=lat, Lng=lng, Skills=skills) newResource.save() return HttpResponse("OK")
def delete(self): """Deletes a resource at a url. If it's a collection, it must be empty.""" path = self.request_path resource = Resource.get_by_path(path) if not resource: return self.response.set_status(404, "Not Found") resource.delete_recursive()
def test_duplicate_submission(self): lo1 = self.lo0 url = 'http://www.google.com/' r = Resource(objective=lo1, url=url) r.full_clean() r.save() rs = ResourceSubmission(user=self.u1, resource=r, type='c') rs.full_clean() rs.save() rs = ResourceSubmission(user=self.u1, resource=r, type='c') self.assertRaises(ValidationError, lambda: rs.full_clean()) # can't vote on a resource you submitted rs = ResourceSubmission(user=self.u1, resource=r, type='v') with self.assertRaisesRegexp(ValidationError, 'cannot vote.*submitted'): rs.full_clean()
def addSubscriptionView(request): if request.method == 'POST': url = request.POST['url'] title = request.POST['title'] description = request.POST['description'] html_request = requests.get(url) url=html_request.url code_html = html_request.text resource = Resource(url=url, title=title, description=description) resource.save() tasks.create_new_version(resource, code_html ,1) return redirect('/followeb/') return HttpResponseBadRequest('Bad Request')
def bundles_resources_save(request, uuid): response = [] for uploaded_file in request.FILES.values(): if is_text_file(uploaded_file): resource = Resource(bundle=Bundle.api.get(uuid, request.user)) resource.source = ''.join([ chunk for chunk in uploaded_file.chunks() ]) resource.save() response.append(resource.uuid) if len(response) and not len(messages.get_messages(request)): messages.success(request, _(u'New resources uploaded.')) if not request.is_ajax(): return redirect('app_bundles_detail', uuid) return HttpResponse( simplejson.dumps(response), mimetype='application/json' )
def move(self): """Moves a resource from one path to another.""" path = self.request_path resource = Resource.get_by_path(path) if not resource: return self.response.set_status(404, "Not Found") overwrite = self.request.headers.get("Overwrite", "T") destination = self.request.headers["Destination"] # exception if not present destination_path = self.url_to_path(urlparse(destination).path) parent_path = os.path.dirname(destination_path) if path == destination_path: return self.response.set_status(403, "Forbidden") # anything at this path already? existing_resource = Resource.get_by_path(destination_path) if existing_resource: if overwrite == "T": existing_resource.delete_recursive() else: return self.response.set_status(412, "Precondition Failed") # fetch parent if parent_path: parent = Resource.get_by_path(parent_path) if not parent or not parent.is_collection: return self.response.set_status(409, "Conflict") # must create parent folder first else: parent = Resource.root() resource.parent_resource = parent # reparent this node resource.move_to_path(destination_path) self.response.set_status(204 if existing_resource else 201)
def request_json(**kwargs): if request.json: global r r = Resource() for k, v in kwargs.iteritems(): r.rid = v # Now automatically updated r.title = request.json['title'] r.link = str(request.json['link']) # Insert Tags to Tags Object r.tags = [] for item in request.json['tags']: t = Tags() t.tag_name = item['tag_name'] r.tags.append(t) r.description = request.json['description'] r.save(upsert=True)
def get_content(request, uri): try: resource = Resource.objects.get(uri=uri) if not resource.retrieved: result = resource.source.getManager().get(uri) except ObjectDoesNotExist: result = None for repository in Repository.objects.all(): result = repository.getManager().get(uri) if result is not None: resource = Resource( uri = uri, source = repository, ) resource.save() break if not resource.retrieved and result is not None: resource = attach_content(resource, result) response = HttpResponse(resource.content, content_type=resource.contentType) response['Content-Disposition'] = 'attachment; filename="'+resource.title+'"' return response
def get(self): """Downloads a file.""" path = self.request_path resource = Resource.get_by_path(path) if not resource: return self.response.set_status(404, "Not Found") if resource.is_collection: template_values = { "path": path, "prefix": self._prefix, "resources": [child for child in resource.children if not child.display_name.startswith(".")], } template_path = os.path.join(os.path.dirname(__file__), "templates/collection.html") self.response.out.write(template.render(template_path, template_values)) else: # deliver the file data self.response.headers["Content-Type"] = resource.content_type_or_default self.response.out.write(resource.data.blob)
def setUp(self): self.u1_password = '******' self.u1 = User.objects.create_user(username='******', email='*****@*****.**', password=self.u1_password) user = authenticate(username=self.u1.username, password=self.u1_password) assert user self.u2 = User.objects.create_user(username='******', email='*****@*****.**') self.cc0 = CourseCategory(id='TESTNA', description='Test Non-Academic') self.cc0.full_clean() self.cc0.save() self.c0 = Course(id='Class00', cat=self.cc0, description='Class00Desc') self.c0.full_clean() self.c0.save() self.lo0 = LearningObjective(id=dummy_objective_id, course=self.c0, description=dummy_objective_description) self.lo0.full_clean() self.lo0.save() self.res1 = Resource(objective=self.lo0, url=dummy_resource_url) self.res1.full_clean() self.res1.save() self.ressub1 = ResourceSubmission(user=self.u1, resource=self.res1, type='v', comment=dummy_comment) self.ressub1.full_clean() self.ressub1.save()
def upload_file(): if request.method == "POST": id = request.args["id"] if id: f = request.files["file"] resource = Resource() resource.id = uuid.uuid4().__str__() resource.bs_id = id name = f.filename extension = getFileExt(name) resource.extension = extension resource.file_name = (resource.id) + "." + extension resource.real_name = name session = DBSession() session.add(resource) session.commit() session.close() f.save(current_app.config.get("UPLOADED_FILE") + resource.file_name) return jsonify(code=0)
def mkcol(self): """Creates a subdirectory, given an absolute path.""" path = self.request_path parent_path = os.path.dirname(path) # check for duplicate if Resource.exists_with_path(path): return self.response.set_status(405, "Method Not Allowed") # fetch parent if parent_path: parent = Resource.get_by_path(parent_path) if not parent: return self.response.set_status(409, "Conflict") # must create parent folder first else: parent = Resource.root() logging.info("Creating dir at %s" % path) collection = Resource(path=path, parent_resource=parent, is_collection=True) collection.put() self.response.set_status(201, "Created")
def get_or_create_resource(session, rad_record, lazy=True, create_categories=True): """ Checks to see if a resource already exists in the database and adds it if it does not exist (or is forced to by use of the lazy argument). Args: session: The current database session. rad_record: The RadRecord to be added. lazy: If false, forces the record to be added even if it is a duplicate. Defaults to true. create_categories: If true, will create categories if they don't already exist. If false, will skip over listed categories that don't already exist. Defaults to true. Returns: Two values. The first value is a boolean indicating if a new record was created. The second value will be the created/updated model. """ # Just create a new record always if we're lazy-loading. This avoids # weirdness in which we're partially updating an item. if lazy: new_record = True record = Resource(name=rad_record.name.strip()) session.add(record) else: new_record, record = get_or_create(session, Resource, name=rad_record.name.strip()) record.last_updated = datetime.utcnow() if new_record: record.date_created = datetime.utcnow() if new_record or not lazy: # See if we have just a normal address field - if not, # manually construct one by joining all available # fields with commas new_address = '' if hasattr(rad_record, 'address') and \ rad_record.address is not None and \ rad_record.address != '' and \ not rad_record.address.isspace(): new_address = rad_record.address.strip() else: new_address = ", ".join(a.strip() for a in [rad_record.street, rad_record.city, rad_record.state, rad_record.zipcode, rad_record.country] if a is not None and a != '' and not a.isspace()) # Address issue 131 - if we're updating an existing # record, and are changing the address (using a lowercase comparison), # invalidate the existing geocoding information. if not new_record and \ record.address is not None and \ record.address.lower() != new_address.lower(): record.latitude = None record.longitude = None record.location = None # Now set the new address if new_address != '' and not new_address.isspace(): record.address = new_address else: record.address = None # Try to parse out the date_verified field if it's provided if rad_record.date_verified is not None and \ len(rad_record.date_verified) > 0 and \ not rad_record.date_verified.isspace(): # Try to parse it out using 'YYYY-MM-DD' try: record.date_verified = datetime.strptime(rad_record.date_verified, '%Y-%m-%d').date() except ValueError: # Parsing error, clear it out record.date_verified = None else: # Not provided - clear it out record.date_verified = None # Copy over all the other fields verbatim record.organization = rad_record.organization record.description = rad_record.description record.email = rad_record.email record.phone = rad_record.phone record.fax = rad_record.fax record.url = rad_record.url record.hours = rad_record.hours record.source = rad_record.source record.npi = rad_record.npi record.notes = rad_record.notes record.visible = rad_record.visible # Do we have a list of category names? # Failing that, do we have a single category name? if hasattr(rad_record, 'category_names') and \ rad_record.category_names is not None and \ len(rad_record.category_names) > 0: # Use the list of category names try_add_categories(session, record, rad_record.category_names, create_categories) elif hasattr(rad_record, 'category_name') and \ rad_record.category_name is not None and \ not rad_record.category_name.isspace(): # Use the single category name try_add_categories(session, record, [rad_record.category_name], create_categories) # Do we have a list of population tags? if hasattr(rad_record, 'population_tags') and \ rad_record.population_tags is not None and \ len(rad_record.population_tags) > 0: try_add_populations(session, record, rad_record.population_tags) session.add(record) # Flush the session because otherwise we won't pick up # duplicates with UNIQUE constraints (such as in category names) # until we get an error trying to commit such duplicates # (which is bad) session.flush() return new_record, record
def create(self, request): term = '' guid = None email = '' leaseid = '' try: if request.POST.get('term') and request.POST['term']: term = request.POST['term'] if request.POST.get('email') and request.POST['email']: email = request.POST['email'] if request.POST.get('guid') and request.POST['guid']: guid = request.POST['guid'] if request.POST.get('leaseid') and request.POST['leaseid']: leaseid = request.POST['leaseid'] if term==None or email==None or int(term) < 0 or int(term) > 365: return HttpResponse(json.dumps({'status':'error', 'msg':'Term and email required.Term has to be less than 365 days'}), status=400) if guid == None: resource = Resource() #guid = uuid.uuid4 #resource.guid = guid resource.callbackurl = '' resource.callbackauth = '' resource.save() print('resource saved') guid = resource.guid try: print('all_resources='+repr(Resource.objects.all())) resource = Resource.objects.get(guid=guid) except Resource.DoesNotExist: resource = None return HttpResponse(json.dumps({ 'status': 'error', 'msg': 'Resource could not be created', 'lease':'', }), status=500) try: subscriber = Subscriber.objects.get(email=email) except Subscriber.DoesNotExist: subscriber = None pass if subscriber == None: subscriber = Subscriber() subscriber.email = email subscriber.save() subscriber = Subscriber.objects.get(email=email) if not leaseid: lease = ResourceLease() print('lease.resource='+repr(resource)) lease.resource = resource lease.subscriber = subscriber lease.term = int(term) from datetime import timedelta lease.expires = datetime.datetime.now() + timedelta(days=int(term)) lease.status = 'A' lease.save() print('lease.id'+str(lease.id)) leaseid = str(lease.id) try: lease = ResourceLease.objects.get(id=leaseid) except ResourceLease.DoesNotExist: lease = None return HttpResponse(json.dumps({ 'status': 'error', 'msg': 'Resource could not be created', 'lease':'', }), status=500) queryset = ResourceSubscribers.objects.filter(resource=resource) recipients = [] for item in queryset: recipients.append(item.subscriber.email) if email not in recipients: recipients.append(email) ressub = ResourceSubscribers() ressub.resource = resource ressub.subscriber = subscriber ressub.save() return HttpResponse(json.dumps({'status':'success', 'guid':str(guid), 'leaseid':str(leaseid), 'subscribers':recipients})) except: import sys exc_type, exc_value, exc_traceback = sys.exc_info() import traceback msg = repr(traceback.format_exception(exc_type, exc_value, exc_traceback)) logger.warn(msg) return HttpResponse(json.dumps({ 'status': 'error', 'msg': msg, 'lease':'', }), status=500) finally: pass
def test_duplicate_resource(self): r = Resource() r.name = 'resource1' with self.assertRaises(IntegrityError) as e: print "Testing for exception..." r.save()
def main(show_progress, *args, **kwargs): # Create a new fetch index for the records fetched. last_fetch_index = Dataset.select(fn.Max(Dataset.fetch_index)).scalar() or 0 fetch_index = last_fetch_index + 1 # Set up progress bar if show_progress: progress_bar = ProgressBar(widgets=[ 'Progress: ', Percentage(), ' ', Bar(marker=RotatingMarker()), ' ', ETA(), ' Fetched metadata for ', Counter(), ' datasets.' ]) progress_bar.start() # Fetch all pages of datasets datasets_fetched = 0 last_page = False while not last_page: params = DEFAULT_PARAMS.copy() params['start'] = datasets_fetched resp = make_request(default_requests_session.get, URL, params=params).json() if not resp['success']: logging.error("Request to URL %s was unsuccessful", URL) result = resp['result'] num_datasets = len(result['results']) datasets_fetched += num_datasets if show_progress: # We can finally initialize the total number of datasets expected # only after we get the first round of results. progress_bar.maxval = result['count'] progress_bar.update(datasets_fetched) for dataset in result['results']: dataset_record = Dataset.create( dataset_id=dataset['id'], title=trim_char_data(dataset['title']), license_title=trim_char_data(['license_title']), fetch_index=fetch_index, ) for resource in dataset['resources']: if resource['format'] == DATA_FORMAT: Resource.create( resource_id=resource['id'], dataset=dataset_record, format=resource['format'], url=resource['url'], ) time.sleep(REQUEST_DELAY) # enforce a pause between each fetch to be respectful to API last_page = datasets_fetched >= result['count'] if show_progress: progress_bar.finish()
def propfind(self): path = self.request_path self.propfind_resource(Resource.get_by_path(path))
class BasicTests(TestCase): def setUp(self): self.u1_password = '******' self.u1 = User.objects.create_user(username='******', email='*****@*****.**', password=self.u1_password) user = authenticate(username=self.u1.username, password=self.u1_password) assert user self.u2 = User.objects.create_user(username='******', email='*****@*****.**') self.cc0 = CourseCategory(id='TESTNA', description='Test Non-Academic') self.cc0.full_clean() self.cc0.save() self.c0 = Course(id='Class00', cat=self.cc0, description='Class00Desc') self.c0.full_clean() self.c0.save() self.lo0 = LearningObjective(id=dummy_objective_id, course=self.c0, description=dummy_objective_description) self.lo0.full_clean() self.lo0.save() self.res1 = Resource(objective=self.lo0, url=dummy_resource_url) self.res1.full_clean() self.res1.save() self.ressub1 = ResourceSubmission(user=self.u1, resource=self.res1, type='v', comment=dummy_comment) self.ressub1.full_clean() self.ressub1.save() def test_1(self): """Basic creation of Resource, disallowing same URL+objective combination""" lo1 = self.lo0 url1 = 'http://127.0.0.1/foo.html' r1 = Resource(objective=lo1, url=url1) self.assertEquals(r1.votes, 0) self.assertEquals(r1.inappropriate_flags, 0) r1.save() when_added = r1.when_added now = datetime.datetime.now() when_added = when_added.replace(tzinfo=None) self.assertTrue(now - when_added < datetime.timedelta(seconds=5)) r2 = Resource(objective=lo1, url=url1) self.assertRaises(IntegrityError, lambda: r2.save()) def test_bad_url(self): bad_urls = ('ftp://*****:*****@example.com/', 'http://*****:*****@example.com/', 'http://foo', ) for (bad_url, i) in zip(bad_urls, range(len(bad_urls))): r = Resource(objective=self.lo0, url=bad_url) self.assertRaises(ValidationError, lambda: r.full_clean()) def test_duplicate_submission(self): lo1 = self.lo0 url = 'http://www.google.com/' r = Resource(objective=lo1, url=url) r.full_clean() r.save() rs = ResourceSubmission(user=self.u1, resource=r, type='c') rs.full_clean() rs.save() rs = ResourceSubmission(user=self.u1, resource=r, type='c') self.assertRaises(ValidationError, lambda: rs.full_clean()) # can't vote on a resource you submitted rs = ResourceSubmission(user=self.u1, resource=r, type='v') with self.assertRaisesRegexp(ValidationError, 'cannot vote.*submitted'): rs.full_clean() # okay to flag a resource you submitted as inappropriate def test_strings(self): lo2 = self.lo0 url = 'http://www.google.com/' r = Resource(objective=lo2, url=url) r.full_clean() r.save() rs = ResourceSubmission(user=self.u1, resource=r, type='c') rs.full_clean() rs.save() self.assertTrue(' created ' in str(rs)) self.assertEquals(rs.type_str(), 'Created') rs = ResourceSubmission(user=self.u1, resource=r, type='f') rs.full_clean() rs.save() self.assertTrue(' flagged ' in str(rs)) self.assertEquals(rs.type_str(), 'Inappropriate') rs = ResourceSubmission(user=self.u2, resource=r, type='v') rs.full_clean() rs.save() self.assertTrue(' voted on ' in str(rs)) self.assertEquals(rs.type_str(), 'Up-voted') def test_index(self): response = self.client.get("/resources/") self.assertContains(response, self.res1.url) def test_detail(self): detail_url = "/resources/" + str(self.res1.id) + "/" response = self.client.get(detail_url) self.assertContains(response, self.res1.url) def test_create_resource(self): login = self.client.login(username=self.u1.username, password=self.u1_password) self.assertTrue(login) create_url = '/resources/create/?objective=%s' % dummy_objective_id response = self.client.get(create_url, follow=True) self.assertContains(response, 'Submit a resource') self.assertContains(response, dummy_objective_id) response = self.client.post(create_url, {'url': 'http://www.example.com/', 'objective': dummy_objective_id}, follow=True) self.assertNotContains(response, 'form-group has-error') self.assertContains(response, 'http://www.example.com/') self.assertContains(response, dummy_objective_id) def test_comment_on_resource(self): login = self.client.login(username=self.u1.username, password=self.u1_password) self.assertTrue(login) comment_url = "/resources/" + str(self.res1.id) + "/comment/" response = self.client.get(comment_url, follow=True) self.assertContains(response, 'Comment on a resource') self.assertContains(response, self.res1.url) response = self.client.post(comment_url, {'resource': str(self.res1.id), 'type': 'v'}, follow=True) self.assertNotContains(response, 'form-group has-error') # This accesses the API endpoint in the test instance, not the one in # the real instance. def test_resource_api(self): response = self.client.get('/resources/api/resource/') self.assertContains(response, dummy_resource_url) objects = json.loads(response.content)['objects'] for o in objects: response = self.client.get(o['objective']) self.assertContains(response, '/repo/api/learningobjective/') response = self.client.get(o['resource_uri']) self.assertContains(response, '/resources/api/resource/' + str(o['id'])) def test_submission_api(self): response = self.client.get('/resources/api/resourcesubmission/') self.assertContains(response, dummy_comment) objects = json.loads(response.content)['objects'] for o in objects: for k in ('resource', 'resource_uri'): response = self.client.get(o[k]) self.assertEqual(response.status_code, 200) def test_rv_strings(self): now = datetime.datetime.utcnow().replace(tzinfo=utc) rv = ResourceVerification(url='http://127.0.0.1/abcd/', last_failure=now - datetime.timedelta(seconds=1)) rv.full_clean() rv.save() self.assertEquals(rv.status_char(), 'I') self.assertEquals(rv.status_str(), 'Invalid') rv.last_success = now self.assertEquals(rv.status_char(), 'V') self.assertEquals(rv.status_str(), 'Valid') self.assertEquals(str(rv), 'Valid:' + rv.url) rv.last_failure = now + datetime.timedelta(seconds=1) self.assertEquals(rv.status_char(), 'I') rv.last_failure = None self.assertEquals(rv.status_char(), 'V')
def add(): """add resource""" if not g.user.is_authenticated(): return render_template('add.html') if request.method == 'GET': return render_template('add.html') resource_type = request.form['resource_type'] tags = request.form.getlist('tags') url = request.form['url'].strip() resources_to_add = [] sniffed_resources = sniff_test_resource(CONFIG, resource_type, url) if not sniffed_resources: msg = gettext("No resources detected") LOGGER.exception() flash(msg, 'danger') for (resource_type, resource_url, title, success, response_time, message, start_time, resource_tags,) in sniffed_resources: # sniffed_resources may return list of resource # types different from initial one # so we need to test each row separately resource = Resource.query.filter_by(resource_type=resource_type, url=url).first() if resource is not None: msg = gettext('Service already registered') flash('%s (%s, %s)' % (msg, resource_type, url), 'danger') if len(sniffed_resources) == 1 and 'resource_type' in request.args: return redirect(url_for('add', lang=g.current_lang)) tags_to_add = [] for tag in chain(tags, resource_tags): tag_obj = tag if not isinstance(tag, Tag): tag_obj = Tag.query.filter_by(name=tag).first() if tag_obj is None: tag_obj = Tag(name=tag) tags_to_add.append(tag_obj) resource_to_add = Resource(current_user, resource_type, title, resource_url, tags=tags_to_add) resources_to_add.append(resource_to_add) probe_to_add = None checks_to_add = [] # Always add a default Probe and Check(s) # from the GHC_PROBE_DEFAULTS conf if resource_type in CONFIG['GHC_PROBE_DEFAULTS']: resource_settings = CONFIG['GHC_PROBE_DEFAULTS'][resource_type] probe_class = resource_settings['probe_class'] if probe_class: # Add the default Probe probe_obj = Factory.create_obj(probe_class) probe_to_add = ProbeVars( resource_to_add, probe_class, probe_obj.get_default_parameter_values()) # Add optional default (parameterized) # Checks to add to this Probe checks_info = probe_obj.get_checks_info() checks_param_info = probe_obj.get_plugin_vars()['CHECKS_AVAIL'] for check_class in checks_info: check_param_info = checks_param_info[check_class] if 'default' in checks_info[check_class]: if checks_info[check_class]['default']: # Filter out params for Check with fixed values param_defs = check_param_info['PARAM_DEFS'] param_vals = {} for param in param_defs: if param_defs[param]['value']: param_vals[param] =\ param_defs[param]['value'] check_vars = CheckVars( probe_to_add, check_class, param_vals) checks_to_add.append(check_vars) result = run_test_resource(resource_to_add) run_to_add = Run(resource_to_add, result) DB.session.add(resource_to_add) # prepopulate notifications for current user resource_to_add.set_recipients('email', [g.user.email]) if probe_to_add: DB.session.add(probe_to_add) for check_to_add in checks_to_add: DB.session.add(check_to_add) DB.session.add(run_to_add) try: DB.session.commit() msg = gettext('Services registered') flash('%s (%s, %s)' % (msg, resource_type, url), 'success') except Exception as err: DB.session.rollback() flash(str(err), 'danger') return redirect(url_for('home', lang=g.current_lang)) if len(resources_to_add) == 1: return edit_resource(resources_to_add[0].identifier) return redirect(url_for('home', lang=g.current_lang))