private bool ProcessMessageFromDevice(
            GetMessages.ResponseParamsMessage messageItem, DeviceToDeviceMessages.Envelope deviceMessage)
        {
            switch (deviceMessage.Type)
            {
            case DeviceToDeviceMessages.Types.NewSecret:
                return(ProcessMessageNewSecretShare(deviceMessage.Message));

            case DeviceToDeviceMessages.Types.RequestEntrySecrets:
                return(ProcessMessageRequestEntrySecrets(messageItem, deviceMessage.Message));

            case DeviceToDeviceMessages.Types.DeleteSecret:
                return(ProcessMessageDeleteSecret(deviceMessage.Message));

            default:
                return(false);
            }
        }
        private bool ProcessMessageRequestEntrySecrets(
            GetMessages.ResponseParamsMessage messageItem, DeviceToDeviceMessages.IMessage message)
        {
            var messageContents = (DeviceToDeviceMessages.RequestEntrySecrets)message;

            var accountSettings = _model.ServerAccountSettings.Query().First();

            var entry = _model.Entries.Query().FirstOrDefault(r => r.Identifier == messageContents.EntryIdentifier);

            if (entry == null)
            {
                return(false);
            }

            var linkedDeviceCryptoKeyId = accountSettings.LinkedDeviceCryptoKeyId;
            var linkedDeviceCryptoKey   = _model.CryptoKeys.Query().First(r => r.Id == linkedDeviceCryptoKeyId);

            var entrySecrets = new Dictionary <string, string>();

            foreach (var secretIdentifier in messageContents.SecretIdentifiers)
            {
                var entrySecretsResult = _model.EntriesSharedSecrets.Query()
                                         .FirstOrDefault(r => r.EntryId == entry.Id && r.SecretIdentifier == secretIdentifier);

                if (entrySecretsResult == null)
                {
                    continue;
                }

                var entrySecretData = _model.EntriesSharedSecretsData.Query().First(r => r.Id == entrySecretsResult.EntrySecretDataId);
                entrySecrets.Add(entrySecretsResult.SecretIdentifier, entrySecretData.Secret);
            }

            if (entrySecrets.Count != messageContents.SecretIdentifiers.Count)
            {
                // We don't appear to have all the requested secrets.
                return(false);
            }

            var requestConfirmed = _controller.PromptSecretShareRequestSafe();

            var apiRequest = new SendLinkedDeviceMessage
            {
                //LinkIdentifier = link.Identifier,
                SecondsValidFor = 30
            };

            if (!requestConfirmed)
            {
                var deniedMessage = new DeviceToDeviceMessages.SendEntrySecrets
                {
                    OriginalMessageIdentifier = messageItem.Identifier,
                    RequestAccepted           = false
                };
                apiRequest.SetMessage(deniedMessage, linkedDeviceCryptoKey.PublicKeyPem);
                apiRequest.GetResponse(GetApiClient());
                return(true);
            }

            var acceptedMessage = new DeviceToDeviceMessages.SendEntrySecrets
            {
                OriginalMessageIdentifier = messageItem.Identifier,
                RequestAccepted           = true,
                Secrets = entrySecrets
            };

            apiRequest.SetMessage(acceptedMessage, linkedDeviceCryptoKey.PublicKeyPem);
            apiRequest.GetResponse(GetApiClient());

            return(true);
        }