nortega/menu-helper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: nortega:d30f8df5c1b82c4bd5649dabe6fd1e071dd37355
Branches Tags
nortega:master
nortega:v1.0
..
compare: nortega:1a590b477ef6b2cba8ac6e12313eafe571e01860
Branches Tags
nortega:master
nortega:v1.0

No commits in common. "d30f8df5c1b82c4bd5649dabe6fd1e071dd37355" and "1a590b477ef6b2cba8ac6e12313eafe571e01860" have entirely different histories.
d30f8df5c1 ... 1a590b477e

6 changed files with 276 additions and 281 deletions
Show Stats Expand all files Collapse all files

2
src/arg_parse.hpp
View File

@ -36,7 +36,7 @@ static const std::map<enum cmd_id, std::vector<std::string>> commands = {
{ CMD_ADD, {"add", "new"} },
{ CMD_LIST, {"list", "ls"} },
{ CMD_DEL, {"del", "rm"} },
{ CMD_INFO, {"info", "i"} },
{ CMD_INFO, { "info" } },
{ CMD_HELP, {"help", "-h", "--help"} },
{ CMD_VERSION, {"version", "-v", "--version"} },
};

78
src/cmd.cpp
View File

@ -19,14 +19,13 @@
#include "db.hpp"
#include "util.hpp"
#include <cstdlib>
#include <iostream>
#include <cstdlib>
#include <string>
#include <unistd.h>
#include <vector>
#include <unistd.h>
int cmd_add(void) {
db db;
int command_add(void) {
std::string name, description, ingredients, tags;
int recipe_id, ingredient_id, tag_id;
@ -42,34 +41,36 @@ int cmd_add(void) {
std::cout << "Tags (comma separated): ";
getline(std::cin, tags);
db.open();
if(not db_open()) {
std::cerr << "Failed to open database. Cannot add new entry." << std::endl;
return EXIT_FAILURE;
}
if((recipe_id = db.get_recipe_id(name)) <= 0)
recipe_id = db.add_recipe(name, description);
if((recipe_id = db_get_recipe_id(name)) <= 0)
recipe_id = db_add_recipe(name, description);
for(auto &ingredient : split(ingredients, ",")) {
trim(ingredient);
if((ingredient_id = db.get_ingredient_id(ingredient)) <= 0)
ingredient_id = db.add_ingredient(ingredient);
db.conn_recipe_ingredient(recipe_id, ingredient_id);
if((ingredient_id = db_get_ingredient_id(ingredient)) <= 0)
ingredient_id = db_add_ingredient(ingredient);
db_conn_recipe_ingredient(recipe_id, ingredient_id);
}
for(auto &tag : split(tags, ",")) {
trim(tag);
if((tag_id = db.get_tag_id(tag)) <= 0)
tag_id = db.add_tag(tag);
db.conn_recipe_tag(recipe_id, tag_id);
if((tag_id = db_get_tag_id(tag)) <= 0)
tag_id = db_add_tag(tag);
db_conn_recipe_tag(recipe_id, tag_id);
}
db.close();
db_close();
return EXIT_SUCCESS;
}
int cmd_list(int argc, char *argv[]) {
db db;
int command_list(int argc, char *argv[]) {
std::vector<std::string> ingredients, tags;
int opt;
@ -92,18 +93,21 @@ int cmd_list(int argc, char *argv[]) {
}
}
db.open();
if(not db_open()) {
std::cerr << "Failed to open database. Cannot add new entry." << std::endl;
return EXIT_FAILURE;
}
for(const auto &recipe : db.get_recipes(ingredients, tags))
for(const auto &recipe : db_get_recipes(ingredients, tags))
std::cout << recipe.id << " | " << recipe.name << " | " << recipe.description << std::endl;
db.close();
db_close();
return EXIT_SUCCESS;
}
int cmd_delete(int argc, char *argv[]) {
db db;
int command_delete(int argc, char *argv[]) {
int ret = EXIT_SUCCESS;
std::vector<int> recipe_ids;
if(argc < 1) {
@ -111,12 +115,15 @@ int cmd_delete(int argc, char *argv[]) {
return EXIT_FAILURE;
}
db.open();
if(not db_open()) {
std::cerr << "Failed to open database. Cannot add new entry." << std::endl;
return EXIT_FAILURE;
}
for(int i = 0; i < argc; ++i) {
const int id = std::stoi(argv[i]);
if(not db.recipe_exists(id)) {
if(not db_recipe_exists(id)) {
std::cerr << "No recipe exists with ID " << id << "." << std::endl;
return EXIT_FAILURE;
} else {
@ -124,30 +131,33 @@ int cmd_delete(int argc, char *argv[]) {
}
}
db.del_recipes(recipe_ids);
db.close();
ret = (db_del_recipes(recipe_ids)) ? EXIT_SUCCESS : EXIT_FAILURE;
return EXIT_SUCCESS;
db_close();
return ret;
}
int cmd_info(const int id) {
db db;
int command_info(const int id) {
struct recipe recipe;
std::vector<std::string> ingredients, tags;
int ret = EXIT_SUCCESS;
db.open();
if(not db_open()) {
std::cerr << "Failed to open database. Cannot add new entry." << std::endl;
return EXIT_FAILURE;
}
if(not db.recipe_exists(id)) {
if(not db_recipe_exists(id)) {
std::cerr << "No recipe with ID '" << id << "'";
return EXIT_FAILURE;
}
recipe = db.get_recipe(id);
ingredients = db.get_recipe_ingredients(id);
tags = db.get_recipe_tags(id);
recipe = db_get_recipe(id);
ingredients = db_get_recipe_ingredients(id);
tags = db_get_recipe_tags(id);
db.close();
db_close();
std::cout << "Name: " << recipe.name << "\n"
<< "Description: " << recipe.description << "\n"

8
src/cmd.hpp
View File

@ -17,7 +17,7 @@
*/
#pragma once
int cmd_add(void);
int cmd_list(int argc, char *argv[]);
int cmd_delete(int argc, char *argv[]);
int cmd_info(const int id);
int command_add(void);
int command_list(int argc, char *argv[]);
int command_delete(int argc, char *argv[]);
int command_info(const int id);

266
src/db.cpp
View File

@ -17,22 +17,28 @@
*/
#include "db.hpp"
#include <sqlite3.h>
#include <cstdlib>
#include <iostream>
#include <filesystem>
#include <format>
#include <iostream>
#include <sqlite3.h>
#include <stdexcept>
#include <string>
#include <vector>
#define DB_VERSION 1
static sqlite3 *db = nullptr;
void db::open(void) {
int db_open(void) {
std::string xdg_data_home;
std::string db_path;
bool new_db = false;
int rc;
if((xdg_data_home = std::getenv("XDG_DATA_HOME")).empty())
throw std::runtime_error("Cannot find environment variable XDG_DATA_HOME. Please define it before continuing.");
if((xdg_data_home = std::getenv("XDG_DATA_HOME")).empty()) {
std::cerr << "Cannot find environment variable XDG_DATA_HOME. Please define it before continuing. E.g.:\n"
"export XDG_DATA_HOME=\"$HOME/.local/share\"" << std::endl;
return 0;
}
db_path = xdg_data_home + "/menu-helper";
@ -46,26 +52,26 @@ void db::open(void) {
new_db = true;
}
if(sqlite3_open(db_path.c_str(), &sqlite_db) not_eq SQLITE_OK)
throw std::runtime_error("Failed to open database file " + db_path);
rc = sqlite3_open(db_path.c_str(), &db);
if(new_db) {
sqlite3_exec(sqlite_db, "CREATE TABLE db_version(version INTEGER UNIQUE NOT nullptr);", nullptr, nullptr, nullptr);
sqlite3_exec(sqlite_db, std::format("INSERT INTO db_version VALUES({});", DB_VERSION).c_str(), nullptr, nullptr, nullptr);
sqlite3_exec(sqlite_db, "CREATE TABLE tags(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING UNIQUE);", nullptr, nullptr, nullptr);
sqlite3_exec(sqlite_db, "CREATE TABLE ingredients(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING UNIQUE);", nullptr, nullptr, nullptr);
sqlite3_exec(sqlite_db, "CREATE TABLE recipes(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING UNIQUE, description STRING);", nullptr, nullptr, nullptr);
sqlite3_exec(sqlite_db, "CREATE TABLE recipe_tag(recipe_id INTEGER REFERENCES recipes(id) ON DELETE CASCADE, tag_id INTEGER REFERENCES tags(id) ON DELETE CASCADE);", nullptr, nullptr, nullptr);
sqlite3_exec(sqlite_db, "CREATE TABLE recipe_ingredient(recipe_id INTEGER REFERENCES recipes(id) ON DELETE CASCADE, ingredient_id INTEGER REFERENCES ingredients(id) ON DELETE CASCADE);", nullptr, nullptr, nullptr);
}
if(rc == SQLITE_OK and new_db) {
sqlite3_exec(db, "CREATE TABLE db_version(version INTEGER UNIQUE NOT nullptr);", nullptr, nullptr, nullptr);
sqlite3_exec(db, std::format("INSERT INTO db_version VALUES({});", DB_VERSION).c_str(), nullptr, nullptr, nullptr);
sqlite3_exec(db, "CREATE TABLE tags(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING UNIQUE);", nullptr, nullptr, nullptr);
sqlite3_exec(db, "CREATE TABLE ingredients(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING UNIQUE);", nullptr, nullptr, nullptr);
sqlite3_exec(db, "CREATE TABLE recipes(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING UNIQUE, description STRING);", nullptr, nullptr, nullptr);
sqlite3_exec(db, "CREATE TABLE recipe_tag(recipe_id INTEGER REFERENCES recipes(id) ON DELETE CASCADE, tag_id INTEGER REFERENCES tags(id) ON DELETE CASCADE);", nullptr, nullptr, nullptr);
sqlite3_exec(db, "CREATE TABLE recipe_ingredient(recipe_id INTEGER REFERENCES recipes(id) ON DELETE CASCADE, ingredient_id INTEGER REFERENCES ingredients(id) ON DELETE CASCADE);", nullptr, nullptr, nullptr);
}
void db::close(void) {
if(not sqlite_db)
return rc == SQLITE_OK;
}
void db_close(void) {
if(not db)
return;
sqlite3_close(sqlite_db);
sqlite_db = nullptr;
sqlite3_close(db);
}
int query_id_cb(void *recipe_id_var, int col_num, char **col_data, char **col_name) {
@ -83,47 +89,43 @@ int query_id_cb(void *recipe_id_var, int col_num, char **col_data, char **col_na
return ret;
}
int db::table_get_id_by_name(const std::string &table, const std::string &name) {
int table_get_id_by_name(const std::string &table, const std::string &name) {
int id = 0;
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(sqlite3_exec(sqlite_db, std::format("SELECT id FROM {} WHERE lower(name)=lower('{}');", table, name).c_str(),
query_id_cb, &id, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to get ID of '{}' from table '{}'.", name, table));
}
if(sqlite3_exec(db, std::format("SELECT id FROM {} WHERE lower(name)=lower('{}');", table, name).c_str(),
query_id_cb, &id, nullptr) not_eq SQLITE_OK)
return -2;
return id;
}
int db::add_recipe(const std::string &name, const std::string &description) {
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
int db_add_recipe(const std::string &name, const std::string &description) {
if(not db)
return -1;
if(sqlite3_exec(sqlite_db, std::format("INSERT INTO recipes(name,description) VALUES('{}','{}');", name, description).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error("Failed to insert new recipe into database.");
if(sqlite3_exec(db, std::format("INSERT INTO recipes(name,description) VALUES('{}','{}');", name, description).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK)
return -2;
return db_get_recipe_id(name);
}
return get_recipe_id(name);
bool db_del_recipe(const int id) {
if(not db)
return false;
if(sqlite3_exec(db, std::format("DELETE FROM recipes WHERE id={}", id).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK)
return false;
return true;
}
void db::del_recipe(const int id) {
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(sqlite3_exec(sqlite_db, std::format("DELETE FROM recipes WHERE id={}", id).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to delete recipe with ID {} from database.", id));
}
}
void db::del_recipes(const std::vector<int> &ids) {
bool db_del_recipes(const std::vector<int> &ids) {
std::string stmt = "DELETE FROM recipes WHERE id IN (";
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(not db)
return false;
bool first = true;
for(auto id : ids) {
@ -137,54 +139,53 @@ void db::del_recipes(const std::vector<int> &ids) {
stmt += ");";
if(sqlite3_exec(sqlite_db, stmt.c_str(), nullptr, nullptr, nullptr) not_eq SQLITE_OK)
throw std::runtime_error("Failed to delete recipes from database.");
if(sqlite3_exec(db, stmt.c_str(), nullptr, nullptr, nullptr) not_eq SQLITE_OK)
return false;
return true;
}
bool db::recipe_exists(const int id) {
bool db_recipe_exists(const int id) {
bool exists = false;
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(not db)
return false;
if(sqlite3_exec(sqlite_db, std::format("SELECT id FROM recipes WHERE id={}", id).c_str(),
sqlite3_exec(db, std::format("SELECT id FROM recipes WHERE id={}", id).c_str(),
[](void *found,int,char**,char**) {
*static_cast<bool*>(found) = true;
return 0;
}, &exists, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error("Failed to select from database.");
}
}, &exists, nullptr);
return exists;
}
struct recipe db::get_recipe(const int id) {
int db_get_recipe_id(const std::string &name) {
if(not db)
return -1;
return table_get_id_by_name("recipes", name);
}
struct recipe db_get_recipe(const int id) {
struct recipe recipe;
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(sqlite3_exec(sqlite_db, std::format("SELECT * FROM recipes WHERE id={};", id).c_str(),
sqlite3_exec(db, std::format("SELECT * FROM recipes WHERE id={};", id).c_str(),
[](void *recipe, int, char **col_data, char**) {
*static_cast<struct recipe*>(recipe) = { std::atoi(col_data[0]), col_data[1], col_data[2] };
return 0;
}, &recipe, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error("Failed to select from database.");
}
}, &recipe, nullptr);
return recipe;
}
std::vector<struct recipe> db::get_recipes(const std::vector<std::string> &ingredients,
std::vector<struct recipe> db_get_recipes(const std::vector<std::string> &ingredients,
const std::vector<std::string> &tags)
{
std::vector<struct recipe> recipes;
std::string stmt = "SELECT id,name,description FROM recipes";
std::string filters;
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(not ingredients.empty() or not tags.empty())
filters += " WHERE";
@ -200,10 +201,14 @@ std::vector<struct recipe> db::get_recipes(const std::vector<std::string> &ingre
filters += " id IN (SELECT recipe_id FROM recipe_ingredient WHERE ingredient_id=";
if((id = get_ingredient_id(i)) <= 0)
throw std::runtime_error(std::format("Failed to find ingredient '{}'", i));
// TODO: use throw?
if((id = db_get_ingredient_id(i)) < 0) {
std::cerr << "Failed to find ingredient '" << i << "'" << std::endl;
return std::vector<struct recipe>();
} else {
filters += std::to_string(id);
}
filters += ")";
}
}
@ -223,106 +228,111 @@ std::vector<struct recipe> db::get_recipes(const std::vector<std::string> &ingre
filters += " id IN (SELECT recipe_id FROM recipe_tag WHERE tag_id=";
if((id = get_tag_id(i)) <= 0)
throw std::runtime_error("Failed to find tag '{}'");
// TODO: use throw?
if((id = db_get_tag_id(i)) < 0) {
std::cerr << "Failed to find tag '" << i << "'" << std::endl;
return std::vector<struct recipe>();
} else {
filters += std::to_string(id);
}
filters += ")";
}
}
stmt += filters + ";";
if(sqlite3_exec(sqlite_db, stmt.c_str(),
sqlite3_exec(db, stmt.c_str(),
[](void *recipe_list, int, char **col_data, char**) {
static_cast<std::vector<struct recipe>*>(recipe_list)->push_back({
auto recipe_vec = static_cast<std::vector<struct recipe>*>(recipe_list);
recipe_vec->push_back({
std::atoi(col_data[0]),
col_data[1],
col_data[2] });
return 0;
}, &recipes, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error("Failed to select recipes.");
}
}, &recipes, nullptr);
return recipes;
}
int db::add_ingredient(const std::string &name) {
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
int db_add_ingredient(const std::string &name) {
if(not db)
return -1;
if(sqlite3_exec(sqlite_db, std::format("INSERT INTO ingredients(name) VALUES(lower('{}'));", name).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to instert ingredient '{}'.", name));
if(sqlite3_exec(db, std::format("INSERT INTO ingredients(name) VALUES(lower('{}'));", name).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK)
return -2;
return db_get_ingredient_id(name);
}
return get_ingredient_id(name);
}
std::vector<std::string> db::get_recipe_ingredients(const int id) {
std::vector<std::string> db_get_recipe_ingredients(const int id) {
std::vector<std::string> ingredients;
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(sqlite3_exec(sqlite_db, std::format("SELECT name FROM ingredients WHERE id IN (SELECT ingredient_id FROM recipe_ingredient WHERE recipe_id={});", id).c_str(),
sqlite3_exec(db, std::format("SELECT name FROM ingredients WHERE id IN (SELECT ingredient_id FROM recipe_ingredient WHERE recipe_id={});", id).c_str(),
[](void *ingredients, int, char **col_data, char**) {
static_cast<std::vector<std::string>*>(ingredients)->push_back(col_data[0]);
return 0;
}, &ingredients, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to select ingredients from recipe with ID {}", id));
}
}, &ingredients, nullptr);
return ingredients;
}
int db::add_tag(const std::string &name) {
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
int db_get_ingredient_id(const std::string &name) {
if(not db)
return -1;
if(sqlite3_exec(sqlite_db, std::format("INSERT INTO tags(name) VALUES('{}');", name).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to insert tag '{}'", name));
return table_get_id_by_name("ingredients", name);
}
return get_tag_id(name);
int db_add_tag(const std::string &name) {
if(not db)
return -1;
if(sqlite3_exec(db, std::format("INSERT INTO tags(name) VALUES('{}');", name).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK)
return -2;
return db_get_tag_id(name);
}
std::vector<std::string> db::get_recipe_tags(const int id) {
std::vector<std::string> db_get_recipe_tags(const int id) {
std::vector<std::string> tags;
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
if(sqlite3_exec(sqlite_db, std::format("SELECT name FROM tags WHERE id IN (SELECT tag_id FROM recipe_tag WHERE recipe_id={});", id).c_str(),
sqlite3_exec(db, std::format("SELECT name FROM tags WHERE id IN (SELECT tag_id FROM recipe_tag WHERE recipe_id={});", id).c_str(),
[](void *tags, int, char **col_data, char**) {
static_cast<std::vector<std::string>*>(tags)->push_back(col_data[0]);
return 0;
}, &tags, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to select tags for recipe with ID {}", id));
}
}, &tags, nullptr);
return tags;
}
void db::conn_recipe_ingredient(int recipe_id, int ingredient_id) {
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
int db_get_tag_id(const std::string &name) {
if(not db)
return -1;
if(sqlite3_exec(sqlite_db, std::format("INSERT INTO recipe_ingredient(recipe_id, ingredient_id) VALUES({},{});", recipe_id, ingredient_id).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to connect recipe with ID {} to ingredient with ID {}",
recipe_id, ingredient_id));
}
return table_get_id_by_name("tags", name);
}
void db::conn_recipe_tag(int recipe_id, int tag_id) {
if(not sqlite_db)
throw std::runtime_error(std::format("{}: Database not open! Please contact a developer.", __PRETTY_FUNCTION__));
int db_conn_recipe_ingredient(int recipe_id, int ingredient_id) {
if(not db)
return -1;
if(sqlite3_exec(sqlite_db, std::format("INSERT INTO recipe_tag(recipe_id, tag_id) VALUES({},{});", recipe_id, tag_id).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK) {
throw std::runtime_error(std::format("Failed to connect recipe with ID {} to tag with ID {}",
recipe_id, tag_id));
if(sqlite3_exec(db, std::format("INSERT INTO recipe_ingredient(recipe_id, ingredient_id) VALUES({},{});", recipe_id, ingredient_id).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK)
return -2;
return 1;
}
int db_conn_recipe_tag(int recipe_id, int tag_id) {
if(not db)
return -1;
if(sqlite3_exec(db, std::format("INSERT INTO recipe_tag(recipe_id, tag_id) VALUES({},{});", recipe_id, tag_id).c_str(),
nullptr, nullptr, nullptr) not_eq SQLITE_OK)
return -2;
return 1;
}

68
src/db.hpp
View File

@ -17,7 +17,6 @@
*/
#pragma once
#include <sqlite3.h>
#include <string>
#include <vector>
@ -27,18 +26,8 @@ struct recipe {
std::string description;
};
class db {
private:
sqlite3 *sqlite_db;
int table_get_id_by_name(const std::string &table, const std::string &name);
public:
db() : sqlite_db(nullptr) {}
~db() {
sqlite3_close(sqlite_db);
}
void open(void);
void close(void);
int db_open(void);
void db_close(void);
/**
* @brief Add a new recipe to the database.
@ -46,20 +35,18 @@ public:
* @param name Name of the new recipe.
* @param description Short description.
*
* @return ID of newly created recipe.
* @return ID of newly created recipe, -1 if DB isn't open, -2 on other failure.
*/
int add_recipe(const std::string &name, const std::string &description);
void del_recipe(const int id);
void del_recipes(const std::vector<int> &ids);
inline int get_recipe_id(const std::string &name) {
return table_get_id_by_name("recipes", name);
int db_add_recipe(const std::string &name, const std::string &description);
bool db_del_recipe(const int id);
bool db_del_recipes(const std::vector<int> &ids);
int db_get_recipe_id(const std::string &name);
bool db_recipe_exists(const int id);
static inline bool db_recipe_exists(const std::string &name) {
return (db_get_recipe_id(name) > 0);
}
inline bool db_recipe_exists(const std::string &name) {
return (get_recipe_id(name) > 0);
}
bool recipe_exists(const int id);
struct recipe get_recipe(const int id);
std::vector<struct recipe> get_recipes(const std::vector<std::string> &ingredients,
struct recipe db_get_recipe(const int id);
std::vector<struct recipe> db_get_recipes(const std::vector<std::string> &ingredients,
const std::vector<std::string> &tags);
/**
@ -67,15 +54,13 @@ public:
*
* @param name Name of the new ingredient.
*
* @return ID of newly created ingredient.
* @return ID of newly created ingredient, -1 if DB isn't open, -2 on other failure.
*/
int add_ingredient(const std::string &name);
std::vector<std::string> get_recipe_ingredients(const int id);
inline int get_ingredient_id(const std::string &name) {
return table_get_id_by_name("ingredients", name);
}
inline bool db_ingredient_exists(const std::string &name) {
return (get_ingredient_id(name) > 0);
int db_add_ingredient(const std::string &name);
std::vector<std::string> db_get_recipe_ingredients(const int id);
int db_get_ingredient_id(const std::string &name);
static inline bool db_ingredient_exists(const std::string &name) {
return (db_get_ingredient_id(name) > 0);
}
/**
@ -85,15 +70,12 @@ public:
*
* @return ID of newly created tag, -1 if DB isn't open, -2 on other failure.
*/
int add_tag(const std::string &name);
std::vector<std::string> get_recipe_tags(const int id);
inline int get_tag_id(const std::string &name) {
return table_get_id_by_name("tags", name);
}
inline bool tag_exists(const std::string &name) {
return (get_tag_id(name) > 0);
int db_add_tag(const std::string &name);
std::vector<std::string> db_get_recipe_tags(const int id);
int db_get_tag_id(const std::string &name);
static inline bool db_tag_exists(const std::string &name) {
return (db_get_tag_id(name) > 0);
}
void conn_recipe_ingredient(int recipe_id, int ingredient_id);
void conn_recipe_tag(int recipe_id, int tag_id);
};
int db_conn_recipe_ingredient(int recipe_id, int ingredient_id);
int db_conn_recipe_tag(int recipe_id, int tag_id);

19
src/main.cpp
View File

@ -16,9 +16,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <cstdlib>
#include <exception>
#include <iostream>
#include <cstdlib>
#include <string>
#include "arg_parse.hpp"
@ -36,19 +35,18 @@ int main(int argc, char *argv[]) {
id = parse_args(argv[1]);
try {
switch(id) {
case CMD_ADD:
ret = cmd_add();
ret = command_add();
break;
case CMD_LIST:
ret = cmd_list(argc - 1, argv + 1);
ret = command_list(argc - 1, argv + 1);
break;
case CMD_DEL:
ret = cmd_delete(argc - 2, argv + 2);
ret = command_delete(argc - 2, argv + 2);
break;
case CMD_INFO:
ret = cmd_info(std::stoi(argv[2]));
ret = command_info(std::stoi(argv[2]));
break;
case CMD_HELP:
print_help();
@ -59,12 +57,7 @@ int main(int argc, char *argv[]) {
default:
std::cerr << "No such command '" << argv[1] << "'. Use 'help' sub-command." << std::endl;
print_usage();
ret = EXIT_FAILURE;
break;
}
} catch(const std::exception &e) {
std::cerr << e.what() << std::endl;
ret = EXIT_FAILURE;
return EXIT_FAILURE;
}
return ret;