nodedata/mongoose/mongoose-model.js

"use strict";
const Q = require('q');
const entity_change_1 = require('../core/enums/entity-change');
const model_entity_1 = require('../core/dynamic/model-entity');
const Enumerable = require('linq');
const winstonLog_1 = require('../logging/winstonLog');
const mongooseHelper = require('./mongoose-model-helper');
const CoreUtils = require("../core/utils");
const constants_1 = require('../core/constants');
const Utils = require('./utils');
const utils_1 = require("../core/metadata/utils");
const decorators_1 = require('../core/constants/decorators');
const dynamic_schema_1 = require('./dynamic-schema');
const instance_service_1 = require('../core/services/instance-service');
/**
 * Iterate through objArr and check if any child object need to be added. If yes, then add those child objects.
 * Bulk create these updated objects.
 * Usage - Post multiple objects parallely
 * @param model
 * @param objArr
 */
function bulkPost(model, objArr, batchSize) {
    if (!objArr) {
        return Q.when([]);
    }
    if (objArr && objArr.length <= 0) {
        return Q.when([]);
    }
    //console.log("bulkPost " + model.modelName);
    mongooseHelper.updateWriteCount();
    var addChildModel = [];
    // create all cloned models
    var clonedModels = [];
    let transientProps = mongooseHelper.getAllTransientProps(model);
    Enumerable.from(objArr).forEach(obj => {
        var cloneObj = mongooseHelper.removeGivenTransientProperties(model, obj, transientProps);
        cloneObj[constants_1.ConstantKeys.TempId] = cloneObj._id ? cloneObj._id : Utils.autogenerateIds(model);
        clonedModels.push(cloneObj);
    });
    return mongooseHelper.addChildModelToParent(model, clonedModels)
        .then(result => {
        // autogenerate ids of all the objects
        //Enumerable.from(clonedModels).forEach(clonedObj => {
        //    try {
        //        mongooseHelper.autogenerateIdsForAutoFields(model, clonedObj);
        //        //Object.assign(obj, clonedObj);
        //    } catch (ex) {
        //        winstonLog.logError(`Error in bulkPost ${ex}`);
        //        return Q.reject(ex);
        //    }
        //});
        var asyncCalls = [];
        if (!batchSize)
            batchSize = 1000;
        for (let curCount = 0; curCount < clonedModels.length; curCount += batchSize) {
            asyncCalls.push(executeBulk(model, clonedModels.slice(curCount, curCount + batchSize)));
        }
        return Q.allSettled(asyncCalls).then(suces => {
            let values = [];
            values = suces.map(x => x.value).reduce((prev, current) => {
                return prev.concat(current);
            });
            //console.log("bulkPost end" + model.modelName);
            return values;
        }).catch(er => {
            winstonLog_1.winstonLog.logError(`Error in bulkPost ${model.modelName}: ${er}`);
            throw er;
        });
    });
}
exports.bulkPost = bulkPost;
function executeBulk(model, arrayOfDbModels) {
    //console.log("start executeBulk post", model.modelName);
    let executeBulkPost = {};
    arrayOfDbModels.forEach(x => {
        if (x[constants_1.ConstantKeys.TempId]) {
            x._id = x[constants_1.ConstantKeys.TempId];
            delete x[constants_1.ConstantKeys.TempId];
        }
        mongooseHelper.setUniqueIdFromShard(x);
        mongooseHelper.setShardCondition(model, x);
        let newModel = mongooseHelper.getNewModelFromObject(model, x);
        if (!executeBulkPost[newModel.modelName]) {
            executeBulkPost[newModel.modelName] = { objs: [], model: newModel };
        }
        executeBulkPost[newModel.modelName].objs.push(x);
        if (!dynamic_schema_1._arrayPropListSchema[model.modelName]) {
            return;
        }
        // assign empty array for not defined properties
        dynamic_schema_1._arrayPropListSchema[model.modelName].forEach(prop => {
            if (!x[prop]) {
                x[prop] = [];
            }
        });
    });
    let asycnCalls = [];
    Object.keys(executeBulkPost).forEach(x => {
        asycnCalls.push(Q.nbind(executeBulkPost[x].model.collection.insertMany, executeBulkPost[x].model.collection)(executeBulkPost[x].objs));
    });
    //console.log("empty array executeBulk ", model.modelName);
    return Q.allSettled(asycnCalls).then(result => {
        //console.log("end executeBulk post", model.modelName);
        let values = [];
        values = result.map(x => x.value.ops).reduce((prev, current) => {
            return prev.concat(current);
        });
        return values;
    }).catch(err => {
        throw err;
    });
}
/**
 * Iterate through objArr and call put for these
 * Usage - Update multiple object sequentially
 * @param model
 * @param objArr
 */
