private void DeleteProductHeaderAndChildren(Snapshot_LicenseProduct licenseProduct)
        {
            if (licenseProduct.ProductHeaderId != null)
            {
                var id = (int)licenseProduct.ProductHeaderId;

                var productHeader =
                    _snapshotProductHeaderRepository.GetProductHeaderByProductHeaderId(
                        id);

                if (productHeader != null)
                {
                    //Delete artist
                    var artist =
                        _snapshotArtistRecsRepository.GetSnapshotArtistRecsByArtistId(productHeader.ArtistRecsId);
                    if (artist != null)
                    {
                        _snapshotArtistRecsRepository.DeleteRecsArtisByArtistSnapshotId(
                            artist.SnapshotArtistRecsId);
                    }
                    //Delete label and child (label group)
                    DeleteLabelAndAllChuldren(productHeader);

                    //Delete RecsConfigurations 'Configurations'
                    DeleteAllRecsConfigAndChildrenForProductHeader(productHeader);

                    _snapshotProductHeaderRepository.DeleteProductHeaderSnapshotBySnapshotId(
                        productHeader.SnapshotProductHeaderId);
                }
            }
        }
Beispiel #2
0
 public Snapshot_LicenseProduct SaveMassiveSnapshotLicenseProduct(Snapshot_LicenseProduct licenseProductSnapshot)
 {
     using (var context = new DataContext())
     {
         context.Snapshot_LicenseProducts.Add(licenseProductSnapshot);
         try
         {
             context.SaveChanges();
         }
         catch (Exception e)
         {
             Logger.Debug(e.ToString());
             throw new Exception(e.ToString());
         }
         return(licenseProductSnapshot);
     }
 }
        private Snapshot_LicenseProduct CastToLicenseProductSnapshot(LicenseProduct licenseProduct)
        {
            var snapshot = new Snapshot_LicenseProduct();

            snapshot.CloneLicenseProductId = licenseProduct.LicenseProductId;
            snapshot.LicenseId             = licenseProduct.LicenseId;
            if (licenseProduct.ProductHeader != null)
            {
                snapshot.ProductHeaderId = (int)licenseProduct.ProductHeader.Id;
            }
            snapshot.ProductHeader            = CastToProductHeaderSnapshot(licenseProduct.ProductHeader, licenseProduct.LicenseProductId);
            snapshot.ScheduleId               = licenseProduct.ScheduleId;
            snapshot.ProductId                = licenseProduct.ProductId;
            snapshot.LicensePRecordingsNo     = licenseProduct.LicensePRecordingsNo;
            snapshot.LicenseClaimException    = licenseProduct.LicenseClaimException;
            snapshot.TotalLicenseConfigAmount = (int)licenseProduct.TotalLicenseConfigAmount;
            snapshot.title             = licenseProduct.title;
            snapshot.PaidQuarter       = licenseProduct.PaidQuarter;
            snapshot.RelatedLicensesNo = licenseProduct.RelatedLicensesNo;

            /*
             * if (licenseProduct.ProductConfigurations != null)
             * {
             *  snapshot.ProductConfigurations = CastToRecsConfigurationsSnapshot(licenseProduct.ProductConfigurations,
             *      (int)snapshot.ProductHeaderId);
             * }
             */
            snapshot.CreatedDate  = licenseProduct.CreatedDate;
            snapshot.CreatedBy    = licenseProduct.CreatedBy;
            snapshot.ModifiedDate = licenseProduct.ModifiedDate;
            snapshot.ModifiedBy   = licenseProduct.ModifiedBy;
            snapshot.Deleted      = licenseProduct.Deleted;
            if (licenseProduct.Recordings != null)
            {
                snapshot.Recordings = CastToSnapshotRecordings(licenseProduct.Recordings, licenseProduct.ProductId,
                                                               licenseProduct.LicenseProductId);
            }
            return(snapshot);
        }
        private void DeleteSnapshotRecsRecordingandChildren(Snapshot_LicenseProduct licenseProduct)
        {
            var licenseConfigurations =
                _snapshotRecsConfigurationRepository.GetAllRecsConfigurationsRecordingsForLicenseProductId(licenseProduct.CloneLicenseProductId);

            if (licenseConfigurations != null)
            {
                //Delete all children
                foreach (var licenseConfig in licenseConfigurations)
                {
                    //Delete Config
                    _snapshotConfigurationRepository.DeleteConfigurationSnapshot(licenseConfig.SnapshotConfigurationId);
                }

                var ids = licenseConfigurations.Select(_ => _.SnapshotRecsConfigurationId).ToList();
                foreach (var id in ids)
                {
                    //delete recConfig
                    _snapshotRecsConfigurationRepository.DeleteWorkRecordingByRecordignSnapshotId(
                        id);
                }
            }
        }
        public Snapshot_LicenseProduct SaveSnapshotLicenseProduct(Snapshot_LicenseProduct snapshotLicenseProduct)
        {
            var worksRecordings   = snapshotLicenseProduct.Recordings;
            var recsConfiguratons = snapshotLicenseProduct.ProductConfigurations;
            var productHeader     = snapshotLicenseProduct.ProductHeader;

            snapshotLicenseProduct.ProductHeader         = null;
            snapshotLicenseProduct.Recordings            = null;
            snapshotLicenseProduct.ProductConfigurations = null;  //not used

            //Save productHeader
            if (productHeader != null)
            {
                Logger.Info("ArtistRecsId: " + productHeader.ArtistRecsId);

                //save artist
                var artist = productHeader.Artist;
                productHeader.Artist = null;

                //save label
                if (productHeader.Label != null)
                {
                    var label = productHeader.Label;
                    productHeader.Label = null;
                    var savedLabelOnProductHeader = _snapshotLabelRepository.SaveSnapshotLabel(label);
                    productHeader.SnapshotLabelId = savedLabelOnProductHeader.SnapshotLabelId;

                    if (label.RecordLabelGroups != null)
                    {
                        var labelGroups = label.RecordLabelGroups;
                        label.RecordLabelGroups = null;
                        foreach (var labelGroup in labelGroups)
                        {
                            //save labelGroup
                            labelGroup.SnapshotLabelId = savedLabelOnProductHeader.SnapshotLabelId;
                            _snapshotLabelGroupRepository.SaveSnapshotLabelGroup(labelGroup);
                        }
                    }
                }
                var recsConfig = productHeader.Configurations;
                productHeader.Configurations = null;

                var savedArtistOnProductHeader = _snapshotArtistRecsRepository.SaveSnapshotArtistRecs(artist);
                productHeader.SnapshotArtistRecsId = savedArtistOnProductHeader.SnapshotArtistRecsId;



                //Finally.. save productHEader
                var savedProductHeader = _snapshotProductHeaderRepository.SaveSnapshotProductHeader(productHeader);
                snapshotLicenseProduct.SnapshotProductHeaderId = savedProductHeader.SnapshotProductHeaderId;

                if (recsConfig != null)
                {
                    foreach (var config in recsConfig)
                    {
                        //save children
                        var configuration = config.Configuration;
                        config.Configuration = null;

                        //Assign FK to recsConfig
                        config.SnapshotProductHeaderId = savedProductHeader.SnapshotProductHeaderId;

                        if (configuration != null)
                        {
                            var savedConfigOnRecsConfig = _snapshotConfigurationRepository.SaveSnapshotConfiguration(configuration);
                            config.SnapshotConfigurationId = savedConfigOnRecsConfig.SnapshotConfigId;
                        }
                        //save parent
                        var savedRecsConfigOnProductHeader = _snapshotRecsConfigurationRepository.SaveSnapshotRecsConfiguration(config);
                    }
                }
            }

            var savedLicenseProduct =
                _snapshotLicenseProductRepository.SaveSnapshotLicenseProduct(snapshotLicenseProduct);

            //Save works recordings
            if (worksRecordings != null)
            {
                foreach (var workRec in worksRecordings)
                {
                    if (workRec != null)
                    {
                        //assign FK
                        workRec.SnapshotLicenseProductId = savedLicenseProduct.SnapshotLicenseProductId;

                        //save track
                        var track = workRec.Track;
                        workRec.Track = null;

                        //set lpr to null (lpr is mechs item)
                        workRec.LicenseRecording = null;
                        //save writer list
                        var writerList = workRec.Writers;
                        workRec.Writers = null;

                        if (track != null)
                        {
                            //Get all track children and set to null
                            var copyRights = track.Copyrights;
                            track.Copyrights = null;

                            var artist = track.Artist;
                            track.Artist = null;

                            //track.SnapshotWorksRecordingId = savedWorksRecording.SnapshotWorksRecodingId;
                            if (artist != null)
                            {
                                var savedArtistOnTrack = _snapshotArtistRecsRepository.SaveSnapshotArtistRecs(artist);
                                track.SnapshotArtistRecsId = savedArtistOnTrack.SnapshotArtistRecsId;
                            }
                            var savedTrack = _snapshotWorkTrackRepository.SaveWorksTrack(track);

                            workRec.SnapshotWorkTrackId = savedTrack.SnapshotWorkTrackId;
                            //save artist

                            foreach (var copyRight in copyRights)
                            {
                                //get, and set children to null
                                var copyRightComposers = copyRight.Composers;
                                copyRight.Composers = null;

                                var copyRightSamples = copyRight.Samples;
                                copyRight.Samples = null;

                                var copyRightLocalClients = copyRight.LocalClients;
                                copyRight.LocalClients = null;

                                var copyRightLocationCodes = copyRight.AquisitionLocationCodes;
                                copyRight.AquisitionLocationCodes = null;

                                copyRight.SnapshotWorkTrackId = savedTrack.SnapshotWorkTrackId;

                                //save copyright, get PK.
                                var savedRecsCopyright = _snapshotRecsCopyrightRespository.SaveSnapshotWorksRecording(copyRight);

                                if (copyRightLocationCodes != null)
                                {
                                    foreach (var copyRightLocationCode in copyRightLocationCodes)
                                    {
                                        copyRightLocationCode.SnapshotRecsCopyrightId =
                                            savedRecsCopyright.SnapshotRecsCopyrightsId;

                                        _aquisitionLocationCodeRepository.SaveAquisitionLocationCode(
                                            copyRightLocationCode);
                                    }
                                }

                                if (copyRightLocalClients != null)
                                {
                                    foreach (var copyRightLocalClient in copyRightLocalClients)
                                    {
                                        copyRightLocalClient.SnapshotRecsCopyrightId =
                                            savedRecsCopyright.SnapshotRecsCopyrightsId;

                                        _snapshotLocalClientCopyrightRepository.SaveLocalClientCopyright(
                                            copyRightLocalClient);
                                    }
                                }

                                if (copyRightSamples != null)
                                {
                                    foreach (var copyRightSample in copyRightSamples)
                                    {
                                        var localClientSamples = copyRightSample.LocalClients;
                                        copyRightSample.LocalClients = null;

                                        var localAquisitionLocaitonCodes = copyRightSample.AquisitionLocationCodes;
                                        copyRightSample.AquisitionLocationCodes = null;

                                        //assign fk
                                        copyRightSample.SnapshotRecsCopyrightId =
                                            savedRecsCopyright.SnapshotRecsCopyrightsId;

                                        //save
                                        var savedSample = _snapshotSampleRepository.SaveSampleSnapshot(copyRightSample);

                                        if (localAquisitionLocaitonCodes != null)
                                        {
                                            foreach (var localAquisitionLocaitonCode in localAquisitionLocaitonCodes)
                                            {
                                                localAquisitionLocaitonCode.SnapshotSampleId =
                                                    savedSample.SnapshotSampleId;

                                                _snapshotSampleAquisitionLocationCodeRepository
                                                .SaveSampleAquisitionLocationCode(localAquisitionLocaitonCode);
                                            }
                                        }

                                        if (localClientSamples != null)
                                        {
                                            foreach (var localClientSample in localClientSamples)
                                            {
                                                localClientSample.SnapshotSampleId = savedSample.SnapshotSampleId;

                                                _snapshotSampleLocalClientCopyrightRepository
                                                .SaveSampleLocalClientCopyright(localClientSample);
                                            }
                                        }
                                    }
                                }

                                //create new entities, save them.
                                if (copyRightComposers != null)
                                {
                                    foreach (var copyRightComposer in copyRightComposers)
                                    {
                                        //done
                                        var composerAffiliations = copyRightComposer.Affiliation;
                                        copyRightComposer.Affiliation = null;

                                        //done
                                        var composerKnownAs = copyRightComposer.KnownAs;
                                        copyRightComposer.KnownAs = null;

                                        var composerOriginalPublishers = copyRightComposer.OriginalPublishers;
                                        copyRightComposer.OriginalPublishers = null;

                                        copyRightComposer.SnapshotRecsCopyrightId =
                                            savedRecsCopyright.SnapshotRecsCopyrightsId;

                                        //save composer, get pk
                                        var savedComposer = _snapshotComposerRepository.SaveComposerSnapshot(copyRightComposer);

                                        if (composerOriginalPublishers != null)
                                        {
                                            foreach (var composerOriginalPublisher in composerOriginalPublishers)
                                            {
                                                //done
                                                var composerOriginalPublisherKnownAs = composerOriginalPublisher.KnownAs;
                                                composerOriginalPublisher.KnownAs = null;

                                                //done
                                                var composerOriginalPublisherAffiliations =
                                                    composerOriginalPublisher.Affiliation;
                                                composerOriginalPublisher.Affiliation = null;

                                                var composerOriginalPubliserAdmins =
                                                    composerOriginalPublisher.Administrator;
                                                composerOriginalPublisher.Administrator = null;

                                                //assign fk
                                                composerOriginalPublisher.SnapshotComposerId =
                                                    savedComposer.SnapshotComposerId;

                                                //save
                                                var savedComposerOriginalPublisher = _composerOriginalPublisherRepository.SaveComposerOriginalPublisher(
                                                    composerOriginalPublisher);

                                                if (composerOriginalPublisherKnownAs != null)
                                                {
                                                    foreach (var known in composerOriginalPublisherKnownAs)
                                                    {
                                                        known.SnapshotComposerOriginalPublisherId =
                                                            savedComposerOriginalPublisher
                                                            .SnapshotComposerOriginalPublisherId;

                                                        _composerOriginalPublisherKnownAsRepository
                                                        .SaveComposerOriginalPublisherKnownAs(known);
                                                    }
                                                }

                                                if (composerOriginalPublisherAffiliations != null)
                                                {
                                                    foreach (var composerOriginalPublisherAffiliation in composerOriginalPublisherAffiliations)
                                                    {
                                                        var composerOpAffiliationBases =
                                                            composerOriginalPublisherAffiliation.Affiliations;
                                                        composerOriginalPublisherAffiliation.Affiliations = null;

                                                        composerOriginalPublisherAffiliation
                                                        .SnapshotComposerOriginalPublisherId =
                                                            savedComposerOriginalPublisher
                                                            .SnapshotComposerOriginalPublisherId;

                                                        var savedComposerOriginalPublisherAffiliation = _composerOriginalPublisherAffiliationRepository
                                                                                                        .SaveComposerOriginalPublisherAffiliation(
                                                            composerOriginalPublisherAffiliation);

                                                        if (composerOpAffiliationBases != null)
                                                        {
                                                            foreach (var composerOpAffiliationBase in composerOpAffiliationBases)
                                                            {
                                                                composerOpAffiliationBase
                                                                .SnapshotComposerOriginalPublisherAffiliationId =
                                                                    savedComposerOriginalPublisherAffiliation
                                                                    .SnapshotComposerOriginalPublisherAffiliationId;

                                                                _composerOriginalPublisherAffiliationBaseRepository
                                                                .SaveComposerOriginalPublisherAffiliationBase(
                                                                    composerOpAffiliationBase);
                                                            }
                                                        }
                                                    }
                                                }

                                                if (composerOriginalPubliserAdmins != null)
                                                {
                                                    foreach (var composerOriginalPubliserAdmin in composerOriginalPubliserAdmins)
                                                    {
                                                        var composerOpAdminAffiliations =
                                                            composerOriginalPubliserAdmin.Affiliation;
                                                        composerOriginalPubliserAdmin.Affiliation = null;

                                                        var composerOpadminKnownAs =
                                                            composerOriginalPubliserAdmin.KnownAs;
                                                        composerOriginalPubliserAdmin.KnownAs = null;

                                                        //add fk
                                                        composerOriginalPubliserAdmin
                                                        .SnapshotComposerOriginalPublisherId =
                                                            savedComposerOriginalPublisher
                                                            .SnapshotComposerOriginalPublisherId;

                                                        var savedComposerOPadmin = _composerOriginalPublisherAdministratorRepository
                                                                                   .SaveComposerOriginalPublisherAdministrator(
                                                            composerOriginalPubliserAdmin);

                                                        if (composerOpAdminAffiliations != null)
                                                        {
                                                            foreach (var composerOpAdminAffiliation in composerOpAdminAffiliations)
                                                            {
                                                                var affiliationBases =
                                                                    composerOpAdminAffiliation.Affiliations;
                                                                composerOpAdminAffiliation.Affiliations = null;

                                                                composerOpAdminAffiliation
                                                                .SnapshotComposerOriginalPublisherAdministratorId =
                                                                    savedComposerOPadmin
                                                                    .SnapshotComposerOriginalPublisherAdministratorId;

                                                                var savedComposerOPAdminAffiliation = _composerOriginalPublisherAdminAffiliation
                                                                                                      .SaveComposerOriginalPublisherAdminAffiliation(
                                                                    composerOpAdminAffiliation);

                                                                if (affiliationBases != null)
                                                                {
                                                                    foreach (var affiliationBase in affiliationBases)
                                                                    {
                                                                        //assign FK
                                                                        affiliationBase
                                                                        .SnapshotComposerOriginalPublisherAdminAffiliationId
                                                                            =
                                                                                savedComposerOPAdminAffiliation
                                                                                .SnapshotComposerOriginalPublisherAdminAffiliationId;

                                                                        //save
                                                                        _composerOriginalPublisherAdminAffiliationBaseRepository
                                                                        .SaveComposerOriginalPublisherAdminAffiliationBase
                                                                            (affiliationBase);
                                                                    }
                                                                }
                                                            }
                                                        }

                                                        if (composerOpadminKnownAs != null)
                                                        {
                                                            foreach (var known in composerOpadminKnownAs)
                                                            {
                                                                //assign fk
                                                                known.SnapshotComposerOriginalPublisherAdministratorId =
                                                                    savedComposerOPadmin
                                                                    .SnapshotComposerOriginalPublisherAdministratorId;

                                                                //save
                                                                _composerOriginalPublisherAdminKnownAsRepository
                                                                .SaveSnapshotComposerOriginalPublisherAdminKnownAs(
                                                                    known);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }

                                        if (composerKnownAs != null)
                                        {
                                            foreach (var knwon in composerKnownAs)
                                            {
                                                //assign fk
                                                knwon.SnapshotComposerId = savedComposer.SnapshotComposerId;

                                                //save known
                                                _composerKnownAsRepository.SaveComposerKnownAs(knwon);
                                            }
                                        }

                                        if (composerAffiliations != null)
                                        {
                                            foreach (var composerAffiliation in composerAffiliations)
                                            {
                                                var composerAffiliationBases = composerAffiliation.Affiliations;
                                                composerAffiliation.Affiliations = null;

                                                //assign fk to composerAffiliation
                                                composerAffiliation.SnapshotComposerId =
                                                    savedComposer.SnapshotComposerId;

                                                //save composer affilliation and get PK
                                                var savedComposedAffiliation =
                                                    _composerAffiliationRepository.SaveComposerAffiliationSnapshot(
                                                        composerAffiliation);

                                                foreach (var composerAffiliationBase in composerAffiliationBases)
                                                {
                                                    //assign fk
                                                    composerAffiliationBase.SnapshotComposerAffiliationId =
                                                        savedComposedAffiliation.SnapshotComposerAffiliationId;
                                                    //save
                                                    _composerAffiliationBaseRepository
                                                    .SaveComposerAffiliatioBasenSnapshot(composerAffiliationBase);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        var savedWorksRecording = _snapshotWorksRecordingRepository.SaveSnapshotWorksRecording(workRec);
                        if (writerList != null)
                        {
                            foreach (var writer in writerList)
                            {
                                var affiliations = writer.Affiliation;
                                writer.Affiliation = null;

                                var knownAs = writer.KnownAs;
                                writer.KnownAs = null;

                                var originalPubs = writer.OriginalPublishers;
                                writer.OriginalPublishers = null;

                                //Set Foriegn Key
                                writer.CloneWorksTrackId        = track.CloneWorksTrackId;
                                writer.SnapshotWorksRecordingId = savedWorksRecording.SnapshotWorksRecodingId;
                                //save writer, get key
                                var saveWorksWriter = _snapshotWorksWriterRepository.SaveWorksWriter(writer);
                                //save writer affiliation

                                if (affiliations != null)
                                {
                                    foreach (var affilation in affiliations)
                                    {
                                        var affiliationBases = affilation.Affiliations;
                                        affilation.Affiliations = null;

                                        affilation.SnapshotWorksWriterId = saveWorksWriter.SnapshotWorksWriterId;
                                        var savedAffiliation = _snapshotAffiliationRepository.SaveSnapshotAffiliation(affilation);

                                        if (affiliationBases != null)
                                        {
                                            foreach (var affiliationBase in affiliationBases)
                                            {
                                                affiliationBase.SnapshotAffiliationId =
                                                    savedAffiliation.SnapshotAffiliationId;

                                                _affiliationBaseRepository.SaveSnapshotAffiliationBase(affiliationBase);
                                            }
                                        }
                                    }
                                }
                                //save writer knownAs

                                if (knownAs != null)
                                {
                                    foreach (var knwn in knownAs)
                                    {
                                        _snapshotKnownAsRepository.SaveKnownAs(knwn);
                                    }
                                }

                                if (originalPubs != null)
                                {
                                    //save original pub
                                    //save knownAs (not implemented)
                                    foreach (var oPub in originalPubs)
                                    {
                                        oPub.SnapshotWorksWriterId = saveWorksWriter.SnapshotWorksWriterId;
                                        var administrators = oPub.Administrator;
                                        oPub.Administrator = null;

                                        var opKnownAs = oPub.KnownAs;
                                        oPub.KnownAs = null;

                                        var opAffiliations = oPub.Affiliation;
                                        oPub.Affiliation = null;

                                        var savedSnapshotOriginalPublisher =
                                            _snapshotOriginalPublisherRepository.SaveSnapshotOriginalPublisher(oPub);

                                        if (opKnownAs != null)
                                        {
                                            foreach (var knwn in opKnownAs)
                                            {
                                                _snapshotKnownAsRepository.SaveKnownAs(knwn);
                                            }
                                        }

                                        if (opAffiliations != null)
                                        {
                                            foreach (var opAffiliation in opAffiliations)
                                            {
                                                var affiliationBases = opAffiliation.Affiliations;
                                                opAffiliation.Affiliations = null;

                                                //assign fk
                                                opAffiliation.SnapshotOriginalPublisherId =
                                                    savedSnapshotOriginalPublisher.SnapshotOriginalPublisherId;

                                                //save
                                                var savedOriginalPubAffiliation =
                                                    _originalPublisherAffiliationRepository
                                                    .SaveSnapshotOriginalPublisherAffiliation(opAffiliation);

                                                if (affiliationBases != null)
                                                {
                                                    foreach (var affiliationBase in affiliationBases)
                                                    {
                                                        //Assign foriegn key
                                                        affiliationBase.SnapshotOriginalPublisherAffiliationId =
                                                            savedOriginalPubAffiliation
                                                            .SnapshotOriginalPublisherAffiliationId;

                                                        //save
                                                        _originalPubAffiliationBaseRepository
                                                        .SaveSnapshotAdminAffiliation(affiliationBase);
                                                    }
                                                }
                                            }
                                        }

                                        if (administrators != null)
                                        {
                                            foreach (var admin in administrators)
                                            {
                                                var adminKnownAs = admin.KnownAs;
                                                admin.KnownAs = null;

                                                var adminAffiliations = admin.Affiliation;
                                                admin.Affiliation = null;

                                                //Assign foriegn Key
                                                admin.SnapshotOriginalPublisherId =
                                                    savedSnapshotOriginalPublisher.SnapshotOriginalPublisherId;

                                                var snapshotAdmin =
                                                    _snapshotAdministratorRepository.SaveSnapshotAdministrator(admin);
                                                if (adminKnownAs != null)
                                                {
                                                    foreach (var knwn in adminKnownAs)
                                                    {
                                                        knwn.SnapshotAdministratorId =
                                                            snapshotAdmin.SnapshotAdministratorId;
                                                        _adminKnownAsRepository.SaveSnapshotAdminKnownAs(knwn);
                                                    }
                                                }

                                                if (adminAffiliations != null)
                                                {
                                                    foreach (var adminAffiliation in adminAffiliations)
                                                    {
                                                        var adminAffiliationBases = adminAffiliation.Affiliations;
                                                        adminAffiliation.Affiliations = null;

                                                        //Assign Foriegn Key
                                                        adminAffiliation.SnapshotAdministratorId =
                                                            snapshotAdmin.SnapshotAdministratorId;

                                                        //Save
                                                        var snapshotAdminAffiliation =
                                                            _snapshotAdminAffiliationRepository
                                                            .SaveSnapshotAdminAffiliation
                                                            (
                                                                adminAffiliation);
                                                        if (adminAffiliationBases != null)
                                                        {
                                                            foreach (var adminAffiliationBase in adminAffiliationBases)
                                                            {
                                                                //Assign FK
                                                                adminAffiliationBase.SnapshotAdminAffiliationId =
                                                                    snapshotAdminAffiliation.SnapshotAdminAffiliationId;

                                                                _adminAffiliationBaseRepository
                                                                .SaveSnapshotAdministrator(
                                                                    adminAffiliationBase);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            //save recs config, usually null
            if (recsConfiguratons != null)
            {
                Logger.Info("Number of Recs Config should be 2 === " + recsConfiguratons.Count);
                foreach (var recConfig in recsConfiguratons)
                {
                    if (recConfig != null)
                    {
                        var config = recConfig.Configuration;
                        recConfig.Configuration = null;

                        var lprConfig = recConfig.LicenseProductConfiguration;
                        recConfig.LicenseProductConfiguration = null;

                        if (config != null)
                        {
                            _snapshotConfigurationRepository.SaveSnapshotConfiguration(config);
                        }

                        _snapshotRecsConfigurationRepository.SaveSnapshotRecsConfiguration(recConfig);
                    }
                }
            }

            return(snapshotLicenseProduct);
        }
        private void DeleteAllWorksRecordingAndChildren(Snapshot_LicenseProduct licenseProduct)
        {
            if (licenseProduct.CloneLicenseProductId != null)
            {
                var workRecordings =
                    _snapshotWorksRecordingRepository.GetAllWorksRecordingsForLicenseProductId(
                        licenseProduct.CloneLicenseProductId);
                if (workRecordings != null)
                {
                    foreach (var recording in workRecordings)
                    {
                        //delete works track
                        var track = _snapshotWorkTrackRepository.GetTrackForCloneTrackId(recording.TrackId);
                        if (track != null)
                        {
                            //get artist and delte
                            var artist =
                                _snapshotArtistRecsRepository.GetSnapshotArtistRecsByArtistId(track.ArtistRecsId);
                            if (artist != null)
                            {
                                _snapshotArtistRecsRepository.DeleteRecsArtisByArtistSnapshotId(
                                    artist.SnapshotArtistRecsId);
                            }

                            //delete copyrights
                            var copyrights =
                                _snapshotRecsCopyrightRespository.GetAllRecsCopyrightsForCloneTrackId(
                                    track.CloneWorksTrackId);

                            if (copyrights != null)
                            {
                                foreach (var copyRight in copyrights)
                                {
                                    //get all samples
                                    var samples =
                                        _snapshotSampleRepository.GetAllSamplesForRecCopyrightId(
                                            copyRight.SnapshotRecsCopyrightsId);

                                    if (samples != null)
                                    {
                                        foreach (var sample in samples)
                                        {
                                            _snapshotSampleRepository.DeleteSampleSnapshot(sample);
                                        }
                                    }
                                    //get all composers
                                    var composers =
                                        _snapshotComposerRepository.GetAllComposersByRecsCopyrightid(
                                            copyRight.SnapshotRecsCopyrightsId);

                                    if (composers != null)
                                    {
                                        foreach (var composer in composers)
                                        {
                                            var affiliations =
                                                _composerAffiliationRepository
                                                .GetAllComposersAffiliationsByComposerSnapshotId(
                                                    composer.SnapshotComposerId);
                                            if (affiliations != null)
                                            {
                                                foreach (var affiliation in affiliations)
                                                {
                                                    var affiliationBases =
                                                        _composerAffiliationBaseRepository
                                                        .GetAllComposersAffiliationBasesByComposerAffiliationSnapshotId
                                                        (
                                                            affiliation.SnapshotComposerAffiliationId);

                                                    if (affiliationBases != null)
                                                    {
                                                        foreach (var affiliationBase in affiliationBases)
                                                        {
                                                            _composerAffiliationBaseRepository
                                                            .DeleteComposerAffiliationBaseSnapshotByComposer(
                                                                affiliationBase);
                                                        }
                                                    }
                                                }
                                                foreach (var affiliation in affiliations)
                                                {
                                                    _composerAffiliationRepository
                                                    .DeleteComposerAffiliationSnapshotByComposer(
                                                        affiliation);
                                                }
                                            }

                                            var originalPublishers =
                                                _composerOriginalPublisherRepository
                                                .GetAllComposerOriginalPublishersForComposerId(
                                                    composer.SnapshotComposerId);
                                            if (originalPublishers != null)
                                            {
                                                foreach (var originalPublisher in originalPublishers)
                                                {
                                                    var admins =
                                                        _composerOriginalPublisherAdministratorRepository
                                                        .GetAllComposerOriginalPublisherAdministratorsForComposerOriginalPublisherId
                                                            (originalPublisher.SnapshotComposerOriginalPublisherId);

                                                    if (admins != null)
                                                    {
                                                        foreach (var admin in admins)
                                                        {
                                                            var adminAffiliations =
                                                                _composerOriginalPublisherAdminAffiliation
                                                                .GetAllComposerOriginalPublisherAdminAffiliationsorAdminId
                                                                (
                                                                    admin
                                                                    .SnapshotComposerOriginalPublisherAdministratorId);
                                                            if (adminAffiliations != null)
                                                            {
                                                                foreach (var adminAffiliation in adminAffiliations)
                                                                {
                                                                    var adminBasse =
                                                                        _composerOriginalPublisherAdminAffiliationBaseRepository
                                                                        .GetAllComposerOriginalPublisherAdminAffiliationBasesForAffiliationId
                                                                            (adminAffiliation
                                                                            .SnapshotComposerOriginalPublisherAdminAffiliationId);
                                                                    if (adminBasse != null)
                                                                    {
                                                                        foreach (var adminBase in adminBasse)
                                                                        {
                                                                            _composerOriginalPublisherAdminAffiliationBaseRepository
                                                                            .DeleteComposerOriginalPublisherAdminAffiliationBase
                                                                                (adminBase);
                                                                        }
                                                                    }
                                                                    _composerOriginalPublisherAdminAffiliation
                                                                    .DeleteComposerOriginalPublisherAdminAffiliation
                                                                    (
                                                                        adminAffiliation);
                                                                }
                                                            }

                                                            var compOriginalPublisherAffilaitions =
                                                                _composerOriginalPublisherAffiliationRepository
                                                                .GetAllComposerOriginalPublisherAffiliationsForComposerOriginalPublisherId
                                                                    (originalPublisher
                                                                    .SnapshotComposerOriginalPublisherId);

                                                            if (compOriginalPublisherAffilaitions != null)
                                                            {
                                                                foreach (
                                                                    var compOriginalPublisherAffilaition in
                                                                    compOriginalPublisherAffilaitions)
                                                                {
                                                                    var compOpAffBase =
                                                                        _composerOriginalPublisherAffiliationBaseRepository
                                                                        .GetComposerOriginalPublisherAffiliationBasesFComposerOriginalPublisherAffiliationId
                                                                            (compOriginalPublisherAffilaition
                                                                            .SnapshotComposerOriginalPublisherAffiliationId);
                                                                    if (compOpAffBase != null)
                                                                    {
                                                                        foreach (var affBase in compOpAffBase)
                                                                        {
                                                                            _composerOriginalPublisherAffiliationBaseRepository
                                                                            .DeleteComposerOriginalPublisherAffiliationBase
                                                                            (
                                                                                affBase);
                                                                        }
                                                                    }
                                                                    _composerOriginalPublisherAffiliationRepository
                                                                    .DeleteComposerOriginalPubhliserAffiliation(
                                                                        compOriginalPublisherAffilaition);
                                                                }
                                                            }

                                                            _composerOriginalPublisherAdministratorRepository
                                                            .DeleteComposerOriginalPublisherAdministrator(admin);
                                                        }
                                                    }

                                                    var knownAs =
                                                        _composerOriginalPublisherKnownAsRepository
                                                        .GetAllComposerOriginalPublisherKnownAsByComposerOriginalPublisherSnapshotId
                                                            (composer.SnapshotComposerId);

                                                    if (knownAs != null)
                                                    {
                                                        foreach (var snapshotComposerOriginalPublisherKnownAs in knownAs
                                                                 )
                                                        {
                                                            _composerOriginalPublisherKnownAsRepository
                                                            .DeleteComposerOriginalPublisherKnownAs(
                                                                snapshotComposerOriginalPublisherKnownAs);
                                                        }
                                                    }
                                                    _composerOriginalPublisherRepository.DeleteComposerOriginalPublisher
                                                    (
                                                        originalPublisher);
                                                }
                                            }

                                            var localClients =
                                                _snapshotLocalClientCopyrightRepository.GetAllLocalCopyrightsForTrackId(
                                                    track.CloneWorksTrackId);
                                            if (localClients != null)
                                            {
                                                foreach (var localClient in localClients)
                                                {
                                                    _snapshotLocalClientCopyrightRepository
                                                    .DeleteLocalClientCopyrightBySnapshotId(
                                                        localClient.SnapshotLocalClientCopyrightId);
                                                }
                                            }

                                            var locationCodes =
                                                _aquisitionLocationCodeRepository
                                                .GetAllAquisitionLocationCodesForTrackId(
                                                    track.CloneWorksTrackId);
                                            if (locationCodes != null)
                                            {
                                                foreach (var locationCode in locationCodes)
                                                {
                                                    _aquisitionLocationCodeRepository
                                                    .DeleteAquisitionLocationCodeBySnashotId(
                                                        locationCode.SnapshotAquisitionLocationCode);
                                                }
                                            }

                                            _snapshotRecsCopyrightRespository
                                            .DeleteRecsCopyrightByRecsCopyrightSnapshotId(
                                                copyRight.SnapshotRecsCopyrightsId);
                                            _snapshotComposerRepository.DeleteComposerSnapshotByComposer(composer);
                                        }
                                    }

                                    //Delete worksRecordiing
                                    _snapshotWorksRecordingRepository.DeleteWorkRecordingByRecordignSnapshotId(
                                        recording.SnapshotWorksRecodingId);
                                }
                            }
                        }
                        if (track != null && track.SnapshotWorkTrackId != null)
                        {
                            _snapshotWorkTrackRepository.DeleteTrackBySnapshotTrackId(track.SnapshotWorkTrackId);
                        }
                        if (recording != null)
                        {
                            DeleteWorksWritersAndChildren(recording);
                        }
                    }
                }
            }
        }