Module setup for ilens-clients module

.env

+MONGO_URI=mongodb://192.168.0.220:2717/
+ILENS_CLIENTS_DB=ilens_clients
+ILENS_CLIENTS_COLLECTION=ilens_clients
+REDIS_HOST=192.168.0.220
+REDIS_PORT=6379
+MODULE_NAME="main"

README.md

+# ilens-Assistant-clients
+
+## Port and Proxy Details
+
+Default port specified: 6999
+
+Proxy: ilens_clients
+
+## Environment values to be configured
+
+| **Variable** | **Value** |
+| -- | -- |
+| MONGO_URI | Configured to the MongoDB URI |
\ No newline at end of file

app.py

+if __name__ == '__main__':
+    from dotenv import load_dotenv
+
+    load_dotenv()
+
+import argparse
+import gc
+
+import uvicorn
+
+from scripts.config import Service
+from scripts.logging.logging import logger
+
+gc.collect()
+
+ap = argparse.ArgumentParser()
+
+if __name__ == "__main__":
+    ap.add_argument(
+        "--port",
+        "-p",
+        required=False,
+        default=Service.PORT,
+        help="Port to start the application.",
+    )
+    ap.add_argument(
+        "--bind",
+        "-b",
+        required=False,
+        default=Service.HOST,
+        help="IP to start the application.",
+    )
+    arguments = vars(ap.parse_args())
+
+    logger.info(f"App Starting at {arguments['bind']}:{arguments['port']}")
+    uvicorn.run("main:app", host=arguments["bind"], port=int(arguments["port"]))

conf/application.conf

+[SERVICE]
+port=6999
+host=0.0.0.0
+version_no=1.0.0
+
+[MONGO_DB]
+uri= $MONGO_URI
+
+[DATABASES]
+ilens_clients_db=$ILENS_CLIENTS_DB
+ilens_clients_collection=$ILENS_CLIENTS_COLLECTION
+
+[REDIS]
+host=$REDIS_HOST
+port=$REDIS_PORT
+login_db = 9
\ No newline at end of file

main.py

+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from scripts.services.get_baseurl import client_info_router
+
+app = FastAPI(
+    title="iLens Clients",
+    version="1.0.0",
+    description="ILENS ASSISTANT App",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "DELETE", "PUT"],
+    allow_headers=["*"],
+)
+
+app.include_router(client_info_router)
\ No newline at end of file

requirements.txt

+fastapi~=0.63.0
+uvicorn~=0.13.4
+pyyaml~=5.3.1
+python-dotenv~=0.15.0
+pymongo~=3.11.3
+pydantic~=1.7.3
+crypto~=1.4.1
+redis~=3.5.3
+pytz~=2021.1
+python-multipart
\ No newline at end of file

scripts/config/__init__.py

+"""
+This file exposes configurations from config file and environments as Class Objects
+"""
+import shutil
+
+if __name__ == '__main__':
+    from dotenv import load_dotenv
+
+    load_dotenv()
+import os.path
+import sys
+from configparser import ConfigParser, BasicInterpolation
+
+
+class EnvInterpolation(BasicInterpolation):
+    """
+    Interpolation which expands environment variables in values.
+    """
+
+    def before_get(self, parser, section, option, value, defaults):
+        value = super().before_get(parser, section, option, value, defaults)
+
+        if not os.path.expandvars(value).startswith('$'):
+            return os.path.expandvars(value)
+        else:
+            return
+
+
+try:
+    config = ConfigParser(interpolation=EnvInterpolation())
+    config.read(f"conf/application.conf")
+except Exception as e:
+    print(f"Error while loading the config: {e}")
+    print("Failed to Load Configuration. Exiting!!!")
+    sys.stdout.flush()
+    sys.exit()
+
+
+class Service:
+    HOST = config.get("SERVICE", "host")
+    PORT = config.getint("SERVICE", "port")
+    LOG_ENABLE_TRACEBACK: bool = config.getboolean('SERVICE', 'enable_traceback', fallback=False)
+
+
+
+class DBConf:
+    MONGO_URI = config.get('MONGO_DB', 'uri')
+    if not MONGO_URI:
+        print("Error, environment variable MONGO_URI not set")
+        sys.exit(1)
+
+
+
+class DatabaseConstants:
+    ilens_clients_db = config.get("DATABASES", "ilens_clients_db")
+    if not bool(ilens_clients_db):
+        ilens_clients_db = "ilens_clients"
+    ilens_clients_collection = config.get("DATABASES", "ilens_clients_collection")
+    if not bool(ilens_clients_collection):
+        ilens_clients_collection = "ilens_clients"
+
+
+
+
+class RedisConfig(object):
+    host = config["REDIS"]["host"]
+    port = int(config["REDIS"]["port"])
+    login_db = config["REDIS"]["login_db"]
+
+