function bulkPut(model, objArr, batchSize, donotLoadChilds) {
    if (!objArr || !objArr.length)
        return Q.when([]);
    //console.log("bulkPut " + model.modelName);
    mongooseHelper.updateWriteCount();
    var asyncCalls = [];
    var length = objArr.length;
    var ids = objArr.map(x => x._id);
    var bulk = model.collection.initializeUnorderedBulkOp();
    var asyncCalls = [];
    if (!batchSize) {
        asyncCalls.push(executeBulkPut(model, objArr, donotLoadChilds));
    }
    else {
        for (let curCount = 0; curCount < objArr.length; curCount += batchSize) {
            asyncCalls.push(executeBulkPut(model, objArr.slice(curCount, curCount + batchSize), donotLoadChilds));
        }
    }
    return Q.allSettled(asyncCalls).then(suces => {
        let values = [];
        values = suces.map(x => x.value).reduce((prev, current) => {
            return prev.concat(current);
        });
        //console.log("bulkPut end" + model.modelName);
        return values;
    }).catch(er => {
        winstonLog_1.winstonLog.logError(`Error in bulkPut ${model.modelName}: ${er}`);
        throw er;
    });
}
exports.bulkPut = bulkPut;
function executeBulkPut(model, objArr, donotLoadChilds) {
    let length = objArr.length;
    var asyncCalls = [];
    let fullyLoaded = objArr && objArr.length > 0 && objArr[0][constants_1.ConstantKeys.FullyLoaded];
    let updateParentRequired = [];
    var objectIds = [];
    //console.log("bulkPut addChildModelToParent child start" + model.modelName);
    let allUpdateProps = [];
    return mongooseHelper.addChildModelToParent(model, objArr).then(r => {
        //console.log("bulkPut addChildModelToParent child end" + model.modelName);
        let transientProps = mongooseHelper.getAllTransientProps(model);
        var metaArr = CoreUtils.getAllRelationsForTargetInternal(model_entity_1.getEntity(model.modelName));
        let isRelationsExist = false;
        if (metaArr && metaArr.length) {
            isRelationsExist = true;
        }
        //let updatePropsReq = !fullyLoaded || isRelationsExist;
        // check if not relationship present in the docs then do not call updateProps
        // 
        let allBulkExecute = {};
        for (let i = 0; i < objArr.length; i++) {
            let result = objArr[i];
            let newModel = mongooseHelper.getNewModelFromObject(model, result);
            var objectId = Utils.getCastObjectId(newModel, result._id);
            objectIds.push(objectId);
            let id = result._id;
            let parent = result.parent;
            if (!allBulkExecute[newModel.modelName]) {
                allBulkExecute[newModel.modelName] = newModel.collection.initializeUnorderedBulkOp();
            }
            let bulk = allBulkExecute[newModel.modelName];
            delete result._id;
            delete result[constants_1.ConstantKeys.FullyLoaded];
            for (let prop in transientProps) {
                delete result[transientProps[prop].propertyKey];
            }
            var updatedProps;
            updatedProps = Utils.getUpdatedProps(result, entity_change_1.EntityChange.put);
            // //console.log("update props", updatedProps);
            delete result.__dbEntity;
            // update only modified objects
            if (Object.keys(updatedProps).length === 0) {
                continue;
            }
            updateParentRequired.push(objectId);
            //if (updatePropsReq) {
            //    updatedProps = Utils.getUpdatedProps(result, EntityChange.put);
            //    // update only modified objects
            //    if (Object.keys(updatedProps).length === 0) {
            //        continue;
            //    }
            //}
            let isDecoratorPresent = isDecoratorApplied(model, decorators_1.Decorators.OPTIMISTICLOCK, "put");
            let query = { _id: objectId };
            if (isDecoratorPresent === true) {
                updatedProps["$set"] && delete updatedProps["$set"]["__v"];
                updatedProps["$inc"] = { '__v': 1 };
                query["__v"] = result["__v"];
            }
            bulk.find(mongooseHelper.setShardCondition(model, { _id: objectId })).update(updatedProps);
        }
        let asyncCalls = [];
        //let promBulkUpdate = Q.when({});
        //console.log("bulkPut bulk.execute start" + model.modelName);
        if (updateParentRequired.length > 0) {
            Object.keys(allBulkExecute).forEach(x => {
                let bulk = allBulkExecute[x];
                asyncCalls.push(Q.nbind(bulk.execute, bulk)());
            });
        }
        return Q.allSettled(asyncCalls).then(result => {
            //return promBulkUpdate.then(result => {
            //console.log("bulkPut bulk.execute end" + model.modelName);
            // update parent
            let repo = model_entity_1.repoFromModel[model.modelName];
            let prom;
            if (fullyLoaded) {
                // remove eagerloading propeties because it will be used for updating parent
                // validate that no one have tampered the new persistent entity
                prom = Q.when(objArr);
                objectIds.forEach((id, index) => {
                    objArr[index]['_id'] = id;
                });
            }
            else {
                prom = findMany(model, objectIds);
            }
            return prom.then((objects) => {
                let updateParentProm = Q.when([]);
                // if (updateParentRequired.length > 0) {
                //     let updateObject = [];
                //     updateParentRequired.forEach(x => {
                //         updateObject.push(objects.find(obj => obj._id.toString() == x));
                //     });
                //     updateParentProm = mongooseHelper.updateParent(model, updateObject);
                // }
                if (updateParentRequired.length > 0) {
                    let updateObject = [];
                    let newObjectsMap = {};
                    objects.forEach(x => {
                        newObjectsMap[x._id.toString()] = x;
                    });
                    updateParentRequired.forEach(x => {
                        if (newObjectsMap[x]) {
                            updateObject.push(newObjectsMap[x]);
                        }
                    });
                    updateParentProm = mongooseHelper.updateParent(model, updateObject);
                }
                return updateParentProm.then(res => {
                    //console.log("bulkPut updateParent start" + model.modelName);
                    if (donotLoadChilds === true) {
                        return Q.when(objects);
                    }
                    return mongooseHelper.fetchEagerLoadingProperties(model, objects).then(resultObject => {
                        return resultObject;
                    });
                });
            });
        });
    }).catch(error => {
        winstonLog_1.winstonLog.logError(`Error in executeBulkPut ${model.modelName}: ${error}`);
        return Q.reject(error);
    });
}
/**
 * Iterate through objArr and call put for these
 * Usage - Update multiple object sequentially
 * @param model
 * @param objArr
 */
