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 return false;
140 }
141 return (version == metaData.version && storeType == metaData.storeType && dataType == metaData.dataType &&
142 securityLevel == metaData.securityLevel && area == metaData.area && uid == metaData.uid &&
143 tokenId == metaData.tokenId && instanceId == metaData.instanceId && appId == metaData.appId &&
144 appType == metaData.appType && bundleName == metaData.bundleName && dataDir == metaData.dataDir &&
145 storeId == metaData.storeId && user == metaData.user && deviceId == metaData.deviceId &&
146 account == metaData.account && authType == metaData.authType && haMode == metaData.haMode);
147 }
148
operator !=(const StoreMetaData & metaData) const149 bool StoreMetaData::operator!=(const StoreMetaData &metaData) const
150 {
151 return !(*this == metaData);
152 }
153
GetKey() const154 std::string StoreMetaData::GetKey() const
155 {
156 if (instanceId == 0) {
157 return GetKey({ deviceId, user, "default", bundleName, storeId });
158 }
159 return GetKey({ deviceId, user, "default", bundleName, storeId, std::to_string(instanceId) });
160 }
161
GetKeyLocal() const162 std::string StoreMetaData::GetKeyLocal() const
163 {
164 if (instanceId == 0) {
165 return StoreMetaDataLocal::GetKey({ deviceId, user, "default", bundleName, storeId });
166 }
167 return StoreMetaDataLocal::GetKey({ deviceId, user, "default", bundleName, storeId, std::to_string(instanceId) });
168 }
169
GetSecretKey() const170 std::string StoreMetaData::GetSecretKey() const
171 {
172 if (version < UUID_CHANGED_TAG) {
173 return SecretKeyMetaData::GetKey({ user, "default", bundleName, storeId });
174 }
175 return SecretKeyMetaData::GetKey({ user, "default", bundleName, storeId, std::to_string(instanceId) });
176 }
177
GetBackupSecretKey() const178 std::string StoreMetaData::GetBackupSecretKey() const
179 {
180 if (version < UUID_CHANGED_TAG) {
181 return SecretKeyMetaData::GetBackupKey({ user, "default", bundleName, storeId });
182 }
183 return SecretKeyMetaData::GetBackupKey({ user, "default", bundleName, storeId, std::to_string(instanceId) });
184 }
185
GetAutoLaunchKey() const186 std::string StoreMetaData::GetAutoLaunchKey() const
187 {
188 return AutoLaunchMetaData::GetPrefix({ deviceId, user, "default", bundleName, storeId });
189 }
190
GetDebugInfoKey() const191 std::string StoreMetaData::GetDebugInfoKey() const
192 {
193 return StoreDebugInfo::GetPrefix({ deviceId, user, "default", bundleName, storeId, std::to_string(instanceId) });
194 }
195
GetStoreAlias() const196 std::string StoreMetaData::GetStoreAlias() const
197 {
198 return Anonymous::Change(storeId);
199 }
200
GetStrategyKey() const201 std::string StoreMetaData::GetStrategyKey() const
202 {
203 if (instanceId == 0) {
204 return StrategyMeta::GetPrefix({ deviceId, user, "default", bundleName, storeId });
205 }
206 return StrategyMeta::GetPrefix({ deviceId, user, "default", bundleName, storeId, std::to_string(instanceId) });
207 }
208
GetKey(const std::initializer_list<std::string> & fields)209 std::string StoreMetaData::GetKey(const std::initializer_list<std::string> &fields)
210 {
211 std::string prefix = KEY_PREFIX;
212 for (const auto &field : fields) {
213 prefix.append(Constant::KEY_SEPARATOR).append(field);
214 }
215 return prefix;
216 }
217
GetPrefix(const std::initializer_list<std::string> & fields)218 std::string StoreMetaData::GetPrefix(const std::initializer_list<std::string> &fields)
219 {
220 return GetKey(fields).append(Constant::KEY_SEPARATOR);
221 }
222
GetStoreInfo() const223 StoreInfo StoreMetaData::GetStoreInfo() const
224 {
225 StoreInfo info;
226 info.instanceId = instanceId;
227 info.bundleName = bundleName;
228 info.storeName = storeId;
229 info.user = atoi(user.c_str());
230 return info;
231 }
232 } // namespace DistributedData
233 } // namespace OHOS