Marcus finishes facebook autoposter backend

src/jobs/facebookScheduler.js

@@ -0,0 +1,166 @@
+const cron = require('node-cron');
+const ScheduledFacebookPost = require('../models/scheduledFacebookPost');
+const { publishToFacebook, getCredentials } = require('../controllers/facebookController');
+const logger = require('../startup/logger');
+
+const PST_TIMEZONE = 'America/Los_Angeles';
+const MAX_POSTS_PER_TICK = 5;
+const MAX_RETRY_ATTEMPTS = 3;
+
+const handlePostError = async (post, error) => {
+  let errorMessage = 'Unknown error';
+  if (typeof error.details === 'string') {
+    errorMessage = error.details;
+  } else if (typeof error.details === 'object' && error.details?.message) {
+    errorMessage = error.details.message;
+  } else if (error.message) {
+    errorMessage = error.message;
+  }
+
+  post.attempts += 1;
+  post.lastError = errorMessage;
+
+  if (post.attempts >= MAX_RETRY_ATTEMPTS) {
+    post.status = 'failed';
+    console.log(
+      `[FacebookScheduler] Permanently failed after ${post.attempts} attempts:`,
+      post._id,
+      '-',
+      errorMessage,
+    );
+  } else {
+    post.status = 'pending';
+    console.log(
+      `[FacebookScheduler] Attempt ${post.attempts}/${MAX_RETRY_ATTEMPTS} failed, will retry:`,
+      post._id,
+      '-',
+      errorMessage,
+    );
+  }
+
+  try {
+    await post.save();
+  } catch (saveError) {
+    console.error('[FacebookScheduler] Failed to save error status:', saveError.message);
+  }
+};
+
+/**
+ * Processes the next pending scheduled post.
+ * Uses credentials from OAuth connection or falls back to env vars.
+ */
+const processNextScheduledPost = async () => {
+  let nextPost;
+
+  try {
+    const credentials = await getCredentials();
+    if (!credentials) {
+      return false;
+    }
+
+    nextPost = await ScheduledFacebookPost.findOneAndUpdate(
+      { status: 'pending', scheduledFor: { $lte: new Date() } },
+      { status: 'sending', lastError: null },
+      { sort: { scheduledFor: 1 }, new: true },
+    ).exec();
+
+    if (!nextPost) return false;
+
+    console.log('[FacebookScheduler] Processing post:', nextPost._id);
+
+    const hasStoredImage = nextPost.imageData && nextPost.imageMimeType;
+
+    const result = await publishToFacebook({
+      message: nextPost.message || undefined,
+      link: nextPost.link,
+      imageUrl: hasStoredImage ? undefined : nextPost.imageUrl,
+      imageBuffer: hasStoredImage ? nextPost.imageData : undefined,
+      imageMimeType: hasStoredImage ? nextPost.imageMimeType : undefined,
+      pageId: nextPost.pageId,
+    });
+
+    nextPost.status = 'sent';
+    nextPost.postedAt = new Date();
+    nextPost.postId = result.postId;
+    nextPost.postType = result.postType;
+    nextPost.attempts += 1;
+    nextPost.lastError = null;
+    nextPost.imageData = null;
+    await nextPost.save();
+
+    console.log(
+      '[FacebookScheduler] Successfully posted:',
+      nextPost._id,
+      '-> FB Post ID:',
+      result.postId,
+    );
+    return true;
+  } catch (error) {
+    console.error('[FacebookScheduler] Error processing post:', error.message);
+
+    if (nextPost) {
+      await handlePostError(nextPost, error);
+    }
+
+    if (typeof logger?.logException === 'function') {
+      logger.logException(error, 'facebookScheduler.process', {
+        scheduledId: nextPost?._id?.toString(),
+      });
+    }
+
+    return true;
+  }
+};
+
+/**
+ * Checks if credentials are available and logs status periodically
+ */
+let lastCredentialCheck = 0;
+const CREDENTIAL_CHECK_INTERVAL = 5 * 60 * 1000; // 5 minutes
+
+const checkCredentialsStatus = async () => {
+  const now = Date.now();
+  if (now - lastCredentialCheck < CREDENTIAL_CHECK_INTERVAL) {
+    return;
+  }
+  lastCredentialCheck = now;
+
+  const credentials = await getCredentials();
+  if (!credentials) {
+    console.log(
+      '[FacebookScheduler] Warning: No Facebook credentials configured. Scheduled posts will not be sent.',
+    );
+  } else {
+    console.log('[FacebookScheduler] Credentials available from:', credentials.source);
+  }
+};
+
+/**
+ * Starts the Facebook scheduler cron job.
+ * Runs every minute to check for posts that need to be sent.
+ */
+const startFacebookScheduler = () => {
+  console.log('[FacebookScheduler] Starting cron job...');
+
+  checkCredentialsStatus();
+
+  cron.schedule(
+    '* * * * *',
+    async () => {
+      await checkCredentialsStatus();
+
+      let processedCount = 0;
+      let keepProcessing = true;
+      while (keepProcessing && processedCount < MAX_POSTS_PER_TICK) {
+        keepProcessing = await processNextScheduledPost();
+        if (keepProcessing) processedCount += 1;
+      }
+      if (processedCount > 0) {
+        console.log(`[FacebookScheduler] Processed ${processedCount} post(s) this tick`);
+      }
+    },
+    { timezone: PST_TIMEZONE },
+  );
+};
+
+module.exports = startFacebookScheduler;