scripts/logging/logger_conf.yml

+logger:
+  name: ebpr-engine
+  level: DEBUG
+  handlers:
+    - type: RotatingFileHandler
+      file_path: logs/
+      max_bytes: 100000000
+      back_up_count: 5
+
+    - type: SocketHandler
+      host: localhost
+      port: 23582
+
+    - type: StreamHandler
+      name: ebpr-engine

scripts/logging/logging.py

+import logging
+import os
+from logging import StreamHandler
+from logging.handlers import RotatingFileHandler, SocketHandler
+
+import yaml
+
+# this method is to read the configuration from backup.conf
+def read_configuration(file_name):
+    """
+    :param file_name:
+    :return: all the configuration constants
+    """
+    with open(file_name, 'r') as stream:
+        try:
+            return yaml.safe_load(stream)
+        except Exception as e:
+            print(f"Failed to load Configuration. Error: {e}")
+
+
+config = read_configuration("scripts/logging/logger_conf.yml")
+
+logging_config = config["logger"]
+
+
+def get_logger():
+    """
+     Creates a rotating log
+     """
+    __logger__ = logging.getLogger('')
+    __logger__.setLevel(logging_config["level"].upper())
+    log_formatter = '%(asctime)s - %(levelname)-6s - [%(threadName)5s:%(funcName)5s():''' \
+                    '%(lineno)s] - %(message)s'
+    time_format = "%Y-%m-%d %H:%M:%S"
+    formatter = logging.Formatter(log_formatter, time_format)
+
+    for each_handler in logging_config["handlers"]:
+        if each_handler["type"] in ["RotatingFileHandler"]:
+            log_file = os.path.join(each_handler["file_path"] + logging_config["name"] + '.log')
+            if not os.path.exists(each_handler["file_path"]):
+                os.makedirs(each_handler["file_path"])
+
+            temp_handler = RotatingFileHandler(log_file,
+                                               maxBytes=each_handler["max_bytes"],
+                                               backupCount=each_handler["back_up_count"])
+            temp_handler.setFormatter(formatter)
+        elif each_handler["type"] in ["SocketHandler"]:
+            temp_handler = SocketHandler(each_handler["host"], each_handler["port"])
+        elif each_handler["type"] in ["StreamHandler"]:
+            temp_handler = StreamHandler()
+            temp_handler.setFormatter(formatter)
+
+        else:
+            temp_handler = None
+        __logger__.addHandler(temp_handler)
+
+    return __logger__
+
+
+logger = get_logger()

scripts/services/get_baseurl.py

+import traceback
+
+from fastapi import APIRouter
+from pymongo import MongoClient
+
+from scripts.config import DBConf, DatabaseConstants
+from scripts.logging.logging import logger
+from scripts.services.get_baseurl_schema import GetBaseUrl
+from scripts.services.response_models import DefaultMobileResponse
+
+client_info_router = APIRouter(tags=["Client List Services"])
+
+
+@client_info_router.post("/client/get_baseurl")
+def get_baseurl(request_data: GetBaseUrl):
+    try:
+        mongo_connection_obj = MongoClient(DBConf.MONGO_URI)
+        mongo_obj = mongo_connection_obj[DatabaseConstants.ilens_clients_db][DatabaseConstants.ilens_clients_collection]
+        data = mongo_obj.find_one({"client_id": request_data.name})
+        data = dict(data) if bool(data) else dict()
+        response_data = data.get("data", {})
+        if not bool(response_data):
+            raise Exception
+        return DefaultMobileResponse(status=True, message="Success", data=response_data)
+    except Exception as e:
+        logger.exception(e)
+        logger.exception(traceback.format_exc())
+        return DefaultMobileResponse(status=False, message="Could'nt find the data")

scripts/services/get_baseurl_schema.py

+from pydantic import BaseModel
+
+
+class GetBaseUrl(BaseModel):
+    name: str

scripts/services/response_models.py

+from typing import Optional, Any,Dict
+
+from pydantic import BaseModel
+
+
+class DefaultMobileResponse(BaseModel):
+    status: bool = False
+    message: Optional[str] = "failed"
+    data: Dict = dict()