1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "metadata/store_meta_data.h"
17
18 #include "metadata/auto_launch_meta_data.h"
19 #include "metadata/secret_key_meta_data.h"
20 #include "metadata/store_debug_info.h"
21 #include "metadata/store_meta_data_local.h"
22 #include "metadata/strategy_meta_data.h"
23 #include "utils/anonymous.h"
24 #include "utils/constant.h"
25 namespace OHOS {
26 namespace DistributedData {
27 constexpr uint32_t StoreMetaData::CURRENT_VERSION;
28 constexpr uint32_t StoreMetaData::FIELD_CHANGED_TAG;
29 constexpr const char *StoreMetaData::KEY_PREFIX;
Marshal(json & node) const30 bool StoreMetaData::Marshal(json &node) const
31 {
32 SetValue(node[GET_NAME(version)], version);
33 SetValue(node[GET_NAME(isAutoSync)], isAutoSync);
34 SetValue(node[GET_NAME(isBackup)], isBackup);
35 SetValue(node[GET_NAME(isEncrypt)], isEncrypt);
36 SetValue(node[GET_NAME(isManualClean)], isManualClean);
37 SetValue(node[GET_NAME(isDirty)], isDirty);
38 SetValue(node[GET_NAME(isSearchable)], isSearchable);
39 SetValue(node[GET_NAME(isNeedCompress)], isNeedCompress);
40 SetValue(node[GET_NAME(storeType)], storeType);
41 SetValue(node[GET_NAME(securityLevel)], securityLevel);
42 SetValue(node[GET_NAME(area)], area);
43 SetValue(node[GET_NAME(uid)], uid);
44 SetValue(node[GET_NAME(tokenId)], tokenId);
45 SetValue(node[GET_NAME(instanceId)], instanceId);
46 SetValue(node[GET_NAME(appId)], appId);
47 SetValue(node[GET_NAME(appType)], appType);
48 SetValue(node[GET_NAME(bundleName)], bundleName);
49 SetValue(node[GET_NAME(hapName)], hapName);
50 SetValue(node[GET_NAME(dataDir)], dataDir);
51 SetValue(node[GET_NAME(deviceId)], deviceId);
52 SetValue(node[GET_NAME(schema)], schema);
53 SetValue(node[GET_NAME(storeId)], storeId);
54 SetValue(node[GET_NAME(user)], user);
55 SetValue(node[GET_NAME(account)], account);
56 SetValue(node[GET_NAME(dataType)], dataType);
57 SetValue(node[GET_NAME(enableCloud)], enableCloud);
58 SetValue(node[GET_NAME(cloudAutoSync)], cloudAutoSync);
59 // compatible with the versions which lower than VERSION_TAG_0000
60 SetValue(node[GET_NAME(kvStoreType)], storeType);
61 SetValue(node[GET_NAME(deviceAccountID)], user);
62 SetValue(node[GET_NAME(userId)], account);
63 SetValue(node[GET_NAME(UID)], uid);
64 SetValue(node[GET_NAME(customDir)], customDir);
65 SetValue(node[GET_NAME(authType)], authType);
66 SetValue(node[GET_NAME(haMode)], haMode);
67 return true;
68 }
69
Unmarshal(const json & node)70 bool StoreMetaData::Unmarshal(const json &node)
71 {
72 GetValue(node, GET_NAME(version), version);
73 GetValue(node, GET_NAME(isAutoSync), isAutoSync);
74 GetValue(node, GET_NAME(isBackup), isBackup);
75 GetValue(node, GET_NAME(isDirty), isDirty);
76 GetValue(node, GET_NAME(isEncrypt), isEncrypt);
77 GetValue(node, GET_NAME(isManualClean), isManualClean);
78 GetValue(node, GET_NAME(isSearchable), isSearchable);
79 GetValue(node, GET_NAME(isNeedCompress), isNeedCompress);
80 GetValue(node, GET_NAME(storeType), storeType);
81 GetValue(node, GET_NAME(securityLevel), securityLevel);
82 GetValue(node, GET_NAME(area), area);
83 GetValue(node, GET_NAME(uid), uid);
84 GetValue(node, GET_NAME(tokenId), tokenId);
85 GetValue(node, GET_NAME(instanceId), instanceId);
86 GetValue(node, GET_NAME(appId), appId);
87 GetValue(node, GET_NAME(appType), appType);
88 GetValue(node, GET_NAME(bundleName), bundleName);
89 GetValue(node, GET_NAME(hapName), hapName);
90 GetValue(node, GET_NAME(dataDir), dataDir);
91 GetValue(node, GET_NAME(deviceId), deviceId);
92 GetValue(node, GET_NAME(schema), schema);
93 GetValue(node, GET_NAME(storeId), storeId);
94 GetValue(node, GET_NAME(user), user);
95 GetValue(node, GET_NAME(account), account);
96 GetValue(node, GET_NAME(dataType), dataType);
97 GetValue(node, GET_NAME(enableCloud), enableCloud);
98 GetValue(node, GET_NAME(cloudAutoSync), cloudAutoSync);
99 // compatible with the older versions
100 if (version < FIELD_CHANGED_TAG) {
101 GetValue(node, GET_NAME(kvStoreType), storeType);
102 GetValue(node, GET_NAME(UID), uid);
103 GetValue(node, GET_NAME(deviceAccountID), user);
104 GetValue(node, GET_NAME(userId), account);
105 }
106 GetValue(node, GET_NAME(customDir), customDir);
107 GetValue(node, GET_NAME(authType), authType);
108 GetValue(node, GET_NAME(haMode), haMode);
109 return true;
110 }
111
StoreMetaData()112 StoreMetaData::StoreMetaData()
113 {
114 }
115
~StoreMetaData()116 StoreMetaData::~StoreMetaData()
117 {
118 }
119
StoreMetaData(const std::string & userId,const std::string & appId,const std::string & storeId)120 StoreMetaData::StoreMetaData(const std::string &userId, const std::string &appId, const std::string &storeId)
121 : appId(appId), storeId(storeId), user(userId)
122 {
123 }
124
StoreMetaData(const StoreInfo & storeInfo)125 StoreMetaData::StoreMetaData(const StoreInfo &storeInfo)
126 : instanceId(storeInfo.instanceId), bundleName(storeInfo.bundleName), storeId(storeInfo.storeName),
127 user(std::to_string(storeInfo.user))
128 {
129 }
130
operator ==(const StoreMetaData & metaData) const131 bool StoreMetaData::operator==(const StoreMetaData &metaData) const
132 {
133 if (Constant::NotEqual(isAutoSync, metaData.isAutoSync) || Constant::NotEqual(isBackup, metaData.isBackup) ||
134 Constant::NotEqual(isDirty, metaData.isDirty) || Constant::NotEqual(isEncrypt, metaData.isEncrypt) ||
135 Constant::NotEqual(isSearchable, metaData.isSearchable) ||
136 Constant::NotEqual(isNeedCompress, metaData.isNeedCompress) ||
137 Constant::NotEqual(enableCloud, metaData.enableCloud) ||
138 Constant::NotEqual(cloudAutoSync, metaData.cloudAutoSync) ||
139 Constant::NotEqual(isManualClean, metaData.isManualClean)) {
140 return false;
141 }
142 return (version == metaData.version && storeType == metaData.storeType && dataType == metaData.dataType &&
143 securityLevel == metaData.securityLevel && area == metaData.area && uid == metaData.uid &&
144 tokenId == metaData.tokenId && instanceId == metaData.instanceId && appId == metaData.appId &&
145 appType == metaData.appType && bundleName == metaData.bundleName && dataDir == metaData.dataDir &&
146 storeId == metaData.storeId && user == metaData.user && deviceId == metaData.deviceId &&
147 account == metaData.account && authType == metaData.authType && haMode == metaData.haMode);
148 }
149
operator !=(const StoreMetaData & metaData) const150 bool StoreMetaData::operator!=(const StoreMetaData &metaData) const
151 {
152 return !(*this == metaData);
153 }
154
GetKey() const155 std::string StoreMetaData::GetKey() const
156 {
157 if (instanceId == 0) {
158 return GetKey({ deviceId, user, "default", bundleName, storeId });
159 }
160 return GetKey({ deviceId, user, "default", bundleName, storeId, std::to_string(instanceId) });
161 }
162
GetKeyLocal() const163 std::string StoreMetaData::GetKeyLocal() const
164 {
165 if (instanceId == 0) {
166 return StoreMetaDataLocal::GetKey({ deviceId, user, "default", bundleName, storeId });
167 }
168 return StoreMetaDataLocal::GetKey({ deviceId, user, "default", bundleName, storeId, std::to_string(instanceId) });
169 }
170
GetSecretKey() const171 std::string StoreMetaData::GetSecretKey() const
172 {
173 if (version < UUID_CHANGED_TAG) {
174 return SecretKeyMetaData::GetKey({ user, "default", bundleName, storeId });
175 }
176 return SecretKeyMetaData::GetKey({ user, "default", bundleName, storeId, std::to_string(instanceId) });
177 }
178
GetBackupSecretKey() const179 std::string StoreMetaData::GetBackupSecretKey() const
180 {
181 if (version < UUID_CHANGED_TAG) {
182 return SecretKeyMetaData::GetBackupKey({ user, "default", bundleName, storeId });
183 }
184 return SecretKeyMetaData::GetBackupKey({ user, "default", bundleName, storeId, std::to_string(instanceId) });
185 }
186
GetAutoLaunchKey() const187 std::string StoreMetaData::GetAutoLaunchKey() const
188 {
189 return AutoLaunchMetaData::GetPrefix({ deviceId, user, "default", bundleName, storeId });
190 }
191
GetDebugInfoKey() const192 std::string StoreMetaData::GetDebugInfoKey() const
193 {
194 return StoreDebugInfo::GetPrefix({ deviceId, user, "default", bundleName, storeId, std::to_string(instanceId) });
195 }
196
GetStoreAlias() const197 std::string StoreMetaData::GetStoreAlias() const
198 {
199 return Anonymous::Change(storeId);
200 }
201
GetStrategyKey() const202 std::string StoreMetaData::GetStrategyKey() const
203 {
204 if (instanceId == 0) {
205 return StrategyMeta::GetPrefix({ deviceId, user, "default", bundleName, storeId });
206 }
207 return StrategyMeta::GetPrefix({ deviceId, user, "default", bundleName, storeId, std::to_string(instanceId) });
208 }
209
GetKey(const std::initializer_list<std::string> & fields)210 std::string StoreMetaData::GetKey(const std::initializer_list<std::string> &fields)
211 {
212 std::string prefix = KEY_PREFIX;
213 for (const auto &field : fields) {
214 prefix.append(Constant::KEY_SEPARATOR).append(field);
215 }
216 return prefix;
217 }
218
GetPrefix(const std::initializer_list<std::string> & fields)219 std::string StoreMetaData::GetPrefix(const std::initializer_list<std::string> &fields)
220 {
221 return GetKey(fields).append(Constant::KEY_SEPARATOR);
222 }
223
GetStoreInfo() const224 StoreInfo StoreMetaData::GetStoreInfo() const
225 {
226 StoreInfo info;
227 info.instanceId = instanceId;
228 info.bundleName = bundleName;
229 info.storeName = storeId;
230 info.user = atoi(user.c_str());
231 return info;
232 }
233 } // namespace DistributedData
234 } // namespace OHOS