<?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-232_rebuild_label_participant:1" author="savva" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of artist_info ingest at %s", [datetime()]);
        </query>
        <query>
            CALL apoc.periodic.iterate(
                "
                    WITH 'mysql_artrelations' as url_alias,
                    '
                        SELECT artist_id, name, vendor_id
                        FROM artist_info
                        WHERE 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)
                    MERGE (v:Vendor {id: ai.vendorId})
                    MERGE (v)-[:HAS_ARTIST]->(ai)
                    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
                    MERGE (lp)-[cf:CREATED_FROM]->(ai)
                        ON CREATE SET cf.created_at = datetime()
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished artist_info ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-232_rebuild_label_participant:2" author="savva" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of project ingest at %s", [datetime()]);
        </query>
        <query>
            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)
                    MERGE (v:Vendor {id: pr.vendorId})
                    MERGE (pr)-[:BELONGS_TO]->(v)
                    FOREACH (isSubAccount IN CASE WHEN not (pr.subaccountId = 0) THEN [1] ELSE [] END |
                        MERGE (sa:SubAccount {id: pr.subaccountId})
                        MERGE (pr)-[:BELONGS_TO]->(sa)
                        MERGE (v)-[:OWNS]->(sa)
                    )
                    FOREACH (isArtistInfo IN CASE WHEN not (pr.artistId = 0) THEN [1] ELSE [] END |
                        MERGE (ai:ArtistInfo {id: pr.artistId})
                        MERGE (pr)-[:HAS_ARTIST]->(ai)
                    )
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished project ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-232_rebuild_label_participant:3" author="savva" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of releases ingest at %s", [datetime()]);
        </query>
        <query>
            CALL apoc.periodic.iterate(
                "
                    WITH 'mysql_artrelations' as url_alias,
                    '
                        SELECT release_id, upc, display_upc, project_id, artist_id, deletions
                        FROM releases
                        WHERE project_id IS NOT NULL
                    ' as sql
                    CALL apoc.load.jdbc(url_alias, sql)
                    YIELD row
                    RETURN row",
                "
                    MERGE (p:Product:Orchard {id: toInteger(row.release_id)})
                        SET p.projectId = toInteger(row.project_id),
                            p.upc = row.upc,
                            p.displayUpc = row.display_upc,
                            p.deletions = (row.deletions = 'Y')
                    MERGE (pr:Project {id: p.projectId})
                    MERGE (pr)-[r:INCLUDES]->(p)
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished releases ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-232_rebuild_label_participant:4" author="savva" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of release_artist ingest at %s", [datetime()]);
        </query>
        <query>
            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
                    ' 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
                    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: toInteger(row.vendor_id),
                            subaccountId: toInteger(row.subaccount_id)
                        }
                    )
                        ON CREATE SET lp.id = i.id
                    MERGE (lp)-[:PARTICIPATED_IN {participated_as: ra.role}]->(p)
                    MERGE (lp)-[cf:CREATED_FROM]->(ra)
                        ON CREATE SET cf.created_at = datetime()
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished release_artist ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-232_rebuild_label_participant:5" author="savva" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of track ingest at %s", [datetime()]);
        </query>
        <query>
            CALL apoc.periodic.iterate(
                "
                    WITH 'mysql_artrelations' as url_alias,
                    '
                        SELECT id, track_name, release_id, isrc
                        FROM track
                        WHERE release_id IS NOT NULL AND COALESCE(isrc, \"\") != \"\"
                    ' as sql
                    CALL apoc.load.jdbc(url_alias, sql)
                    YIELD row
                    RETURN row
                ",
                "
                    MERGE (t:Track:Orchard {id: toInteger(row.id)})
                        SET t.name = row.track_name,
                            t.isrc = row.isrc,
                            t.productId = toInteger(row.release_id)
                    WITH t
                    MERGE (t)-[:IS_PLACEMENT_OF]->(sr:SoundRecording:Orchard {isrc: t.isrc})
                        ON CREATE SET sr.id = apoc.create.uuid()
                    MERGE (p:Product:Orchard {id: t.productId})
                    MERGE (p)-[:INCLUDES]->(t)
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished track ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-232_rebuild_label_participant:6" author="savva" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of participant_identifier for apple ingest at %s", [datetime()]);
        </query>
        <query>
            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 store_id = 1
                    ' 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
                    WITH pi
                    MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                        ON CREATE SET i.id = 1
                        ON MATCH SET i.id = i.id + 1
                    MERGE (
                        lp:LabelParticipant:Orchard {
                            name: pi.name,
                            vendorId: pi.vendorId,
                            subaccountId: pi.subaccountId
                        }
                    )
                        ON CREATE SET lp.id = i.id
                    SET lp.appleMusicId = toInteger(pi.storeArtistId)
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished participant_identifier for apple ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-232_rebuild_label_participant:7" author="savva" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of participant_identifier for spotify ingest at %s", [datetime()]);
        </query>
        <query>
            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 store_id = 286
                    ' 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
                    WITH pi
                    MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                        ON CREATE SET i.id = 1
                        ON MATCH SET i.id = i.id + 1
                    MERGE (
                        lp:LabelParticipant:Orchard {
                            name: pi.name,
                            vendorId: pi.vendorId,
                            subaccountId: pi.subaccountId
                        }
                    )
                        ON CREATE SET lp.id = i.id
                    SET lp.spotifyId = pi.storeArtistId
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished participant_identifier for spotify ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-232_rebuild_label_participant:8" author="savva" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of track_artist ingest at %s", [datetime()]);
        </query>
        <query>
            CALL apoc.periodic.iterate(
                "
                    WITH 'mysql_artrelations' as url_alias,
                    '
                        SELECT id, track_id, name, type
                        FROM track_artist
                        WHERE track_id IS NOT NULL
                    ' 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
                    WITH ta
                    MATCH (t:Track:Orchard {id: ta.trackId})
                    MATCH (t)-[:IS_PLACEMENT_OF]-(sr:SoundRecording)
                    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
                    MERGE (lp)-[tp:PARTICIPATED_IN {participated_as: ta.type}]->(t)
                    MERGE (lp)-[srp:PARTICIPATED_IN {participated_as: ta.type}]->(sr)
                    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-232_rebuild_label_participant:9" author="savva" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of track_writer ingest at %s", [datetime()]);
        </query>
        <query>
            CALL apoc.periodic.iterate(
                "
                    WITH 'mysql_artrelations' as url_alias,
                    '
                        SELECT track_writer_id, unique_track_id, writer_name
                        FROM track_writer
                        WHERE unique_track_id IS NOT NULL
                    ' as sql
                    CALL apoc.load.jdbc(url_alias, sql)
                    YIELD row
                    RETURN row
                ",
                "
                    MERGE (tw:TrackWriter {id: toInteger(row.track_writer_id)})
                        SET
                            tw.uniqueTrackId = toInteger(row.unique_track_id),
                            tw.writerName = row.writer_name
                    WITH tw
                    MATCH (t:Track:Orchard {id: tw.uniqueTrackId})
                    MATCH (t)-[:IS_PLACEMENT_OF]-(sr:SoundRecording)
                    MATCH (p:Product:Orchard)-[r:INCLUDES]->(t)
                    MATCH (pr:Project)-[r1:INCLUDES]->(p)
                    WHERE exists(pr.subaccountId)
                    MERGE (t)-[:HAS_SOURCE_ARTIST]->(tw)
                    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(tw.writerName, '[ ]{2,}', ' ')),
                            vendorId: pr.vendorId,
                            subaccountId: pr.subaccountId
                        }
                    )
                        ON CREATE SET lp.id = i.id
                    MERGE (lp)-[:PARTICIPATED_IN {participated_as: 'track_writer'}]->(t)
                    MERGE (lp)-[:PARTICIPATED_IN {participated_as: 'track_writer'}]->(sr)
                    MERGE (lp)-[cf:CREATED_FROM]->(tw)
                        ON CREATE SET cf.created_at = datetime()
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished track_writer ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-232_rebuild_label_participant:10" author="savva" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of creating relationships between label participant and labels at %s", [datetime()]);
        </query>
        <query>
            CALL apoc.periodic.iterate(
                "
                    MATCH (lp:LabelParticipant) RETURN lp
                ",
                "
                    MERGE (v:Vendor {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 {id: lp.subaccountId})
                        MERGE (sa)-[:HAS_LABEL_PARTICIPANT]->(lp)
                    )
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished creating relationships between label participant and labels at %s", [datetime()]);
        </query>
    </changeset>
</changelog>
