RecipeDB.pro

@@ -12,8 +12,7 @@ TARGET = RecipeDB
 TEMPLATE = app
 
 
-SOURCES += SQLite/sqlite3.c \
+SOURCES += model/recipe/instruction.cpp \
-    model/recipe/instruction.cpp \
     model/recipe/recipe.cpp \
     userInterface/mainwindow.cpp \
     main.cpp \
@@ -22,11 +21,13 @@ SOURCES += SQLite/sqlite3.c \
     model/recipe/ingredients/ingredient.cpp \
     model/recipe/ingredients/ingredientlistmodel.cpp \
     model/recipe/ingredients/recipeingredient.cpp \
-    model/recipe/tags/recipetag.cpp
+    model/recipe/tags/recipetag.cpp \
+    SQLite/sqlite3.c \
+    model/database/resulttable.cpp \
+    model/database/recipedatabase.cpp \
+    utils/fileutils.cpp
 
-HEADERS  += SQLite/sqlite3.h \
+HEADERS  += model/recipe/instruction.h \
-    SQLite/sqlite3ext.h \
-    model/recipe/instruction.h \
     model/recipe/recipe.h \
     userInterface/mainwindow.h \
     model/database/database.h \
@@ -34,7 +35,14 @@ HEADERS  += SQLite/sqlite3.h \
     model/recipe/ingredients/ingredient.h \
     model/recipe/ingredients/ingredientlistmodel.h \
     model/recipe/ingredients/recipeingredient.h \
-    model/recipe/tags/recipetag.h
+    model/recipe/tags/recipetag.h \
+    SQLite/sqlite3.h \
+    SQLite/sqlite3ext.h \
+    model/database/resulttable.h \
+    model/database/recipedatabase.h \
+    utils/fileutils.h
+
+LIBS += -ldl \
 
 FORMS    += gui/mainwindow.ui
 

main.cpp

@@ -2,6 +2,7 @@
 #include <QApplication>
 
 #include "model/database/database.h"
+#include "model/database/recipedatabase.h"
 
 int main(int argc, char *argv[])
 {
@@ -9,7 +10,30 @@ int main(int argc, char *argv[])
     MainWindow w;
     w.show();
 
-    Database db("test.db");
+	//TESTING CODE
+
+	RecipeDatabase recipeDB("recipes");
+//	recipeDB.storeIngredient(Ingredient("Apple", "Fruit"));
+//	recipeDB.storeIngredient(Ingredient("Corn", "Vegetable"));
+//	recipeDB.storeIngredient(Ingredient("Lettuce", "Vegetable"));
+//	recipeDB.storeIngredient(Ingredient("Carrot", "Vegetable"));
+
+//	recipeDB.executeSQL("SELECT * FROM ingredient;").printData();
+
+	//TESTING CODE
+	vector<RecipeIngredient> ri;
+	ri.push_back(RecipeIngredient("flour", "grains", 3.0f, UnitOfMeasure("cup", "cups", "c")));
+	ri.push_back(RecipeIngredient("Baking Powder", "Additives", 1.0f, UnitOfMeasure("Teaspoon", "Teaspoons", "Tsp")));
+
+	Recipe rec("Example", ri, Instruction("<b>BOLD</b><i>iTaLiCs</i>"), QImage(), vector<RecipeTag>(), QDate::currentDate(), QTime(0, 30), QTime(0, 25), 10.0f);
+
+	bool success = recipeDB.storeRecipe(rec);
+	printf("Storage successful: %d\n", success);
+
+	Recipe reloadRec = recipeDB.retrieveRecipe("Example");
+	reloadRec.print();
+
+	w.loadFromRecipe(reloadRec);
 
 	return a.exec();
 }

model/database/database.cpp

@@ -3,18 +3,49 @@
 Database::Database(string filename){
     this->filename = filename;
     openConnection();
-    //TESTING CODE
-    if (tableExists("ingredients")){
-        printf("Ingredients table already exists.\n");
-    } else {
-        printf("Couldn't find the ingredients table.\n");
-    }
 }
 
 Database::~Database(){
 	closeConnection();
 }
 
