def modify_resource():
if 'resource_ids' not in session:
session['resource_ids'] = db_handler.get_resource_ids()
# POST
if request.method == 'POST':
# Load Resource
if request.form.get('res_sel'):
session['resource'] = Resource(request.form['res_sel']).serialize()
# Modify keys
else:
resource = decode(session['resource'])
mod_keys = list()
for key in resource.keys:
mod_key = dict(KEY_ID=key['KEY_ID'], KEY_NAAM=key['KEY_NAAM']
, KEY_GELDIG=int(request.form[key['KEY_NAAM']]))
mod_keys.append(mod_key)
resource.update_keys(mod_keys)
session['resource'] = resource.serialize()
# GET
else:
if 'resource' not in session:
session['resource'] = Resource(session['resource_ids'][0]).serialize()
return render_template('modify_resource.html'
, resource=decode(session['resource'])
, resource_ids=session['resource_ids']
, choices=VALID_KEYS_VALS)
def create_resources():
try:
req = request.get_json(force=True)
if req["data"] != "":
data = req["data"]
else:
data = req
except Exception:
data = request.get_data().decode("utf-8")
data = data.split("|")
data = {
"name": data[0],
"parent_name": data[1],
"instance_type": data[2],
"imported_at": data[3]
}
if 'name' not in data or 'parent_name' not in data or 'imported_at' not in data:
return bad_request(
'must include name, parent_name, instance_type and imported_at')
resource = Resource()
resource.from_dict(data, new_data=True)
db.session.add(resource)
db.session.commit()
response = {"isSucceed": True, "resource": resource.to_dict()}
response = jsonify(response)
response.headers['Location'] = url_for('api.get_resource_by_id',
id=resource.id)
return response
def resource_del():
res_id = request.form.get('res_id', -1)
if res_id != -1:
res = Resource.get_by_id(res_id)
ret = Resource.delete_res(res)
else:
ret = u'删除失败'
return jsonify(ret=ret)
def resource_del():
res_id = request.form.get('res_id', -1)
if res_id != -1:
res = Resource.get_by_id(res_id)
ret = Resource.delete_res(res)
else:
ret = u'删除失败'
return jsonify(ret = ret)
def test_res(self):
u = User(username='******', email='*****@*****.**')
res = Resource(body="hello")
res.issuer = u
db.session.add(res)
db.session.commit()
users = User.query.all()
self.assertEqual(users[0].resources[0].body, 'hello')
self.assertEqual(users[0].resources[0].issuer.username, 'asdf')
self.assertEqual(users[0].resources.count(), 1)
def resource_map():
if 'resource_ids' not in session:
session['resource_ids'] = db_handler.get_resource_ids()
if request.method == 'POST':
session['resource'] = Resource(request.form['res_sel']).serialize()
else:
if 'resource' not in session:
session['resource'] = Resource(session['resource_ids'][0]).serialize()
return render_template('resource_map.html', resource_ids=session['resource_ids'],
resource=decode(session['resource']))
def add_one_resource(self):
user = User.query.filter_by(email="*****@*****.**").first()
resource = Resource()
resource.deserialize({
'name' : "test_res",
'owner_id' : user.id,
'available_start': "5:00",
'available_end' : "17:00"
})
db.session.add(resource)
db.session.commit()
def test_delete(self):
u1 = User(username='******', email='*****@*****.**')
res = Resource(body="hello")
res.issuer = u1
db.session.add(u1)
db.session.add(res)
db.session.commit()
self.assertEqual(u1.id, 1)
self.assertEqual(res.id, 1)
db.session.delete(u1)
# db.session.commit()
self.assertTrue(len(User.query.all())==0)
self.assertTrue(len(Resource.query.all())==1)
def test_create_a_resource_missing_key(self):
resource = Resource()
error = False
try:
resource.deserialize({
'name' : "test_res",
'available_start': "5:00",
'available_end' : "17:00"
})
except KeyError as e:
self.assertTrue("Invalid resource: missing" in e.message)
error = True
self.assertTrue(error)
def test_buy(self):
u1 = User(username='******', email='*****@*****.**')
res = Resource(body="hello")
res.issuer = u1
u2 = User(username='******')
db.session.add(u1)
db.session.add(u2)
db.session.add(res)
db.session.commit()
u2.buy_res(res)
db.session.commit()
self.assertEqual(Certs.query.all()[0].payer_id, 2)
def test_create_a_resource_wrong_value(self):
resource = Resource()
error = False
try:
resource.deserialize({
'name' : "test_res",
'owner_id' : 'not_integer',
'available_start': "5:00",
'available_end' : "17:00"
})
except ValueError as e:
self.assertTrue("body of request contained bad or no data" in e.message)
error = True
self.assertTrue(error)
def create_resources(json, db):
try:
# Resources to return in the response
created_resources = []
# Serialized Resources to send to Algolia
created_resources_algolia = []
# Resource IDs to delete if Algolia fails to index
resource_id_cache = []
# Create each Resource in the database one by one
for resource in json:
langs, categ = get_attributes(resource)
new_resource = Resource(
name=resource.get('name'),
url=resource.get('url'),
category=categ,
languages=langs,
paid=resource.get('paid'),
notes=resource.get('notes'))
try:
db.session.add(new_resource)
db.session.commit()
created_resources_algolia.append(new_resource.serialize_algolia_search)
resource_id_cache.append(new_resource.id)
except IntegrityError as e:
logger.exception(e)
return utils.standardize_response(status_code=422)
except Exception as e:
logger.exception(e)
return utils.standardize_response(status_code=500)
created_resources.append(new_resource.serialize)
# Take all the created resources and save them in Algolia with one API call
try:
index.save_objects(created_resources_algolia)
except (AlgoliaUnreachableHostException, AlgoliaException) as e:
if (environ.get("FLASK_ENV") != 'development'):
logger.exception(e)
# Remove created resources from the db to stay in sync with Algolia
for res_id in resource_id_cache:
res = Resource.query.get(res_id)
res.languages.clear()
db.session.delete(res)
db.session.commit()
msg = "Algolia failed to index resources"
error = {'errors': [{"algolia-failed": {"message": msg}}]}
return utils.standardize_response(payload=error, status_code=500)
# Success
return utils.standardize_response(payload=dict(data=created_resources))
except Exception as e:
logger.exception(e)
return utils.standardize_response(status_code=500)
def edit_resource(resource_id):
"""
Validate the resource Id. Also check for the data in the json payload.
If the data exists update the resource with the new data.
:param resource_id: resource Id
:return: Http Json response
"""
if request.content_type == 'application/json':
data = request.get_json().get("resource")
link = data.get('link') if data.get('link') is not None else None
categories = data.get('categories') if data.get(
'categories') is not None else None
status = data.get('status') if data.get('status') is not None else None
updated_resource = Resource(link, categories, status)
if link or categories or status:
try:
int(resource_id)
except ValueError:
return response('failed', 'Please provide a valid resource Id',
400)
resource = Resource.query.filter_by(
resource_id=resource_id).first()
if resource:
resource.update(updated_resource)
return response_for_created_resource(resource, 201)
return response(
'failed',
'The resource with Id ' + resource_id + ' does not exist', 404)
return response(
'failed',
'No attribute or value was specified, nothing was changed', 400)
return response('failed', 'Content-type must be json', 202)
def get_resources():
page = request.args.get('page', 1, type=int)
per_page = min(request.args.get('per_page', 1000, type=int), 100)
query = Resource.query
data = Resource.to_collection_dict(query, page, per_page,
'api.get_resources')
return jsonify({"_count": query.count(), "data": data["items"]})
def test_edit_suggestion(self):
"""Test suggestion of an edit"""
r = Resource(name='test_edit')
db.session.add(r)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
r_added = Resource.query.filter_by(name='test_edit').first()
s_text = "The phone number of this establishment is incorrect: it should be 212-346-5927"
s_contact_name = "Anonymous Helper"
s_contact_email = "*****@*****.**"
s_contact_number = "000-001-0101"
s_timestamp = datetime.now(pytz.timezone('US/Eastern'))
suggestion = Suggestion(resource_id=r_added.id,
suggestion_text=s_text,
read=1,
contact_name=s_contact_name,
contact_email=s_contact_email,
contact_phone_number=s_contact_number,
submission_time=s_timestamp)
db.session.add(suggestion)
db.session.commit()
r_in_table = Suggestion.query.filter_by(suggestion_text=s_text).first()
self.assertTrue(r_in_table is not None)
self.assertTrue(r_in_table.suggestion_text == s_text)
self.assertTrue(r_in_table.resource_id == r_added.id)
self.assertTrue(r_in_table.read == 1)
self.assertTrue(r_in_table.contact_phone_number == s_contact_number)
self.assertTrue(r_in_table.submission_time is not None)
self.assertTrue(r_in_table.contact_name == s_contact_name)
self.assertTrue(r_in_table.contact_email == s_contact_email)
def create_resource():
form = CreateResourceForm()
if form.validate_on_submit():
print(form)
print(form.name.data)
print(form.description.data)
resource = Resource(
name=form.name.data,
description=form.description.data,
user_id=current_user.id,
)
try:
db.session.add(resource)
db.session.commit()
flash("Resource added.")
except:
flash("error adding resource. :(")
return redirect(url_for("main.list_resources"))
elif request.method == "GET":
# load editing data into form
pass
return render_template(
"create_resource.html", title="Add a bookable resource", form=form
)
def get_resource(id):
resource = Resource.get_single_resource_as_dict(id)
if resource is None:
return jsonify({})
return jsonify(resource)
def create_resource(json, db):
langs, categ = get_attributes(json)
new_resource = Resource(name=json.get('name'),
url=json.get('url'),
category=categ,
languages=langs,
paid=json.get('paid'),
notes=json.get('notes'))
try:
db.session.add(new_resource)
db.session.commit()
index.save_object(new_resource.serialize_algolia_search)
except (AlgoliaUnreachableHostException, AlgoliaException) as e:
logger.exception(e)
print(f"Algolia failed to index new resource '{new_resource.name}'")
except IntegrityError as e:
logger.exception(e)
return utils.standardize_response(status_code=422)
except Exception as e:
logger.exception(e)
return utils.standardize_response(status_code=500)
return utils.standardize_response(payload=dict(
data=new_resource.serialize))
def add_url():
new_url = request.form['new_url']
new_title = request.form['new_title']
new_resource = Resource(url=new_url, title=new_title)
db.session.add(new_resource)
db.session.commit()
return redirect('/further_resources')
def test_vote_information():
test_apikey = '1234abcd'
test_id = 1
test_direction = 'upvote'
resource = Resource(id=test_id,
name='name',
url='https://resource.url',
category=Category(name='Category'),
languages=[Language(name='language')],
paid=False,
notes='Some notes')
key = Key(email="*****@*****.**", apikey=test_apikey)
vote_info = VoteInformation(voter_apikey=key.apikey,
resource_id=resource.id,
current_direction=test_direction)
vote_info.voter = key
resource.voters.append(vote_info)
assert (vote_info.voter_apikey == test_apikey)
assert (vote_info.resource_id == test_id)
assert (vote_info.current_direction == test_direction)
assert (vote_info.voter == key)
assert (vote_info.resource == resource)
def _insert_resources(level_resources: List = None) -> None:
""" insert resources to database """
insert_resources_code = [
level_resource.get('code') for level_resource in level_resources
]
query_resources = db.session.query(Resource.code, Resource).all()
query_resources_dict = dict(query_resources)
query_resources_code = query_resources_dict.keys()
insert_code = set(insert_resources_code) ^ set(query_resources_code)
update_code = set(insert_resources_code) & set(query_resources_code)
for level_resource in level_resources:
level_code = level_resource.get('code')
if level_code in insert_code:
resource = Resource()
for key, value in level_resource.items():
if hasattr(resource, key):
setattr(resource, key, value)
db.session.add(resource)
elif level_code in update_code and query_resources_dict.get(level_code):
query_resource = query_resources_dict.get(level_code)
for key, value in level_resource.items():
if hasattr(query_resource, key):
setattr(query_resource, key, value)
else:
raise RuntimeError(f'Please check {level_resource}')
db.session.commit()
def issue():
form = ResIssueForm()
if form.validate_on_submit():
resfile = form.resfile.data
filename = resfile.filename
res = Resource(
title=form.title.data,
price=form.price.data,
body=form.body.data,
issuer=current_user,
filename=filename
)
db.session.add(res)
db.session.commit()
filedir = os.path.join(app.config['RES_FILE_PATH'], str(res.id))
if not pathlib.Path(filedir).exists():
os.makedirs(filedir)
resfile.save(
os.path.join(
app.config['RES_FILE_PATH'], str(res.id), res.filename
)
)
flash('1,发布成功！！！资源已上架！')
return redirect(url_for('index'))
return render_template('issue/res.html', title="issue resource", form=form)
def resource_fixture(user: User, topic: Topic, session: Session) -> Resource:
resource = Resource(name="UNSW",
url="unsw.edu.au",
user_id=user.id,
topics=[topic])
session.add(resource)
session.commit()
yield resource
def test_get_resources(self):
resource = Resource(resource_name="booking")
db.session.add(resource)
db.session.commit()
response = self.client.get("resource")
data = json.loads(response.data)
return self.assertEquals(data.get("count"), 1)
def create_resource():
if request.get_json() is None:
abort(422)
body = request.get_json()
if 'name' not in body or 'type' not in body or 'max' not in body or 'rate' not in body:
return abort(422)
name = body.get('name')
type = body.get('type')
max = body.get('max')
rate = body.get('rate')
resource = Resource(name, type, max, rate)
resource.insert()
return jsonify({'success': True, 'resource': resource.format()})
def add_fake_data(count):
"""
Adds fake data to the database.
"""
User.generate_fake(count=count)
ZIPCode.generate_fake()
Resource.generate_fake()
ResourceReview.generate_fake(count=count)
Address.generate_fake()
AffiliationTag.generate_default()
# Set a random zip for each user without one.
User.set_random_zip_codes(User.query.filter_by(zip_code=None).all(),
ZIPCode.query.all())
# Set a random affiliation tag for each user.
User.set_random_affiliation_tags(User.query.all(),
AffiliationTag.query.all())
def create_resource():
data = request.json
print("&&&&&&&&", data)
new_resource = Resource(name=data["name"],
department_id=data["departmentId"],
active=data["active"])
db.session.add(new_resource)
db.session.commit()
format_resource = new_resource.to_dict()
return {"resource": format_resource}
# @resources.route("/list")
# def department_list():
# departments = db.session.query(Department).all()
# format_departments = [{"id": department.id, "name": department.name} for department in departments]
# return {"departments":format_departments}
def fill_resource_data() -> None:
resource_graph = ResourceGraphModel.objects[:1].first()
resource_data_list = []
data = (_get_cpu_data(resource_graph) + _get_gpu_data(resource_graph) +
_get_memory_data(resource_graph) +
_get_system_data(resource_graph) +
_get_hard_disk_data(resource_graph) +
_get_network_data(resource_graph))
for item in data:
print(item)
resource_data = ResourceDataModel(**item)
resource_data_list.append(resource_data)
resource = ResourceModel()
resource.data = resource_data_list
resource.save()
def create_resource():
"""
Create an resource from the sent json data.
:return:
"""
if request.content_type == 'application/json':
data = request.get_json().get("resource")
link = data.get('link') if data.get('link') is not None else None
categories = data.get('categories') if data.get(
'categories') is not None else None
status = data.get('status') if data.get('status') is not None else None
if link and categories and status:
resource = Resource(link, categories, status)
resource.save()
return response_for_created_resource(resource, 201)
return response('failed',
'Missing some resource data, nothing was changed', 400)
return response('failed', 'Content-type must be json', 202)
def resource(uid):
"""
Get, add, update, or delete a specific resource based on request method. Modifies database.
:param uid: skipper_uid of the resource
:return: (str) brief message of action taken
"""
if request.method == "GET":
resource = db.session.query(Resource).filter(
Resource.uid == uid).first()
return jsonify(data=row_to_dict(resource))
elif request.method == 'DELETE':
# Removes resource with given uid, all descendants, and associated edges
to_delete = [uid]
while len(to_delete) > 0:
# delete the resource in question
curr_uid = to_delete.pop()
db.session.query(Resource).filter(
Resource.uid == curr_uid).delete()
# find all children
outgoing_edges = db.session.query(Edge).filter(
Edge.start_uid == curr_uid).all()
child_uids = [edge.end_uid for edge in outgoing_edges]
to_delete += child_uids
# removes edges associated with this resource
db.session.query(Edge).filter(
Edge.start_uid == curr_uid
or Edge.end_uid == curr_uid).delete()
db.session.commit()
return "Resource, descendants, and associated edges deleted"
else:
data = request.form.to_dict()
# make sure all dates are datetimes
if 'created_at' in data.keys() and not isinstance(
data['created_at'], datetime.datetime):
data['created_at'] = parse(data['created_at'])
if request.method == 'POST': # add to db
try:
r1 = Resource(**data)
db.session.add(r1)
db.session.commit()
except sqlalchemy.exc.IntegrityError: # unique uid already in db
requests.put(
'http://127.0.0.1:5000/resource/{}'.format(uid),
data=data) # redirect as put request with same data
return "Resource saved"
if request.method == 'PUT': # update db
db.session.query(Resource).filter(Resource.uid == uid).update(data)
db.session.commit()
return "Resource updated"
def many_resources_fixture(user: User, topic: Topic,
session: Session) -> List[Resource]:
resources = [
Resource(name="Google",
url="google.com",
user_id=user.id,
topics=[topic]),
Resource(name="UNSW", url="unsw.edu.au", user_id=user.id, topics=[]),
Resource(
name="Introduction To Deep Learning",
url="https://sebastianraschka.com/blog/2021/dl-course.html",
user_id=user.id,
topics=[topic],
),
]
for resource in resources:
session.add(resource)
session.commit()
yield resources
def test_transfer(self):
u1 = User(username='******', email='*****@*****.**')
res = Resource(body="hello")
res.issuer = u1
u2 = User(username='******')
u3 = User(username='******')
db.session.add(u1)
db.session.add(u2)
db.session.add(u3)
db.session.add(res)
db.session.commit()
u2.buy_res(res)
db.session.commit()
cert = Certs.query.filter_by(payer_id=u2.id, resource_id=res.id).first()
u3.obtain_cert(cert)
db.session.commit()
self.assertEqual(Certs.query.all()[0].payer_id, 2)
self.assertEqual(len(cert.query.all()), 2)
pass
"""
Definition of views.
"""
from django.shortcuts import render
from django.http import HttpRequest
from django.template import RequestContext
from datetime import datetime
from app import models
from app.models import Resource
resources=Resource.returnResources()
def home(request):
"""Renders the home page."""
assert isinstance(request, HttpRequest)
return render(
request,
'app/index.html',
{
'title':'Home',
'year':datetime.now().year,
}
)
def mapdata(request):
"""Renders the mapdata page."""
assert isinstance(request, HttpRequest)
return render(
request,
'app/mapdata.html',
def add_fake_data(number_users):
"""
Adds fake data to the database.
"""
User.generate_fake(count=number_users)
Resource.generate_fake()
