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

[WIP] full views rework

Browse source
This commit is contained in:
Vyn 2025-06-29 20:07:11 +02:00
parent 9de3972630
commit 15bd0f58a7
Signed by: vyn
GPG key ID: E1B2BE34E7A971E7
30 changed files with 812 additions and 1175 deletions
Download patch file Download diff file Expand all files Collapse all files

2
external/mirai-core/CMakeLists.txt vendored
View file

@ -8,14 +8,12 @@ set(CMAKE_COMPILE_WARNING_AS_ERROR ON)
add_library(mirai-core
src/Mirai.cpp
src/Task.cpp
src/Day.cpp
src/Event.cpp
src/DateTime.cpp
src/EventEmitter.cpp
src/Source.cpp
src/MarkdownDataProvider.cpp
src/MarkdownDataProvider.Parser.cpp
src/View.cpp
src/utils.cpp
)

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

@ -14,45 +14,34 @@
namespace mirai
{
struct day_data {
int id;
Date date;
};
struct updatable_day_data {
std::optional<Date> date;
};
enum task_state { TODO, DONE };
struct task_data {
int id;
std::string title;
task_state state;
std::optional<int> dayId;
std::optional<int> eventId;
std::optional<Date> due_date;
};
struct updatable_task_data {
std::optional<std::string> title = std::nullopt;
std::optional<task_state> state = std::nullopt;
std::optional<std::optional<int>> dayId = std::nullopt;
std::optional<std::optional<int>> eventId = std::nullopt;
std::optional<std::optional<Date>> due_date = std::nullopt;
};
struct event_data {
int id;
int dayId;
Date date;
std::string title;
Time startsAt;
Time endsAt;
Time starts_at;
Time ends_at;
};
struct updatable_event_data {
std::optional<int> dayId;
std::optional<Date> date;
std::optional<std::string> title;
std::optional<Time> startsAt;
std::optional<Time> endsAt;
std::optional<Time> starts_at;
std::optional<Time> ends_at;
};
class data_provider
@ -73,8 +62,6 @@ class data_provider
virtual task_data insert_task(const task_data &task) = 0;
virtual void remove_task_by_id(int taskId) = 0;
virtual std::optional<task_data> get_task_by_id(int taskId) = 0;
virtual std::vector<task_data> get_tasks_by_event_id(int eventId) = 0;
virtual std::vector<task_data> get_tasks_by_day_id(int dayId) = 0;
virtual std::vector<task_data> get_tasks_by_date(Date date) = 0;
virtual std::vector<task_data> get_tasks_without_date() = 0;
virtual std::vector<task_data> get_tasks() = 0;
@ -88,13 +75,6 @@ class data_provider
virtual std::vector<event_data> get_events_by_date(Date date) = 0;
virtual void update_event(int eventId, updatable_event_data updateData) = 0;
// Days
virtual day_data insert_day(const day_data &day) = 0;
virtual void remove_day_by_id(int dayId) = 0;
virtual std::vector<day_data> get_days() = 0;
virtual std::optional<day_data> get_day_by_date(const Date &date) = 0;
virtual void update_day(int dayId, updatable_day_data updateData) = 0;
const int id = data_provider::generate_next_id();
void set_dirty(bool dirty)

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

@ -1,38 +0,0 @@
/*
* Mirai. Copyright (C) 2024 Vyn
* This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
* The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
*/
#pragma once
#include "DataProvider.h"
#include <vector>
namespace mirai
{
class Task;
class Event;
class Day
{
public:
Day(data_provider *data, day_data day) : data_(data), dayData_(day) {};
Date date() const;
std::vector<Task> tasks();
std::vector<Event> events();
void mergeDay(const Day &otherDay);
int id() const;
int sourceId() const;
private:
day_data dayData_;
data_provider *data_;
};
} // namespace mirai

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

@ -7,7 +7,6 @@
#pragma once
#include "DataProvider.h"
#include "Day.h"
#include <string>
#include <vector>
@ -20,25 +19,26 @@ class Event
{
public:
Event(data_provider *data, event_data eventData) : data_(data), eventData_(eventData) {};
Event(data_provider *provider, event_data data) : _provider(provider), _data(data) {};
std::string title() const;
Time startsAt() const;
Time endsAt() const;
Date date() const;
Time starts_at() const;
Time ends_at() const;
std::vector<Task> queryTasks() const;
std::vector<Task> query_tasks() const;
void setTitle(const std::string &newTitle);
void setDay(const Day &day);
void setStartTime(const Time &time);
void setEndTime(const Time &time);
void set_title(const std::string &newTitle);
void set_date(const Date &date);
void set_start_time(const Time &time);
void set_end_time(const Time &time);
int id() const;
int sourceId() const;
int source_id() const;
private:
event_data eventData_;
data_provider *data_;
event_data _data;
data_provider *_provider;
};
} // namespace mirai

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