src/models/facebookConnections.js

@@ -0,0 +1,81 @@
+const mongoose = require('mongoose');
+
+const { Schema } = mongoose;
+
+/**
+ * Stores the organization's Facebook Page connection.
+ * Single shared token approach - one connection used by all authorized users.
+ */
+const FacebookConnectionSchema = new Schema(
+  {
+    // Page details
+    pageId: { type: String, required: true },
+    pageName: { type: String },
+    pageAccessToken: { type: String, required: true },
+
+    // Token metadata
+    tokenExpiresAt: { type: Date }, // Long-lived tokens expire in ~60 days
+    tokenType: { type: String, default: 'page_access_token' },
+
+    // User token (used to refresh page token if needed)
+    userAccessToken: { type: String },
+    userTokenExpiresAt: { type: Date },
+    userId: { type: String }, // Facebook user ID who connected
+
+    // Connection status
+    isActive: { type: Boolean, default: true },
+    lastVerifiedAt: { type: Date },
+    lastError: { type: String },
+
+    // Audit trail
+    connectedBy: {
+      odUserId: { type: String }, // HGN user ID
+      name: { type: String },
+      role: { type: String },
+    },
+    disconnectedBy: {
+      odUserId: { type: String },
+      name: { type: String },
+      role: { type: String },
+      disconnectedAt: { type: Date },
+    },
+
+    // Permissions granted during OAuth
+    grantedPermissions: [{ type: String }],
+  },
+  { timestamps: true },
+);
+
+// Unique active connection per pageId, allow multiple inactive records
+FacebookConnectionSchema.index(
+  { pageId: 1 },
+  { unique: true, partialFilterExpression: { isActive: true } },
+);
+
+// Index for quick lookup of active connection
+FacebookConnectionSchema.index({ isActive: 1, createdAt: -1 });
+
+/**
+ * Static method to get the active connection (if any)
+ */
+FacebookConnectionSchema.statics.getActiveConnection = async function () {
+  return this.findOne({ isActive: true }).sort({ createdAt: -1 }).exec();
+};
+
+/**
+ * Static method to deactivate all connections (used before creating new one)
+ */
+FacebookConnectionSchema.statics.deactivateAll = async function (disconnectedBy) {
+  return this.updateMany(
+    { isActive: true },
+    {
+      isActive: false,
+      disconnectedBy: {
+        ...disconnectedBy,
+        disconnectedAt: new Date(),
+      },
+    },
+  );
+};
+
+module.exports = mongoose.model('FacebookConnection', FacebookConnectionSchema);

src/models/scheduledFacebookPost.js

@@ -0,0 +1,40 @@
+const mongoose = require('mongoose');
+
+const { Schema } = mongoose;
+
+const ScheduledFacebookPostSchema = new Schema(
+  {
+    message: { type: String, default: '' },
+    link: { type: String },
+    imageUrl: { type: String },
+    imageData: { type: Buffer, default: null },
+    imageMimeType: { type: String, default: null },
+    imageOriginalName: { type: String, default: null },
+    pageId: { type: String },
+    scheduledFor: { type: Date, required: true },
+    timezone: { type: String, default: 'America/Los_Angeles' },
+    status: {
+      type: String,
+      enum: ['pending', 'sending', 'sent', 'failed'],
+      default: 'pending',
+    },
+    attempts: { type: Number, default: 0 },
+    postedAt: { type: Date },
+    postId: { type: String },
+    postType: { type: String },
+    postMethod: {
+      type: String,
+      enum: ['direct', 'scheduled'],
+      default: 'scheduled',
+    },
+    lastError: { type: String },
+    createdBy: {
+      userId: { type: String },
+      role: { type: String },
+      permissions: { type: Schema.Types.Mixed },
+    },
+  },
+  { timestamps: true },
+);
+
+module.exports = mongoose.model('ScheduledFacebookPost', ScheduledFacebookPostSchema);