function bulkPatch(model, objArr) {
    if (!objArr || !objArr.length)
        return Q.when([]);
    //console.log("bulkPatch " + model.modelName);
    mongooseHelper.updateWriteCount();
    var asyncCalls = [];
    var length = objArr.length;
    var ids = objArr.map(x => x._id);
    var asyncCalls = [];
    return mongooseHelper.addChildModelToParent(model, objArr).then(x => {
        let transientProps = mongooseHelper.getAllTransientProps(model);
        let jsonProps = mongooseHelper.getEmbeddedPropWithFlat(model).map(x => x.propertyKey);
        //it has to be group by
        let allBulkExecute = {};
        objArr.forEach(result => {
            var objectId = Utils.getCastObjectId(model, result._id);
            let newModel = mongooseHelper.getNewModelFromObject(model, result);
            if (!allBulkExecute[newModel.modelName]) {
                allBulkExecute[newModel.modelName] = newModel.collection.initializeUnorderedBulkOp();
            }
            let bulk = allBulkExecute[newModel.modelName];
            delete result._id;
            for (let prop in transientProps) {
                delete result[transientProps[prop].propertyKey];
            }
            var updatedProps = Utils.getUpdatedProps(result, entity_change_1.EntityChange.patch, jsonProps);
            let isDecoratorPresent = isDecoratorApplied(model, decorators_1.Decorators.OPTIMISTICLOCK, "patch");
            let query = { _id: objectId };
            if (isDecoratorPresent === true) {
                updatedProps["$set"] && delete updatedProps["$set"]["__v"];
                updatedProps["$inc"] = { '__v': 1 };
                query["__v"] = result["__v"];
            }
            bulk.find(mongooseHelper.setShardCondition(model, query)).update(updatedProps);
        });
        let asyncCalls = [];
        Object.keys(allBulkExecute).forEach(x => {
            let bulk = allBulkExecute[x];
            asyncCalls.push(Q.nbind(bulk.execute, bulk)());
        });
        return Q.allSettled(asyncCalls).then(result => {
            // update parent
            return findMany(model, ids).then((objects) => {
                return mongooseHelper.updateParent(model, objects).then(res => {
                    return mongooseHelper.fetchEagerLoadingProperties(model, objects).then(resultObject => {
                        //console.log("bulkPatch end" + model.modelName);
                        return resultObject;
                    });
                });
            });
        }).catch(error => {
            winstonLog_1.winstonLog.logError(`Error in bulkPatch ${model.modelName}: ${error}`);
            return Q.reject(error);
        });
    });
}
exports.bulkPatch = bulkPatch;
/**
 * Bulk update objects. Find updated objects, and update the parent docs
 * Usage - Update multiple objects parallely with same porperty set
 * @param model
 * @param objIds
 * @param obj
 */
