public static CardManager GetManagerWithConstAccessTokenProvider(ConstAccessTokenProvider constAccessTokenProvider)
        {
            Func <RawSignedModel, Task <RawSignedModel> > signCallBackFunc = async(model) =>
            {
                var response = await EmulateServerResponseToSignByAppRequest(model.ExportAsString());

                return(RawSignedModelUtils.GenerateFromString(response));
            };

            var validator = new VirgilCardVerifier(new VirgilCardCrypto())
            {
                VerifySelfSignature = true, VerifyVirgilSignature = true
            };

            validator.ChangeServiceCreds(AppSettings.ServicePublicKeyDerBase64);
            var manager = new CardManager(new CardManagerParams()
            {
                CardCrypto          = CardCrypto,
                ApiUrl              = AppSettings.CardsServiceAddress,
                AccessTokenProvider = constAccessTokenProvider,
                SignCallBack        = signCallBackFunc,
                Verifier            = validator
            });

            return(manager);
        }
        /// <summary>
        /// Imports and verifies <see cref="Card"/> from BASE64 string.
        /// </summary>
        /// <param name="str">BASE64 string to get card from.</param>
        /// <returns>Imported and verified card.</returns>
        public Card ImportCardFromString(string str)
        {
            var rawSignedModel = RawSignedModelUtils.GenerateFromString(str);
            var card           = CardUtils.Parse(CardCrypto, rawSignedModel);

            this.ValidateCards(new[] { card });
            return(card);
        }
        public void GeneratePureModelFromString_Should_ReturnEquivalentModel()
        {
            //STC-1
            var model       = faker.PredefinedRawSignedModel();
            var exportedStr = model.ExportAsString();

            var importedModel = RawSignedModelUtils.GenerateFromString(exportedStr);

            Assert.IsTrue(importedModel.ContentSnapshot.SequenceEqual(model.ContentSnapshot));
            Assert.AreEqual(Configuration.Serializer.Serialize(importedModel.Signatures),
                            Configuration.Serializer.Serialize(model.Signatures));
        }
        private static Task <string> EmulateServerResponseToSignByAppRequest(string modelStr)
        {
            var serverResponse = Task <string> .Factory.StartNew(() =>
            {
                Thread.Sleep(1000); // simulation of long-term processing
                                    // var appPrivateKey = Crypto.ImportVirgilPrivateKey(
                                    //    Bytes.FromString(AccessPublicKeyId, StringEncoding.BASE64));
                var rawSignedModel = RawSignedModelUtils.GenerateFromString(modelStr);

                return(rawSignedModel.ExportAsString());
            });

            return(serverResponse);
        }
        public void GenerateFullModelFromString_Should_ReturnEquivalentModel()
        {
            //STC-2
            var model = faker.PredefinedRawSignedModel(
                "a666318071274adb738af3f67b8c7ec29d954de2cabfd71a942e6ea38e59fff9",
                true, true, true);

            var exportedStr   = model.ExportAsString();
            var importedModel = RawSignedModelUtils.GenerateFromString(exportedStr);

            Assert.IsTrue(importedModel.ContentSnapshot.SequenceEqual(model.ContentSnapshot));
            Assert.AreEqual(Configuration.Serializer.Serialize(importedModel.Signatures),
                            Configuration.Serializer.Serialize(model.Signatures));
        }