def create_sample_data():
"""creation of nodes and relationship between those"""
# create skills
python: Union[Skill, Any] = Skill(name="Python").save()
fim_process = Skill(name="FIM Process").save()
neo4j = Skill(name="neo4j").save()
data_engineering = Skill(name="Data Engineering").save()
data_visualization = Skill(name="Data Visualization").save()
# create team members and connect to skill
tom = TeamMember(first_name="Tom", last_name="Holiday").save()
tom.skill.connect(python, {"year": 2019, "score": 4.0})
tom.skill.connect(fim_process, {"year": 2019, "score": 5.0})
tom.skill.connect(python, {"year": 2020, "score": 5.0})
tom.skill.connect(fim_process, {"year": 2020, "score": 5.0})
tran = TeamMember(first_name="Tran", last_name="Charismatic").save()
tran.skill.connect(python, {"year": 2019, "score": 3.0})
ron = TeamMember(first_name="Ron", last_name="Paradise").save()
ron.skill.connect(neo4j, {"year": 2019, "score": 2.0})
ron.skill.connect(python, {"year": 2019, "score": 3.0})
ron.skill.connect(data_engineering, {"year": 2019, "score": 5.0})
dev = TeamMember(first_name="Dev", last_name="Global").save()
dev.skill.connect(data_engineering, {"year": 2019, "score": 4.0})
dev.skill.connect(data_visualization, {"year": 2019, "score": 3.0})
aqua = TeamMember(first_name="Aqua", last_name="Gloss").save()
aqua.skill.connect(data_visualization, {"year": 2019, "score": 2.0})
aqua.skill.connect(python, {"year": 2019, "score": 2.0})
prem = TeamMember(first_name="Prem", last_name="Chopra").save()
prem.skill.connect(fim_process, {"year": 2019, "score": 3.0})
print("Created sample data ...")
def parse_skills(skills_json):
skill_objs = []
for skill in skills_json:
# import ipdb; ipdb.set_trace()# BREAKPOINT)
skill_objs.append(Skill(id=skill['id'], name=skill['name']))
return skill_objs
def create_skill():
try:
if 'skill_name' not in request.json or 'skill_type' not in request.json:
return (jsonify("skill_name and skill_type must be included in the request"),400)
elif type(request.json["skill_name"]) != str or type(request.json["skill_type"]) != str:
return (jsonify("skill_name and skill_type need to be in string format"),400)
else:
skill_name = request.json["skill_name"]
skill_type = request.json["skill_type"]
temp_list = ["Hard skill","Soft skill"]
if skill_type not in temp_list:
return(jsonify("Skill_type only accepts values 'Hard skill' or 'Soft skill', case sensitive"),400)
else:
valid_skill_name = Skill.query.filter_by(skill_name=skill_name).first()
if valid_skill_name is not None:
return(jsonify("The skill you are trying to add already exists"),400)
else:
new_entry = Skill(skill_name=skill_name,skill_type=skill_type)
db.session.add(new_entry)
db.session.commit()
return (jsonify("{} has been added to the database".format(new_entry.skill_name)),200)
except Exception as e:
return(str(e),400)
def add_skills():
name = request.get_json(force=True)['name']
skill = Skill()
skill.name = name
db.session.add(skill)
db.session.commit()
def post(self):
user = self.user_model
employer = cgi.escape(self.request.get('employer')).strip()
profession = cgi.escape(self.request.get('job')).strip()
field = cgi.escape(self.request.get('field')).strip()
tools = cgi.escape(self.request.get('tools'))
specialty = cgi.escape(self.request.get('specialty')).strip()
tool_list = tools.split(',')
new_skills_count = 0 #for field and specialty
for i in tool_list:
if i != " ":
i = i.lower().strip()
skill_query = Skill.query(Skill.name == i).get()
#don't add duplicate skill
if skill_query == None:
new_skill = Skill(name=i)
new_skill.put()
user.skills.append(new_skill.key)
user.subscriptions.append(new_skill.name.replace(" ",""))
else:
user.skills.append(skill_query.key)
user.subscriptions.append(skill_query.name.replace(" ", ""))
new_skills_count += 1
# Add new User Info
if field != "":
field_skill = Skill(name=field.lower())
field_skill.put()
user.skills.append(field_skill.key)
new_skills_count += 1
if specialty != "":
specialty_skill = Skill(name=specialty.lower())
specialty_skill.put()
user.skills.append(specialty_skill.key)
new_skills_count += 1
if employer != " ":
user.employer = employer
user.lower_employer = employer.lower()
if profession != " ":
user.profession = profession
user.lower_profession = profession.lower()
user.skills_count += new_skills_count
user.subscriptions.append(employer.lower().replace(" ", ""))
user.put()
def resolve_create_skill(_, info, input):
skill = Skill(**input)
skill.id = str(uuid4())
try:
session.add(skill)
session.commit()
except Exception:
session.rollback()
return skill
def save_skill(request):
data = request.json
skill = Skill({
"name": data["name"],
"icon": data["icon"],
"type": data["type"]
})
skill.m.save()
skill = decode.decode_object_id(skill)
return skill
def add_skill():
if session['is_admin']:
form = AddSkill()
if form.validate_on_submit():
skill_name = form.skill_name.data
new_skill = Skill(skill_name)
db.session.add(new_skill)
db.session.commit()
return redirect(url_for('list_skill'))
return render_template('skill/addSkill.html', form=form)
else:
abort(404, description="You dont have access to this URL.")
def save_skill():
try:
cat_id = request.form['cat_id']
title = request.form['title']
# saving skill in db
skill = Skill(cat_id, title)
db.session.add(skill)
db.session.commit()
except Exception as exp:
print "save_skill() :: Got Excetion: %s" % exp
print(traceback.format_exc())
return "Save Skill"
def handle_skill():
"""
Create person and retrieve all persons
"""
# POST request
body = request.get_json()
if body is None:
raise APIException("You need to specify the request body as a json object", status_code=400)
skill1 = Skill(skill_type=body['skill_type'], user_id=body['user_id'])
db.session.add(skill1)
db.session.commit()
return "ok", 200
def read_skill_csv():
import csv
with open('skill.csv', newline='') as csvfile:
spamreader = csv.DictReader(csvfile)
for row in spamreader:
icon = get_skill_icon(row['Name'], row['Grade Value'],
row['Type 1'], row['Float Value 1'])
name = row['Name']
name_kr = row['NameKr']
description = row['Description']
condition = row['Condition']
if icon[0] > -1 or icon[1] > -1:
icon_uri = f"i_skill{icon[0]}_{icon[1]}.png"
skill = Skill(name, name_kr, description, condition, icon_uri)
db_session.add(skill)
db_session.commit()
def get_or_make_skill():
if request.method == "GET":
skills = session.query(Skill).all()
if len(skills) == 0:
return "No skills added yet, how sad!"
return jsonify(skills=[skill.serialize for skill in skills])
elif request.method == "POST":
if request.json.get('name'):
name = request.json.get('name').lower().strip()
if request.json.get('level'):
level = request.json.get('level')
skill = Skill(name=name, level=level)
session.add(skill)
session.commit()
return jsonify(skill.serialize), 201
def restore_object(self, attrs, instance=None):
classgroup = attrs.get('classgroup')
name = attrs.get('name')
attributes = ['grading_policy']
user = self.context['request'].user
if instance is None:
instance = Skill(classgroup=classgroup,
name=alphanumeric_name(name),
display_name=name)
instance.save()
else:
if not ClassGroupPermissions.is_teacher(classgroup, user):
raise serializers.ValidationError(
"You do not have permission to modify this skill.")
instance.name = alphanumeric_name(name)
instance.display_name = name
resources = self.context['request'].DATA.get('resources')
if isinstance(resources, basestring):
resources = [resources]
if resources is not None:
resources = [str(r).strip() for r in resources]
else:
resources = []
skill_resources = []
for (i, r) in enumerate(resources):
if len(r) < 1:
continue
resource = Resource.objects.get(display_name=r,
classgroup=classgroup)
skill_resource, created = SkillResource.objects.get_or_create(
resource=resource, skill=instance)
skill_resource.priority = i
skill_resource.save()
skill_resources.append(skill_resource)
for s in SkillResource.objects.filter(skill=instance):
if s not in skill_resources:
s.delete()
instance = set_attributes(attributes, attrs, instance)
return instance
def parse_teams(teams_json, session):
team_objs = []
for team in teams_json:
new_team = Team(name=team['name'],
idea_description=team['idea_description'], repository=team['repository'],
need_more_members=team['need_more_members'], room=team['room'],
place=team['place'])
if team['technologies_full']:
for skill in team['technologies_full']:
try:
skill = session.query(Skill).filter(Skill.name == skill['name']).one()
# print(skill)
new_team.skill.append(skill)
except Exception:
new_team.skill = [Skill(name=skill['name'])]
team_objs.append(new_team)
return team_objs
def post(self):
user = self.user_model
skills = cgi.escape(self.request.get('skills'))
new_skills = skills.split(',')
new_skills = [skill for skill in new_skills if len(skill) >0]
to_add_skills = []
to_add_subscriptions = []
for i in new_skills:
i = i.lower().strip()
skill_query = Skill.query(Skill.name == i).get()
if skill_query == None: # Not in skills database
new_skill = Skill(name=i)
new_skill_key = new_skill.put()
print "New Skill Added to Database"
print new_skill.name
to_add_subscriptions.append(new_skill.name.replace(" ", ""))
to_add_skills.append(new_skill_key)
else: # In skills database
# Search user skills to see if exists
flag = " "
for skill in user.skills:
skill = skill.get()
if skill.name == i:
flag = "exists"
print skill.name
print "already exists in user skills"
break
if flag != "exists":
new_skill = Skill.query(Skill.name == i).get()
print("Added to user skills:")
print(new_skill.name)
to_add_subscriptions.append(new_skill.name.replace(" ", ""))
to_add_skills.append(new_skill.key)
# Add to user skills
user.skills.extend(to_add_skills)
user.skills_count += len(to_add_skills)
# Add to user subscriptions
user.subscriptions.extend(to_add_subscriptions)
time.sleep(1)
user.put()
def parse_skills(self, xml_skills):
"""
Parse all active skill setups from the given xml
:param xml_skills: root node containing the skills
:return: list of skills
"""
skills = []
# parse skills and the supported gems
for skill in xml_skills:
gems = []
for gem in skill:
gems.append(
Gem(Parser.get_attrib_if_exists(gem, 'skillId'),
gem.attrib['nameSpec'], gem.attrib['level'],
gem.attrib['quality'],
Parser.get_attrib_if_exists(gem, 'skillPart'),
gem.attrib['enabled']))
slot = Parser.get_attrib_if_exists(skill, 'slot')
if slot:
pass
skills.append(Skill(gems, skill.attrib['mainActiveSkill'], slot))
return skills
def post_new_skill(jwt):
try:
# Get request data
req_data = request.get_json()
name = req_data.get('name')
description = req_data.get('description', None)
# Create new Skill instance
new_skill = Skill(
name = name,
description = description
)
# Create new entry in database
new_skill.insert()
return jsonify({
'success':True,
'skill': new_skill.format()
})
except:
db.session.rollback()
abort(422)
def parse(self, response):
for hero in response.xpath(
'//body//span[@class="character_icon"]/a/@href'):
yield response.follow(
'http://dota.wikia.com' + str(hero.extract()), self.parse)
# yield {'heroe': 'http://dota.wikia.com' + str(hero.extract())}
names = []
lore = ''
for skill in response.xpath('//body//div[@title="Dota 2"]/table/tr'):
skill_names = skill.xpath('//td[1]/b/text()')
for name in skill_names.extract():
if 'Ability Name' not in name and name not in names:
names.append(name)
descs = response.xpath(
'//body//div[@title="Dota 2"]/table/tr/td[2]').extract()[1:]
descs = [re.sub('<.*?>', '', x) for x in descs]
self.log(descs)
for lore_found in response.xpath('//body//div[@title="Lore"]'):
value = lore_found.xpath('//p[2]').extract()
lore = ' '.join(value).strip().replace(' ', '').replace('\n', '')
if len(lore) < 20:
value = lore_found.xpath('//p[3]').extract()
lore = ' '.join(value).strip().replace(' ',
'').replace('\n', '')
lore = re.sub('<.*?>', '', lore)
hero_type = response.xpath(
'//body//tr[contains(td, " Attributes")]').extract()[0]
if 'Agility' in hero_type:
hero_type = 'Agility'
if 'Intelligence' in hero_type:
hero_type = 'Intelligence'
if 'Strength' in hero_type:
hero_type = 'Strength'
hero_name = response.url.split('/')[-1]
hero = Hero()
hero.lore = lore
hero.name = hero_name
hero.type = hero_type
session.add(hero)
session.commit()
mongo_skills = []
mongo_hero = {'lore': lore, 'name': hero_name, 'type': hero_type}
i = 0
for name in names:
db_skill = Skill()
db_skill.name = name
db_skill.description = descs[i]
db_skill.hero_id = hero.id
session.add(db_skill)
mongo_skills.append({
'name': name,
'description': descs[i],
})
i += 1
mongo_hero['skills'] = mongo_skills
heroes.insert_one(mongo_hero)
session.commit()
session.close()
from datetime import date
from models import Skill
web_engineering = Skill(
'Web Engineering',
'Django',
'Angular',
'Rails',
'Ractive',
'Chef',
'Jenkins',
'AWS',
'Protractor'
)
print web_engineering.render()
from models import db, Task, Member, Skill
from task import app
# if "createdb" in sys.argv:
with app.app_context():
db.create_all()
print("Database created!")
# elif "seeddb" in sys.argv:
with app.app_context():
s1 = Skill(name="python", level=5)
db.session.add(s1)
s2 = Skill(name="finance", level=2)
db.session.add(s2)
s3 = Skill(name="sql", level=4)
db.session.add(s3)
s4 = Skill(name="critical thinking", level=3)
db.session.add(s4)
s5 = Skill(name="react", level=4)
db.session.add(s5)
s6 = Skill(name="scrum master", level=5)
db.session.add(s6)
s7 = Skill(name="sap consulting", level=5)
db.session.add(s7)
s8 = Skill(name="abap", level=5)
db.session.add(s8)
t1 = Task(name="Create Git", desc="We need to create a microservice for calulating the amount of materials that we will have to use in production. We have to use cloud environment for this task. It can use MachineLearning algorithms to utilize our past data. While working on this service we should focus on high-availability.", status="OPEN")
db.session.add(t1)
t2 = Task(name="Create UI", desc="Frontend with buttons", status="DONE")
db.session.add(t2)
from sqlalchemy.orm import sessionmaker
from models import Base, Skill, Person
import json
engine = create_engine('sqlite://')
Session = sessionmaker(bind=engine)
session = Session()
# Setup of in memory database, from data.json if tables doesn´t exist
if not engine.dialect.has_table(engine.connect(), "skills"):
Base.metadata.create_all(bind=engine)
data = json.load(open('../datasource/data.json'))
skills = data['skills']
for skill in skills:
new_skill = Skill(**skill)
session.add(new_skill)
session.commit()
persons = data['persons']
for person in persons:
friends = []
skills = []
if 'friends' in person:
person_ids = person.pop('friends')
friends = session.query(Person).filter(
Person.id.in_(person_ids)).all()
if 'skills' in person:
skill_ids = person.pop('skills')
skills = session.query(Skill).filter(Skill.id.in_(skill_ids)).all()
keywords = [
"python", "javascript", "html", "css", "ruby", "bash", "linux", "unix",
"rest", "restful", "api", "aws", "cloud", "svn", "git", "junit", "testng",
"java", "php", "agile", "scrum", "nosql", "mysql", "postgresdb",
"postgres", "shell", "scripting", "mongodb", "puppet", "chef", "ansible",
"nagios", "sumo", "nginx", "haproxy", "docker", "automation", "jvm",
"scikit-learn", "tensorflow", "vue", "react", "angular", "webpack",
"drupal", "gulp", "es6", "jquery", "sass", "scss", "less", "nodejs",
"node.js", "graphql", "postgresql", "db2", "sql", "spring",
"microservices", "kubernates", "swagger", "hadoop", "ci/cd", "django",
"elasticsearch", "redis", "c++", "c", "hive", "spark", "apache", "mesos",
"gcp", "jenkins", "azure", "allcloud", "amqp", "gcp", "objective-c",
"kotlin"
"kafka", "jira", "cassandra", "containers", "oop", "redis", "memcached",
"redux", "bigquery", "bigtable", "hbase", "ec2", "s3", "gradle", ".net",
"riak", "shell", "hudson", "maven", "j2ee", "oracle", "swarm", "sysbase",
"dynamodb", "neo4", "allcloud", "grunt", "gulp", "apex", "rails", "mongo",
"apis", "html5", "css3", "rails", "scala", "rasa", "soa", "soap",
"microservices", "storm", "flink", "gitlab", "ajax", "micro-services",
"oop", "saas", "struts", "jsp", "freemarker", "hibernate", "rlak",
"solidity", "heroku", "ecs", "gce", "scripting", "perl", "c#", "golang",
"xml", "newrelic", "grafana", "helm", "polymer", "closure", "backbone",
"atlassian", "angularjs", "flask", "scikitlearn", "theano", "numpy",
"scipy", "panda", "tableau", "gensim", "rpc", "graphql", "iaas", "paas",
"azure", "es", "solr", "http", "iot", "kinesis", "lambda", "typescript",
"gradle", "buck", "bazel"
]
for skill in keywords:
new_skill = Skill(name=skill)
new_skill.save()
