# Mongoose

const express = require("express");
const bodyParser = require("body-parser");
const mongoose = require("mongoose");

// Connect database
mongoose.connect(process.env.MONGODB, {
  useNewUrlParser: true
});

// Load your models
const { Project, Task } = require("./models");
const models = [Project, Task];

// Import Mongoose ApiPack
const { ApiPack } = require("@kolinalabs/api-pack-mongoose");

// Import ExpressJS ApiPack (router stack)
const RouterStack = require("@kolinalabs/api-pack-express");

// Instantiate + build routes
const apiPack = new ApiPack(models);
const routes = apiPack.routing(RouterStack);

const app = express();
app.use(bodyParser.json());
app.use("/api", routes);

app.listen(process.env.APP_PORT);

const Koa = require("koa");
const bodyParser = require("koa-bodyparser");
const mongoose = require("mongoose");

// Connect database
mongoose.connect(process.env.MONGODB, {
  useNewUrlParser: true
});

// Load your models
const { Project, Task } = require("./models");
const models = [Project, Task];

// Import Mongoose ApiPack
const { ApiPack } = require("@kolinalabs/api-pack-mongoose");

// Import KoaJS ApiPack (router stack)
const RouterStack = require("@kolinalabs/api-pack-koa");

// Instantiate + build routes
const apiPack = new ApiPack(models);
const routing = apiPack.routing(RouterStack);
routing.prefix("/api");

const app = new Koa();
app.use(bodyParser());
app.use(routing.routes());

app.listen(process.env.APP_PORT);

const mongoose = require("mongoose");

const TaskSchema = new mongoose.Schema({
  title: String,
  status: String,
  note: String,
  priority: Number,
  closed: Boolean,
  openedAt: Date,
  closedAt: Date
});

const Task = mongoose.model("Task", TaskSchema);

const ProjectSchema = new mongoose.Schema(
  {
    title: String,
    description: String,
    amount: Number,
    priority: Number,
    isPrivate: Boolean,
    isLocked: Boolean,
    status: String
  },
  {
    timestamps: true
  }
);

// ApiPack configuration
ProjectSchema.statics.ApiPack = function() {
  return {
    name: "AdvancedProject",
    description: "This is my project with advanced mode.",
    operations: {
      paginate: true,
      retrieve: true,
      create: true,
      update: true,
      remove: false // disable operation
    },
    pagination: {
      enabled: false // disable pagination
    },
    filters: {
      boolean: {
        properties: ["isPrivate", "isLocked"]
      },
      date: {
        properties: ["createdAt", "updatedAt"]
      },
      exists: {
        properties: ["status"]
      },
      numeric: {
        properties: ["amount", "priority"]
      },
      order: {
        properties: ["_id", "amount", "priority", "title"]
      },
      range: {
        properties: ["amount", "priority"]
      },
      search: {
        properties: ["title", "description", "status"]
      }
    }
  };
};

const Project = mongoose.model("Project", ProjectSchema);

schema.statics.ApiPack = function() {
  return {
    operations: ["paginate", "retrieve"]
  };
};

schema.statics.ApiPack = function() {
  return {
    operations: {
      paginate: true,
      retrieve: true,
      create: false,
      update: false,
      remove: false
    }
  };
};

const MyCustomSerializer = {
  serialize(operation) {
    // Your custom logic to add/remove/change
    // "operation.data" properties before response
  },
  deserialize(operation) {
    // Your custom logic to populate resource instance (operation.data)
  }
};

// Override apiPack default serializer
apiPack.serializers.splice(0, 1, MyCustomSerializer);

schema.statics.ApiPack = function() {
  return {
    filters: {
      boolean: {
        properties: ["enabled", "isLocked"]
      }
    }
  };
};

schema.statics.ApiPack = function() {
  return {
    filters: {
      date: {
        properties: ["createdAt", "updatedAt"]
      }
    }
  };
};

schema.statics.ApiPack = function() {
  return {
    filters: {
      date: {
        properties: {
          createdAt: "include_null",
          updatedAt: "include_null_before"
        }
      }
    }
  };
};

schema.statics.ApiPack = function() {
  return {
    filters: {
      exists: {
        properties: ["description", "status", "note"]
      }
    }
  };
};

schema.statics.ApiPack = function() {
  return {
    filters: {
      numeric: {
        properties: ["amount", "priority"]
      }
    }
  };
};

schema.statics.ApiPack = function() {
  return {
    filters: {
      order: {
        properties: ["amount", "priority", "title"]
      }
    }
  };
};

schema.statics.ApiPack = function() {
  return {
    filters: {
      order: {
        properties: {
          amount: "asc",
          priority: "desc",
          title: "asc"
        }
      }
    }
  };
};

schema.statics.ApiPack = function() {
  return {
    filters: {
      range: {
        properties: ["amount", "priority"]
      }
    }
  };
};

schema.statics.ApiPack = function() {
  return {
    filters: {
      search: {
        properties: {
          title: "ipartial",
          description: "partial",
          status: "exact"
        }
      }
    }
  };
};

schema.statics.ApiPack = function() {
  return {
    pagination: {
      enabled: true,
      pageParameter: "pg",
      clientEnabled: true,
      enabledParameter: "paging",
      itemsPerPage: 50,
      clientItemsPerPage: true,
      itemsPerPageParameter: "per_page",
      maxItemsPerPage: 100
    }
  };
};

const MyCustomExtension = {
  name: "MyCustomExtension",
  apply(query, operation) {
    // Your query increment logic
    // e.g.: query.where('property', 'value')
  }
};

apiPack.addExtension(MyCustomExtension);

const UserReferenceExtension = {
  name: "UserReferenceExtension",
  apply(query, operation) {
    /**
     * Note: The `api-pack-express` and` api-pack-koa` packages
     * include the `request` object automatically in the context of the operation.
     * If you are using a custom route stack, watch out for this detail.
     * See more about this in the referenced resource documentation.
     */

    // Retrieve the "userId" information
    const userId = operation.context.request.user.id;
    // Add query criteria
    query.where("userId", userId);
  }
};

const UserReferenceExtension = {
  name: "UserReferenceExtension",
  supports: ["collection:get", "put"]
  apply(query, operation) {
    // ....
  }
};

const UserReferenceExtension = {
  name: "UserReferenceExtension",
  supports(operation, query) {
    // The 'resource' is your model
    // Apply only if Model is "Project"
    return operation.resource.modelName === "Project";
  },
  apply(query, operation) {
    // ....
  }
};