function bulkPutMany(model, objIds, obj) {
    if (!objIds || !objIds.length)
        return Q.when([]);
    //console.log("bulkPutMany " + model.modelName);
    mongooseHelper.updateWriteCount();
    delete obj._id;
    let clonedObj = mongooseHelper.removeTransientProperties(model, obj);
    // First update the any embedded property and then update the model
    var cond = {};
    cond['_id'] = {
        $in: objIds
    };
    cond = mongooseHelper.setShardCondition(model, cond);
    var updatedProps = Utils.getUpdatedProps(clonedObj, entity_change_1.EntityChange.put);
    let newModels = mongooseHelper.getAllShardModelsFromIds(model, objIds);
    let asyncCalls = [];
    Object.keys(newModels).forEach(x => {
        asyncCalls.push(Q.nbind(newModels[x].update, newModels[x])(cond, updatedProps, { multi: true }));
    });
    return Q.allSettled(asyncCalls)
        .then(result => {
        let allReferencingEntities = CoreUtils.getAllRelationsForTarget(model_entity_1.getEntity(model.modelName));
        let ref = allReferencingEntities.find((x) => x.params && x.params.embedded);
        if (ref) {
            return findMany(model, objIds).then((objects) => {
                return mongooseHelper.updateParent(model, objects).then(res => {
                    //console.log("bulkPutMany end" + model.modelName);
                    return objects;
                });
            });
        }
        else {
            //console.log("bulkPutMany end" + model.modelName);
            return result;
        }
    }).catch(error => {
        winstonLog_1.winstonLog.logError(`Error in bulkPutMany ${model.modelName}: ${error}`);
        return Q.reject(error);
    });
}
exports.bulkPutMany = bulkPutMany;
/**
 * Usage - Find all the objects
 * @param model
 */
function findAll(model) {
    //console.log("findAll " + model.modelName);
    return model.find(mongooseHelper.setShardCondition(model, {})).lean().then(result => {
        //console.log("findAll end" + model.modelName);
        return result;
    }).catch(error => {
        winstonLog_1.winstonLog.logError(`Error in findAll ${model.modelName}: ${error}`);
        return Q.reject(error);
    });
}
exports.findAll = findAll;
/**
 * Query collection and then populate child objects with relationship
 * Usage - Search object with given condition
 * @param model
 * @param query
 */
function countWhere(model, query) {
    if (Object.keys(query).length == 0) {
        return Q.nbind(model.collection.stats, model.collection)().then((result) => {
            return Q.resolve(result.count);
        });
    }
    let queryObj = model.find(mongooseHelper.setShardCondition(model, query)).count();
    //winstonLog.logInfo(`findWhere query is ${query}`);
    return Q.nbind(queryObj.exec, queryObj)()
        .then(result => {
        // update embedded property, if any
        return Q.resolve(result);
    }).catch(error => {
        winstonLog_1.winstonLog.logError(`Error in countWhere ${model.modelName}: ${error}`);
        return Q.reject(error);
    });
}
exports.countWhere = countWhere;
function distinctWhere(model, query) {
    let queryObj = model.find(mongooseHelper.setShardCondition(model, query)).distinct();
    //winstonLog.logInfo(`findWhere query is ${query}`);
    return Q.nbind(queryObj.exec, queryObj)()
        .then(result => {
        // update embedded property, if any
        return Q.resolve(result);
    }).catch(error => {
        winstonLog_1.winstonLog.logError(`Error in distinctWhere ${model.modelName}: ${error}`);
        return Q.reject(error);
    });
}
exports.distinctWhere = distinctWhere;
/**
 * Query collection and then populate child objects with relationship
 * Usage - Search object with given condition
 * @param model
 * @param query
 * @param select {Array<string> | any} In case it is an array of string, it selects the specified keys mentioned in the array. In case  it is an Object, it sets the JS object as the projection key
 * @param sort
 * @param skip
 * @param limit
 */
