Untitled

from models.cache_store import cache_store
from models.cache_store_by_username import cache_store_by_username
from models.cache_store_by_date import cache_store_by_date
from models.indexes import indexes
from models.columns import columns as tablecolumns
from datetime import datetime, timedelta, timezone
from dateutil.relativedelta import relativedelta
from pandas.io.json import json_normalize
import json
from config.logger import configlogfile

from flask import jsonify, make_response
import pandas as pd
import sys
import gc
import uuid
import pytz


"""
This function is used to fetch cache details based on valueType and key
"""
def getData(payLoad, configvalues):
    from config.logger import configlogfile
    logging = configlogfile()
    logging.info("Started to fetch the records for " + str(payLoad) )

    cacheStore = []
    try:
        payLoad = payLoad.to_dict()
        columnMapping = json.loads(configvalues.get('apiconfiguration', 'columnMapping', raw=True))
        reversecolumnMapping = {y: x for x, y in columnMapping.items()}
        validColumns = json.loads(configvalues.get('apiconfiguration', 'validColumns', raw=True))
        datecolumns = json.loads(configvalues.get('apiconfiguration', 'dateColumns', raw=True))
        logging.debug('Arguments -' + str(payLoad))
        # return ((["0000"],str(payLoad['valueType'])))

        for k, v in reversecolumnMapping.items():
            if k in list(payLoad.keys()):
                payLoad[v] = payLoad.pop(k)
        # modified the code on 18-Feb to fetch data based on keyspace and then table name 
        recs = indexes.objects().filter(keyspace_name =cache_store.__keyspace__)
        recs = recs.filter(table_name='cache_store')
        indexedcolumns = [row.options['target'] for row in recs]

        recs =  tablecolumns.objects().filter(keyspace_name = cache_store.__keyspace__)
        recs = recs.filter(table_name='cache_store')
       
        partitioncolumns = [row.column_name for row in recs if
                            row.kind in ["partition_key"]]
        partitioncolumns = partitioncolumns + [row.column_name for row in recs if
                                               row.kind in ["primary_key", "clustering"]]
        parametercolumns = partitioncolumns + indexedcolumns
        partitioncolstofilter = [parametercolumn for parametercolumn in parametercolumns if
                            parametercolumn in list(payLoad.keys())]

        if (bool(payLoad) == False):
            return (("200","parameters needs to be passed to fetch values from the cache store"))
            #query = 'global cacheStoreRecords;cacheStoreRecords=cache_store.objects().all();'
        else:
            #return ((["0000"], str(range(len(partitioncolstofilter)))))
            if set(list(payLoad.keys())).issubset(parametercolumns):

                for i in range(len(partitioncolstofilter)):
                    if i == 0:
                        if partitioncolstofilter[i] in datecolumns:
                            query = 'global cacheStoreRecords;cacheStoreRecords=cache_store.objects().filter(' + \
                                    partitioncolstofilter[i] + '=datetime.strptime(\'' + \
                                    str((payLoad[partitioncolstofilter[i]])) + '\',\'%Y-%m-%dT%H:%M:%S%z\'));'
                            # return ((["0000"],query))
                        else:
                            query = 'global cacheStoreRecords;cacheStoreRecords=cache_store.objects().filter(' + \
                                    partitioncolstofilter[i] + '=\'' + str(payLoad[partitioncolstofilter[i]]) + '\');'
                    else:
                        if partitioncolstofilter[i] in datecolumns:
                            query = 'global cacheStoreRecords;cacheStoreRecords=cacheStoreRecords.filter(' + \
                                    partitioncolstofilter[i] + \
                                    '=datetime.strptime(\'' + str(
                                (payLoad[partitioncolstofilter[i]])) + '\',\'%Y-%m-%dT%H:%M:%S%z\'));'
                            # return ((["0000"],query))
                        else:
                            query = 'global cacheStoreRecords;cacheStoreRecords=cacheStoreRecords.filter(' + \
                                    partitioncolstofilter[i] + \
                                    '=\'' + str(payLoad[partitioncolstofilter[i]]) + '\');'

                    #return ((["0000"],query))
                    exec(query)
            else:
                for i in range(len(parametercolumns)):
                    for k, v in reversecolumnMapping.items():
                        if v == parametercolumns[i]:
                            parametercolumns[i] = k
                return (("200",("9003", "Invalid Arguments  passed to the API. Valid Arguments are " + ','.join(parametercolumns))))
        if len(cacheStoreRecords) == 0:
            return (("200",{}))  
            #return (("404", ("9007", "cache details could not be found.")))
            #return ((["9007"], "Details could not be found"))
        cacheStore = [row.__json__() for row in cacheStoreRecords]
        #return ((200,cacheStore))
        cacheStore = pd.DataFrame.from_dict((cacheStore), orient='columns')
        cacheStore.fillna('',inplace = True)
        if len(cacheStore)>0:
            for column in datecolumns:
                if column in cacheStore.columns.tolist():
                    cacheStore[column] = pd.to_datetime(cacheStore[column],unit='ns')
                    cacheStore[column] = cacheStore[column].dt.tz_localize('UTC').dt.tz_convert(configvalues.get('apiconfiguration','timeZone')).dt.strftime('%Y-%m-%dT%H:%M:%S.%f%z')
                #return (("404",("0000",cacheStore[column].to_list())))
                cacheStore[column] = [ "" if columnValue == "NaT" else columnValue for columnValue in cacheStore[column].to_list()]
                #return (("404",("0000",cacheStore[column].to_list())))
        cacheStore = cacheStore[validColumns]
        validColumns = {k: v for k, v in columnMapping.items() if k in validColumns}
        cacheStore = cacheStore.rename(columns=(validColumns))
        cacheStore = cacheStore.to_dict(orient='records')
        import unicodedata
        if len(cacheStore) > 0:
            #cacheStore = [ {k : ( unicodedata.normalize('NFC',v) if k == 'value' else v ) for k,v in x.items()} for x in cacheStore]
            cacheStore = [ {k : (v.encode().decode() if k == 'value' else v ) for k,v in x.items()} for x in cacheStore]
        logging.debug('cacheStore-'+str(cacheStore))
        response = {}
        response = response if len(cacheStore) == 0 else cacheStore[0] if len(cacheStore) == 1 else cacheStore

        logging.info("Completed fetching the records")
        gc.collect()
        return ((200,(response)))

    except Exception as e:
        gc.collect()
        logging.error("Error - {} . Line No - {} ".format(str(e), str(sys.exc_info()[-1].tb_lineno)))
        return (("500", "Technical exception"))