void htmlFormVarPrint(struct htmlFormVar *var, FILE *f, char *prefix)
/* Print out variable to file, prepending prefix. */
{
struct slName *val;
fprintf(f, "%s%s\t%s\t%s\t%s\n", prefix, var->name, var->tagName,
naForNull(var->type),
naForNull(var->curVal));
for (val = var->values; val != NULL; val = val->next)
fprintf(f, "%s\t%s\n", prefix, val->name);
}
void fullCaption(struct sqlConnection *conn, int id)
/* Print information about image. */
{
char *publication, *copyright;
char *caption = NULL;
int imageFile = -1;
struct slInt *imageList;
int imageCount=0;
int oldId = 0;
struct captionElement *captionElements;
int forwardedId = vgForwardedImage(conn, id);
if (forwardedId)
{
oldId = id;
id = forwardedId;
}
caption = visiGeneCaption(conn, id);
imageFile = visiGeneImageFile(conn, id);
showSource(conn, oldId);
showSource(conn, id);
publication = visiGenePublication(conn,id);
if (publication != NULL)
{
char *pubUrl = visiGenePubUrl(conn,id);
printf("<B>Reference:</B> ");
if (pubUrl != NULL && pubUrl[0] != 0)
printf("<A HREF=\"%s\" target=_blank>%s</A>", pubUrl, publication);
else
{
printf("%s", naForEmpty(publication));
}
printf("<BR>\n");
}
printf("<B>Year:</B> %d ", visiGeneYear(conn,id));
printf("<B>Contributors:</B> %s<BR>\n",
naForNull(visiGeneContributors(conn,id)));
if (caption != NULL)
{
printf("<B>Notes:</B> %s<BR>\n", caption);
freez(&caption);
}
imageList = visiGeneImagesForFile(conn, imageFile);
imageCount = slCount(imageList);
captionElements = makePaneCaptionElements(conn, imageList);
printCaptionElements(conn, captionElements, imageList);
copyright = visiGeneCopyright(conn, id);
if (copyright != NULL)
printf("<B>Copyright:</B> %s<BR>\n", copyright);
showAcknowledgement(conn, oldId);
showAcknowledgement(conn, id);
printf("<BR>\n");
}
static void rTsWriteAsFlatTab(struct tagStanza *list, struct slName *fieldList,
FILE *f, char *idTag, boolean withParent,
int maxDepth, int depth)
/* Recursively write out list to file */
{
if (depth > maxDepth)
return;
struct tagStanza *stanza;
for (stanza = list; stanza != NULL; stanza = stanza->next)
{
char *idVal = NULL;
if (idTag != NULL)
{
idVal = slPairFindVal(stanza->tagList, idTag);
}
if (idTag == NULL || idVal != NULL)
{
struct hash *uniq = hashNew(0);
if (withParent && stanza->parent != NULL && idTag != NULL)
{
char *parentVal = slPairFindVal(stanza->parent->tagList, idTag);
if (parentVal != NULL)
{
hashAdd(uniq, "parent", parentVal);
}
}
struct tagStanza *family;
for (family = stanza; family != NULL; family = family->parent)
{
struct slPair *pair;
for (pair = family->tagList; pair != NULL; pair = pair->next)
{
if (!hashLookup(uniq, pair->name))
{
hashAdd(uniq, pair->name, pair->val);
}
}
}
struct slName *field;
for (field = fieldList; field != NULL; field = field->next)
{
if (field != fieldList)
fputc('\t', f);
char *val = naForNull(hashFindVal(uniq, field->name));
fputs(val, f);
}
fputc('\n', f);
hashFree(&uniq);
}
rTsWriteAsFlatTab(stanza->children, fieldList, f, idTag, withParent, maxDepth, depth+1);
}
}
void doValidatedEmail(struct edwSubmit *submit, boolean isComplete)
/* Send an email with info on all validated files */
{
struct sqlConnection *conn = edwConnect();
struct edwUser *user = edwUserFromId(conn, submit->userId);
struct dyString *message = dyStringNew(0);
/* Is this submission has no new file at all */
if ((submit->oldFiles != 0) && (submit->newFiles == 0) &&
(submit->metaChangeCount == 0) && isEmpty(submit->errorMessage)
&& (submit->fileIdInTransit == 0))
{
dyStringPrintf(message, "Your submission from %s is completed, but validation was not performed for this submission since all files in validate.txt have been previously submitted and validated.\n", submit->url);
mailViaPipe(user->email, "EDW Validation Results", message->string, edwDaemonEmail);
sqlDisconnect(&conn);
dyStringFree(&message);
return;
}
if (isComplete)
dyStringPrintf(message, "Your submission from %s is completely validated\n", submit->url);
else
dyStringPrintf(message,
"Your submission hasn't validated after 24 hours, something is probably wrong\n"
"at %s\n", submit->url);
dyStringPrintf(message, "\n#accession\tsubmitted_file_name\tnotes\n");
char query[512];
sqlSafef(query, sizeof(query),
"select licensePlate,submitFileName "
" from edwFile left join edwValidFile on edwFile.id = edwValidFile.fileId "
" where edwFile.submitId = %u and edwFile.id != %u"
, submit->id, submit->submitFileId);
struct sqlResult *sr = sqlGetResult(conn, query);
char **row;
while ((row = sqlNextRow(sr)) != NULL)
{
char *licensePlate = row[0];
char *submitFileName = row[1];
dyStringPrintf(message, "%s\t%s\t", naForNull(licensePlate), submitFileName);
if (licensePlate == NULL)
{
dyStringPrintf(message, "Not validating");
}
dyStringPrintf(message, "\n");
}
sqlFreeResult(&sr);
mailViaPipe(user->email, "EDW Validation Results", message->string, edwDaemonEmail);
sqlDisconnect(&conn);
dyStringFree(&message);
}
static struct captionElement *makePaneCaptionElements(
struct sqlConnection *conn, struct slInt *imageList)
/* Make list of all caption elements */
{
struct slInt *image;
struct captionElement *ceList = NULL, *ce;
for (image = imageList; image != NULL; image = image->next)
{
int paneId = image->val;
struct slName *geneList = geneProbeList(conn, paneId);
struct slName *genbankRawList = visiGeneGenbank(conn, paneId);
struct slName *genbankUrlList = wrapUrlList(genbankRawList, genbankRawList,
"http://www.ncbi.nlm.nih.gov/entrez/query.fcgi?"
"cmd=Search&db=Nucleotide&term=%s&doptcmdl=GenBank&tool=genome.ucsc.edu");
struct slName *probeList = getProbeList(conn, paneId);
ce = captionElementNew(paneId, "Gene", makeCommaSpacedList(geneList));
ce->hasHtml = TRUE;
slAddHead(&ceList, ce);
ce = captionElementNew(paneId, "Probe", makeCommaSpacedList(probeList));
ce->hasHtml = TRUE;
slAddHead(&ceList, ce);
ce = captionElementNew(paneId, "GenBank", makeCommaSpacedList(genbankUrlList));
slAddHead(&ceList, ce);
ce->hasHtml = TRUE;
ce = captionElementNew(paneId, "Organism", visiGeneOrganism(conn, paneId));
slAddHead(&ceList, ce);
ce = captionElementNew(paneId, "Sex",
naForNull(visiGeneSex(conn, paneId)));
slAddHead(&ceList, ce);
ce = captionElementNew(paneId, "Strain",
naForNull(visiGeneStrain(conn, paneId)));
slAddHead(&ceList, ce);
ce = captionElementNew(paneId, "Genotype",
naForNull(visiGeneHypertextGenotype(conn, paneId)));
ce->hasHtml = TRUE;
slAddHead(&ceList, ce);
ce = captionElementNew(paneId, "Stage", visiGeneStage(conn, paneId, TRUE));
slAddHead(&ceList, ce);
ce = captionElementNew(paneId, "Body Part",
naForNull(visiGeneBodyPart(conn, paneId)));
slAddHead(&ceList, ce);
addExpressionInfo(conn, paneId, &ceList);
ce = captionElementNew(paneId, "Section Type",
naForNull(visiGeneSliceType(conn, paneId)));
slAddHead(&ceList, ce);
ce = captionElementNew(paneId, "Permeablization",
naForNull(visiGenePermeablization(conn, paneId)));
}
slReverse(&ceList);
return ceList;
}
struct htmlPage *quickSubmit(struct htmlPage *basePage,
char *org, char *db, char *group, char *track, char *table,
char *testName, char *button, char *buttonVal)
/* Submit page and record info. Return NULL if a problem. */
{
struct tablesTest *test;
struct qaStatus *qs;
struct htmlPage *page;
// don't get ahead of the botDelay
sleep1000(5000);
verbose(2, "quickSubmit(%p, %s, %s, %s, %s, %s, %s, %s, %s)\n",
basePage, naForNull(org), naForNull(db), naForNull(group),
naForNull(track), naForNull(table), naForNull(testName),
naForNull(button), naForNull(buttonVal));
if (basePage != NULL)
{
if (db != NULL)
htmlPageSetVar(basePage, NULL, "db", db);
if (org != NULL)
htmlPageSetVar(basePage, NULL, "org", org);
if (group != NULL)
htmlPageSetVar(basePage, NULL, hgtaGroup, group);
if (track != NULL)
htmlPageSetVar(basePage, NULL, hgtaTrack, track);
if (table != NULL)
htmlPageSetVar(basePage, NULL, hgtaTable, table);
qs = qaPageFromForm(basePage, basePage->forms,
button, buttonVal, &page);
/*
if (page->forms != NULL)
htmlFormPrint(page->forms, stdout);
*/
test = tablesTestNew(qs, testName, org, db, group, track, table);
}
return page;
}
struct nearTest *nearTestNew(struct qaStatus *status,
char *type, char *sort, char *org, char *db, char *col, char *gene)
/* Save away column test results. */
{
struct nearTest *test;
AllocVar(test);
test->status = status;
test->info[ntiiType] = cloneString(naForNull(type));
test->info[ntiiSort] = cloneString(naForNull(sort));
test->info[ntiiOrg] = cloneString(naForNull(org));
test->info[ntiiDb] = cloneString(naForNull(db));
test->info[ntiiCol] = cloneString(naForNull(col));
test->info[ntiiGene] = cloneString(naForNull(gene));
slAddHead(&nearTestList, test);
return test;
}
struct tablesTest *tablesTestNew(struct qaStatus *status,
char *type, char *org, char *db, char *group,
char *track, char *table)
/* Save away test test results. */
{
struct tablesTest *test;
AllocVar(test);
test->status = status;
test->info[ntiiType] = cloneString(naForNull(type));
test->info[ntiiOrg] = cloneString(naForNull(org));
test->info[ntiiDb] = cloneString(naForNull(db));
test->info[ntiiGroup] = cloneString(naForNull(group));
test->info[ntiiTrack] = cloneString(naForNull(track));
test->info[ntiiTable] = cloneString(naForNull(table));
slAddHead(&tablesTestList, test);
return test;
}
void printCaption(struct sqlConnection *conn, int id, char *geneName)
/* Print information about image. */
{
char query[256];
char **row;
char *treatment, *publication;
char *setUrl, *itemUrl;
printf("<B>gene:</B> %s ", naForNull(geneName));
printf("<B>accession:</B> %s ", naForNull(bioImageAccession(conn,id)));
printf("<B>type:</B> %s<BR>\n", naForNull(bioImageType(conn,id)));
printf("<B>organism:</B> %s ", bioImageOrganism(conn, id));
printf("<B>stage:</B> %s<BR>\n", bioImageStage(conn, id, TRUE));
printf("<B>body part:</B> %s ", naForNull(bioImageBodyPart(conn,id)));
printf("<B>section type:</B> %s<BR>\n", naForNull(bioImageSliceType(conn,id)));
treatment = bioImageTreatment(conn,id);
if (treatment != NULL)
printf("<B>treatment:</B> %s<BR>\n", treatment);
publication = bioImagePublication(conn,id);
if (publication != NULL)
{
char *pubUrl = bioImagePubUrl(conn,id);
printf("<B>reference:</B> ");
if (pubUrl != NULL)
printf("<A HREF=\"%s\" target=_blank>%s</A>", pubUrl, publication);
else
printf("%s", publication);
printf("<BR>\n");
}
printf("<B>contributors:</B> %s<BR>\n", naForNull(bioImageContributors(conn,id)));
setUrl = bioImageSetUrl(conn, id);
itemUrl = bioImageItemUrl(conn, id);
if (setUrl != NULL || itemUrl != NULL)
{
printf("<B>contributor links:</B> ");
if (setUrl != NULL)
printf("<A HREF=\"%s\" target=_blank>image set</A> ", setUrl);
if (itemUrl != NULL)
{
printf("<A HREF=\"");
printf(itemUrl, bioImageSubmitId(conn, id));
printf("\" target=_blank>this image</A>");
}
printf("<BR>\n");
}
}
void encodeExpToTab(char *outExp, char *outSeries, char *outResults)
/* encodeExpToCvDb - Convert encode experiments table to a table more suitable for cvDb. */
{
struct hash *optHash = optionalFieldsHash();
struct mdbObj *mdbList = getMdbList(metaDbs, ArraySize(metaDbs));
struct hash *mdbHash = mdbHashKeyedByExpId(mdbList);
struct hash *seriesHash = hashNew(0);
struct series *seriesList = NULL;
verbose(1, "read %d mdb objects from %s in %d databases\n", mdbHash->elCount, metaTable,
(int)ArraySize(metaDbs));
struct sqlConnection *expDbConn = sqlConnect(expDb);
struct sqlConnection *cvDbConn = sqlConnect(cvDb);
char query[256];
sqlSafef(query, sizeof(query), "select * from %s", expTable);
struct sqlResult *sr = sqlGetResult(expDbConn, query);
FILE *f = mustOpen(outExp, "w");
char **row;
while ((row = sqlNextRow(sr)) != NULL)
{
/* Read in database structure. */
struct encodeExp *ee = encodeExpLoad(row);
/* Much of the data we're processing comes from lists of the form
* "a=aVal b=bVal c=cVal." We'll convert these to id's in the appropriate
* tables and store the IDs in the optCol array declared below. */
int optColCount = ArraySize(expOptionalFields);
int optCol[optColCount];
int i;
for (i=0; i<optColCount; ++i)
optCol[i] = 0;
/* Convert var=val string in encodeExp.expVars into list of slPairs, and loop through it. */
struct slPair *varList = slPairListFromString(ee->expVars, TRUE);
struct slPair *var;
for (var = varList; var != NULL; var = var->next)
{
/* Figure out name of table and the term within that table. */
char *table = var->name;
char *term = var->val;
if (sameString(table, "antibody")) // Deal with antibody special case
{
if (sameString(term, "Control") || sameString(term, "Input")
|| sameString(term, "RevXlinkChromatin") || sameString(term, "ripInput"))
{
table = "control";
}
}
/* If it looks like we have a valid table and term, store result in
* optCol array we'll output soon. */
struct hashEl *hel;
if ((hel = hashLookup(optHash, table)) != NULL)
{
int id = lookupId(cvDbConn, table, term);
if (id == 0)
{
warn("No id in cvDb for %s=%s\n", table, term);
continue;
}
int optColIx = ptToInt(hel->val);
optCol[optColIx] = id;
}
else
verbose(2, "%s %s ?\n", table, term);
}
/* Now we want to process metaDb, which has some info encodeExp does not. */
char *composite = NULL;
char ixAsString[16];
safef(ixAsString, sizeof(ixAsString), "%d", ee->ix);
struct mdbObj *mdb = hashFindVal(mdbHash, ixAsString);
if (mdb != NULL)
{
struct mdbVar *v;
for (v = mdb->vars; v != NULL; v = v->next)
{
/* Look up table and term and change table name if need be */
char *table = v->var;
char *term = v->val;
if (sameString(table, "antibody"))
table = "ab";
else if (sameString(table, "grant"))
table = "grantee";
/* Squirrel away the ever-important composite term for later. */
if (sameString("composite", table))
composite = term;
struct hashEl *hel;
if ((hel = hashLookup(optHash, table)) != NULL)
{
int optColIx = ptToInt(hel->val);
if (optCol[optColIx] == 0) // Only use mdb if encodeExp has no data.
{
int id = lookupId(cvDbConn, table, term);
optCol[optColIx] = id;
}
}
}
}
/* If we've got a composite, then make up a series record. */
if (composite != NULL)
{
assert(mdb != NULL);
struct series *series = hashFindVal(seriesHash, composite);
if (series == NULL)
{
series = seriesFromMdb(mdb, composite);
hashAdd(seriesHash, composite, series);
slAddHead(&seriesList, series);
}
}
if (ee->accession != NULL)
{
/* Write out required fields. Order of required fields
* here needs to follow order in expRequiredFields. */
fprintf(f, "%u", ee->ix);
fprintf(f, "\t%s", ee->updateTime);
fprintf(f, "\t%s", naForNull(composite));
fprintf(f, "\t%s", ee->accession);
fprintf(f, "\t%d", lookupId(cvDbConn, "organism", ee->organism));
fprintf(f, "\t%d", lookupId(cvDbConn, "lab", ee->lab));
fprintf(f, "\t%d", lookupId(cvDbConn, "dataType", ee->dataType));
fprintf(f, "\t%d", lookupId(cvDbConn, "cellType", ee->cellType));
/* Now write out optional fields. */
for (i=0; i<optColCount; ++i)
fprintf(f, "\t%d", optCol[i]);
/* End output record. */
fprintf(f, "\n");
}
}
/* Write out series list to a separate file. */
slReverse(&seriesList);
writeSeriesList(outSeries, seriesList);
/* Write out results to a separate file. */
writeMdbListAsResults(mdbList, outResults);
/* Clean up and go home. */
carefulClose(&f);
sqlFreeResult(&sr);
sqlDisconnect(&expDbConn);
sqlDisconnect(&cvDbConn);
}
void testOneTable(struct htmlPage *trackPage, char *org, char *db,
char *group, char *track, char *table)
/* Test stuff on one table if we haven't already tested this table. */
{
/* Why declared here and not globally? */
static struct hash *uniqHash = NULL;
char fullName[256];
if (uniqHash == NULL)
uniqHash = newHash(0);
safef(fullName, sizeof(fullName), "%s.%s", db, table);
if (!hashLookup(uniqHash, fullName))
{
struct htmlPage *tablePage;
struct htmlForm *mainForm;
hashAdd(uniqHash, fullName, NULL);
verbose(1, "Testing %s %s %s %s %s\n", naForNull(org), db, group, track, table);
tablePage = quickSubmit(trackPage, org, db, group,
track, table, "selectTable", hgtaTable, table);
if (!isObsolete(table) && tablePage != NULL)
{
if ((mainForm = htmlFormGet(tablePage, "mainForm")) == NULL)
{
qaStatusSoftError(tablesTestList->status,
"Couldn't get main form on tablePage for %s %s %s %s", db, group, track, table);
}
else
{
testSchema(tablePage, mainForm, org, db, group, track, table);
testSummaryStats(tablePage, mainForm, org, db, group, track, table);
if (outTypeAvailable(mainForm, "bed"))
{
if (outTypeAvailable(mainForm, "primaryTable"))
{
int rowCount;
rowCount = testAllFields(tablePage, mainForm, org, db, group, track, table);
testOneField(tablePage, mainForm, org, db, group, track, table, rowCount);
testOutSequence(tablePage, mainForm, org, db, group, track, table, rowCount);
testOutBed(tablePage, mainForm, org, db, group, track, table, rowCount);
testOutHyperlink(tablePage, mainForm, org, db, group, track, table, rowCount);
testOutGff(tablePage, mainForm, org, db, group, track, table);
if (rowCount > 0)
testOutCustomTrack(tablePage, mainForm, org, db, group, track, table);
}
}
else if (outTypeAvailable(mainForm, "primaryTable"))
{
/* If BED type is not available then the region will be ignored, and
* we'll end up scanning whole table. Make sure table is not huge
* before proceeding. */
if (tableSize(db, table) < 500000)
{
int rowCount;
rowCount = testAllFields(tablePage, mainForm, org, db, group, track, table);
testOneField(tablePage, mainForm, org, db, group, track, table, rowCount);
}
}
}
htmlPageFree(&tablePage);
}
carefulCheckHeap();
}
}
void hgFlyBase(char *database, char *genesFile)
/* hgFlyBase - Parse FlyBase genes.txt file and turn it into a couple of
* tables. */
{
char *tGene = "fbGene";
char *tSynonym = "fbSynonym";
char *tAllele = "fbAllele";
char *tRef = "fbRef";
char *tRole = "fbRole";
char *tPhenotype = "fbPhenotype";
char *tTranscript = "fbTranscript";
char *tGo = "fbGo";
char *tUniProt = "fbUniProt";
FILE *fGene = hgCreateTabFile(tabDir, tGene);
FILE *fSynonym = hgCreateTabFile(tabDir, tSynonym);
FILE *fAllele = hgCreateTabFile(tabDir, tAllele);
FILE *fRef = hgCreateTabFile(tabDir, tRef);
FILE *fRole = hgCreateTabFile(tabDir, tRole);
FILE *fPhenotype = hgCreateTabFile(tabDir, tPhenotype);
FILE *fTranscript = NULL;
FILE *fGo = hgCreateTabFile(tabDir, tGo);
FILE *fUniProt = hgCreateTabFile(tabDir, tUniProt);
struct lineFile *lf = lineFileOpen(genesFile, TRUE);
struct hash *refHash = newHash(19);
int nextRefId = 0;
int nextAlleleId = 0;
char *line, sub, type, *rest, *s;
char *geneSym = NULL, *geneName = NULL, *geneId = NULL;
int recordCount = 0;
struct slName *synList = NULL, *syn;
int curAllele = 0, curRef = 0;
struct ref *ref = NULL;
struct sqlConnection *conn;
struct hash *goUniqHash = newHash(18);
/* Make table from flybase genes to BGDP transcripts. */
if (doTranscript)
{
fTranscript = hgCreateTabFile(tabDir, tTranscript);
getAllSplices(database, fTranscript);
}
/* Make dummy reference for flybase itself. */
fprintf(fRef, "0\tFlyBase\n");
/* Loop through parsing and writing tab files. */
while (lineFileNext(lf, &line, NULL))
{
sub = line[0];
if (sub == '#')
{
/* End of record. */
++recordCount;
if (geneId == NULL)
errAbort("Record without *z line ending line %d of %s",
lf->lineIx, lf->fileName);
/* Write out synonyms. */
s = naForNull(geneSym);
geneSym = ungreek(s);
freeMem(s);
s = naForNull(geneName);
geneName = ungreek(s);
if (! sameString(s, "n/a"))
freeMem(s);
if (geneSym != NULL && !sameString(geneSym, "n/a"))
slNameStore(&synList, geneSym);
if (geneName != NULL && !sameString(geneName, "n/a"))
slNameStore(&synList, geneName);
for (syn = synList; syn != NULL; syn = syn->next)
{
s = ungreek(syn->name);
fprintf(fSynonym, "%s\t%s\n", geneId, s);
freeMem(s);
}
/* Write out gene record. */
fprintf(fGene, "%s\t%s\t%s\n", geneId, geneSym, geneName);
/* Clean up. */
freez(&geneSym);
freez(&geneName);
freez(&geneId);
slFreeList(&synList);
ref = NULL;
curRef = curAllele = 0;
continue;
}
else if (sub == 0)
errAbort("blank line %d of %s, not allowed in gene.txt",
lf->lineIx, lf->fileName);
else if (isalnum(sub))
errAbort("line %d of %s begins with %c, not allowed",
lf->lineIx, lf->fileName, sub);
type = line[1];
rest = trimSpaces(line+2);
if (sub == '*' && type == 'a')
geneSym = cloneString(rest);
else if (sub == '*' && type == 'e')
geneName = cloneString(rest);
else if (sub == '*' && type == 'z')
{
geneId = cloneString(rest);
if (!startsWith("FBgn", geneId))
errAbort("Bad FlyBase gene ID %s line %d of %s", geneId,
lf->lineIx, lf->fileName);
}
else if (type == 'i' && (sub == '*' || sub == '$'))
{
if (strlen(rest) > 2) /* Avoid short useless ones. */
slNameStore(&synList, rest);
}
else if (sub == '*' && type == 'A')
{
if (geneId == NULL)
errAbort("Allele before geneId line %d of %s",
lf->lineIx, lf->fileName);
curAllele = ++nextAlleleId;
fprintf(fAllele, "%d\t%s\t%s\n", curAllele, geneId, rest);
if (!sameString(rest, "classical") &&
!sameString(rest, "in vitro") &&
!sameString(rest, "wild-type") )
{
slNameStore(&synList, rest);
}
}
else if (sub == '*' && type == 'm')
{
if (geneId == NULL)
errAbort("*m protein ID before geneId line %d of %s",
lf->lineIx, lf->fileName);
if (startsWith("UniProt", rest))
{
char *ptr = strchr(rest, ':');
if (ptr != NULL)
ptr++;
else
errAbort("Trouble parsing UniProt ID %s like %d of %s",
rest, lf->lineIx, lf->fileName);
fprintf(fUniProt, "%s\t%s\n", geneId, ptr);
}
}
else if (type == 'E')
{
ref = hashFindVal(refHash, rest);
if (ref == NULL)
{
AllocVar(ref);
ref->id = ++nextRefId;
hashAdd(refHash, rest, ref);
subChar(rest, '\t', ' ');
fprintf(fRef, "%d\t%s\n", ref->id, rest);
}
curRef = ref->id;
}
else if ((type == 'k' || type == 'r' || type == 'p') && sub != '@')
{
FILE *f = (type == 'r' ? fRole : fPhenotype);
struct dyString *dy = suckSameLines(lf, line);
subChar(dy->string, '\t', ' ');
if (geneId == NULL)
errAbort("Expecting *z in record before line %d of %s",
lf->lineIx, lf->fileName);
fprintf(f, "%s\t%d\t%d\t%s\n", geneId, curAllele, curRef, dy->string);
dyStringFree(&dy);
}
else if (type == 'd' || type == 'f' || type == 'F')
{
FILE *f = fGo;
char aspect = (type == 'd') ? 'P' : (type == 'f') ? 'C' : 'F';
char *goId = rest;
char *p = strstr(goId, " ; ");
char assoc[128];
if (p == NULL)
continue;
else
goId = firstWordInLine(p + 3);
safef(assoc, sizeof(assoc), "%s.%s", geneId, goId);
if (hashLookup(goUniqHash, assoc) == NULL)
{
hashAddInt(goUniqHash, assoc, 1);
fprintf(f, "%s\t%s\t%c\n", geneId, goId, aspect);
}
}
}
printf("Processed %d records in %d lines\n", recordCount, lf->lineIx);
lineFileClose(&lf);
conn = sqlConnect(database);
remakeTables(conn);
if (doLoad)
{
printf("Loading %s\n", tGene);
hgLoadTabFile(conn, tabDir, tGene, &fGene);
if (doTranscript)
{
printf("Loading %s\n", tTranscript);
hgLoadTabFile(conn, tabDir, tTranscript, &fTranscript);
}
printf("Loading %s\n", tSynonym);
hgLoadTabFile(conn, tabDir, tSynonym, &fSynonym);
printf("Loading %s\n", tAllele);
hgLoadTabFile(conn, tabDir, tAllele, &fAllele);
printf("Loading %s\n", tRef);
hgLoadTabFile(conn, tabDir, tRef, &fRef);
printf("Loading %s\n", tRole);
hgLoadTabFile(conn, tabDir, tRole, &fRole);
printf("Loading %s\n", tPhenotype);
hgLoadTabFile(conn, tabDir, tPhenotype, &fPhenotype);
printf("Loading %s\n", tGo);
hgLoadTabFile(conn, tabDir, tGo, &fGo);
printf("Loading %s\n", tUniProt);
hgLoadTabFile(conn, tabDir, tUniProt, &fUniProt);
hgRemoveTabFile(tabDir, tGene);
if (doTranscript)
hgRemoveTabFile(tabDir, tTranscript);
hgRemoveTabFile(tabDir, tSynonym);
hgRemoveTabFile(tabDir, tAllele);
hgRemoveTabFile(tabDir, tRef);
hgRemoveTabFile(tabDir, tRole);
hgRemoveTabFile(tabDir, tPhenotype);
hgRemoveTabFile(tabDir, tGo);
hgRemoveTabFile(tabDir, tUniProt);
}
}