src/routes/facebookRouter.js

@@ -0,0 +1,71 @@
+const express = require('express');
+const multer = require('multer');
+const {
+  postToFacebook,
+  postToFacebookWithImage,
+  scheduleFacebookPost,
+  scheduleFacebookPostWithImage,
+  getScheduledPosts,
+  getPostHistory,
+  cancelScheduledPost,
+  updateScheduledPost,
+} = require('../controllers/facebookController');
+const {
+  getConnectionStatus,
+  handleAuthCallback,
+  connectPage,
+  disconnectPage,
+  verifyConnection,
+} = require('../controllers/facebookAuthController');
+
+const upload = multer({
+  storage: multer.memoryStorage(),
+  limits: {
+    fileSize: 10 * 1024 * 1024,
+  },
+  fileFilter: (req, file, cb) => {
+    const allowedMimes = ['image/jpeg', 'image/png', 'image/gif', 'image/webp'];
+    if (allowedMimes.includes(file.mimetype)) {
+      cb(null, true);
+    } else {
+      cb(new Error('Only JPEG, PNG, GIF, and WebP images are allowed'), false);
+    }
+  },
+});
+
+const routes = function () {
+  const router = express.Router();
+
+  // Auth and connection routes
+  router.route('/social/facebook/auth/status').get(getConnectionStatus);
+  router.route('/social/facebook/auth/callback').post(handleAuthCallback);
+  router.route('/social/facebook/auth/connect').post(connectPage);
+  router.route('/social/facebook/auth/disconnect').post(disconnectPage);
+  router.route('/social/facebook/auth/verify').post(verifyConnection);
+
+  // Posting routes
+  router
+    .route('/social/facebook/post/upload')
+    .post(upload.single('image'), postToFacebookWithImage);
+  router.route('/social/facebook/post').post(postToFacebook);
+
+  // Scheduling routes
+  router
+    .route('/social/facebook/schedule/upload')
+    .post(upload.single('image'), scheduleFacebookPostWithImage);
+  router.route('/social/facebook/schedule').post(scheduleFacebookPost);
+
+  // Scheduled posts management
+  router.route('/social/facebook/scheduled').get(getScheduledPosts);
+  router
+    .route('/social/facebook/schedule/:postId')
+    .delete(cancelScheduledPost)
+    .put(updateScheduledPost);
+
+  // Post history
+  router.route('/social/facebook/history').get(getPostHistory);
+
+  return router;
+};
+
+module.exports = routes;

src/server.js

@@ -17,6 +17,7 @@ require('./cronjobs/userProfileJobs')();
 require('./cronjobs/pullRequestReviewJobs')();
 require('./jobs/analyticsAggregation').scheduleDaily();
 require('./cronjobs/bidWinnerJobs')();
+require('./jobs/facebookScheduler')();
 
 // Process pending and stuck emails on startup (only after DB is connected)
 mongoose.connection.once('connected', () => {

src/startup/routes.js

@@ -205,6 +205,7 @@ const ownerMessageRouter = require('../routes/ownerMessageRouter')(ownerMessage)
 const ownerMessageLogRouter = require('../routes/ownerMessageLogRouter')();
 
 const emailRouter = require('../routes/emailRouter')();
+const facebookRouter = require('../routes/facebookRouter')();
 const emailOutboxRouter = require('../routes/emailOutboxRouter');
 const reasonRouter = require('../routes/reasonRouter')(reason, userProfile);
 const mouseoverTextRouter = require('../routes/mouseoverTextRouter')(mouseoverText);
@@ -519,6 +520,7 @@ module.exports = function (app) {
   app.use('/api', permissionChangeLogRouter);
   app.use('/api', emailOutboxRouter);
   app.use('/api', emailRouter);
+  app.use('/api', facebookRouter);
   app.use('/api', isEmailExistsRouter);
   app.use('/api', faqRouter);
   app.use('/api', mapLocationRouter);