| Path : /var/www/html/biogreenas/BiogreenMangal/dist/ |
|
B-Con CMD Config cPanel C-Rdp D-Log Info Jump Mass Ransom Symlink vHost Zone-H |
| Current File : /var/www/html/biogreenas/BiogreenMangal/dist/index.js |
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" is not supported');
});
// server/index.ts
import express2 from "express";
// server/routes.ts
import { createServer } from "http";
// server/services/email.ts
import nodemailer from "nodemailer";
var transporter = nodemailer.createTransport({
host: "mail.eceas.com",
port: 587,
secure: false,
auth: {
user: "biogreenweb@biogreenas.com",
pass: "auVahroo6beithe"
},
tls: {
rejectUnauthorized: false
}
});
async function sendContactEmail(data) {
const mailOptions = {
from: "biogreenweb@biogreenas.com",
to: "info@biogreenas.com",
subject: `Yeni \u0130leti\u015Fim Formu: ${data.name}`,
text: `
\u0130sim: ${data.name}
Email: ${data.email}
Mesaj: ${data.message}
`,
html: `
<h3>Yeni \u0130leti\u015Fim Formu Mesaj\u0131</h3>
<p><strong>\u0130sim:</strong> ${data.name}</p>
<p><strong>Email:</strong> ${data.email}</p>
<p><strong>Mesaj:</strong> ${data.message}</p>
`
};
return transporter.sendMail(mailOptions);
}
// server/routes.ts
import { z } from "zod";
var contactSchema = z.object({
name: z.string().min(2),
email: z.string().email(),
message: z.string().min(10),
captcha: z.string().min(1)
});
async function registerRoutes(app2) {
app2.post("/api/contact", async (req, res) => {
try {
const data = contactSchema.parse(req.body);
await sendContactEmail(data);
res.json({ success: true });
} catch (error) {
res.status(400).json({
success: false,
message: error instanceof Error ? error.message : "Bir hata olu\u015Ftu"
});
}
});
const httpServer = createServer(app2);
return httpServer;
}
// server/vite.ts
import express from "express";
import fs from "fs";
import path2, { dirname as dirname2 } from "path";
import { fileURLToPath as fileURLToPath2 } from "url";
import { createServer as createViteServer, createLogger } from "vite";
// vite.config.ts
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
import themePlugin from "@replit/vite-plugin-shadcn-theme-json";
import path, { dirname } from "path";
import runtimeErrorOverlay from "@replit/vite-plugin-runtime-error-modal";
import { fileURLToPath } from "url";
var __filename = fileURLToPath(import.meta.url);
var __dirname = dirname(__filename);
var vite_config_default = defineConfig({
plugins: [
react(),
runtimeErrorOverlay(),
themePlugin(),
...process.env.NODE_ENV !== "production" && process.env.REPL_ID !== void 0 ? [
await import("@replit/vite-plugin-cartographer").then(
(m) => m.cartographer()
)
] : []
],
resolve: {
alias: {
"@": path.resolve(__dirname, "client", "src"),
"@shared": path.resolve(__dirname, "shared")
}
},
root: path.resolve(__dirname, "client"),
build: {
outDir: path.resolve(__dirname, "dist/public"),
emptyOutDir: true
}
});
// server/vite.ts
import { nanoid } from "nanoid";
var __filename2 = fileURLToPath2(import.meta.url);
var __dirname2 = dirname2(__filename2);
var viteLogger = createLogger();
function log(message, source = "express") {
const formattedTime = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
hour: "numeric",
minute: "2-digit",
second: "2-digit",
hour12: true
});
console.log(`${formattedTime} [${source}] ${message}`);
}
async function setupVite(app2, server) {
const serverOptions = {
middlewareMode: true,
hmr: { server },
allowedHosts: true
};
const vite = await createViteServer({
...vite_config_default,
configFile: false,
customLogger: {
...viteLogger,
error: (msg, options) => {
viteLogger.error(msg, options);
process.exit(1);
}
},
server: serverOptions,
appType: "custom"
});
app2.use(vite.middlewares);
app2.use("*", async (req, res, next) => {
const url = req.originalUrl;
try {
const clientTemplate = path2.resolve(
__dirname2,
"..",
"client",
"index.html"
);
let template = await fs.promises.readFile(clientTemplate, "utf-8");
template = template.replace(
`src="/src/main.tsx"`,
`src="/src/main.tsx?v=${nanoid()}"`
);
const page = await vite.transformIndexHtml(url, template);
res.status(200).set({ "Content-Type": "text/html" }).end(page);
} catch (e) {
vite.ssrFixStacktrace(e);
next(e);
}
});
}
function serveStatic(app2) {
const distPath = path2.resolve(__dirname2, "public");
if (!fs.existsSync(distPath)) {
throw new Error(
`Could not find the build directory: ${distPath}, make sure to build the client first`
);
}
app2.use(express.static(distPath));
app2.use("*", (_req, res) => {
res.sendFile(path2.resolve(distPath, "index.html"));
});
}
// server/index.ts
import { createServer as createServer2 } from "http";
var app = express2();
var app7000 = express2();
app.use(express2.json());
app.use(express2.urlencoded({ extended: false }));
app7000.use(express2.json());
app7000.use(express2.urlencoded({ extended: false }));
app.use((req, res, next) => {
const start = Date.now();
const path3 = req.path;
let capturedJsonResponse = void 0;
const originalResJson = res.json;
res.json = function(bodyJson, ...args) {
capturedJsonResponse = bodyJson;
return originalResJson.apply(res, [bodyJson, ...args]);
};
res.on("finish", () => {
const duration = Date.now() - start;
if (path3.startsWith("/api")) {
let logLine = `${req.method} ${path3} ${res.statusCode} in ${duration}ms`;
if (capturedJsonResponse) {
logLine += ` :: ${JSON.stringify(capturedJsonResponse)}`;
}
if (logLine.length > 80) {
logLine = logLine.slice(0, 79) + "\u2026";
}
log(logLine);
}
});
next();
});
(async () => {
const server = await registerRoutes(app);
const server7000 = createServer2(app7000);
app.use((err, _req, res, _next) => {
const status = err.status || err.statusCode || 500;
const message = err.message || "Internal Server Error";
res.status(status).json({ message });
throw err;
});
if (app.get("env") === "development") {
await setupVite(app, server);
app7000.use((req, res) => {
const options = {
hostname: "localhost",
port: 5e3,
path: req.url,
method: req.method,
headers: req.headers
};
const proxyReq = __require("http").request(options, (proxyRes) => {
res.writeHead(proxyRes.statusCode, proxyRes.headers);
proxyRes.pipe(res);
});
req.pipe(proxyReq);
});
} else {
serveStatic(app);
serveStatic(app7000);
}
const port5000 = process.env.PORT || 7001;
server.listen({
port: port5000,
host: "0.0.0.0",
reusePort: true
}, () => {
log(`serving on port ${port5000}`);
});
server7000.listen({
port: 7e3,
host: "0.0.0.0",
reusePort: true
}, () => {
log(`proxy server running on port 7000`);
});
})();