function findWhere(model, query, select, queryOptions, toLoadChilds, sort, skip, limit) {
    //console.log("findWhere " + model.modelName);
    let lt, gt, lte, gte, lt_value, lte_value, gt_value, gte_value;
    var sel = {};
    let order = undefined;
    if (select instanceof Array) {
        select.forEach(x => {
            sel[x] = 1;
        });
    }
    else if (select) {
        sel = select;
    }
    if (queryOptions) {
        if (queryOptions.limit != null)
            limit = Number.parseInt(queryOptions.limit.toString());
        if (queryOptions.skip != null)
            skip = Number.parseInt(queryOptions.skip.toString());
        if (queryOptions.lt != null) {
            lt = queryOptions.lt;
        }
        if (queryOptions.gt != null) {
            gt = queryOptions.gt;
        }
        if (queryOptions.lt_value != null) {
            lt_value = Number.parseInt(queryOptions.lt_value);
        }
        if (queryOptions.gt_value != null) {
            gt_value = Number.parseInt(queryOptions.gt_value);
        }
        if (queryOptions.lt != null) {
            lte = queryOptions.lte;
        }
        if (queryOptions.gt != null) {
            gte = queryOptions.gte;
        }
        if (queryOptions.lt_value != null) {
            lte_value = Number.parseInt(queryOptions.lte_value);
        }
        if (queryOptions.gt_value != null) {
            gte_value = Number.parseInt(queryOptions.gte_value);
        }
        if (queryOptions.sort != null) {
            sort = queryOptions.sort;
            if (queryOptions.order != null && queryOptions.order === 'desc') {
                let descSort = {};
                descSort[sort] = -1;
                sort = descSort;
            }
        }
    }
    let newModels = {};
    let obj = instance_service_1.InstanceService.getInstanceFromType(model_entity_1.getEntity(model.modelName), true);
    if (obj.getShardKey) {
        let key = obj.getShardKey();
        if (query[key]) {
            if (CoreUtils.isJSON(query[key])) {
                if (query[key]['$in']) {
                    query[key]['$in'].forEach(x => {
                        let newModel = mongooseHelper.getChangedModelForDynamicSchema(model, x);
                        newModels[newModel.modelName] = newModel;
                    });
                }
            }
            else {
                // get shard collection 
                let newModel = mongooseHelper.getChangedModelForDynamicSchema(model, query[key]);
                newModels[newModel.modelName] = newModel;
            }
        }
        if (Object.keys(newModels).length == 0) {
            // find all the collection name and execute the query
            mongooseHelper.getAllTheShards(model).forEach(x => {
                newModels[x.modelName] = x;
            });
        }
    }
    else {
        newModels[model.modelName] = model;
    }
    let asyncCalls = [];
    Object.keys(newModels).forEach(x => {
        let queryObj = newModels[x].find(mongooseHelper.setShardCondition(model, query), sel).lean();
        if (sort) {
            queryObj = queryObj.sort(sort);
        }
        if (skip) {
            queryObj = queryObj.skip(skip);
        }
        if (limit) {
            queryObj = queryObj.limit(limit);
        }
        if (gt && gt_value != undefined) {
            queryObj = queryObj.gt(gt, gt_value);
        }
        if (lt && lt_value != undefined) {
            queryObj = queryObj.lt(lt, lt_value);
        }
        if (gte && gte_value != undefined) {
            queryObj = queryObj.gte(gte, gte_value);
        }
        if (lte && lte_value != undefined) {
            queryObj = queryObj.lte(lte, lte_value);
        }
        asyncCalls.push(Q.nbind(queryObj.exec, queryObj)());
    });
    return Q.allSettled(asyncCalls).then(res => {
        let result = [];
        result = res.map(x => x.value).reduce((prev, current) => {
            return prev.concat(current);
        });
        //winstonLog.logInfo(`findWhere query is ${query}`);
        // update embedded property, if any
        if (toLoadChilds != undefined && toLoadChilds == false) {
            mongooseHelper.transformAllEmbeddedChildern1(model, result);
            //console.log("findWhere end" + model.modelName);
            return result;
        }
        var asyncCalls = [];
        asyncCalls.push(mongooseHelper.embeddedChildren1(model, result, false));
        return Q.allSettled(asyncCalls).then(r => {
            //console.log("findWhere end" + model.modelName);
            return result;
        });
    }).catch(error => {
        winstonLog_1.winstonLog.logError(`Error in findWhere ${model.modelName}: ${error}`);
        return Q.reject(error);
    });
    // winstonLog.logInfo(`findWhere query is ${query}`);
    // return Q.nbind(model.find, model)(query)
    //     .then(result => {
    //         return toObject(result);
    //     }).catch(error => {
    //         winstonLog.logError(`Error in findWhere ${error}`);
    //         return error;
    //     });
}
exports.findWhere = findWhere;
/**
 * Usage - find object with given object id
 * @param model
 * @param id
 */
