var express = require('express');

var router = express.Router();

var multer = require('multer');

var achivement = require('../Models/achivement');

var Area = require('../Models/areaMaster');
var User = require('../Models/B_Usermaster');
var Billboard = require('../Models/Billboard');
var billboardSchedule = require('../Models/billboardSchedule')
var booking = require('../Models/bookingMaster');
var carrier = require('../Models/carrierMaster');
var City = require('../Models/cityMaster');
var client = require('../Models/clientPartner');
var CSR = require('../Models/corporateSocialresponsibility');
var Feedback = require('../Models/Feedback');
var Gallery = require('../Models/Gallery');
var image = require('../Models/image');
var offer = require('../Models/offer');
var pRent = require('../Models/propertyRent');
var service = require('../Models/serviceMaster');
var sProvider = require('../Models/serviceProvider');
var subservice = require('../Models/subserviceMaster');

const { body } = require('express-validator');

var storage = multer.diskStorage({

destination: function (req, res, cb) {
var docimg=req.body.docimg;
if(docimg=="PropertyImage")
{
cb(null, './public/upload/PropertyImage')
}else if(docimg=="PropertyTypeImage"){
cb(null, './public/upload/PropertyTypeImage')
}else if(docimg=="PropertyImages"){
cb(null, './public/upload/PropertyImages')
}else if(docimg=="UserImage"){
cb(null, './public/upload/UserImage')
}
else{
cb(null, './public/upload')
}

},

filename: function (req, file, cb) {

cb(null, file.originalname)
}
});

