Initial project setup with authentication, session management, and basic views

Author: jeeshumittal7

.env.example

@@ -0,0 +1,10 @@
+# Copy this file to .env and edit the settings
+
+# Port to listen on (example: 3000)
+PORT=
+
+# MongoDB database URL (example: mongodb://localhost/dbname)
+DATABASE_URL=
+
+# Session secret string (must be unique to your server)
+SESSION_SECRET=

.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+package-lock.json
+.env

models/Article.js

@@ -0,0 +1,14 @@
+const mongoose = require('mongoose');
+
+const articleSchema = new mongoose.Schema({
+  title: { type: String, required: true },
+  content: { type: String, required: true },
+  author: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
+  category: { type: String, required: true },
+  tags: [{ type: String }],
+  status: { type: String, enum: ['draft', 'published'], default: 'draft' },
+}, { timestamps: true });
+
+const Article = mongoose.model('Article', articleSchema);
+
+module.exports = Article;

models/User.js

@@ -0,0 +1,24 @@
+const mongoose = require('mongoose');
+const bcrypt = require('bcrypt');
+
+const userSchema = new mongoose.Schema({
+  username: { type: String, unique: true, required: true },
+  password: { type: String, required: true }
+});
+
+userSchema.pre('save', function(next) {
+  const user = this;
+  if (!user.isModified('password')) return next();
+  bcrypt.hash(user.password, 10, (err, hash) => {
+    if (err) {
+      console.error('Error hashing password:', err);
+      return next(err);
+    }
+    user.password = hash;
+    next();
+  });
+});
+
+const User = mongoose.model('User', userSchema);
+
+module.exports = User;

package.json

@@ -0,0 +1,30 @@
+{
+  "name": "PythaSpace",
+  "version": "1.0.0",
+  "description": "",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.27.3",
+    "axios": "^1.7.7",
+    "bcrypt": "^5.1.1",
+    "body-parser": "^1.20.2",
+    "chart.js": "^4.4.1",
+    "connect-flash": "^0.1.1",
+    "connect-mongo": "^5.1.0",
+    "csv-writer": "^1.6.0",
+    "dotenv": "^16.4.5",
+    "ejs": "^3.1.9",
+    "express": "^4.18.2",
+    "express-session": "^1.18.0",
+    "moment": "^2.30.1",
+    "mongoose": "^8.1.1",
+    "openai": "^4.63.0"
+  }
+}

public/css/style.css

@@ -0,0 +1,17 @@
+/* Placeholder for custom styles */
+body {
+    padding-bottom: 60px;
+}
+
+footer {
+    height: 40px;
+}
+
+nav.navbar {
+    padding: 10px 20px;
+}
+
+.pythagora-logo {
+    height: 20px;
+    margin-left: 5px;
+}

public/js/main.js

@@ -0,0 +1 @@
+// Placeholder for future JavaScript code

routes/authRoutes.js

@@ -0,0 +1,56 @@
+const express = require('express');
+const User = require('../models/User');
+const bcrypt = require('bcrypt');
+const router = express.Router();
+
+router.get('/auth/register', (req, res) => {
+  res.render('register');
+});
+
+router.post('/auth/register', async (req, res) => {
+  try {
+    const { username, password } = req.body;
+    // User model will automatically hash the password using bcrypt
+    await User.create({ username, password });
+    res.redirect('/auth/login');
+  } catch (error) {
+    console.error('Registration error:', error);
+    res.status(500).send(error.message);
+  }
+});
+
+router.get('/auth/login', (req, res) => {
+  res.render('login');
+});
+
+router.post('/auth/login', async (req, res) => {
+  try {
+    const { username, password } = req.body;
+    const user = await User.findOne({ username });
+    if (!user) {
+      return res.status(400).send('User not found');
+    }
+    const isMatch = await bcrypt.compare(password, user.password);
+    if (isMatch) {
+      req.session.userId = user._id;
+      return res.redirect('/');
+    } else {
+      return res.status(400).send('Password is incorrect');
+    }
+  } catch (error) {
+    console.error('Login error:', error);
+    return res.status(500).send(error.message);
+  }
+});
+
+router.get('/auth/logout', (req, res) => {
+  req.session.destroy(err => {
+    if (err) {
+      console.error('Error during session destruction:', err); // gpt_pilot_debugging_log
+      return res.status(500).send('Error logging out');
+    }
+    res.redirect('/auth/login');
+  });
+});
+
+module.exports = router;

routes/middleware/authMiddleware.js

@@ -0,0 +1,20 @@
+const User = require('../../models/User');
+const isAuthenticated = async (req, res, next) => {
+  if (req.session && req.session.userId) {
+    try {
+      const user = await User.findById(req.session.userId);
+      if (user) {
+        req.user = user;
+        return next();
+      }
+    } catch (error) {
+      console.error('Error in authentication middleware:', error);
+      res.status(500).send('Error during authentication process');
+    }
+  }
+  return res.status(401).send('You are not authenticated');
+};
+
+module.exports = {
+  isAuthenticated
+};

server.js

