vyn/mirai
1
Fork 0
mirror of https://codeberg.org/vyn/mirai.git synced 2025-07-01 17:03:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[WIP] convert to snake_case

Browse source
This commit is contained in:
Vyn 2025-06-27 10:55:56 +02:00
parent 4bca7fac3e
commit 9de3972630
Signed by: vyn
GPG key ID: E1B2BE34E7A971E7
17 changed files with 335 additions and 336 deletions
Download patch file Download diff file Expand all files Collapse all files

82
external/mirai-core/include/mirai-core/DataProvider.h vendored
View file

@ -14,33 +14,33 @@
namespace mirai namespace mirai
{ {
struct DayData { struct day_data {
int id; int id;
Date date; Date date;
}; };
struct UpdatableDayData { struct updatable_day_data {
std::optional<Date> date; std::optional<Date> date;
}; };
enum TaskState { TODO, DONE }; enum task_state { TODO, DONE };
struct TaskData { struct task_data {
int id; int id;
std::string title; std::string title;
TaskState state; task_state state;
std::optional<int> dayId; std::optional<int> dayId;
std::optional<int> eventId; std::optional<int> eventId;
}; };
struct UpdatableTaskData { struct updatable_task_data {
std::optional<std::string> title = std::nullopt; std::optional<std::string> title = std::nullopt;
std::optional<TaskState> state = std::nullopt; std::optional<task_state> state = std::nullopt;
std::optional<std::optional<int>> dayId = std::nullopt; std::optional<std::optional<int>> dayId = std::nullopt;
std::optional<std::optional<int>> eventId = std::nullopt; std::optional<std::optional<int>> eventId = std::nullopt;
}; };
struct EventData { struct event_data {
int id; int id;
int dayId; int dayId;
std::string title; std::string title;
@ -48,69 +48,69 @@ struct EventData {
Time endsAt; Time endsAt;
}; };
struct UpdatableEventData { struct updatable_event_data {
std::optional<int> dayId; std::optional<int> dayId;
std::optional<std::string> title; std::optional<std::string> title;
std::optional<Time> startsAt; std::optional<Time> startsAt;
std::optional<Time> endsAt; std::optional<Time> endsAt;
}; };
class DataProvider class data_provider
{ {
public: public:
DataProvider() {}; data_provider() {};
DataProvider(DataProvider &) = delete; data_provider(data_provider &) = delete;
DataProvider(DataProvider &&) = delete; data_provider(data_provider &&) = delete;
virtual ~DataProvider() = default; virtual ~data_provider() = default;
virtual void save() = 0; virtual void save() = 0;
virtual void load() = 0; virtual void load() = 0;
virtual std::string name() const = 0; virtual std::string name() const = 0;
// Tasks // Tasks
virtual TaskData insertTask(const TaskData &task) = 0; virtual task_data insert_task(const task_data &task) = 0;
virtual void removeTaskById(int taskId) = 0; virtual void remove_task_by_id(int taskId) = 0;
virtual std::optional<TaskData> getTaskById(int taskId) = 0; virtual std::optional<task_data> get_task_by_id(int taskId) = 0;
virtual std::vector<TaskData> getTasksByEventId(int eventId) = 0; virtual std::vector<task_data> get_tasks_by_event_id(int eventId) = 0;
virtual std::vector<TaskData> getTasksByDayId(int dayId) = 0; virtual std::vector<task_data> get_tasks_by_day_id(int dayId) = 0;
virtual std::vector<TaskData> getTasksByDate(Date date) = 0; virtual std::vector<task_data> get_tasks_by_date(Date date) = 0;
virtual std::vector<TaskData> getTasksWithoutDate() = 0; virtual std::vector<task_data> get_tasks_without_date() = 0;
virtual std::vector<TaskData> getTasks() = 0; virtual std::vector<task_data> get_tasks() = 0;
virtual void updateTask(int taskId, UpdatableTaskData updateData) = 0; virtual void update_task(int taskId, updatable_task_data updateData) = 0;
// Events // Events
virtual EventData insertEvent(const EventData &task) = 0; virtual event_data insertEvent(const event_data &task) = 0;
virtual void removeEventById(int eventId) = 0; virtual void remove_event_by_id(int eventId) = 0;
virtual std::optional<EventData> getEventById(int eventId) = 0; virtual std::optional<event_data> get_event_by_id(int eventId) = 0;
virtual std::vector<EventData> getEvents() = 0; virtual std::vector<event_data> get_events() = 0;
virtual std::vector<EventData> getEventsByDate(Date date) = 0; virtual std::vector<event_data> get_events_by_date(Date date) = 0;
virtual void updateEvent(int eventId, UpdatableEventData updateData) = 0; virtual void update_event(int eventId, updatable_event_data updateData) = 0;
// Days // Days
virtual DayData insertDay(const DayData &day) = 0; virtual day_data insert_day(const day_data &day) = 0;
virtual void removeDayById(int dayId) = 0; virtual void remove_day_by_id(int dayId) = 0;
virtual std::vector<DayData> getDays() = 0; virtual std::vector<day_data> get_days() = 0;
virtual std::optional<DayData> getDayByDate(const Date &date) = 0; virtual std::optional<day_data> get_day_by_date(const Date &date) = 0;
virtual void updateDay(int dayId, UpdatableDayData updateData) = 0; virtual void update_day(int dayId, updatable_day_data updateData) = 0;
const int id = DataProvider::generateNextId(); const int id = data_provider::generate_next_id();
void setDirty(bool dirty) void set_dirty(bool dirty)
{ {
isDirty_ = dirty; _is_dirty = dirty;
}; };
bool isDirty() const bool is_dirty() const
{ {
return isDirty_; return _is_dirty;
}; };
private: private:
bool isDirty_ = false; bool _is_dirty = false;
static int generateNextId() static int generate_next_id()
{ {
static int nextId = 0; static int nextId = 0;
return nextId++; return nextId++;

6
external/mirai-core/include/mirai-core/Day.h vendored
View file

@ -19,7 +19,7 @@ class Day
{ {
public: public:
Day(DataProvider *data, DayData day) : data_(data), dayData_(day) {}; Day(data_provider *data, day_data day) : data_(data), dayData_(day) {};
Date date() const; Date date() const;
std::vector<Task> tasks(); std::vector<Task> tasks();
@ -31,8 +31,8 @@ class Day
int sourceId() const; int sourceId() const;
private: private:
DayData dayData_; day_data dayData_;
DataProvider *data_; data_provider *data_;
}; };
} // namespace mirai } // namespace mirai

6
external/mirai-core/include/mirai-core/Event.h vendored
View file

@ -20,7 +20,7 @@ class Event
{ {
public: public:
Event(DataProvider *data, EventData eventData) : data_(data), eventData_(eventData) {}; Event(data_provider *data, event_data eventData) : data_(data), eventData_(eventData) {};
std::string title() const; std::string title() const;
Time startsAt() const; Time startsAt() const;
@ -37,8 +37,8 @@ class Event
int sourceId() const; int sourceId() const;
private: private:
EventData eventData_; event_data eventData_;
DataProvider *data_; data_provider *data_;
}; };
} // namespace mirai } // namespace mirai

62
external/mirai-core/include/mirai-core/MarkdownDataProvider.h vendored
View file

@ -19,22 +19,22 @@
namespace mirai namespace mirai
{ {
struct MarkdownData { struct markdown_data {
std::string name; std::string name;
std::vector<TaskData> tasks; std::vector<task_data> tasks;
std::vector<DayData> days; std::vector<day_data> days;
std::vector<EventData> events; std::vector<event_data> events;
}; };
class MarkdownDataProvider : public DataProvider class markdown_data_provider : public data_provider
{ {
public: public:
MarkdownDataProvider(const std::string &filePath) : filePath_(filePath), DataProvider() markdown_data_provider(const std::string &file_path) : _file_path(file_path), data_provider()
{ {
} }
std::string toMarkdown(); std::string to_markdown();
MarkdownData parseMarkdown(const std::string &content); markdown_data parse_markdown(const std::string &content);
std::string path() const; std::string path() const;
@ -44,35 +44,35 @@ class MarkdownDataProvider : public DataProvider
std::string name() const override; std::string name() const override;
// Tasks // Tasks
TaskData insertTask(const TaskData &task) override; task_data insert_task(const task_data &task) override;
void removeTaskById(int taskId) override; void remove_task_by_id(int taskId) override;
std::optional<TaskData> getTaskById(int taskId) override; std::optional<task_data> get_task_by_id(int taskId) override;
std::vector<TaskData> getTasksByEventId(int eventId) override; std::vector<task_data> get_tasks_by_event_id(int eventId) override;
std::vector<TaskData> getTasksByDayId(int dayId) override; std::vector<task_data> get_tasks_by_day_id(int dayId) override;
std::vector<TaskData> getTasksByDate(Date date) override; std::vector<task_data> get_tasks_by_date(Date date) override;
std::vector<TaskData> getTasksWithoutDate() override; std::vector<task_data> get_tasks_without_date() override;
std::vector<TaskData> getTasks() override; std::vector<task_data> get_tasks() override;
void updateTask(int taskId, UpdatableTaskData updateData) override; void update_task(int taskId, updatable_task_data updateData) override;
// Events // Events
EventData insertEvent(const EventData &task) override; event_data insertEvent(const event_data &task) override;
void removeEventById(int eventId) override; void remove_event_by_id(int eventId) override;
std::optional<EventData> getEventById(int eventId) override; std::optional<event_data> get_event_by_id(int eventId) override;
std::vector<EventData> getEvents() override; std::vector<event_data> get_events() override;
std::vector<EventData> getEventsByDate(Date date) override; std::vector<event_data> get_events_by_date(Date date) override;
void updateEvent(int eventId, UpdatableEventData updateData) override; void update_event(int eventId, updatable_event_data updateData) override;
// Days // Days
DayData insertDay(const DayData &day) override; day_data insert_day(const day_data &day) override;
void removeDayById(int dayId) override; void remove_day_by_id(int dayId) override;
std::vector<DayData> getDays() override; std::vector<day_data> get_days() override;
std::optional<DayData> getDayByDate(const Date &date) override; std::optional<day_data> get_day_by_date(const Date &date) override;
void updateDay(int dayId, UpdatableDayData updateData) override; void update_day(int dayId, updatable_day_data updateData) override;
private: private:
std::string name_; std::string _name;
std::string filePath_; std::string _file_path;
MarkdownData data; markdown_data _data;
}; };
} // namespace mirai } // namespace mirai

18
external/mirai-core/include/mirai-core/Mirai.h vendored
View file

@ -22,7 +22,7 @@ class Mirai
public: public:
Mirai(const std::string &configFilePath); Mirai(const std::string &configFilePath);
void addSource( void addSource(
const std::string &name, const std::string &type, std::unique_ptr<DataProvider> &&source const std::string &name, const std::string &type, std::unique_ptr<data_provider> &&source
); );
void void
editSource(int id, const std::string &name, const std::string &color, const std::string &path); editSource(int id, const std::string &name, const std::string &color, const std::string &path);
@ -30,25 +30,25 @@ class Mirai
void unloadAllSources(); void unloadAllSources();
void save(); void save();
std::vector<std::unique_ptr<Source>> &getSources(); std::vector<std::unique_ptr<source>> &getSources();
const std::vector<std::string> &getTags(); const std::vector<std::string> &getTags();
// Returns a non owning pointer to the requested resource or nullptr if not found. // Returns a non owning pointer to the requested resource or nullptr if not found.
Source *getSourceById(int id); source *getSourceById(int id);
Source *getSourceByName(const std::string &name); source *getSourceByName(const std::string &name);
void onSourceAdded(std::function<void(Source *)> f); void onSourceAdded(std::function<void(source *)> f);
void onSourceEdited(std::function<void(Source *)> f); void onSourceEdited(std::function<void(source *)> f);
void onSourceDeleted(std::function<void(int)> f); void onSourceDeleted(std::function<void(int)> f);
private: private:
void loadConfig(const std::string &path); void loadConfig(const std::string &path);
void saveConfig(); void saveConfig();
std::vector<std::unique_ptr<Source>> sources_; std::vector<std::unique_ptr<source>> sources_;
std::string configPath_; std::string configPath_;
EventEmitter<Source *> sourceAdded; EventEmitter<source *> sourceAdded;
EventEmitter<Source *> sourceEdited; EventEmitter<source *> sourceEdited;
EventEmitter<int> sourceDeleted; EventEmitter<int> sourceDeleted;
}; };
} // namespace mirai } // namespace mirai

68
external/mirai-core/include/mirai-core/Source.h vendored
View file

@ -33,24 +33,24 @@ struct createEventParams {
struct SourceConstructor { struct SourceConstructor {
std::string name; std::string name;
std::string color; std::string color;
DataProvider *sourceDataProvider; data_provider *sourceDataProvider;
}; };
class Source class source
{ {
public: public:
Source(SourceConstructor params) source(SourceConstructor params)
: data(params.sourceDataProvider), name_(params.name), color_(params.color), : data(params.sourceDataProvider), _name(params.name), _color(params.color),
type_("FileSystemMarkdown") _type("FileSystemMarkdown")
{ {
} }
Source(Source &) = delete; source(source &) = delete;
Source(Source &&) = delete; source(source &&) = delete;
Source operator=(Source &) = delete; source operator=(source &) = delete;
Source operator=(Source &&) = delete; source operator=(source &&) = delete;
~Source() = default; ~source() = default;
void init(); void init();
void save(); void save();
@ -59,44 +59,44 @@ class Source
std::string name() const; std::string name() const;
std::string type() const; std::string type() const;
std::string color() const; std::string color() const;
DataProvider *dataProvider(); class data_provider *data_provider();
void setName(const std::string &name); void set_name(const std::string &name);
void setColor(const std::string &color); void set_color(const std::string &color);
void createTask(const createTaskParams &task); void create_task(const createTaskParams &task);
void removeTask(const Task &task); void remove_task(const Task &task);
std::optional<Task> getTaskById(int taskId); std::optional<Task> get_task_by_id(int taskId);
std::vector<Task> getTasksByDate(Date date); std::vector<Task> get_tasks_by_date(Date date);
std::vector<Task> getUnscheduledTasks(); std::vector<Task> get_unscheduled_tasks();
std::vector<Task> getTasks(); std::vector<Task> get_tasks();
void createEvent(const createEventParams &eventToCreate); void create_event(const createEventParams &eventToCreate);
void removeEvent(const Event &event); void remove_event(const Event &event);
std::vector<Event> getEvents(); std::vector<Event> get_events();
std::optional<Event> getEventById(int eventId); std::optional<Event> get_event_by_id(int eventId);
std::vector<Event> getEventsByDate(Date date); std::vector<Event> get_events_by_date(Date date);
std::vector<Day> getDays(); std::vector<Day> get_days();
std::optional<Day> getDayByDate(Date date); std::optional<Day> get_day_by_date(Date date);
const int id = Source::generateNextId(); const int id = source::generate_next_id();
bool isDirty() const bool is_dirty() const
{ {
return data->isDirty(); return data->is_dirty();
}; };
private: private:
static int generateNextId() static int generate_next_id()
{ {
static int nextId = 0; static int nextId = 0;
return nextId++; return nextId++;
} }
std::string name_; std::string _name;
std::string type_; std::string _type;
std::string color_; std::string _color;
DataProvider *data; class data_provider *data;
}; };
} // namespace mirai } // namespace mirai

8
external/mirai-core/include/mirai-core/Task.h vendored
View file

@ -19,10 +19,10 @@ class Task
{ {
public: public:
Task(DataProvider *data, TaskData task) : data_(data), task_(task) {}; Task(data_provider *data, task_data task) : data_(data), task_(task) {};
std::string title() const; std::string title() const;
mirai::TaskState state() const; mirai::task_state state() const;
bool checked() const; bool checked() const;
bool hasEvent() const; bool hasEvent() const;
bool hasDate() const; bool hasDate() const;
@ -38,8 +38,8 @@ class Task
int sourceId() const; int sourceId() const;
private: private:
TaskData task_; task_data task_;
DataProvider *data_; data_provider *data_;
}; };
} // namespace mirai } // namespace mirai

6
external/mirai-core/include/mirai-core/View.h vendored
View file

@ -40,10 +40,10 @@ class View
void update(); void update();
void removeSources(); void removeSources();
void addSource(const Source &source); void addSource(const source &source);
void setSources(const std::vector<Source> &sources); void setSources(const std::vector<source> &sources);
void setAllSources(); void setAllSources();
bool isSourceSelected(const Source &source) const; bool isSourceSelected(const source &source) const;
size_t activeSourceCount() const; size_t activeSourceCount() const;

8
external/mirai-core/src/Day.cpp vendored
View file

@ -29,11 +29,11 @@ Date Day::date() const
std::vector<Task> Day::tasks() std::vector<Task> Day::tasks()
{ {
auto tasksData = data_->getTasksByDayId(id()); auto tasksData = data_->get_tasks_by_day_id(id());
std::vector<Task> tasks; std::vector<Task> tasks;
std::transform( std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks), tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const TaskData &taskData) { [&](const task_data &taskData) {
return Task{data_, taskData}; return Task{data_, taskData};
} }
); );
@ -42,11 +42,11 @@ std::vector<Task> Day::tasks()
std::vector<Event> Day::events() std::vector<Event> Day::events()
{ {
auto eventsData = data_->getEventsByDate(dayData_.date); auto eventsData = data_->get_events_by_date(dayData_.date);
std::vector<Event> events; std::vector<Event> events;
std::transform( std::transform(
eventsData.begin(), eventsData.end(), std::back_inserter(events), eventsData.begin(), eventsData.end(), std::back_inserter(events),
[&](const EventData &eventData) { [&](const event_data &eventData) {
return Event{data_, eventData}; return Event{data_, eventData};
} }
); );

12
external/mirai-core/src/Event.cpp vendored
View file

@ -38,11 +38,11 @@ Time Event::endsAt() const
std::vector<Task> Event::queryTasks() const std::vector<Task> Event::queryTasks() const
{ {
auto tasksData = data_->getTasksByEventId(eventData_.id); auto tasksData = data_->get_tasks_by_event_id(eventData_.id);
std::vector<Task> tasks; std::vector<Task> tasks;
std::transform( std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks), tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const TaskData &taskData) { [&](const task_data &taskData) {
return Task{data_, taskData}; return Task{data_, taskData};
} }
); );
@ -51,21 +51,21 @@ std::vector<Task> Event::queryTasks() const
void Event::setTitle(const std::string &newTitle) void Event::setTitle(const std::string &newTitle)
{ {
data_->updateEvent(id(), {.title = newTitle}); data_->update_event(id(), {.title = newTitle});
} }
void Event::setDay(const Day &day) void Event::setDay(const Day &day)
{ {
data_->updateEvent(id(), {.dayId = day.id()}); data_->update_event(id(), {.dayId = day.id()});
} }
void Event::setStartTime(const Time &time) void Event::setStartTime(const Time &time)
{ {
data_->updateEvent(id(), {.startsAt = time}); data_->update_event(id(), {.startsAt = time});
} }
void Event::setEndTime(const Time &time) void Event::setEndTime(const Time &time)
{ {
data_->updateEvent(id(), {.endsAt = time}); data_->update_event(id(), {.endsAt = time});
} }
} // namespace mirai } // namespace mirai

51
external/mirai-core/src/MarkdownDataProvider.Parser.cpp vendored
View file

@ -37,16 +37,17 @@ std::string fieldWithSpace(const std::string &field)
return (field + " "); return (field + " ");
} }
TaskData stringToTask(const std::string &str, const std::string &date) task_data stringToTask(const std::string &str, const std::string &date)
{ {
std::smatch matches; std::smatch matches;
std::regex regex("- \\[(\\s|X)\\] (([0-9]{2}:[0-9]{2})-([0-9]{2}:[0-9]{2}) > )?(.*?)( -- (.*))?" std::regex regex(
"- \\[(\\s|X)\\] (([0-9]{2}:[0-9]{2})-([0-9]{2}:[0-9]{2}) > )?(.*?)( -- (.*))?"
); );
std::regex_match(str, matches, regex); std::regex_match(str, matches, regex);
std::string text = stringUtils::trim(matches[5]); std::string text = stringUtils::trim(matches[5]);
TaskData taskItem{ task_data taskItem{
.title = text, .title = text,
.state = str.substr(0, 5) == "- [X]" ? DONE : TODO, .state = str.substr(0, 5) == "- [X]" ? DONE : TODO,
}; };
@ -69,7 +70,7 @@ Time stringToTime(const std::string &str)
return time; return time;
} }
EventData stringToEvent(const std::string &str, const std::string &dateString) event_data stringToEvent(const std::string &str, const std::string &dateString)
{ {
std::smatch matches; std::smatch matches;
std::regex regex("> (([0-9]{2}h[0-9]{2})-([0-9]{2}h[0-9]{2}) )(.*?)( -- (.*))?"); std::regex regex("> (([0-9]{2}h[0-9]{2})-([0-9]{2}h[0-9]{2}) )(.*?)( -- (.*))?");
@ -83,7 +84,7 @@ EventData stringToEvent(const std::string &str, const std::string &dateString)
throw std::runtime_error("Malformated date"); throw std::runtime_error("Malformated date");
} }
EventData eventData{ event_data eventData{
.title = text, .title = text,
.startsAt = stringToTime(matches[2]), .startsAt = stringToTime(matches[2]),
.endsAt = stringToTime(matches[3]), .endsAt = stringToTime(matches[3]),
@ -91,23 +92,23 @@ EventData stringToEvent(const std::string &str, const std::string &dateString)
return eventData; return eventData;
} }
std::string taskToString(const TaskData &task) std::string taskToString(const task_data &task)
{ {
std::string str = task.title; std::string str = task.title;
str = (task.state == DONE ? "- [X] " : "- [ ] ") + str; str = (task.state == DONE ? "- [X] " : "- [ ] ") + str;
return str; return str;
} }
std::string MarkdownDataProvider::toMarkdown() std::string markdown_data_provider::to_markdown()
{ {
const std::vector<DayData> days = getDays(); const std::vector<day_data> days = get_days();
std::string result = "# " + name() + "\n\n"; std::string result = "# " + name() + "\n\n";
std::string currentDate = ""; std::string currentDate = "";
for (const auto &day : days) { for (const auto &day : days) {
auto &date = day.date; auto &date = day.date;
auto tasks = getTasksByDayId(day.id); auto tasks = get_tasks_by_day_id(day.id);
auto events = getEventsByDate(date); auto events = get_events_by_date(date);
if (tasks.size() == 0 && events.size() == 0) { if (tasks.size() == 0 && events.size() == 0) {
continue; continue;
} }
@ -122,7 +123,7 @@ std::string MarkdownDataProvider::toMarkdown()
end.minute, event.title end.minute, event.title
) + ) +
"\n"; "\n";
for (const auto &task : getTasksByEventId(event.id)) { for (const auto &task : get_tasks_by_event_id(event.id)) {
result += taskToString(task) + '\n'; result += taskToString(task) + '\n';
} }
result += '\n'; result += '\n';
@ -133,7 +134,7 @@ std::string MarkdownDataProvider::toMarkdown()
result += '\n'; result += '\n';
} }
auto unscheduledTasks = getTasksWithoutDate(); auto unscheduledTasks = get_tasks_without_date();
if (unscheduledTasks.size() > 0) { if (unscheduledTasks.size() > 0) {
result += "## Unscheduled\n\n"; result += "## Unscheduled\n\n";
for (const auto &task : unscheduledTasks) { for (const auto &task : unscheduledTasks) {
@ -144,7 +145,7 @@ std::string MarkdownDataProvider::toMarkdown()
return result; return result;
}; };
MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content) markdown_data markdown_data_provider::parse_markdown(const std::string &content)
{ {
cpputils::debug::Timer readMdFormatDuration; cpputils::debug::Timer readMdFormatDuration;
@ -156,13 +157,13 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
std::println("Couldn't find the task list name"); std::println("Couldn't find the task list name");
} }
data.name = line.substr(2); _data.name = line.substr(2);
std::string currentDateString = ""; std::string currentDateString = "";
std::vector<mirai::DayData> daysData; std::vector<mirai::day_data> daysData;
std::vector<mirai::TaskData> unscheduledTasks; std::vector<mirai::task_data> unscheduledTasks;
std::optional<Date> currentDate = std::nullopt; std::optional<Date> currentDate = std::nullopt;
std::optional<EventData> currentEvent = std::nullopt; std::optional<event_data> currentEvent = std::nullopt;
cpputils::debug::Timer stringToTaskDuration; cpputils::debug::Timer stringToTaskDuration;
stringToTaskDuration.reset(); stringToTaskDuration.reset();
@ -178,11 +179,11 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
if (!currentDate.has_value()) { if (!currentDate.has_value()) {
throw std::runtime_error("Malformated date (1)"); throw std::runtime_error("Malformated date (1)");
} }
insertDay({.id = generateUniqueId(), .date = currentDate.value()}); insert_day({.id = generateUniqueId(), .date = currentDate.value()});
} else if (line.starts_with("> ")) { } else if (line.starts_with("> ")) {
auto event = stringToEvent(line, currentDateString); auto event = stringToEvent(line, currentDateString);
if (currentDate.has_value()) { if (currentDate.has_value()) {
auto day = getDayByDate(currentDate.value()); auto day = get_day_by_date(currentDate.value());
currentEvent = insertEvent( currentEvent = insertEvent(
{.id = generateUniqueId(), {.id = generateUniqueId(),
.dayId = day->id, .dayId = day->id,
@ -193,10 +194,10 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
} }
} else if (line.starts_with("- [ ]") || line.starts_with("- [X]")) { } else if (line.starts_with("- [ ]") || line.starts_with("- [X]")) {
stringToTaskDuration.start(); stringToTaskDuration.start();
TaskData taskItemData = stringToTask(line, currentDateString); task_data taskItemData = stringToTask(line, currentDateString);
stringToTaskDuration.stop(); stringToTaskDuration.stop();
if (currentEvent.has_value()) { if (currentEvent.has_value()) {
insertTask({ insert_task({
.id = generateUniqueId(), .id = generateUniqueId(),
.title = taskItemData.title, .title = taskItemData.title,
.state = taskItemData.state, .state = taskItemData.state,
@ -204,8 +205,8 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
.eventId = currentEvent.value().id, .eventId = currentEvent.value().id,
}); });
} else if (currentDate.has_value()) { } else if (currentDate.has_value()) {
auto day = getDayByDate(currentDate.value()); auto day = get_day_by_date(currentDate.value());
insertTask({ insert_task({
.id = generateUniqueId(), .id = generateUniqueId(),
.title = taskItemData.title, .title = taskItemData.title,
.state = taskItemData.state, .state = taskItemData.state,
@ -213,7 +214,7 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
.eventId = std::nullopt, .eventId = std::nullopt,
}); });
} else { } else {
insertTask({ insert_task({
.id = generateUniqueId(), .id = generateUniqueId(),
.title = taskItemData.title, .title = taskItemData.title,
.state = taskItemData.state, .state = taskItemData.state,
@ -229,6 +230,6 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
gelinesDuration.printTimeElapsed("getlinesDuration"); gelinesDuration.printTimeElapsed("getlinesDuration");
stringToTaskDuration.printTimeElapsed("stringToTaskDuration"); stringToTaskDuration.printTimeElapsed("stringToTaskDuration");
readMdFormatDuration.printTimeElapsed("Reading MD File duration"); readMdFormatDuration.printTimeElapsed("Reading MD File duration");
return data; return _data;
} }
} // namespace mirai } // namespace mirai

144
external/mirai-core/src/MarkdownDataProvider.cpp vendored
View file

@ -18,33 +18,33 @@
namespace mirai namespace mirai
{ {
std::string MarkdownDataProvider::path() const std::string markdown_data_provider::path() const
{ {
return filePath_; return _file_path;
} }
std::string MarkdownDataProvider::name() const std::string markdown_data_provider::name() const
{ {
return data.name; return _data.name;
} }
void MarkdownDataProvider::save() void markdown_data_provider::save()
{ {
std::ofstream file(filePath_); std::ofstream file(_file_path);
if (!file.is_open()) { if (!file.is_open()) {
throw std::runtime_error("can't create " + filePath_); throw std::runtime_error("can't create " + _file_path);
} }
const std::string content = toMarkdown(); const std::string content = to_markdown();
file << content; file << content;
file.close(); file.close();
setDirty(false); set_dirty(false);
}; };
void MarkdownDataProvider::load() void markdown_data_provider::load()
{ {
std::ifstream file(filePath_); std::ifstream file(_file_path);
if (!file.is_open()) { if (!file.is_open()) {
return; return;
} }
@ -55,19 +55,19 @@ void MarkdownDataProvider::load()
content += line + "\n"; content += line + "\n";
} }
file.close(); file.close();
data = parseMarkdown(content); _data = parse_markdown(content);
}; };
TaskData MarkdownDataProvider::insertTask(const TaskData &taskData) task_data markdown_data_provider::insert_task(const task_data &taskData)
{ {
data.tasks.push_back(taskData); _data.tasks.push_back(taskData);
setDirty(true); set_dirty(true);
return taskData; return taskData;
} }
void MarkdownDataProvider::updateTask(int taskId, UpdatableTaskData updateData) void markdown_data_provider::update_task(int taskId, updatable_task_data updateData)
{ {
auto taskData = ptrFindFirst(data.tasks, [&](const TaskData &task) { auto taskData = ptrFindFirst(_data.tasks, [&](const task_data &task) {
return task.id == taskId; return task.id == taskId;
}); });
assert(taskData != nullptr); // Shouldn't be possible assert(taskData != nullptr); // Shouldn't be possible
@ -83,122 +83,122 @@ void MarkdownDataProvider::updateTask(int taskId, UpdatableTaskData updateData)
if (updateData.eventId.has_value()) { if (updateData.eventId.has_value()) {
taskData->eventId = updateData.eventId.value(); taskData->eventId = updateData.eventId.value();
} }
setDirty(true); set_dirty(true);
} }
std::optional<TaskData> MarkdownDataProvider::getTaskById(int taskId) std::optional<task_data> markdown_data_provider::get_task_by_id(int taskId)
{ {
return findFirst(data.tasks, [&](const TaskData &task) { return findFirst(_data.tasks, [&](const task_data &task) {
return task.id == taskId; return task.id == taskId;
}); });
} }
std::vector<TaskData> MarkdownDataProvider::getTasksByEventId(int eventId) std::vector<task_data> markdown_data_provider::get_tasks_by_event_id(int eventId)
{ {
return findAll(data.tasks, [&](const TaskData &task) { return findAll(_data.tasks, [&](const task_data &task) {
return task.eventId == eventId; return task.eventId == eventId;
}); });
} }
std::vector<TaskData> MarkdownDataProvider::getTasksByDayId(int dayId) std::vector<task_data> markdown_data_provider::get_tasks_by_day_id(int dayId)
{ {
return findAll(data.tasks, [&](const TaskData &task) { return findAll(_data.tasks, [&](const task_data &task) {
return task.dayId == dayId; return task.dayId == dayId;
}); });
} }
std::vector<TaskData> MarkdownDataProvider::getTasksWithoutDate() std::vector<task_data> markdown_data_provider::get_tasks_without_date()
{ {
return findAll(data.tasks, [](const TaskData &t) { return findAll(_data.tasks, [](const task_data &t) {
return t.dayId == std::nullopt && t.eventId == std::nullopt; return t.dayId == std::nullopt && t.eventId == std::nullopt;
}); });
} }
std::vector<TaskData> MarkdownDataProvider::getTasksByDate(Date date) std::vector<task_data> markdown_data_provider::get_tasks_by_date(Date date)
{ {
auto day = getDayByDate(date); auto day = get_day_by_date(date);
if (!day.has_value()) { if (!day.has_value()) {
return {}; return {};
} }
return findAll(data.tasks, [&](const TaskData &t) { return findAll(_data.tasks, [&](const task_data &t) {
return t.dayId == day.value().id; return t.dayId == day.value().id;
}); });
} }
std::vector<TaskData> MarkdownDataProvider::getTasks() std::vector<task_data> markdown_data_provider::get_tasks()
{ {
return data.tasks; return _data.tasks;
} }
void MarkdownDataProvider::removeTaskById(int taskId) void markdown_data_provider::remove_task_by_id(int taskId)
{ {
data.tasks.erase( _data.tasks.erase(
std::remove_if( std::remove_if(
data.tasks.begin(), data.tasks.end(), _data.tasks.begin(), _data.tasks.end(),
[&](const TaskData &task) { [&](const task_data &task) {
return task.id == taskId; return task.id == taskId;
} }
), ),
data.tasks.end() _data.tasks.end()
); );
setDirty(true); set_dirty(true);
} }
DayData MarkdownDataProvider::insertDay(const DayData &dayData) day_data markdown_data_provider::insert_day(const day_data &dayData)
{ {
data.days.push_back(dayData); _data.days.push_back(dayData);
setDirty(true); set_dirty(true);
return dayData; return dayData;
} }
void MarkdownDataProvider::updateDay(int dayId, UpdatableDayData updateData) void markdown_data_provider::update_day(int dayId, updatable_day_data updateData)
{ {
auto dayData = ptrFindFirst(data.days, [&](const DayData &day) { auto dayData = ptrFindFirst(_data.days, [&](const day_data &day) {
return day.id == dayId; return day.id == dayId;
}); });
assert(dayData != nullptr); // Shouldn't be possible assert(dayData != nullptr); // Shouldn't be possible
if (updateData.date.has_value()) { if (updateData.date.has_value()) {
dayData->date = updateData.date.value(); dayData->date = updateData.date.value();
} }
setDirty(true); set_dirty(true);
} }
void MarkdownDataProvider::removeDayById(int dayId) void markdown_data_provider::remove_day_by_id(int dayId)
{ {
data.days.erase( _data.days.erase(
std::remove_if( std::remove_if(
data.days.begin(), data.days.end(), _data.days.begin(), _data.days.end(),
[&](const DayData &day) { [&](const day_data &day) {
return day.id == dayId; return day.id == dayId;
} }
), ),
data.days.end() _data.days.end()
); );
setDirty(true); set_dirty(true);
} }
std::vector<DayData> MarkdownDataProvider::getDays() std::vector<day_data> markdown_data_provider::get_days()
{ {
return data.days; return _data.days;
} }
std::optional<DayData> MarkdownDataProvider::getDayByDate(const Date &date) std::optional<day_data> markdown_data_provider::get_day_by_date(const Date &date)
{ {
return findFirst(data.days, [&](const DayData &day) { return findFirst(_data.days, [&](const day_data &day) {
return day.date == date; return day.date == date;
}); });
} }
EventData MarkdownDataProvider::insertEvent(const EventData &eventData) event_data markdown_data_provider::insertEvent(const event_data &eventData)
{ {
data.events.push_back(eventData); _data.events.push_back(eventData);
setDirty(true); set_dirty(true);
return eventData; return eventData;
} }
void MarkdownDataProvider::updateEvent(int eventId, UpdatableEventData updateData) void markdown_data_provider::update_event(int eventId, updatable_event_data updateData)
{ {
auto eventData = ptrFindFirst(data.events, [&](const EventData &event) { auto eventData = ptrFindFirst(_data.events, [&](const event_data &event) {
return event.id == eventId; return event.id == eventId;
}); });
assert(eventData != nullptr); // Shouldn't be possible assert(eventData != nullptr); // Shouldn't be possible
@ -214,43 +214,43 @@ void MarkdownDataProvider::updateEvent(int eventId, UpdatableEventData updateDat
if (updateData.endsAt.has_value()) { if (updateData.endsAt.has_value()) {
eventData->endsAt = updateData.endsAt.value(); eventData->endsAt = updateData.endsAt.value();
} }
setDirty(true); set_dirty(true);
} }
void MarkdownDataProvider::removeEventById(int eventId) void markdown_data_provider::remove_event_by_id(int eventId)
{ {
data.events.erase( _data.events.erase(
std::remove_if( std::remove_if(
data.events.begin(), data.events.end(), _data.events.begin(), _data.events.end(),
[&](const EventData &event) { [&](const event_data &event) {
return event.id == eventId; return event.id == eventId;
} }
), ),
data.events.end() _data.events.end()
); );
setDirty(true); set_dirty(true);
} }
std::optional<EventData> MarkdownDataProvider::getEventById(int eventId) std::optional<event_data> markdown_data_provider::get_event_by_id(int eventId)
{ {
return findFirst(data.events, [&](const EventData &event) { return findFirst(_data.events, [&](const event_data &event) {
return event.id == eventId; return event.id == eventId;
}); });
} }
std::vector<EventData> MarkdownDataProvider::getEventsByDate(Date date) std::vector<event_data> markdown_data_provider::get_events_by_date(Date date)
{ {
auto day = getDayByDate(date); auto day = get_day_by_date(date);
if (!day.has_value()) { if (!day.has_value()) {
return {}; return {};
} }
return findAll(data.events, [&](const EventData &event) { return findAll(_data.events, [&](const event_data &event) {
return event.dayId == day.value().id; return event.dayId == day.value().id;
}); });
} }
std::vector<EventData> MarkdownDataProvider::getEvents() std::vector<event_data> markdown_data_provider::get_events()
{ {
return data.events; return _data.events;
} }
} // namespace mirai } // namespace mirai

51
external/mirai-core/src/Mirai.cpp vendored
View file

@ -43,11 +43,11 @@ void Mirai::loadConfig(const std::string &path)
const auto name = filePath.asObject().getString("name"); const auto name = filePath.asObject().getString("name");
const auto color = filePath.asObject().getString("color"); const auto color = filePath.asObject().getString("color");
const auto path = filePath.asObject().getString("path"); const auto path = filePath.asObject().getString("path");
std::unique_ptr<DataProvider> file = std::make_unique<MarkdownDataProvider>(path); std::unique_ptr<data_provider> file = std::make_unique<markdown_data_provider>(path);
DataProvider *sourceDataProvider = file.release(); data_provider *sourceDataProvider = file.release();
sourceDataProvider->load(); sourceDataProvider->load();
sources_.push_back( sources_.push_back(
std::make_unique<Source>(SourceConstructor{ std::make_unique<source>(SourceConstructor{
.name = name, .color = color, .sourceDataProvider = sourceDataProvider .name = name, .color = color, .sourceDataProvider = sourceDataProvider
}) })
); );
@ -69,7 +69,7 @@ void Mirai::saveConfig()
rei::json::JsonObject jsonSource; rei::json::JsonObject jsonSource;
jsonSource.set("name", source->name()); jsonSource.set("name", source->name());
jsonSource.set("color", source->color()); jsonSource.set("color", source->color());
auto dataProvider = dynamic_cast<MarkdownDataProvider *>(source->dataProvider()); auto dataProvider = dynamic_cast<markdown_data_provider *>(source->data_provider());
jsonSource.set("path", dataProvider->path()); jsonSource.set("path", dataProvider->path());
jsonSource.set("type", "FileSystemMarkdown"); jsonSource.set("type", "FileSystemMarkdown");
configJson.getArray("files").push(jsonSource); configJson.getArray("files").push(jsonSource);
@ -84,13 +84,13 @@ Mirai::Mirai(const std::string &configFilePath) : configPath_(configFilePath)
} }
void Mirai::addSource( void Mirai::addSource(
const std::string &name, const std::string &type, std::unique_ptr<DataProvider> &&source const std::string &name, const std::string &type, std::unique_ptr<data_provider> &&new_source
) )
{ {
DataProvider *sourceDataProvider = source.release(); data_provider *sourceDataProvider = new_source.release();
sourceDataProvider->load(); sourceDataProvider->load();
sources_.push_back( sources_.push_back(
std::make_unique<Source>( std::make_unique<source>(
SourceConstructor{.name = name, .sourceDataProvider = sourceDataProvider} SourceConstructor{.name = name, .sourceDataProvider = sourceDataProvider}
) )
); );
@ -103,21 +103,20 @@ void Mirai::editSource(
) )
{ {
auto source = getSourceById(id); auto source = getSourceById(id);
source->setName(name); source->set_name(name);
source->setColor(color); source->set_color(color);
DataProvider *sourceDataProvider = source->dataProvider(); data_provider *sourceDataProvider = source->data_provider();
saveConfig(); saveConfig();
sourceEdited.emit(nullptr); sourceEdited.emit(nullptr);
} }
void Mirai::deleteSource(int id) void Mirai::deleteSource(int id)
{ {
auto source = getSourceById(id);
sources_.erase( sources_.erase(
std::remove_if( std::remove_if(
sources_.begin(), sources_.end(), sources_.begin(), sources_.end(),
[&](const std::unique_ptr<Source> &source) { [&](const std::unique_ptr<source> &source) {
return source->id == id; return source->id == id;
} }
), ),
@ -136,47 +135,47 @@ void Mirai::unloadAllSources()
void Mirai::save() void Mirai::save()
{ {
for (auto &source : sources_) { for (auto &source : sources_) {
if (source->isDirty()) { if (source->is_dirty()) {
source->save(); source->save();
} }
} }
} }
std::vector<std::unique_ptr<Source>> &Mirai::getSources() std::vector<std::unique_ptr<source>> &Mirai::getSources()
{ {
return sources_; return sources_;
} }
Source *Mirai::getSourceById(int id) source *Mirai::getSourceById(int id)
{ {
auto source = std::ranges::find_if(sources_, [&](const std::unique_ptr<Source> &source) { auto source_found = std::ranges::find_if(sources_, [&](const std::unique_ptr<source> &source) {
return source->id == id; return source->id == id;
}); });
assert(source != sources_.end()); // This should not happen assert(source_found != sources_.end()); // This should not happen
if (source == sources_.end()) { if (source_found == sources_.end()) {
return nullptr; return nullptr;
} }
return source->get(); return source_found->get();
} }
Source *Mirai::getSourceByName(const std::string &name) source *Mirai::getSourceByName(const std::string &name)
{ {
auto source = std::ranges::find_if(sources_, [&](const std::unique_ptr<Source> &source) { auto source_found = std::ranges::find_if(sources_, [&](const std::unique_ptr<source> &source) {
return source->name() == name; return source->name() == name;
}); });
assert(source != sources_.end()); // This should not happen assert(source_found != sources_.end()); // This should not happen
if (source == sources_.end()) { if (source_found == sources_.end()) {
return nullptr; return nullptr;
} }
return source->get(); return source_found->get();
} }
void Mirai::onSourceAdded(std::function<void(Source *)> f) void Mirai::onSourceAdded(std::function<void(source *)> f)
{ {
sourceAdded.registerCallback(f); sourceAdded.registerCallback(f);
} }
void Mirai::onSourceEdited(std::function<void(Source *)> f) void Mirai::onSourceEdited(std::function<void(source *)> f)
{ {
sourceEdited.registerCallback(f); sourceEdited.registerCallback(f);
} }

76
external/mirai-core/src/Source.cpp vendored
View file

@ -16,20 +16,20 @@
namespace mirai namespace mirai
{ {
void Source::save() void source::save()
{ {
data->save(); data->save();
} }
void Source::createTask(const createTaskParams &task) void source::create_task(const createTaskParams &task)
{ {
std::optional<int> dayId = std::nullopt; std::optional<int> dayId = std::nullopt;
std::optional<int> eventId = std::nullopt; std::optional<int> eventId = std::nullopt;
if (!task.event.has_value() && task.date.has_value()) { if (!task.event.has_value() && task.date.has_value()) {
auto day = data->getDayByDate(task.date.value()); auto day = data->get_day_by_date(task.date.value());
if (!day.has_value() && task.date.has_value()) { if (!day.has_value() && task.date.has_value()) {
day = data->insertDay({.id = generateUniqueId(), .date = task.date.value()}); day = data->insert_day({.id = generateUniqueId(), .date = task.date.value()});
} }
dayId = day->id; dayId = day->id;
} }
@ -38,7 +38,7 @@ void Source::createTask(const createTaskParams &task)
eventId = task.event.value().id(); eventId = task.event.value().id();
} }
data->insertTask({ data->insert_task({
.id = generateUniqueId(), .id = generateUniqueId(),
.title = task.title, .title = task.title,
.state = TODO, .state = TODO,
@ -47,34 +47,34 @@ void Source::createTask(const createTaskParams &task)
}); });
}; };
std::vector<Day> Source::getDays() std::vector<Day> source::get_days()
{ {
auto daysData = data->getDays(); auto daysData = data->get_days();
std::vector<Day> days; std::vector<Day> days;
std::transform( std::transform(
daysData.begin(), daysData.end(), std::back_inserter(days), [&](const DayData &dayData) { daysData.begin(), daysData.end(), std::back_inserter(days), [&](const day_data &dayData) {
return Day{data, dayData}; return Day{data, dayData};
} }
); );
return days; return days;
} }
std::optional<Day> Source::getDayByDate(Date date) std::optional<Day> source::get_day_by_date(Date date)
{ {
auto day = data->getDayByDate(date); auto day = data->get_day_by_date(date);
if (!day.has_value()) { if (!day.has_value()) {
return std::nullopt; return std::nullopt;
} }
return Day{data, day.value()}; return Day{data, day.value()};
} }
void Source::createEvent(const createEventParams &eventToCreate) void source::create_event(const createEventParams &eventToCreate)
{ {
std::optional<int> dayId = std::nullopt; std::optional<int> dayId = std::nullopt;
auto day = data->getDayByDate(eventToCreate.date); auto day = data->get_day_by_date(eventToCreate.date);
if (!day.has_value()) { if (!day.has_value()) {
day = data->insertDay({.id = generateUniqueId(), .date = eventToCreate.date}); day = data->insert_day({.id = generateUniqueId(), .date = eventToCreate.date});
dayId = day->id; dayId = day->id;
} }
@ -87,28 +87,28 @@ void Source::createEvent(const createEventParams &eventToCreate)
}); });
}; };
std::optional<Event> Source::getEventById(int evendId) std::optional<Event> source::get_event_by_id(int evendId)
{ {
auto event = data->getEventById(evendId); auto event = data->get_event_by_id(evendId);
if (!event.has_value()) { if (!event.has_value()) {
return std::nullopt; return std::nullopt;
} }
return Event{data, event.value()}; return Event{data, event.value()};
} }
void Source::removeEvent(const Event &event) void source::remove_event(const Event &event)
{ {
data->removeEventById(event.id()); data->remove_event_by_id(event.id());
} }
void Source::removeTask(const Task &task) void source::remove_task(const Task &task)
{ {
data->removeTaskById(task.id()); data->remove_task_by_id(task.id());
} }
std::optional<Task> Source::getTaskById(int taskId) std::optional<Task> source::get_task_by_id(int taskId)
{ {
auto taskData = data->getTaskById(taskId); auto taskData = data->get_task_by_id(taskId);
if (!taskData.has_value()) { if (!taskData.has_value()) {
return std::nullopt; return std::nullopt;
} }
@ -116,59 +116,59 @@ std::optional<Task> Source::getTaskById(int taskId)
return task; return task;
} }
std::vector<Task> Source::getTasks() std::vector<Task> source::get_tasks()
{ {
auto tasksData = data->getTasks(); auto tasksData = data->get_tasks();
std::vector<Task> tasks; std::vector<Task> tasks;
std::transform( std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks), tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const TaskData &taskData) { [&](const task_data &taskData) {
return Task{data, taskData}; return Task{data, taskData};
} }
); );
return tasks; return tasks;
} }
std::vector<Task> Source::getUnscheduledTasks() std::vector<Task> source::get_unscheduled_tasks()
{ {
auto tasksData = data->getTasksWithoutDate(); auto tasksData = data->get_tasks_without_date();
std::vector<Task> tasks; std::vector<Task> tasks;
std::transform( std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks), tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const TaskData &taskData) { [&](const task_data &taskData) {
return Task{data, taskData}; return Task{data, taskData};
} }
); );
return tasks; return tasks;
} }
std::string Source::name() const std::string source::name() const
{ {
return name_; return _name;
} }
std::string Source::color() const std::string source::color() const
{ {
return color_; return _color;
} }
void Source::setName(const std::string &name) void source::set_name(const std::string &name)
{ {
name_ = name; _name = name;
} }
void Source::setColor(const std::string &color) void source::set_color(const std::string &color)
{ {
color_ = color; _color = color;
} }
std::string Source::type() const std::string source::type() const
{ {
// There is only 1 type for now // There is only 1 type for now
return type_; return _type;
} }
DataProvider *Source::dataProvider() data_provider *source::data_provider()
{ {
return data; return data;
} }

18
external/mirai-core/src/Task.cpp vendored
View file

@ -29,7 +29,7 @@ std::string Task::title() const
return task_.title; return task_.title;
} }
mirai::TaskState Task::state() const mirai::task_state Task::state() const
{ {
return task_.state; return task_.state;
} }
@ -51,40 +51,40 @@ bool Task::hasDate() const
void Task::setTitle(const std::string &newTitle) void Task::setTitle(const std::string &newTitle)
{ {
data_->updateTask(id(), {.title = newTitle}); data_->update_task(id(), {.title = newTitle});
} }
void Task::setDay(const Day &day) void Task::setDay(const Day &day)
{ {
auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt)); auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->updateTask(id(), {.dayId = day.id(), .eventId = emptyEventId}); data_->update_task(id(), {.dayId = day.id(), .eventId = emptyEventId});
} }
void Task::setDate(const Date &date) void Task::setDate(const Date &date)
{ {
auto day = data_->getDayByDate(date); auto day = data_->get_day_by_date(date);
if (!day.has_value()) { if (!day.has_value()) {
day = data_->insertDay({.id = generateUniqueId(), .date = date}); day = data_->insert_day({.id = generateUniqueId(), .date = date});
} }
auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt)); auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->updateTask(id(), {.dayId = day.value().id, .eventId = emptyEventId}); data_->update_task(id(), {.dayId = day.value().id, .eventId = emptyEventId});
} }
void Task::unschedule() void Task::unschedule()
{ {
auto emptyId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt)); auto emptyId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->updateTask(id(), {.dayId = emptyId, .eventId = emptyId}); data_->update_task(id(), {.dayId = emptyId, .eventId = emptyId});
} }
void Task::setEvent(const Event &event) void Task::setEvent(const Event &event)
{ {
auto emptyDayId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt)); auto emptyDayId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->updateTask(id(), {.dayId = emptyDayId, .eventId = event.id()}); data_->update_task(id(), {.dayId = emptyDayId, .eventId = event.id()});
} }
void Task::setChecked(bool checked) void Task::setChecked(bool checked)
{ {
data_->updateTask(id(), {.state = checked ? DONE : TODO}); data_->update_task(id(), {.state = checked ? DONE : TODO});
} }
} // namespace mirai } // namespace mirai

