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 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 put(self, id_userdata):
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 = {
"where": {
"id_userdata": id_userdata
},
"data": {
"email": args['email'],
"first_name": args['first_name'],
"last_name": args['last_name'],
"location": args['location'],
}
}
try:
db.update("tb_userdata", data=data)
except Exception as e:
message = {"status": False, "error": str(e)}
else:
message = {"status": True, "data": data}
finally:
return response(200, message=message)
def update():
id_userdata = get_jwt_identity()
data = {
"where":{
"userdata_id": id_userdata
},
"data":{
"email" : request.form['email'],
"first_name" : request.form['first_name'],
"last_name" : request.form['last_name'],
"location" : request.form['location']
}
}
try:
db.update("tb_userdata", data=data)
except Exception as e:
message = {
"status": False,
"error": str(e)
}
else:
message = {
"status": True,
"data": data
}
finally:
return response(200, message=message)
def put(self, userdata_id):
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 = {
"where":{
"userdata_id": userdata_id
},
"data":{
"project_id" : args['project_id'],
"user_id" : args['user_id'],
}
}
try:
db.update("userdata", data=data)
except Exception as e:
message = {
"status": False,
"error": str(e)
}
else:
message = {
"status": True,
"data": data
}
finally:
return response(200, message=message)
def sync_cname_default(id_zone, id_record):
tags = {"id_record": id_record}
cmd.zone_begin_http(url, tags)
json_command = cmd.zone_insert(tags)
check_res = send_http(url, json_command)
if check_res:
# state change
state = change_state("id_record", id_record, "1")
db.update("zn_record", data=state)
cmd.zone_commit_http(url, tags)
def sync_ns(id_zone):
tags = {"id_zone": id_zone}
cmd.z_begin(url, tags)
result_ns = cmd.zone_ns_insert(tags)
for i in result_ns:
check_res = send_http(url, i['command'])
if check_res:
state = change_state("id_record", i['id_record'], "1")
db.update("zn_record", data=state)
cmd.z_commit(url, tags)
def sync_soa(id_zone):
tags = {"id_zone": id_zone}
cmd.z_begin(url, tags)
id_record, respons = cmd.zone_soa_insert_default(tags)
check_res = send_http(url, respons)
if check_res:
# state change
state = change_state("id_record", id_record, "1")
db.update("zn_record", data=state)
cmd.z_commit(url, tags)
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 update_serial(serial_resource, increment="01"):
serial = serial_resource["serial"]
soa_record = serial_resource["soa_record"]
rdata_record = serial_resource["rdata_record"]
new_serial = helpers.increment_serial(serial, increment)
new_rdata = helpers.replace_serial(rdata_record["rdata"], new_serial)
content_data = {
"where": {"record_id": soa_record["id"]},
"data": {"rdata": new_rdata, "record_id": soa_record["id"]},
}
model.update("rdata", data=content_data)
def put(self, user_id):
parser = reqparse.RequestParser()
parser.add_argument("email", type=str, required=True)
args = parser.parse_args()
email = args["email"]
args = parser.parse_args()
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 = {"where": {"id": user_id}, "data": {"email": email}}
row_count = model.update("user", data=data)
if not row_count:
return response(404)
return response(200, data=data.get("data"))
except Exception as e:
current_app.logger.error(f"{e}")
return response(500)
def sync_conf_insert(id_zone):
tags = {"id_zone": id_zone}
respons_c_insert = cmd.config_insert(tags)
cmd.conf_begin_http(url)
check_res = send_http(url, respons_c_insert)
if check_res:
# state change
state = change_state("id_zone", id_zone, "1")
check = db.update("zn_zone", data=state)
print(check)
cmd.conf_commit_http(url)
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 put(self, key):
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"]
if utils.check_unique("user", "email", email, key=key):
return response(401, message="Duplicate email Detected")
data_update = {
"key": key,
"email": email,
"project_id": project_id,
"state": "edited",
"created_at": utils.get_datetime()
}
try:
model.update("user", key, data_update)
except Exception as e:
return response(401, message=str(e))
else:
return response(200, data=data_update, message="Update Success")
def put(self, key):
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"]
if utils.check_unique("zone", "value", zone, key=key):
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.update("zone", key, data)
except Exception as e:
return response(401, message=str(e))
else:
return response(200, data=data, message="Edited")
def put(self, ttl_id):
parser = reqparse.RequestParser()
parser.add_argument("ttl", type=str, required=True)
args = parser.parse_args()
ttl = args["ttl"]
if not ttl:
return response(422)
try:
data = {"where": {"id": ttl_id}, "data": {"ttl": ttl}}
row_count = model.update("ttl", data=data)
if not row_count:
return response(404)
return response(200, data=data.get("data"))
except Exception as e:
return response(500, message=f"{e}")
def put(self, type_id):
parser = reqparse.RequestParser()
parser.add_argument("type", type=str, required=True)
args = parser.parse_args()
type_ = args["type"]
if not type_:
return response(422)
try:
data = {"where": {"id": type_id}, "data": {"type": type_}}
row_count = model.update("type", data=data)
if not row_count:
return response(404)
return response(200, data=data.get("data"))
except Exception:
return response(500)
def post(self):
url_env = os.getenv("SOCKET_AGENT_HOST")
port = os.getenv("SOCKET_AGENT_PORT")
url_fix = url_env + ":" + port
url = url_fix + "/api/command_rest"
json_req = request.get_json(force=True)
command = utils.get_command(request.path)
init_data = parse.parser(json_req, command)
respons = dict()
if init_data['action'] == 'conf-read':
respons = cmd.conf_read()
http_respons = utils.send_http(url, data=respons)
return response(200, data=http_respons)
if init_data['action'] == 'conf-insert':
tags = dict()
for i in init_data['data']:
tags = i['tags']
respons = cmd.config_insert(tags)
cmd.conf_begin_http(url)
http_respons = utils.send_http(url, respons)
if http_respons:
# state change
state = utils.change_state("id_zone", tags['id_zone'], "1")
db.update("zn_zone", data=state)
cmd.conf_commit_http(url)
return response(200, data=http_respons)
if init_data['action'] == 'zone-read':
tags = dict()
for i in init_data['data']:
tags = i['tags']
respons = cmd.zone_read(tags)
http_respons = utils.send_http(url, respons)
return response(200, data=http_respons)
if init_data['action'] == 'zone-soa-insert':
result = list()
for i in init_data['data']:
tags = i['tags']
begin_json = cmd.zone_begin(tags)
begin_respon = utils.send_http(url, begin_json)
result.append(begin_respon)
try:
id_record, respons = cmd.zone_soa_insert_default(tags)
except Exception as e:
respons = {"Status": False, "Error": str(e)}
return response(400, message=respons)
else:
http_respons = utils.send_http(url, respons)
# state change
if http_respons:
state = utils.change_state("id_record", id_record, "1")
db.update("zn_record", data=state)
result.append(http_respons)
commit_json = cmd.zone_commit(tags)
commit_response = utils.send_http(url, commit_json)
result.append(commit_response)
return response(200, data=result)
if init_data['action'] == 'zone-begin':
for i in init_data['data']:
tags = i['tags']
respons = cmd.zone_begin(tags)
http_response = utils.send_http(url, respons)
return response(200, data=http_response)
if init_data['action'] == 'zone-commit':
for i in init_data['data']:
tags = i['tags']
respons = cmd.zone_commit(tags)
http_response = utils.send_http(url, respons)
return response(200, data=http_response)
if init_data['action'] == 'zone-insert':
respons = list()
for i in init_data['data']:
tags = i['tags']
json_begin = cmd.zone_begin_http(url, tags)
respons.append(json_begin)
json_command = cmd.zone_insert(tags)
http_response = utils.send_http(url, json_command)
# change state
if http_response:
state = utils.change_state("id_record", tags['id_record'], "1")
try:
db.update("zn_record", data=state)
except Exception as e:
print(e)
respons.append(http_response)
res_commit = cmd.zone_commit_http(url, tags)
respons.append(res_commit)
return response(200, data=respons)
if init_data['action'] == 'zone-ns-insert':
respons = list()
for i in init_data['data']:
tags = i['tags']
res_begin = cmd.z_begin(url, tags)
respons.append(res_begin)
try:
result = cmd.zone_ns_insert(tags)
except Exception as e:
respons = {"Status": False, "Error": str(e)}
return response(400, message=respons)
else:
for i in result:
state = None
http_response = utils.send_http(url, i['command'])
# state change
if http_response:
state = utils.change_state("id_record", i['id_record'],
"1")
try:
db.update("zn_record", data=state)
except Exception as e:
print(e)
respons.append(http_response)
res_commit = cmd.z_commit(url, tags)
respons.append(res_commit)
return response(200, data=respons)
if init_data['action'] == 'zone-srv-insert':
result = list()
for i in init_data['data']:
tags = i['tags']
begin_json = cmd.zone_begin_http(url, tags)
# begin_respon = utils.send_http(url,begin_json)
result.append(begin_json)
try:
respons = cmd.zone_insert_srv(tags)
except Exception as e:
respons = {"status": False, "error": str(e)}
return response(400, data=result, message=respons)
else:
http_response = utils.send_http(url, respons)
if http_response:
state = utils.change_state("id_record", tags['id_record'],
"1")
try:
db.update("zn_record", data=state)
except Exception as e:
print(e)
result.append(http_response)
commit_json = cmd.zone_commit_http(url, tags)
# commit_response = utils.send_http(url,commit_json)
result.append(commit_json)
return response(200, data=result)
if init_data['action'] == 'zone-mx-insert':
result = list()
for i in init_data['data']:
tags = i['tags']
begin_json = cmd.zone_begin_http(url, tags)
# begin_respon = utils.send_http(url,begin_json)
result.append(begin_json)
try:
respons = cmd.zone_insert_mx(tags)
except Exception as e:
respons = {"status": False, "error": str(e)}
return response(400, data=result, message=respons)
else:
http_response = utils.send_http(url, respons)
# change state
if http_respons:
state = utils.change_state("id_record", tags['id_record'],
"1")
try:
db.update("zn_record", data=state)
except Exception as e:
print(e)
result.append(http_response)
commit_json = cmd.zone_commit_http(url, tags)
result.append(commit_json)
return response(200, data=result)
# delete all zone
if init_data['action'] == 'conf-unset':
result = list()
for i in init_data['data']:
tags = i['tags']
data = cmd.conf_unset(tags)
cmd.conf_begin_http(url)
http_respons = utils.send_http(url, data)
cmd.conf_commit_http(url)
return response(200, data=http_respons)
if init_data['action'] == 'zone-unset':
result = list()
for i in init_data['data']:
print(i)
tags = i['tags']
respons = list()
res_begin = cmd.zone_begin_http(url, tags)
respons.append(res_begin)
json_command = cmd.zone_unset(tags)
http_response = utils.send_http(url, json_command)
respons.append(http_response)
res_commit = cmd.zone_commit_http(url, tags)
respons.append(res_commit)
return response(200, data=respons)
def put(self, record_id):
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)
record_model.is_exists(record_id)
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_edit(rtype, zone_id, type_id, owner, rdata, ttl_id, record_id)
except Exception as e:
return response(409, message=f"{e}")
try:
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 = {
"where": {"id": record_id},
"data": {
"owner": owner,
"zone_id": zone_id,
"type_id": type_id,
"ttl_id": ttl_id,
},
}
content_data = {
"where": {"record_id": record_id},
"data": {"rdata": rdata, "record_id": record_id},
}
command.set_zone(record_id, "zone-unset")
model.update("rdata", data=content_data)
model.update("record", data=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, "02")
record = model.get_one(table="record", field="id", value=record_id)
data_ = record_model.get_other_data(record)
return response(200, 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)
