var dbInit=require("../config/dbInit");

module.exports.getNamespaces = function getNamespaces(callback){
    dbInit.getDB(function (err, pdb, model) {
        if (err)
            throw err;
        else{
            model.namespace.all(function (err, namespaceResult) {
                if (err)
                    callback(err, null);
                else
                    callback(null, namespaceResult);
            });
        }
    });
};

module.exports.getNamespacesForUser = function getNamespacesForUser(username, callback, namespacesFromGroup){
    dbInit.getDB(function (err, pdb, model) {
        if (err)
            throw err;
        else{
            console.log(username);
            model.permissionsNamespace.find({username: username}, function (err, permissions){
                if (err)
                    callback(err, null);
                else{
                    var namespaces = [];
                    if (namespacesFromGroup && namespacesFromGroup.length) namespaces = namespacesFromGroup;
                    permissions.forEach(function(permission){
                        if (namespaces.indexOf(permission.namespace) == -1)
                            namespaces.push(permission.namespace);
                    });
                    model.namespace.find({namespace: namespaces}, function (err, namespaceResult) {
                        if (err)
                            callback(err, null);
                        else
                            callback(null, namespaceResult);
                    });
                }
            });
        }
    });
};

module.exports.getNamespace = function getNamespace(id, callback){
    dbInit.getDB(function (err, pdb, model) {
        if (err)
            throw err;
        else{
            model.namespace.find({namespace: id},function (err, namespaceResult) {
                if (err)
                    callback(err, null);
                else{
                    model.partitions.find({namespace: id},function (err, partitionsResult) {
                        if (err)
                            callback(err, null);
                        else{
                            if (namespaceResult[0]){
                                namespaceResult[0].partitions = partitionsResult;
                                callback(null, namespaceResult);
                            }else
                                callback(null, []);
                        }
                    });
                }
            });
        }
    });
};

module.exports.createNamespace = function createNamespace(objNamespace, callback){
    dbInit.getDB(function (err, pdb, model) {
        if (err)
            throw err;
        else{
            var partitionsOfObj = objNamespace.partitions;
            model.namespace.create(objNamespace, function (err) {
                if (err)
                    callback(err);
                else{
                    var partitions = [];
                    if (partitionsOfObj && partitionsOfObj.length)
                        partitions = partitionsOfObj;
                    else{
                        if (objNamespace.namespace==0){
                            partitions = [{
                                namespace: objNamespace.namespace,
                                partitionId: "00",
                                sequence: 0
                            }, {
                                namespace: objNamespace.namespace,
                                partitionId: "01",
                                sequence: 0
                            }, {
                                namespace: objNamespace.namespace,
                                partitionId: "02",
                                sequence: 0
                            }];
                        }else {
                            partitions = [{
                                namespace: objNamespace.namespace,
                                partitionId: "10",
                                sequence: 0
                            }, {
                                namespace: objNamespace.namespace,
                                partitionId: "11",
                                sequence: 0
                            }, {
                                namespace: objNamespace.namespace,
                                partitionId: "12",
                                sequence: 0
                            }];
                        }
                    }
                    model.partitions.create(partitions, function (err) {
                        if (err)
                            callback(err);
                        else
                            callback(null);
                    });
                }
            });
        }
    });
};

module.exports.editPartition = function editPartition(ids, editedSequence, callback) {
    dbInit.getDB(function (err, pdb, model) {
        if (err)
            throw err;
        else{
            model.partitions.get(ids, function(err, partition) {
                if (err)
                    callback(err);
                else{
                    partition.sequence = editedSequence;
                    partition.save(function(err){
                        if (err)
                            callback(err);
                        else
                            callback(null);
                    });
                }
            });
        }
    });
};

module.exports.editNamespace = function editNamespace(id, editedNamespace, callback) {
    dbInit.getDB(function (err, pdb, model) {
        if (err)
            throw err;
        else{
            model.namespace.get(id, function(err, namespace) {
                if (err)
                    callback(err);
                else{
                    namespace.organizationName =editedNamespace.organizationName;
                    namespace.email =editedNamespace.email;
                    namespace.dateIssued =editedNamespace.dateIssued;
                    namespace.organizationAndContactDetails =editedNamespace.organizationAndContactDetails;
                    namespace.notes =editedNamespace.notes;
                    namespace.save(function(err){
                        if (err)
                            callback(err);
                        else
                            callback(null);
                    });
                }
            });
        }
    });
};

module.exports.deleteNamespace = function deleteNamespace(id, callback){
    dbInit.getDB(function (err, pdb, model) {
        if (err)
            throw err;
        else{
            model.namespace.find({namespace: id}).remove(function(err) {
                if (err)
                    callback(err);
                else{
                    model.partitions.find({namespace: id}).remove(function(err) {
                        if (err)
                            callback(err);
                        else
                            callback(null);
                    });
                }
            });
        }
    });
};

module.exports.getPermissions = function getPermissions(namespaceId, callback){
    dbInit.getDB(function (err, pdb, model) {
        if (err)
            throw err;
        else{
            model.permissionsNamespace.find({namespace: namespaceId}, function (err, permissions) {
                if (err)
                    callback(err, null);
                else
                    callback(null, permissions);
            });
        }
    });
};

module.exports.createPermission = function createPermission(permission, callback){
    dbInit.getDB(function (err, pdb, model) {
        if (err)
            throw err;
        else{
            model.permissionsNamespace.create(permission, function (err) {
                if (err)
                    callback(err);
                else
                      callback(null);
            });
        }
    });
};

module.exports.deletePermission = function deletePermission(namespaceId, username, callback){
    dbInit.getDB(function (err, pdb, model) {
        if (err)
            throw err;
        else{
            model.permissionsNamespace.find({namespace: namespaceId, username: username}).remove(function(err) {
                if (err)
                    callback(err);
                else
                    callback(null);
            });
        }
    });
};
@@ -645,32 +645,81 @@
 ;%0A        else%7B%0A
+            console.log(%22getNamespacesForUser%22);%0A
             cons

Test new group permissions