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