<?xml version="1.0" encoding="UTF-8"?>
<changelog xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="https://www.liquigraph.org/schema/1.0/liquigraph.xsd">
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:1" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // LabelParticipant -> GlobalParticipant
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lpToT]-(lp:LabelParticipant)<-[gpToLp]-(gp:GlobalParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    CALL apoc.util.sleep(10)
                    MERGE (nlp:LabelParticipant:Orchard {normalizedName: lp.normalizedName, vendorId: lp.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlp.id = datetime.realtime().epochMillis,
                            nlp.uuid = apoc.create.uuid(),
                            nlp.createdAt = datetime(),
                            nlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                        SET nlp += apoc.map.removeKeys(lp, ['id', 'uuid', 'vendorId', 'subaccountId', 'createdAt', 'createdBy']),
                            nlp.lastModifiedAt = datetime(),
                            nlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                    WITH *
                    CALL apoc.merge.relationship(gp, type(gpToLp), null, gpToLp, nlp)
                    YIELD rel AS rel
                    RETURN true;

                    // Delete LabelParticipant -> GlobalParticipant
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lpToT]-(lp:LabelParticipant)<-[gpToLp]-(gp:GlobalParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    DELETE gpToLp;
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:2" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // Track LabelParticipant -> ArtistInfo
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lpToT]-(lp:LabelParticipant)-[cf:CREATED_FROM]->(ai:ArtistInfo)
                    WHERE lp.subaccountId <> pr.subaccountId
                    CALL apoc.util.sleep(10)
                    MERGE (nlp:LabelParticipant:Orchard {normalizedName: lp.normalizedName, vendorId: lp.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlp.id = datetime.realtime().epochMillis,
                            nlp.uuid = apoc.create.uuid(),
                            nlp.createdAt = datetime(),
                            nlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                        SET nlp += apoc.map.removeKeys(lp, ['id', 'uuid', 'vendorId', 'subaccountId', 'createdAt', 'createdBy']),
                            nlp.lastModifiedAt = datetime(),
                            nlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                    WITH *
                    CALL apoc.merge.relationship(nlp, type(cf), null, cf, ai)
                    YIELD rel AS rel
                    RETURN true;

                    // Delete old Product LP -> ArtistInfo
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lpToT]-(lp:LabelParticipant)-[cf:CREATED_FROM]->(ai:ArtistInfo)
                    WHERE lp.subaccountId <> pr.subaccountId
                    DELETE cf;
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:3" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // LabelParticipant -> Track
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lpToT]-(lp:LabelParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    CALL apoc.util.sleep(10)
                    MERGE (nlp:LabelParticipant:Orchard {normalizedName: lp.normalizedName, vendorId: pr.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlp.id = datetime.realtime().epochMillis,
                            nlp.uuid = apoc.create.uuid(),
                            nlp.createdAt = datetime(),
                            nlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                        SET nlp += apoc.map.removeKeys(lp, ['id', 'uuid', 'vendorId', 'subaccountId', 'createdAt']),
                            nlp.lastModifiedAt = datetime(),
                            nlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                    WITH *
                    CALL apoc.merge.relationship(nlp, type(lpToT), {participated_as: lpToT.participated_as}, lpToT, t)
                    YIELD rel AS rel1
                    RETURN true
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:4" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.doIt(
                "
                    // LabelParticipant -> TrackArtist
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lpToT]-(lp:LabelParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    MATCH (lp)-[cf:CREATED_FROM]->(ta:TrackArtist)<-[:HAS_SOURCE_ARTIST]-(t)
                    CALL apoc.util.sleep(10)
                    MERGE (nlp:LabelParticipant:Orchard {normalizedName: lp.normalizedName, vendorId: lp.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlp.id = datetime.realtime().epochMillis,
                            nlp.uuid = apoc.create.uuid(),
                            nlp.createdAt = datetime(),
                            nlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                        SET nlp += apoc.map.removeKeys(lp, ['id', 'uuid', 'vendorId', 'subaccountId', 'createdAt', 'createdBy']),
                            nlp.lastModifiedAt = datetime(),
                            nlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                    WITH *
                    CALL apoc.merge.relationship(nlp, type(cf), null, cf, ta)
                    YIELD rel AS rel
                    RETURN true
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD value
                RETURN true;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:5" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // LabelParticipant -> TrackWriter
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lpToT]-(lp:LabelParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    MATCH (lp)-[cf:CREATED_FROM]->(tw:TrackWriter)<-[:HAS_SOURCE_ARTIST]-(t)
                    CALL apoc.util.sleep(10)
                    MERGE (nlp:LabelParticipant:Orchard {normalizedName: lp.normalizedName, vendorId: lp.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlp.id = datetime.realtime().epochMillis,
                            nlp.uuid = apoc.create.uuid(),
                            nlp.createdAt = datetime(),
                            nlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                        SET nlp += apoc.map.removeKeys(lp, ['id', 'uuid', 'vendorId', 'subaccountId', 'createdAt', 'createdBy']),
                            nlp.lastModifiedAt = datetime(),
                            nlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                    WITH *
                    CALL apoc.merge.relationship(nlp, type(cf), null, cf, tw)
                    YIELD rel AS rel
                    RETURN true;

                    // Delete old LP -> Track/TrackArtist/TrackWriter
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lpToT]-(lp:LabelParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    OPTIONAL MATCH (lp)-[lpToTa]->(ta:TrackArtist)<-[:HAS_SOURCE_ARTIST]-(t)
                    OPTIONAL MATCH (lp)-[lpToTw]->(tw:TrackWriter)<-[:HAS_SOURCE_ARTIST]-(t)
                    DELETE lpToT, lpToTa, lpToTw
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:6" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.doIt(
                "
                    // Delete old LP -> Track/TrackArtist/TrackWriter
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lpToT]-(lp:LabelParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    OPTIONAL MATCH (lp)-[lpToTa]->(ta:TrackArtist)<-[:HAS_SOURCE_ARTIST]-(t)
                    OPTIONAL MATCH (lp)-[lpToTw]->(tw:TrackWriter)<-[:HAS_SOURCE_ARTIST]-(t)
                    DELETE lpToT, lpToTa, lpToTw
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD value
                RETURN true;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:7" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // LabelParticipant -> GlobalParticipant
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(p:Product)<-[lpToP]-(lp:LabelParticipant)<-[gpToLp]-(gp:GlobalParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    CALL apoc.util.sleep(10)
                    MERGE (nlp:LabelParticipant:Orchard {normalizedName: lp.normalizedName, vendorId: lp.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlp.id = datetime.realtime().epochMillis,
                            nlp.uuid = apoc.create.uuid(),
                            nlp.createdAt = datetime(),
                            nlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                        SET nlp += apoc.map.removeKeys(lp, ['id', 'uuid', 'vendorId', 'subaccountId', 'createdAt', 'createdBy']),
                            nlp.lastModifiedAt = datetime(),
                            nlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                    WITH *
                    CALL apoc.merge.relationship(gp, type(gpToLp), null, gpToLp, nlp)
                    YIELD rel AS rel
                    RETURN true;

                    // Delete LabelParticipant -> GlobalParticipant
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(p:Product)<-[lpToP]-(lp:LabelParticipant)<-[gpToLp]-(gp:GlobalParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    DELETE gpToLp;
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:8" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // LabelParticipant -> Product
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(p:Product)<-[lpToP]-(lp:LabelParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    CALL apoc.util.sleep(10)
                    MERGE (nlp:LabelParticipant:Orchard {normalizedName: lp.normalizedName, vendorId: lp.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlp.id = datetime.realtime().epochMillis,
                            nlp.uuid = apoc.create.uuid(),
                            nlp.createdAt = datetime(),
                            nlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                        SET nlp += apoc.map.removeKeys(lp, ['id', 'uuid', 'vendorId', 'subaccountId', 'createdAt', 'createdBy']),
                            nlp.lastModifiedAt = datetime(),
                            nlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                    WITH *
                    CALL apoc.merge.relationship(nlp, type(lpToP), {participated_as: lpToP.participated_as}, lpToP, p)
                    YIELD rel AS rel
                    RETURN true
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:9" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // LabelParticipant -> ArtistInfo
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(p:Product)<-[lpToP]-(lp:LabelParticipant)-[cf:CREATED_FROM]->(ai:ArtistInfo)
                    WHERE lp.subaccountId <> pr.subaccountId
                    CALL apoc.util.sleep(10)
                    MERGE (nlp:LabelParticipant:Orchard {normalizedName: lp.normalizedName, vendorId: lp.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlp.id = datetime.realtime().epochMillis,
                            nlp.uuid = apoc.create.uuid(),
                            nlp.createdAt = datetime(),
                            nlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                        SET nlp += apoc.map.removeKeys(lp, ['id', 'uuid', 'vendorId', 'subaccountId', 'createdAt', 'createdBy']),
                            nlp.lastModifiedAt = datetime(),
                            nlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                    WITH *
                    CALL apoc.merge.relationship(nlp, type(cf), null, cf, ai)
                    YIELD rel AS rel
                    RETURN true;

                    // Delete old Product LP -> ArtistInfo
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(p:Product)<-[lpToP]-(lp:LabelParticipant)-[cf:CREATED_FROM]->(ai:ArtistInfo)
                    WHERE lp.subaccountId <> pr.subaccountId
                    DELETE cf
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:10" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // LabelParticipant -> ReleaseArtist
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(p:Product)<-[lpToP]-(lp:LabelParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    MATCH (lp)-[lpToRa]-(ra:ReleaseArtist {productId: p.id})
                    CALL apoc.util.sleep(10)
                    MERGE (nlp:LabelParticipant:Orchard {normalizedName: lp.normalizedName, vendorId: lp.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlp.id = datetime.realtime().epochMillis,
                            nlp.uuid = apoc.create.uuid(),
                            nlp.createdAt = datetime(),
                            nlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                        SET nlp += apoc.map.removeKeys(lp, ['id', 'uuid', 'vendorId', 'subaccountId', 'createdAt', 'createdBy']),
                            nlp.lastModifiedAt = datetime(),
                            nlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                    WITH *
                    CALL apoc.merge.relationship(nlp, type(lpToRa), null, lpToRa, ra)
                    YIELD rel AS rel
                    RETURN true;

                    // Delete old LP -> Product/ReleaseArtist
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(p:Product)<-[lpToP]-(lp:LabelParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    OPTIONAL MATCH (lp)-[lpToRa]-(ra:ReleaseArtist {productId: p.id})
                    DELETE lpToP, lpToRa
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:11" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // LabelParticipant -> ArtistInfo
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:CREATED_FOR_PARTICIPANT]->(lp:LabelParticipant)-[cf:CREATED_FROM]->(ai:ArtistInfo)
                    WHERE lp.subaccountId <> pr.subaccountId
                    CALL apoc.util.sleep(10)
                    MERGE (nlp:LabelParticipant:Orchard {normalizedName: lp.normalizedName, vendorId: lp.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlp.id = datetime.realtime().epochMillis,
                            nlp.uuid = apoc.create.uuid(),
                            nlp.createdAt = datetime(),
                            nlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                        SET nlp += apoc.map.removeKeys(lp, ['id', 'uuid', 'vendorId', 'subaccountId', 'createdAt', 'createdBy']),
                            nlp.lastModifiedAt = datetime(),
                            nlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                    WITH *
                    CALL apoc.merge.relationship(nlp, type(cf), null, cf, ai)
                    YIELD rel AS rel
                    RETURN true;

                    // Delete old LP -> ArtistInfo
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:CREATED_FOR_PARTICIPANT]->(lp:LabelParticipant)-[cf:CREATED_FROM]->(ai:ArtistInfo)
                    WHERE lp.subaccountId <> pr.subaccountId
                    DELETE cf
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:12" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // LabelParticipant -> Project
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[lpToP]->(lp:LabelParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    CALL apoc.util.sleep(10)
                    MERGE (nlp:LabelParticipant:Orchard {normalizedName: lp.normalizedName, vendorId: lp.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlp.id = datetime.realtime().epochMillis,
                            nlp.uuid = apoc.create.uuid(),
                            nlp.createdAt = datetime(),
                            nlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                        SET nlp += apoc.map.removeKeys(lp, ['id', 'uuid', 'vendorId', 'subaccountId', 'createdAt', 'createdBy']),
                            nlp.lastModifiedAt = datetime(),
                            nlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                    WITH *
                    CALL apoc.merge.relationship(pr, type(lpToP), null, lpToP, nlp)
                    YIELD rel AS rel
                    // Delete old LP -> Project
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[lpToP]->(lp:LabelParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    DELETE lpToP
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:13" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // LP -> LabelSoundRecordingParticipation
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lsrToT]->(lsr:LabelSoundRecording)<-[:ON_LABEL_SOUND_RECORDING]-(lsrp:LabelSoundRecordingParticipation)<-[hlsrp:HAS_LABEL_SOUND_RECORDING_PARTICIPATION]-(lp:LabelParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    CALL apoc.util.sleep(10)
                    MERGE (nlp:LabelParticipant:Orchard {normalizedName: lp.normalizedName, vendorId: lp.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlp.id = datetime.realtime().epochMillis,
                            nlp.uuid = apoc.create.uuid(),
                            nlp.createdAt = datetime(),
                            nlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879',
                        SET nlp += apoc.map.removeKeys(lp, ['id', 'uuid', 'vendorId', 'subaccountId', 'createdAt', 'createdBy']),
                            nlp.lastModifiedAt = datetime(),
                            nlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                    WITH *
                    CALL apoc.merge.relationship(nlp, type(hlsrp), null, hlsrp, lsrp)
                    YIELD rel AS rel
                    RETURN true;

                    // delete old LP -> LabelSoundRecordingParticipation
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lsrToT]->(lsr:LabelSoundRecording)<-[:ON_LABEL_SOUND_RECORDING]-(lsrp:LabelSoundRecordingParticipation)<-[hlsrp:HAS_LABEL_SOUND_RECORDING_PARTICIPATION]-(lp:LabelParticipant)
                    WHERE lp.subaccountId <> pr.subaccountId
                    DELETE hlsrp;
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:14" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // LSR -> LabelSoundRecordingParticipation
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lsrToT]-(lsr:LabelSoundRecording)<-[olsr:ON_LABEL_SOUND_RECORDING]-(lsrp:LabelSoundRecordingParticipation)
                    WHERE lsr.subaccountId <> pr.subaccountId
                    MERGE (vhlp:LabelSoundRecording:Orchard {isrc: lsr.isrc, vendorId: pr.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            vhlp.id = apoc.create.uuid(),
                            vhlp.createdAt = datetime(),
                            vhlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879',
                            vhlp.lastModifiedAt = datetime(),
                            vhlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                        SET vhlp += apoc.map.removeKeys(lsr, ['id', 'isrc', 'vendorId', 'subaccountId', 'createdAt'])
                        SET
                            vhlp.lastModifiedAt = datetime(),
                            vhlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                    WITH *
                    CALL apoc.merge.relationship(lsrp, type(olsr), {}, olsr, vhlp)
                    YIELD rel
                    RETURN true;

                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lsrToT]-(lsr:LabelSoundRecording)<-[olsr:ON_LABEL_SOUND_RECORDING]-(lsrp:LabelSoundRecordingParticipation)
                    WHERE lsr.subaccountId <> pr.subaccountId
                    DELETE olsr;
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:14_1" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // LSR -> GlobalSoundRecording
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(:Track)-[:IS_PLACEMENT_OF]->(lsr:LabelSoundRecording)<-[lsrToGsr:REPRESENTS]-(gsr:GlobalSoundRecording)
                    WHERE lsr.subaccountId <> pr.subaccountId
                    MERGE (nlsr:LabelSoundRecording:Orchard {isrc: lsr.isrc, vendorId: pr.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlsr.id = apoc.create.uuid(),
                            nlsr.createdAt = datetime(),
                            nlsr.createdBy = 'lambda-kinesis-to-neo4j/label_participant_to_label_sound_recording_participation'
                        SET nlsr += apoc.map.removeKeys(lsr, ['id', 'isrc', 'vendorId', 'subaccountId', 'createdAt']),
                            nlsr.lastModifiedAt = datetime(),
                            nlsr.lastModifiedBy = 'lambda-kinesis-to-neo4j/label_participant_global_sound_recording_participation'
                    WITH *
                    CALL apoc.merge.relationship(gsr, type(lsrToGsr), null, lsrToGsr, nlsr)
                    YIELD rel
                    RETURN true;
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:14_2" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)<-[:BELONGS_TO]-(pr:Project)
                WHERE v.id IN [82879]
                CALL apoc.cypher.runMany(
                "
                    // LSR -> Track
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(t:Track)-[lsrToT:IS_PLACEMENT_OF]->(lsr:LabelSoundRecording)
                    WHERE lsr.subaccountId <> pr.subaccountId
                    MERGE (nlsr:LabelSoundRecording:Orchard {isrc: lsr.isrc, vendorId: pr.vendorId, subaccountId: pr.subaccountId})
                        ON CREATE SET
                            nlsr.id = apoc.create.uuid(),
                            nlsr.createdAt = datetime(),
                            nlsr.createdBy = 'lambda-kinesis-to-neo4j/label_sound_recording_to_track'
                        SET nlsr += apoc.map.removeKeys(lsr, ['id', 'isrc', 'vendorId', 'subaccountId', 'createdAt']),
                            nlsr.lastModifiedAt = datetime(),
                            nlsr.lastModifiedBy = 'lambda-kinesis-to-neo4j/label_sound_recording_to_track'
                    WITH *
                    CALL apoc.merge.relationship(t, type(lsrToT), null, lsrToT, nlsr)
                    YIELD rel
                    RETURN true;

                    // Delete LSR -> Track
                    MATCH (v:Vendor {id: $vendorId})<-[:BELONGS_TO]-(pr:Project {id: $projectId})-[:INCLUDES]->(:Product)-[:INCLUDES]->(:Track)-[lsrToT:IS_PLACEMENT_OF]->(lsr:LabelSoundRecording)
                    WHERE lsr.subaccountId <> pr.subaccountId
                    DELETE lsrToT;
                ",
                {vendorId: pr.vendorId, projectId: pr.id})
                YIELD row, result
                RETURN row, result;
            ]]>
        </query>
    </changeset>
    <changeset id="INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879:15" author="wcheong" run-on-change="true" run-always="true">
        <query>
            <![CDATA[
                MATCH (v:Vendor)-[:HAS_LABEL_PARTICIPANT|CREATED_FROM]-(lp:LabelParticipant)
                WHERE v.vendorId in [82879] AND lp.subaccountId <> 0
                MATCH (sa:Subaccount)
                WHERE sa.id = lp.subaccountId
                MERGE (v)-[vhlp:HAS_LABEL_PARTICIPANT]->(lp)
                    ON CREATE SET
                        vhlp.createdAt = datetime(),
                        vhlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879',
                        vhlp.lastModifiedAt = datetime(),
                        vhlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                MERGE (sa)-[sahlp:HAS_LABEL_PARTICIPANT]->(lp)
                    ON CREATE SET
                        sahlp.createdAt = datetime(),
                        sahlp.createdBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879',
                        sahlp.lastModifiedAt = datetime(),
                        sahlp.lastModifiedBy = 'database/INT-1713-neo4j-link-artist-profiles-after-d3-conversion-for-label_id=82879'
                RETURN true;
            ]]>
        </query>
    </changeset>
</changelog>
