def get(self) -> Tuple[dict, int]:
""" returns a list of existing employees """
employees = [
employee.json()
for employee in Employee.query.order_by(Employee.id.desc()).all()
]
logger.debug('Returning the list of all Employees')
return {'employees': employees}, 200
def get(self) -> Tuple[dict, int]:
""" returns a list of all departments """
depts = {'departments': []}
for dept in Department.query.order_by(Department.id.desc()).all():
depts['departments'].append(dept.json())
logger.debug('Returning the list of all departments')
return depts, 200
def get(self, pk: int) -> Tuple[dict, int]:
""" returns data about employee from db """
employee = Employee.query.filter_by(id=pk).first()
if employee:
logger.debug('Returning Employee Data')
return employee.json(), 200
return {'message': 'employee with id {} not found'.format(pk)}, 404
def delete(self, name: str) -> Tuple[dict, int]:
""" removes department from db """
dept = Department.query.filter_by(name=name).first()
if not dept:
return {'message': 'department with name \'{}\' does not exist'.format(name)}, 404
db.session.delete(dept)
db.session.commit()
logger.debug('Department Removed')
return {'message': 'department \'{}\' successfully removed'.format(name)}, 200
def post(self, name: str) -> Tuple[dict, int]:
""" creates new department """
if Department.query.filter_by(name=name).first():
return {'message': 'department with name \'{}\' already exists'.format(name)}, 400
dept = Department(name=name)
db.session.add(dept)
db.session.commit()
logger.debug('Created new Department')
return dept.json(), 201
def get(self, name: str) -> Tuple[dict, int]:
""" returns a list of employees of department """
dept = Department.query.filter_by(name=name).first()
if not dept:
return {'message': 'department with name \'{}\' does not exist'.format(name)}, 404
employees = Employee.query.order_by(Employee.id.desc()).filter_by(department_id=dept.id)
logger.debug('Returning the list of all department\'s employees')
return {'department': dept.json(),
'employees': [empl.json() for empl in employees]}, 200
def status_code_or_raise(self, response: Response, code: int):
logger.debug(f"Response: {response.status_code} {response.content}")
if response.status_code == code:
return
msg = f"Expected {code}, but was {response.status_code}"
if response.status_code == 422:
raise UnprocessableEntityError(msg, response)
raise ValueError(msg, response)
def update_event(self, event_id: int, data: dict):
logger.debug(f"Update event {event_id} {data['name']}")
try:
self.session_client.put(f"/events/{event_id}", data=data)
except UnprocessableEntityError as e:
if e.json["errors"][0]["field"] == "photo":
logger.warn("Retrying without photo")
del data["photo"]
self.session_client.put(f"/events/{event_id}", data=data)
else:
raise
def _import_organizer(self, item: dict) -> int:
organizer_item = None
if "organizer" in item:
organizer_item = item["organizer"]
if not organizer_item and "author" in item:
organizer_item = item["author"]
if (organizer_item and isinstance(organizer_item, list)
and len(organizer_item) > 0 and organizer_item[0]):
organizer_item = organizer_item[0]
organizer_name = organizer_item["name"]
organizer = dict()
organizer["name"] = organizer_name
if "url" in organizer_item and self._is_url(organizer_item["url"]):
organizer["url"] = organizer_item["url"]
if "email" in organizer_item:
organizer["email"] = organizer_item["email"]
if "telephone" in organizer_item:
organizer["phone"] = organizer_item["telephone"]
if "faxNumber" in organizer_item:
organizer["fax"] = organizer_item["faxNumber"]
if "address" in organizer_item:
organizer["location"] = self._import_location(
organizer_item["address"])
hash_key = organizer_name
organizer_hash = self._hash_dict(organizer)
self.organizer_hashes.add(organizer_hash)
if hash_key in self.stored_organizer_mapping:
organizer_id = int(self.stored_organizer_mapping[hash_key])
logger.debug(
f"Found organizer {organizer_name} in mapping: {organizer_id}."
)
stored_organizer_hash = self.stored_organizer_hashes.get(
hash_key, None)
if organizer_hash == stored_organizer_hash:
logger.debug("Organizer did not change. Nothing to do.")
else:
logger.debug("Organizer did change. Updating..")
self.api_client.update_organizer(organizer_id, organizer)
r.hset("organizer_hashes", hash_key, organizer_hash)
else:
logger.debug(
f"Organizer {organizer_name} not in mapping. Inserting..")
organizer_id = self.api_client.upsert_organizer(organizer)
r.hset("organizer_mapping", hash_key, organizer_id)
r.hset("organizer_hashes", hash_key, organizer_hash)
return organizer_id
def delete(self, pk: int) -> Tuple[dict, int]:
""" removes employee from db """
employee = Employee.query.filter_by(id=pk).first()
if not employee:
return {
'message': 'employee with id {} does not exist'.format(pk)
}, 404
db.session.delete(employee)
db.session.commit()
logger.debug('Employee removed')
return {
'message': 'employee with id {} successfully removed'.format(pk)
}, 200
def put(self, name: str) -> Tuple[dict, int]:
""" changes data related to an existing department or creates a new one """
dept = Department.query.filter_by(name=name).first()
if not dept:
return self.post(name)
data = DepartmentAPI.parser.parse_args()
if Department.query.filter_by(name=data['name']).first():
return {'message': 'department with name \'{}\''
'already exists'.format(data['name'])}, 400
dept.name = data['name']
db.session.commit()
logger.debug('Updated Department Data')
return dept.json(), 200
def insert_event(self, data: dict) -> int:
logger.debug(f"Insert event {data['name']}")
try:
response = self.session_client.post(
f"/organizations/{self.organization_id}/events", data=data)
except UnprocessableEntityError as e:
if e.json["errors"][0]["field"] == "photo":
logger.warn("Retrying without photo")
del data["photo"]
response = self.session_client.post(
f"/organizations/{self.organization_id}/events", data=data)
else:
raise
event = response.json()
return event["id"]
def _import_event_from_sitemap(self, url: str, lastmod: str):
logger.debug(f"Loading event at {url} from {lastmod}")
if self.last_run:
last_modified = datetime.datetime.fromisoformat(lastmod)
if last_modified < self.last_run:
if url in self.stored_url_mapping:
uid = self.stored_url_mapping[url]
logger.debug(
"Event was not modified since last run. Nothing to do."
)
self.uids_in_run.add(uid)
self.urls_in_run.add(url)
self.unchanged_event_count = self.unchanged_event_count + 1
return
self._import_event_from_url(url)
def post(self) -> Tuple[dict, int]:
""" create new user """
data = EmployeeAPI.parser.parse_args()
message, status_code = EmployeeAPI.validate_args(data)
if status_code != 200:
return {'message': message}, status_code
department = Department.query.filter_by(
name=data['department']).first()
employee = Employee(department_id=department.id,
name=data['name'],
birthdate=data['birthdate'],
salary=data['salary'])
db.session.add(employee)
db.session.commit()
data['id'] = employee.id
logger.debug('New Employee created')
return data, 201
def put(self, pk: int) -> Tuple[dict, int]:
""" changes data related to an existing user """
data = request.get_json()
if Employee.query.filter_by(id=pk).first():
message, status_code = EmployeeAPI.validate_args(data)
if status_code != 200:
return {'message': message}, status_code
if 'department' in data.keys():
department = Department.query.filter_by(
name=data['department']).first()
data['department_id'] = department.id
data.pop('department', None)
employee = Employee.query.filter_by(id=pk)
employee.update(data)
db.session.commit()
logger.debug('Updated Employee Data')
return employee.first().json(), 200
return {'message': 'employee with id {} not found'.format(pk)}, 404
def _import_place(self, item: dict) -> int:
place_item = item["location"][0]
place_name = place_item["name"]
place = dict()
place["name"] = place_name
location = dict()
if "address" in place_item:
location = self._import_location(place_item["address"])
if "coordinate" in item:
lat_str, lon_str = item["coordinate"].split(",")
latitude = float(lat_str)
longitude = float(lon_str)
if latitude != 0 and longitude != 0:
location["latitude"] = latitude
location["longitude"] = longitude
place["location"] = location
hash_key = place_name
place_hash = self._hash_dict(place)
self.place_hashes.add(place_hash)
if hash_key in self.stored_place_mapping:
place_id = int(self.stored_place_mapping[hash_key])
logger.debug(f"Found place {place_name} in mapping: {place_id}.")
stored_place_hash = self.stored_place_hashes.get(hash_key, None)
if place_hash == stored_place_hash:
logger.debug("Place did not change. Nothing to do.")
else:
logger.debug("Place did change. Updating..")
self.api_client.update_place(place_id, place)
r.hset("place_hashes", hash_key, place_hash)
else:
logger.debug(f"Place {place_name} not in mapping. Inserting..")
place_id = self.api_client.upsert_place(place)
r.hset("place_mapping", hash_key, place_id)
r.hset("place_hashes", hash_key, place_hash)
return place_id
def upsert_organizer(self, data: dict) -> int:
name = data["name"]
logger.debug(f"Upsert organizer {name}")
response = self.session_client.get(
f"/organizations/{self.organization_id}/organizers?name={name}")
pagination = response.json()
organizer = self._find_item_in_pagination(pagination, name)
if not organizer:
logger.debug(f"Organizer {name} does not exist")
return self.insert_organizer(data)
organizer_id = organizer["id"]
logger.debug(
f"Organizer {organizer_id} {name} already exists. No need to update."
)
return organizer_id
def upsert_place(self, data: dict) -> int:
name = data["name"]
logger.debug(f"Upsert place {name}")
response = self.session_client.get(
f"/organizations/{self.organization_id}/places?name={name}")
pagination = response.json()
place = self._find_item_in_pagination(pagination, name)
if not place:
logger.debug(f"Place {name} does not exist")
return self.insert_place(data)
place_id = place["id"]
logger.debug(f"Place {place_id} {name} already exists")
self.update_place(place_id, data)
return place_id
def delete(self, url: str) -> Response:
url = self.complete_url(url)
logger.debug(f"DELETE {url}")
response = self.session.delete(url)
self.status_code_or_raise(response, 204)
return response
def put(self, url: str, data: Any) -> Response:
url = self.complete_url(url)
logger.debug(f"PUT {url}\n{json.dumps(data)}")
response = self.session.put(url, json=data)
self.status_code_or_raise(response, 204)
return response
def get(self, url: str) -> Response:
url = self.complete_url(url)
logger.debug(f"GET {url}")
response = self.session.get(url)
self.status_code_or_raise(response, 200)
return response
def update_organizer(self, organizer_id: int, data: dict):
logger.debug(f"Update organizer {organizer_id} {data['name']}")
self.session_client.put(f"/organizers/{organizer_id}", data=data)
def department(name):
""" Department page for changing department data and viewing list of workers """
if not Department.query.filter_by(name=name).first():
logger.debug('Aborting request with error 404')
abort(404)
return render_template('department.html', department=name)
def insert_place(self, data: dict) -> int:
logger.debug(f"Insert place {data['name']}")
response = self.session_client.post(
f"/organizations/{self.organization_id}/places", data=data)
place = response.json()
return place["id"]
def _import_event_from_url(self, url: str) -> int:
self.urls_in_run.add(url)
# Load event
item = self.harzinfo_loader.load_event(url)
if not item:
logger.warn("No event data.")
r.hset("url_mapping", url, "nodata")
return 0
if not self._is_url(item["url"]):
logger.warn("Invalid url.")
r.hset("url_mapping", url, "invalidurl")
return 0
# Check for duplicates
uid = item["identifier"][0]
if uid in self.uids_in_run:
logger.warn(f"Duplicate UID {uid}")
return 0
self.uids_in_run.add(uid)
# Compare to stored hashes
item_hash = self._hash_dict(item)
event_id = 0
if uid in self.stored_event_mapping:
event_id = int(self.stored_event_mapping[uid])
logger.debug(f"Found event for uid {uid} in mapping: {event_id}.")
stored_event_hash = self.stored_event_hashes.get(uid, None)
if item_hash == stored_event_hash:
logger.debug("Event did not change. Nothing to do.")
self.unchanged_event_count = self.unchanged_event_count + 1
return event_id
# Organizer
organizer_id = self._import_organizer(item)
# Place
place_id = self._import_place(item)
# Event
event = dict()
event["external_link"] = item["url"]
event["name"] = item["name"]
event["start"] = item["startDate"]
event["place"] = {"id": place_id}
event["organizer"] = {"id": organizer_id}
if "description" in item:
event["description"] = item["description"]
self._import_event_photo(event, item)
self._import_event_status(event, item)
self._add_categories(event, item)
self._add_tags(event, item)
if event_id > 0:
logger.debug("Event did change. Updating..")
self.api_client.update_event(event_id, event)
r.hset("event_hashes", uid, item_hash)
self.updated_event_count = self.updated_event_count + 1
else:
logger.debug(f"Event for uid {uid} not in mapping. Inserting..")
event_id = self.api_client.insert_event(event)
r.hset("event_mapping", uid, event_id)
r.hset("event_hashes", uid, item_hash)
r.hset("url_mapping", url, uid)
self.new_event_count = self.new_event_count + 1
return event_id
def update_place(self, place_id: int, data: dict):
logger.debug(f"Update place {place_id} {data['name']}")
self.session_client.put(f"/places/{place_id}", data=data)
def error_404(error):
""" Function that simply renders 404 error page """
logger.debug('Error 404 raised')
return render_template('error_pages/404.html'), 404
def insert_organizer(self, data: dict) -> int:
logger.debug(f"Insert organizer {data['name']}")
response = self.session_client.post(
f"/organizations/{self.organization_id}/organizers", data=data)
organizer = response.json()
return organizer["id"]
def error_500(error):
""" Function that simply renders 500 error page """
logger.debug('Error 500 raised')
return render_template('error_pages/500.html'), 500
def get_categories(self) -> int:
logger.debug("Get categories")
response = self.session_client.get("/event-categories?per_page=50")
pagination = response.json()
return pagination["items"]
