def HandleNodeWebApi(self, api_service_options):
"""
⚝ Handling Nodejs Express Web Api
① Get CamelCase name for renaming output project folder
② Copy from template to output dir
③ Handle Data, Authorization
④ Add to docker-compose and configure Dockerfile
⑤ Clear folders for region tags
"""
#1dawda
CamelCaseName = to_camelcase(api_service_options['name'])
apiServicesPath = os.path.join(self.project_templates_paths,'api_services')
api_template_folder = os.path.join(apiServicesPath,'express_web_api')
srcDir = os.path.join(self.outputPath,'src')
api_copy_folder = os.path.join(srcDir,'ApiServices',CamelCaseName)
if os.path.isdir(api_copy_folder):
shutil.rmtree(api_copy_folder,ignore_errors=True)
# TODO: Swap shutil operations
#shutil.copytree(api_template_folder,api_copy_folder,ignore=shutil.ignore_patterns('node_modules*'))
shutil.copytree(api_template_folder,api_copy_folder)
#3
self.HandleNodeJsData(api_service_options,api_copy_folder)
self.HandleNodeJsAuthorization(api_service_options,api_copy_folder)
#4
docker_config = self.HandleNodeJsDockerOptions(api_service_options,api_copy_folder)
docker_instance = Docker.getInstance()
docker_instance.AddService(api_service_options['name'], docker_config)
#5
app_js_file_path = os.path.join(api_copy_folder,'src','app.js')
ClearRegionLines([app_js_file_path])
def GenerateNginxInstance(self):
serversPath = os.path.join(self.project_templates_paths, 'servers')
nginxTemplateFolder = os.path.join(serversPath, 'nginx')
folderPath = os.path.normpath(
os.path.join(self.outputPath, self.server_options['name']))
nginxPath = os.path.join(folderPath, 'nginx.conf')
if os.path.isdir(folderPath):
shutil.rmtree(folderPath, ignore_errors=True)
shutil.copytree(nginxTemplateFolder, folderPath)
api_services_uses_nginx = self.FindApiServicesUsesNginx(
self.server_options['name'])
clients_uses_nginx = self.FindClientsUsesNginx(
self.server_options['name'])
identity_uses_nginx = self.FindIdentityServicesUsesNginx(
self.server_options['name'])
nginxConfig = self.BuildNginxConfiguration(self.server_options,
api_services_uses_nginx,
clients_uses_nginx,
identity_uses_nginx)
docker_config = self.BuildNginxDockerOptions(api_services_uses_nginx,
clients_uses_nginx,
identity_uses_nginx)
docker_instance = Docker.getInstance()
docker_instance.AddService(self.server_options['name'], docker_config)
nginx.dumpf(nginxConfig, nginxPath)
def HandleIdentityServer4(self, identity_service):
docker_options = self.GetIdentityServerDockerOptions(identity_service)
docker_instance = Docker.getInstance()
docker_instance.AddService(identity_service['name'], docker_options)
identityServicesPath = os.path.join(self.project_templates_paths,
'identity_services')
is4_template_folder = os.path.join(identityServicesPath,
'identityserver4ef')
srcDir = os.path.join(self.outputPath, 'src')
is4_copy_folder = os.path.join(srcDir, 'IdentityServices',
identity_service['name'])
if os.path.isdir(is4_copy_folder):
shutil.rmtree(is4_copy_folder, ignore_errors=True)
# TODO: Swap shutil operations
#shutil.copytree(is4_template_folder,is4_copy_folder,ignore=shutil.ignore_patterns('bin*','obj*'))
shutil.copytree(is4_template_folder, is4_copy_folder)
api_services_using_is4 = self.FindApiServicesUsesIs4(
identity_service['name'])
clients_using_is4 = self.FindClientsUsesIs4(identity_service['name'])
self.HandleIs4ClientConfiguration(clients_using_is4, identity_service,
is4_copy_folder)
self.HandleIs4ResourcesConfiguration(api_services_using_is4,
identity_service, is4_copy_folder)
self.HanldeIs4Csproj(identity_service, is4_copy_folder)
self.HandleConnectionStringForIs4(identity_service, is4_copy_folder)
if 'eventbus' in identity_service:
self.HandleEventBusForIs4(identity_service, is4_copy_folder)
self.HandleIs4DockerFile(identity_service, is4_copy_folder)
self.HandleStartupForIs4(identity_service, is4_copy_folder)
self.HandleIs4Cleaning(is4_copy_folder)
def HandleDotnetApiService(self, api_service_options):
CamelCaseName = to_camelcase(api_service_options['name'])
apiServicesPath = os.path.join(self.project_templates_paths,
'api_services')
api_template_folder = os.path.join(apiServicesPath, 'dotnet_web_api',
'src')
srcDir = os.path.join(self.outputPath, 'src')
api_copy_folder = os.path.join(srcDir, 'ApiServices', CamelCaseName)
if os.path.isdir(api_copy_folder):
shutil.rmtree(api_copy_folder, ignore_errors=True)
# TODO: Swap shutil operations
#shutil.copytree(api_template_folder,api_copy_folder,ignore=shutil.ignore_patterns('bin*','obj*'))
shutil.copytree(api_template_folder, api_copy_folder)
api_src_folder = os.path.join(srcDir, 'ApiServices', CamelCaseName,
'DotnetWebApi')
api_src_rename_folder = os.path.join(srcDir, 'ApiServices',
CamelCaseName, 'src')
api_csproj_folder = os.path.join(srcDir, 'ApiServices', CamelCaseName,
'src', 'DotnetWebApi.csproj')
api_csproj_rename_folder = os.path.join(srcDir, 'ApiServices',
CamelCaseName, 'src',
CamelCaseName + '.csproj')
if not os.path.isdir(api_src_rename_folder):
shutil.copytree(api_src_folder, api_src_rename_folder)
shutil.rmtree(api_src_folder, ignore_errors=True)
else:
shutil.rmtree(api_src_rename_folder, ignore_errors=True)
shutil.copytree(api_src_folder, api_src_rename_folder)
if not os.path.exists(api_csproj_rename_folder):
shutil.copy(api_csproj_folder, api_csproj_rename_folder)
os.remove(api_csproj_folder)
else:
os.remove(api_csproj_rename_folder)
shutil.copy(api_csproj_folder, api_csproj_rename_folder)
self.HandleDotnetApiCsproj(api_service_options, api_copy_folder)
self.HandleDotnetApiStartup(api_service_options, api_copy_folder)
self.HandleDotnetApiProgramFile(api_service_options, api_copy_folder)
self.HandleDotnetApiDbContext(api_service_options, api_copy_folder)
self.HandleDotnetApiNameSpaceAndCleaning(api_service_options,
api_copy_folder)
self.HandleDotnetApiDockerFile(api_service_options, api_copy_folder)
docker_config = self.HandleDotnetApiDockerCompose(
api_service_options, api_copy_folder)
docker_instance = Docker.getInstance()
docker_instance.AddService(api_service_options['name'], docker_config)
def HandleRedisDatabase(self, db_options):
print(self.project_templates_paths)
databasesPath = os.path.join(self.project_templates_paths, 'databases')
redis_template_folder = os.path.join(databasesPath, 'redis')
redis_project_folder = os.path.join(self.outputPath,
db_options['name'])
if os.path.isdir(redis_project_folder):
shutil.rmtree(redis_project_folder, ignore_errors=True)
#Copy template (config and Dockerfile)
shutil.copytree(redis_template_folder, redis_project_folder)
docker_options = self.GetRedisDockerOptions(db_options)
docker_instance = Docker.getInstance()
docker_instance.AddService(db_options['name'], docker_options)
docker_instance.AddVolume('redis-volume')
def HandleAngular6SsrClient(self, client_options):
CamelCaseName = to_camelcase(client_options['name'])
clientsPath = os.path.join(self.project_templates_paths, 'clients')
template_folder = os.path.join(clientsPath, 'angular', 'cli_6_ssr')
srcDir = os.path.join(self.outputPath, 'src')
copy_folder = os.path.join(srcDir, 'Clients', CamelCaseName)
if os.path.isdir(copy_folder):
shutil.rmtree(copy_folder, ignore_errors=True)
# TODO: Ignore Node Modules in prod
shutil.copytree(template_folder, copy_folder)
# shutil.copytree(template_folder,copy_folder,ignore=shutil.ignore_patterns('node_modules*'))
self.HandleAngular6SsrAuth(client_options, copy_folder)
self.HandleDockerfileForAngularSsr(client_options, copy_folder)
docker_config = self.HandleDockerComposeForAngularSsr(client_options)
docker_instance = Docker.getInstance()
docker_instance.AddService(client_options['name'], docker_config)
def HandleMongoDb(self, db_options):
mongo_docker_options = self.GetDockerOptions(db_options)
docker_instance = Docker.getInstance()
docker_instance.AddService(db_options['name'], mongo_docker_options)
docker_instance.AddVolume('mongodb-volume')
def HandlePostgre(self, db_options):
docker_options = self.BuildDockerOptions(db_options)
docker_instance = Docker.getInstance()
docker_instance.AddService(db_options['name'], docker_options)
docker_instance.AddVolume('postgres-volume')
def HandleRabbitMq(self, rabbit_options):
docker_options = self.GetRabbitmqDockerOptions(rabbit_options)
docker_instance = Docker.getInstance()
docker_instance.AddService(rabbit_options['name'], docker_options)
docker_instance.AddVolume('rabbit-volume')
def HandleMysql(self, db_options):
docker_options = self.BuildDockerOptions(db_options)
docker_instance = Docker.getInstance()
docker_instance.AddService(db_options['name'],docker_options)
docker_instance.AddVolume('mysql-volume')