17
external/mirai-core/src/View.cpp vendored
View file

@ -63,8 +63,8 @@ void View::update()
auto todayDate = Date(std::chrono::system_clock::now()); auto todayDate = Date(std::chrono::system_clock::now());
for (int sourceId : sourcesIds_) { for (int sourceId : sourcesIds_) {
Source *source = mirai_->getSourceById(sourceId); source *source = mirai_->getSourceById(sourceId);
for (auto day : source->getDays()) { for (auto day : source->get_days()) {
// day's tasks // day's tasks
auto sourceTasks = day.tasks() | std::ranges::views::filter([&](const Task &task) { auto sourceTasks = day.tasks() | std::ranges::views::filter([&](const Task &task) {
if (day.date() >= todayDate) { if (day.date() >= todayDate) {
@ -102,7 +102,7 @@ void View::update()
} }
} }
// unscheduled tasks // unscheduled tasks
auto tasks = source->getUnscheduledTasks(); auto tasks = source->get_unscheduled_tasks();
unscheduledTasks_.insert(unscheduledTasks_.end(), tasks.begin(), tasks.end()); unscheduledTasks_.insert(unscheduledTasks_.end(), tasks.begin(), tasks.end());
} }
@ -119,17 +119,16 @@ void View::removeSources()
sourcesIds_.clear(); sourcesIds_.clear();
} }
void View::addSource(const Source &source) void View::addSource(const source &source)
{ {
sourcesIds_.push_back(source.id); sourcesIds_.push_back(source.id);
} }
void View::setSources(const std::vector<Source> &sources) void View::setSources(const std::vector<source> &sources)
{ {
sourcesIds_.clear(); sourcesIds_.clear();
std::transform( std::transform(
sources.begin(), sources.end(), std::back_inserter(sourcesIds_), sources.begin(), sources.end(), std::back_inserter(sourcesIds_), [](const source &source) {
[](const Source &source) {
return source.id; return source.id;
} }
); );
@ -141,13 +140,13 @@ void View::setAllSources()
sourcesIds_.clear(); sourcesIds_.clear();
std::transform( std::transform(
sources.begin(), sources.end(), std::back_inserter(sourcesIds_), sources.begin(), sources.end(), std::back_inserter(sourcesIds_),
[](const std::unique_ptr<Source> &source) { [](const std::unique_ptr<source> &source) {
return source->id; return source->id;
} }
); );
} }
bool View::isSourceSelected(const Source &source) const bool View::isSourceSelected(const source &source) const
{ {
for (auto &sourceId : sourcesIds_) { for (auto &sourceId : sourcesIds_) {
if (sourceId == source.id) { if (sourceId == source.id) {

38
src/windows/AppWindow/AppWindow.cpp
View file

@ -114,15 +114,15 @@ void AppWindow::setupCallbacks()
models().on_get_source_path_from_id([&](int sourceId) { models().on_get_source_path_from_id([&](int sourceId) {
auto source = miraiInstance_->getSourceById(sourceId); auto source = miraiInstance_->getSourceById(sourceId);
assert(source); assert(source);
mirai::MarkdownDataProvider *sourceProvider = mirai::markdown_data_provider *sourceProvider =
dynamic_cast<mirai::MarkdownDataProvider *>(source->dataProvider()); dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());
return slint::SharedString(sourceProvider->path()); return slint::SharedString(sourceProvider->path());
}); });
miraiInstance_->onSourceAdded([&](mirai::Source *source) { miraiInstance_->onSourceAdded([&](mirai::source *source) {
refreshModels(); refreshModels();
}); });
miraiInstance_->onSourceEdited([&](mirai::Source *source) { miraiInstance_->onSourceEdited([&](mirai::source *source) {
refreshModels(); refreshModels();
}); });
miraiInstance_->onSourceDeleted([&](int id) { miraiInstance_->onSourceDeleted([&](int id) {
@ -132,7 +132,7 @@ void AppWindow::setupCallbacks()
actions().on_task_clicked([&](int sourceId, int taskId) { actions().on_task_clicked([&](int sourceId, int taskId) {
auto source = miraiInstance_->getSourceById(sourceId); auto source = miraiInstance_->getSourceById(sourceId);
assert(source); assert(source);
auto task = source->getTaskById(taskId); auto task = source->get_task_by_id(taskId);
assert(task); assert(task);
if (!task->checked() && !task->hasDate() && !task->hasEvent()) { if (!task->checked() && !task->hasDate() && !task->hasEvent()) {
task->setDate(mirai::Date(mirai::Date(std::chrono::system_clock::now()))); task->setDate(mirai::Date(mirai::Date(std::chrono::system_clock::now())));
@ -149,7 +149,7 @@ void AppWindow::setupCallbacks()
view_.setAllSources(); view_.setAllSources();
} else { } else {
view_.removeSources(); view_.removeSources();
const mirai::Source *source = miraiInstance_->getSourceById(index); const mirai::source *source = miraiInstance_->getSourceById(index);
view_.addSource(*source); view_.addSource(*source);
} }
models().set_default_source_index(index == -1 ? 0 : index); models().set_default_source_index(index == -1 ? 0 : index);
@ -159,8 +159,8 @@ void AppWindow::setupCallbacks()
}); });
actions().on_add_source([&](slint::SharedString name, slint::SharedString path) { actions().on_add_source([&](slint::SharedString name, slint::SharedString path) {
std::unique_ptr<mirai::DataProvider> file = std::unique_ptr<mirai::data_provider> file =
std::make_unique<mirai::MarkdownDataProvider>(std::string(path)); std::make_unique<mirai::markdown_data_provider>(std::string(path));
miraiInstance_->addSource(std::string(name), "FileSystemMarkdown", std::move(file)); miraiInstance_->addSource(std::string(name), "FileSystemMarkdown", std::move(file));
}); });
@ -174,9 +174,9 @@ void AppWindow::setupCallbacks()
actions().on_delete_task_clicked([&](int sourceId, int taskId) { actions().on_delete_task_clicked([&](int sourceId, int taskId) {
auto source = miraiInstance_->getSourceById(sourceId); auto source = miraiInstance_->getSourceById(sourceId);
assert(source); assert(source);
auto task = source->getTaskById(taskId); auto task = source->get_task_by_id(taskId);
assert(task); assert(task);
source->removeTask(*task); source->remove_task(*task);
miraiInstance_->save(); miraiInstance_->save();
view_.update(); view_.update();
reloadTasks(); reloadTasks();
@ -191,10 +191,10 @@ void AppWindow::setupCallbacks()
actions().on_save_task([&](ui::SaveTaskData newTaskData) { actions().on_save_task([&](ui::SaveTaskData newTaskData) {
auto source = miraiInstance_->getSourceById(newTaskData.sourceId); auto source = miraiInstance_->getSourceById(newTaskData.sourceId);
assert(source); assert(source);
auto task = source->getTaskById(newTaskData.id); auto task = source->get_task_by_id(newTaskData.id);
assert(task.has_value()); assert(task.has_value());
const mirai::Date &date = SlintDateToMiraiDate(newTaskData.date); const mirai::Date &date = SlintDateToMiraiDate(newTaskData.date);
const auto dayOpt = source->getDayByDate(date); const auto dayOpt = source->get_day_by_date(date);
task->setTitle(std::string(newTaskData.title)); task->setTitle(std::string(newTaskData.title));
if (!task.value().hasEvent() && date.year != 0) { if (!task.value().hasEvent() && date.year != 0) {
@ -219,10 +219,10 @@ void AppWindow::setupCallbacks()
std::optional<mirai::Event> event = std::nullopt; std::optional<mirai::Event> event = std::nullopt;
if (newTaskData.eventId >= 0) { if (newTaskData.eventId >= 0) {
event = source->getEventById(newTaskData.eventId); event = source->get_event_by_id(newTaskData.eventId);
} }
source->createTask({ source->create_task({
.title = std::string(newTaskData.title), .title = std::string(newTaskData.title),
.event = event, .event = event,
.date = date, .date = date,
@ -236,9 +236,9 @@ void AppWindow::setupCallbacks()
actions().on_delete_event([&](int sourceId, int eventId) { actions().on_delete_event([&](int sourceId, int eventId) {
auto source = miraiInstance_->getSourceById(sourceId); auto source = miraiInstance_->getSourceById(sourceId);
assert(source); assert(source);
auto event = source->getEventById(eventId); auto event = source->get_event_by_id(eventId);
assert(event.has_value()); assert(event.has_value());
source->removeEvent(event.value()); source->remove_event(event.value());
miraiInstance_->save(); miraiInstance_->save();
view_.update(); view_.update();
reloadTasks(); reloadTasks();
@ -250,7 +250,7 @@ void AppWindow::setupCallbacks()
const auto sourceId = models().get_default_source_index(); const auto sourceId = models().get_default_source_index();
auto source = miraiInstance_->getSourceById(sourceId == -1 ? 0 : sourceId); auto source = miraiInstance_->getSourceById(sourceId == -1 ? 0 : sourceId);
source->createEvent({ source->create_event({
.title = std::string(newEventParams.title), .title = std::string(newEventParams.title),
.date = SlintDateToMiraiDate(newEventParams.date), .date = SlintDateToMiraiDate(newEventParams.date),
.startsAt = SlintTimeToMiraiTime(newEventParams.startsAt), .startsAt = SlintTimeToMiraiTime(newEventParams.startsAt),
@ -407,8 +407,8 @@ void AppWindow::reloadSources()
bool noSourceSelected = miraiInstance_->getSources().size() == view_.activeSourceCount(); bool noSourceSelected = miraiInstance_->getSources().size() == view_.activeSourceCount();
for (const auto &source : miraiInstance_->getSources()) { for (const auto &source : miraiInstance_->getSources()) {
bool isSourceSelected = view_.isSourceSelected(*source); bool isSourceSelected = view_.isSourceSelected(*source);
mirai::MarkdownDataProvider *sourceProvider = mirai::markdown_data_provider *sourceProvider =
dynamic_cast<mirai::MarkdownDataProvider *>(source->dataProvider()); dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());
sources_->push_back( sources_->push_back(
{.id = source->id, {.id = source->id,
.name = slint::SharedString(source->name()), .name = slint::SharedString(source->name()),