22f3b1b0c2d7ea49cbe84baa32fab19205027010
braney
  Thu Apr 24 13:40:02 2025 -0700
work on vetted and not liftable list

diff --git src/hg/lib/trackHub.c src/hg/lib/trackHub.c
index 8ce0a440f5d..49a4758b099 100644
--- src/hg/lib/trackHub.c
+++ src/hg/lib/trackHub.c
@@ -1508,34 +1508,63 @@
     trashDirDateFile(&hubTn, "quickLift", "hub", ".txt");
     hubName = cloneString(hubTn.forCgi);
     cartSetString(cart, buffer, hubName);
     }
 
 FILE *f = mustOpen(hubName, "w");
 outHubHeader(f, db);
 fclose(f);
 
 if (fd >= 0)
     close(fd);
 
 return hubName;
 }
 
+static char *vettedTracks[] =
+/* tracks that have been tested with quickLift */
+{
+"decipherSnvs",
+"omimLocation",
+"omimAvSnp",
+"ncbiRefSeq",
+"clinvar",
+"clinvarSubLolly",
+"pubsBlat",
+"pubsMarkerBand",
+"pubsMarkerSnp",
+"pubsMarkerGene",
+};
+
 static boolean isVetted(char *track)
 /* Is this a track that's been tested with quickLift?  If not we don't want to do the special name handling on the track. */
 {
-return sameString(track, "decipherSnvs")|| sameString(track, "omimLocation") || sameString(track, "omimAvSnp")|| sameString(track, "ncbiRefSeq")|| sameString(track, "clinvar")|| sameString(track, "clinvarSubLolly");
+static bool inited = FALSE;
+static struct hash *vettedHash = NULL;
+
+if (!inited)
+    {
+    vettedHash = newHash(10);
+
+    int ii;
+    int len = sizeof(vettedTracks) / sizeof(char *);
+
+    for(ii = 0; ii < len; ii++)
+        hashStore(vettedHash, vettedTracks[ii]);
+    }
+
+return hashLookup(vettedHash, track) != NULL;
 }
 
 static void dumpTdbAndChildren(struct dyString *dy, struct trackDb *tdb)
 /* Put a trackDb entry into a dyString, stepping up the tree for some variables. */
 {
 struct hashCookie cookie = hashFirst(tdb->settingsHash);
 struct hashEl *hel;
 while ((hel = hashNext(&cookie)) != NULL)
     {   
     if (differentString(hel->name, "track"))
         {
         if (sameString(hel->name, "parent") || sameString(hel->name, "html"))
             dyStringPrintf(dy, "%s %s\n", hel->name, trackHubSkipHubName((char *)hel->val));
         else
             dyStringPrintf(dy, "%s %s\n", hel->name, ((char *)hel->val));
@@ -1616,148 +1645,149 @@
 
 // add a note that the name based handler shouldn't be used on this track
 // add a note that this is a quickLifted track so the browser will accept tracks that aren't big*
 dy = dyStringNew(200);
 char *track =  trackHubSkipHubName(tdb->track);
 dyStringPrintf(dy, "track %s\nquickLifted on\n", track);
 
 if (!isVetted(track))
     dyStringPrintf(dy, "avoidHandler on\n");
     
 dumpTdbAndChildren(dy, tdb);
 
 return dy;
 }
 
-static boolean validateOneTdb(char *db, struct trackDb *tdb)
+static boolean validateOneTdb(char *db, struct trackDb *tdb, struct trackDb **badList)
 /* Make sure the tdb is a track type we grok. */
 {
 if (!( startsWith("bigBed", tdb->type) || \
        startsWith("bigWig", tdb->type) || \
        startsWith("bigDbSnp", tdb->type) || \
        startsWith("bigGenePred", tdb->type) || \
        startsWith("gvf", tdb->type) || \
        startsWith("genePred", tdb->type) || \
+       startsWith("narrowPeak", tdb->type) || \
        startsWith("bigLolly", tdb->type) || \
        startsWith("bed ", tdb->type)))
     {
-    //printf("%s not included: bad type %s\n",tdb->track,tdb->type);
+    printf("%s %s<BR>\n",tdb->track,tdb->type);
     return FALSE;
     }
 
 // make sure we have a bigDataUrl
 if (startsWith("bigBed", tdb->type) || \
        startsWith("bigWig", tdb->type))
     {
     char *fileName = cloneString(trackDbSetting(tdb, "bigDataUrl"));
 
     if (fileName == NULL)
         {
         struct sqlConnection *conn = hAllocConnTrack(db, tdb);
         fileName = bbiNameFromSettingOrTable(tdb, conn, tdb->table);
         hashAdd(tdb->settingsHash, "bigDataUrl", fileName);
         }
     }
 
 return TRUE;
 }
 
-static struct trackDb * validateTdbChildren(struct cart *cart, char *db, struct trackDb *tdb)
+static struct trackDb * validateTdbChildren(struct cart *cart, char *db, struct trackDb *tdb, struct trackDb **badList)
 /* return a list of the children that can be quick lifted */
 {
 struct trackDb *validTdbs = NULL;
 struct trackDb *nextTdb;
 unsigned count = 0;
 
 if (tdb->subtracks)  // this is a view, descend again
     {
     struct trackDb *view = tdb;
     for (; view; view = nextTdb)
         {
         nextTdb = view->next;
-        view->subtracks = validateTdbChildren(cart, db,view->subtracks);
+        view->subtracks = validateTdbChildren(cart, db,view->subtracks, badList);
 
         if (view->subtracks != NULL)
             {
             slAddHead(&validTdbs, view);
             if (view->visibility)
                 count++;
             }
         }
     }
 else
     {
     for(; tdb; tdb = nextTdb)
         {
         nextTdb = tdb->next;
-        if (validateOneTdb(db, tdb))
+        if (validateOneTdb(db, tdb, badList))
             {
             slAddHead(&validTdbs, tdb);
             if (isSubtrackVisible(cart, tdb))
                 count++;
             }
         }
     }
 if (count)
     return validTdbs;
 
 return NULL;
 }
 
-static boolean validateTdb(struct cart *cart, char *db, struct trackDb *tdb)
+static boolean validateTdb(struct cart *cart, char *db, struct trackDb *tdb, struct trackDb **badList)
 // make sure we only output track types that can
 // be quickLifted.  Return true if we any tracks survive
 {
 if (tdb->subtracks)
     {
-    tdb->subtracks = validateTdbChildren(cart, db, tdb->subtracks);
+    tdb->subtracks = validateTdbChildren(cart, db, tdb->subtracks, badList);
 
     if (tdb->subtracks == NULL)
         return FALSE;
     return TRUE;
     }
 
-return validateOneTdb(db, tdb);
+return validateOneTdb(db, tdb, badList);
 }
 
-static void walkTree(FILE *f, char *db, struct cart *cart,  struct trackDb *tdb, struct dyString *visDy)
+static void walkTree(FILE *f, char *db, struct cart *cart,  struct trackDb *tdb, struct dyString *visDy, struct trackDb **badList)
 /* walk tree looking for visible tracks. */
 {
 for(; tdb; tdb = tdb->next)
     {
     boolean isVisible = FALSE;
 
     if (tdb->parent == NULL)  // not in super track
         {
         char *cartVis = cartOptionalString(cart, tdb->track);
         if (cartVis != NULL)
             {
             tdb->visibility = hTvFromString(cartVis);
             }
         isVisible =  tdb->visibility != tvHide;
         }
     else if (isParentVisible(cart, tdb) &&  isSubtrackVisible(cart, tdb)) // child of supertrack
         {
         char *cartVis = cartOptionalString(cart, tdb->parent->track);
         if (cartVis != NULL)
             tdb->visibility = hTvFromString(cartVis);
         else if (tdbIsSuperTrack(tdb->parent))
             tdb->visibility = tdb->parent->isShow;
         isVisible = TRUE;
         }
 
-    if (isVisible && validateTdb(cart, db, tdb))
+    if (isVisible && validateTdb(cart, db, tdb, badList))
         {
         dyStringPrintf(visDy, "&%s=%s", trackHubSkipHubName(tdb->track),hStringFromTv(tdb->visibility));
         //if (hashLookup(tdb->settingsHash, "customized") == NULL)
             {
             hashRemove(tdb->settingsHash, "maxHeightPixels");
             hashRemove(tdb->settingsHash, "superTrack");
             hashRemove(tdb->settingsHash, "subGroups");
             hashRemove(tdb->settingsHash, "polished");
             hashRemove(tdb->settingsHash, "noInherit");
             hashRemove(tdb->settingsHash, "group");
             hashRemove(tdb->settingsHash, "parent");
             }
 
         //hashReplace(tdb->settingsHash, "customized", "on");
 
@@ -1765,43 +1795,43 @@
         char *tdbType = trackDbSetting(tdb, "tdbType");
         if (tdbType != NULL)
             {
             hashReplace(tdb->settingsHash, "type", tdbType);
             hashReplace(tdb->settingsHash, "shortLabel", trackDbSetting(tdb, "name"));
             hashReplace(tdb->settingsHash, "longLabel", trackDbSetting(tdb, "description"));
             }
 
         struct dyString *dy = trackDbString(tdb);
 
         fprintf(f, "%s\n", dy->string);
         }
     }
 }
 
-char *trackHubBuild(char *db, struct cart *cart, struct dyString *visDy)
+char *trackHubBuild(char *db, struct cart *cart, struct dyString *visDy, struct trackDb **badList)
 /* Build a track hub using trackDb and the cart. */
 {
 struct  trackDb *tdbList;
 struct grp *grpList;
 cartTrackDbInit(cart, &tdbList, &grpList, FALSE);
 
 char *filename = getHubName(cart, db);
 
 FILE *f = mustOpen(filename, "a");
 chmod(filename, 0666);
 
-walkTree(f, db, cart, tdbList, visDy);
+walkTree(f, db, cart, tdbList, visDy, badList);
 fclose(f);
 
 return cloneString(filename);
 }
 
 struct grp *trackHubGetGrps()
 /* Get the groups defined by attached track hubs. */
 {
 return trackHubGrps;
 }
 
 struct trackDb *trackHubAddTracksGenome(struct trackHubGenome *hubGenome)
 /* Load up stuff from data hub and return list. */
 {
 /* Load trackDb.ra file and make it into proper trackDb tree */