cadhub/app/api/db/seed.js

/* eslint-disable no-console */
const { PrismaClient } = require('@prisma/client')
const dotenv = require('dotenv')

dotenv.config()
const db = new PrismaClient()

async function main() {
  // Seed data is database data that needs to exist for your app to run.
  // Ideally this file should be idempotent: running it multiple times
  // will result in the same database state (usually by checking for the
  // existence of a record before trying to create it). For example:
  //
  //   const existing = await db.user.findMany({ where: { email: 'admin@email.com' }})
  //   if (!existing.length) {
  //     await db.user.create({ data: { name: 'Admin', email: 'admin@email.com' }})
  //   }
  const users = [
    {
      id: "a2b21ce1-ae57-43a2-b6a3-b6e542fd9e60",
      userName: "local-user-1",
      name: "local 1",
      email: "localUser1@kurthutten.com"
    },
    {
      id: "682ba807-d10e-4caf-bf28-74054e46c9ec",
      userName: "local-user-2",
      name: "local 2",
      email: "localUser2@kurthutten.com"
    },
    {
      id: "5cea3906-1e8e-4673-8f0d-89e6a963c096",
      userName: "local-admin-2",
      name: "local admin",
      email: "localAdmin@kurthutten.com"
    },
  ]

  let existing
  existing = await db.user.findMany({ where: { id: users[0].id }})
  if(!existing.length) {
    await db.user.create({
      data: users[0],
    })
  }
  existing = await db.user.findMany({ where: { id: users[1].id }})
  if(!existing.length) {
    await db.user.create({
      data: users[1],
    })
  }

  const projects = [
    {
      title: 'demo-project1',
      description: '# can be markdown',
      mainImage: 'CadHub/kjdlgjnu0xmwksia7xox',
      code: getOpenScadHingeCode(),
      cadPackage: 'openscad',
      user: {
        connect: {
          id: users[0].id,
        },
      },
    },
    {
      title: 'demo-project2',
      description: '## [hey](www.google.com)',
      user: {
        connect: {
          id: users[1].id,
        },
      },
    },
  ]

  existing = await db.project.findMany({where: { title: projects[0].title}})
  if(!existing.length) {
    await db.project.create({
      data: projects[0],
    })
  }
  existing = await db.project.findMany({where: { title: projects[1].title}})
  if(!existing.length) {
    const result = await db.project.create({
      data: projects[1],
    })

    await db.project.create({
      data: {
        ...projects[1],
        title: `${projects[1].title} fork`,
        forkedFrom: {
          connect: {
            id: result.id,
          },
        },
      },
    })
  }



  const aProject = await db.project.findUnique({where: {
    title_userId: {
      title: projects[0].title,
      userId: users[0].id,
    }
  }})
  await db.comment.create({
    data: {
      text: "nice project, I like it",
      userId: users[0].id,
      projectId: aProject.id,
      // user: {connect: { id: users[0].id}},
      // project: {connect: { id: aProject.id}},
    }
  })
  await db.projectReaction.create({
    data: {
      emote: "❤️",
      userId: users[0].id,
      projectId: aProject.id,
      // user: {connect: { id: users[0].id}},
      // project: {connect: { id: aProject.id}},
    }
  })

  console.info('No data to seed. See api/prisma/seeds.js for info.')
}

main()
  .catch((e) => console.error(e))
  .finally(async () => {
    await db.$disconnect()
  })



function getOpenScadHingeCode () {
  return `
baseWidth=15; // [0.1:0.1:50]

hingeLength=30; // [0.1:0.1:50]

// Hole mant mounting holes per half.
mountingHoleCount=3; // [1:20]

baseThickness=3; // [0.1:0.1:20]

pivotRadius=5; // [0.1:0.1:20]

// Pin that the hinge pivots on.
pinRadius=2; // [0.1:0.1:20]

mountingHoleRadius=1.5; // [0.1:0.1:10]

// How far away the hole is from the egde.
mountingHoleEdgeOffset=4; // [0:50]

// Depending on the accuracy of your printer this may need to be increased in order for print in place to work.
clearance=0.2; // [0.05:0.01:1]

// Radius difference in the ivot taper to stop the hinge from falling apart. Should be increased with large clearance values.
pinTaper=0.25; // [0.1:0.1:2]

// calculated values
hingeHalfExtrudeLength=hingeLength/2-clearance/2;
mountingHoleMoveIncrement=(hingeLength-2*mountingHoleEdgeOffset)/
  (mountingHoleCount-1);

module costomizerEnd() {}
$fn=30;
tiny=0.005;
// modules
module hingeBaseProfile() {
  translate([pivotRadius,0,0]){
    square([baseWidth,baseThickness]);
  }
}

module hingeBodyHalf() {
  difference() {
    union() {
      linear_extrude(hingeHalfExtrudeLength){
        offset(1)offset(-2)offset(1){
          translate([0,pivotRadius,0]){
            circle(pivotRadius);
          }
          square([pivotRadius,pivotRadius]);
          hingeBaseProfile();
        }
      }
      linear_extrude(hingeLength){
        offset(1)offset(-1)hingeBaseProfile();
      }
    }
    plateHoles();
  }
}

module pin(rotateY, radiusOffset) {
  translate([0,pivotRadius,hingeHalfExtrudeLength+tiny]){
    rotate([0,rotateY,0]) {
      cylinder(
        h=hingeLength/2+clearance/2,
        r1=pinRadius+radiusOffset,
        r2=pinRadius+pinTaper+radiusOffset
      );
    }
  }
}

module hingeHalfFemale() {
  difference() {
    hingeBodyHalf();
    pin(rotateY=180, radiusOffset=clearance);
  }
}

module hingeHalfMale() {
  translate([0,0,hingeLength]) {
    rotate([0,180,0]) {
      hingeBodyHalf();
      pin(rotateY=0, radiusOffset=0);
    }
  }
}

module plateHoles() {
  for(i=[0:mountingHoleCount-1]){
    translate([
      baseWidth/2+pivotRadius,
      -baseThickness,
      i*mountingHoleMoveIncrement+mountingHoleEdgeOffset
    ]){
      rotate([-90,0,0]){
        cylinder(r=mountingHoleRadius,h=baseThickness*4);
      }
    }
  }
}

// using high-level modules
translate([0,0,-15]) {
    hingeHalfFemale();
    hingeHalfMale();
}
  `
}