const fileFilter = (req, file, cb) => {

if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/jpg' ||
file.mimetype === 'image/png') {
cb(null, true);
} else {
cb(null, false);
}

}
var upload = multer({
 storage: storage,

limits: {
fileSize: 1024 * 1024 * 20
},
fileFilter: fileFilter

});
{/*
router.get('/',async(req,res)=>{
sess = req.session;

if (sess.userEmail) {

const objAreaEJS = await Area.find({

isActive: true
});
const objUserEJS = await User.find({
isActive: true
});
const objBillboardEJS = await Billboard.find({
isActive: true
});
const objbillboardScheduleEJS = await billboardSchedule.find({
isActive: true
});
const objbookingMasterEJS = await bookingMaster.find({
isActive: true
});
const objcarrierMasterEJS = await carrierMaster.find({
isActive: true
});
const objCityEJS = await City.find({
isActive: true
});
const objclientPartnerEJS = await clientPartner.find({
isActive: true
});
const objFeedbackEJS = await Feedback.find({
isActive: true
});
const objpropertyRentEJS = await propertyRent.find({
isActive: true
});

const objclientPartnerAvailableEJS = await clientPartner.find({

isActive: true,
isAvailable:true
}).populate('B_UsermasterIDFK', ['userFname','userLname'])
.limit(5)
for (var i = 0; i < objclientPartnerAvailableEJS.length; i++) {
objclientPartnerAvailableEJS[i].user_value =
objclientPartnerAvailableEJS[i].B_UsermasterIDFK.userFname+" "+
objclientPartnerAvailableEJS[i].B_UsermasterIDFK.userLname
}
var data = [];
data["areaCount"]= objAreaEJS.length;
data["userCount"]= objUserEJS.length;
 data["BillboardCount"]= objBillboradEJS.length;
data["BillboradScheduleCount"]= objbillboardScheduleEJS.length;
data["BookingCount"]=objbookingMasterEJS.length;
data["carrierCount"]=objcarrierMasterEJS.length;
data["cityCount"]= objCityEJS.length;
data["clientCount"]= objclientPartnerEJS.length;
data["feedbackCount"]= objFeedbackEJS.length;
data["propertyCount"]= objpropertyRentEJS.length;
res.render('index',{"data":data,objUser:req.session.userType});
}else {
res.render('login');
}
});
router.post('/loginEJS', async (req, res) => {

const objUser = await User.findOne({

userEmail: req.body.userEmail
});
console.log(objUser);
if (objUser != null) {
if (objUser.userType === "Admin") {

sess = req.session;
sess.userEmail = req.body.userEmail;
sess.userType = objUser.userType;
sess.userFname=objUser.userFname;
sess.userLname=objUser.userLname;
// sess.objAuth=objauth;
res.redirect('/admin');
}
else {
res.redirect('/admin');
}
}else {
res.redirect('/admin');
}
});

router.get('/logout',(req,res) => {
req.session.destroy();
res.redirect('/admin');
});
*/}
//Achivement
router.get('/addachivement', async (req, res) => {
var objAchivement = new achivement();
objAchivement.achivement = req.body.achivement,
objUser.addedOn = new Date(),
objUser.isActive = true;
console.log();

const inserted = await objUser.save();

if (inserted != null) {
res.json({ result: "success", msg: "Achivement Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "Achivement Not Inserted", data: 0 });
}
});
router.post('/updateachivementEJS',async (req, res) => {
console.log(req.body.id)
const objachivement = await achivement.updateOne({
_id: req.body.id
}, {
achivement: req.body.achivement
});
// res.send(objAchivement)
if (objachivement != null) {
res.json({ result: "success", msg: "Achivement update", data: 1 });
} else {
res.json({ result: "failure", msg: "Achivement Not update", data: 0 });
}
});
router.post('/deleteachivement', async (req, res) => {
console.log(req.body.id);
const objDeleteachivement = await achivement.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeleteachivement != null) {
res.json({ result: "success", msg: "Achivement deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "Achivement Not deleted", data: 0 });
}
});
router.get('/fetchachivement/:id', async (req, res) => {
const fetchachivementObj = await achivement.findOne({
_id: req.params.id
});

if (fetchachivementObj != null) {
res.json({ result: "success", msg: "Achivement Fetch", data:
fetchachivementObj });
} else {
res.json({ result: "failure", msg: "Achivement Not Fetch", data:
fetchachivementObj});
}
});
router.get('/fetchachivement', async (req, res) => {
const fetchachivementObj = await achivement.find({
isActive:true,
});

if (fetchachivementObj != null) {
res.json({ result: "success", msg: "Achivement List", data:
fetchachivementObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data:
fetchachivementObj});
}
});

//Area
router.get('/addArea', async (req, res) => {
var objArea = new Area();
objArea.Area = req.body.Area,
objArea.cityMaster = req.body.cityMaster
 objArea.areaName = "",
objArea.addedOn = new Date(),
objArea.isActive = true;
console.log();

const inserted = await objArea.save();

if (inserted != null) {
res.json({ result: "success", msg: "Area Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "Area Not Inserted", data: 0 });
}
});
router.post('/updateAreaEJS',async (req, res) => {
console.log(req.body.id)
const objArea = await Area.updateOne({
_id: req.body.id
}, {
areaName: req.body.areaName,
cityName: req.body.cityName
});
// res.send(objArea)
if (objArea != null) {
res.json({ result: "success", msg: "Area update", data: 1 });
} else {
res.json({ result: "failure", msg: "Area Not update", data: 0 });
}
});
router.post('/deleteArea', async (req, res) => {
console.log(req.body.id);
const objDeleteArea = await Area.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeleteArea != null) {
res.json({ result: "success", msg: "Area deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "Area Not deleted", data: 0 });
}
});
router.get('/fetchArea/:id', async (req, res) => {
const fetchAreaObj = await Area.findOne({
_id: req.params.id
});
if (fetchAreaObj != null) {
res.json({ result: "success", msg: "Area Fetch", data: fetchAreaObj });
} else {
res.json({ result: "failure", msg: "Area Not Fetch", data: fetchAreaObj});
}
});
router.get('/fetchArea', async (req, res) => {
const fetchAreaObj = await Area.find({
isActive:true,
});

if (fetchAreaObj != null) {
res.json({ result: "success", msg: "Area List", data: fetchAreaObj });
} else {
 res.json({ result: "failure", msg: "unsuccessfull", data: fetchAreaObj});
}
});

//User
router.get('/addUser', async (req, res) => {
var objUser = new User();
objUser.userFname = "",
objUser.userMname = req.body.userMname,
objUser.userLname = req.body.userLname,
objUser.userAddress = req.body.userAddress,
objUser.contact = "",
objUser.userEmail = req.body.userEmail,
objUser.pincode = req.body.pincode,
objUser.cityMaster = req.body.cityMaster,
objUser.clientPartner = req.body.clientPartner,
objUser.addedOn = new Date(),
objUser.isActive = true;
console.log();

const inserted = await objUser.save();

if (inserted != null) {
res.json({ result: "success", msg: "User Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "User Not Inserted", data: 0 });
}
});
router.post('/updateUserEJS',async (req, res) => {
const objUser = await User.updateOne({
_id: req.body.id
}, {
userFName : req.body.userFName,
userMname : req.body.userMname,
userLname : req.body.userLname,
userAddress : req.body.userAddress,
contact : req.body.contact,
userEmail : req.body.userEmail,
pincode : req.body.pincode,
contact :req.body.contact,
});

// res.send(objTeacher)
if (objUser != null) {
res.json({ result: "success", msg: "User updated Successfully", data: 1
});

} else {
res.json({ result: "failure", msg: "UnSuccessful", data: 0 });

}
});
router.post('/deleteUser', async (req, res) => {
console.log(req.body.id);
const objDeleteUser = await User.updateOne({
_id: req.body.id
},{
isActive : false
});
 if (objDeleteUser != null) {
res.json({ result: "success", msg: "User deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "User Not deleted", data: 0 });
}
});
router.get('/fetchUser/:id', async (req, res) => {
const fetchUserObj = await User.findOne({
_id: req.params.id
});

if (fetchUserObj != null) {
res.json({ result: "success", msg: "User Fetch", data: fetchUserObj });
} else {
res.json({ result: "failure", msg: "User Not Fetch", data: fetchUserObj});
}
});
router.get('/fetchUser', async (req, res) => {
const fetchUserObj = await User.find({
isActive:true,
});

if (fetchUserObj != null) {
res.json({ result: "success", msg: "User List", data: fetchUserObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data: fetchUserObj});
}
});
//Billbord
router.get('/addBillboard', async (req, res) => {
var objBillboard = new Billboard();
objBillboard.location = "",
objBillboard.latitude = "",
objBillboard.longitude = "",
objBillboard.locationImage = req.body.locationImage,
objBillboard.isLight = req.body.isLight,
objBillboard.price = req.body.price,
objBillboard.billboardWidth = req.body.billboardWidth,
objBillboard.billboardHeight = req.body.billboardHeight,
objBillboard.totalPrice = req.body.totalPrice,
objBillboard.addedOn = new Date(),
objBillboard.isActive = true;
console.log();

const inserted = await objBillboard.save();

if (inserted != null) {
res.json({ result: "success", msg: "Billboard Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "Billboard Not Inserted", data: 0 });
}
});
router.post('/updateBillboardEJS', async (req, res) => {
console.log(req.body.id)
const objBillboard = await Billboard.updateOne({
_id: req.body.id
},{
location: req.body.location,
latitude: req.body.latitude,
 longitude: req.body.longitude,
isLight: req.body.isLight,
price: req.body.price,
billboardWidth: req.body.billboardWidth,
billboardHeight: req.body.billboardHeight,
totalPrice: req.body.totalPrice,
});
if (objBillboard != null) {
res.json({ result: "success", msg: "Billboard update", data: 1 });
} else {
res.json({ result: "failure", msg: "Billboard Not update", data: 0 });
}
});
router.post('/deleteBillboard', async (req, res) => {
console.log(req.body.id);
const objDeleteBillboard = await Billboard.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeleteBillboard != null) {
res.json({ result: "success", msg: "Billboard deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "Billboard Not deleted", data: 0 });
}
});
router.get('/fetchBillboard/:id', async (req, res) => {
const fetchBillboardObj = await User.findOne({
_id: req.params.id
});

if (fetchBillboardObj != null) {
res.json({ result: "success", msg: "Billboard Fetch", data:
fetchBillboardObj });
} else {
res.json({ result: "failure", msg: "Billboard Not Fetch", data:
fetchBillboardObj});
}
});
router.get('/fetchBillboard', async (req, res) => {
const fetchBillboardObj = await Billboard.find({
isActive:true,
});

if (fetchBillboardObj != null) {
res.json({ result: "success", msg: "Billboard List", data:
fetchBillboardObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data:
fetchBillboardObj});
}
});

//billboardSchedule
router.get('/addbillboardSchedule', async (req, res) => {
var objbillboardSchedule = new billboardSchedule();
objbillboardSchedule.Billboard = req.body.billboardSchedule,
objbillboardSchedule.B_Usermaster = req.params.B_Usermaster,
objbillboardSchedule.startDate = "",
 objbillboardSchedule.endDate = "",
objbillboardSchedule.addedOn = new Date(),
objbillboardSchedule.isActive = true;

console.log();

const inserted = await objbillboardSchedule.save();

if (inserted != null) {
res.json({ result: "success", msg: "Billboard Schedule Inserted", data:
1 });
} else {
res.json({ result: "failure", msg: "Billboard Schedule Not Inserted", data:
0 });
}

});
router.post('/updatebillboardScheduleEJS', async (req , res) => {
console.log(req.body.id);
const objbillboardSchedule = await billboardSchedule.updateOne({
_id: req.body.id
},{
Billboard: req.body.Billboard,
B_Usermaster: req.body.B_Usermaster,
startDate: req.body.startDate,
endDate: req.body.endDate
});
if (objbillboardSchedule != null) {
res.json({ result: "success", msg: "Billboard Schedule update", data: 1 });
} else {
res.json({ result: "failure", msg: "Billboard Schedule Not update", data: 0
});
}
});
router.post('/deletebillboardSchedule', async (req, res) => {
console.log(req.body.id);
const objDeletebillboardSchedule = await billboardSchedule.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeletebillboardSchedule != null) {
res.json({ result: "success", msg: "Billboard Schedule deleted", data:
1 });
} else {
res.json({ result: "failure", msg: "Billboard Schedule Not deleted", data:
0 });
}
});
router.get('/fetchbillboardSchedule/:id', async (req, res) => {
const fetchbillboardScheduleObj = await User.findOne({
_id: req.params.id
});

if (fetchbillboardScheduleObj != null) {
res.json({ result: "success", msg: "Biilboard Schedule Fetch", data:
fetchbillboardScheduleObj });
} else {
res.json({ result: "failure", msg: "Billboard Schedule Not Fetch", data:
fetchbillboardScheduleObj});
}

});
router.get('/fetchbillboardSchedule', async (req, res) => {
const fetchbillboardScheduleObj = await billboardSchedule.find({
isActive:true,
});

if (fetchbillboardScheduleObj != null) {
res.json({ result: "success", msg: "Billboard Schedule List", data:
fetchbillboardScheduleObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data:
fetchbillboardScheduleObj});
}
});

//bookingMaster
router.get('/addbooking', async (req, res) => {
var objbooking = new booking();
objbooking.Billboard = req.body.Billboard,
objbooking.subservice = req.body.subservice,
objbooking.B_Usermaster = req.body.B_Usermaster,
objbooking.bookDate = req.body.bookDate,
objbooking.orderstartDate = req.body.orderstartDate,
objbooking.orderendDate = req.body.orderendDate,
objbooking.totalAmount = "",
objbooking.depositeAmount = "",
objbooking.status = req.body.status,
objbooking.offer = req.body.offer,
objbooking.addedOn = new Date(),
objbooking.isActive = true;
console.log();

const inserted = await objbooking.save();

if (inserted != null) {
res.json({ result: "success", msg: "Booking Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "Booking Not Inserted", data: 0 });
}
});
router.post('/updatebookingEJS', async (req, res) => {
console.log(req.body.id);
const objbooking = await booking.updateOne({
_id: req.body.id
},{
Billboard: req.body.Billboard,
subserviceMaster: req.body.subserviceMaster,
B_Usermaster: req.body.B_Usermaster,
bookDate: req.body.bookDate,
orderstartDate: req.body.orderstartDate,
orderendDate: req.body.orderendDate,
totalAmount: req.body.totalAmount,
depositeAmount: req.body.depositeAmount,
status: req.body.status,
offer: req.body.offer
});
 if (objbooking != null) {
res.json({ result: "success", msg: "Booking update", data: 1 });
} else {
res.json({ result: "failure", msg: "Booking Not update", data: 0 });
}
});
router.post('/deletebooking', async (req, res) => {
console.log(req.body.id);
const objDeletebooking = await booking.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeletebooking != null) {
res.json({ result: "success", msg: "Booking update", data: 1 });
} else {
res.json({ result: "failure", msg: "Booking Not update", data: 0 });
}
});
router.get('/fetchbooking/:id', async (req, res) => {
const fetchbookingObj = await booking.findOne({
_id: req.params.id
});

if (fetchbookingObj != null) {
res.json({ result: "success", msg: "Achivement Fetch", data:
fetchbookingObj });
} else {
res.json({ result: "failure", msg: "Achivement Not Fetch", data:
fetchbookingObj});
}
});
router.get('/fetchbooking', async (req, res) => {
const fetchbookingObj = await booking.find({
isActive:true,
});

if (fetchbookingObj != null) {
res.json({ result: "success", msg: "Booking List", data:
fetchbookingObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data:
fetchbookingObj});
}
});

//carrierMaster
router.get('/addcarrier', async (req, res) => {
var objcarrier = new carrier();
objcarrier.carrierName = "",
objcarrier.email = req.body.email,
objcarrier.contact = "",
objcarrier.post = "",
objcarrier.cityMaster = req.body.cityMaster,
objcarrier.referenceName = req.body.referenceName,
objcarrier.referenceNumber = req.body.referenceNumber,
objcarrier.upload = "",
objcarrier.addedOn = new Date(),
objcarrier.isActive = true;
 console.log();

const inserted = await objcarrier.save();

if (inserted != null) {
res.json({ result: "success", msg: "Carrier Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "Carrier Not Inserted", data: 0 });
}
});
router.post('/updatecarrierEJS', async (req, res) => {
console.log(req.body.id);
const objcarrier = await carrier.updateOne({
_id: req.body.id
},{
carrierName: req.body.carrierName,
email: req.body.email,
contact: req.body.contact,
post: req.body.post,
cityMaster: req.body.cityMaster,
referenceName: req.body.referenceName,
referenceNumber: req.body.referenceNumber,
uploadResume: req.body.uploadResume
});
if (objcarrier != null) {
res.json({ result: "success", msg: "Carrier update", data: 1 });
} else {
res.json({ result: "failure", msg: "Carrier Not update", data: 0 });
}
});
router.post('/deletecarrier', async (req, res) => {
console.log(req.body.id);
const objDeletecarrier = await carrier.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeletecarrier != null) {
res.json({ result: "success", msg: "Carrier deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "Carrier Not deleted", data: 0 });
}
});
router.get('/fetchcarrier/:id', async (req, res) => {
const fetchcarrierObj = await carrier.findOne({
_id: req.params.id
});

if (fetchcarrierObj != null) {
res.json({ result: "success", msg: "Carrier Fetch", data:
fetchcarrierObj });
} else {
res.json({ result: "failure", msg: "Carrier Not Fetch", data:
fetchcarrierObj});
}
});
router.get('/fetchcarrier', async (req, res) => {
const fetchcarrierObj = await carrier.find({
isActive:true,
 });

if (fetchcarrierObj != null) {
res.json({ result: "success", msg: "Carrier List", data:
fetchcarrierObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data:
fetchcarrierObj});
}
});

//city
router.get('/addCity', async (req, res) => {
var objCity = new City();
objCity.cityName = "",
objCity.addedOn = new Date(),
objCity.isActive = true;
console.log();

const inserted = await objCity.save();

if (inserted != null) {
res.json({ result: "success", msg: "City Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "city Not Inserted", data: 0 });
}
});
router.post('/updateCityEJS', async (req, res, ) => {
console.log(req.body.id);
const objCity =await City.updateOne({
_id: req.body.id
},{
cityName: req.body.cityName
});
if (objCity != null) {
res.json({ result: "success", msg: "City update", data: 1 });
} else {
res.json({ result: "failure", msg: "City Not update", data: 0 });
}
});
router.post('/deleteCity', async (req, res) => {
console.log(req.body.id);
const objDeleteCity = await City.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeleteCity != null) {
res.json({ result: "success", msg: "City deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "City Not deleted", data: 0 });
}
});
router.get('/fetchCity/:id', async (req, res) => {
const fetchCityObj = await City.findOne({
_id: req.params.id
});

if (fetchCityObj != null) {
 res.json({ result: "success", msg: "City Fetch", data: fetchCityObj });
} else {
res.json({ result: "failure", msg: "City Not Fetch", data: fetchCityObj});
}

});
router.get('/fetchCity', async (req, res) => {
const fetchCityObj = await City.find({
isActive:true,
});

if (fetchCityObj != null) {
res.json({ result: "success", msg: "City List", data: fetchCityObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data: fetchCityObj});
}
});

//clientPartner
router.get('/addclient', async (req, res) => {
var objclient = new client();
objclient.B_Usermaster = req.body.B_Usermaster,
objclient.address = req.body.address,
objclient.pincode = req.body.pincode,
objclient.email = req.body.email,
objclient.contact = req.body.contact,
objclient.imageUpload = req.body.imageUpload,
objclient.addedOn = new Date(),
objclient.isActive= true;
console.log();

const inserted = await objclient.save();

if (inserted != null) {
res.json({ result: "success", msg: "Client Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "Client Not Inserted", data: 0 });
}
});
router.post('/updateclientEJS', async (req, res) => {
console.log(req.body.id);
const objclient = await client.updateOne({
_id: req.body.id
},{
B_Usermaster: req.body.B_Usermaster,
address: req.body.address,
pincode: req.body.pincode,
email: req.body.email,
contact: req.body.contact,
imageUpload: req.body.imageUpload
});
if (objclient != null) {
res.json({ result: "success", msg: "Client update", data: 1 });
} else {
res.json({ result: "failure", msg: "Client Not update", data: 0 });
}
});
router.post('/deleteclient', async (req, res) => {
console.log(req.body.id);
 const objDeleteclient = await client.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeleteclient != null) {
res.json({ result: "success", msg: "Client deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "Clinet Not deleted", data: 0 });
}
});
router.get('/fetchclient/:id', async (req, res) => {
const fetchclientObj = await client.findOne({
_id: req.params.id
});

if (fetchclientObj != null) {
res.json({ result: "success", msg: "Client Fetch", data: fetchclientObj });
} else {
res.json({ result: "failure", msg: "Client Not Fetch", data:
fetchclientObj});
}
});
router.get('/fetchclient', async (req, res) => {
const fetchclientObj = await client.find({
isActive:true,
});

if (fetchclientObj != null) {
res.json({ result: "success", msg: "Client List", data: fetchclientObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data: fetchclientObj});
}
});

//corporateSocialresponsibility
router.get('/addCSR', async (req, res) => {
var objCSR = new CSR();
objCSR.title = req.body.title,
objCSR.message = "",
objCSR.image = req.body.image,
objCSR.addedOn = new Date(),
objCSR.isActive = this.trace;

console.log();

const inserted = await objCSR.save();

if (inserted != null) {
res.json({ result: "success", msg: "corporate Social Responsibility
Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "corporate Social Responsibility Not
Inserted", data: 0 });
}
});
router.post('/updateCSREJS', async (req, res) => {
console.log(req.body.id);
const objCSR = await CSR.updateOne({
 _id: req.body.id
},{
title: req.body.title,
message: req.body.message,
image: req.body.image
});
if (objCSR != null) {
res.json({ result: "success", msg: "corporate Social Responsibility
update", data: 1 });
} else {
res.json({ result: "failure", msg: "corporate Social Responsibility Not
update", data: 0 });
}
});
router.post('/deleteCSR', async (req, res) => {
console.log(req.body.id);
const objDeleteCSR = await CSR.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeleteCSR != null) {
res.json({ result: "success", msg: "corporate Social Responsibility
deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "corporate Social Responsibility Not
deleted", data: 0 });
}
});
router.get('/fetchCSR/:id', async (req, res) => {
const fetchCSRObj = await CSR.findOne({
_id: req.params.id
});

if (fetchCSRObj != null) {
res.json({ result: "success", msg: "corporate Social Responsibility Fetch",
data: fetchCSRObj });
} else {
res.json({ result: "failure", msg: "corporate Social Responsibility Not
Fetch", data: fetchCSRObj});
}
});
router.get('/fetchCSR', async (req, res) => {
const fetchCSRObj = await CSR.find({
isActive:true,
});

if (fetchCSRObj != null) {
res.json({ result: "success", msg: "corporate Social Responsibility List",
data: fetchCSRObj });
} else {
res.json({ result: "failure", msg: "corporate Social Responsibility", data:
fetchCSRObj});
}
});

//Feedback
router.get('/addFeedback', async(req, res) => {
var objFeedback = new Feedback();
 objFeedback.B_Usermaster = req.body.B_Usermaster,
objFeedback.fullName = "",
objFeedback.contact = "",
objFeedback.email = req.body.email,
objFeedback.message = "",
objFeedback.addedOn = new Date(),
objFeedback.isActive = true;
console.log();
const inserted = await objFeedback.save();

if (inserted != null) {
res.json({ result: "success", msg: "Feedback Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "Feedback Not Inserted", data: 0 });
}

});
router.post('/updateFeedbackEJS',async (req, res) => {
console.log(req.body.id);
const objFeedback = await Feedback.updateOne({
_id: req.body.id
},{
B_Usermaster: req.body.B_Usermaster,
fullName: req.body.fullName,
contact: req.body.contact,
email: req.body.email,
message: req.body.message
});
if (objFeedback != null) {
res.json({ result: "success", msg: "Feedback update", data: 1 });
} else {
res.json({ result: "failure", msg: "Feedback Not update", data: 0 });
}
});
router.post('/deleteFeedback', async (req, res) => {
console.log(req.body.id);
const objDeleteFeedback = await Feedback.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeleteFeedback != null) {
res.json({ result: "success", msg: "Feedback deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "Feedback Not deleted", data: 0 });
}
});
router.get('/fetchFeedback/:id', async (req, res) => {
const fetchFeedbackObj = await Feedback.findOne({
_id: req.params.id
});
if (fetchachivementObj != null) {
res.json({ result: "success", msg: "Feedback Fetch", data: fetchFeedbackObj
});
} else {
res.json({ result: "failure", msg: "Feedback Not Fetch", data:
fetchFeedbackObj});
}
});
router.get('/fetchFeedback', async (req, res) => {
const fetchFeedbackObj = await Feedback.find({
isActive:true,
});

if (fetchFeedbackObj != null) {
res.json({ result: "success", msg: "Feedback List", data:
fetchFeedbackObj });
} else {
res.json({ result: "failure", msg: "Feedback", data: fetchFeedbackObj});
}
});

//Gallery
router.get('/addGallery', async (req, res) => {
var objGallery = new Gallery();
objGallery.galleryName = req.body.galleryName,
objGallery.galleryTitle = req.body.galleryTitle,
objGallery.galleryDescription = req.body.galleryDescription,
objGallery.addedOn = new Date(),
objGallery.isActive = true;
console.log();

const inserted = await objGallery.save();

if (inserted != null) {
res.json({ result: "success", msg: "Gallery Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "Gallery Not Inserted", data: 0 });
}
});
router.post('/updateGalleryEJS', async (req, res) => {
console.log(req.body.id);
const objGallery = await Gallery.updateOne({
_id: req.body.id
},{
galleryName: req.body.galleryName,
galleryTitle: req.body.galleryTitle,
galleryDescription: req.body.galleryDescription
});
if (objGallery != null) {
res.json({ result: "success", msg: "Gallery update", data: 1 });
} else {
res.json({ result: "failure", msg: "Gallery Not update", data: 0 });
}
});
router.post('/deleteGallery', async (req, res) => {
console.log(req.body.id);
const objDeleteGallery = await Gallery.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeleteGallery != null) {
res.json({ result: "success", msg: "Gallery deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "Gallery Not deleted", data: 0 });
}
});
router.get('/fetchGallery/:id', async (req, res) => {
const fetchGalleryObj = await Gallery.findOne({
_id: req.params.id
});

if (fetchGalleryObj != null) {
res.json({ result: "success", msg: "Gallery Fetch", data:
fetchGalleryObj });
} else {
res.json({ result: "failure", msg: "Gallery Not Fetch", data:
fetchGalleryObj});
}
});
router.get('/fetchGallery', async (req, res) => {
const fetchGalleryObj = await Gallery.find({
isActive:true,
});

if (fetchGalleryObj != null) {
res.json({ result: "success", msg: "Gallery List", data:
fetchGalleryObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data:
fetchGalleryObj});
}
});

//image
router.get('/addimage', async (req, res) => {
var objimage = new image();
objimage.Gallery = req.body.Gallery,
objimage.imagepath = req.body.imagepath,
objimage.imageTitle = req.body.imageTitle,
objimage.imageDescription = req.body.imageDescription,
objimage.status = req.body.status,
objimage.addedOn = new Date();
objimage.isActive = true;
console.log();

const inserted = await objimage.save();

if (inserted != null) {
res.json({ result: "success", msg: "Image Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "Image Not Inserted", data: 0 });
}
});
router.post('/updateimageEJS', async (req, res) => {
console.log(req.body.id);
const objimage = await image.updateOne({
_id: req.body.id
},{
Gallery: req.body.Gallery,
imagepath: req.body.imagepath,
imageTitle: req.body.imageTitle,
imageDescription: req.body.imageDescription,
status: req.body.status
});
 if (objimage != null) {
res.json({ result: "success", msg: "Image update", data: 1 });
} else {
res.json({ result: "failure", msg: "Image Not update", data: 0 });
}
});
router.post('/deleteimage', async (req, res) => {
console.log(req.body.id);
const objDeleteimage = await image.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeleteimage != null) {
res.json({ result: "success", msg: "Image deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "Image Not deleted", data: 0 });
}
});
router.get('/fetchimage/:id', async (req, res) => {
const fetchimageObj = await image.findOne({
_id: req.params.id
});

if (fetchimageObj != null) {
res.json({ result: "success", msg: "Image Fetch", data: fetchimageObj });
} else {
res.json({ result: "failure", msg: "Image Not Fetch", data:
fetchimageObj});
}
});
router.get('/fetchimage', async (req, res) => {
const fetchimageObj = await image.find({
isActive:true,
});

if (fetchimageObj != null) {
res.json({ result: "success", msg: "Image List", data: fetchimageObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data: fetchimageObj});
}
});

//offer
router.get('/addoffer', async (req, res) => {
var objoffer = new offer();
objoffer.offerStartdate = req.body.offerStartdate,
objoffer.offerEnddate = req.body.offerEnddate,
objoffer.discountRatio = req.body.discountRatio,
objoffer.validationCode = req.body.validationCode,
objoffer.addedOn = new Date(),
objoffer.isActive = true;
console.log();

const inserted = await objoffer.save();

if (inserted != null) {
res.json({ result: "success", msg: "Offer Inserted", data: 1 });
} else {
 res.json({ result: "failure", msg: "Offer Not Inserted", data: 0 });
}
});
router.post('/updateofferEJS', async (req, res) => {
console.log(req.body.id);
const objoffer =await offer.updateOne({
_id: req.body.id
},{
offerStartdate: req.body.offerStartdate,
offerEnddate: req.body.offerEnddate,
discountRatio: req.body.discountRatio,
validationCode: req.body.validationCode
});
if (objoffer != null) {
res.json({ result: "success", msg: "Offer update", data: 1 });
} else {
res.json({ result: "failure", msg: "Offer Not update", data: 0 });
}
});
router.post('/deleteoffer', async (req, res) => {
console.log(req.body.id);
const objDeleteoffer = await client.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeleteoffer != null) {
res.json({ result: "success", msg: "Offer deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "Offer Not deleted", data: 0 });
}
});
router.get('/fetchoffer/:id', async (req, res) => {
const fetchofferObj = await offer.findOne({
_id: req.params.id
});

if (fetchofferObj != null) {
res.json({ result: "success", msg: "Offer Fetch", data: fetchofferObj });
} else {
res.json({ result: "failure", msg: "Offer Not Fetch", data:
fetchofferObj});
}
});
router.get('/fetchoffer', async (req, res) => {
const fetchofferObj = await offer.find({
isActive:true,
});

if (fetchofferObj != null) {
res.json({ result: "success", msg: "Offer List", data: fetchofferObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data: fetchofferObj});
}
});

//propertyRent
router.get('/addpRent', async (req, res) => {
var objpRent = new pRent();
 objpRent.Name = "",
objpRent.email= req.body.email,
objpRent.contact = "",
objpRent.cityMaster = req.body.cityMaster,
objpRent.areaMaster = req.body.areaMaster,
objpRent.address = req.body.address,
objpRent.remark = req.body.remark,
objpRent.ownerType = req.body.ownerType,
objpRent.propertyType = req.body.propertyType,
objpRent.uploadImage = req.body.uploadImage,
objpRent.addedOn = new Date(),
objpRent.isActive = true;
console.log();

const inserted = await objpRent.save();

if (inserted != null) {
res.json({ result: "success", msg: "Property Rent Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "Property Rent Not Inserted", data:
0 });
}
});
router.post('/updatepRentEJS', async (req, res) => {
console.log(req.body.id);
const objpRent = await pRent({
_id: req.body.id
},{
Name: req.body.Name,
email: req.body.email,
contact: req.body.contact,
cityMaster: req.body.cityMaster,
areaMaster: req.body.areaMaster,
address: req.body.address,
remark: req.body.remark,
ownerType: req.body.ownerType,
propertyType: req.body.propertyType,
uploadImage: req.body.uploadImage
});
if (objpRent != null) {
res.json({ result: "success", msg: "Property Rent update", data: 1 });
} else {
res.json({ result: "failure", msg: "Property Rent Not update", data: 0 });
}
});
router.post('/deletepRent', async (req, res) => {
console.log(req.body.id);
const objDeletepRent = await pRent.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeletepRent != null) {
res.json({ result: "success", msg: "Property Rent deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "Property Rent Not deleted", data: 0 });
}
});
router.get('/fetchpRent/:id', async (req, res) => {
 const fetchpRentObj = await pRent.findOne({
_id: req.params.id
});
if (fetchpRentObj != null) {
res.json({ result: "success", msg: "Property Rent Fetch", data:
fetchpRentObj });
} else {
res.json({ result: "failure", msg: "Property Rent Not Fetch", data:
fetchpRentObj});
}

});
router.get('/fetchpRent', async (req, res) => {
const fetchpRentObj = await pRent.find({
isActive:true,
});

if (fetchpRentObj != null) {
res.json({ result: "success", msg: "Property Rent List", data:
fetchpRentObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data: fetchpRentObj});
}
});

//serviceMaster
router.get('/addservice', async (req, res) => {
var objservice = new service();
objservice.serviceName = req.body.serviceName,
objservice.serviceImage = req.body.serviceImage,
objservice.addedOn = new Date(),
objservice.isActive = true;
console.log();

const inserted = await objservice.save();

if (inserted != null) {
res.json({ result: "success", msg: "Service Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "Service Not Inserted", data: 0 });
}
});
router.post('/updateserviceEJS', async (req, res) => {
console.log(req.body.id);
const objservice = await service({
_id: req.body.id
},{
serviceName: req.body.serviceName,
serviceImage: req.body.serviceImage
});
if (objservice != null) {
res.json({ result: "success", msg: "Service update", data: 1 });
} else {
res.json({ result: "failure", msg: "Service Not update", data: 0 });
}
});
router.post('/deleteservice', async (req, res) => {
console.log(req.body.id);
const objDeleteservice = await service.updateOne({
 _id: req.body.id
},{
isActive : false
});
if (objDeleteservice != null) {
res.json({ result: "success", msg: "Service deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "Service Not deleted", data: 0 });
}
});
router.get('/fetchservice/:id', async (req, res) => {
const fetchserviceObj = await service.findOne({
_id: req.params.id
});

if (fetchserviceObj != null) {
res.json({ result: "success", msg: "Service Fetch", data:
fetchserviceObj });
} else {
res.json({ result: "failure", msg: "Service Not Fetch", data:
fetchserviceObj});
}
});
router.get('/fetchservice', async (req, res) => {
const fetchserviceObj = await service.find({
isActive:true,
});

if (fetchserviceObj != null) {
res.json({ result: "success", msg: "Service List", data:
fetchserviceObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data:
fetchserviceObj});
}
});

//serviceProvider
router.get('/addsProvider', async (req, res) => {
var objsProvider = new sProvider();
objsProvider.sproviderName = req.body.sproviderName,
objsProvider.sproviderEmail= req.body.sproviderEmail,
objsProvider.sproviderContact = req.body.sproviderContact,
objsProvider.address = req.body.address,
objsProvider.chairmenName=req.body.chairmenName,
objsProvider.chairmenEmail = req.body.chairmenEmail,
objsProvider.sproviderWebsite= req.body.sproviderWebsite,
objsProvider.serviceProvider = req.body.serviceProvider,
objsProvider.addedOn = new Date(),
objsProvider.isActive = true;
console.log();

const inserted = await objsProvider.save();

if (inserted != null) {
res.json({ result: "success", msg: "Service Provider Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "Service Provider Not Inserted", data: 0
});
 }
});
router.post('/updatesProvider', async (req, res) => {
console.log(req.body.id);
const objsProvider = await sProvider.updateOne({
_id: req.body.id
},{
sproviderName: req.body.sproviderName,
sproviderEmail: req.body.sproviderEmail,
sproviderContact: req.body.sproviderContact,
address: req.body.address,
chairmenName: req.body.chairmenName,
chairmenEmail: req.body.chairmenEmail,
sproviderWebsite: req.body.sproviderWebsite,
serviceProvider: req.body.serviceProvider
});
if (objsProvider != null) {
res.json({ result: "success", msg: "Service Provider update", data: 1 });
} else {
res.json({ result: "failure", msg: "Service Provider Not update", data:
0 });
}
});
router.post('/deletesProvider', async (req, res) => {
console.log(req.body.id);
const objDeletesProvider = await sProvider.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objDeletesProvider != null) {
res.json({ result: "success", msg: "Service Provider deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "Service Provider Not deleted", data:
0 });
}
});
router.get('/fetchsProvider/:id', async (req, res) => {
const fetchsProviderObj = await sProvider.findOne({
_id: req.params.id
});
if (fetchsProviderObj != null) {
res.json({ result: "success", msg: "Service Provider Fetch", data:
fetchsProviderObj});
} else {
res.json({ result: "failure", msg: "Service Provider Not Fetch", data:
fetchsProviderObj});
}
});
router.get('/fetchsProviderObj', async (req, res) => {
const fetchsProviderObj = await sProvider.find({
isActive:true,
});

if (fetchsProviderObj != null) {
res.json({ result: "success", msg: "Service Provider List", data:
fetchsProviderObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data:
fetchsProviderObj});
}
});

//subserviceMaster
router.get('/addsubservice', async (req, res) => {
var objsubservicer = new subservice() ;
objsubservicer.serviceName = req.body.serviceName,
objsubservicer.serviceImage= req.body.serviceImage,
objsubservicer.addedOn = new Date (),
objsubservicer.isActive=true;
console.log();

const inserted = await objsubservicer.save();

if (inserted != null) {
res.json({ result: "success", msg: "Sub Service Inserted", data: 1 });
} else {
res.json({ result: "failure", msg: "Sub Service Not Inserted", data: 0 });
}

});
router.post('/updatesubservicer', async (req, res) => {
console.log(req.body.id);
const objsubservicer = await subservicer.updateOne({
_id: req.body.id
},{
serviceMaster: req.body.serviceMaster,
subserviceName: req.body.subserviceName,
unitofMeasuer: req.body.unitofMeasuer,
price: req.body.price
});
if (objsubservicer != null) {
res.json({ result: "success", msg: "Sub Service update", data: 1 });
} else {
res.json({ result: "failure", msg: "Sub Service Not update", data: 0 });
}
});
router.post('/deletesubservice', async (req, res) => {
console.log(req.body.id);
const objDeletesubservice = await subservice.updateOne({
_id: req.body.id
},{
isActive : false
});
if (objsubservicer != null) {
res.json({ result: "success", msg: "Sub Service deleted", data: 1 });
} else {
res.json({ result: "failure", msg: "Sub Service Not deleted", data: 0 });
}
});
router.get('/fetchsubservice/:id', async (req, res) => {
const fetchsubserviceObj = await subservice.findOne({
_id: req.params.id
});

if (fetchsubserviceObj != null) {
res.json({ result: "success", msg: "Sub Service Fetch", data:
fetchsubserviceObj});
 } else {
res.json({ result: "failure", msg: "Sub Service Not Fetch", data:
fetchsubserviceObj});
}
});
router.get('/fetchsubserviceObj', async (req, res) => {
const fetchsubserviceObj = await subservice.find({
isActive:true,
});

if (fetchsubserviceObj != null) {
res.json({ result: "success", msg: "Service Provider List", data:
fetchsubserviceObj });
} else {
res.json({ result: "failure", msg: "unsuccessfull", data:
fetchsubserviceObj});
}
});

module.exports = router;