function findOne(model, id, donotLoadChilds) {
    //console.log("findOne " + model.modelName);
    let newModel = mongooseHelper.getChangedModelForDynamicSchema(model, id);
    return newModel.findOne(mongooseHelper.setShardCondition(model, { '_id': id })).lean().then(result => {
        return mongooseHelper.embeddedChildren1(model, [result], false, donotLoadChilds)
            .then(r => {
            //console.log("findOne end" + model.modelName);
            return result;
        });
    }).catch(error => {
        winstonLog_1.winstonLog.logError(`Error in findOne ${model.modelName}: ${error}`);
        return Q.reject(error);
    });
}
exports.findOne = findOne;
/**
 * Usage - find the object with given {property : value}
 * @param model
 * @param fieldName
 * @param value
 */
function findByField(model, fieldName, value) {
    //console.log("findByField " + model.modelName);
    var param = {};
    param[fieldName] = value;
    return model.findOne(mongooseHelper.setShardCondition(model, param)).lean().then(result => {
        return mongooseHelper.embeddedChildren1(model, [result], false)
            .then(r => {
            //console.log("findByField end" + model.modelName);
            return result;
        });
    }, err => {
        winstonLog_1.winstonLog.logError(`Error in findByField ${model.modelName}: ${err}`);
        return Q.reject(err);
    });
}
exports.findByField = findByField;
/**
 * Usage - Find all the objects with given ids
 * @param model
 * @param ids
 */
function findMany(model, ids, toLoadEmbeddedChilds) {
    if (!ids || !ids.length)
        return Q.when([]);
    //console.log("findMany " + model.modelName);
    if (toLoadEmbeddedChilds == undefined) {
        toLoadEmbeddedChilds = false;
    }
    let newModels = mongooseHelper.getAllShardModelsFromIds(model, ids);
    let asyncCalls = [];
    Object.keys(newModels).forEach(x => {
        asyncCalls.push(newModels[x].find(mongooseHelper.setShardCondition(model, {
            '_id': {
                $in: ids.map(x => Utils.getCastObjectId(model, x))
            }
        })).lean());
    });
    return Q.allSettled(asyncCalls).then(res => {
        let result = [];
        result = res.map(x => x.value).reduce((prev, current) => {
            return prev.concat(current);
        });
        if (result.length !== ids.length) {
            let oneId = "";
            if (ids && ids.length) {
                oneId = ids[0];
            }
            var error = 'findmany - numbers of items found:' + result.length + 'number of items searched: ' + ids.length + ' for model: ' + model.modelName + ' one of the id searched is: ' + oneId;
            winstonLog_1.winstonLog.logError(`Error in findMany ${error}`);
            return Q.reject(error);
        }
        if (toLoadEmbeddedChilds) {
            let asyncCalls = [];
            asyncCalls.push(mongooseHelper.embeddedChildren1(model, result, false));
            //console.log("findMany end" + model.modelName);
            return Q.allSettled(asyncCalls).then(r => {
                return result;
            });
        }
        else {
            mongooseHelper.transformAllEmbeddedChildern1(model, result);
            //console.log("findMany end" + model.modelName);
            return result;
        }
    }).catch(error => {
        winstonLog_1.winstonLog.logError(`Error in findMany ${model.modelName}: ${error}`);
        return Q.reject(error);
    });
}
exports.findMany = findMany;
/**
 * find object with the given id.
 * Check if property has a relationship. If yes, then find all the child objects and return child
 * @param model
 * @param id
 * @param prop
 */
