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"]