def putinput(optionname): iop={ "serviceid": "", "task":"" } serviceid=request.json["serviceid"] task=request.json["task"] step=getoption(serviceid,optionname) stepjson=step["body"] try: for stepid in stepjson["steporder"]: for steptask in stepjson[stepid]["tasks"]: if steptask["taskname"]==task["taskname"]: inputjson=task["input_options"] steptask["input_options"]=inputjson taskinputpath="deploy/"+serviceid+"/"+optionname+"/"+stepid+"/task"+str(task["taskno"])+"/"+stepid.lower()+"/inputoption.json" status,statusmessage,taskwrite=datafile.write_s3_file(taskinputpath,inputjson) if status == "error": message={"statusCode":400,"errorMessage":statusmessage} return(message) task["formfill"]=False steptask["formfill"]=False optionpath="deploy/"+serviceid+"/"+optionname+"/"+optionname+".json" status,statusmessage,stepput=datafile.write_s3_file(optionpath,stepjson) if status == "error": message={"statusCode":400,"errorMessage":statusmessage} return(message) message={"statusCode":200,"body":task} return(message) except Exception as e: message={"statusCode":400,"errorMessage":str(e)} return(message)
def createdeploy(productid,serviceid): try: templatepath="/home/app/web/archeplay/template" servicepath= "services/"+productid+"/services.json" status,statusmessage,services=datafile.load_s3_file(servicepath) if status == "error": message={"statusCode":400,"errorMessage":statusmessage,"Error":services} return(message) for svc in services: if svc["serviceid"] == serviceid: servicetype=svc["servicetype"] svc["status"]="published" writestatus,writestatusmessage,srvswrite=datafile.write_s3_file(servicepath,services) if writestatus == "error": message={"statusCode":400,"errorMessage":writestatusmessage,"Error":srvswrite} return(message) svctemplatepath=templatepath+"/servicetemplates/"+servicetype+".json" with open(svctemplatepath,"r") as f: stepdata=f.read() stepjson=json.loads(stepdata) optionname=stepjson["optionname"] optionjson=getfiles(stepjson,serviceid,templatepath) optionpath="deploy/"+serviceid+"/"+optionname+"/"+optionname+".json" status,statusmessage,optionput=datafile.write_s3_file(optionpath,optionjson) if status == "success": message={"statusCode":200,"body":optionjson} else: message={"statusCode":400,"errorMessage":optionput} return(message) except Exception as e: message={"statusCode":400,"errorMessage":str(e)} return(message)
def createtable(serviceid, dbid): iop = {"tablename": ""} tablename = request.json["tablename"] json_dict = request.get_json() dbpath = "servicedesigns/" + serviceid + "/data/" + dbid + "/config.json" status, statusmessage, database = datafile.load_s3_file(dbpath) if status == "success": if database["tables"] == []: tableid = uniqid("tb") elif database["tables"] != []: a = True while a is True: tableid = uniqid('tb') if tableid in database["tables"]: a = True else: a = False database["tables"].append(tableid) status, statusmessage, response = datafile.write_s3_file( dbpath, database) tablejson = { "tableid": tableid, "tablename": tablename, "dbtype": database["DBType"], "schema": [], "indexes": {} } if "description" in json_dict: tablejson["description"] = request.json["description"] tablepath = "servicedesigns/" + serviceid + "/data/" + dbid + "/tables/" + tableid + "/config.json" status, statusmessage, table = datafile.write_s3_file( tablepath, tablejson) if status == "success": message = { "statusCode": 200, "message": "Table Created", "body": tablejson } else: message = { "statusCode": 400, "errorMessage": statusmessage, "Error": table } else: message = { "statusCode": 400, "errorMessage": statusmessage, "Error": database } return (message)
def createdb(serviceid, versionid, resourceid): json_dict = request.get_json() resourcepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/config.json" status, statusmessage, resource = datafile.load_s3_file(resourcepath) if status == "success": for data in resource["data"]: if data["db"] == []: dbid = uniqid("db") db = {"Ref": dbid} data["db"].append(db) elif data["db"] != []: dbids = [] for db in data["db"]: dbids.append(db["Ref"]) a = True while a is True: dbid = uniqid('db') if dbid in dbids: a = True else: a = False db = {"Ref": dbid} data["db"].append(db) resstatus, resstatusmessage, res = datafile.write_s3_file( resourcepath, resource) dbjson = { "dbid": dbid, "CreateType": "IMPORT|NEW", "import": { "Ref": dbid }, "DBType": "DYNAMODB", "type": "dynamodb", "deploy": { "type": "mock" }, "tables": [] } if "description" in json_dict: dbjson["description"] = request.json["description"] datapath = "servicedesigns/" + serviceid + "/data/" + dbid + "/config.json" status, statusmessage, response = datafile.write_s3_file( datapath, dbjson) if status == "success": message = {"statusCode": 200, "body": dbjson} else: message = {"statusCode": 400, "errorMessage": statusmessage} else: message = {"errorMessage": statusmessage, "Error": resource} return (message)
def addtestcases(productid, serviceid, apiid, versionid, resourceid): testcasename = request.json["testcasename"] testcaseid = uniqid("tc_") methodid = request.json["methodid"] methodpath = request.json["methodpath"] methodtype = request.json["methodtype"] testcasedata = { "body": "", "pathparameters": {}, "queryparameters": "", "headers": "", "testcasename": testcasename, "testcaseid": testcaseid, "methodid": methodid, "methodpath": methodpath, "methodtype": methodtype } testcasepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/testcases/" + methodid + "/" + testcaseid + ".json" testcasestatus, testcasestatusmessage, testres = datafile.write_s3_file( testcasepath, testcasedata) if testcasestatus == "success": message = {"statusCode": 200, "body": testcasedata} else: message = {"statusCode": 400, "errorMessage": testres} return (message)
def deleteresource(productid, serviceid, apiid, versionid, resourceid): apipath = "servicedesigns/" + serviceid + "/api/config.json" status, statusmessage, api = datafile.load_s3_file(apipath) if status == "success": for ver in api['versions']: if ver["versionid"] == versionid: if resourceid in ver["resources"]: resourceprefix = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid delstatus, statusmessage = datafile.delete_folders( resourceprefix) ver["resources"].remove(resourceid) status, statusmessage, response = datafile.write_s3_file( apipath, api) if delstatus == "success" and status == "success": message = { "statusCode": 200, "message": "resource deleted" } else: message = { "statusCode": 400, "errorMessage": "resource deletion failed" } else: message = { "statusCode": 400, "errorMessage": "resourceid does not exist" } else: message = {"statusCode": 400, 'errorMessage': api} return (message)
def deletemethod(productid, serviceid, apiid, versionid, resourceid, methodid): resourcepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/config.json" status, statusmessage, resource = datafile.load_s3_file(resourcepath) if status == "success": methodids = [] for method in resource["methods"]: methodids.append(method["Ref"]) if methodid in methodids: for method in resource["methods"]: if method["Ref"] == methodid: resource["methods"].remove(method) resstatus, resstatusmessage, res = datafile.write_s3_file( resourcepath, resource) methodprefix = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid methodpath = methodprefix + ".json" status, statusmessage, delmeth = datafile.delete_s3_file( methodpath) delstatus, delstatusmessage = datafile.delete_folders(methodprefix) if status == "success" and delstatus == "success": message = {"statusCode": 200, "message": "method deleted"} else: message = {"statusCode": 400, "message": delstatusmessage} else: message = {"statusCode": 400, "message": "methodid does not exist"} else: message = {"errorMessage": statusmessage, "Error": resource} return (message)
def deleteversion(productid, serviceid, apiid, versionid): apipath = "servicedesigns/" + serviceid + "/api/config.json" status, statusmessage, api = datafile.load_s3_file(apipath) if status == "success": versionids = [] for version in api["versions"]: versionids.append(version["versionid"]) if versionid in versionids: for version in api["versions"]: if version["versionid"] == versionid: api["versions"].remove(version) status, statusmessage, response = datafile.write_s3_file( apipath, api) versionprefix = "servicedesigns/" + serviceid + "/api/" + versionid delstatus, delstatusmessage = datafile.delete_folders( versionprefix) message = {"statusCode": 200, "message": "Version Deleted"} else: message = { "statusCode": 400, "errorMessage": "versionid does not exist" } else: message = {"errorMessage": statusmessage, "Error": api} return (message)
def updateservicebyid(productid, serviceid): servicepath = "services/" + productid + "/services.json" status, statusmessage, services = datafile.load_s3_file(servicepath) if status == "success": serviceids = [] for svc in services: serviceids.append(svc["serviceid"]) if serviceid in serviceids: service = {} for svc in services: if svc["serviceid"] == serviceid: svc["status"] = "design" service = svc status, statusmessage, writeservice = datafile.write_s3_file( servicepath, services) if status == "error": message = {"statusCode": 400, "errorMessage": statusmessage} return (message) message = {"statusCode": 200, "body": service} else: message = { "statusCode": 400, "errorMessage": "serviceid does not exist" } else: message = {"statusCode": 400, "errorMessage": services} return (message)
def deleteservice(productid, serviceid): servicepath = "services/" + productid + "/services.json" status, statusmessage, services = datafile.load_s3_file(servicepath) if status == "success": serviceids = [] for svc in services: serviceids.append(svc["serviceid"]) if serviceid in serviceids: for svc in services: if svc["serviceid"] == serviceid: services.remove(svc) svcprefix = "servicedesigns/" + serviceid delstatus, delstatusmessage = datafile.delete_folders( svcprefix) status, statusmessage, response = datafile.write_s3_file( servicepath, services) message = {"statusCode": 200, 'message': 'Service Deleted'} else: message = { "statusCode": 400, "errorMessage": "serviceid does not exist" } else: message = {"errorMessage": statusmessage, "Error": services} return (message)
def deletetable(serviceid, dbid, tableid): dbpath = "servicedesigns/" + serviceid + "/data/" + dbid + "/config.json" status, statusmessage, data = datafile.load_s3_file(dbpath) if status == "success": if tableid in data["tables"]: tablepathprefix = "servicedesigns/" + serviceid + "/data/" + dbid + "/tables/" + tableid data["tables"].remove(tableid) status, statusmessage = datafile.delete_folders(tablepathprefix) datastatus, datamessage, datawrite = datafile.write_s3_file( dbpath, data) if status == "success": message = {"statusCode": 200, "message": "Table Deleted"} else: message = { "statusCode": 400, "errorMessage": "Table deletion failed" } else: message = { "statusCode": 400, "errorMessage": "tableid does not exist" } else: message = {"errorMessage": statusmessage, "Error": data} return (message)
def createresource(productid, serviceid, apiid, versionid): iop = {"resourcename": ""} resourcename = request.json["resourcename"] apipath = "servicedesigns/" + serviceid + "/api/config.json" status, statusmessage, api = datafile.load_s3_file(apipath) if status == "success": for ver in api['versions']: if ver['versionid'] == versionid: version = ver a = True while a is True: resourceid = uniqid('res') if resourceid in ver["resources"]: a = True else: a = False resource = { "resourceid": resourceid, "resourcename": resourcename, "methods": [], "data": [{ "db": [] }] } version['resources'].append(resourceid) status, statusmessage, response = datafile.write_s3_file( apipath, api) resourcepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/config.json" status, statusmessage, resources = datafile.write_s3_file( resourcepath, resource) message = { "statusCode": 200, 'message': "Resource Created", 'body': resource } else: message = { "statusCode": 400, 'message': "versionid does not exist" } else: message = { "statusCode": 400, 'message': statusmessage, 'errorMessage': api } return (message)
def updatetable(serviceid, dbid, tableid): json_dict = request.get_json() tablepath = "servicedesigns/" + serviceid + "/data/" + dbid + "/tables/" + tableid + "/config.json" status, statusmessage, table = datafile.load_s3_file(tablepath) if status == "success": if "addschema" in json_dict: for sch in request.json['addschema']: if all(sch['attributename'] != tbh['attributename'] for tbh in table['schema']): table['schema'].append(sch) # table['schema']=table['schema']+request['addschema'] if "deleteschema" in json_dict: for sch in request.json['deleteschema']: for schema in table['schema']: if sch['attributename'] == schema['attributename']: if sch['attributename'] not in str(table['indexes']): table['schema'].remove(schema) if "editschema" in json_dict: for schema in table['schema']: for sch in request.json['editschema']: if sch['attributename'] == schema['attributename']: table['schema'][table['schema'].index(schema)] = sch if "indexes" in json_dict: table['indexes'] = request.json['indexes'] if "updatepath" in json_dict: request.json['updatevalue'] = json.loads( request.json['updatevalue']) path = request.json['updatepath'].split("/") myd = table for i in path[:-1]: myd = myd[i] if "[" in path[-1]: path[-1] = path[-1].replace("]", "") p = path[-1].split("[") if p[0] not in myd: myd[p[0]] = [] if int(p[1]) >= len(myd[p[0]]): myd[p[0]].append(request.json['updatevalue']) else: myd[p[0]][int(p[1])] = request.json['updatevalue'] else: myd[path[-1]] = request.json['updatevalue'] status, statusmessage, response = datafile.write_s3_file( tablepath, table) if status == "success": message = {"statusCode": 200, "body": table} else: message = {"statusCode": 400, "errorMessage": statusmessage} else: message = {"errorMessage": statusmessage, "Error": table} return (message)
def template_pull(): iop = { "connectiontype": "", "templategiturl": "", "templategitpassword": "", "templategitusername": "", "templategitbranch": "" } connectiontype = request.json["connectiontype"] templategiturl = request.json["templategiturl"] templategitpassword = request.json["templategitpassword"] templategitusername = t = request.json["templategitusername"] branch = request.json["templategitbranch"] try: machine = templategiturl.split("/")[2] gitcred = "machine " + machine + " login " + templategitusername + " password " + templategitpassword + "\n" secretpath = os.getenv("NETRC") datawrite = writefile(secretpath, gitcred) destinationpath = "/home/app/.netrc" directory = os.path.dirname(destinationpath) if not os.path.exists(directory): os.makedirs(directory) copyfile(secretpath, destinationpath) folderpath = "/home/app/web/archeplay/template" archetemplatepath = "/home/app/web/archeplay/" + uniqid( "localtemplate") status, statusmessage = template_clone(templategiturl, branch, folderpath, archetemplatepath, templategitusername) if status == "error": message = {"statusCode": 400, "errormessage": statusmessage} return (message) templatecred = { "connectiontype": connectiontype, "templategiturl": templategiturl, "templategitpassword": templategitpassword, "templategitusername": templategitusername, "templategitbranch": branch } templaterepoconfigpath = "templateconfig/config.json" status, statusmessage, templaterepoconf = datafile.write_s3_file( templaterepoconfigpath, templatecred) if status == "error": message = {"statusCode": 400, "errorMessage": "write error"} return (message) message = {"statusCode": 200, "message": "template git cloned"} return (message) except Exception as e: message = {"statusCode": 400, "errorMessage": "final error"} return (message)
def updatemethod(productid, serviceid, apiid, versionid, resourceid, methodid): json_dict = request.get_json() methodpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + ".json" status, statusmessage, method = datafile.load_s3_file(methodpath) req_string = "" if status == "success": snippetid = request.json["snippetid"] if "inputschema" in json_dict: method['inputschema'] = request.json['inputschema'] if "outputschema" in json_dict: method['outputschema'] = request.json['outputschema'] if "requirements" in json_dict: method["snippets"][snippetid]['requirements'] = request.json[ 'requirements'] if "import_code" in json_dict: method["snippets"][snippetid]["import_code"] = request.json[ "import_code"] if "function_code" in json_dict: method["snippets"][snippetid]["function_code"] = request.json[ "function_code"] if "function_call" in json_dict: method["snippets"][snippetid]["function_call"] = request.json[ "function_call"] if "data_code" in json_dict: method["snippets"][snippetid]["data_code"] = request.json[ "data_code"] codestring, requirements = consolidate_code(method) # codestring=method["snippets"][snippetid]["import_code"]+"\n"+method["snippets"][snippetid]["data_code"]+"\n"+method["snippets"][snippetid]["function_code"]+"\n"+method["snippets"][snippetid]["function_call"] + "\n" +method["type_code"] codepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + "/code/" + methodid + ".py" codestatus, codestatusmessage, code = datafile.write_txt_file( codepath, codestring) for requirement in requirements: req_string = req_string + requirement + '\n' requirementpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + "/code/requirement.txt" reqwritestatus, reqwritestatusmessage, req = datafile.write_txt_file( requirementpath, req_string) writestatus, statusmessage, response = datafile.write_s3_file( methodpath, method) if writestatus == "success" and codestatus == "success": message = { "statusCode": 200, 'body': method["snippets"][snippetid] } else: message = {"statusCode": 400, "errorMessage": response} else: message = {"errorMessage": statusmessage, "Error": method} return (message)
def deletesnippet(productid, serviceid, apiid, versionid, resourceid, methodid, snippetid): methodpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + ".json" status, statusmessage, methodjson = datafile.load_s3_file(methodpath) del methodjson["snippets"][snippetid] snippetorder = methodjson["snippets"]["snippetorder"] count = 0 for item in snippetorder: if item["snippetid"] == snippetid: break else: count = count + 1 snippetorder.pop(count) methodjson["snippets"].update({"snippetorder": snippetorder}) methodjson["methodpath"] = methodjson["methodpath"].replace("{", "<") methodjson["methodpath"] = methodjson["methodpath"].replace("}", ">") # if methodjson["methodpath"]!="": # apicallpath="/"+versionname+"/"+resource["resourcename"]+methodjson["methodpath"] # else: # apicallpath="/"+versionname+"/"+resource["resourcename"] # methodpath="servicedesigns/"+serviceid+"/api/"+versionid+"/resources/"+resourceid+"/methods/"+methodid+".json" # methodjson["type_code"]=methodjson["type_code"].replace("METHODID",methodid) # methodjson["type_code"]=methodjson["type_code"].replace("METHODPATH",apicallpath) codestring, requirement = consolidate_code(methodjson) codepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + "/code/" + methodid + ".py" codestatus, codestatusmessage, code = datafile.write_txt_file( codepath, codestring) if codestatus == "error": message = {"statusCode": 400, "errorMessage": code} return (message) reqstring = "" for i in requirement: reqstring = reqstring + i + "\n" # act["requirements"]=reqstring requirementpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + "/code/requirement.txt" requirementstatus, requirementstatusmessage, req = datafile.write_txt_file( requirementpath, reqstring) if requirementstatus == "error": message = {"statusCode": 400, "errorMessage": req} return (message) methstatus, methstatusmessage, methres = datafile.write_s3_file( methodpath, methodjson) if methstatus == "error": message = {"statusCode": 400, "errorMessage": code} return (message) if methstatus == "success" and codestatus == "success" and requirementstatus == "success": message = {"statusCode": 200, "body": methodjson} return (message)
def design_push(): iop = {"commitmessage": "", "tagname": ""} try: coderepoconfigpath = "repoconfig/config.json" status, statusmessage, codecred = datafile.load_s3_file( coderepoconfigpath) if status == "error": message = { "statusCode": 400, "errorMessage": statusmessage, "Error": codecred } return (message) branch = codecred["mybranch"]["Branchname"] foldername = codecred["mybranch"]["Name"] gitrepourl = codecred["gitrepourl"] gitusername = codecred["gitusername"] commitmessage = request.json["commitmessage"] tagname = request.json["tagname"] srcfolder = "/home/app/web/archeplay/data" destfolder = "/home/app/web/archeplay/" + foldername copy_tree(srcfolder, destfolder) output_files = glob.glob(destfolder + "/**/*output.json", recursive=True) for file in output_files: os.remove(file) log_files = glob.glob(destfolder + "/**/*log.json", recursive=True) for file in log_files: os.remove(file) status, statusmessage = git_push(destfolder, gitrepourl, branch, gitusername, destfolder, commitmessage, tagname) if status == "error": message = {"statusCode": 400, "errorMessage": statusmessage} return (message) codecred["mybranch"]["Tags"].append(tagname) writestatus, writestatusmessage, mybranchtag = datafile.write_s3_file( coderepoconfigpath, codecred) if writestatus == "error": message = {"statusCode": 400, "errorMessage": writestatusmessage} return (message) message = {"statusCode": 200, "message": statusmessage} return (message) except Exception as e: message = {"statusCode": 400, "errorMessage": str(e)} return (message)
def createproduct(): iop = {"userid": "", "productname": ""} userid = request.headers["userid"] productname = request.json["productname"] json_dict = request.get_json() productpath = "products/products.json" status, statusmessage, products = datafile.load_s3_file(productpath) if status != "success": products = [] productids = [] for prod in products: productids.append(prod["productid"]) a = True while a is True: productid = uniqid('prod') if productid in productids: a = True else: a = False product = { 'productid': productid, 'userid': userid, 'productname': productname } if "description" in json_dict: product["description"] = request.json["description"] products.append(product) status, statusmessage, response = datafile.write_s3_file( productpath, products) if status == "success": message = { "statusCode": 200, "message": "New Product Created", "body": product } else: message = { "statusCode": 400, "errorMessage": statusmessage, "Error": response } return (message)
def store_cred(): try: coderepoconfigpath = "repoconfig/config.json" connectiontype = request.json["connectiontype"] gitrepourl = request.json["gitrepourl"] gitusername = request.json["gitusername"] gitpassword = request.json["gitpassword"] codecred = { "connectiontype": connectiontype, "gitrepourl": gitrepourl, "gitusername": gitusername, "gitpassword": gitpassword, "mybranch": {}, "sharedbranch": [], "environmentdeploybranch": [] } machine = gitrepourl.split("/")[2] gitcred = "machine " + machine + " login " + gitusername + " password " + gitpassword + "\n" status, statusmessage, coderepoconf = datafile.write_s3_file( coderepoconfigpath, codecred) if status == "error": message = {"statusCode": 400, "errorMessage": coderepoconf} return (message) secretpath = os.getenv("NETRC") datawrite = writefile(secretpath, gitcred) destinationpath = "/home/app/.netrc" directory = os.path.dirname(destinationpath) if not os.path.exists(directory): os.makedirs(directory) copyfile(secretpath, destinationpath) message = { "statusCode": 200, "message": "credentials added", "body": codecred } return (message) except Exception as e: message = {"statusCode": 400, "errorMessage": str(e)} return (message)
def deletedata(serviceid, versionid, resourceid, dbid): resourcepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/config.json" status, statusmessage, resource = datafile.load_s3_file(resourcepath) if status == "success": for data in resource["data"]: if data["db"] != []: dbids = [] for db in data["db"]: dbids.append(db["Ref"]) if dbid in dbids: for db in data["db"]: if db["Ref"] == dbid: data["db"].remove(db) status, statusmessage, response = datafile.write_s3_file( resourcepath, resource) datapath = "servicedesigns/" + serviceid + "/data/" + dbid + "/config.json" delstatus, delstatusmessage, delres = datafile.delete_s3_file( datapath) datapathprefix = "servicedesigns/" + serviceid + "/data/" + dbid delstatus, delstatusmessage = datafile.delete_folders( datapathprefix) message = { "statusCode": 200, "message": "database deleted" } else: message = { "statusCode": 400, "errorMessage": "dbid does not exist" } else: message = { "statusCode": 400, "errorMessage": "no database present" } else: message = {"errorMessage": statusmessage, "Error": resource} return (message)
def createversion(productid, serviceid, apiid): iop = {"versionname": ""} versionname = request.json["versionname"] json_dict = request.get_json() apipath = "servicedesigns/" + serviceid + "/api/config.json" status, statusmessage, api = datafile.load_s3_file(apipath) if status == "success": version = { 'versionname': versionname, 'versionid': uniqid('v-'), 'resources': [] } if 'description' in json_dict: version['description'] = request.json['description'] api['versions'].append(version) writestatus, writestatusmessage, response = datafile.write_s3_file( apipath, api) if writestatus == "success": message = {"statusCode": 200, "body": api} else: message = {"errorMessage": writestatusmessage, "Error": response} else: message = {"errorMessage": statusmessage, "Error": api} return (message)
def updatetestcases(productid, serviceid, apiid, versionid, resourceid, methodid, testcaseid): json_dict = request.get_json() testcasepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/testcases/" + methodid + "/" + testcaseid + ".json" status, statusmessage, testcase = datafile.load_s3_file(testcasepath) if status == "success": if "body" in json_dict: testcase["body"] = request.json["body"] if "headers" in json_dict: testcase["headers"] = request.json["headers"] if "pathparameters" in json_dict: testcase["pathparameters"] = request.json["pathparameters"] if "queryparameters" in json_dict: testcase["queryparameters"] = request.json["queryparameters"] if "testcasename" in json_dict: testcase["testcasename"] = request.json["testcasename"] testcasepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/testcases/" + methodid + "/" + testcaseid + ".json" testcasestatus, testcasestatusmessage, testres = datafile.write_s3_file( testcasepath, testcase) if testcasestatus == "success": message = {"statusCode": 200, "body": testcase} else: message = {"statusCode": 400, "errorMessage": testres} return (message)
def deleteproduct(productid): productpath = "products/products.json" status, statusmessage, products = datafile.load_s3_file(productpath) if status == "success": productids = [] for prod in products: productids.append(prod["productid"]) if productid in productids: for prod in products: if prod["productid"] == productid: products.remove(prod) status, statusmessage, response = datafile.write_s3_file( productpath, products) prodprefix = "services/" + productid delstatus, delmessage = datafile.delete_folders(prodprefix) message = {"statusCode": 200, 'message': 'Product Deleted'} else: message = { "statusCode": 400, "errorMessage": "productid does not exist" } else: message = {"statusCode": 400, "errorMessage": products} return (message)
def publish_push(serviceid, optionname): iop = {"commitmessage": "", "Branchname": "", "Name": ""} try: commitmessage = request.json["commitmessage"] branch = request.json["Branchname"] foldername = request.json["Name"] coderepoconfigpath = "repoconfig/config.json" status, statusmessage, codecred = datafile.load_s3_file( coderepoconfigpath) if status == "error": message = { "statusCode": 400, "errorMessage": statusmessage, "Error": codecred } return (message) gitrepourl = codecred["gitrepourl"] gitusername = codecred["gitusername"] ###commands### pullcommand = "git clone -b " + branch + " " + gitrepourl + " archedeploy\nexport CLONE_PATH=$PWD/archedeploy" optionpath = "deploy/" + serviceid + "/" + optionname + "/" + optionname + ".json" status, statusmessage, optionjson = datafile.load_s3_file(optionpath) if status == "error": message = {"statusCode": 400, "errorMessage": statusmessage} return (message) createshcommand = "bash " + "$CLONE_PATH/deploy/" + serviceid + "/" + optionname + "/createscript.sh" updateshcommand = "bash " + "$CLONE_PATH/deploy/" + serviceid + "/" + optionname + "/updatescript.sh" deleteshcommand = "bash " + "$CLONE_PATH/deploy/" + serviceid + "/" + optionname + "/deletescript.sh" finalstep = { "deploy": { "description": "Run the command below to deploy resources", "tasks": [{ "taskno": 1.0, "description": "Clone Code repo", "taskname": "Clone", "initscript": pullcommand }, { "taskno": 2.0, "description": "Deploy the resources", "taskname": "Deploy", "initscript": createshcommand }, { "taskno": 3.0, "description": "Update the resources", "taskname": "UpdateDeploy", "initscript": updateshcommand }, { "taskno": 4.0, "description": "Delete the resources", "taskname": "Deletedeploy", "initscript": deleteshcommand }] } } optionjson[optionname] = finalstep status, statusmessage, writeoptionjson = datafile.write_s3_file( optionpath, optionjson) if status == "error": message = {"statusCode": 400, "errorMessage": statusmessage} return (message) ###pushing to git#### srcfolder = "/home/app/web/archeplay/data" destfolder = "/home/app/web/archeplay/" + foldername pushfolder = "deploy/*" copy_tree(srcfolder, destfolder) count = 1 push = True while push: tagname = serviceid + ".v" + str(count) status, statusmessage = git_push(destfolder, gitrepourl, branch, gitusername, pushfolder, commitmessage, tagname) if status == "success": push = False else: if "already exists" in statusmessage: count = count + 1 else: message = { "statusCode": 400, "errorMessage": statusmessage } return (message) message = {"statusCode": 200, "body": optionjson} return (message) except Exception as e: message = {"statusCode": 400, "errorMessage": str(e)} return (message)
def shared_design_push(productid, serviceid): iop = { "commitmessage": "", "Branchname": "", "Name": "", "SourceBranchName": "", "SourceName": "", "Tag": "" } try: commitmessage = request.json["commitmessage"] branch = request.json["Branchname"] foldername = request.json["Name"] sourcebranch = request.json["SourceBranchName"] sourcefoldername = request.json["SourceName"] Tag = request.json["Tag"] coderepoconfigpath = "repoconfig/config.json" status, statusmessage, codecred = datafile.load_s3_file( coderepoconfigpath) if status == "error": message = { "statusCode": 400, "errorMessage": statusmessage, "Error": codecred } return (message) gitrepourl = codecred["gitrepourl"] gitusername = codecred["gitusername"] ##pulling source tag localsorcepath = "/home/app/web/archeplay/" + uniqid("localgit") repo = git.Repo.clone_from(gitrepourl, localsourcepath, branch=sourcebranch) repo.config_writer().set_value("user", "name", gitusername).release() repo.config_writer().set_value("user", "email", gitusername).release() giturl = repo.git giturl.pull('origin', sourcebranch, '--allow-unrelated-histories') giturl.checkout('tags/' + Tag) ###copying product json### productpath = localsourcepath + "/products/products.json" prodstatus, prodstatusmessage, products = datafile.load_copy_file( productpath) if prodstatus == "error": message = { "statusCode": 400, "errormessage": prodstatusmessage, "Error": products } return (message) copyproductpath = "/home/app/web/archeplay/" + foldername + "/products/products.json" prodstatus, prodstatusmessage, copyproduct = datafile.load_copy_file( copyproductpath) if prodstatus == "error": copyproduct = [] for prod in products: if prod["productid"] == productid: copyproduct.append(prod) copyproductpath = "/home/app/web/archeplay/" + foldername + "/products/products.json" prodstatus, prodstatusmessage, copyprod = datafile.write_copy_file( copyproductpath, copyproduct) if prodstatus == "error": message = { "statusCode": 400, "errorMessage": prodstatusmessage, "Error": copyprod } return (message) ###copying service json##### servicepath = localsourcepath + "/services/" + productid + "/services.json" srvstatus, srvstatusmessage, services = datafile.load_copy_file( servicepath) if srvstatus == "error": message = { "statusCode": 400, "errorMessage": srvstatusmessage, "Error": services } return (message) copyservicepath = "/home/app/web/archeplay/" + foldername + "/services/" + productid + "/services.json" svcstatus, svcstatusmessage, copyservice = datafile.load_copy_file( copyservicepath) if svcstatus == "error": copyservice = [] for svc in services: if svc["serviceid"] == serviceid: copyservice.append(svc) copyservicepath = "/home/app/web/archeplay/" + foldername + "/services/" + productid + "/services.json" svcstatus, svcstatusmessage, copysvc = datafile.write_copy_file( copyservicepath, copyservice) if svcstatus == "error": message = { "statusCode": 400, "errorMessage": svcstatusmessage, "Error": copysvc } return (message) ###copying design data### designdatapath = localsourcepath + "/servicedesigns/" + serviceid destfolder = "/home/app/web/archeplay/" + foldername + "/servicedesigns/" + serviceid directory = os.path.dirname(destfolder) if not os.path.exists(directory): os.makedirs(directory) copy_tree(designdatapath, destfolder) ###copying repoconfig#### coderepoconfigpath = localsourcepath + "/repoconfig/config.json" destpath = "/home/app/web/archeplay/" + foldername + "/repoconfig/config.json" directory = os.path.dirname(destpath) if not os.path.exists(directory): os.makedirs(directory) copyfile(coderepoconfigpath, destpath) ###copying templateconfig#### templaterepoconfigpath = localsourcepath + "/templateconfig/config.json" destpath = "/home/app/web/archeplay/" + foldername + "/templateconfig/config.json" directory = os.path.dirname(destpath) if not os.path.exists(directory): os.makedirs(directory) copyfile(templaterepoconfigpath, destpath) ###pushing to git### pushfolder = "/home/app/web/archeplay/" + foldername output_files = glob.glob(pushfolder + "/**/*output.json", recursive=True) for file in output_files: os.remove(file) log_files = glob.glob(pushfolder + "/**/*log.json", recursive=True) for file in log_files: os.remove(file) count = 1 push = True while push: tagname = serviceid + ".v" + str(count) status, statusmessage = git_push(pushfolder, gitrepourl, branch, gitusername, pushfolder, commitmessage, tagname) if status == "success": for svc in services: if svc["serviceid"] == serviceid: svc["tagnames"].append(tagname) svc["Branchname"] = branch svc["Name"] = foldername srvstatus, srvstatusmessage, svcupdate = datafile.write_s3_file( servicepath, services) if srvstatus == "error": message = { "statusCode": 400, "errorMessage": srvstatusmessage, "Error": svcupdate } return (message) copysvcstatus, copysvcstatusmessage, copysvc = datafile.load_copy_file( copyservicepath) if copysvcstatus == "error": message = { "statusCode": 400, "errormessage": copysvcstatusmessage } return (message) for cpsvc in copysvc: if cpsvc["serviceid"] == serviceid: cpsvc["tagnames"].append(tagname) cpsvc["Branchname"] = branch cpsvc["Name"] = foldername writecpsvcstatus, writecpsvcstatusmessage, cpsrvice = datafile.write_copy_file( copyservicepath, copysvc) if writecpsvcstatus == "error": message = { "statusCode": 400, "errorMessage": writecpsvcstatusmessage } return (message) push = False else: if "already exists" in statusmessage: count = count + 1 else: message = { "statusCode": 400, "errorMessage": statusmessage } return (message) message = {"statusCode": 200, "message": statusmessage} return (message) except Exception as e: message = {"statusCode": 400, "errorMessage": str(e)} return (message)
def create_branches(): iop = { "mybranch": { "Name": "", "Branchname": "" }, "sharedbranch": [{ "Name": "", "Branchname": "" }, { "Name": "", "Branchname": "" }], "environmentdeploybranch": [{ "Name": "", "Branchname": "" }, { "Name": "prod", "Branchname": "" }] } try: branches = request.json["branches"] mybranch = branches["mybranch"] compsharedbranch = comparelistitems(branches["sharedbranch"]) if compsharedbranch["statusCode"] == 400: return (compsharedbranch) compenvbranch = comparelistitems(branches["environmentdeploybranch"]) if compenvbranch["statusCode"] == 400: return (compenvbranch) for sharedbranchitem in branches["sharedbranch"]: for envbranchitem in branches["environmentdeploybranch"]: if sharedbranchitem["Name"] == envbranchitem[ "Name"] or sharedbranchitem[ "Branchname"] == envbranchitem["Branchname"]: message = { "statusCode": 400, "errorMessage": "Not unique name in environmentdeploybranch and sharedbranch" } return (message) for sharedbranchitem in branches["sharedbranch"]: if sharedbranchitem["Name"] == mybranch["Name"] or sharedbranchitem[ "Branchname"] == mybranch["Branchname"]: message = { "statusCode": 400, "errorMessage": "Not unique name in mybranch and sharedbranch" } return (message) for envbranchitem in branches["environmentdeploybranch"]: if envbranchitem["Name"] == mybranch["Name"] or envbranchitem[ "Branchname"] == mybranch["Branchname"]: message = { "statusCode": 400, "errorMessage": "Not unique name in environmentdeploybranch and mybranch" } return (message) coderepoconfigpath = "repoconfig/config.json" status, statusmessage, codecred = datafile.load_s3_file( coderepoconfigpath) if status == "error": message = {"statusCode": 400, "errorMessage": statusmessage} return (message) gitrepourl = codecred["gitrepourl"] gitusername = codecred["gitusername"] codecred["mybranch"] = branches["mybranch"] codecred["mybranch"]["Tags"] = [] codecred["sharedbranch"] = branches["sharedbranch"] codecred["environmentdeploybranch"] = branches[ "environmentdeploybranch"] secretpath = os.getenv("NETRC") destinationpath = "/home/app/.netrc" directory = os.path.dirname(destinationpath) if not os.path.exists(directory): os.makedirs(directory) copyfile(secretpath, destinationpath) writestatus, writestatusmessage, repoupdatebranch = datafile.write_s3_file( coderepoconfigpath, codecred) if writestatus == "error": message = {"statusCode": 400, "errorMessage": writestatusmessage} return (message) getbranch = get_branches() if getbranch["statusCode"] == 400: return (getbranch) branchnames = getbranch["body"] devdesignbranch = branches["mybranch"]["Branchname"] devdesignfoldername = branches["mybranch"]["Name"] archepath = "/home/app/web/archeplay" archedesignpath = archepath + "/" + devdesignfoldername mybranchstatus = create_branch(devdesignbranch, branchnames, gitrepourl, archedesignpath, gitusername) if mybranchstatus["statusCode"] == 400: return (mybranchstatus) for sharedbranch in branches["sharedbranch"]: branch = sharedbranch["Branchname"] sharedfoldername = sharedbranch["Name"] folderpath = archepath + "/" + sharedfoldername sharedbranchstatus = shared_branch(branch, branchnames, gitrepourl, folderpath, gitusername) if sharedbranchstatus["statusCode"] == 400: return (sharedbranchstatus) for envbranch in branches["environmentdeploybranch"]: branch = envbranch["Branchname"] envfoldername = envbranch["Name"] folderpath = archepath + "/" + envfoldername envbranchstatus = create_branch(branch, branchnames, gitrepourl, folderpath, gitusername) if envbranchstatus["statusCode"] == 400: return (envbranchstatus) message = {"statusCode": 200, "body": codecred} return (message) except Exception as e: message = {"statusCode": 400, "errorMessage": str(e)} return (message)
def createservice(productid): iop = { "servicename": "", "description": "", "servicetype": "", "optionname": "" } userid = request.headers["userid"] servicename = request.json["servicename"] servicetype = request.json["servicetype"] optionname = request.json["optionname"] json_dict = request.get_json() servicepath = "services/" + productid + "/services.json" status, statusmessage, services = datafile.load_s3_file(servicepath) if status != "success": services = [] serviceids = [] for svc in services: serviceids.append(svc["serviceid"]) a = True while a is True: serviceid = uniqid('service') if serviceid in serviceids: a = True else: a = False service = { 'productid': productid, 'serviceid': serviceid, 'userid': userid, 'servicename': servicename, 'servicetype': servicetype, 'optionname': optionname, 'tagnames': [] } if "description" in json_dict: service["description"] = request.json["description"] apiid = uniqid('api') api = { 'productid': productid, 'serviceid': serviceid, 'apiid': apiid, 'userid': userid, 'apiname': request.json['servicename'], 'versions': [{ 'versionname': 'v1', 'versionid': uniqid('v-'), 'description': 'default version', 'resources': [] }], 'deploy': { 'cloud': 'aws', 'deployplatform': 'eks', 'image': 'docker', 'imagerepo': 'ecr' } } if 'description' in json_dict: api['description'] = request.json['description'] service['apiid'] = api['apiid'] services.append(service) status, statusmessage, response = datafile.write_s3_file( servicepath, services) apipath = "servicedesigns/" + serviceid + "/api/config.json" statusapi, statusmessageapi, resapi = datafile.write_s3_file(apipath, api) if status == "success": message = { "statusCode": 200, 'message': 'New Service Created', 'body': service } else: message = { "statusCode": 400, 'message': statusmessage, 'Error': response } return (message)
def generatemethod(productid, serviceid, apiid, versionid, resourceid): resourcepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/config.json" status, statusmessage, resource = datafile.load_s3_file(resourcepath) actions = request.json["actions"] versionname = request.json["versionname"] methodmessage = getmethod(productid, serviceid, apiid, versionid, resourceid) if methodmessage["statusCode"] == 200: if methodmessage["body"] != []: for method in methodmessage["body"]: for action in actions: action["methodpath"] = action["methodpath"].replace( "{", "<") action["methodpath"] = action["methodpath"].replace( "}", ">") if action["methodpath"] == method["methodpath"] and action[ "methodtype"] == method["methodtype"]: actions.remove(action) else: return (methodmessage) autopoppulate = { "resourceid": resourceid, "serviceid": serviceid, "versionid": versionid, "actions": actions } actionlist = [] for act in autopoppulate["actions"]: methodid = uniqid("meth") act["methodid"] = methodid act["methodpath"] = act["methodpath"].replace("{", "<") act["methodpath"] = act["methodpath"].replace("}", ">") if act["methodpath"] != "": apicallpath = "/" + versionname + "/" + resource[ "resourcename"] + act["methodpath"] else: apicallpath = "/" + versionname + "/" + resource["resourcename"] method = {"Ref": methodid} resource["methods"].append(method) resstatus, resstatusmessage, res = datafile.write_s3_file( resourcepath, resource) if resstatus == "error": message = {"statusCode": 400, "errorMessage": res} return (message) methodpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + ".json" full_code = consolidate_code(act, requirements) # act["import_code"]=act["import_code"].replace("METHODID",methodid) # act["import_code"]=act["import_code"].replace("METHODPATH",apicallpath) # act["function_code"]=act["function_code"].replace("METHODID",methodid) # act["function_code"]=act["function_code"].replace("METHODPATH",apicallpath) # act["main_code"]=act["main_code"].replace("METHODID",methodid) # act["main_code"]=act["main_code"].replace("METHODPATH",apicallpath) # act["type_code"]=act["type_code"].replace("METHODID",methodid) # act["type_code"]=act["type_code"].replace("METHODPATH",apicallpath) # codestring=act["import_code"]+"\n"+act["function_code"]+"\n"+act["main_code"]+"\n"+act["type_code"] codepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + "/code/" + methodid + ".py" codestatus, codestatusmessage, code = datafile.write_txt_file( codepath, codestring) if codestatus == "error": message = {"statusCode": 400, "errorMessage": code} return (message) requirement = act["requirements"] reqstring = "" for i in requirement: reqstring = reqstring + i + "\n" # act["requirements"]=reqstring requirementpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + "/code/requirement.txt" requirementstatus, requirementstatusmessage, req = datafile.write_txt_file( requirementpath, reqstring) if requirementstatus == "error": message = {"statusCode": 400, "errorMessage": req} return (message) methstatus, methstatusmessage, methres = datafile.write_s3_file( methodpath, act) if methstatus == "error": message = {"statusCode": 400, "errorMessage": code} return (message) if methstatus == "success" and codestatus == "success" and requirementstatus == "success": actionlist.append(act) message = {"statusCode": 200, "body": actionlist} return (message)
def createmethod(productid, serviceid, apiid, versionid, resourceid): iop = {"methodtype": "", "path": ""} methodtype = request.json["methodtype"] json_dict = request.get_json() resourcepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/config.json" status, statusmessage, resource = datafile.load_s3_file(resourcepath) if status == "success": if resource["methods"] == []: methodid = uniqid('meth') method = {"Ref": methodid} resource["methods"].append(method) elif resource["methods"] != []: methodids = [] for method in resource["methods"]: methodids.append(method["Ref"]) a = True while a is True: methodid = uniqid('meth') if methodid in methodids: a = True else: a = False method = {"Ref": methodid} resource["methods"].append(method) resstatus, resstatusmessage, res = datafile.write_s3_file( resourcepath, resource) methodjson = { "methodtype": methodtype, "methodid": methodid, "codetype": "python", "language": "python3.6", "servicetype": "dynamodb_eks_flask", "requirements": "", "import_code": "", "function_code": "", "main_code": "", "type_code": "" } if "path" in json_dict: methodjson["methodpath"] = request.json["path"] if "description" in json_dict: methodjson["description"] = request.json["description"] methodpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + ".json" codestring = methodjson["import_code"] + "\n" + methodjson[ "function_code"] + "\n" + methodjson[ "main_code"] + "\n" + methodjson["type_code"] codepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + "/code/" + methodid + ".py" codestatus, codestatusmessage, code = datafile.write_txt_file( codepath, codestring) requirement = methodjson["requirements"] requirementpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + "/code/requirement.txt" requirementstatus, requirementstatusmessage, req = datafile.write_txt_file( requirementpath, requirement) methstatus, methstatusmessage, methres = datafile.write_s3_file( methodpath, methodjson) if methstatus == "success" and codestatus == "success" and requirementstatus == "success": message = {"statusCode": 200, "body": methodjson} else: message = {"errorMessage": methstatus, "Error": methres} else: message = {"errorMessage": statusmessage, "Error": resource} return (message)
def addsnippet(productid, serviceid, apiid, versionid, resourceid, methodid): resourcepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/config.json" status, statusmessage, resource = datafile.load_s3_file(resourcepath) if "snippetname" not in request.json: snippet = request.json["snippet"] versionname = request.json["versionname"] snippetid = uniqid("sn_") updated_method = { "import_code": snippet["import_code"], "function_code": snippet["function_code"], "function_call": snippet["function_call"], "requirements": snippet["requirements"], "version": snippet["version"], "name": snippet["name"] } methodpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + ".json" status, statusmessage, methodjson = datafile.load_s3_file(methodpath) table = request.json["table"] if "TABLENAME" in updated_method["function_code"]: updated_method["function_code"] = updated_method[ "function_code"].replace("TABLENAME", table["tablename"]) if "TABLENAME" in updated_method["function_call"]: updated_method["function_call"] = updated_method[ "function_call"].replace("TABLENAME", table["tablename"]) if "PRIMARYKEY" in updated_method["function_code"]: updated_method["function_code"] = updated_method[ "function_code"].replace("PRIMARYKEY", table['indexes']['primary']['key']) if "PRIMARYKEY" in updated_method["function_call"]: updated_method["function_call"] = updated_method[ "function_call"].replace("PRIMARYKEY", table['indexes']['primary']['key']) updated_method["function_code"] = updated_method[ "function_code"].replace("SNIPPETID", snippetid) updated_method["function_call"] = updated_method[ "function_call"].replace("SNIPPETID", snippetid) updated_method.update({"snippetid": snippetid}) methodpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + ".json" status, statusmessage, methodjson = datafile.load_s3_file(methodpath) if status == "success": snippetorder = methodjson["snippets"]["snippetorder"] snippetorder.append({ "name": snippet["name"], "snippetid": snippetid }) methodjson["snippets"].update({ snippetid: updated_method, "snippetorder": snippetorder }) methodjson["methodpath"] = methodjson["methodpath"].replace( "{", "<") methodjson["methodpath"] = methodjson["methodpath"].replace( "}", ">") if methodjson["methodpath"] != "": apicallpath = "/" + versionname + "/" + resource[ "resourcename"] + methodjson["methodpath"] else: apicallpath = "/" + versionname + "/" + resource["resourcename"] methodpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + ".json" methodjson["type_code"] = methodjson["type_code"].replace( "METHODID", methodid) methodjson["type_code"] = methodjson["type_code"].replace( "METHODPATH", apicallpath) codestring, requirement = consolidate_code(methodjson) codepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + "/code/" + methodid + ".py" codestatus, codestatusmessage, code = datafile.write_txt_file( codepath, codestring) if codestatus == "error": message = {"statusCode": 400, "errorMessage": code} return (message) reqstring = "" for i in requirement: reqstring = reqstring + i + "\n" # act["requirements"]=reqstring requirementpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + "/code/requirement.txt" requirementstatus, requirementstatusmessage, req = datafile.write_txt_file( requirementpath, reqstring) if requirementstatus == "error": message = {"statusCode": 400, "errorMessage": req} return (message) methstatus, methstatusmessage, methres = datafile.write_s3_file( methodpath, methodjson) if methstatus == "error": message = {"statusCode": 400, "errorMessage": code} return (message) if methstatus == "success" and codestatus == "success" and requirementstatus == "success": message = { "statusCode": 200, "body": methodjson, "snippetid": snippetid } return (message) else: versionname = request.json["versionname"] snippetname = request.json["snippetname"] functionname = request.json["functionname"] import_code = "import boto3,json\n" function_code = "def " + functionname + "():\r\n # Write your code here\r\n return()\r\n" data_code = "" methodpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + ".json" status, statusmessage, methodjson = datafile.load_s3_file(methodpath) dbtype = methodjson["dbtype"] if dbtype == "dynamodb": data_code = "dynamodb=boto3.resource('dynamodb',region_name='us-east-1')\n" function_call = "" snippetid = uniqid("sn_") custom_snippet = { "import_code": import_code, "data_code": data_code, "function_code": function_code, "function_call": function_call, "name": snippetname + functionname, "snippetid": snippetid, "requirements": [] } snippetorder = methodjson["snippets"]["snippetorder"] snippetorder.append({ "name": custom_snippet["name"], "snippetid": snippetid }) methodjson["snippets"].update({ snippetid: custom_snippet, "snippetorder": snippetorder }) methodjson["methodpath"] = methodjson["methodpath"].replace("{", "<") methodjson["methodpath"] = methodjson["methodpath"].replace("}", ">") if methodjson["methodpath"] != "": apicallpath = "/" + versionname + "/" + resource[ "resourcename"] + methodjson["methodpath"] else: apicallpath = "/" + versionname + "/" + resource["resourcename"] methodpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + ".json" methodjson["type_code"] = methodjson["type_code"].replace( "METHODID", methodid) methodjson["type_code"] = methodjson["type_code"].replace( "METHODPATH", apicallpath) codestring, requirement = consolidate_code(methodjson) codepath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + "/code/" + methodid + ".py" codestatus, codestatusmessage, code = datafile.write_txt_file( codepath, codestring) if codestatus == "error": message = {"statusCode": 400, "errorMessage": code} return (message) reqstring = "" for i in requirement: reqstring = reqstring + i + "\n" # act["requirements"]=reqstring requirementpath = "servicedesigns/" + serviceid + "/api/" + versionid + "/resources/" + resourceid + "/methods/" + methodid + "/code/requirement.txt" requirementstatus, requirementstatusmessage, req = datafile.write_txt_file( requirementpath, reqstring) if requirementstatus == "error": message = {"statusCode": 400, "errorMessage": req} return (message) methstatus, methstatusmessage, methres = datafile.write_s3_file( methodpath, methodjson) if methstatus == "error": message = {"statusCode": 400, "errorMessage": code} return (message) if methstatus == "success" and codestatus == "success" and requirementstatus == "success": message = { "statusCode": 200, "body": methodjson, "snippetid": snippetid } return (message)