function findChild(model, id, prop) {
    //console.log("findChild " + model.modelName);
    let newModel = mongooseHelper.getChangedModelForDynamicSchema(model, id);
    return newModel.findOne(mongooseHelper.setShardCondition(model, { '_id': id })).lean().then(res => {
        var metas = CoreUtils.getAllRelationsForTargetInternal(model_entity_1.getEntity(model.modelName));
        if (Enumerable.from(metas).any(x => x.propertyKey == prop)) {
            // create new object and add only that property for which we want to do eagerloading
            var result = {};
            result[prop] = res;
            return mongooseHelper.embeddedChildren1(model, [result], true)
                .then(r => {
                //console.log("findChild end" + model.modelName);
                return result[prop];
            });
        }
        //console.log("findChild end" + model.modelName);
        return res;
    }).catch(error => {
        winstonLog_1.winstonLog.logError(`Error in findChild ${model.modelName}: ${error}`);
        return Q.reject(error);
    });
}
exports.findChild = findChild;
/**
 * case 1: all new - create main item and child separately and embed if true
 * case 2: some new, some update - create main item and update/create child accordingly and embed if true
 * @param obj
 */
function post(model, obj) {
    //console.log("post " + model.modelName);
    mongooseHelper.updateWriteCount();
    let clonedObj = mongooseHelper.removeTransientProperties(model, obj);
    clonedObj[constants_1.ConstantKeys.TempId] = clonedObj._id ? clonedObj._id : Utils.autogenerateIds(model);
    return mongooseHelper.addChildModelToParent(model, [clonedObj])
        .then(result => {
        //try {
        //    mongooseHelper.autogenerateIdsForAutoFields(model, clonedObj);
        //    //Object.assign(obj, clonedObj);
        //} catch (ex) {
        //    //console.log(ex);
        //    return Q.reject(ex);
        //}
        if (clonedObj[constants_1.ConstantKeys.TempId]) {
            clonedObj._id = clonedObj[constants_1.ConstantKeys.TempId];
            delete clonedObj[constants_1.ConstantKeys.TempId];
        }
        mongooseHelper.setUniqueIdFromShard(clonedObj);
        mongooseHelper.setShardCondition(model, clonedObj);
        // assign empty array for not defined properties
        if (dynamic_schema_1._arrayPropListSchema[model.modelName]) {
            dynamic_schema_1._arrayPropListSchema[model.modelName].forEach(prop => {
                if (!clonedObj[prop]) {
                    clonedObj[prop] = [];
                }
            });
        }
        let newModel = mongooseHelper.getNewModelFromObject(model, clonedObj);
        return Q.nbind(newModel.create, newModel)(clonedObj).then(result => {
            let resObj = Utils.toObject(result);
            Object.assign(obj, resObj);
            return mongooseHelper.embeddedChildren1(model, [obj], false)
                .then(r => {
                //console.log("post end " + model.modelName);
                return obj;
            });
        });
    }).catch(error => {
        winstonLog_1.winstonLog.logError(`Error in post ${model.modelName}: ${error}`);
        return Q.reject(error);
    });
}
exports.post = post;
/**
 * Delete object with given id. Check if, any children have deletecase=true, then delete children from master table
 * Update parent document for all the deleted objects
 * Usage - Delete object given id
 * @param model
 * @param id
 */
function del(model, id) {
    //console.log("delete " + model.modelName);
    let newModel = mongooseHelper.getChangedModelForDynamicSchema(model, id);
    return newModel.findByIdAndRemove(mongooseHelper.setShardCondition(model, { '_id': id })).lean().then((response) => {
        return mongooseHelper.deleteCascade(model, [response]).then(x => {
            return mongooseHelper.deleteEmbeddedFromParent(model, entity_change_1.EntityChange.delete, [response])
                .then(res => {
                //console.log("delete end" + model.modelName);
                return ({ delete: 'success' });
            });
        });
    })
        .catch(err => {
        winstonLog_1.winstonLog.logError(`delete failed ${model.modelName}: ${err}`);
        return Q.reject({ delete: 'failed', error: err });
    });
}
exports.del = del;
/**
 * Sequetially delete the objects
 * @param modelte
 * @param ids
 */