+ResultTable Database::executeSQL(string statement){
+	sqlite3_stmt* stmt;
+	this->sql = statement;
+	this->returnCode = sqlite3_prepare_v2(this->db, statement.c_str(), -1, &stmt, NULL);
+	ResultTable t(statement);
+	if (this->returnCode != SQLITE_OK){
+		fprintf(stderr, "Unable to successfully prepare SQL statement. Error code: %d\n\tError Message: %s\n", this->returnCode, sqlite3_errmsg(this->db));
+		return t;
+	}
+
+	t.extractData(stmt);
+
+	this->returnCode = sqlite3_finalize(stmt);
+
+	return t;
+}
+
+bool Database::insertInto(string tableName, vector<string> columnNames, vector<string> values){
+	if (columnNames.size() != values.size() || columnNames.empty()){
+		return false;
+	}
+	string query = "INSERT INTO "+tableName+" (";
+	string cols = combineVector(columnNames, ", ");
+	string vals = combineVector(values, ", ");
+	query += cols + ") VALUES (" + vals + ");";
+	ResultTable t = this->executeSQL(query);
+	return (t.getReturnCode() == SQLITE_DONE);
+}
+
+ResultTable Database::selectFrom(string tableName, string columnNames, string conditions){
+	if (columnNames.size() == 0 || tableName.empty()){
+		return ResultTable();
+	}
+	string query = "SELECT " + columnNames + " FROM " + tableName + " WHERE " + conditions + ";";
+	return this->executeSQL(query);
+}
+
 void Database::openConnection(){
     this->returnCode = sqlite3_open(this->filename.c_str(), &this->db);
     if (this->returnCode || this->db == NULL){
@@ -31,17 +62,30 @@ void Database::closeConnection(){
 	this->dbIsOpen = false;
 }
 
+string Database::combineVector(std::vector<string> strings, string mid){
+	if (strings.empty()){
+		return "";
+	}
+	std::string result = surroundString(strings[0], "'");
+	for (std::vector<std::string>::iterator it = strings.begin() + 1; it != strings.end(); ++it){
+		result += mid + surroundString((*it), "'");
+	}
+	return result;
+}
+
+string Database::surroundString(string s, string surround){
+	return surround+s+surround;
+}
+
 bool Database::tableExists(string tableName){
-    if (this->dbIsOpen){
+	if (tableName.empty() || this->db == NULL || !this->dbIsOpen){
-        this->sql = "SELECT name FROM sqlite_master WHERE type='table' AND name='"+tableName+"';";
-        const char* str = this->sql.c_str();
-        this->returnCode = sqlite3_exec(this->db, str, NULL, 0, &this->errorMsg);
-        if (this->returnCode == SQLITE_ERROR){
-            fprintf(stderr, "Unable to select name from master table list: %s\n", this->errorMsg);
-            return false;
-        } else {
-            return true;
-        }
-    }
 		return false;
 	}
+	ResultTable t = this->selectFrom("sqlite_master", "name", "type='table' AND name='"+tableName+"'");
+	//ResultTable t = executeSQL("SELECT name FROM sqlite_master WHERE type='table' AND name='"+tableName+"';");
+	return !t.isEmpty();
+}
+
+int Database::getLastInsertedRowId(){
+	return sqlite3_last_insert_rowid(this->db);
+}

model/database/database.h

@@ -3,19 +3,35 @@
 
 #include <string>
 #include <vector>
+#include <numeric>
 
 #include "SQLite/sqlite3.h"
 #include "model/recipe/ingredients/ingredient.h"
+#include "resulttable.h"
 
 using namespace std;
 
+/**
+ * @brief The Database class is responsible for generic abstraction of commonly used database features.
+ */
+
 class Database
 {
 public:
+	//Creates and opens a database connection to a file of the given name. If not there, this will generate a database.
     Database(string filename);
 	~Database();
 
-    void insertIngredient(Ingredient);
+	//Executes an SQL string statement in a safe way and returns the result.
+	ResultTable executeSQL(string statement);
+	bool insertInto(string tableName, vector<string> columnNames, vector<string> values);
+	ResultTable selectFrom(string tableName, string columnNames, string conditions);
+
+	bool tableExists(string tableName);
+	int getLastInsertedRowId();
+
+protected:
+	string surroundString(string s, string surround);
 
 private:
     //SQL Instance variables.
@@ -28,11 +44,7 @@ private:
 
     void openConnection();
 	void closeConnection();
-    //Guarantees that all tables from the schema exist.
+	std::string combineVector(std::vector<std::string> strings, std::string mid);
-    void ensureTablesExist();
-
-    //Utility methods.
-    bool tableExists(string tableName);
 };
 
 #endif // DATABASE_H

model/database/recipedatabase.cpp

@@ -0,0 +1,182 @@
+#include "recipedatabase.h"
+
+RecipeDatabase::RecipeDatabase(string filename) : Database(filename){
+	this->ensureTablesExist();
+}
+
+bool RecipeDatabase::storeRecipe(Recipe recipe){
+	///TODO: Implement this in a smart way using transaction.
+	this->executeSQL("BEGIN;");
+	ResultTable t = this->selectFrom("recipe", "*", "name="+surroundString(recipe.getName(), "'"));
+	if (!t.isEmpty()){
+		fprintf(stderr, "Error storing recipe: Recipe with name %s already exists.\n", recipe.getName().c_str());
+	} else {
+		bool success = this->insertInto("recipe",
+						 vector<string>({
+											"name",
+											"createdDate",
+											"cookTime",
+											"prepTime",
+											"servingCount"
+										}),
+						 vector<string>({
+											recipe.getName(),
+											recipe.getCreatedDate().toString().toStdString(),
+											recipe.getCookTime().toString().toStdString(),
+											recipe.getPrepTime().toString().toStdString(),
+											std::to_string(recipe.getServings())
+										}));
+		if (success){
+			//If successful, proceed to insert instructions, image, and ingredients, and tags.
+			int recipeId = this->getLastInsertedRowId();
+			bool ingredientSuccess = true;
+			for (unsigned int i = 0; i < recipe.getIngredients().size(); i++){
+				if (!this->storeRecipeIngredient(recipe.getIngredients()[i], recipeId)){
+					ingredientSuccess = false;
+					break;
+				}
+			}
+			if (ingredientSuccess &&
+					this->storeInstruction(recipe.getInstruction(), recipeId) &&
+					this->storeImage(recipe.getImage(), recipeId) &&
+					this->storeTags(recipe.getTags(), recipeId)){
+				this->executeSQL("COMMIT;");
+				return true;
+			}
+		}
+	}
+	this->executeSQL("ROLLBACK;");
+	return false;
+}
+
+bool RecipeDatabase::storeRecipeIngredient(RecipeIngredient ri, int recipeId){
+	//First check if the base ingredient has been added to the database. This is done within storeIngredient().
+	ResultTable t = this->selectFrom("ingredient", "ingredientId", "name="+surroundString(ri.getName(), "'"));
+	int ingId = 0;
+	if (t.isEmpty()){
+		if (!this->insertInto("ingredient", vector<string>({"foodGroup", "name"}), vector<string>({ri.getFoodGroup(), ri.getName()}))){
+			return false;
+		}
+		ingId = this->getLastInsertedRowId();
+	} else {
+		ingId = std::stoi(t.valueAt(0, 0));
+	}
+	return this->insertInto("recipeIngredient",
+					 vector<string>({
+										"ingredientId",
+										"recipeId",
+										"quantity",
+										"unitName",
+										"comment"
+									}),
+					 vector<string>({
+										std::to_string(ingId),
+										std::to_string(recipeId),
+										std::to_string(ri.getQuantity()),
+										ri.getUnit().getName(),
+										ri.getComment()
+									}));
+}
+
+void RecipeDatabase::storeIngredient(Ingredient ingredient){
+	ResultTable t = this->selectFrom("ingredient", "*", "name="+surroundString(ingredient.getName(), "'"));
+	if (t.isEmpty()){
+		this->insertInto("ingredient", vector<string>({"foodGroup", "name"}), vector<string>({ingredient.getFoodGroup(), ingredient.getName()}));
+	}
+}
+
+bool RecipeDatabase::storeInstruction(Instruction instruction, int recipeId){
+	return FileUtils::saveInstruction(recipeId, instruction);
+}
+
+bool RecipeDatabase::storeImage(QImage image, int recipeId){
+	return FileUtils::saveImage(recipeId, image);
+}
+
+bool RecipeDatabase::storeTags(vector<RecipeTag> tags, int recipeId){
+	for (vector<RecipeTag>::iterator it = tags.begin(); it != tags.end(); ++it){
+		bool s = this->insertInto("recipeTag",
+								  vector<string>({
+													 "recipeId",
+													 "tagName"
+												 }),
+								  vector<string>({
+													 std::to_string(recipeId),
+													 (*it).getValue()
+												 }));
+		if (!s){
+			return false;
+		}
+	}
+	return true;
+}
+
+Recipe RecipeDatabase::retrieveRecipe(string name){
+	ResultTable t = this->selectFrom("recipe", "*", "name="+surroundString(name, "'"));
+	if (t.isEmpty()){
+		fprintf(stderr, "Error: No recipe with name %s found!\n", name.c_str());
+		return Recipe();
+	}
+	t.printData();
+	Recipe r;
+	int id = std::stoi(t.valueAt(0, 0));
+	r.setName(t.valueAt(0, 1));
+	r.setCreatedDate(QDate::fromString(QString::fromStdString(t.valueAt(0, 2))));
+	r.setPrepTime(QTime::fromString(QString::fromStdString(t.valueAt(0, 3))));
+	r.setCookTime(QTime::fromString(QString::fromStdString(t.valueAt(0, 4))));
+	r.setServings(std::stof(t.valueAt(0, 5)));
+	r.setInstruction(FileUtils::loadInstruction(id));
+	r.setImage(FileUtils::loadImage(id));
+	r.setIngredients(this->retrieveRecipeIngredients(id));
+	return r;
+}
+
+vector<RecipeIngredient> RecipeDatabase::retrieveRecipeIngredients(int recipeId){
+	ResultTable t = this->executeSQL("SELECT ingredient.name, ingredient.foodGroup, recipeIngredient.quantity, recipeIngredient.unitName, recipeIngredient.comment "
+									 "FROM ingredient "
+									 "INNER JOIN recipeIngredient "
+									 "ON ingredient.ingredientId = recipeIngredient.ingredientId "
+									 "AND recipeIngredient.recipeId = "+std::to_string(recipeId)+";");
+	t.printData();
+	vector<RecipeIngredient> ings;
+	for (unsigned int row = 0; row < t.rowCount(); row++){
+		RecipeIngredient r(t.valueAt(row, 0), t.valueAt(row, 1), std::stof(t.valueAt(row, 2)), UnitOfMeasure(t.valueAt(row, 3)));
+		ings.push_back(r);
+	}
+	return ings;
+}
+
+void RecipeDatabase::ensureTablesExist(){
+	//Make sure that foreign keys are enabled.
+	this->executeSQL("PRAGMA foreign_keys = ON;");
+
+	this->executeSQL("BEGIN;");
+	//Ingredients table.
+	this->executeSQL("CREATE TABLE IF NOT EXISTS ingredient("
+					 "ingredientId INTEGER PRIMARY KEY,"
+					 "foodGroup varchar,"
+					 "name varchar UNIQUE);");
+	//Recipe table. Each recipe can have at most one instruction, and one image.
+	this->executeSQL("CREATE TABLE IF NOT EXISTS recipe("
+					 "recipeId INTEGER PRIMARY KEY,"
+					 "name varchar UNIQUE,"
+					 "createdDate date,"
+					 "prepTime time,"
+					 "cookTime time,"
+					 "servingCount real);");
+	//Recipe tags table.
+	this->executeSQL("CREATE TABLE IF NOT EXISTS recipeTag("
+					 "recipeId int,"
+					 "tagName varchar,"
+					 "FOREIGN KEY (recipeId) REFERENCES recipe(recipeId));");
+	//RecipeIngredient table.
+	this->executeSQL("CREATE TABLE IF NOT EXISTS recipeIngredient("
+					 "ingredientId int,"
+					 "recipeId int,"
+					 "quantity real,"
+					 "unitName varchar,"
+					 "comment varchar,"
+					 "FOREIGN KEY (ingredientId) REFERENCES ingredient(ingredientId),"
+					 "FOREIGN KEY (recipeId) REFERENCES recipe(recipeId));");
+	this->executeSQL("COMMIT;");
+}

model/database/recipedatabase.h

@@ -0,0 +1,39 @@
+#ifndef RECIPEDATABASE_H
+#define RECIPEDATABASE_H
+
+
+
+#include "database.h"
+#include "model/recipe/recipe.h"
+#include "utils/fileutils.h"
+
+using namespace std;
+
+/**
+ * @brief The RecipeDatabase class represents the precise database used for the recipe storage, and is specialized.
+ */
+
+class RecipeDatabase : public Database
+{
+	public:
+		RecipeDatabase(string filename);
+
+		//Stores a full recipe in the database.
+		bool storeRecipe(Recipe recipe);
+
+		//SQL Helper methods.
+		bool storeRecipeIngredient(RecipeIngredient ri, int recipeId);
+		void storeIngredient(Ingredient ingredient);
+		bool storeInstruction(Instruction instruction, int recipeId);
+		bool storeImage(QImage image, int recipeId);
+		bool storeTags(vector<RecipeTag> tags, int recipeId);
+
+		Recipe retrieveRecipe(string name);
+		vector<RecipeIngredient> retrieveRecipeIngredients(int recipeId);
+	private:
+
+		//Utility methods.
+		void ensureTablesExist();
+};
+
+#endif // RECIPEDATABASE_H

model/database/resulttable.cpp

@@ -0,0 +1,92 @@
+#include "resulttable.h"
+
+ResultTable::ResultTable(){
+
+}
+
+ResultTable::ResultTable(string query){
+	this->originalQuery = query;
+}
+
+void ResultTable::extractData(sqlite3_stmt *stmt){
+	this->values.clear();
+	int res = sqlite3_step(stmt);
+	while (res == SQLITE_ROW){
+		processRow(stmt);
+		res = sqlite3_step(stmt);
+	}
+	this->queryCode = res;
+}
+
+void ResultTable::processRow(sqlite3_stmt *stmt){
+	int colCount = sqlite3_column_count(stmt);
+	vector<string> currentRow;
+
+	for (int i = 0; i < colCount; i++){
+		currentRow.push_back(convertToString(sqlite3_column_value(stmt, i)));
+	}
+
+	this->values.push_back(currentRow);
+}
+
+void ResultTable::printData(){
+	if (this->isEmpty()){
+		printf("Result table is empty.\n");
+		return;
+	}
+	printf("Printing table: [%d x %d]\t%s\n", this->rowCount(), this->columnCount(), this->originalQuery.c_str());
+	for (unsigned int row = 0; row < this->rowCount(); row++){
+		for (unsigned int col = 0; col < this->columnCount(); col++){
+			printf("| %s ", this->values[row][col].c_str());
+		}
+		printf("\n");
+	}
+}
+
+bool ResultTable::isEmpty(){
+	return this->values.empty();
+}
+
+string ResultTable::valueAt(unsigned int row, unsigned int col){
+	if (isIndexValid(row, col)){
+		return this->values[row][col];
+	} else {
+		fprintf(stderr, "Out of bounds error while trying to get value in result table at [%d, %d].\n", row, col);
+		return "";
+	}
+}
+
+int ResultTable::getReturnCode(){
+	return this->queryCode;
+}
+
+string ResultTable::getOriginalQuery(){
+	return this->originalQuery;
+}
+
+unsigned int ResultTable::columnCount(){
+	if (this->isEmpty()){
+		return 0;
+	}
+	return this->values[0].size();
+}
+
+unsigned int ResultTable::rowCount(){
+	if (this->isEmpty()){
+		return 0;
+	}
+	return this->values.size();
+}
+
+string ResultTable::convertToString(sqlite3_value *val){
+	const unsigned char* raw_text = sqlite3_value_text(val);
+	if (raw_text == 0){
+		return "";
+	}
+	string st = (const char*) raw_text;
+	return st;
+}
+
+bool ResultTable::isIndexValid(unsigned int row, unsigned int col){
+	return (row < this->values.size()) && (col < this->values[0].size());
+}

model/database/resulttable.h

@@ -0,0 +1,46 @@
+#ifndef RESULTTABLE_H
+#define RESULTTABLE_H
+
+#include <vector>
+#include <string>
+
+#include "SQLite/sqlite3.h"
+
+using namespace std;
+
+/**
+ * @brief The ResultTable class is an object that contains the results of an SQL query, in string form.
+ */
+
+class ResultTable
+{
+	public:
+		//Constructs an empty table.
+		ResultTable();
+		//Constructs a table with the original query saved.
+		ResultTable(string query);
+
+		//Gets all the data from the result set and stores it internally as strings.
+		void extractData(sqlite3_stmt* stmt);
+		//Stores the information from one row of a result set.
+		void processRow(sqlite3_stmt* stmt);
+		//Displays the data somewhat legibly.
+		void printData();
+
+		bool isEmpty();
+		string valueAt(unsigned int row, unsigned int col);
+		int getReturnCode();
+		string getOriginalQuery();
+		unsigned int columnCount();
+		unsigned int rowCount();
+	private:
+		vector<vector<string>> values;
+		int queryCode;
+		string originalQuery;
+
+		//Utility methods.
+		string convertToString(sqlite3_value* val);
+		bool isIndexValid(unsigned int row, unsigned int col);
+};
+
+#endif // RESULTTABLE_H

model/recipe/ingredients/recipeingredient.cpp

@@ -12,6 +12,10 @@ RecipeIngredient::RecipeIngredient(Ingredient i, float quantity, UnitOfMeasure u
 	setUnit(unit);
 }
 
+RecipeIngredient::RecipeIngredient(){
+
+}
+
 float RecipeIngredient::getQuantity() const{
     return this->quantity;
 }

model/recipe/ingredients/recipeingredient.h

@@ -19,6 +19,7 @@ public:
     RecipeIngredient(string name, string foodGroup, float quantity, UnitOfMeasure unit);
     //Constructor using data from a child ingredient.
     RecipeIngredient(Ingredient i, float quantity, UnitOfMeasure unit);
+	RecipeIngredient();
 
     //Getters
     float getQuantity() const;

model/recipe/ingredients/unitofmeasure.cpp

@@ -6,6 +6,13 @@ UnitOfMeasure::UnitOfMeasure(string name, string plural, string abbreviation){
 	this->abbreviation = abbreviation;
 }
 
+UnitOfMeasure::UnitOfMeasure(string name){
+	this->name = name;
+	this->plural = name + "s";
+	this->abbreviation = "NULL";
+	///TODO: Make actual guessing of this stuff.
+}
+
 UnitOfMeasure::UnitOfMeasure() : UnitOfMeasure::UnitOfMeasure("", "", ""){
     //Default constructor initializes all fields to empty strings.
 }

model/recipe/ingredients/unitofmeasure.h

@@ -14,6 +14,8 @@ class UnitOfMeasure
 public:
     //Full constructor.
     UnitOfMeasure(string name, string plural, string abbreviation);
+	//Attempt to guess unit from just a string.
+	UnitOfMeasure(string name);
     //Constructor with default values.
     UnitOfMeasure();
 

model/recipe/recipe.cpp

@@ -32,6 +32,10 @@ QImage Recipe::getImage() const{
 	return this->image;
 }
 
+vector<RecipeTag> Recipe::getTags() const{
+	return this->tags;
+}
+
 QDate Recipe::getCreatedDate() const{
     return this->createdDate;
 }
@@ -91,3 +95,27 @@ void Recipe::setCookTime(QTime newTime){
 void Recipe::setServings(float newServingsCount){
 	this->servings = newServingsCount;
 }
+
+void Recipe::print(){
+	printf("Recipe: %s, Created on: %s, Prep time: %s, Cook time: %s, Serves: %f\n",
+		   this->name.c_str(),
+		   this->createdDate.toString().toStdString().c_str(),
+		   this->prepTime.toString().toStdString().c_str(),
+		   this->cookTime.toString().toStdString().c_str(),
+		   this->servings);
+	printf("\tInstruction: %s\n", this->instruction.getHTML().c_str());
+	printf("\tIngredients:\n");
+	for (vector<RecipeIngredient>::iterator it = this->ingredients.begin(); it != this->ingredients.end(); ++it){
+		RecipeIngredient ri = *it;
+		printf("\t\t%s, Food Group: %s, Quantity: %f, Unit: %s\n",
+			   ri.getName().c_str(),
+			   ri.getFoodGroup().c_str(),
+			   ri.getQuantity(),
+			   ri.getUnit().getName().c_str());
+	}
+	printf("\tTags:\n");
+	for (vector<RecipeTag>::iterator it = this->tags.begin(); it != this->tags.end(); ++it){
+		RecipeTag t = *it;
+		printf("\t\t%s\n", t.getValue().c_str());
+	}
+}

model/recipe/recipe.h

@@ -58,6 +58,8 @@ public:
     void setPrepTime(QTime newTime);
     void setCookTime(QTime newTime);
     void setServings(float newServingsCount);
+
+	void print();
 private:
     //Main information.
     string name;                                //The name of the recipe.

userInterface/mainwindow.cpp

@@ -7,15 +7,6 @@ MainWindow::MainWindow(QWidget *parent) :
     ui->setupUi(this);
 
 	ui->ingredientsListView->setModel(&this->ingredientModel);
-
-    //TESTING CODE
-    vector<RecipeIngredient> ri;
-    ri.push_back(RecipeIngredient("flour", "grains", 3.0f, UnitOfMeasure("cup", "cups", "c")));
-    ri.push_back(RecipeIngredient("Baking Powder", "Additives", 1.0f, UnitOfMeasure("Teaspoon", "Teaspoons", "Tsp")));
-
-    Recipe rec("Example", ri, Instruction("<b>BOLD</b><i>iTaLiCs</i>"), QImage(), vector<RecipeTag>(), QDate::currentDate(), QTime(0, 30), QTime(0, 25), 10.0f);
-
-    this->loadFromRecipe(rec);
 }
 
 MainWindow::~MainWindow(){

utils/fileutils.cpp

@@ -0,0 +1,64 @@
+#include "fileutils.h"
+
+namespace FileUtils{
+
+void ensureAppDataFolderExists(){
+	QDir folder(appDataPath);
+	if (!folder.exists()){
+		folder.mkpath(".");
+	}
+}
+
+bool saveInstruction(int nr, Instruction instruction){
+	ensureAppDataFolderExists();
+	QString filename = appDataPath + QString::fromStdString(std::to_string(nr)) +".html";
+	QFile file(filename);
+	if (file.open(QIODevice::WriteOnly)){
+		QTextStream stream(&file);
+		stream<<instruction.getHTML().c_str()<<endl;
+		file.close();
+		return true;
+	} else {
+		fprintf(stderr, "Error opening file: %s to write instruction.\n", filename.toStdString().c_str());
+		return false;
+	}
+}
+
+Instruction loadInstruction(int nr){
+	QString filename = appDataPath + QString::fromStdString(std::to_string(nr)) + ".html";
+	QFile file(filename);
+	if (!file.exists()){
+		fprintf(stderr, "Instruction Nr: %d does not exist.\n", nr);
+		return Instruction();
+	}
+	if (file.open(QIODevice::ReadOnly)){
+		QTextStream stream(&file);
+		QString s = stream.readAll();
+		file.close();
+		return Instruction(s.toStdString());
+	} else {
+		fprintf(stderr, "Error opening file: %s to read instruction.\n", filename.toStdString().c_str());
+		return Instruction();
+	}
+}
+
+bool saveImage(int nr, QImage image){
+	QString filename = appDataPath + QString::fromStdString(std::to_string(nr)) + ".png";
+	QFile file(filename);
+	if (file.open(QIODevice::WriteOnly)){
+		image.save(&file, "PNG");
+		file.close();
+		return true;
+	} else {
+		fprintf(stderr, "Error saving image to file: %s\n", filename.toStdString().c_str());
+		return false;
+	}
+}
+
+QImage loadImage(int nr){
+	QString filename = appDataPath + QString::fromStdString(std::to_string(nr)) + ".png";
+	QImage img(filename);
+	return img;
+}
+
+}

utils/fileutils.h

@@ -0,0 +1,27 @@
+#ifndef FILEUTILS_H
+#define FILEUTILS_H
+
+#include <QStandardPaths>
+#include <QFile>
+#include <QDir>
+#include <QTextStream>
+#include <QImage>
+
+#include "model/recipe/instruction.h"
+
+namespace FileUtils{
+
+	const QString appDataPath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation)+"/.recipeDB/";
+
+	void ensureAppDataFolderExists();
+
+	bool saveInstruction(int nr, Instruction instruction);
+
+	Instruction loadInstruction(int nr);
+
+	bool saveImage(int nr, QImage image);
+
+	QImage loadImage(int nr);
+}
+
+#endif // FILEUTILS_H