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)