@ -22,11 +22,10 @@ namespace mirai
struct markdown_data {
std::string name;
std::vector<task_data> tasks;
std::vector<day_data> days;
std::vector<event_data> events;
};
class markdown_data_provider : public data_provider
class markdown_data_provider final : public data_provider
{
public:
markdown_data_provider(const std::string &file_path) : _file_path(file_path), data_provider()
@ -47,8 +46,6 @@ class markdown_data_provider : public data_provider
task_data insert_task(const task_data &task) override;
void remove_task_by_id(int taskId) override;
std::optional<task_data> get_task_by_id(int taskId) override;
std::vector<task_data> get_tasks_by_event_id(int eventId) override;
std::vector<task_data> get_tasks_by_day_id(int dayId) override;
std::vector<task_data> get_tasks_by_date(Date date) override;
std::vector<task_data> get_tasks_without_date() override;
std::vector<task_data> get_tasks() override;
@ -62,13 +59,6 @@ class markdown_data_provider : public data_provider
std::vector<event_data> get_events_by_date(Date date) override;
void update_event(int eventId, updatable_event_data updateData) override;
// Days
day_data insert_day(const day_data &day) override;
void remove_day_by_id(int dayId) override;
std::vector<day_data> get_days() override;
std::optional<day_data> get_day_by_date(const Date &date) override;
void update_day(int dayId, updatable_day_data updateData) override;
private:
std::string _name;
std::string _file_path;

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

@ -8,7 +8,6 @@
#include "DataProvider.h"
#include "DateTime.h"
#include "Day.h"
#include "Event.h"
#include "Task.h"
#include <string>
@ -17,30 +16,29 @@
namespace mirai
{
struct createTaskParams {
struct create_task_params {
std::string title;
std::optional<Event> event;
std::optional<Date> date;
std::optional<Date> due_date;
};
struct createEventParams {
struct create_event_params {
std::string title;
Date date;
Time startsAt;
Time endsAt;
Time starts_at;
Time ends_at;
};
struct SourceConstructor {
struct source_constructor {
std::string name;
std::string color;
data_provider *sourceDataProvider;
data_provider *source_data_provider;
};
class source
{
public:
source(SourceConstructor params)
: data(params.sourceDataProvider), _name(params.name), _color(params.color),
source(source_constructor params)
: data(params.source_data_provider), _name(params.name), _color(params.color),
_type("FileSystemMarkdown")
{
}
@ -64,22 +62,19 @@ class source
void set_name(const std::string &name);
void set_color(const std::string &color);
void create_task(const createTaskParams &task);
void create_task(const create_task_params &task);
void remove_task(const Task &task);
std::optional<Task> get_task_by_id(int taskId);
std::vector<Task> get_tasks_by_date(Date date);
std::vector<Task> get_unscheduled_tasks();
std::vector<Task> get_tasks();
void create_event(const createEventParams &eventToCreate);
void create_event(const create_event_params &eventToCreate);
void remove_event(const Event &event);
std::vector<Event> get_events();
std::optional<Event> get_event_by_id(int eventId);
std::vector<Event> get_events_by_date(Date date);
std::vector<Day> get_days();
std::optional<Day> get_day_by_date(Date date);
const int id = source::generate_next_id();
bool is_dirty() const

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

@ -7,7 +7,9 @@
#pragma once
#include "DataProvider.h"
#include "DateTime.h"
#include "Event.h"
#include <optional>
#include <string>
namespace mirai
@ -24,18 +26,16 @@ class Task
std::string title() const;
mirai::task_state state() const;
bool checked() const;
bool hasEvent() const;
bool hasDate() const;
bool has_due_date() const;
std::optional<Date> due_date() const;
void setTitle(const std::string &newTitle);
void setDay(const Day &day);
void setDate(const Date &date);
void setEvent(const Event &event);
void setChecked(bool checked);
void set_title(const std::string &newTitle);
void set_date(const Date &date);
void set_checked(bool checked);
void unschedule();
int id() const;
int sourceId() const;
int source_id() const;
private:
task_data task_;

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

@ -1,58 +0,0 @@
/*
* Mirai. Copyright (C) 2024 Vyn
* This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
* The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
*/
#pragma once
#include "Mirai.h"
#include "Task.h"
#include <algorithm>
#include <iterator>
#include <map>
#include <memory>
#include <string>
#include <vector>
namespace mirai
{
struct DateView {
std::vector<Task> tasks;
std::vector<Event> events;
};
class View
{
public:
View(Mirai *mirai);
void hideCompletedTasks(bool hide);
bool shouldHideCompletedTasks() const;
std::vector<Date> getDates();
std::vector<Task> getTasksForDate(const Date &date);
std::vector<Event> getEventsForDate(const Date &date);
std::vector<Task> getUnscheduledTasks();
void update();
void removeSources();
void addSource(const source &source);
void setSources(const std::vector<source> &sources);
void setAllSources();
bool isSourceSelected(const source &source) const;
size_t activeSourceCount() const;
private:
Mirai *mirai_;
std::vector<int> sourcesIds_;
std::vector<Task> unscheduledTasks_;
std::map<Date, DateView> dates;
bool shouldHideCompletedTasks_ = true;
};
} // namespace mirai

5
external/mirai-core/include/mirai-core/utils.h vendored
View file

@ -6,11 +6,14 @@
#pragma once
#include "DataProvider.h"
#include "DateTime.h"
#include <cctype>
#include <cpp-utils/string.h>
#include <cpp-utils/vector.h>
#include <functional>
#include <optional>
#include <vector>
namespace mirai
{
@ -45,6 +48,6 @@ template <typename T, typename F> std::vector<T> findAll(std::vector<T> containe
return result;
}
int generateUniqueId();
int generate_unique_id();
} // namespace mirai

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

@ -1,60 +0,0 @@
/*
* Mirai. Copyright (C) 2024 Vyn
* This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
* The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
*/
#include "Day.h"
#include "Task.h"
#include <algorithm>
#include <stdexcept>
namespace mirai
{
int Day::id() const
{
return dayData_.id;
}
int Day::sourceId() const
{
return data_->id;
}
Date Day::date() const
{
return dayData_.date;
}
std::vector<Task> Day::tasks()
{
auto tasksData = data_->get_tasks_by_day_id(id());
std::vector<Task> tasks;
std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const task_data &taskData) {
return Task{data_, taskData};
}
);
return tasks;
}
std::vector<Event> Day::events()
{
auto eventsData = data_->get_events_by_date(dayData_.date);
std::vector<Event> events;
std::transform(
eventsData.begin(), eventsData.end(), std::back_inserter(events),
[&](const event_data &eventData) {
return Event{data_, eventData};
}
);
return events;
}
void Day::mergeDay(const Day &otherDay)
{
throw std::runtime_error("Not implemented yet");
}
} // namespace mirai

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

@ -13,59 +13,51 @@ namespace mirai
int Event::id() const
{
return eventData_.id;
return _data.id;
}
int Event::sourceId() const
int Event::source_id() const
{
return data_->id;
return _provider->id;
}
std::string Event::title() const
{
return eventData_.title;
return _data.title;
}
Time Event::startsAt() const
Date Event::date() const
{
return eventData_.startsAt;
return _data.date;
}
Time Event::endsAt() const
Time Event::starts_at() const
{
return eventData_.endsAt;
return _data.starts_at;
}
std::vector<Task> Event::queryTasks() const
Time Event::ends_at() const
{
auto tasksData = data_->get_tasks_by_event_id(eventData_.id);
std::vector<Task> tasks;
std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const task_data &taskData) {
return Task{data_, taskData};
}
);
return tasks;
return _data.ends_at;
}
void Event::setTitle(const std::string &newTitle)
void Event::set_title(const std::string &newTitle)
{
data_->update_event(id(), {.title = newTitle});
_provider->update_event(id(), {.title = newTitle});
}
void Event::setDay(const Day &day)
void Event::set_date(const Date &date)
{
data_->update_event(id(), {.dayId = day.id()});
_provider->update_event(id(), {.date = date});
}
void Event::setStartTime(const Time &time)
void Event::set_start_time(const Time &time)
{
data_->update_event(id(), {.startsAt = time});
_provider->update_event(id(), {.starts_at = time});
}
void Event::setEndTime(const Time &time)
void Event::set_end_time(const Time &time)
{
data_->update_event(id(), {.endsAt = time});
_provider->update_event(id(), {.ends_at = time});
}
} // namespace mirai

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

@ -7,6 +7,7 @@
#include "MarkdownDataProvider.h"
#include "cpp-utils/debug.h"
#include "utils.h"
#include <optional>
#include <print>
#include <regex>
@ -85,9 +86,10 @@ event_data stringToEvent(const std::string &str, const std::string &dateString)
}
event_data eventData{
.date = date.value(),
.title = text,
.startsAt = stringToTime(matches[2]),
.endsAt = stringToTime(matches[3]),
.starts_at = stringToTime(matches[2]),
.ends_at = stringToTime(matches[3]),
};
return eventData;
}
@ -101,47 +103,64 @@ std::string taskToString(const task_data &task)
std::string markdown_data_provider::to_markdown()
{
const std::vector<day_data> days = get_days();
std::string result = "# " + name() + "\n\n";
std::string currentDate = "";
for (const auto &day : days) {
auto &date = day.date;
auto tasks = get_tasks_by_day_id(day.id);
auto events = get_events_by_date(date);
if (tasks.size() == 0 && events.size() == 0) {
continue;
int next_task_index = 0;
int next_event_index = 0;
while (next_event_index < _data.events.size() || next_task_index < _data.tasks.size()) {
std::optional<Date> current_date = std::nullopt;
// First we find the lowest date between the events and the tasks
if (_data.events.size() > 0 && next_event_index < _data.events.size()) {
current_date = _data.events.at(next_event_index).date;
}
result +=
"## " + std::format("{:02d}-{:02d}-{:02d}", date.year, date.month, date.day) + "\n\n";
for (auto event : events) {
auto &start = event.startsAt;
auto &end = event.endsAt;
result += "> " +
std::format(
"{:02d}h{:02d}-{:02d}h{:02d} {}", start.hour, start.minute, end.hour,
end.minute, event.title
) +
"\n";
for (const auto &task : get_tasks_by_event_id(event.id)) {
result += taskToString(task) + '\n';
if (_data.tasks.size() > 0 && next_task_index < _data.tasks.size()) {
auto &task = _data.tasks.at(next_task_index);
if (task.due_date.has_value() && task.due_date < current_date.value()) {
current_date = _data.tasks.at(next_task_index).due_date;
}
result += '\n';
}
for (const auto &task : tasks) {
result += taskToString(task) + '\n';
if (current_date.has_value()) {
result += "## "
+ std::format(
"{:02d}-{:02d}-{:02d}", current_date.value().year,
current_date.value().month, current_date.value().day
)
+ "\n\n";
} else {
result += "## Unscheduled\n\n";
}
while (next_event_index < _data.events.size()) {
auto &current_event = _data.events.at(next_event_index);
if (current_event.date != current_date) {
break;
}
auto &start = current_event.starts_at;
auto &end = current_event.ends_at;
result += "> "
+ std::format(
"{:02d}h{:02d}-{:02d}h{:02d} {}", start.hour, start.minute, end.hour,
end.minute, current_event.title
)
+ "\n";
next_event_index++;
current_event = _data.events.at(next_event_index);
}
while (next_task_index < _data.tasks.size()) {
auto &current_task = _data.tasks.at(next_task_index);
if (current_task.due_date != current_date) {
break;
}
taskToString(current_task);
next_event_index++;
current_task = _data.tasks.at(next_task_index);
}
result += '\n';
}
auto unscheduledTasks = get_tasks_without_date();
if (unscheduledTasks.size() > 0) {
result += "## Unscheduled\n\n";
for (const auto &task : unscheduledTasks) {
result += taskToString(task) + '\n';
}
result += '\n';
}
return result;
};
@ -160,10 +179,7 @@ markdown_data markdown_data_provider::parse_markdown(const std::string &content)
_data.name = line.substr(2);
std::string currentDateString = "";
std::vector<mirai::day_data> daysData;
std::vector<mirai::task_data> unscheduledTasks;
std::optional<Date> currentDate = std::nullopt;
std::optional<event_data> currentEvent = std::nullopt;
std::optional<Date> current_date = std::nullopt;
cpputils::debug::Timer stringToTaskDuration;
stringToTaskDuration.reset();
@ -172,58 +188,34 @@ markdown_data markdown_data_provider::parse_markdown(const std::string &content)
if (std::string_view{line.data(), 3} == "## ") {
currentDateString = line.substr(3);
if (currentDateString == "Unscheduled") {
currentDate = std::nullopt;
current_date = std::nullopt;
continue;
}
currentDate = mirai::stringToDate(currentDateString);
if (!currentDate.has_value()) {
current_date = mirai::stringToDate(currentDateString);
if (!current_date.has_value()) {
throw std::runtime_error("Malformated date (1)");
}
insert_day({.id = generateUniqueId(), .date = currentDate.value()});
} else if (line.starts_with("> ")) {
auto event = stringToEvent(line, currentDateString);
if (currentDate.has_value()) {
auto day = get_day_by_date(currentDate.value());
currentEvent = insertEvent(
{.id = generateUniqueId(),
.dayId = day->id,
if (current_date.has_value()) {
insertEvent(
{.id = generate_unique_id(),
.date = current_date.value(),
.title = event.title,
.startsAt = event.startsAt,
.endsAt = event.endsAt}
.starts_at = event.starts_at,
.ends_at = event.ends_at}
);
}
} else if (line.starts_with("- [ ]") || line.starts_with("- [X]")) {
stringToTaskDuration.start();
task_data taskItemData = stringToTask(line, currentDateString);
stringToTaskDuration.stop();
if (currentEvent.has_value()) {
insert_task({
.id = generateUniqueId(),
.title = taskItemData.title,
.state = taskItemData.state,
.dayId = std::nullopt,
.eventId = currentEvent.value().id,
});
} else if (currentDate.has_value()) {
auto day = get_day_by_date(currentDate.value());
insert_task({
.id = generateUniqueId(),
.title = taskItemData.title,
.state = taskItemData.state,
.dayId = day->id,
.eventId = std::nullopt,
});
} else {
insert_task({
.id = generateUniqueId(),
.title = taskItemData.title,
.state = taskItemData.state,
.dayId = std::nullopt,
.eventId = std::nullopt,
});
}
} else if (cpputils::string::trim(line) == "") {
currentEvent = std::nullopt;
insert_task(
{.id = generate_unique_id(),
.title = taskItemData.title,
.state = taskItemData.state,
.due_date = current_date}
);
}
}

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

@ -77,11 +77,8 @@ void markdown_data_provider::update_task(int taskId, updatable_task_data updateD
if (updateData.state.has_value()) {
taskData->state = updateData.state.value();
}
if (updateData.dayId.has_value()) {
taskData->dayId = updateData.dayId.value();
}
if (updateData.eventId.has_value()) {
taskData->eventId = updateData.eventId.value();
if (updateData.due_date.has_value()) {
taskData->due_date = updateData.due_date.value();
}
set_dirty(true);
}
@ -93,35 +90,17 @@ std::optional<task_data> markdown_data_provider::get_task_by_id(int taskId)
});
}
std::vector<task_data> markdown_data_provider::get_tasks_by_event_id(int eventId)
{
return findAll(_data.tasks, [&](const task_data &task) {
return task.eventId == eventId;
});
}
std::vector<task_data> markdown_data_provider::get_tasks_by_day_id(int dayId)
{
return findAll(_data.tasks, [&](const task_data &task) {
return task.dayId == dayId;
});
}
std::vector<task_data> markdown_data_provider::get_tasks_without_date()
{
return findAll(_data.tasks, [](const task_data &t) {
return t.dayId == std::nullopt && t.eventId == std::nullopt;
return t.due_date == std::nullopt;
});
}
std::vector<task_data> markdown_data_provider::get_tasks_by_date(Date date)
{
auto day = get_day_by_date(date);
if (!day.has_value()) {
return {};
}
return findAll(_data.tasks, [&](const task_data &t) {
return t.dayId == day.value().id;
return t.due_date == date;
});
}
@ -144,51 +123,6 @@ void markdown_data_provider::remove_task_by_id(int taskId)
set_dirty(true);
}
day_data markdown_data_provider::insert_day(const day_data &dayData)
{
_data.days.push_back(dayData);
set_dirty(true);
return dayData;
}
void markdown_data_provider::update_day(int dayId, updatable_day_data updateData)
{
auto dayData = ptrFindFirst(_data.days, [&](const day_data &day) {
return day.id == dayId;
});
assert(dayData != nullptr); // Shouldn't be possible
if (updateData.date.has_value()) {
dayData->date = updateData.date.value();
}
set_dirty(true);
}
void markdown_data_provider::remove_day_by_id(int dayId)
{
_data.days.erase(
std::remove_if(
_data.days.begin(), _data.days.end(),
[&](const day_data &day) {
return day.id == dayId;
}
),
_data.days.end()
);
set_dirty(true);
}
std::vector<day_data> markdown_data_provider::get_days()
{
return _data.days;
}
std::optional<day_data> markdown_data_provider::get_day_by_date(const Date &date)
{
return findFirst(_data.days, [&](const day_data &day) {
return day.date == date;
});
}
event_data markdown_data_provider::insertEvent(const event_data &eventData)
{
_data.events.push_back(eventData);
@ -205,14 +139,14 @@ void markdown_data_provider::update_event(int eventId, updatable_event_data upda
if (updateData.title.has_value()) {
eventData->title = updateData.title.value();
}
if (updateData.dayId.has_value()) {
eventData->dayId = updateData.dayId.value();
if (updateData.date.has_value()) {
eventData->date = updateData.date.value();
}
if (updateData.startsAt.has_value()) {
eventData->startsAt = updateData.startsAt.value();
if (updateData.starts_at.has_value()) {
eventData->starts_at = updateData.starts_at.value();
}
if (updateData.endsAt.has_value()) {
eventData->endsAt = updateData.endsAt.value();
if (updateData.ends_at.has_value()) {
eventData->ends_at = updateData.ends_at.value();
}
set_dirty(true);
}
@ -240,12 +174,8 @@ std::optional<event_data> markdown_data_provider::get_event_by_id(int eventId)
std::vector<event_data> markdown_data_provider::get_events_by_date(Date date)
{
auto day = get_day_by_date(date);
if (!day.has_value()) {
return {};
}
return findAll(_data.events, [&](const event_data &event) {
return event.dayId == day.value().id;
return event.date == date;
});
}

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

@ -47,8 +47,8 @@ void Mirai::loadConfig(const std::string &path)
data_provider *sourceDataProvider = file.release();
sourceDataProvider->load();
sources_.push_back(
std::make_unique<source>(SourceConstructor{
.name = name, .color = color, .sourceDataProvider = sourceDataProvider
std::make_unique<source>(source_constructor{
.name = name, .color = color, .source_data_provider = sourceDataProvider
})
);
}
@ -91,7 +91,7 @@ void Mirai::addSource(
sourceDataProvider->load();
sources_.push_back(
std::make_unique<source>(
SourceConstructor{.name = name, .sourceDataProvider = sourceDataProvider}
source_constructor{.name = name, .source_data_provider = sourceDataProvider}
)
);
saveConfig();
@ -116,9 +116,7 @@ void Mirai::deleteSource(int id)
sources_.erase(
std::remove_if(
sources_.begin(), sources_.end(),
[&](const std::unique_ptr<source> &source) {
return source->id == id;
}
[&](const std::unique_ptr<source> &source) { return source->id == id; }
),
sources_.end()
);
@ -151,7 +149,7 @@ source *Mirai::getSourceById(int id)
auto source_found = std::ranges::find_if(sources_, [&](const std::unique_ptr<source> &source) {
return source->id == id;
});
assert(source_found != sources_.end()); // This should not happen
// assert(source_found != sources_.end()); // This should not happen
if (source_found == sources_.end()) {
return nullptr;
}

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

@ -21,72 +21,38 @@ void source::save()
data->save();
}
void source::create_task(const createTaskParams &task)
void source::create_task(const create_task_params &task)
{
std::optional<int> dayId = std::nullopt;
std::optional<int> eventId = std::nullopt;
if (!task.event.has_value() && task.date.has_value()) {
auto day = data->get_day_by_date(task.date.value());
if (!day.has_value() && task.date.has_value()) {
day = data->insert_day({.id = generateUniqueId(), .date = task.date.value()});
}
dayId = day->id;
}
if (task.event.has_value() && task.event->id()) {
eventId = task.event.value().id();
}
data->insert_task({
.id = generateUniqueId(),
.id = generate_unique_id(),
.title = task.title,
.state = TODO,
.dayId = dayId,
.eventId = eventId,
.due_date = task.due_date,
});
};
std::vector<Day> source::get_days()
void source::create_event(const create_event_params &new_event)
{
auto daysData = data->get_days();
std::vector<Day> days;
std::transform(
daysData.begin(), daysData.end(), std::back_inserter(days), [&](const day_data &dayData) {
return Day{data, dayData};
}
);
return days;
}
std::optional<Day> source::get_day_by_date(Date date)
{
auto day = data->get_day_by_date(date);
if (!day.has_value()) {
return std::nullopt;
}
return Day{data, day.value()};
}
void source::create_event(const createEventParams &eventToCreate)
{
std::optional<int> dayId = std::nullopt;
auto day = data->get_day_by_date(eventToCreate.date);
if (!day.has_value()) {
day = data->insert_day({.id = generateUniqueId(), .date = eventToCreate.date});
dayId = day->id;
}
data->insertEvent({
.id = generateUniqueId(),
.dayId = day.value().id,
.title = eventToCreate.title,
.startsAt = eventToCreate.startsAt,
.endsAt = eventToCreate.endsAt,
.id = generate_unique_id(),
.date = new_event.date,
.title = new_event.title,
.starts_at = new_event.starts_at,
.ends_at = new_event.ends_at,
});
};
std::vector<Event> source::get_events()
{
auto event_data = data->get_events();
std::vector<Event> events;
std::transform(
event_data.begin(), event_data.end(), std::back_inserter(events),
[&](const struct event_data &event_data) { return Event{data, event_data}; }
);
return events;
}
std::optional<Event> source::get_event_by_id(int evendId)
{
auto event = data->get_event_by_id(evendId);
@ -122,9 +88,7 @@ std::vector<Task> source::get_tasks()
std::vector<Task> tasks;
std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const task_data &taskData) {
return Task{data, taskData};
}
[&](const task_data &taskData) { return Task{data, taskData}; }
);
return tasks;
}
@ -135,9 +99,7 @@ std::vector<Task> source::get_unscheduled_tasks()
std::vector<Task> tasks;
std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const task_data &taskData) {
return Task{data, taskData};
}
[&](const task_data &taskData) { return Task{data, taskData}; }
);
return tasks;
}

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

@ -6,7 +6,6 @@
#include "Task.h"
#include "DataProvider.h"
#include "Day.h"
#include "utils.h"
#include <optional>
#include <string>
@ -19,7 +18,7 @@ int Task::id() const
return task_.id;
}
int Task::sourceId() const
int Task::source_id() const
{
return data_->id;
}
@ -39,50 +38,37 @@ bool Task::checked() const
return task_.state == mirai::DONE;
}
bool Task::hasEvent() const
bool Task::has_due_date() const
{
return task_.eventId.has_value();
return task_.due_date.has_value();
}
bool Task::hasDate() const
std::optional<Date> Task::due_date() const
{
return task_.dayId.has_value();
if (!task_.due_date.has_value()) {
return std::nullopt;
}
return task_.due_date.value();
}
void Task::setTitle(const std::string &newTitle)
void Task::set_title(const std::string &newTitle)
{
data_->update_task(id(), {.title = newTitle});
}
void Task::setDay(const Day &day)
void Task::set_date(const Date &date)
{
auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->update_task(id(), {.dayId = day.id(), .eventId = emptyEventId});
}
void Task::setDate(const Date &date)
{
auto day = data_->get_day_by_date(date);
if (!day.has_value()) {
day = data_->insert_day({.id = generateUniqueId(), .date = date});
}
auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->update_task(id(), {.dayId = day.value().id, .eventId = emptyEventId});
data_->update_task(id(), {.due_date = date});
}
void Task::unschedule()
{
auto emptyId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->update_task(id(), {.dayId = emptyId, .eventId = emptyId});
data_->update_task(id(), {.due_date = std::nullopt});
}
void Task::setEvent(const Event &event)
{
auto emptyDayId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->update_task(id(), {.dayId = emptyDayId, .eventId = event.id()});
}
void Task::setChecked(bool checked)
void Task::set_checked(bool checked)
{
data_->update_task(id(), {.state = checked ? DONE : TODO});
}

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

@ -1,164 +0,0 @@
/*
* Mirai. Copyright (C) 2024 Vyn
* This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
* The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
*/
#include "View.h"
#include "utils.h"
#include <algorithm>
#include <iostream>
#include <iterator>
#include <ranges>
namespace mirai
{
View::View(Mirai *mirai) : mirai_(mirai)
{
}
void View::hideCompletedTasks(bool hide)
{
shouldHideCompletedTasks_ = hide;
}
bool View::shouldHideCompletedTasks() const
{
return shouldHideCompletedTasks_;
}
std::vector<Date> View::getDates()
{
std::vector<Date> datesVector;
for (auto &date : dates) {
datesVector.push_back(date.first);
}
return datesVector;
}
std::vector<Task> View::getTasksForDate(const Date &date)
{
return dates.at(date).tasks;
}
std::vector<Event> View::getEventsForDate(const Date &date)
{
if (!dates.contains(date)) {
return {};
}
return dates.at(date).events;
}
std::vector<Task> View::getUnscheduledTasks()
{
return unscheduledTasks_;
}
void View::update()
{
dates.clear();
unscheduledTasks_.clear();
auto todayDate = Date(std::chrono::system_clock::now());
for (int sourceId : sourcesIds_) {
source *source = mirai_->getSourceById(sourceId);
for (auto day : source->get_days()) {
// day's tasks
auto sourceTasks = day.tasks() | std::ranges::views::filter([&](const Task &task) {
if (day.date() >= todayDate) {
return true;
}
if (shouldHideCompletedTasks()) {
return task.checked() == false;
}
return true;
});
if (day.date() >= todayDate || std::ranges::distance(sourceTasks) > 0) {
if (!dates.contains(day.date())) {
dates.insert_or_assign(day.date(), DateView{});
}
auto &tasks = dates.at(day.date()).tasks;
tasks.insert(tasks.end(), sourceTasks.begin(), sourceTasks.end());
}
// day's events
auto sourceEvents =
day.events() | std::ranges::views::filter([&](const Event &event) {
return (!shouldHideCompletedTasks() || day.date() >= todayDate) ||
findFirst(event.queryTasks(), [&](const Task &task) {
return task.checked() == false;
}).has_value();
});
if (day.date() >= todayDate || std::ranges::distance(sourceEvents) > 0) {
if (!dates.contains(day.date())) {
dates.insert_or_assign(day.date(), DateView{});
}
auto &events = dates.at(day.date()).events;
events.insert(events.end(), sourceEvents.begin(), sourceEvents.end());
}
}
// unscheduled tasks
auto tasks = source->get_unscheduled_tasks();
unscheduledTasks_.insert(unscheduledTasks_.end(), tasks.begin(), tasks.end());
}
for (auto &date : dates) {
auto &events = date.second.events;
std::sort(events.begin(), events.end(), [](const Event &a, const Event &b) {
return a.startsAt() < b.startsAt();
});
}
}
void View::removeSources()
{
sourcesIds_.clear();
}
void View::addSource(const source &source)
{
sourcesIds_.push_back(source.id);
}
void View::setSources(const std::vector<source> &sources)
{
sourcesIds_.clear();
std::transform(
sources.begin(), sources.end(), std::back_inserter(sourcesIds_), [](const source &source) {
return source.id;
}
);
}
void View::setAllSources()
{
const auto &sources = mirai_->getSources();
sourcesIds_.clear();
std::transform(
sources.begin(), sources.end(), std::back_inserter(sourcesIds_),
[](const std::unique_ptr<source> &source) {
return source->id;
}
);
}
bool View::isSourceSelected(const source &source) const
{
for (auto &sourceId : sourcesIds_) {
if (sourceId == source.id) {
return true;
}
}
return false;
}
size_t View::activeSourceCount() const
{
return sourcesIds_.size();
}
} // namespace mirai

2
external/mirai-core/src/utils.cpp vendored
View file

@ -39,7 +39,7 @@ bool isDate(const std::string &dateStr)
return true;
}
int generateUniqueId()
int generate_unique_id()
{
static int nextId = 0;
return nextId++;