async public Task <HealthcareBC.Fabric.ContractTransaction> ChangeActiveState(string citizenIdentifier, string activeState)
        {
            var         FabricEndpoint = ServiceEndPointResolver.GetServiceEndPoint(ServiceEndpoints.fabricEndPoint, null);
            FabricProxy FabricProxy    = new FabricProxy(FabricEndpoint, new HttpClient()
            {
                Timeout = new TimeSpan(0, 30, 0)
            });

            var transaction = await FabricProxy.ChangeActiveStateAsync(citizenIdentifier, activeState);

            //Indexing Service
            await LogTransaction(transaction, $"Current Active State was changed into {activeState}");

            return(transaction);//await FabricProxy.ChangeActiveStateAsync(citizenIdentifier, activeState);
        }
        async public Task <HealthcareBC.Fabric.ContractTransaction> AssignHealthcarePlan(HealthcareBC.Fabric.HealthcarePlan healthcarePlan, string citizenIdentifier)
        {
            var         FabricEndpoint = ServiceEndPointResolver.GetServiceEndPoint(ServiceEndpoints.fabricEndPoint, null);
            FabricProxy FabricProxy    = new FabricProxy(FabricEndpoint, new HttpClient()
            {
                Timeout = new TimeSpan(0, 30, 0)
            });

            var transaction = await FabricProxy.AssignHealthcarePlanAsync(healthcarePlan, citizenIdentifier);

            //Indexing Service
            await LogTransaction(transaction, "Healthcare Plan was assigned and eligiility will be updated by Fabric logic after transaction");

            return(transaction);//await FabricProxy.AssignHealthcarePlanAsync(healthcarePlan, citizenIdentifier);
        }
        async public Task <HealthcareBC.Fabric.ContractTransaction> UpdateProfileWithProofDocument(HealthcareBC.Fabric.DocProof docProof, string citizenIdentifier)
        {
            var         FabricEndpoint = ServiceEndPointResolver.GetServiceEndPoint(ServiceEndpoints.fabricEndPoint, null);
            FabricProxy FabricProxy    = new FabricProxy(FabricEndpoint, new HttpClient()
            {
                Timeout = new TimeSpan(0, 30, 0)
            });

            var transaction = await FabricProxy.UpdateProfileAsync(citizenIdentifier, docProof);

            //Indexing Service
            await LogTransaction(transaction, "Citizen Proof Document was checked and updated on Profile");

            return(transaction);
        }
        async public Task <HealthcareBC.Fabric.ContractTransaction> ApproveHealthcarePlan(string citizenIdentifier)
        {
            var         FabricEndpoint = ServiceEndPointResolver.GetServiceEndPoint(ServiceEndpoints.fabricEndPoint, null);
            FabricProxy FabricProxy    = new FabricProxy(FabricEndpoint, new HttpClient()
            {
                Timeout = new TimeSpan(0, 30, 0)
            });

            var transaction = await FabricProxy.ApproveHealthcarePlanAsync(citizenIdentifier);

            //Indexing Service
            await LogTransaction(transaction, "Healthcare Plan was Approved");


            return(transaction);
        }
        async public Task <HealthcareBC.Fabric.ContractTransaction> GetCitizenProfile(string citizenIdentifier)
        {
            var         FabricEndpoint = ServiceEndPointResolver.GetServiceEndPoint(ServiceEndpoints.fabricEndPoint, null);
            FabricProxy FabricProxy    = new FabricProxy(FabricEndpoint, new HttpClient()
            {
                Timeout = new TimeSpan(0, 30, 0)
            });

            var retProfile = await FabricProxy.GetProfileInformationAsync(citizenIdentifier);

            //Decrypt basicProfile information
            //var decrypter = new Cryptolib("");
            //retProfile.BusinessContractDTO.BasicProfile.Name = decrypter.DecryptString(retProfile.BusinessContractDTO.BasicProfile.Name).Result;
            //retProfile.BusinessContractDTO.BasicProfile.Address.Street = decrypter.DecryptString(retProfile.BusinessContractDTO.BasicProfile.Address.Street).Result;
            //retProfile.BusinessContractDTO.BasicProfile.Address.City = decrypter.DecryptString(retProfile.BusinessContractDTO.BasicProfile.Address.City).Result;

            return(retProfile);
        }
        async public Task <HealthcareBC.Fabric.ContractTransaction> CreateCitizenProfile(HealthcareBC.Fabric.Profile citizenProfile)
        {
            var         FabricEndpoint = ServiceEndPointResolver.GetServiceEndPoint(ServiceEndpoints.fabricEndPoint, null);
            FabricProxy FabricProxy    = new FabricProxy(FabricEndpoint, new HttpClient()
            {
                Timeout = new TimeSpan(0, 30, 0)
            });

            //TODO : Add the Encryption after the Demo / Decrypting the results / Add the decryption to Lists

            //Encrypt basicProfile information
            //var encrypter = new Cryptolib("");
            //citizenProfile.BasicProfile.Name = encrypter.EncryptString(citizenProfile.BasicProfile.Name).Result;
            //citizenProfile.BasicProfile.Address.Street = encrypter.EncryptString(citizenProfile.BasicProfile.Address.Street).Result;
            //citizenProfile.BasicProfile.Address.City = encrypter.EncryptString(citizenProfile.BasicProfile.Address.City).Result;

            var transaction = await FabricProxy.CreateProfileAsync(citizenProfile);

            //Indexing Service
            await LogTransaction(transaction, "Citizen Profile was created");

            return(transaction);
        }