Line data Source code
1 : /**
2 : * Copyright Soramitsu Co., Ltd. All Rights Reserved.
3 : * SPDX-License-Identifier: Apache-2.0
4 : */
5 :
6 : #include "model/converters/pb_command_factory.hpp"
7 :
8 : #include <boost/assign/list_inserter.hpp>
9 :
10 : #include "common/byteutils.hpp"
11 : #include "common/instanceof.hpp"
12 : #include "model/converters/pb_common.hpp"
13 :
14 : using namespace shared_model::permissions;
15 :
16 : namespace iroha {
17 : namespace model {
18 : namespace converters {
19 :
20 : /**
21 : * convert hex string to pubkey
22 : * @param dest reference to destination public key
23 : * @param src source string
24 : */
25 : static void trySetHexKey(pubkey_t &dest, const std::string &src) {
26 7 : iroha::hexstringToArray<pubkey_t::size()>(src) |
27 : [&dest](const auto &blob) { dest = blob; };
28 7 : }
29 :
30 : PbCommandFactory::PbCommandFactory() {
31 154 : boost::assign::insert(pb_role_map_)
32 : // Can append role
33 : (protocol::RolePermission::can_append_role, can_append_role)
34 : // Can create role
35 : (protocol::RolePermission::can_create_role, can_create_role)
36 : // Can append role
37 : (protocol::RolePermission::can_detach_role, can_detach_role)
38 : // Can add asset quantity
39 : (protocol::RolePermission::can_add_asset_qty, can_add_asset_qty)
40 : // Can subtract asset quantity
41 : (protocol::RolePermission::can_subtract_asset_qty,
42 : can_subtract_asset_qty)
43 : // Can add peer
44 : (protocol::RolePermission::can_add_peer, can_add_peer)
45 : // Can add signatory
46 : (protocol::RolePermission::can_add_signatory, can_add_signatory)
47 : // Can remove signatory
48 : (protocol::RolePermission::can_remove_signatory,
49 : can_remove_signatory)
50 : // Can set quorum
51 : (protocol::RolePermission::can_set_quorum, can_set_quorum)
52 : // Can create account
53 : (protocol::RolePermission::can_create_account, can_create_account)
54 : // Can set detail
55 : (protocol::RolePermission::can_set_detail, can_set_detail)
56 : // Can create asset
57 : (protocol::RolePermission::can_create_asset, can_create_asset)
58 : // Can transfer
59 : (protocol::RolePermission::can_transfer, can_transfer)
60 : // Can receive
61 : (protocol::RolePermission::can_receive, can_receive)
62 : // Can create domain
63 : (protocol::RolePermission::can_create_domain, can_create_domain)
64 : // Can read assets
65 : (protocol::RolePermission::can_read_assets, can_read_assets)
66 : // Can get roles
67 : (protocol::RolePermission::can_get_roles, can_get_roles)
68 : // Can get my account
69 : (protocol::RolePermission::can_get_my_account, can_get_my_account)
70 : // Can get all accounts
71 : (protocol::RolePermission::can_get_all_accounts,
72 : can_get_all_accounts)
73 : // Can get domain accounts
74 : (protocol::RolePermission::can_get_domain_accounts,
75 : can_get_domain_accounts)
76 : // Can get my signatories
77 : (protocol::RolePermission::can_get_my_signatories,
78 : can_get_my_signatories)
79 : // Can get all signatories
80 : (protocol::RolePermission::can_get_all_signatories,
81 : can_get_all_signatories)
82 : // Can get domain signatories
83 : (protocol::RolePermission::can_get_domain_signatories,
84 : can_get_domain_signatories)
85 : // Can get my account assets
86 : (protocol::RolePermission::can_get_my_acc_ast, can_get_my_acc_ast)
87 : // Can get all account assets
88 : (protocol::RolePermission::can_get_all_acc_ast, can_get_all_acc_ast)
89 : // Can get domain account assets
90 : (protocol::RolePermission::can_get_domain_acc_ast,
91 : can_get_domain_acc_ast)
92 : // Can get my account detail
93 : (protocol::RolePermission::can_get_my_acc_detail,
94 : can_get_my_acc_detail)
95 : // Can get all account detail
96 : (protocol::RolePermission::can_get_all_acc_detail,
97 : can_get_all_acc_detail)
98 : // Can get domain account detail
99 : (protocol::RolePermission::can_get_domain_acc_detail,
100 : can_get_domain_acc_detail)
101 : // Can get my account transactions
102 : (protocol::RolePermission::can_get_my_acc_txs, can_get_my_acc_txs)
103 : // Can get all account transactions
104 : (protocol::RolePermission::can_get_all_acc_txs, can_get_all_acc_txs)
105 : // Can get domain account transactions
106 : (protocol::RolePermission::can_get_domain_acc_txs,
107 : can_get_domain_acc_txs)
108 : // Can get my account assets transactions
109 : (protocol::RolePermission::can_get_my_acc_ast_txs,
110 : can_get_my_acc_ast_txs)
111 : // Can get all account asset transactions
112 : (protocol::RolePermission::can_get_all_acc_ast_txs,
113 : can_get_all_acc_ast_txs)
114 : // Can get domain account asset transactions
115 : (protocol::RolePermission::can_get_domain_acc_ast_txs,
116 : can_get_domain_acc_ast_txs)
117 : // Can get my transactions
118 : (protocol::RolePermission::can_get_my_txs, can_get_my_txs)
119 : // Can get all transactions
120 : (protocol::RolePermission::can_get_all_txs, can_get_all_txs)
121 :
122 : // Can grant set quorum
123 : (protocol::RolePermission::can_grant_can_set_my_quorum,
124 154 : can_grant + can_set_my_quorum)
125 : // Can grant add signatory
126 : (protocol::RolePermission::can_grant_can_add_my_signatory,
127 154 : can_grant + can_add_my_signatory)
128 : // Can grant remove signatory
129 : (protocol::RolePermission::can_grant_can_remove_my_signatory,
130 154 : can_grant + can_remove_my_signatory)
131 : // Can grant can_transfer
132 : (protocol::RolePermission::can_grant_can_transfer_my_assets,
133 154 : can_grant + can_transfer_my_assets)
134 : // Can write details to other accounts
135 : (protocol::RolePermission::can_grant_can_set_my_account_detail,
136 154 : can_grant + can_set_my_account_detail)
137 :
138 : // Can get blocks
139 : (protocol::RolePermission::can_get_blocks, can_get_blocks);
140 :
141 154 : boost::assign::insert(pb_grant_map_)
142 : // Can add my signatory
143 : (protocol::GrantablePermission::can_add_my_signatory,
144 : can_add_signatory)
145 : // Can remove my signatory
146 : (protocol::GrantablePermission::can_remove_my_signatory,
147 : can_remove_signatory)
148 : // Can set my quorum
149 : (protocol::GrantablePermission::can_set_my_quorum, can_set_quorum)
150 : // Can write details to other accounts
151 : (protocol::GrantablePermission::can_set_my_account_detail,
152 : can_set_detail)
153 : // Can transfer my assets
154 : (protocol::GrantablePermission::can_transfer_my_assets,
155 : can_transfer);
156 154 : }
157 :
158 : // asset quantity
159 : protocol::AddAssetQuantity PbCommandFactory::serializeAddAssetQuantity(
160 : const model::AddAssetQuantity &add_asset_quantity) {
161 4 : protocol::AddAssetQuantity pb_add_asset_quantity;
162 4 : pb_add_asset_quantity.set_asset_id(add_asset_quantity.asset_id);
163 4 : pb_add_asset_quantity.set_amount(add_asset_quantity.amount);
164 4 : return pb_add_asset_quantity;
165 4 : }
166 :
167 : model::AddAssetQuantity PbCommandFactory::deserializeAddAssetQuantity(
168 : const protocol::AddAssetQuantity &pb_add_asset_quantity) {
169 2 : model::AddAssetQuantity add_asset_quantity;
170 2 : add_asset_quantity.asset_id = pb_add_asset_quantity.asset_id();
171 2 : add_asset_quantity.amount = pb_add_asset_quantity.amount();
172 :
173 2 : return add_asset_quantity;
174 2 : }
175 :
176 : // subtract asset quantity
177 : protocol::SubtractAssetQuantity
178 : PbCommandFactory::serializeSubtractAssetQuantity(
179 : const model::SubtractAssetQuantity &subtract_asset_quantity) {
180 4 : protocol::SubtractAssetQuantity pb_subtract_asset_quantity;
181 4 : pb_subtract_asset_quantity.set_asset_id(
182 4 : subtract_asset_quantity.asset_id);
183 4 : pb_subtract_asset_quantity.set_amount(subtract_asset_quantity.amount);
184 4 : return pb_subtract_asset_quantity;
185 4 : }
186 :
187 : model::SubtractAssetQuantity
188 : PbCommandFactory::deserializeSubtractAssetQuantity(
189 : const protocol::SubtractAssetQuantity &pb_subtract_asset_quantity) {
190 2 : model::SubtractAssetQuantity subtract_asset_quantity;
191 2 : subtract_asset_quantity.asset_id =
192 2 : pb_subtract_asset_quantity.asset_id();
193 2 : subtract_asset_quantity.amount = pb_subtract_asset_quantity.amount();
194 :
195 2 : return subtract_asset_quantity;
196 2 : }
197 :
198 : // add peer
199 : protocol::AddPeer PbCommandFactory::serializeAddPeer(
200 : const model::AddPeer &add_peer) {
201 4 : protocol::AddPeer pb_add_peer;
202 4 : auto peer = pb_add_peer.mutable_peer();
203 4 : peer->CopyFrom(serializePeer(add_peer.peer));
204 4 : return pb_add_peer;
205 4 : }
206 :
207 : model::AddPeer PbCommandFactory::deserializeAddPeer(
208 : const protocol::AddPeer &pb_add_peer) {
209 2 : model::AddPeer add_peer;
210 2 : add_peer.peer = deserializePeer(pb_add_peer.peer());
211 :
212 2 : return add_peer;
213 2 : }
214 :
215 : // add signatory
216 : protocol::AddSignatory PbCommandFactory::serializeAddSignatory(
217 : const model::AddSignatory &add_signatory) {
218 5 : protocol::AddSignatory pb_add_signatory;
219 5 : pb_add_signatory.set_account_id(add_signatory.account_id);
220 5 : pb_add_signatory.set_public_key(add_signatory.pubkey.to_hexstring());
221 5 : return pb_add_signatory;
222 5 : }
223 :
224 : model::AddSignatory PbCommandFactory::deserializeAddSignatory(
225 : const protocol::AddSignatory &pb_add_signatory) {
226 3 : model::AddSignatory add_signatory;
227 3 : add_signatory.account_id = pb_add_signatory.account_id();
228 3 : trySetHexKey(add_signatory.pubkey, pb_add_signatory.public_key());
229 3 : return add_signatory;
230 3 : }
231 :
232 : // create asset
233 : protocol::CreateAsset PbCommandFactory::serializeCreateAsset(
234 : const model::CreateAsset &create_asset) {
235 7 : protocol::CreateAsset pb_create_asset;
236 7 : pb_create_asset.set_asset_name(create_asset.asset_name);
237 7 : pb_create_asset.set_domain_id(create_asset.domain_id);
238 7 : pb_create_asset.set_precision(create_asset.precision);
239 7 : return pb_create_asset;
240 7 : }
241 :
242 : model::CreateAsset PbCommandFactory::deserializeCreateAsset(
243 : const protocol::CreateAsset &pb_create_asset) {
244 4 : model::CreateAsset create_asset;
245 4 : create_asset.asset_name = pb_create_asset.asset_name();
246 4 : create_asset.domain_id = pb_create_asset.domain_id();
247 4 : create_asset.precision =
248 4 : static_cast<uint8_t>(pb_create_asset.precision());
249 4 : return create_asset;
250 4 : }
251 :
252 : // create account
253 : protocol::CreateAccount PbCommandFactory::serializeCreateAccount(
254 : const model::CreateAccount &create_account) {
255 4 : protocol::CreateAccount pb_create_account;
256 4 : pb_create_account.set_account_name(create_account.account_name);
257 4 : pb_create_account.set_domain_id(create_account.domain_id);
258 4 : pb_create_account.set_public_key(create_account.pubkey.to_hexstring());
259 4 : return pb_create_account;
260 4 : }
261 : model::CreateAccount PbCommandFactory::deserializeCreateAccount(
262 : const protocol::CreateAccount &pb_create_account) {
263 2 : model::CreateAccount create_account;
264 2 : create_account.account_name = pb_create_account.account_name();
265 2 : create_account.domain_id = pb_create_account.domain_id();
266 2 : trySetHexKey(create_account.pubkey, pb_create_account.public_key());
267 2 : return create_account;
268 2 : }
269 :
270 : // create domain
271 : protocol::CreateDomain PbCommandFactory::serializeCreateDomain(
272 : const model::CreateDomain &create_domain) {
273 7 : protocol::CreateDomain pb_create_domain;
274 7 : pb_create_domain.set_domain_id(create_domain.domain_id);
275 7 : pb_create_domain.set_default_role(create_domain.user_default_role);
276 7 : return pb_create_domain;
277 7 : }
278 :
279 : model::CreateDomain PbCommandFactory::deserializeCreateDomain(
280 : const protocol::CreateDomain &pb_create_domain) {
281 4 : model::CreateDomain create_domain;
282 4 : create_domain.domain_id = pb_create_domain.domain_id();
283 4 : create_domain.user_default_role = pb_create_domain.default_role();
284 4 : return create_domain;
285 4 : }
286 :
287 : // remove signatory
288 : protocol::RemoveSignatory PbCommandFactory::serializeRemoveSignatory(
289 : const model::RemoveSignatory &remove_signatory) {
290 4 : protocol::RemoveSignatory pb_remove_signatory;
291 4 : pb_remove_signatory.set_account_id(remove_signatory.account_id);
292 4 : pb_remove_signatory.set_public_key(
293 4 : remove_signatory.pubkey.to_hexstring());
294 4 : return pb_remove_signatory;
295 4 : }
296 :
297 : model::RemoveSignatory PbCommandFactory::deserializeRemoveSignatory(
298 : const protocol::RemoveSignatory &pb_remove_signatory) {
299 2 : model::RemoveSignatory remove_signatory;
300 2 : remove_signatory.account_id = pb_remove_signatory.account_id();
301 2 : trySetHexKey(remove_signatory.pubkey, pb_remove_signatory.public_key());
302 2 : return remove_signatory;
303 2 : }
304 : // set account quorum
305 : protocol::SetAccountQuorum PbCommandFactory::serializeSetQuorum(
306 : const model::SetQuorum &set_account_quorum) {
307 2 : protocol::SetAccountQuorum pb_set_account_quorum;
308 2 : pb_set_account_quorum.set_account_id(set_account_quorum.account_id);
309 2 : pb_set_account_quorum.set_quorum(set_account_quorum.new_quorum);
310 2 : return pb_set_account_quorum;
311 2 : }
312 : model::SetQuorum PbCommandFactory::deserializeSetQuorum(
313 : const protocol::SetAccountQuorum &pb_set_account_quorum) {
314 2 : model::SetQuorum set_quorum;
315 2 : set_quorum.account_id = pb_set_account_quorum.account_id();
316 2 : set_quorum.new_quorum = pb_set_account_quorum.quorum();
317 2 : return set_quorum;
318 2 : }
319 :
320 : // transfer asset
321 : protocol::TransferAsset PbCommandFactory::serializeTransferAsset(
322 : const model::TransferAsset &transfer_asset) {
323 4 : protocol::TransferAsset pb_transfer_asset;
324 :
325 4 : pb_transfer_asset.set_src_account_id(transfer_asset.src_account_id);
326 4 : pb_transfer_asset.set_dest_account_id(transfer_asset.dest_account_id);
327 4 : pb_transfer_asset.set_asset_id(transfer_asset.asset_id);
328 4 : pb_transfer_asset.set_description(transfer_asset.description);
329 4 : pb_transfer_asset.set_amount(transfer_asset.amount);
330 4 : return pb_transfer_asset;
331 4 : }
332 :
333 : model::TransferAsset PbCommandFactory::deserializeTransferAsset(
334 : const protocol::TransferAsset &pb_subtract_asset_quantity) {
335 2 : model::TransferAsset transfer_asset;
336 2 : transfer_asset.src_account_id =
337 2 : pb_subtract_asset_quantity.src_account_id();
338 2 : transfer_asset.dest_account_id =
339 2 : pb_subtract_asset_quantity.dest_account_id();
340 2 : transfer_asset.asset_id = pb_subtract_asset_quantity.asset_id();
341 2 : transfer_asset.description = pb_subtract_asset_quantity.description();
342 2 : transfer_asset.amount = pb_subtract_asset_quantity.amount();
343 2 : return transfer_asset;
344 2 : }
345 :
346 : // Append Role
347 : model::AppendRole PbCommandFactory::deserializeAppendRole(
348 : const protocol::AppendRole &command) {
349 2 : return AppendRole(command.account_id(), command.role_name());
350 : }
351 :
352 : protocol::AppendRole PbCommandFactory::serializeAppendRole(
353 : const model::AppendRole &command) {
354 2 : protocol::AppendRole cmd;
355 2 : cmd.set_account_id(command.account_id);
356 2 : cmd.set_role_name(command.role_name);
357 2 : return cmd;
358 2 : }
359 :
360 : // Append Role
361 : model::DetachRole PbCommandFactory::deserializeDetachRole(
362 : const protocol::DetachRole &command) {
363 2 : return DetachRole(command.account_id(), command.role_name());
364 : }
365 :
366 : protocol::DetachRole PbCommandFactory::serializeDetachRole(
367 : const model::DetachRole &command) {
368 2 : protocol::DetachRole cmd;
369 2 : cmd.set_account_id(command.account_id);
370 2 : cmd.set_role_name(command.role_name);
371 2 : return cmd;
372 2 : }
373 :
374 : // Create Role
375 : model::CreateRole PbCommandFactory::deserializeCreateRole(
376 : const protocol::CreateRole &command) {
377 44 : std::set<std::string> perms;
378 :
379 44 : std::for_each(command.permissions().begin(),
380 44 : command.permissions().end(),
381 : [&perms, this](auto perm) {
382 126 : auto it = this->pb_role_map_.left.find(
383 126 : static_cast<protocol::RolePermission>(perm));
384 126 : if (it != this->pb_role_map_.left.end()) {
385 126 : perms.insert(it->second);
386 126 : }
387 126 : });
388 44 : return CreateRole(command.role_name(), perms);
389 44 : }
390 :
391 : protocol::CreateRole PbCommandFactory::serializeCreateRole(
392 : const model::CreateRole &command) {
393 46 : protocol::CreateRole cmd;
394 46 : cmd.set_role_name(command.role_name);
395 46 : std::for_each(command.permissions.begin(),
396 46 : command.permissions.end(),
397 : [&cmd, this](auto perm) {
398 132 : auto perm_name = this->pb_role_map_.right.at(perm);
399 132 : cmd.add_permissions(perm_name);
400 132 : });
401 46 : return cmd;
402 46 : }
403 :
404 : // Grant Permission
405 : protocol::GrantPermission PbCommandFactory::serializeGrantPermission(
406 : const model::GrantPermission &command) {
407 2 : protocol::GrantPermission cmd;
408 2 : cmd.set_account_id(command.account_id);
409 2 : auto perm = pb_grant_map_.right.at(command.permission_name);
410 2 : cmd.set_permission(perm);
411 2 : return cmd;
412 2 : }
413 :
414 : model::GrantPermission PbCommandFactory::deserializeGrantPermission(
415 : const protocol::GrantPermission &command) {
416 2 : auto it = pb_grant_map_.left.find(command.permission());
417 2 : if (it == pb_grant_map_.left.end()) {
418 0 : return {};
419 : }
420 2 : return GrantPermission(command.account_id(), it->second);
421 2 : }
422 :
423 : protocol::RevokePermission PbCommandFactory::serializeRevokePermission(
424 : const model::RevokePermission &command) {
425 2 : protocol::RevokePermission cmd;
426 2 : cmd.set_account_id(command.account_id);
427 2 : auto permission = pb_grant_map_.right.at(command.permission_name);
428 2 : cmd.set_permission(permission);
429 2 : return cmd;
430 2 : }
431 :
432 : model::RevokePermission PbCommandFactory::deserializeRevokePermission(
433 : const protocol::RevokePermission &command) {
434 2 : auto it = pb_grant_map_.left.find(command.permission());
435 2 : if (it == pb_grant_map_.left.end()) {
436 0 : return {};
437 : }
438 2 : return RevokePermission(command.account_id(), it->second);
439 2 : }
440 :
441 : protocol::SetAccountDetail PbCommandFactory::serializeSetAccountDetail(
442 : const model::SetAccountDetail &command) {
443 2 : protocol::SetAccountDetail cmd;
444 2 : cmd.set_account_id(command.account_id);
445 2 : cmd.set_key(command.key);
446 2 : cmd.set_value(command.value);
447 2 : return cmd;
448 2 : }
449 :
450 : model::SetAccountDetail PbCommandFactory::deserializeSetAccountDetail(
451 : const protocol::SetAccountDetail &command) {
452 2 : model::SetAccountDetail setAccountDetail;
453 2 : setAccountDetail.account_id = command.account_id();
454 2 : setAccountDetail.key = command.key();
455 2 : setAccountDetail.value = command.value();
456 2 : return setAccountDetail;
457 2 : }
458 :
459 : protocol::Command PbCommandFactory::serializeAbstractCommand(
460 : const model::Command &command) {
461 43 : PbCommandFactory commandFactory;
462 43 : auto cmd = protocol::Command();
463 : // TODO 26/09/17 grimadas: refactor this #VARIANT
464 :
465 : // -----|CreateRole|-----
466 43 : if (instanceof <model::CreateRole>(command)) {
467 3 : auto serialized = commandFactory.serializeCreateRole(
468 3 : static_cast<const model::CreateRole &>(command));
469 3 : cmd.set_allocated_create_role(new protocol::CreateRole(serialized));
470 3 : }
471 :
472 : // -----|AppendRole|-----
473 43 : if (instanceof <model::AppendRole>(command)) {
474 1 : auto serialized = commandFactory.serializeAppendRole(
475 1 : static_cast<const model::AppendRole &>(command));
476 1 : cmd.set_allocated_append_role(new protocol::AppendRole(serialized));
477 1 : }
478 :
479 : // -----|DetachRole|-----
480 43 : if (instanceof <model::DetachRole>(command)) {
481 1 : auto serialized = commandFactory.serializeDetachRole(
482 1 : static_cast<const model::DetachRole &>(command));
483 1 : cmd.set_allocated_detach_role(new protocol::DetachRole(serialized));
484 1 : }
485 :
486 : // -----|GrantPermission|-----
487 43 : if (instanceof <model::GrantPermission>(command)) {
488 1 : auto serialized = commandFactory.serializeGrantPermission(
489 1 : static_cast<const model::GrantPermission &>(command));
490 1 : cmd.set_allocated_grant_permission(
491 1 : new protocol::GrantPermission(serialized));
492 1 : }
493 :
494 : // -----|RevokePermission|-----
495 43 : if (instanceof <model::RevokePermission>(command)) {
496 1 : auto serialized = commandFactory.serializeRevokePermission(
497 1 : static_cast<const model::RevokePermission &>(command));
498 1 : cmd.set_allocated_revoke_permission(
499 1 : new protocol::RevokePermission(serialized));
500 1 : }
501 :
502 : // -----|AddAssetQuantity|-----
503 43 : if (instanceof <model::AddAssetQuantity>(command)) {
504 3 : auto serialized = commandFactory.serializeAddAssetQuantity(
505 3 : static_cast<const model::AddAssetQuantity &>(command));
506 3 : cmd.set_allocated_add_asset_quantity(
507 3 : new protocol::AddAssetQuantity(serialized));
508 3 : }
509 :
510 : // -----|SubtractAssetQuantity|-----
511 43 : if (instanceof <model::SubtractAssetQuantity>(command)) {
512 3 : auto serialized = commandFactory.serializeSubtractAssetQuantity(
513 3 : static_cast<const model::SubtractAssetQuantity &>(command));
514 3 : cmd.set_allocated_subtract_asset_quantity(
515 3 : new protocol::SubtractAssetQuantity(serialized));
516 3 : }
517 :
518 : // -----|AddPeer|-----
519 43 : if (instanceof <model::AddPeer>(command)) {
520 3 : auto serialized = commandFactory.serializeAddPeer(
521 3 : static_cast<const model::AddPeer &>(command));
522 3 : cmd.set_allocated_add_peer(new protocol::AddPeer(serialized));
523 3 : }
524 :
525 : // -----|AddSignatory|-----
526 43 : if (instanceof <model::AddSignatory>(command)) {
527 4 : auto serialized = commandFactory.serializeAddSignatory(
528 4 : static_cast<const model::AddSignatory &>(command));
529 4 : cmd.set_allocated_add_signatory(
530 4 : new protocol::AddSignatory(serialized));
531 4 : }
532 :
533 : // -----|CreateAsset|-----
534 43 : if (instanceof <model::CreateAsset>(command)) {
535 6 : auto serialized = commandFactory.serializeCreateAsset(
536 6 : static_cast<const model::CreateAsset &>(command));
537 6 : cmd.set_allocated_create_asset(new protocol::CreateAsset(serialized));
538 6 : }
539 :
540 : // -----|CreateAccount|-----
541 43 : if (instanceof <model::CreateAccount>(command)) {
542 3 : auto serialized = commandFactory.serializeCreateAccount(
543 3 : static_cast<const model::CreateAccount &>(command));
544 3 : cmd.set_allocated_create_account(
545 3 : new protocol::CreateAccount(serialized));
546 3 : }
547 :
548 : // -----|SetAccountDetail|-----
549 43 : if (instanceof <model::SetAccountDetail>(command)) {
550 1 : auto serialized = commandFactory.serializeSetAccountDetail(
551 1 : static_cast<const model::SetAccountDetail &>(command));
552 1 : cmd.set_allocated_set_account_detail(
553 1 : new protocol::SetAccountDetail(serialized));
554 1 : }
555 :
556 : // -----|CreateDomain|-----
557 43 : if (instanceof <model::CreateDomain>(command)) {
558 6 : auto serialized = commandFactory.serializeCreateDomain(
559 6 : static_cast<const model::CreateDomain &>(command));
560 6 : cmd.set_allocated_create_domain(
561 6 : new protocol::CreateDomain(serialized));
562 6 : }
563 :
564 : // -----|RemoveSignatory|-----
565 43 : if (instanceof <model::RemoveSignatory>(command)) {
566 3 : auto serialized = commandFactory.serializeRemoveSignatory(
567 3 : static_cast<const model::RemoveSignatory &>(command));
568 3 : cmd.set_allocated_remove_signatory(
569 3 : new protocol::RemoveSignatory(serialized));
570 3 : }
571 :
572 : // -----|SetAccountQuorum|-----
573 43 : if (instanceof <model::SetQuorum>(command)) {
574 1 : auto serialized = commandFactory.serializeSetQuorum(
575 1 : static_cast<const model::SetQuorum &>(command));
576 1 : cmd.set_allocated_set_account_quorum(
577 1 : new protocol::SetAccountQuorum(serialized));
578 1 : }
579 :
580 : // -----|TransferAsset|-----
581 43 : if (instanceof <model::TransferAsset>(command)) {
582 3 : auto serialized = commandFactory.serializeTransferAsset(
583 3 : static_cast<const model::TransferAsset &>(command));
584 3 : cmd.set_allocated_transfer_asset(
585 3 : new protocol::TransferAsset(serialized));
586 3 : }
587 :
588 43 : return cmd;
589 43 : }
590 :
591 : std::shared_ptr<model::Command>
592 : PbCommandFactory::deserializeAbstractCommand(
593 : const protocol::Command &command) {
594 21 : PbCommandFactory commandFactory;
595 21 : std::shared_ptr<model::Command> val;
596 :
597 : // -----|CreateRole|-----
598 21 : if (command.has_create_role()) {
599 1 : auto pb_command = command.create_role();
600 1 : auto cmd = commandFactory.deserializeCreateRole(pb_command);
601 1 : val = std::make_shared<model::CreateRole>(cmd);
602 1 : }
603 :
604 : // -----|AppendRole|-----
605 21 : if (command.has_append_role()) {
606 1 : auto pb_command = command.append_role();
607 1 : auto cmd = commandFactory.deserializeAppendRole(pb_command);
608 1 : val = std::make_shared<model::AppendRole>(cmd);
609 1 : }
610 :
611 : // -----|DetachRole|-----
612 21 : if (command.has_detach_role()) {
613 1 : auto pb_command = command.detach_role();
614 1 : auto cmd = commandFactory.deserializeDetachRole(pb_command);
615 1 : val = std::make_shared<model::DetachRole>(cmd);
616 1 : }
617 :
618 : // -----|GrantPermission|-----
619 21 : if (command.has_grant_permission()) {
620 1 : auto pb_command = command.grant_permission();
621 1 : auto cmd = commandFactory.deserializeGrantPermission(pb_command);
622 1 : val = std::make_shared<model::GrantPermission>(cmd);
623 1 : }
624 :
625 : // -----|RevokePermission|-----
626 21 : if (command.has_revoke_permission()) {
627 1 : auto pb_command = command.revoke_permission();
628 1 : auto cmd = commandFactory.deserializeRevokePermission(pb_command);
629 1 : val = std::make_shared<model::RevokePermission>(cmd);
630 1 : }
631 :
632 : // -----|AddAssetQuantity|-----
633 21 : if (command.has_add_asset_quantity()) {
634 1 : auto pb_command = command.add_asset_quantity();
635 1 : auto cmd = commandFactory.deserializeAddAssetQuantity(pb_command);
636 1 : val = std::make_shared<model::AddAssetQuantity>(cmd);
637 1 : }
638 :
639 : // -----|SubtractAssetQuantity|-----
640 21 : if (command.has_subtract_asset_quantity()) {
641 1 : auto pb_command = command.subtract_asset_quantity();
642 : auto cmd =
643 1 : commandFactory.deserializeSubtractAssetQuantity(pb_command);
644 1 : val = std::make_shared<model::SubtractAssetQuantity>(cmd);
645 1 : }
646 :
647 : // -----|AddPeer|-----
648 21 : if (command.has_add_peer()) {
649 1 : auto pb_command = command.add_peer();
650 1 : auto cmd = commandFactory.deserializeAddPeer(pb_command);
651 1 : val = std::make_shared<model::AddPeer>(cmd);
652 1 : }
653 :
654 : // -----|AddSignatory|-----
655 21 : if (command.has_add_signatory()) {
656 2 : auto pb_command = command.add_signatory();
657 2 : auto cmd = commandFactory.deserializeAddSignatory(pb_command);
658 2 : val = std::make_shared<model::AddSignatory>(cmd);
659 2 : }
660 :
661 : // -----|CreateAsset|-----
662 21 : if (command.has_create_asset()) {
663 3 : auto pb_command = command.create_asset();
664 3 : auto cmd = commandFactory.deserializeCreateAsset(pb_command);
665 3 : val = std::make_shared<model::CreateAsset>(cmd);
666 3 : }
667 :
668 : // -----|CreateAccount|-----
669 21 : if (command.has_create_account()) {
670 1 : auto pb_command = command.create_account();
671 1 : auto cmd = commandFactory.deserializeCreateAccount(pb_command);
672 1 : val = std::make_shared<model::CreateAccount>(cmd);
673 1 : }
674 :
675 : // -----|SetAccountDetail|-----
676 21 : if (command.has_set_account_detail()) {
677 1 : auto pb_command = command.set_account_detail();
678 1 : auto cmd = commandFactory.deserializeSetAccountDetail(pb_command);
679 1 : val = std::make_shared<model::SetAccountDetail>(cmd);
680 1 : }
681 :
682 : // -----|CreateDomain|-----
683 21 : if (command.has_create_domain()) {
684 3 : auto pb_command = command.create_domain();
685 3 : auto cmd = commandFactory.deserializeCreateDomain(pb_command);
686 3 : val = std::make_shared<model::CreateDomain>(cmd);
687 3 : }
688 :
689 : // -----|RemoveSignatory|-----
690 21 : if (command.has_remove_signatory()) {
691 1 : auto pb_command = command.remove_signatory();
692 1 : auto cmd = commandFactory.deserializeRemoveSignatory(pb_command);
693 1 : val = std::make_shared<model::RemoveSignatory>(cmd);
694 1 : }
695 :
696 : // -----|SetAccountQuorum|-----
697 21 : if (command.has_set_account_quorum()) {
698 1 : auto pb_command = command.set_account_quorum();
699 1 : auto cmd = commandFactory.deserializeSetQuorum(pb_command);
700 1 : val = std::make_shared<model::SetQuorum>(cmd);
701 1 : }
702 :
703 : // -----|TransferAsset|-----
704 21 : if (command.has_transfer_asset()) {
705 1 : auto pb_command = command.transfer_asset();
706 1 : auto cmd = commandFactory.deserializeTransferAsset(pb_command);
707 1 : val = std::make_shared<model::TransferAsset>(cmd);
708 1 : }
709 :
710 21 : return val;
711 21 : }
712 :
713 : } // namespace converters
714 : } // namespace model
715 : } // namespace iroha
|
