def sigin():
username = request.form['username']
password = request.form['password']
user = db.get_by_id(table="tb_user", field="username", value=username)
if not user or not pbkdf2_sha256.verify(password, user[0]['password']):
return response(status_code=401, data="You Not Authorized")
else:
random_string = uuid.uuid4()
raw_token = '{}{}'.format(random_string, username)
access_token = hashlib.sha256(raw_token.encode('utf-8')).hexdigest()
userdata = db.get_by_id(table="tb_userdata",
field="id_userdata",
value=user[0]['id_userdata'])
stored_data = {
'id_userdata': user[0]['id_userdata'],
'email': userdata[0]['email'],
'username': username
}
dill_object = dill.dumps(stored_data)
redis_store.set(access_token, dill_object)
redis_store.expire(access_token, 3600)
data = {
'email': userdata[0]['email'],
'Access-Token': access_token,
'expires': 3600
}
return response(200, data=data)
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 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):
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 get(self):
parser = reqparse.RequestParser()
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'])
obj_userdata = []
results = db.get_by_id(
table="zn_user_zone",
field="userdata_id",
value = userdata_id
)
for i in results :
data = {
"id_user_zone" : str(i['id_user_zone']),
"userdata_id" : str(i['userdata_id']),
"id_zone" : str(i['id_zone'])
}
obj_userdata.append(data)
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']
user = db.get_by_id(
table= "tb_user",
field="username",
value=username
)
expires = datetime.timedelta(hours=1)
if username != user[0]['username'] and pbkdf2_sha256.verify(password, user[0]['password']):
return response(401, data="Kampret")
else:
access_token = create_access_token(
identity=user[0],
expires_delta=expires
)
data = {
'username': user[0]['username'],
'token': "Bearer "+access_token,
'expires': str(expires)
}
return response(200, data=data)
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 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 post(self):
parser = reqparse.RequestParser()
parser.add_argument('name', type=str, required=True)
parser.add_argument('vat', type=str, required=True)
parser.add_argument('id_number', type=str, required=True)
parser.add_argument('address1', type=str, required=False)
parser.add_argument('address2', type=str, required=False)
parser.add_argument('city', type=str, required=False)
parser.add_argument('state', type=str, required=False)
parser.add_argument('postal_code', type=str, required=False)
parser.add_argument('country_id', type=str, required=False)
parser.add_argument('work_phone', type=str, required=True)
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)
args = parser.parse_args()
client_data = {
"name": args['name'],
"vat_number": args['vat'],
"id_number": args['id_number'],
"address1": args['address1'],
"address2": args['address2'],
"city": args['city'],
"state": args['state'],
"postal_code": args['postal_code'],
"country_id": args['country_id'],
"work_phone": args['work_phone']
}
client_data_temps = utils.post_ninja("clients", client_data)
contact_data = client_data_temps['data']['contacts']
contact_db = db.get_by_id("contacts", "public_id",
contact_data[0]['id'])[0]
contact_data_update = {
"where": {
"id": str(contact_db['id'])
},
"data": {
"email": args['email'],
"first_name": args['first_name'],
"last_name": args['last_name'],
"phone": args['work_phone']
}
}
try:
a = db.update("contacts", contact_data_update)
except Exception as e:
return response(401, message=str(e))
else:
id = str(client_data_temps['data']['id'])
client_data = utils.get_ninja(api="clients/" + id)['data']
return response(200, data=client_data)
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 zone_commit_http(url, tags):
fields = tags['id_record']
domain_data = model.get_by_id("v_record", "id_record", fields)
json_command={
"zone-commit": {
"sendblock": {
"cmd": "zone-commit",
"zone": domain_data[0]['nm_zone']
},
"receive": {
"type": "block"
}
}
}
res = utils.send_http(url, json_command)
return res
def get(self, userdata_id):
obj_userdata = []
results = db.get_by_id(
table="userdata",
field="userdata_id",
value=userdata_id
)
for i in results :
data = {
"userdata_id": str(i['userdata_id']),
"user_id" : i['user_id'],
"project_id" : i['project_id'],
"created_at": str(i['created_at'])
}
obj_userdata.append(data)
return response(200, data=obj_userdata)
def get(self, id_userdata):
obj_userdata = []
results = db.get_by_id(table="tb_userdata",
field="id_userdata",
value=id_userdata)
for i in results:
data = {
"id_userdata": str(i['id_userdata']),
"email": i['email'],
"first_name": i['first_name'],
"last_name": i['last_name'],
"location": i['location'],
"created_at": str(i['created_at'])
}
obj_userdata.append(data)
return response(200, data=obj_userdata)
def z_begin(url,tags):
domain_name = None
fields = tags['id_zone']
domain_data = model.get_by_id("zn_zone", "id_zone", fields)
for i in domain_data:
domain_name = i['nm_zone']
json_command={
"zone-begin": {
"sendblock": {
"cmd": "zone-begin",
"zone": domain_name
},
"receive": {
"type": "block"
}
}
}
return utils.send_http(url,json_command)
def zone_begin(tags):
domain_name = None
fields = str(list(tags.keys())[0])
domain_data = model.get_by_id("zn_zone", fields, tags[fields])
for i in domain_data:
domain_name = i['nm_zone']
json_command={
"zone-begin": {
"sendblock": {
"cmd": "zone-begin",
"zone": domain_name
},
"receive": {
"type": "block"
}
}
}
return json_command
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 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 config_insert(tags):
fields = str(list(tags.keys())[0])
domain_data = model.get_by_id("zn_zone", fields, tags[fields])
domain_name = ""
domain_id = ""
for i in domain_data:
domain_name = i['nm_zone']
domain_id = i['id_zone']
json_command = {
"conf-set": {
"sendblock": {
"cmd": "conf-set",
"section": "zone",
"item": "domain",
"data": domain_name
},
"receive": {
"type": "block"
}
}
}
return json_command
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 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)
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):
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 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)
