<?xml version="1.0" encoding="UTF-8"?>
<changelog xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.liquigraph.org/schema/1.0/liquigraph.xsd">
    <changeset id="ARTARCH-276_backfill_from_art_relations:1" author="gaguirre" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of artist_info ingest at %s", [datetime()]);
        </query>
        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                    "
                        WITH 'mysql_artrelations' as url_alias,
                        '
                            SELECT ai.artist_id, ai.name, ai.vendor_id, v.is_distributor != \"Y\"
                            FROM artist_info ai
                            INNER JOIN vendor v ON ai.vendor_id = v.vendor_id
                            WHERE ai.vendor_id IS NOT NULL
                        ' as sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        RETURN row
                    ",
                    "
                        MERGE (ai:ArtistInfo {id: toInteger(row.artist_id)})
                            SET ai.name = row.name,
                                ai.vendorId = toInteger(row.vendor_id),
                                ai.updated_at = datetime()
                        WITH ai, row
                        MERGE (v:Vendor:Label {id: ai.vendorId})
                        MERGE (v)-[:HAS_ARTIST]->(ai)
                        FOREACH (notDistr IN CASE WHEN NOT row.is_distributor THEN [1] ELSE [] END |
                            MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                                ON CREATE SET i.id = 1
                                ON MATCH SET i.id = i.id + 1
                            MERGE (lp:LabelParticipant:Orchard {
                                name: trim(apoc.text.regreplace(ai.name, '[ ]{2,}', ' ')),
                                vendorId: toInteger(ai.vendorId),
                                subaccountId: 0
                            })
                                ON CREATE SET
                                    lp.id = i.id,
                                    lp.uuid = apoc.create.uuid(),
                                    lp.createdAt = datetime(),
                                    lp.modifiedAt = datetime()
                            MERGE (lp)-[cf:CREATED_FROM]->(ai)
                                ON CREATE SET cf.created_at = datetime()
                            MERGE (v)-[:HAS_LABEL_PARTICIPANT]->(lp)
                        )
                        WITH ai
                        MATCH (ai)<-[:HAS_ARTIST]-(pr:Project)
                        WHERE pr.vendorId IS NOT NULL AND pr.subaccountId IS NOT NULL
                            AND NOT (pr)-[:CREATED_FOR_PARTICIPANT]->(:LabelParticipant)
                        MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                            ON CREATE SET i.id = 1
                            ON MATCH SET i.id = i.id + 1
                        MERGE (lp:LabelParticipant:Orchard {
                            vendorId: pr.vendorId,
                            subaccountId: pr.subaccountId,
                            name: trim(apoc.text.regreplace(ai.name, '[ ]{2,}', ' '))
                        })
                        ON CREATE SET
                            lp.id = i.id,
                            lp.uuid = apoc.create.uuid(),
                            lp.createdAt = datetime(),
                            lp.modifiedAt = datetime()
                        MERGE (pr)-[:CREATED_FOR_PARTICIPANT]->(lp)
                    ",
                    {batchSize:1000}
                );
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished artist_info ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-262_backfill_from_art_relations:2" author="gaguirre" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of project ingest at %s", [datetime()]);
        </query>
        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                    "
                        WITH 'mysql_artrelations' as url_alias,
                        '
                            SELECT project_id, vendor_id, subaccount_id, artist_id
                            FROM project
                            WHERE vendor_id IS NOT NULL
                        ' as sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        RETURN row
                    ",
                    "
                        MERGE (pr:Project {id: toInteger(row.project_id)})
                            SET pr.vendorId = toInteger(row.vendor_id),
                                pr.subaccountId = toInteger(row.subaccount_id),
                                pr.artistId = toInteger(row.artist_id),
                                pr.updated_at = datetime()
                        MERGE (v:Vendor:Label {id: pr.vendorId})
                        MERGE (pr)-[:BELONGS_TO]-(v)
                        FOREACH (isSubAccount IN
                                            CASE WHEN pr.subaccountId <> 0 THEN [1] ELSE [] END |
                            MERGE (sa:SubAccount:Subaccount:Label {id: pr.subaccountId})
                            MERGE (pr)-[:BELONGS_TO]-(sa)
                            MERGE (v)-[:OWNS]->(sa)
                        )
                        FOREACH (isArtistInfo IN CASE WHEN pr.artistId <> 0 THEN [1] ELSE [] END |
                            MERGE (ai:ArtistInfo {id: pr.artistId})
                            MERGE (pr)-[:HAS_ARTIST]->(ai)
                        )
                        WITH pr, v
                        MATCH (pr)-[:HAS_ARTIST]->(ai)
                        WHERE ai.name IS NOT NULL
                        MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                            ON CREATE SET i.id = 1
                            ON MATCH SET i.id = i.id + 1
                        MERGE (lp:LabelParticipant:Orchard {
                            vendorId: pr.vendorId,
                            subaccountId: pr.subaccountId,
                            name: trim(apoc.text.regreplace(ai.name, '[ ]{2,}', ' '))
                        })
                        ON CREATE SET
                            lp.id = i.id,
                            lp.uuid = apoc.create.uuid(),
                            lp.createdAt = datetime(),
                            lp.modifiedAt = datetime()
                        MERGE (lp)-[:CREATED_FROM]->(ai)
                        MERGE (pr)-[:CREATED_FOR_PARTICIPANT]->(lp)
                        MERGE (v)-[:HAS_LABEL_PARTICIPANT]->(lp)
                        FOREACH (hasSubAccount IN
                                        CASE WHEN NOT (lp.subaccountId = 0) THEN [1] ELSE [] END |
                            MERGE (sa:SubAccount:Subaccount:Label {id: lp.subaccountId})
                            MERGE (sa)-[:HAS_LABEL_PARTICIPANT]->(lp)
                        )
                    ",
                    {batchSize:1000}
                );
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished project ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-262_backfill_from_art_relations:3" author="gaguirre" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of release_artist ingest at %s", [datetime()]);
        </query>
        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                    "
                        WITH 'mysql_artrelations' as url_alias,
                        '
                            SELECT ra.release_artist_id, ra.release_id, ra.artist_name, ra.role, p.vendor_id, p.subaccount_id
                            FROM release_artist ra
                            INNER JOIN releases r on ra.release_id = r.release_id
                            INNER JOIN project p on r.project_id = p.project_id
                            WHERE ra.release_id IS NOT NULL
                            AND ra.release_artist_id IN (
                                6332087,
                                6332085,
                                6332074,
                                6332053,
                                6332051,
                                6332030
                            )
                        ' as sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        RETURN row
                    ",
                    "
                        MERGE (ra:ReleaseArtist {id: toInteger(row.release_artist_id)})
                            SET ra.productId = toInteger(row.release_id),
                                ra.name = row.artist_name,
                                ra.role = row.role,
                                ra.updated_at = datetime()
                        MERGE (p:Product:Orchard {id: ra.productId})
                        MERGE (p)-[:HAS_SOURCE_ARTIST]->(ra)
                        MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                          ON CREATE SET i.id = 1
                          ON MATCH SET i.id = i.id + 1
                        MERGE (
                          lp:LabelParticipant:Orchard {
                              name: trim(apoc.text.regreplace(ra.name, '[ ]{2,}', ' ')),
                              vendorId: row.vendor_id,
                              subaccountId: row.subaccount_id
                          }
                        )
                            ON CREATE SET
                                lp.id = i.id,
                                lp.uuid = apoc.create.uuid(),
                                lp.createdAt = datetime(),
                                lp.modifiedAt = datetime()
                        MERGE (lp)-[:PARTICIPATED_IN {participated_as: ra.role}]->(p)
                        MERGE (lp)-[cf:CREATED_FROM]->(ra)
                          ON CREATE SET cf.created_at = datetime()
                        MERGE (v:Vendor:Label {id: lp.vendorId})
                        MERGE (v)-[:HAS_LABEL_PARTICIPANT]->(lp)
                        FOREACH (hasSubAccount IN
                                        CASE WHEN NOT (lp.subaccountId = 0) THEN [1] ELSE [] END |
                            MERGE (sa:SubAccount:Subaccount:Label {id: lp.subaccountId})
                            MERGE (sa)-[:HAS_LABEL_PARTICIPANT]->(lp)
                        )
                    ",
                    {batchSize:1000}
                );
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished release_artist ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-262_backfill_from_art_relations:4" author="gaguirre" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of track_artist ingest at %s", [datetime()]);
        </query>
        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                    "
                        WITH 'mysql_artrelations' as url_alias,
                        '
                            SELECT id, track_id, name, type
                            FROM track_artist ta
                            WHERE track_id IS NOT NULL
                            AND ta.id IN (
                                89356208,
                                89356207
                            )
                            ORDER BY id
                        ' as sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        RETURN row
                    ",
                    "
                        MERGE (ta:TrackArtist {id: toInteger(row.id)})
                            SET ta.trackId = toInteger(row.track_id),
                                ta.name = row.name,
                                ta.type = row.type,
                                ta.updated_at = datetime()
                        WITH ta
                        MATCH (t:Track:Orchard {id: ta.trackId})
                        MATCH (p:Product:Orchard)-[:INCLUDES]->(t)
                        MATCH (pr:Project)-[:INCLUDES]->(p)
                        WHERE exists(pr.subaccountId)
                        MERGE (t)-[:HAS_SOURCE_ARTIST]->(ta)
                        MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                            ON CREATE SET i.id = 1
                            ON MATCH SET i.id = i.id + 1
                        MERGE (
                            lp:LabelParticipant:Orchard {
                                name: trim(apoc.text.regreplace(ta.name, '[ ]{2,}', ' ')),
                                vendorId: pr.vendorId,
                                subaccountId: pr.subaccountId
                            }
                        )
                            ON CREATE SET
                                lp.id = i.id,
                                lp.uuid = apoc.create.uuid()
                        MERGE (lp)-[tp:PARTICIPATED_IN {participated_as: ta.type}]->(t)
                        MERGE (lp)-[cf:CREATED_FROM]->(ta)
                            ON CREATE SET cf.created_at = datetime()
                    ",
                    {batchSize:1000}
                );
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished track_artist ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-262_backfill_from_art_relations:5" author="gaguirre" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of participant_identifier at %s", [datetime()]);
        </query>
        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                    "
                        WITH 'mysql_artrelations' as url_alias,
                        '
                            SELECT id, vendor_id, subaccount_id, orchard_artist_name, store_id, store_artist_id
                            FROM participant_identifier
                            WHERE id IN (
                                2195124,
                                2195123,
                                2195109,
                                2195108
                            )
                        ' as sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        RETURN row
                    ",
                    "
                        MERGE (pi:ParticipantIdentifier {id: toInteger(row.id)})
                            SET pi.vendorId = toInteger(row.vendor_id),
                                pi.subaccountId = toInteger(row.subaccount_id),
                                pi.name = row.orchard_artist_name,
                                pi.storeId = toInteger(row.store_id),
                                pi.storeArtistId = row.store_artist_id,
                                pi.updated_at = datetime()
                        MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                            ON CREATE SET i.id = 1
                            ON MATCH SET i.id = i.id + 1
                        MERGE (lp:LabelParticipant:Orchard {
                            name: row.orchard_artist_name,
                            vendorId: row.vendor_id,
                            subaccountId: row.subaccount_id
                        })
                            ON CREATE SET
                                lp.id = i.id,
                                lp.uuid = apoc.create.uuid(),
                                lp.createdAt = datetime(),
                                lp.modifiedAt = datetime()
                        MERGE (lp)-[cf:CREATED_FROM]->(pi)
                            ON CREATE SET cf.created_at = datetime()
                        WITH *
                        OPTIONAL MATCH (gp:GlobalParticipant {spotifyId: row.store_artist_id})
                            WHERE row.store_id = 286
                        FOREACH (store IN CASE WHEN row.store_id = 1 THEN [1] ELSE [] END |
                            SET lp.appleMusicId = CASE WHEN row.store_artist_id = '' THEN NULL ELSE toInteger(row.store_artist_id) END
                        )
                        FOREACH (store IN CASE WHEN row.store_id = 286 THEN [1] ELSE [] END |
                            SET lp.spotifyId = CASE WHEN row.store_artist_id = '' THEN NULL ELSE row.store_artist_id END
                            FOREACH (gpExists IN CASE WHEN gp IS NOT NULL THEN [1] ELSE [] END |
                                MERGE (gp)-[:REPRESENTS]->(lp)
                            )
                        )
                        MERGE (v:Vendor:Label {id: lp.vendorId})
                        MERGE (v)-[:HAS_LABEL_PARTICIPANT]->(lp)
                        FOREACH (hasSubAccount IN
                                        CASE WHEN lp.subaccountId <> 0 THEN [1] ELSE [] END |
                            MERGE (sa:SubAccount:Subaccount:Label {id: lp.subaccountId})
                            MERGE (sa)-[:HAS_LABEL_PARTICIPANT]->(lp)
                        )
                    ",
                    {batchSize:1000}
                );
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished participant_identifier ingest at %s", [datetime()]);
        </query>
    </changeset>
</changelog>
