Assimp importing what do I have to do with my mesh class to get it to render (OpneGL)

[AI-Messiah]

I know that it is not because of an error in code. I have tried to do this many times and I have some experience with OpenGL

Here is my Mesh.h

#pragma once

#include <string>

#include <sstream>
#include <iostream>
#include <vector>
#define GLEW_STATIC
#include "GL/glew.h"
#include "glm/glm.hpp"
#include "glm/gtc/matrix_transform.hpp"
#include "assimp/scene.h"
#include "Shader.h"
using namespace std;

struct Vertex {
	glm::vec3 position;
	glm::vec3 normal;
	glm::vec2 texcoord;
};

struct Texture {
	GLuint id;
	string type;
	aiString path;
};

class Mesh {
public:
	vector<Vertex> vertices;
	vector<GLuint> indices;
	vector<Texture> textures;
	Mesh(vector<Vertex> vert, vector<GLuint> indi, vector<Texture> text) {
		vertices = vert;
		indices = indi;
		textures = text;
		SetupMesh();
	}
	void Draw(Shader shader) {
		int diffuseN = 1;

		for (GLuint i = 0; i < textures.size(); i++) {
			glActiveTexture(GL_TEXTURE0 + i);
			stringstream ss;
			string number;
			string name = textures[i].type;
			if (name == "texture_diffuse") {
				ss << diffuseN++;
			}
			number = ss.str();
			glUniform1i(glGetUniformLocation(shader.Program, (name + number).c_str()), i);
			glBindTexture(GL_TEXTURE_2D, textures[i].id);
		}
		glBindVertexArray(vao);
		glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
		glBindVertexArray(0);
		for (GLuint i = 0; i < textures.size(); i++) {
			glActiveTexture(GL_TEXTURE0 + i);
			glBindTexture(GL_TEXTURE_2D, 0);
		}
	}
private:
	void SetupMesh() {
		glGenVertexArrays(1, &vao);
		glGenBuffers(1, &vbo);
		glGenBuffers(1, &ibo);

		glBindVertexArray(vao);
		glBindBuffer(GL_ARRAY_BUFFER, vbo);
		glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);

		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLuint), &indices[0], GL_STATIC_DRAW);
		glEnableVertexAttribArray(0);
		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)0);
		glEnableVertexAttribArray(1);
		glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)offsetof(Vertex, normal));
		glEnableVertexAttribArray(2);
		glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)offsetof(Vertex, texcoord));
		glBindVertexArray(0);
	}
	GLuint vao, vbo, ibo;
};

My Model.h (Remember that stb_image requires a cpp file

#pragma once
#include "Mesh.h"
#include "assimp/Importer.hpp"
#include "assimp/postprocess.h"
class Model
{
public:
	Model(const char* path) {
		loadModel(path);
	}
	void Draw(Shader shader) {
		for (GLuint i = 0; i < meshes.size(); i++) meshes.at(i).Draw(shader);
	}
private:
	GLuint TextureFromFile(const char* path, string directory);
	void loadModel(string path) {
		Assimp::Importer importer;
		const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);
		if (!scene || scene->mFlags == AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) {
			cout << "Error " << importer.GetErrorString() << "\n";
			return;
		}
		directory = path.substr(0, path.find_last_of('/'));
		processNode(scene->mRootNode, scene);
	}
	void processNode(aiNode* node, const aiScene* scene) {
		for (GLuint i = 0; i < node->mNumMeshes; i++) {
			aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
			meshes.push_back(processMesh(mesh, scene));
		}
		for (GLuint i = 0; i < node->mNumChildren; i++) {
			processNode(node->mChildren[i], scene);
		}
	}
	Mesh processMesh(aiMesh* mesh, const aiScene* scene) {
		vector<Vertex> vertices;
		vector<GLuint> indices;
		vector<Texture> textures;
		Vertex vertex;
		for (GLuint i = 0; i < mesh->mNumVertices; i++) {
			glm::vec3 vec;
			vec.x = mesh->mVertices[i].x;
			vec.y = mesh->mVertices[i].y;
			vec.z = mesh->mVertices[i].z;
			vertex.position = vec;
			vec.x = mesh->mNormals[i].x;
			vec.y = mesh->mNormals[i].y;
			vec.z = mesh->mNormals[i].z;
			vertex.normal = vec;
			glm::vec2 vec1 = glm::vec2(0, 0);
			if (mesh->mTextureCoords[0]) {
				vec1.x = mesh->mTextureCoords[0][i].x;
				vec1.y = mesh->mTextureCoords[0][i].y;
			}
			vertex.texcoord = vec1;
			vertices.push_back(vertex);
		}
		for (GLuint i = 0; i < mesh->mNumFaces; i++) {
			aiFace face = mesh->mFaces[i];
			for (GLuint j = 0; j < face.mNumIndices; j++) indices.push_back(face.mIndices[i]);
		}
		if (mesh->mMaterialIndex >= 0) {
			aiMaterial* mat = scene->mMaterials[mesh->mMaterialIndex];
			vector<Texture> diffuseMaps = loadMaterialTextures(mat, aiTextureType_DIFFUSE, "texture_diffuse");
			textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
		}
		return Mesh(vertices, indices, textures);
	}
	vector<Texture> loadMaterialTextures(aiMaterial* mat, aiTextureType textype, string texName) {
		vector<Texture> ret;

		for (GLuint i = 0; i < mat->GetTextureCount(textype); i++) {
			aiString str;
			mat->GetTexture(textype, i, &str);
			GLboolean skip = false;
			for (GLuint j = 0; j < textures_loaded.size(); j++) {
				if (textures_loaded[j].path == str) {
					ret.push_back(textures_loaded[j]);
					skip = true;
					break;
				}
			}
			if (!skip) {
				Texture tex;
				tex.id = TextureFromFile(str.C_Str(), directory);
				tex.type = texName;
				tex.path = str;
				ret.push_back(tex);
				textures_loaded.push_back(tex);
			}
		}

		return ret;
	}

	vector<Mesh> meshes;
	string directory;
	vector<Texture> textures_loaded;
};

Model.cpp

#include "model.h"
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image/stb_image.h"
GLuint Model::TextureFromFile(const char* path, string directory) {
	string fileName = directory + "/" + string(path);
	GLuint texid;
	glGenTextures(1, &texid);

	int width, height, components;
	unsigned char* imgdata = stbi_load(fileName.c_str(), &width, &height, &components, STBI_rgb_alpha);
	glBindTexture(GL_TEXTURE_2D, texid);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, imgdata);
	glGenerateMipmap(GL_TEXTURE_2D);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glBindTexture(GL_TEXTURE_2D, 0);
	stbi_image_free(imgdata);
	return texid;
}

[kimkulling]

I would need some more information. A build output would be a great start.
Kim