def addCNAMEDefault(id_zone, nm_zone): id_record = None data_record = { "nm_record": "www", "date_record":str(date), "id_type": "402427533112147969", "id_zone": id_zone } try: id_record = db.insert("zn_record", data=data_record) except Exception as e: print(e) data_ttl = { "id_record": id_record, "id_ttl": "402140815780249601" } try: id_ttl_data = db.insert("zn_ttldata", data=data_ttl) except Exception as e: print(e) data_content = { "id_ttldata": id_ttl_data, "nm_content": nm_zone+"." } try: db.insert("zn_content", data=data_content) except Exception as e: print(e) return id_record
def post(self): parser = reqparse.RequestParser() parser.add_argument('id_userdata', type=str, required=True) parser.add_argument('username', type=str, required=True) parser.add_argument('password', type=str, required=True) args = parser.parse_args() password_hash = pbkdf2_sha256.hash(args['password']) data_insert = { "id_userdata" : args['id_userdata'], "username" : args['username'], "password" : password_hash, } try: db.insert(table="tb_user", data=data_insert) except Exception as e: message = { "status": False, "error": str(e) } else: message = { "status": True, "data": data_insert } finally: return response(200, message=message)
def post(self): parser = reqparse.RequestParser() parser.add_argument('domain', type=str, required=True) parser.add_argument('project_id', type=str, required=True) args = parser.parse_args() project_id = args['project_id'] zone = args['domain'] zone_domain = {'nm_zone': zone} check = False data_insert = None try: data_insert = db.insert("zn_zone", zone_domain) check = True except Exception as e: msg = str(e) if not check: print(msg) else: userdata = db.get_by_id("userdata", "project_id", str(project_id)) userdata_id = userdata[0]['userdata_id'] dt_user_zone = { 'id_zone': str(data_insert), 'userdata_id': str(userdata_id) } db.insert("zn_user_zone", dt_user_zone) id_zone_soa = addSOADefault(zone) id_zone_ns = addNSDefault(zone) id_record = addCNAMEDefault(data_insert, zone) # #UNCOMENT TO SYNC AUTO sync_conf_insert(data_insert) sync_soa(id_zone_soa) sync_ns(id_zone_ns) sync_cname_default(data_insert, id_record) # #UNCOMENT TO SYNC AUTO respon = list() try: zone_data = db.get_by_id("zn_zone", "nm_zone", zone) except Exception as e: data = {"status": False, "messages": str(e)} respon.append(data) return response(200, message=data) else: for i in zone_data: data = { 'id_zone': str(i['id_zone']), 'nm_zone': i['nm_zone'], 'state': i['state'] } respon = {"status": True, "data": data} return response(200, data=respon, message="Fine!")
def post(self): parser = reqparse.RequestParser() parser.add_argument('project_id', type=str, required=True) parser.add_argument('user_id', type=str, required=True) args = parser.parse_args() data_insert = { "project_id" : args['project_id'], "user_id" : args['user_id'], } try: result = db.insert(table="userdata", data=data_insert) except Exception as e: message = { "status": False, "error": str(e) } else: message = { "status": True, "data": data_insert, "id": result } finally: return response(200, message=message)
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 insert_user(self): random_string = uuid.uuid4() raw_token = '{}{}'.format(random_string, request.form['email']) access_token = hashlib.sha256(raw_token.encode('utf-8')).hexdigest() data_insert = { "email" : request.form['email'], "first_name" : request.form['first_name'], "last_name" : request.form['last_name'], "location" : request.form['location'], "sso_id" : access_token, } try: result = db.insert(table="tb_userdata", data=data_insert) except Exception as e: data = { "status": False, "error": str(e) } return response(200, message=data) else: data = { "status": True, "data": data_insert, "id": result } return response(200, data=data)
def post(self): parser = reqparse.RequestParser() parser.add_argument('id_zone', type=str, required=True) parser.add_argument("user-id", type=str, required=True, location='headers') args = parser.parse_args() args['user_id'] = args.pop('user-id') temp = db.get_all(table='userdata') for i in temp: if str(i['user_id']) == args['user_id']: userdata_id = str(i['userdata_id']) data_insert = { "id_zone" : args['id_zone'], "userdata_id" : userdata_id } try : result = db.insert(table='zn_user_zone', data=data_insert) except Exception as e: message = { "status" : False, "error" : str(e) } else: message = { "status" : True, "data" : data_insert, "id" : result } finally: return response(200, message=message)
def insert_cname_record(zone_id): record_data = { "owner": "www", "zone_id": zone_id, "type_id": "5", "ttl_id": "6" } record_id = model.insert(table="record", data=record_data) return record_id
def insert_ns_record(zone_id): record_data = { "owner": "@", "zone_id": zone_id, "type_id": "4", "ttl_id": "6" } record_id = model.insert(table="record", data=record_data) return record_id
def insert_soa_rdata(record_id): """Insert default SOA record. Notes: <MNAME> <RNAME> <serial> <refresh> <retry> <expire> <minimum> See: https://tools.ietf.org/html/rfc1035 (3.3.13. SOA RDATA format) """ current_time = helpers.soa_time_set() serial = f"{str(current_time)}01" default_soa_content = os.environ.get("DEFAULT_SOA_RDATA") rdatas = default_soa_content.split(" ") # rdata doesn't contains serial mname_and_rname = " ".join(rdatas[0:2]) ttls = " ".join(rdatas[2:]) rdata = f"{mname_and_rname} {serial} {ttls}" content_data = {"rdata": rdata, "record_id": record_id} model.insert(table="rdata", data=content_data)
def insert_login(): password_hash = pbkdf2_sha256.hash(request.form['password']) data_insert = { "id_userdata": request.form['userdata_id'], "username": request.form['username'], "password": password_hash, } try: db.insert(table="tb_user", data=data_insert) except Exception as e: respon = {"status": False, "error": str(e)} else: data_insert = { "userdata_id": request.form['userdata_id'], "username": request.form['username'], } respon = {"status": True, "data": data_insert} return response(200, message=respon)
def authorized(resp): access_token = resp['access_token'] headers = {'Authorization': 'OAuth ' + access_token} try: req = utils.get_http('https://www.googleapis.com/oauth2/v1/userinfo', None, headers) except Exception: return redirect(url_for('google')) try: dt_db = model.get_by_id("tb_userdata", "email", req['email']) except Exception as e: dt_db = None if not dt_db: data_save = { "sso_id": req['id'], "first_name": req['given_name'], "last_name": req['family_name'], "email": req['email'], "location": "", "picture": req['picture'] } try: model.insert("tb_userdata", data_save) except Exception as e: print(e) expires_in = resp['expires_in'] dill_object = dill.dumps(data_save) redis_store.set(access_token, dill_object) redis_store.expire(access_token, expires_in) else: expires_in = resp['expires_in'] dill_object = dill.dumps(dt_db[0]) redis_store.set(access_token, dill_object) redis_store.expire(access_token, expires_in) data_result = { "Access-Token": access_token, "email": req['email'], "expires": expires_in } return response(200, data=data_result)
def addSOADefault(zone): defaultdata = repodefault() zone_data = db.get_by_id("zn_zone", "nm_zone", zone) type_data = db.get_by_id("zn_type", "nm_type", "SOA") record_soa = { "nm_record": zone, "date_record": str(date), "id_zone": str(zone_data[0]['id_zone']), "id_type": str(type_data[0]['id_type']) } try: db.insert("zn_record", record_soa) except Exception as e: print(e) record_soa_data = db.get_by_id("zn_record", "id_zone", zone_data[0]['id_zone']) ttldata_soa = { "id_record": str(record_soa_data[0]['id_record']), "id_ttl": "402140815780249601" } try: db.insert("zn_ttldata", ttldata_soa) except Exception as e: print(e) ttl_soa_data = db.get_by_id("zn_ttldata", "id_record", record_soa_data[0]['id_record']) content_soa_d = defaultdata['default']['ns'] for i in content_soa_d: content_soa = { "id_ttldata": str(ttl_soa_data[0]['id_ttldata']), "nm_content": i } try: db.insert("zn_content", content_soa) except Exception as e: print(e) serial_content_soa = defaultdata['default']['serial'] for c in serial_content_soa: serial_content = { "nm_content_serial": c, "id_record": str(record_soa_data[0]['id_record']) } try: db.insert("zn_content_serial", serial_content) except Exception as e: print(e) return str(zone_data[0]['id_zone'])
def post(self): parser = reqparse.RequestParser() parser.add_argument('email', type=str, required=True) parser.add_argument('first_name', type=str, required=True) parser.add_argument('last_name', type=str, required=True) parser.add_argument('location', type=str, required=True) args = parser.parse_args() data_insert = { "email": args['email'], "first_name": args['first_name'], "last_name": args['last_name'], "location": args['location'] } try: db.insert(table="tb_userdata", data=data_insert) except Exception as e: message = {"status": False, "error": str(e)} else: message = {"status": True, "data": data_insert} finally: return response(200, message=message)
def github_authorized(): resp = oauth.github.authorized_response() token = None for i in resp: if i == 'access_token': token = resp[i] req = utils.get_http('https://api.github.com/user?access_token=' + token, None, None) try: dt_db = model.get_by_id("tb_userdata", "email", req['email']) except Exception as e: dt_db = None if not dt_db: data_save = { "sso_id": req['id'], "first_name": req['given_name'], "last_name": req['family_name'], "email": req['email'], "location": "", "picture": req['picture'] } try: model.insert("tb_userdata", data_save) except Exception as e: print(e) dill_object = dill.dumps(data_save) redis_store.set(token, dill_object) redis_store.expire(token, 3600) else: dill_object = dill.dumps(dt_db[0]) redis_store.set(token, dill_object) redis_store.expire(token, 3600) data_result = { "Access-Token": token, "email": req['email'], "expires": 3600 } return response(200, data=data_result)
def post(self): parser = reqparse.RequestParser() parser.add_argument("ttl", type=str, required=True) args = parser.parse_args() ttl = args["ttl"] data = {"ttl": ttl} if not ttl: return response(422) try: inserted_id = model.insert(table="ttl", data=data) data_ = {"id": inserted_id, **data} return response(201, data=data_) except Exception as e: return response(500, message=f"{e}")
def post(self): parser = reqparse.RequestParser() parser.add_argument("type", type=str, required=True) args = parser.parse_args() type_ = args["type"] data = {"type": type_} if not type_: return response(422) try: inserted_id = model.insert(table="type", data=data) data_ = {"id": inserted_id, **data} return response(201, data=data_) except Exception: return response(500)
def post(self): parser = reqparse.RequestParser() parser.add_argument("email", type=str, required=True) args = parser.parse_args() email = args["email"] if not model.is_unique(table="user", field="email", value=f"{email}"): return response(409, message="Duplicate Email") try: validator.validate("EMAIL", email) except Exception as e: return response(422, message=f"{e}") try: data = {"email": email, "created_at": helpers.get_datetime()} inserted_id = model.insert(table="user", data=data) data_ = {"id": inserted_id, **data} return response(201, data=data_) except Exception as e: current_app.logger.error(f"{e}") return response(500)
def addNSDefault(zone): zone_data = db.get_by_id("zn_zone", "nm_zone", zone) type_data = db.get_by_id("zn_type", "nm_type", "NS") record_ns = { "nm_record": "@", "date_record": str(date), "id_zone": str(zone_data[0]['id_zone']), "id_type": str(type_data[0]['id_type']) } try: db.insert("zn_record", record_ns) except Exception as e: print(e) record_ns_data = db.get_by_id("zn_record", "id_zone", zone_data[0]['id_zone']) for i in record_ns_data: if str(i['id_type']) == "402393625286410241": record_ns_data = i ttldata_ns = { "id_record": str(record_ns_data['id_record']), "id_ttl": "402140815780249601" } try: db.insert("zn_ttldata", ttldata_ns) except Exception as e: print(e) ttl_ns_data = db.get_by_id("zn_ttldata", "id_record", str(record_ns_data['id_record'])) content = repodefault()['default']['ns'] for i in content: content_ns = { "id_ttldata": str(ttl_ns_data[0]['id_ttldata']), "nm_content": i } try: db.insert("zn_content", content_ns) except Exception as e: print(e) return str(zone_data[0]['id_zone'])
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 = dict() 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_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) respons = {"status": True, "messages": "Fine!"} finally: return response(200, data=obj_userdata, message=respons) if init_data['action'] == 'view': obj_userdata = list() table = "" fields = None 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 column = model.get_columns("v_product_hosting") try: result = list() if fields is None: query = """select * from v_product_hosting""" db.execute(query) rows = db.fetchall() for row in rows: result.append(dict(zip(column, row))) else: query = """ select * from v_product_hosting where """ + fields + """='""" + tags[ fields] + """'""" db.execute(query) rows = db.fetchall() for row in rows: result.append(dict(zip(column, row))) except Exception as e: respons = {"status": False, "messages": str(e)} else: for i in result: data = { "id_company": str(i["id_company"]), "id_product": str(i["id_product"]), "id_hosting": str(i['id_hosting']), "id_company_product": str(i['id_company_product']), "id_additional_features": str(i["id_additional_features"]), "nm_company": i['nm_company'], "url_company": i['url_company'], "nm_product": i['nm_product'], "nm_company_product": i['nm_company_product'], "spec_storage": i['spec_storage'], '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'], "spec_features": i['spec_features'], "spec_features_value": i['spec_features_value'], "spec_features_price": i['spec_features_price'] } obj_userdata.append(data) respons = {"status": True, "messages": "Fine!"} finally: return response(200, data=obj_userdata, message=respons)
def post(self): """Add new record. note: Adding any record with other record is allowed. IETF best practice is not handled automatically. Knot didn't handle this too, and let the user know the standards themselves. See https://tools.ietf.org/html/rfc1912 """ parser = reqparse.RequestParser() parser.add_argument("zone", type=str, required=True) parser.add_argument("owner", type=str, required=True) parser.add_argument("rtype", type=str, required=True) parser.add_argument("rdata", type=str, required=True) parser.add_argument("ttl", type=str, required=True) args = parser.parse_args() owner = args["owner"].lower() rtype = args["rtype"].lower() rdata = args["rdata"] zone = args["zone"] ttl = args["ttl"] try: ttl_id = ttl_model.get_ttlid_by_ttl(ttl) type_id = type_model.get_typeid_by_rtype(rtype) zone_id = zone_model.get_zone_id(zone) except Exception as e: return response(404, message=f"{e}") try: rules.check_add(rtype, zone_id, type_id, owner, rdata, ttl_id) except Exception as e: return response(409, message=f"{e}") try: # rtype no need to be validated & no need to check its length # `get_typeid` will raise error for non existing rtype validator.validate(rtype, rdata) validator.validate("owner", owner) except Exception as e: return response(422, message=f"{e}") try: serial_resource = get_serial_resource(zone) check_serial_limit(serial_resource) except Exception as e: return response(429, message=f"{e}") try: data = { "owner": owner, "zone_id": zone_id, "type_id": type_id, "ttl_id": ttl_id, } record_id = model.insert(table="record", data=data) content_data = {"rdata": rdata, "record_id": record_id} model.insert(table="rdata", data=content_data) command.set_zone(record_id, "zone-set") # increment serial after adding new record rtype = type_model.get_type_by_recordid(record_id) if rtype != "SOA": update_serial(serial_resource) record = model.get_one(table="record", field="id", value=record_id) data = record_model.get_other_data(record) return response(201, data=data) except Exception as e: current_app.logger.error(f"{e}") return response(500)
def post(self): parser = reqparse.RequestParser() parser.add_argument('client_id', type=str, required=True) parser.add_argument('is_recurring', type=str, required=True) parser.add_argument('tax_rate1', type=str, required=True) parser.add_argument('tax_name1', type=str, required=True) parser.add_argument('is_amount_discount', type=str, required=False) parser.add_argument('service_type', type=str, required=True) parser.add_argument('product_id', type=str, required=True) args = parser.parse_args() try: get_products = utils.get_ninja("products/"+str(args['product_id']))['data'] except Exception as e: print(e) tax_value = percentage(get_products['cost'], get_products['tax_rate1']) data_insert = { "client_id": args['client_id'], "is_recurring": args['is_recurring'], "tax_rate1": str(args['tax_rate1']), "tax_name1": str(args['tax_name1']), "is_amount_discount": str(args['is_amount_discount']), "custom_value1": args['service_type'] } try: invoice_data_temps = utils.post_ninja("invoices", data_insert)['data'] except Exception as e: print(e) get_invoice_id = db.get_by_id("invoices","public_id", invoice_data_temps['id'])[0] data_insert_items = { "account_id": "1", "user_id": "1", "invoice_id": str(get_invoice_id['id']), "product_id": str(args['product_id']), "product_key": get_products['product_key'], "notes": get_products['notes'], "custom_value1": args['service_type'], "tax_rate1": "0", "tax_name1": "", "tax_rate2":"0", "tax_name2": "", "discount": "0", "cost": str(get_products['cost']), "public_id": str(invoice_data_temps['id']), "qty":"1" } try: db.insert("invoice_items", data_insert_items) except Exception as e: print(e) else: invoice_updates = { "where":{ "public_id": str(invoice_data_temps['id']) }, "data":{ "invoice_status_id": "2", "amount": str(get_products['cost']+tax_value), "balance": str(get_products['cost']+tax_value) } } try: db.update("invoices", data=invoice_updates) except Exception as e: print("DISINI",e) email_data = { "invoice_number":invoice_data_temps['invoice_number'] } try: send_email = utils.post_ninja("email_invoice", email_data) except Exception as e: print(e) try: get_invoice = utils.get_ninja("invoices/"+str(invoice_data_temps['id'])) except Exception as e: return response(200, message=str(e)) else: return response(200, data=get_invoice)
def insert_cname_rdata(zone, record_id): data = {"rdata": f"{zone}.", "record_id": record_id} model.insert(table="rdata", data=data)
def insert_zone(zone, user_id): data = {"zone": zone, "user_id": user_id} zone_id = model.insert(table="zone", data=data) return zone_id
def post(self): parser = reqparse.RequestParser() parser.add_argument('app_name', type=str, required=True) parser.add_argument('app_port', type=str, required=True) parser.add_argument('username', type=str, required=True) parser.add_argument('bless_file', type=werkzeug.datastructures.FileStorage, location='files') args = parser.parse_args() bless_file = args['bless_file'] username = args['username'] app_port = args['app_port'] app_name = args['app_name'] c_user = get_jwt_identity() project_id = None id_userdata = db.get_by_id("tb_user", "username", c_user) id_userdata = id_userdata[0]['id_userdata'] obj_insert = { "id_userdata": str(id_userdata), "nm_project_app": app_name, "nm_project_port": app_port } try: project_id = db.insert(table="tb_project_app", data=obj_insert) except Exception as e: return response(401, message=str(e)) if project_id: upload_folder = APP_ROOT + BLESS_FOLDER + "/" + project_id + "/" if not os.path.exists(upload_folder): os.makedirs(upload_folder) bless_file.save(upload_folder + "bless.yml") else: bless_file.save(upload_folder + "bless.yml") url_ops = os.getenv("OPENSTACK_URL") + ":" + os.getenv( "OPENSTACK_PORT") url_create = url_ops + "/api/create" headers = {"Access-Token": os.getenv("TOKEN_OPENSTACK")} send_to_openstack = { "instances": { app_name: { "parameters": { "project_id": project_id, "app_name": app_name, "app_port": app_port, "private_network": "vm-net", "key_name": "vm-key", "username": username }, "template": "bless" } } } res_fix = dict() data_create = list() data_respon = list() data_pemkey = "" try: data_create = utils.send_http(url_create, data=send_to_openstack, headers=headers) url_vm = url_ops + "/api/list/vm" url_pemkey = url_ops + "/api/list/pemkey/" + app_name c_limit = True while c_limit: data_vm = utils.get_http(url_vm, headers=headers) for i in data_vm['data']: if i['name'] == app_name: res_fix = i c_limit = False data_pemkey = utils.get_http(url_pemkey, headers=headers) except Exception as e: return response(401, message=str(e)) else: data_respon.append({ "create": data_create['data'], "vm": res_fix, "pemkey": data_pemkey }) return response(200, data=data_respon)
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'] == 'view': obj_userdata = list() table = "" fields = None 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 column = model.get_columns("v_product_vm") try: result = list() if fields is None: query = """select * from v_product_vm""" db.execute(query) rows = db.fetchall() for row in rows: result.append(dict(zip(column, row))) else: query = """ select * from v_product_vm_test where """ + fields + """='""" + tags[ fields] + """'""" db.execute(query) rows = db.fetchall() for row in rows: result.append(dict(zip(column, row))) except Exception as e: respons = {"status": False, "messages": str(e)} else: for i in result: data = { "id_company": str(i['id_company']), "id_company_product": str(i['id_company_product']), "id_product": str(i['id_product']), 'id_vm': str(i['id_vm']), "id_additional_features": str(i['id_additional_features']), "nm_company": i['nm_company'], "url_company": i['url_company'], 'nm_company_product': i['nm_company_product'], "nm_product": i['nm_product'], "currency_used": i['currency_used'], '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_features': i['spec_features'], "spec_features_value": i['spec_features_value'], "spec_features_price": i['spec_features_price'], 'spec_price': i['spec_price'], "date_time": i['date_time'] } obj_userdata.append(data) respons = {"status": True, "messages": "Fine!"} finally: return response(200, data=obj_userdata, 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_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) respons = {"status": True, "messages": "Fine!"} finally: return response(200, data=obj_userdata, message=respons)
def insert_ns_rdata(name, record_id): data = {"rdata": name, "record_id": record_id} model.insert(table="rdata", data=data)
def post(self): json_req = request.get_json(force=True) command = utils.get_command(request.path) command = "zn_" + command init_data = cmd.parser(json_req, command) respons = dict() 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": "Fine!", "id": result} finally: return response(200, data=fields, 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_content": str(i['id_content']), "id_ttldata": str(i['id_ttldata']), "nm_content": str(i['nm_content']) } obj_userdata.append(data) respons = {"status": True, "messages": "Fine!"} finally: return response(200, data=obj_userdata, message=respons) if init_data['action'] == 'remove': table = "" tags = dict() fields = "" 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.delete(table, fields, tags[fields]) except Exception as e: respons = {"status": False, "messages": str(e)} else: respons = {"status": result, "messages": "Fine Deleted!"} finally: return response(200, data=tags, message=respons) if init_data['action'] == 'view': obj_userdata = list() table = "" fields = None 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 column = model.get_columns("v_contentdata") try: result = list() if fields is None: query = """select * from v_contentdata""" db.execute(query) rows = db.fetchall() for row in rows: result.append(dict(zip(column, row))) else: query = """ select * from v_contentdata where """ + fields + """='""" + tags[ fields] + """'""" db.execute(query) rows = db.fetchall() for row in rows: result.append(dict(zip(column, row))) except Exception as e: respons = {"status": False, "messages": str(e)} else: for i in result: data = { "id_content": str(i['id_content']), "nm_zone": str(i['nm_zone']), "nm_record": str(i['nm_record']), "nm_type": str(i['nm_type']), "nm_ttl": i['nm_ttl'], "id_record": str(i['id_record']), "nm_content": str(i['nm_content']), } obj_userdata.append(data) respons = {"status": True, "messages": "Fine!"} finally: return response(200, data=obj_userdata, message=respons)