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))
        datecolumns.append('createdtime')  # Add 'createdtime' column
        validArguments = json.loads(configvalues.get('apiconfiguration', 'validArguments', raw=True))
        logging.debug('Arguments -' + str(payLoad))

        for k, v in reversecolumnMapping.items():
            if k in list(payLoad.keys()):
                payLoad[v] = payLoad.pop(k)

        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

        if not bool(payLoad):
            return (("200", "Parameters need to be passed to fetch values from the cache store"))

        if set(list(payLoad.keys())).issubset(validArguments):
            for i in range(len(partitioncolumns)):
                if partitioncolumns[i] in list(payLoad.keys()):
                    if partitioncolumns[i] in datecolumns:
                        query = 'global cacheStoreRecords;cacheStoreRecords=cache_store.objects().filter(' + \
                            partitioncolumns[i] + '=datetime.strptime(\'' + \
                            str(payLoad[partitioncolumns[i]]) + '\',\'%Y-%m-%d\'));'
                    else:
                        query = 'global cacheStoreRecords;cacheStoreRecords=cache_store.objects().filter(' + \
                            partitioncolumns[i] + '=\'' + str(payLoad[partitioncolumns[i]]) + '\');'
                    exec(query)
        else:
            return (("200", ("9003", "Invalid arguments passed to the API. Valid arguments are " + ', '.join(validArguments))))

        if len(cacheStoreRecords) == 0:
            return (("200", {}))

        cacheStore = [row.__json__() for row in cacheStoreRecords]
        cacheStore = pd.DataFrame.from_dict(cacheStore, orient='columns')

        if len(cacheStore) > 0:
            cacheStore = cacheStore.applymap(lambda x: '' if pd.isnull(x) else x)
            cacheStore = cacheStore[validColumns]

        return (("200", cacheStore))

    except Exception as e:
        logging.error(str(sys.exc_info()[0]) + " - " + str(e))
        return (("400", ("9001", "Unable to fetch values from the cache store")))

    finally:
        cacheStoreRecords = None
        cacheStore = None
        recs = None
        partitioncolumns = None
        indexedcolumns = None
        gc.collect()