Exemplo n.º 1
0
        public List <RecoveryPointBase> ListRecoveryPoints(Dictionary <Enum, object> ProviderData)
        {
            string   vaultName             = (string)ProviderData[VaultParams.VaultName];
            string   resourceGroupName     = (string)ProviderData[VaultParams.ResourceGroupName];
            DateTime startDate             = (DateTime)(ProviderData[RecoveryPointParams.StartDate]);
            DateTime endDate               = (DateTime)(ProviderData[RecoveryPointParams.EndDate]);
            string   restorePointQueryType = ProviderData.ContainsKey(RecoveryPointParams.RestorePointQueryType) ?
                                             (string)ProviderData[RecoveryPointParams.RestorePointQueryType] : "All";
            bool secondaryRegion         = (bool)ProviderData[CRRParams.UseSecondaryRegion];
            RecoveryPointTier targetTier = (RecoveryPointTier)ProviderData[RecoveryPointParams.TargetTier];
            bool isReadyForMove          = (bool)ProviderData[RecoveryPointParams.IsReadyForMove];
            RecoveryPointTier tier       = (RecoveryPointTier)ProviderData[RecoveryPointParams.Tier];

            ItemBase item = ProviderData[RecoveryPointParams.Item] as ItemBase;

            Dictionary <UriEnums, string> uriDict = HelperUtils.ParseUri(item.Id);
            string containerUri      = HelperUtils.GetContainerUri(uriDict, item.Id);
            string protectedItemName = HelperUtils.GetProtectedItemUri(uriDict, item.Id);

            //we need to fetch the list of RPs
            var queryFilterString = "null";

            if (string.Compare(restorePointQueryType, "All") == 0)
            {
                queryFilterString = QueryBuilder.Instance.GetQueryString(new BMSRPQueryObject()
                {
                    StartDate = startDate,
                    EndDate   = endDate,
                });
            }
            else
            {
                queryFilterString = QueryBuilder.Instance.GetQueryString(new BMSRPQueryObject()
                {
                    StartDate             = startDate,
                    EndDate               = endDate,
                    RestorePointQueryType = restorePointQueryType,
                    ExtendedInfo          = true
                });
            }

            List <RecoveryPointBase> recoveryPointList;

            if (secondaryRegion)
            {
                ODataQuery <CrrModel.BMSRPQueryObject> queryFilter = new ODataQuery <CrrModel.BMSRPQueryObject>();
                queryFilter.Filter = queryFilterString;

                //fetch recovery points from secondary region
                List <CrrModel.RecoveryPointResource> rpListResponseCrr;
                rpListResponseCrr = ServiceClientAdapter.GetRecoveryPointsFromSecondaryRegion(
                    containerUri,
                    protectedItemName,
                    queryFilter,
                    vaultName: vaultName,
                    resourceGroupName: resourceGroupName);

                recoveryPointList = RecoveryPointConversions.GetPSAzureRecoveryPointsForSecondaryRegion(rpListResponseCrr, item);
            }
            else
            {
                ODataQuery <BMSRPQueryObject> queryFilter = new ODataQuery <BMSRPQueryObject>();
                queryFilter.Filter = queryFilterString;

                List <RecoveryPointResource> rpListResponse;
                rpListResponse = ServiceClientAdapter.GetRecoveryPoints(
                    containerUri,
                    protectedItemName,
                    queryFilter,
                    vaultName: vaultName,
                    resourceGroupName: resourceGroupName);

                recoveryPointList = RecoveryPointConversions.GetPSAzureRecoveryPoints(rpListResponse, item);
            }

            //filter out archived recovery points for secondary region
            if (secondaryRegion)
            {
                recoveryPointList = recoveryPointList.Where(
                    recoveryPoint =>
                {
                    if (recoveryPoint.GetType() == typeof(AzureVmRecoveryPoint))
                    {
                        return(((AzureVmRecoveryPoint)recoveryPoint).RecoveryPointTier != RecoveryPointTier.VaultArchive);
                    }

                    if (recoveryPoint.GetType() == typeof(CmdletModel.AzureWorkloadRecoveryPoint))
                    {
                        return(((CmdletModel.AzureWorkloadRecoveryPoint)recoveryPoint).RecoveryPointTier != RecoveryPointTier.VaultArchive);
                    }

                    return(false);
                }).ToList();
            }

            // filter move readness based on target tier
            recoveryPointList = RecoveryPointConversions.CheckRPMoveReadiness(recoveryPointList, targetTier, isReadyForMove);

            //filter RPs based on tier
            return(RecoveryPointConversions.FilterRPsBasedOnTier(recoveryPointList, tier));
        }