def populate_db():
with app.app_context():
o = Organization('Testing', '555-512-1234')
db.session.add(Organization('Real Estate', '555-555-5555'))
db.session.add(Organization('Insurance', '555-555-5556'))
db.session.add(Organization('Private Equity', '555-555-5557'))
db.session.commit()
def test_article_4(self):
s = Organization(name='CowNews')
a = Article(title='Why you shouldn\'t drink your own milk',
organization=s)
db.session.add(a)
first = Article.query.first()
self.assertEqual(first.organization.name, 'CowNews')
def test_country_5(self):
c = Country(name='Cowland')
s = Organization(name='Monthly Milkpost')
c.organizations.append(s)
db.session.add(s)
first = Country.query.first()
self.assertEqual(len(first.organizations), 1)
def setUp(self):
app.config['TESTING'] = True
app.config['WTF_CSRF_ENABLED'] = False
app.config['DEBUG'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + \
os.path.join(path, TEST_DB)
self.app = app.test_client()
db.drop_all()
db.create_all()
#setting up org and users
org = Organization(name='Test', org_key='12345')
add_db_entry(org)
admin = User(organization=org.id,
email=self.admin_username,
password=generate_password_hash(self.admin_password),
name='Admin',
role='admin')
add_db_entry(admin)
user = User(organization=org.id,
email=self.user_username,
password=generate_password_hash(self.user_password),
name='User',
role='user')
add_db_entry(user)
self.assertEqual(app.debug, False)
def populate_db():
with app.app_context():
db.session.add(
Organization('San Martin Animal Shelter',
'12370 Murphy Ave, San Martin, CA 95046',
'(408) 686-3900', 5))
db.session.commit()
def init_db():
'''
project1 = Project(location=1, number_participants=2)
project1.save()
project2 = Project(location=1, number_participants=1, part_of=project1)
project2.save()
user = UserAccount(username="******", email="*****@*****.**", firstname="hans", lastname="mueller", preference="none")
user = UserAccount(username="******", email="*****@*****.**", firstname="carlo", lastname="arndt", preference="none")
user.save()
'''
business = BusinessAccount(email='*****@*****.**',
company_name='business1',
fee=10.10,
bank_account='AT123456789123')
business.save()
organization = Organization(focus='sth',
name='brot fuer die Welt',
employees=1200,
business=business)
organization.save()
project = Project(location=2,
number_participants=12,
organization=organization)
project.save()
def post(self):
"""
Create a new Organization
"""
if "Administrator" != current_user.role:
return make_response(jsonify({"msg": "Forbidden"}), 403)
id = request.json.get('id')
name = request.json.get("name")
network_id = request.json.get('network_id')
organization = Organization.query.filter_by(
name=name, network_id=network_id).first()
if not organization: # If no organization exists with that name, then create a new one
organization = Organization(id=id,
name=name,
network_id=network_id)
db.session.add(organization)
db.session.commit()
ret = {'msg': 'Success'}
return make_response(jsonify(ret), 200)
else:
return make_response(
jsonify({
"msg":
"Organization with that name already exists, please try again with a new name."
}), 400)
def handle_organization():
"""
agrega una organizacion (POST), trae lista de organizaciones (GET)
"""
# POST request
if request.method == 'POST':
body = request.get_json()
if body is None:
raise APIException("You need to specify the request body as a json object", status_code=400)
if 'name' not in body:
raise APIException('You need to specify the name', status_code=400)
if 'address' not in body:
raise APIException('You need to specify the address', status_code=400)
if 'phone' not in body:
raise APIException('You need to specify the phone', status_code=400)
if 'email' not in body:
raise APIException('You need to specify the email', status_code=400)
organization1 = Organization(name=body['name'], address=body['address'], phone=body['phone'], email=body['email'])
db.session.add(organization1)
db.session.commit()
return "ok", 200
# GET request
if request.method == 'GET':
all_organization = Organization.query.all()
all_organization = list(map(lambda x: x.serialize(), all_organization))
return jsonify(all_organization), 200
return "Invalid Method", 404
def test_organization_5(self):
a = Article(title='Breaking: Milking Postponed Until Saturday')
s = Organization(name='CowNews')
s.articles.append(a)
db.session.add(s)
first = Organization.query.first()
self.assertEqual(len(first.articles), 1)
def post(self, org_name):
"""The POST handler for the /orgs/<org_name> endpoint
Arguments:
org_name {str} -- The organization's name
Returns:
dict -- A status message
"""
args = parser.parse_args()
org = Organization.query.filter_by(name=org_name).first()
if org:
return {
'status': 'error',
'message': 'This organization already exists!'
}, 401
new_org = Organization(org_name)
db.session.add(new_org)
db.session.commit()
# Make user the admin of the new organization
req_user = this_user()
new_org_id = Organization.query.filter_by(name=org_name).first().id
user = User.query.filter_by(id=req_user['id']).first()
user.org_id = new_org_id
user.role = 'admin'
db.session.commit()
return {'status': 'success'}, 201
def create_orga():
if request.method == 'POST':
name = request.form['name']
email = request.form['email']
telephone = request.form['telephone']
new_orga = Organization(name, email, telephone)
db.session.add(new_orga)
db.session.commit()
db.session.close()
return redirect(url_for('show_home'))
def create_organization(current_user):
if not current_user.admin:
return jsonify({'message': 'This endpoint is not allowed!'})
data = request.get_json()
hashed_pw = generate_password_hash(data['password'], method='sha256')
new_org = Organization(public_id=str(uuid.uuid4()),
name=data['name'],
password=hashed_pw,
admin=False)
db.session.add(new_org)
db.session.commit()
return jsonify({"message": "New Organization Created!"})
def post(self):
json = request.json
abort_if_invalid_request_params(json, ['code', 'name'])
organization = Organization()
organization.code = json['code']
organization.name = json['name']
if 'description' in json:
organization.description = json['description']
organization.save()
return me_obj_to_serializable(organization)
def organizations_management():
if request.method == "POST":
form = CreateOrganizationForm(request.form)
if form.validate():
org = Organization(name=form.short_name.data,
full_name=form.full_name.data)
org.put()
else:
form = CreateOrganizationForm()
existing_orgs = Organization.query().fetch(100)
return render_template("admin/organizations.html",
existing_orgs=existing_orgs,
form=form)
def org_create(request):
form = OrganizationForm()
if request.method == "POST":
req_data = {}
data = request.POST
user_id = request.session.get("user").get("id")
up = UserProfile.objects.get(pk=user_id)
req_data["state"] = State.objects.get(pk=data["state"])
req_data["city"] = City.objects.get(pk=data["city"])
req_data["country"] = Country.objects.get(pk=data["country"])
req_data["user"] = up
req_data["name"] = data.get("name")
org = Organization(**req_data)
org.save()
return redirect("/userorgs/")
return render(request, "bloodgroup/organization_form.html", {"form": form})
def test_nonmember_cannot_editor_private_repo(self):
user = User(username="******",
password="******",
display_name="Display Name",
email="*****@*****.**")
org = Organization(name="org", display_name="Organization")
Repository(organization=org,
name="repo",
display_name="A Repository",
is_public=False)
self.session.add(user)
self.session.commit()
self.assertFalse(
RepositoryUserMapManager.is_editable(self.session, "username",
"org", "repo"))
def wsRegister(request):
serialized = UserSerializer(data=request.data)
if serialized.is_valid():
serialized.save()
org = Organization(name=request.POST['company_name'])
org.save()
print("user data")
print(serialized.data['username'])
user = User.objects.get(username=serialized.data['username'])
print(user)
profile = UserProfile(user=user, organization=org)
profile.save()
return Response(serialized.data, status=status.HTTP_201_CREATED)
else:
print("bad request")
return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def post(self):
"""Handles POST requests for /orgs endpoint
Returns:
dict -- Status message
"""
try:
args = parser.parse_args()
auth = args['secret']
if auth != auth_key:
return {'message': 'Bad secret'}, 401
organization = Organization(name=args['name'], phone_number=args['phone_number'])
db.session.add(Organization)
db.session.commit()
return {'message': 'success'}
except Exception as e:
traceback.print_exc()
return generic_400(e)
def test_repo_editor_can_editor_private_repo(self):
user = User(username="******",
password="******",
display_name="Display Name",
email="*****@*****.**")
org = Organization(name="org", display_name="Organization")
OrganizationUserMap(organization=org, user=user, role_shortname='M')
repo = Repository(organization=org,
name="repo",
display_name="A Repository",
is_public=False)
RepositoryUserMap(repository=repo, user=user, role_shortname='E')
self.session.add(user)
self.session.commit()
self.assertTrue(
RepositoryUserMapManager.is_editable(self.session, "username",
"org", "repo"))
def post(self, org_name):
args = parser.parse_args()
org = Organization.query.filter_by(name=org_name).first()
if org:
return {
'status': 'error',
'message': 'This organization already exists!'
}, 401
new_org = Organization(org_name)
db.session.add(new_org)
db.session.commit()
# Make user the admin of the new organization
token = AuthToken.query.filter_by(data=args['Auth-Token']).first()
req_user = User.query.filter_by(id=token.user_id).first()
new_org_id = Organization.query.filter_by(name=org_name).first().id
req_user.org_id = new_org_id
req_user.role = 'admin'
db.session.commit()
return {'status': 'success'}, 201
def userRegisteration(request: User, db: Session = Depends(get_db)):
id_uid = id_uuids()
organization = Organization(id=id_uid, name=request.organization_name)
db.add(organization)
db.commit()
db.refresh(organization)
id_uid = id_uuids()
tenant = Tenant(id=id_uid,
name=request.tenant_name,
company_logo=request.company_logo,
organization_id=organization.id)
db.add(tenant)
db.commit()
db.refresh(tenant)
role = db.query(
models.Role).filter(models.Role.name == "tenentAdmin").first()
if role:
print(role.id)
else:
role = Role(id=id_uid, name="tenentAdmin")
db.add(role)
db.commit()
db.refresh(role)
# atuo generate password
a = randoms()
password = str(a)
Tenantuser = TenantUser(id=id_uid,
username=request.username,
role_id=role.id,
password=password,
tenant_id=tenant.id)
db.add(Tenantuser)
db.commit()
db.refresh(Tenantuser)
return {organization, tenant, Tenantuser}
def construct_org(org_slug: str) -> Organization:
type_map: dict = dict()
with env.prefixed(f"{org_slug.upper()}_"):
connector_api_key = env("CONNECTOR_API_KEY")
eventbrite_token = env("EVENTBRITE_TOKEN", None)
eventbrite_org_id = env("EVENTBRITE_ORG_ID", None)
if eventbrite_token:
for mapping in env("TYPE_MAP").split(","):
eb_type, sf_type = mapping.split(":")
type_map[eb_type] = sf_type
paypal_client_id = env("PAYPAL_CLIENT_ID", None)
paypal_client_secret = env("PAYPAL_CLIENT_SECRET", None)
paypal_property = env("PAYPAL_PROPERTY", None)
with env.prefixed(f"{org_slug.upper()}_SALESFORCE_"):
sf_config = SalesforceConfig(
client_id=env("CLIENT_ID"),
client_secret=env("CLIENT_SECRET"),
username=env("USERNAME"),
password=env("PASSWORD"),
host=env("HOST"),
api_version=SALESFORCE_API_VERSION,
slug=org_slug,
)
logger.debug(sf_config)
org = Organization(
slug=org_slug,
eventbrite_token=eventbrite_token,
eventbrite_org_id=eventbrite_org_id,
connector_api_key=connector_api_key,
sf_config=sf_config,
sfc=SalesforceConnection(config=sf_config),
eb_connection=Eventbrite(eventbrite_token),
type_map=type_map,
paypal_client_id=paypal_client_id,
paypal_client_secret=paypal_client_secret,
paypal_property=paypal_property if paypal_property else "Property1",
)
return org
def org_edit(id=0):
setExits()
id = cleanRecordID(id)
if id < 0:
flash("That is not a valid ID")
return redirect(g.listURL)
timeZones = getTimeZones()
if not request.form:
""" if no form object, send the form page """
# get the Org record if you can
rec = None
if int(id) > 0:
rec = Organization.query.get(id)
return render_template('org/org_edit.html', rec=rec, timeZones=timeZones)
#have the request form
if validForm():
if id > 0:
rec = Organization.query.get(id)
else:
## create a new record stub
rec = Organization(request.form['name'],request.form['email'],request.form["defaultTimeZone"])
db.session.add(rec)
#update the record
rec.name = request.form['name']
rec.email = request.form['email']
rec.defaultTimeZone = request.form["defaultTimeZone"]
try:
db.session.commit()
except Exception as e:
flash(printException('Error attempting to create '+g.title+' record.',"error",e))
db.session.rollback()
return redirect(url_for('.org_list'))
# form not valid - redisplay
return render_template('org/org_edit.html', rec=request.form, timeZones=timeZones)
def userRegisteration(request: User, db: Session = Depends(get_db)):
id_uid = id_uuids()
organization = Organization(id=id_uid, name=request.organization_name)
db.add(organization)
db.commit()
db.refresh(organization)
id_uid = id_uuids()
tenant = Tenant(id=id_uid,
name=request.tenant_name,
organization_id=organization.id)
db.add(tenant)
db.commit()
db.refresh(tenant)
role = db.query(models.Role).filter(models.Role.name == "admin").first()
if role:
role_id = role.id
else:
role_id = Role(id=id_uid, name="tenentAdmin")
db.add(role_id)
db.commit()
db.refresh(role_id)
print(role_id)
tenantuser = TenantUser(id=id_uid,
username=request.username,
first_name=request.firstname,
last_name=request.lastname,
email=request.email,
role_id=role_id,
tenant_id=tenant.id)
db.add(tenantuser)
db.commit()
db.refresh(tenantuser)
return {organization, tenant, tenantuser}
def register():
form = RegisterAdmin()
print form.validate_on_submit()
if form.validate_on_submit():
print "here"
org = Organization(name = form.oname.data)
dept = Department.query.filter_by(name = 'Admin').first()
if dept is None:
dept = Department(name='Admin',description='Administrator of Organization.', isfin=False, organization=org)
db.session.add(dept)
db.session.commit()
db.session.add(org)
db.session.commit()
user = User(name=form.name.data, email=form.email.data, password=form.password.data,
type=1, profile_filename='default256.png', profile_url='static/default256.png',
department=dept, organization=org)
db.session.add(user)
db.session.commit()
flash('Registration Completed.')
return redirect('/login')
return render_template('register.html',form=form)
def newOrganization():
if 'username' not in login_session:
flash("Você precisa estar logado para cadastrar uma Organização" \
.decode('utf8'))
return redirect(url_for('showLogin'))
else:
categories = session.query(Category).all()
user = getUserInfo(login_session['user_id'])
if request.method == 'POST':
addNewOrg = Organization(name=request.form['name'],
description=request.form['description'],
site=request.form['site'],
category_id=request.form['category'],
user_id=login_session['user_id'])
session.add(addNewOrg)
session.commit()
flash("Organização criada com sucesso!".decode('utf8'))
return redirect(
url_for('showOrganizationDetail',
organization_id=addNewOrg.id))
else:
return render_template('newOrganization.html',
categories=categories)
def populate_db():
with app.app_context():
try:
db.session.add(Organization('CIA'))
db.session.add(Organization('DEA'))
db.session.add(Organization('DHS'))
db.session.add(Organization('FBI'))
db.session.add(Organization('KFC'))
db.session.add(Organization('NSA'))
db.session.add(
User('leon',
sha256('test'.encode()).hexdigest(), '*****@*****.**',
'admin', 5))
db.session.add(
User('student',
sha256('ist440'.encode()).hexdigest(), '*****@*****.**',
'admin', 4))
db.session.commit()
except:
pass
def populate_db():
with app.app_context():
try:
db.session.add(Organization('CIA'))
db.session.add(Organization('DEA'))
db.session.add(Organization('DHS'))
db.session.add(Organization('FBI'))
db.session.add(Organization('KFC'))
db.session.add(Organization('NSA'))
db.session.add(
User('leon',
sha256('test'.encode()).hexdigest(), '*****@*****.**',
'admin', 5))
db.session.add(
User('student',
sha256('ist440'.encode()).hexdigest(), '*****@*****.**',
'admin', 4))
db.session.add(
User('bob',
sha256('lazar'.encode()).hexdigest(),
'*****@*****.**', 'standard', 4))
db.session.add(
User('john',
sha256('smith'.encode()).hexdigest(), '*****@*****.**',
'standard', 4))
db.session.add(
User('cheney',
sha256('dick'.encode()).hexdigest(),
'*****@*****.**', 'admin', 1))
db.session.add(
User('skywalker',
sha256('luke'.encode()).hexdigest(), '*****@*****.**',
'admin', 2))
db.session.add(
User('palpatine',
sha256('sidious'.encode()).hexdigest(),
'*****@*****.**', 'admin', 3))
db.session.commit()
except:
pass
def extract_paper_info(self):
# DOI
doi = self.soup.teiheader.find("idno", type="DOI")
if doi:
self.paper.doi = elem_to_text(doi)
elif self.document:
self.paper.doi = self.document['doi']
# Title
title = self.soup.teiheader.find("title")
if title:
self.paper.title = elem_to_text(title)
# Authors
authors = self.get_authors(self.soup.analytic.find_all('author'))
if authors:
self.paper.authors = authors
if self.soup.abstract:
self.paper.abstract = elem_to_text(self.soup.abstract)
# Year
published = self.soup.analytic.find("publicationstmt")
if published:
self.paper.year = elem_to_text(published.find("date", type="when"))
# Organization / Affiliations
affiliations = self.soup.analytic.find_all('affiliation')
for affiliation in affiliations:
org = Organization()
org.type = "institution"
org.name = elem_to_text(affiliation.find("orgname", type="institution"))
address = Address()
addr = affiliation.find("address")
if addr:
address.place = elem_to_text(addr.find("settlement"))
address.region = elem_to_text(addr.find("region"))
address.country = elem_to_text(addr.find("country"))
org.address = address
self.paper.affiliations.append(org)
# University Ranking
if self.paper.affiliations:
if self.paper.affiliations[0] != '':
self.paper.uni_rank = self.uni_rank.get_rank(self.paper.affiliations[0].name)
elif len(self.paper.affiliations) > 1:
self.paper.uni_rank = self.uni_rank.get_rank(self.paper.affiliations[1].name)
else:
self.paper.uni_rank = self.uni_rank.get_rank('Random')
# Citations
bibliography = self.soup.listbibl.find_all('biblstruct')
for bibl in bibliography:
citation = Citation()
cited_paper = bibl.analytic
if cited_paper:
citation.title = elem_to_text(cited_paper.find("title", type="main"))
citation_authors = self.get_authors(cited_paper.find_all("author"))
citation.doi = elem_to_text(cited_paper.find("idno", type="DOI"))
if citation_authors:
citation.authors = citation_authors
cited_journal = bibl.monogr
if cited_journal:
citation.source = elem_to_text(cited_journal.find("title"))
try:
citation.publish_year = cited_journal.imprint.date['when']
except TypeError:
pass
self.paper.citations.append(citation)
# NER - Ack pairs - Funding status
self.paper.ack_pairs = self.get_funding_status()
er_list = [org for (entity, org) in self.paper.ack_pairs]
if 'ORG' in er_list:
self.paper.funded = 1
else:
self.paper.funded = 0
# SJR
api_resp = self.get_sjr(self.paper.doi, self.paper.title,self.db)
# Adding the paragraphs from the paper to the corpus
extractor = ClaimEvidenceExtractor(self.xml, self.soup,self.test_csv)
os.chdir("/scifact/")
extractor.make_corpus()
# Get response for claim evidence using request to API
response = requests.get('http://0.0.0.0:8000/getclaimevidence')
print(response)
self.support, self.refute, self.ratio = extractor.get_results()
print('support:',self.support,'refute:',self.refute,'ratio:',self.ratio)
os.chdir("../")
if api_resp:
self.paper.cited_by_count = api_resp["num_citations"]
self.paper.sjr = api_resp["sjr"]
self.paper.subject = api_resp["subject"]
self.paper.subject_code = api_resp["subject_code"]
self.paper.normalized = api_resp["normalized_citations"]
self.paper.velocity = api_resp["citationVelocity"]
self.paper.influentialcitations = api_resp["influentialCitationCount"]
self.paper.references = api_resp["references_count"]
self.paper.flag = api_resp["openaccessflag"]
self.paper.influentialref = api_resp["influentialReferencesCount"]
self.paper.ref_background = api_resp["reference_background"]
self.paper.ref_result = api_resp["reference_result"]
self.paper.ref_method = api_resp["reference_methodology"]
self.paper.cite_background = api_resp["citations_background"]
self.paper.cite_result = api_resp["citations_result"]
self.paper.cite_method = api_resp["citations_methodology"]
self.paper.cite_next = api_resp["citations_next"]
self.paper.influential_references_methodology = api_resp["upstream_influential_methodology_count"]
self.paper.issn = api_resp["ISSN"]
self.paper.auth = api_resp["authors"]
self.paper.age = api_resp["age"]
if api_resp["abstract"]:
self.paper.abstract = api_resp["abstract"]
# Set self-citations
self.paper.self_citations = self.paper.set_self_citations()
# return paper
#calculate coCitations
t2,t3 = coCite(self.paper.doi, self.db)
#calculate NLP features
reading_score = self.get_reading_score(self.paper.abstract)
subjectivity = self.get_subjectivity(self.paper.abstract)
sentiment = self.get_sentiment(self.paper.abstract)
return {"doi": self.paper.doi, "title": self.paper.title, "num_citations": self.paper.cited_by_count,
"author_count": len(self.paper.authors),"sjr": self.paper.sjr, "u_rank": self.paper.uni_rank,
"funded": self.paper.funded,"self_citations": self.paper.self_citations, "subject": self.paper.subject,
"subject_code": self.paper.subject_code, "citationVelocity": self.paper.velocity,
"influentialCitationCount": self.paper.influentialcitations, "references_count": self.paper.references,
"openaccessflag": self.paper.flag, "influentialReferencesCount": self.paper.influentialref,
"normalized_citations": self.paper.normalized, "reference_background": self.paper.ref_background,
"reference_result": self.paper.ref_result, "reference_methodology": self.paper.ref_method,
"citations_background": self.paper.cite_background, "citations_result": self.paper.cite_result,
"citations_methodology": self.paper.cite_method, "citations_next": self.paper.cite_next,
"upstream_influential_methodology_count": self.paper.influential_references_methodology,
"coCite2":t2, "coCite3":t3, "ISSN":self.paper.issn, "authors":self.paper.auth,"citations":api_resp["citations"],"age":self.paper.age,
"reading_score":reading_score, "subjectivity":subjectivity, "sentiment":sentiment, "supporting_sentences":self.support, "refuting_sentences":self.refute, "ratio_support":self.ratio}
def make_org(self, data, **kwargs):
return Organization(**data)
