def show_latest_catalog(): databaseManager = DatabaseManager() categories = databaseManager.get_categories() items = databaseManager.get_latest_items() return render_template("latest_item_catalog.html", categories=categories, items=items, category_id=0)
def show_catalog(id): databaseManager = DatabaseManager() categories = databaseManager.get_categories() items = databaseManager.get_items(id) itemcount = databaseManager.get_items_count(id) return render_template("catalog.html", categories=categories, items=items, category_id=id, itemcount=itemcount)
class PicManager: def __init__(self): self.data_manager = DatabaseManager() self.pic_site = "https://source.unsplash.com/category/" self.pic_size = "/1400x1200" self.pic_to_upload = "pic1.jpg" # zwraca liste 20 defaultowych tagow LIKE COMENT FOLLOW SHOUTOUT def get_default_category_tags(self, list): list.extend(self.data_manager.get_count_tag_by_category('Likes', 5)) list.extend(self.data_manager.get_count_tag_by_category('Comments', 5)) list.extend(self.data_manager.get_count_tag_by_category('Follow me', 5)) list.extend(self.data_manager.get_count_tag_by_category('Shoutout', 5)) return list # zwraca liste tagow z zadanej kategorii # 20 tagow defaultowych i okreslone parametrem limit tagi z zadanej kategorii def get_tags(self, category, limit): list = [] list.extend(self.data_manager.get_count_tag_by_category(category, limit)) self.get_default_category_tags(list) return list def urban_url(self): return "buildings" # dodaje zdjecie def upload(self, list): list = self.get_tags("Urban", 10) context = ssl._create_unverified_context() #category_url = get_category_url(category) urllib.urlretrieve(self.pic_site + "buildings" + self.pic_size, self.pic_to_upload, context=context) self.cut_image() with pynstagram.client('urbanshot__', 'kluza1') as client: tags = '' for tag in list: tags = tags + '#' + tag + ' ' client.upload('pic1.jpg', tags) return list # przycina zdjecie do kwadratu def cut_image(self): img = Image.open(self.pic_to_upload) half_width = img.size[0] / 2 half_height = img.size[1] / 2 img1 = img.crop( ( half_width - 450, half_height - 450, half_width + 450, half_height + 450 ) ) img1.save(self.pic_to_upload)
class PicManager: def __init__(self): self.data_manager = DatabaseManager() self.pic_site = "https://source.unsplash.com/category/" self.pic_size = "/1400x1200" self.pic_to_upload = "pic1.jpg" # zwraca liste 20 defaultowych tagow LIKE COMENT FOLLOW SHOUTOUT def get_default_category_tags(self, list): list.extend(self.data_manager.get_count_tag_by_category('Likes', 5)) list.extend(self.data_manager.get_count_tag_by_category('Comments', 5)) list.extend(self.data_manager.get_count_tag_by_category( 'Follow me', 5)) list.extend(self.data_manager.get_count_tag_by_category('Shoutout', 5)) return list # zwraca liste tagow z zadanej kategorii # 20 tagow defaultowych i okreslone parametrem limit tagi z zadanej kategorii def get_tags(self, category, limit): list = [] list.extend( self.data_manager.get_count_tag_by_category(category, limit)) self.get_default_category_tags(list) return list def urban_url(self): return "buildings" # dodaje zdjecie def upload(self, list): list = self.get_tags("Urban", 10) context = ssl._create_unverified_context() #category_url = get_category_url(category) urllib.urlretrieve(self.pic_site + "buildings" + self.pic_size, self.pic_to_upload, context=context) self.cut_image() with pynstagram.client('urbanshot__', 'kluza1') as client: tags = '' for tag in list: tags = tags + '#' + tag + ' ' client.upload('pic1.jpg', tags) return list # przycina zdjecie do kwadratu def cut_image(self): img = Image.open(self.pic_to_upload) half_width = img.size[0] / 2 half_height = img.size[1] / 2 img1 = img.crop((half_width - 450, half_height - 450, half_width + 450, half_height + 450)) img1.save(self.pic_to_upload)
def create_new_item(category_id): databaseManager = DatabaseManager() if request.method == "POST": databaseManager.create_items(request.form["category"], request.form["name"], request.form["description"], user_id=login_session['user_id']) if category_id == 0: return redirect(url_for("show_latest_catalog")) else: return redirect(url_for("show_catalog", id=category_id)) else: categories = databaseManager.get_categories() return render_template("create_item.html", category_id=category_id, categories=categories)
def __init__(self, login, password): self.data_manager = DatabaseManager() self.pic_site = { "Swimming" : "https://source.unsplash.com/category/people/?swimming", "Running" : "https://source.unsplash.com/category/people/?running", "Cars" : "https://source.unsplash.com/category/objects/?cars", "Sports" : "https://source.unsplash.com/category/people/?sports", "Winter" : "https://source.unsplash.com/category/nature/?winter", "Summer" : "https://source.unsplash.com/category/nature/?summer", "Friends" : "https://source.unsplash.com/category/people/?friends", "Boys" : "https://source.unsplash.com/category/people/?boys", "Baby" : "https://source.unsplash.com/category/people/?baby", "People" : "https://source.unsplash.com/category/people", "Sea" : "https://source.unsplash.com/category/nature/?sea", "Flower" : "https://source.unsplash.com/category/nature/?flower", "Urban" : "https://source.unsplash.com/category/buildings", "Love" : "https://source.unsplash.com/category/people/?love", "Nature" : "https://source.unsplash.com/category/nature", "Food" : "https://source.unsplash.com/category/food" } self.pic_size = "/1400x1200" self.pic_to_upload = "pic1.jpg" self.login = login self.password = password self.category = "brak"
def __update_plan_type(self, plan_type: PlanType): self.__plan_type = plan_type with DatabaseManager.connect() as database_connection: database_connection.execute( "UPDATE magic_castles SET plan_type = ? WHERE hostname = ?", (self.__plan_type.value, self.__hostname), ) database_connection.commit()
def run(self): database = DatabaseManager(self._args) try: character_manager = CharacterManager(database) discord_manager = Bot(character_manager, command_prefix='MG!', prefix='MG!', command_attrs=dict(hidden=True)) self.load_cogs(discord_manager) discord_manager.run(self._token) except KeyboardInterrupt: database.close() logging.warning("Exiting...") sys.exit(1)
def edit_item(item_id, category_id): databaseManager = DatabaseManager() if request.method == "GET": item = databaseManager.get_item(item_id) categories = databaseManager.get_categories() return render_template("edit_item.html", item=item, categories=categories, category_id=category_id) else: item = databaseManager.update_item(item_id, request.form["name"], request.form["description"], request.form["category"]) flash("update item successfully") if category_id == 0: return redirect(url_for("show_latest_catalog")) else: return redirect(url_for("show_catalog", id=item.category_id))
def join_chow(cls, chow_id, token): db = database.getInstance() client = boto3.client('cognito-idp', region_name='us-east-2') user = client.get_user(AccessToken=token) chow = db.get_item_as_json('Chow', chow_id) chow['joinedUser'] = user['Username'] chow['joinedName'] = user['UserAttributes'][2]['Value'] #username is stored here chow['joinedEmail'] = user['UserAttributes'][3]['Value'] #email is stored here success = db.put_item('Chow', chow) return jsonify({"success":success})
def unjoin_chow(cls, chow_id, token): db = database.getInstance() client = boto3.client('cognito-idp', region_name='us-east-2') user = client.get_user(AccessToken=token) chow = db.get_item_as_json('Chow', chow_id) chow['joinedUser'] = None chow['joinedName'] = None chow['joinedEmail'] = None success = db.put_item('Chow', chow) return jsonify({"success":success})
def get_joined_chows(cls, token): db = database.getInstance() client = boto3.client('cognito-idp', region_name='us-east-2') user = client.get_user(AccessToken=token) chows = db.scan_as_json_with_criteria('Chow', 'joinedUser', user['Username']) chows = chowutil.remove_soft_delete(chows) chows = chowutil.remove_expired(chows) return jsonify(chows)
def myDynamodb(request): # Create table for testing db = database.getInstance() db.create_table('ChowTest') def remove_table(): print('delete table ChowTest') db.delete_table('ChowTest') request.addfinalizer(remove_table) return db
def get_plan_type(self) -> PlanType: if self.__plan_type is None: with DatabaseManager.connect() as database_connection: result = database_connection.execute( "SELECT plan_type FROM magic_castles WHERE hostname = ?", (self.get_hostname(), ), ).fetchone() if result: self.__plan_type = PlanType(result[0]) else: self.__plan_type = PlanType.NONE return self.__plan_type
def get_owner(self): if self.__owner is None: with DatabaseManager.connect() as database_connection: result = database_connection.execute( "SELECT owner FROM magic_castles WHERE hostname = ?", (self.get_hostname(), ), ).fetchone() if result: self.__owner = result[0] else: self.__owner = None return self.__owner
def get_status(self) -> ClusterStatusCode: if self.__status is None: with DatabaseManager.connect() as database_connection: result = database_connection.execute( "SELECT status FROM magic_castles WHERE hostname = ?", (self.get_hostname(), ), ).fetchone() if result: self.__status = ClusterStatusCode(result[0]) else: self.__status = ClusterStatusCode.NOT_FOUND return self.__status
def get_chows(cls, remove_expired=True): db = database.getInstance() chows = db.scan_as_json('Chow') # remove chows that are marked as 'isDeleted' chows = chowutil.remove_soft_delete(chows) if (remove_expired): chows = chowutil.remove_expired(chows) #remove chows that have been "chowed in" on chows = chowutil.remove_joined_users(chows) response = jsonify(chows) return response
def delete_item(item_id, category_id): if request.method == "GET": databaseManager = DatabaseManager() item = databaseManager.get_item(item_id) return render_template("delete_item.html", item=item, category_id=category_id) else: flash("delete item successfully") databaseManager = DatabaseManager() databaseManager.delete_item(item_id) if category_id == 0: return redirect(url_for("show_latest_catalog")) else: return redirect(url_for("show_catalog", id=category_id))
def __update_status(self, status: ClusterStatusCode): self.__status = status with DatabaseManager.connect() as database_connection: database_connection.execute( "UPDATE magic_castles SET status = ? WHERE hostname = ?", (self.__status.value, self.__hostname), ) database_connection.commit() # Log cluster status updates for log analytics print( json.dumps({ "hostname": self.get_hostname(), "status": self.__status.value, "owner": self.get_owner(), }), flush=True, )
def __init__(self, configuration): self.configuration = configuration self.last_msg = 0 self.bot = None self.ttt_games = {} self.database_manager = DatabaseManager() if self.database_manager.db.engine is not None: self.event_manager = EventManager(self.database_manager) self.time_manager = TimeManager(self.event_manager) else: self.database_manager = None self.event_manager = None self.time_manager = None self.id_manager = IdentityManager(self.database_manager) self.nickname_manager = NicknameManager(self.database_manager) self.birthday_manager = BirthdayManager(self.database_manager) self.wheel_manager = WheelManager(self.database_manager) self.reminder_manager = ReminderManager()
def decorator(*args, **kwargs): auth_type = AuthType(config.get("auth_type") or "NONE") with DatabaseManager.connect() as database_connection: if auth_type == AuthType.SAML: try: # Note: Request headers are interpreted as ISO Latin 1 encoded strings. # Therefore, special characters and accents in givenName and surname are not correctly decoded. user = AuthenticatedUser( database_connection, edu_person_principal_name=request. headers["eduPersonPrincipalName"], given_name=request.headers["givenName"], surname=request.headers["surname"], mail=request.headers["mail"], ) except KeyError: # Missing an authentication header raise UnauthenticatedException else: user = AnonymousUser(database_connection) return route_handler(user, *args, **kwargs)
class PicManager: def __init__(self, login, password): self.data_manager = DatabaseManager() self.pic_site = { "Swimming" : "https://source.unsplash.com/category/people/?swimming", "Running" : "https://source.unsplash.com/category/people/?running", "Cars" : "https://source.unsplash.com/category/objects/?cars", "Sports" : "https://source.unsplash.com/category/people/?sports", "Winter" : "https://source.unsplash.com/category/nature/?winter", "Summer" : "https://source.unsplash.com/category/nature/?summer", "Friends" : "https://source.unsplash.com/category/people/?friends", "Boys" : "https://source.unsplash.com/category/people/?boys", "Baby" : "https://source.unsplash.com/category/people/?baby", "People" : "https://source.unsplash.com/category/people", "Sea" : "https://source.unsplash.com/category/nature/?sea", "Flower" : "https://source.unsplash.com/category/nature/?flower", "Urban" : "https://source.unsplash.com/category/buildings", "Love" : "https://source.unsplash.com/category/people/?love", "Nature" : "https://source.unsplash.com/category/nature", "Food" : "https://source.unsplash.com/category/food" } self.pic_size = "/1400x1200" self.pic_to_upload = "pic1.jpg" self.login = login self.password = password self.category = "brak" # zwraca liste 20 defaultowych tagow LIKE COMENT FOLLOW SHOUTOUT def get_default_category_tags(self, list): list.extend(self.data_manager.get_count_tag_by_category('Likes', 5)) list.extend(self.data_manager.get_count_tag_by_category('Comments', 5)) list.extend(self.data_manager.get_count_tag_by_category('Follow me', 5)) list.extend(self.data_manager.get_count_tag_by_category('Shoutout', 5)) return list # zwraca liste tagow z zadanej kategorii # 20 tagow defaultowych i okreslone parametrem limit tagi z zadanej kategorii def get_tags(self, category, limit): list = [] list.extend(self.data_manager.get_count_tag_by_category(category, limit)) self.get_default_category_tags(list) return list # dodaje zdjecie def upload(self): list = self.get_tags(self.category, 10) context = ssl._create_unverified_context() category_url = self.pic_site[self.category] + self.pic_size urllib.urlretrieve(category_url, self.pic_to_upload, context=context) self.cut_image() with pynstagram.client(self.login, self.password) as client: tags = '' for tag in list: tags = tags + '#' + tag + ' ' client.upload('pic1.jpg', tags) print("Photo uploaded") return list # przycina zdjecie do kwadratu def cut_image(self): img = Image.open(self.pic_to_upload) half_width = img.size[0] / 2 half_height = img.size[1] / 2 img1 = img.crop( ( half_width - 450, half_height - 450, half_width + 450, half_height + 450 ) ) img1.save(self.pic_to_upload)
def terraform_apply(destroy: bool): try: self.__rotate_terraform_logs(apply=True) with open( self.__get_cluster_path(TERRAFORM_APPLY_LOG_FILENAME), "w") as output_file: environment_variables = environ.copy() dns_manager = DnsManager(self.get_domain()) environment_variables.update( dns_manager.get_environment_variables()) environment_variables["OS_CLOUD"] = DEFAULT_CLOUD if destroy: environment_variables["TF_WARN_OUTPUT_ERRORS"] = "1" run( [ "terraform", "apply", "-input=false", "-no-color", "-auto-approve", self.__get_cluster_path( TERRAFORM_PLAN_BINARY_FILENAME), ], cwd=self.__get_cluster_path(), stdout=output_file, stderr=output_file, check=True, env=environment_variables, ) if destroy: # Removes the content of the cluster's folder, even if not empty rmtree(self.__get_cluster_path(), ignore_errors=True) with DatabaseManager.connect() as database_connection: database_connection.execute( "DELETE FROM magic_castles WHERE hostname = ?", (self.get_hostname(), ), ) database_connection.commit() else: self.__update_status( ClusterStatusCode.PROVISIONING_RUNNING) if not destroy: provisioning_manager = ProvisioningManager( self.get_hostname()) # Avoid multiple threads polling the same cluster if not provisioning_manager.is_busy(): try: provisioning_manager.poll_until_success() status_code = ClusterStatusCode.PROVISIONING_SUCCESS except PuppetTimeoutException: status_code = ClusterStatusCode.PROVISIONING_ERROR self.__update_status(status_code) except CalledProcessError: logging.info( "An error occurred while running terraform apply.") self.__update_status(ClusterStatusCode.DESTROY_ERROR if destroy else ClusterStatusCode.BUILD_ERROR) finally: self.__remove_existing_plan()
def __plan(self, *, destroy, existing_cluster): plan_type = PlanType.DESTROY if destroy else PlanType.BUILD if existing_cluster: self.__remove_existing_plan() previous_status = self.get_status() else: with DatabaseManager.connect() as database_connection: database_connection.execute( "INSERT INTO magic_castles (hostname, cluster_name, domain, status, plan_type, owner) VALUES (?, ?, ?, ?, ?, ?)", ( self.get_hostname(), self.get_cluster_name(), self.get_domain(), ClusterStatusCode.CREATED.value, plan_type.value, self.get_owner(), ), ) database_connection.commit() mkdir(self.__get_cluster_path()) previous_status = ClusterStatusCode.CREATED self.__update_status(ClusterStatusCode.PLAN_RUNNING) self.__update_plan_type(plan_type) if not destroy: self.__configuration.update_main_tf_json_file() try: run( ["terraform", "init", "-no-color", "-input=false"], cwd=self.__get_cluster_path(), capture_output=True, check=True, ) except CalledProcessError: self.__update_status(previous_status) raise PlanException( "An error occurred while initializing Terraform.", additional_details=f"hostname: {self.get_hostname()}", ) self.__rotate_terraform_logs(apply=False) with open(self.__get_cluster_path(TERRAFORM_PLAN_LOG_FILENAME), "w") as output_file: environment_variables = environ.copy() dns_manager = DnsManager(self.get_domain()) environment_variables.update( dns_manager.get_environment_variables()) environment_variables["OS_CLOUD"] = DEFAULT_CLOUD try: run( [ "terraform", "plan", "-input=false", "-no-color", "-destroy=" + ("true" if destroy else "false"), "-out=" + self.__get_cluster_path( TERRAFORM_PLAN_BINARY_FILENAME), ], cwd=self.__get_cluster_path(), env=environment_variables, stdout=output_file, stderr=output_file, check=True, ) except CalledProcessError: if destroy: # Terraform returns an error if we try to destroy a cluster when the image # it was created with does not exist anymore (e.g. CentOS-7-x64-2019-07). In these cases, # not refreshing the terraform state (refresh=false) solves the issue. try: run( [ "terraform", "plan", "-refresh=false", "-input=false", "-no-color", "-destroy=" + ("true" if destroy else "false"), "-out=" + self.__get_cluster_path( TERRAFORM_PLAN_BINARY_FILENAME), ], cwd=self.__get_cluster_path(), env=environment_variables, stdout=output_file, stderr=output_file, check=True, ) except CalledProcessError: # terraform plan fails even without refreshing the state self.__update_status(previous_status) raise PlanException( "An error occurred while planning changes.", additional_details= f"hostname: {self.get_hostname()}", ) else: self.__update_status(previous_status) raise PlanException( "An error occurred while planning changes.", additional_details=f"hostname: {self.get_hostname()}", ) with open(self.__get_cluster_path(TERRAFORM_PLAN_JSON_FILENAME), "w") as output_file: try: run( [ "terraform", "show", "-no-color", "-json", TERRAFORM_PLAN_BINARY_FILENAME, ], cwd=self.__get_cluster_path(), stdout=output_file, check=True, ) except CalledProcessError: self.__update_status(previous_status) raise PlanException( "An error occurred while exporting planned changes.", additional_details=f"hostname: {self.get_hostname()}", ) self.__update_status(previous_status)
def create_chow(cls, chow): db = database.getInstance() success = db.put_item('Chow', chow) response = jsonify({"success": success}) return response
def get_items_by_category(id): databaseManager = DatabaseManager() items = databaseManager.get_items(id) return jsonify(items=[i.serialize for i in items])
def get_items_by_id(item_id): databaseManager = DatabaseManager() item = databaseManager.get_item(item_id) return jsonify(item.serialize)
def show_item(item_id, category_id): databaseManager = DatabaseManager() item = databaseManager.get_item(item_id) return render_template("show_item.html", item=item, category_id=category_id)
def delete_chow(cls, chow_id): db = database.getInstance() success = db.soft_delete_item('Chow', chow_id) return jsonify({"success":success})
from flask import Flask, send_file, send_from_directory from resources.magic_castle_api import MagicCastleAPI from resources.progress_api import ProgressAPI from resources.available_resources_api import AvailableResourcesApi from resources.user_api import UserAPI from flask_cors import CORS from models.cloud.openstack_manager import OpenStackManager from database.schema_manager import SchemaManager from database.database_manager import DatabaseManager from models.configuration import config # Exit with an error if the clouds.yaml is not found or the OpenStack API can't be reached OpenStackManager.test_connection() # Update the database schema to the latest version with DatabaseManager.connect() as database_connection: SchemaManager(database_connection).update_schema() app = Flask(__name__) # Allows all origins on all routes (not safe for production) CORS( app, origins=config["cors_allowed_origins"], ) magic_castle_view = MagicCastleAPI.as_view("magic_castle") app.add_url_rule( "/api/magic-castles", view_func=magic_castle_view, defaults={"hostname": None},
#! /usr/bin/env python3 from database.database_manager import DatabaseManager database = DatabaseManager() # Get top 3 articles top_three_articles = database.get_popular_three_articles() print("1. What are the most popular three articles of all time?") for article in top_three_articles: print("\"" + article[0] + "\" -- " + str(article[1]) + " views") # Get top authors of all time print("2. Who are the most popular article authors of all time?") top_authors = database.get_popular_authors() for authors in top_authors: print(authors[0] + " -- " + str(authors[1]) + " views") # Get error requests which are more than 1% print("3. On which days did more than 1% of requests lead to errors?") fail_request = database.get_error_requests() for bad_request in fail_request: print(bad_request[0] + " -- " + str(bad_request[1]) + "% errors")
def get_chow(cls, chow_id): db = database.getInstance() chow = db.get_item_as_json('Chow', chow_id) response = jsonify(chow) return response
def __init__(self): self.data_manager = DatabaseManager() self.pic_site = "https://source.unsplash.com/category/" self.pic_size = "/1400x1200" self.pic_to_upload = "pic1.jpg"
def update_chow(cls, chow_id, chow): db = database.getInstance() chow['id'] = chow_id success = db.put_item('Chow', chow) return jsonify({"success": success, "chow": chow})