1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ash/child_accounts/time_limit_test_utils.h"
#include <algorithm>
#include <optional>
#include <utility>
#include "base/json/json_writer.h"
#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
namespace ash {
namespace time_limit_test_utils {
namespace {
// Definition of private constants.
constexpr char kTimeLimitLastUpdatedAt[] = "last_updated_millis";
constexpr char kTimeWindowLimit[] = "time_window_limit";
constexpr char kTimeUsageLimit[] = "time_usage_limit";
constexpr char kUsageLimitResetAt[] = "reset_at";
constexpr char kUsageLimitUsageQuota[] = "usage_quota_mins";
constexpr char kWindowLimitEntries[] = "entries";
constexpr char kWindowLimitEntryEffectiveDay[] = "effective_day";
constexpr char kWindowLimitEntryEndsAt[] = "ends_at";
constexpr char kWindowLimitEntryStartsAt[] = "starts_at";
constexpr char kWindowLimitEntryTimeHour[] = "hour";
constexpr char kWindowLimitEntryTimeMinute[] = "minute";
} // namespace
// Definition of public constants.
const char kMonday[] = "MONDAY";
const char kTuesday[] = "TUESDAY";
const char kWednesday[] = "WEDNESDAY";
const char kThursday[] = "THURSDAY";
const char kFriday[] = "FRIDAY";
const char kSaturday[] = "SATURDAY";
const char kSunday[] = "SUNDAY";
base::Time TimeFromString(const char* time_string) {
base::Time time;
if (!base::Time::FromUTCString(time_string, &time))
LOG(ERROR) << "Wrong time string format.";
return time;
}
std::string CreatePolicyTimestamp(const char* time_string) {
base::Time time = TimeFromString(time_string);
return CreatePolicyTimestamp(time);
}
std::string CreatePolicyTimestamp(base::Time time) {
return base::NumberToString(
(time - base::Time::UnixEpoch()).InMilliseconds());
}
base::TimeDelta CreateTime(int hour, int minute) {
DCHECK_LT(hour, 24);
DCHECK_GE(hour, 0);
DCHECK_LT(minute, 60);
DCHECK_GE(minute, 0);
return base::Minutes(hour * 60 + minute);
}
base::Value::Dict CreatePolicyTime(base::TimeDelta time) {
DCHECK_EQ(time.InNanoseconds() % base::Minutes(1).InNanoseconds(), 0);
DCHECK_LT(time, base::Hours(24));
int hour = time.InHours();
int minute = time.InMinutes() - time.InHours() * base::Hours(1).InMinutes();
base::Value::Dict policyTime;
policyTime.Set(kWindowLimitEntryTimeHour, base::Value(hour));
policyTime.Set(kWindowLimitEntryTimeMinute, base::Value(minute));
return policyTime;
}
base::Value::Dict CreateTimeWindow(const std::string& day,
base::TimeDelta start_time,
base::TimeDelta end_time,
base::Time last_updated) {
base::Value::Dict time_window;
time_window.Set(kWindowLimitEntryEffectiveDay, base::Value(day));
time_window.Set(kWindowLimitEntryStartsAt, CreatePolicyTime(start_time));
time_window.Set(kWindowLimitEntryEndsAt, CreatePolicyTime(end_time));
time_window.Set(kTimeLimitLastUpdatedAt,
base::Value(CreatePolicyTimestamp(last_updated)));
return time_window;
}
base::Value::Dict CreateTimeUsage(base::TimeDelta usage_quota,
base::Time last_updated) {
base::Value::Dict time_usage;
time_usage.Set(kUsageLimitUsageQuota, base::Value(usage_quota.InMinutes()));
time_usage.Set(kTimeLimitLastUpdatedAt,
base::Value(CreatePolicyTimestamp(last_updated)));
return time_usage;
}
base::Value::Dict CreateTimeLimitPolicy(base::TimeDelta reset_time) {
base::Value::Dict time_usage_limit;
time_usage_limit.Set(kUsageLimitResetAt, CreatePolicyTime(reset_time));
base::Value::Dict time_limit;
time_limit.Set(kTimeUsageLimit, std::move(time_usage_limit));
return time_limit;
}
void AddTimeUsageLimit(base::Value::Dict* policy,
std::string day,
base::TimeDelta quota,
base::Time last_updated) {
// Asserts that the usage limit quota in minutes corresponds to an integer
// number.
DCHECK_EQ(quota.InNanoseconds() % base::Minutes(1).InNanoseconds(), 0);
DCHECK_LT(quota, base::Hours(24));
std::ranges::transform(day, day.begin(), ::tolower);
policy->Find(kTimeUsageLimit)
->GetDict()
.Set(day, CreateTimeUsage(quota, last_updated));
}
void AddTimeWindowLimit(base::Value::Dict* policy,
const std::string& day,
base::TimeDelta start_time,
base::TimeDelta end_time,
base::Time last_updated) {
base::Value::Dict* time_window_limit = policy->EnsureDict(kTimeWindowLimit);
base::Value::List* window_limit_entries =
time_window_limit->EnsureList(kWindowLimitEntries);
window_limit_entries->Append(
CreateTimeWindow(day, start_time, end_time, last_updated));
}
void AddOverride(base::Value::Dict* policy,
usage_time_limit::TimeLimitOverride::Action action,
base::Time created_at) {
base::Value::List* overrides = policy->EnsureList(
usage_time_limit::TimeLimitOverride::kOverridesDictKey);
usage_time_limit::TimeLimitOverride new_override(action, created_at,
std::nullopt);
overrides->Append(new_override.ToDictionary());
}
void AddOverrideWithDuration(base::Value::Dict* policy,
usage_time_limit::TimeLimitOverride::Action action,
base::Time created_at,
base::TimeDelta duration) {
base::Value::List* overrides = policy->EnsureList(
usage_time_limit::TimeLimitOverride::kOverridesDictKey);
usage_time_limit::TimeLimitOverride new_override(action, created_at,
duration);
overrides->Append(new_override.ToDictionary());
}
std::string PolicyToString(const base::Value::Dict& policy) {
std::string json_string;
base::JSONWriter::Write(policy, &json_string);
return json_string;
}
} // namespace time_limit_test_utils
} // namespace ash
|
