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