def get(self, project_id): results = list() user = dict() try: data_user = model.read_all("user") except Exception as e: return response(401, message=str(e)) else: for i in data_user: if i['project_id'] == project_id: user = i break try: data_zone = model.read_all("zone") except Exception as e: return response(401, message=str(e)) else: for i in data_zone: if i['user'] == user['key']: user = model.read_by_id("user", i['user']) record = model.record_by_zone(i['key']) data = { "key": i['key'], "value": i['value'], "created_at": i['created_at'], "user": user, "record": record } results.append(data) return response(200, data=results)
def get(self): try: data = model.read_all("ttl") except Exception as e: return response(401, message=str(e)) else: return response(200, data=data)
def put(self, key): parser = reqparse.RequestParser() parser.add_argument('content', type=str, required=True) parser.add_argument('id_record', type=str, required=True) args = parser.parse_args() content = args["content"] content = content.lower() record = args["id_record"] # Check Relation if model.check_relation("record", record): return response(401, message="Relation to Record error Check Your Key") # Validation if validation.content_validation(record, content): return response(401, message="Named Error") if validation.count_character(content): return response(401, message="Count Character Error") data = { "key": key, "value": content, "record": record, "created_at": utils.get_datetime() } try: model.update("content", key, data) except Exception as e: return response(401, message=str(e)) else: return response(200, data=data, message="Edited")
def get(self, key): try: data = model.read_by_id("ttl", key) except Exception as e: return response(401, message=str(e)) else: return response(200, data=data)
def add_cname_default(zone_key, record_key, zone_name): record_data = { "key": record_key, "value": "www", "zone": zone_key, "type": "2", "ttl": "6", "created_at": utils.get_datetime(), "serial": False } try: model.insert_data("record", record_key, record_data) except Exception as e: return response(401, message=str(e)) content_key = utils.get_last_key("content") content_data = { "key": content_key, "value": zone_name + ".", "record": record_key, "created_at": utils.get_datetime() } try: model.insert_data("content", content_key, content_data) except Exception as e: return response(401, message=str(e))
def add_ns_default(zone_key, record_key): record_data = { "key": record_key, "value": "@", "zone": zone_key, "type": "5", "ttl": "6", "created_at": utils.get_datetime(), "serial": False } try: model.insert_data("record", record_key, record_data) except Exception as e: return response(401, message=str(e)) default_ns = os.environ.get("DEFAULT_NS", os.getenv("DEFAULT_NS")) default_ns = default_ns.split(" ") for i in default_ns: content_key = utils.get_last_key("content") content_data = { "key": content_key, "value": i, "record": record_key, "created_at": utils.get_datetime() } try: model.insert_data("content", content_key, content_data) except Exception as e: return response(401, message=str(e))
def post(self): parser = reqparse.RequestParser() parser.add_argument('email', type=str, required=True) parser.add_argument('project_id', type=str, required=True) args = parser.parse_args() project_id = args["project_id"] email = args["email"] key = utils.get_last_key("user") if utils.check_unique("user", "email", email): return response(401, message="Duplicate email Detected") data = { "key": key, "email": email, "project_id": project_id, "state": "inserted", "created_at": utils.get_datetime() } try: model.insert_data("/user", key, data) except Exception as e: return response(401, message=str(e)) else: return response(200, data=data, message="Inserted")
def post(self): json_req = request.get_json(force=True) command = utils.get_command(request.path) command = 'dt_' + command init_data = cmd.parser(json_req, command) respons = {} if init_data['action'] == 'insert': table = init_data['data'][0]['table'] fields = init_data['data'][0]['fields'] try: result = model.insert(table, fields) except Exception as e: respons = {"status": False, "error": str(e)} else: respons = {"status": True, "messages": "Success", "id": result} finally: return response(200, data=fields, message=respons) if init_data['action'] == 'remove': table = "" tags = dict() fields = "" for i in init_data['data']: table = i['table'] tags = i['tags'] fields = str(list(tags.keys())[0]) try: result = model.delete(table, fields, tags[fields]) except Exception as e: respons = {"status": False, "messages": str(e)} else: respons = {"status": result, "messages": "Success!"} finally: return response(200, data=tags, message=respons) if init_data['action'] == 'where': obj_userdata = list() table = "" fields = "" tags = dict() for i in init_data['data']: table = i['table'] tags = i['tags'] for a in tags: if tags[a] is not None: fields = a try: result = model.get_by_id(table, fields, tags[fields]) except Exception as e: respons = {"status": False, "messages": str(e)} else: for i in result: data = { "id_product": str(i['id_product']), "nm_product": i["nm_product"], "nm_databaseref": i["nm_databaseref"] } obj_userdata.append(data) respons = {"status": True, "messages": "Fine!"} finally: return response(200, data=obj_userdata, message=respons)
def put(self, key): parser = reqparse.RequestParser() parser.add_argument('value', type=str, required=True) parser.add_argument('name', type=str, required=True) parser.add_argument('id_record', type=str, required=True) args = parser.parse_args() serial = args["value"] name = args["name"] record_key = args["id_record"] # Check Relation if model.check_relation("record", record_key): return response(401, message="Relation to Record error Check Your Key") if not utils.check_record_serial(record_key): return response(401, message="No Serial Record") data = { "key": key, "value": serial, "name": name, "record": record_key, "created_at": utils.get_datetime() } try: model.update("serial", key, data) except Exception as e: return response(401, message=str(e)) else: return response(200, data=data, message="Edited")
def post(self): headers = request.headers secret_key = common.secret_key() request_key = headers.get("X-Whois-Key") domain = request.data.decode() if secret_key is None: return response(400, message="secret key not found") if common.validate_domain(domain) is not True: return response(403, message="domain not supported") if request_key == secret_key: whois_data = whois.query(domain) data = { "name": whois_data.name, "registrar": whois_data.registrar, "creation_date": str(whois_data.creation_date), "expiration_date": str(whois_data.expiration_date), "last_updated": str(whois_data.last_updated), "name_servers": list(whois_data.name_servers), } return response(200, data=data) else: return response(401)
def post(self): parser = reqparse.RequestParser() parser.add_argument('zone', type=str, required=True) parser.add_argument('id_user', type=str, required=True) args = parser.parse_args() zone = args["zone"] zone = zone.lower() id_user = args["id_user"] key = utils.get_last_key("zone") if utils.check_unique("zone", "value", zone): return response(401, message="Duplicate zone Detected") if validation.zone_validation(zone): return response(401, message="Named Error") data = { "key": key, "value": zone, "created_at": utils.get_datetime(), "user": id_user, } try: model.insert_data("zone", key, data) except Exception as e: return response(401, message=str(e)) else: return response(200, data=data, message="Inserted")
def delete(self, key): try: data = model.delete("ttl", key) except Exception as e: return response(401, message=str(e)) else: return response(200, data=data, message="Deleted")
def add_soa_record(zone_key, record_key): record_data = { "key": record_key, "value": "@", "zone": zone_key, "type": "4", "ttl": "6", "created_at": utils.get_datetime(), "serial": False } try: model.insert_data("record", record_key, record_data) except Exception as e: return response(401, message=str(e)) date_data = utils.soa_time_set() + "01" default_soa_content = os.environ.get("DEFAULT_SOA_CONTENT", os.getenv("DEFAULT_SOA_CONTENT")) default_soa_serial = os.environ.get("DEFAULT_SOA_SERIAL", os.getenv("DEFAULT_SOA_SERIAL")) content_value = default_soa_content + " " + date_data + " " + default_soa_serial content_key = utils.get_last_key("content") content_data = { "key": content_key, "value": content_value, "record": record_key, "created_at": utils.get_datetime() } try: model.insert_data("content", content_key, content_data) except Exception as e: return response(401, message=str(e))
def decorated_function(*args, **kwargs): if 'X-Whois-Key' not in request.headers: return response(401, message="Invalid access key") else: whoiskey = request.headers['X-Whois-Key'] if not pbkdf2_sha256.verify(WHOIS_PASSWORD, whoiskey): return response(401, message="Invalid access key") return f(*args, **kwargs)
def get(self, key): zone_data = model.read_by_id("zone", key)['value'] command_data = command.config_zone(zone_data, key) try: test = producer.send(command_data) except Exception as e: return response(401, message=str(e)) else: data = {"send_status": test, "command": command_data} return response(200, data=data, message=test)
def decorated_function(*args, **kwargs): if 'Access-Token' not in request.headers: check_admin = check_admin_mode(request.remote_addr) if not check_admin: return response(400, message="Your not access") else: access_token = request.headers['Access-Token'] stored_data = redis_store.get('{}'.format(access_token)) if not stored_data: return response(400, message=" Invalid access token ") return f(*args, **kwargs)
def put(self, key): parser = reqparse.RequestParser() parser.add_argument('ttl', type=str, required=True) args = parser.parse_args() ttl = args["ttl"] data = {"key": key, "value": ttl} try: model.update("ttl", key, data) except Exception as e: return response(401, message=str(e)) else: return response(200, data=data, message="Edited")
def post(self): parser = reqparse.RequestParser() parser.add_argument('zone', type=str, required=True) parser.add_argument('project_id', type=str, required=True) args = parser.parse_args() zone = args['zone'] project_id = args['project_id'] user = model.get_user_by_project_id(project_id)['key'] zone_key = utils.get_last_key("zone") # Validation Unique Zone if utils.check_unique("zone", "value", zone): return response(401, message="Duplicate zone Detected") # Validation Zone Name if validation.zone_validation(zone): return response(401, message="Named Error") # Check Relation Zone to User if model.check_relation("user", user): return response(401, message="Relation to user error Check Your Key") zone_data = { "key": zone_key, "value": zone, "created_at": utils.get_datetime(), "user": user, } try: model.insert_data("zone", zone_key, zone_data) except Exception as e: return response(401, message=str(e)) else: # Adding Zone Config config_command = command.config_zone(zone, zone_key) producer.send(config_command) # ADDING DEFAULT RECORD record_key_soa = utils.get_last_key("record") add_soa_record(zone_key, record_key_soa) command.soa_default_command(record_key_soa) record_key_ns = utils.get_last_key("record") add_ns_default(zone_key, record_key_ns) command.ns_default_command(record_key_ns) record_key_cname = utils.get_last_key("record") add_cname_default(zone_key, record_key_cname, zone) json_command = command.record_insert(record_key_cname) producer.send(json_command) # DEFAULT RECORD END return response(200, data=zone_data, message="Inserted")
def post(self): parser = reqparse.RequestParser() parser.add_argument('ttl', type=str, required=True) args = parser.parse_args() ttl = args["ttl"] key = utils.get_last_key("ttl") data = {"key": key, "value": ttl} try: model.insert_data("ttl", key, data) except Exception as e: return response(401, message=str(e)) else: return response(200, data=data, message="Inserted")
def post(self): parser = reqparse.RequestParser() parser.add_argument('username', type=str, required=True) parser.add_argument('password', type=str, required=True) parser.add_argument('project_id', type=str, required=True) args = parser.parse_args() username = args['username'] password = args['password'] project_id = args['project_id'] os_admin = os.getenv('ADMIN_USER') os_password = os.getenv("ADMIN_PASSWORD") if username == os_admin and os_password==password: data_user = db.get_by_id("userdata", "project_id", project_id) if not data_user: return response(200, message= "Project ID Not Found") stored_data = { 'username': username, 'project_id': data_user[0]['project_id'], 'user_id': data_user[0]['user_id'], 'timestamp': arrow.now(), 'session': "admin" } random_string = uuid.uuid4() raw_token = '{}{}'.format(random_string, username) access_token = hashlib.sha256(raw_token.encode( 'utf-8')).hexdigest() try: dill_object = dill.dumps(stored_data) redis_store.set(access_token, dill_object) redis_store.expire(access_token,3600) except Exception as e: resp = { "error": str(e) } return response(401, message= resp) else: data = { 'project_id': data_user[0]['project_id'], 'user_id': data_user[0]['user_id'], "token": access_token } return response(200, data= data) else: return response(401, message= "Not Found")
def get(self, key): try: data_zone = model.read_by_id("zone", key) except Exception as e: return response(401, message=str(e)) else: user_data = model.read_by_id("user", data_zone['user']) data = { "key": data_zone['key'], "value": data_zone['value'], "created_at": data_zone['created_at'], "user": user_data } return response(200, data=data)
def put(self, id): parser = reqparse.RequestParser() parser.add_argument('key', type=str, required=True) parser.add_argument('key1', type=str, required=False) args = parser.parse_args() try: data = { "user": args['key'], "password": args['key1'], } except Exception as e: return rest.response(401, message=str(e)) else: return rest.response(200, data=data, message="PUT Ok By" + id)
def get(self): command = utils.get_command(request.path) command = "dt_" + command try: results = model.get_all(command) obj_userdata = list() for i in results: data = { "id_hosting": str(i['id_hosting']), "id_company_product": str(i['id_company_product']), 'spec_price': i['spec_price'], "spec_storage": i['spec_storage'], 'spec_database': i['spec_database'], "spec_free_domain": i['spec_free_domain'], "spec_hosting_domain": i['spec_hosting_domain'], 'spec_subdomain': i['spec_subdomain'], "spec_ftp_user": i['spec_ftp_user'], "spec_control_panel": i['spec_control_panel'], 'spec_email_account': i['spec_email_account'], "spec_spam_filter": i['spec_spam_filter'], "date_time": i['date_time'] } obj_userdata.append(data) except Exception: results = None else: return response(200, data=obj_userdata)
def post(self): parser = reqparse.RequestParser() parser.add_argument('email', type=str, required=True) parser.add_argument('messages', type=str, required=True) args = parser.parse_args() data = { "email": args['email'], "subject": "Test", "messages": args['messages'] } try: producer.send("email_service", data) except Exception as e: return response(401, message=str(e)) else: return response(200, data=data, message="Sending Email")
def get(self): command = utils.get_command(request.path) command = "dt_" + command try: results = model.get_all(command) obj_userdata = list() for i in results: data = { "id_vm": str(i['id_vm']), "id_company_product": str(i['id_company_product']), "spec_vcpu": i['spec_vcpu'], 'spec_clock': i['spec_clock'], "spec_ram": i['spec_ram'], "spec_os": i['spec_os'], "spec_storage_volume": i['spec_storage_volume'], 'spec_ssd_volume': i['spec_ssd_volume'], "spec_snapshot_volume": i['spec_snapshot_volume'], "spec_template_volume": i['spec_template_volume'], 'spec_iso_volume': i['spec_iso_volume'], "spec_public_ip": i['spec_public_ip'], "spec_backup_storage": i['spec_backup_storage'], 'spec_price': i['spec_price'], "spec_notes": i['spec_notes'], "date_time": i['date_time'] } obj_userdata.append(data) except Exception: results = None else: return response(200, data=obj_userdata)
def post(self): parser = reqparse.RequestParser() parser.add_argument('username', type=str, required=True) parser.add_argument('password', type=str, required=True) args = parser.parse_args() username = args['username'] password = args['password'] try: sess = login_utils.generate_session(username, password, GLOBAL_AUTH_URL, GLOBAL_USER_DOMAIN_NAME) except Exception as e: return str(e) else: user_id = sess.get_user_id() project_id = login_utils.get_project_id(sess) stored_data = { 'username': username, 'user_id': user_id, 'project_id': project_id, 'timestamp': arrow.now(), 'session': sess } random_string = uuid.uuid4() raw_token = '{}{}'.format(random_string, username) access_token = hashlib.sha256( raw_token.encode('utf-8')).hexdigest() try: dill_object = dill.dumps(stored_data) redis_store.set(access_token, dill_object) redis_store.expire(access_token, 3600) except Exception as e: resp = {"error": str(e)} return response(200, message=resp) else: data = { "user_id": user_id, "project_id": project_id, "token": access_token } return response(200, data=data)
def get(self): results = list() try: data_zone = model.read_all("zone") except Exception as e: return response(401, message=str(e)) for i in data_zone: user_data = model.read_by_id("user", i['user']) data = { "key": i['key'], "value": i['value'], "created_at": i['created_at'], "user": user_data } results.append(data) return response(200, data=results)
def delete(self, key): try: record = model.record_by_zone(key) except Exception as e: return response(401, message="Record Not Found | " + str(e)) else: for i in record: try: model.record_delete(i['key']) except Exception as e: print(e) try: model.delete("zone", key) except Exception as e: return response(401, message=str(e)) else: return response(200, message="Domain Or Zone Deleted")
def wrapper(*args, **kwargs): username = get_jwt_identity() user = db.get_by_id(table="userlogin", field="username", value=username) if not user: data = {"msg": "user not found"} return response(404, data=data) g.user = user[0] return fn(*args, **kwargs)
def get(self, key): try: data_content = model.read_by_id("content", key) except Exception as e: return response(401, message=str(e)) else: record = model.read_by_id("record", data_content['record']) types = model.read_by_id("type", record['type']) ttl = model.read_by_id("ttl", record['ttl']) zone = model.read_by_id("zone", record['zone']) data = { "key": data_content['key'], "value": data_content['value'], "created_at": data_content['created_at'], "record": record, "ttl": ttl, "type": types, "zone": zone } return response(200, data=data)