function bulkDel(model, objs) {
    //console.log("bulkDel " + model.modelName);
    var asyncCalls = [];
    var ids = [];
    Enumerable.from(objs).forEach(x => {
        if (CoreUtils.isJSON(x)) {
            ids.push(x._id);
        }
        else {
            ids.push(x);
        }
    });
    if (!ids || !ids.length)
        return Q.when([]);
    let newModels = mongooseHelper.getAllShardModelsFromIds(model, ids);
    Object.keys(newModels).forEach(x => {
        asyncCalls.push(newModels[x].find(mongooseHelper.setShardCondition(model, {
            '_id': {
                $in: ids
            }
        })).lean());
    });
    return Q.allSettled(asyncCalls).then(res => {
        let parents = [];
        parents = res.map(x => x.value).reduce((prev, current) => {
            return prev.concat(current);
        });
        asyncCalls = [];
        Object.keys(newModels).forEach(x => {
            asyncCalls.push(Q.nbind(newModels[x].remove, newModels[x])(mongooseHelper.setShardCondition(model, {
                '_id': {
                    $in: ids
                }
            })));
        });
        return Q.allSettled(asyncCalls).then(result => {
            return mongooseHelper.deleteCascade(model, parents).then(success => {
                let asyncCalls = [];
                return mongooseHelper.deleteEmbeddedFromParent(model, entity_change_1.EntityChange.delete, parents).then(x => {
                    //console.log("bulkDel end" + model.modelName);
                    return ({ delete: 'success' });
                });
            });
        }).catch(err => {
            winstonLog_1.winstonLog.logError(`bulkDel failed ${model.modelName}: ${err}`);
            return Q.reject('bulkDel failed');
        });
    });
}
exports.bulkDel = bulkDel;
/**
 * Check if any child object need to be added, if yes, then add those child objects.
 * update the object with propertie. And then update the parent objects.
 * Usage - Update the object with given object id
 * @param model
 * @param id
 * @param obj
 */
function put(model, id, obj) {
    //console.log("put " + model.modelName);
    // Mayank - Check with suresh how to reject the changes in optimistic locking
    return bulkPut(model, [obj]).then((res) => {
        if (res.length) {
            //this merging is wrong, as we cannnot send transient props in API rsult.Inconsistency @Ratnesh sugestion
            Object.assign(obj, res[0]);
            //console.log("put end" + model.modelName);
            return obj;
        }
        //console.log("put end" + model.modelName);
        return [];
    }).catch(error => {
        winstonLog_1.winstonLog.logError(`Error in put ${model.modelName}: ${error}`);
        return Q.reject(error);
    });
}
exports.put = put;
/**
 * Check if any child object need to be added, if yes, then add those child objects.
 * update the object with propertie. And then update the parent objects.
 * Usage - Update the object with given object id
 * @param model
 * @param id
 * @param obj
 */
function patch(model, id, obj) {
    //console.log("patch " + model.modelName);
    // need to set id in case id is not supplied in patched obj
    obj._id = id;
    // Mayank - Check with suresh how to reject the changes in optimistic locking
    return bulkPatch(model, [obj]).then((res) => {
        if (res.length)
            return res[0];
        return [];
    }).catch(error => {
        winstonLog_1.winstonLog.logError(`Error in patch ${model.modelName}: ${error}`);
        return Q.reject(error);
    });
}
exports.patch = patch;
/**
 * Check whether decorator is applied or not.
 * @param path
 * @param decorator
 * @param propertyKey
 */
function isDecoratorApplied(model, decorator, propertyKey) {
    var isDecoratorPresent = false;
    let repo = model_entity_1.repoFromModel[model.modelName];
    var repoEntity = repo && repo.getEntityType();
    var optimisticLock = repoEntity && utils_1.MetaUtils.getMetaData(repoEntity, decorator, propertyKey);
    if (optimisticLock) {
        isDecoratorPresent = true;
    }
    return isDecoratorPresent;
}

//# sourceMappingURL=mongoose-model.js.map