@@ -0,0 +1,94 @@
+// Load environment variables
+require("dotenv").config();
+const mongoose = require("mongoose");
+const express = require("express");
+const session = require("express-session");
+const MongoStore = require('connect-mongo');
+const authRoutes = require("./routes/authRoutes");
+const Article = require('./models/Article'); // Importing the Article model
+
+if (!process.env.DATABASE_URL || !process.env.SESSION_SECRET) {
+  console.error("Error: config environment variables not set. Please create/edit .env configuration file.");
+  process.exit(-1);
+}
+
+const app = express();
+const port = process.env.PORT || 3000;
+
+// Middleware to parse request bodies
+app.use(express.urlencoded({ extended: true }));
+app.use(express.json());
+
+// Setting the templating engine to EJS
+app.set("view engine", "ejs");
+
+// Serve static files
+app.use(express.static("public"));
+
+// Database connection
+mongoose
+  .connect(process.env.DATABASE_URL)
+  .then(() => {
+    console.log("Database connected successfully");
+  })
+  .catch((err) => {
+    console.error(`Database connection error: ${err.message}`);
+    console.error(err.stack);
+    process.exit(1);
+  });
+
+// Session configuration with connect-mongo
+app.use(
+  session({
+    secret: process.env.SESSION_SECRET,
+    resave: false,
+    saveUninitialized: false,
+    store: MongoStore.create({ mongoUrl: process.env.DATABASE_URL }),
+  }),
+);
+
+app.on("error", (error) => {
+  console.error(`Server error: ${error.message}`);
+  console.error(error.stack);
+});
+
+// Logging session creation and destruction
+app.use((req, res, next) => {
+  const sess = req.session;
+  // Make session available to all views
+  res.locals.session = sess;
+  if (!sess.views) {
+    sess.views = 1;
+    console.log("Session created at: ", new Date().toISOString());
+  } else {
+    sess.views++;
+    console.log(
+      `Session accessed again at: ${new Date().toISOString()}, Views: ${sess.views}, User ID: ${sess.userId || '(unauthenticated)'}`,
+    );
+  }
+  next();
+});
+
+// Authentication Routes
+app.use(authRoutes);
+
+// Root path response
+app.get("/", (req, res) => {
+  res.render("index");
+});
+
+// If no routes handled the request, it's a 404
+app.use((req, res, next) => {
+  res.status(404).send("Page not found.");
+});
+
+// Error handling
+app.use((err, req, res, next) => {
+  console.error(`Unhandled application error: ${err.message}`);
+  console.error(err.stack);
+  res.status(500).send("There was an error serving your request.");
+});
+
+app.listen(port, () => {
+  console.log(`Server running at http://localhost:${port}`);
+});

services/llm.js

@@ -0,0 +1,72 @@
+const axios = require('axios');
+const OpenAI = require('openai');
+const Anthropic = require('@anthropic-ai/sdk');
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+const anthropic = new Anthropic({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+});
+
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 1000;
+
+async function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function sendRequestToOpenAI(model, message) {
+  for (let i = 0; i < MAX_RETRIES; i++) {
+    try {
+      const response = await openai.chat.completions.create({
+        model: model,
+        messages: [{ role: 'user', content: message }],
+        max_tokens: 1024,
+      });
+      return response.choices[0].message.content;
+    } catch (error) {
+      console.error(`Error sending request to OpenAI (attempt ${i + 1}):`, error.message, error.stack);
+      if (i === MAX_RETRIES - 1) throw error;
+      await sleep(RETRY_DELAY);
+    }
+  }
+}
+
+async function sendRequestToAnthropic(model, message) {
+  for (let i = 0; i < MAX_RETRIES; i++) {
+    try {
+      console.log(`Sending request to Anthropic with model: ${model} and message: ${message}`);
+      const response = await anthropic.messages.create({
+        model: model,
+        messages: [{ role: 'user', content: message }],
+        max_tokens: 1024,
+      });
+      console.log(`Received response from Anthropic: ${JSON.stringify(response.content)}`);
+      return response.content[0].text;
+    } catch (error) {
+      console.error(`Error sending request to Anthropic (attempt ${i + 1}):`, error.message, error.stack);
+      if (i === MAX_RETRIES - 1) throw error;
+      await sleep(RETRY_DELAY);
+    }
+  }
+}
+
+async function sendLLMRequest(provider, model, message) {
+  switch (provider.toLowerCase()) {
+    case 'openai':
+      return sendRequestToOpenAI(model, message);
+    case 'anthropic':
+      return sendRequestToAnthropic(model, message);
+    default:
+      throw new Error(`Unsupported LLM provider: ${provider}`);
+  }
+}
+
+module.exports = {
+  sendLLMRequest
+};

views/index.ejs

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+<%- include('partials/_head.ejs') %>
+  <body>
+<%- include('partials/_header.ejs') %>
+    <main role="main" class="container mt-4">
+      <div class="text-center">
+        <h1>PythaSpace</h1>
+      </div>
+    </main>
+  </body>
+<%- include('partials/_footer.ejs') %>
+  <script src="/js/main.js"></script>
+</html>

views/login.ejs

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+<%- include('partials/_head.ejs') %>
+  <body>
+<%- include('partials/_header.ejs') %>
+    <main role="main">
+      <div class="container mt-5">
+        <h2>Login</h2>
+        <form action="/auth/login" method="POST">
+          <div class="mb-3">
+            <input type="text" name="username" placeholder="Username" required class="form-control">
+          </div>
+          <div class="mb-3">
+            <input type="password" name="password" placeholder="Password" required class="form-control">
+          </div>
+          <div class="mb-3">
+            <button type="submit" class="btn btn-primary">Login</button>
+            Don't have an account? <a href="/auth/register">Register</a>
+          </div>
+        </form>
+      </div>
+    </main>
+  </body>
+<%- include('partials/_footer.ejs') %>
+</html>