def writeReleaseRevisions(inputFile, control):
# initialise IDCounter to 1
requestNewCdifId()
inputFile = open(inputFile, 'r')
releaseRevisionDict = ReleaseRevisionDictionary()
buildReleaseRevisionDict(inputFile, releaseRevisionDict)
inputFile.close()
revisionReleaseFile = open("revisionBelongsToRelease.txt", 'w')
# first build up the relations
revisionBelongsToRelease = {}
releases = {}
revisions = {}
importReleases(releases)
importRevisions(revisions)
for releaseRevisionEntity in releaseRevisionDict.entityDict.values():
addReleaseRevisionEntity(releaseRevisionEntity, revisionBelongsToRelease, \
releases, revisions)
indices = revisionBelongsToRelease.keys()
indices.sort()
for revisionId in indices:
releaseList = revisionBelongsToRelease[revisionId]
releaseList.sort()
for releaseId in releaseList:
info = str(revisionId) + "\t" + str(releaseId) + "\n"
revisionReleaseFile.write(info)
revisionReleaseFile.close()
return EX_OK
def writeSourceFiles(inputFile, control):
# initialise IDCounter to 1
requestNewCdifId()
inputFile = open(inputFile, 'r')
fileDict = SourceFileDictionary()
buildFileDict(inputFile, fileDict, control)
inputFile.close()
# first build up the relations
modules = [] # moduleName (moduleId = index(moduleName)+1)
fileBelongsToModule = {} # fileId x moduleId
moduleBelongsToModule = {} # childModuleId x parentModuleId
for fileEntity in fileDict.entityDict.values():
addFileEntity(fileEntity, modules, fileBelongsToModule,
moduleBelongsToModule)
# then write everything to file
modules_file = open("modulesWithIDs.txt", 'w')
for moduleName in modules:
moduleId = "M" + ` modules.index(moduleName) + 1 `
moduleInfo = moduleId + "\t\"" + moduleName + "\"\n"
modules_file.write(moduleInfo)
modules_file.close()
moduleBelongsToModule_file = open("moduleBelongsToModule.txt", 'w')
moduleIndices = moduleBelongsToModule.keys()
moduleIndices.sort()
for childModuleId in moduleIndices:
parentModuleId = "M" + ` moduleBelongsToModule[childModuleId] `
moduleBelongsToModuleInfo = "M" + ` childModuleId ` + "\t" + parentModuleId + "\n"
moduleBelongsToModule_file.write(moduleBelongsToModuleInfo)
moduleBelongsToModule_file.close()
files_file = open("filesWithIDs.txt", 'w')
timeFile = open("artefactTime.txt", 'a')
for fileEntity in fileDict.entityDict.values():
fileId = fileEntity.getCdifId()
uniqueName = fileEntity.getUniqueName()
fileInfo = str(fileId) + "\t\"" + uniqueName + "\"\n"
files_file.write(fileInfo)
fileCreationTime = convertTimeToUNIX(fileEntity.getCreationTime())
timeInfo = str(fileId) + "\t\"" + str(fileCreationTime)
timeFile.write(timeInfo)
files_file.close()
timeFile.close()
fileBelongsToModule_file = open("fileBelongsToModule.txt", 'w')
fileIndices = fileBelongsToModule.keys()
fileIndices.sort()
for fileId in fileIndices:
parentModuleId = "M" + ` fileBelongsToModule[fileId] `
fileBelongsToModuleInfo = str(fileId) + "\t" + parentModuleId + "\n"
fileBelongsToModule_file.write(fileBelongsToModuleInfo)
fileBelongsToModule_file.close()
return EX_OK
def add(self, revisionEntity):
if (not revisionEntity.isDeletion()
) and revisionEntity.getCdifId() == None:
revisionEntity.setCdifId(requestNewCdifId())
self.entityDict[revisionEntity.getDbId()] = revisionEntity
timeKey = (revisionEntity.getCreationTime(), revisionEntity.getDbId())
self.dictByTime[timeKey] = revisionEntity.getDbId()
def addPreBuiltEntity(self, transactionEntity):
if transactionEntity.getCdifId() == None:
transactionEntity.setCdifId(requestNewCdifId())
if transactionEntity.getTransactionNumber() == None:
transactionEntity.setTransactionNumber(
self.requestNewTransaction())
self.dictByName[transactionEntity.getUniqueName()] = transactionEntity
self.dictByNumber[
transactionEntity.getTransactionNumber()] = transactionEntity
def add(self, fileEntity):
filePath = '/' + fileEntity.getPath()
if filePath in self.fileRevisionDict:
if not fileEntity in self.entityDict.values():
fileEntity.setCdifId(requestNewCdifId())
self.entityDict[fileEntity.getCdifId()] = fileEntity
return True
return False
def add(self, releaseEntity):
if releaseEntity.getCdifId() == None:
releaseEntity.setCdifId(requestNewCdifId())
self.entityDict[releaseEntity.getDbId()] = releaseEntity
def add(self, systemVersionEntity):
if systemVersionEntity.getCdifId() == None:
systemVersionEntity.setCdifId(requestNewCdifId())
self.entityDict[systemVersionEntity.getCdifId()] = systemVersionEntity
def writeRevisions(inputFile, control):
# initialise IDCounter to 1
requestNewCdifId()
inputFile = open(inputFile, 'r')
revisionDict = RevisionDictionary()
buildRevisionDict(inputFile, revisionDict, control)
inputFile.close()
revisionsFile = open("revisionsWithIDs.txt", 'w')
timeFile = open("artefactTime.txt", 'a')
nextFile = open("artefactNext.txt", 'a')
previousFile = open("artefactPrevious.txt", 'a')
fileFile = open("revisionOfFile.txt", 'w')
authorFile = open("revisionBelongsToAuthor.txt", 'w')
changesFile = open("revisionBelongsToTransaction.txt", 'w')
deletesFile = open("revisionDeletedByTransaction.txt", 'w')
# first build up the relations
revisionOfFile = {}
revisionBelongsToAuthor = {}
artefactNext = {}
artefactPrevious = {}
revisionBelongsToTransaction = {}
revisionDeletedByTransaction = {}
authors = {}
files = {}
transactions = {}
importAuthors(authors)
importFiles(files)
importTransactions(transactions, False)
for revisionEntity in revisionDict.entityDict.values():
addRevisionEntity(revisionEntity, revisionOfFile, revisionBelongsToAuthor, \
artefactNext, artefactPrevious, revisionBelongsToTransaction, \
revisionDeletedByTransaction, revisionDict, authors, files, \
transactions)
revisionId = revisionEntity.getCdifId()
revisionIdentifier = revisionEntity.getUniqueName()
revisionInfo = str(revisionId) + "\t\"" + revisionIdentifier + "\"\n"
revisionsFile.write(revisionInfo)
revisionTime = convertTimeToUNIX(revisionEntity.getCreationTime())
timeInfo = str(revisionId) + "\t\"" + str(revisionTime) + "\"\n"
timeFile.write(timeInfo)
revisionsFile.close()
timeFile.close()
indices = revisionOfFile.keys()
indices.sort()
for revisionId in indices:
fileId = revisionOfFile[revisionId]
revisionOfFileInfo = str(revisionId) + "\t" + str(fileId) + "\n"
fileFile.write(revisionOfFileInfo)
fileFile.close()
indices = revisionBelongsToAuthor.keys()
indices.sort()
for revisionId in indices:
authorId = revisionBelongsToAuthor[revisionId]
revisionBelongsToAuthorInfo = str(revisionId) + "\t" + str(
authorId) + "\n"
authorFile.write(revisionBelongsToAuthorInfo)
authorFile.close()
indices = artefactNext.keys()
indices.sort()
for revisionId in indices:
nextId = artefactNext[revisionId]
nextInfo = str(revisionId) + "\t" + str(nextId) + "\n"
nextFile.write(nextInfo)
nextFile.close()
indices = artefactPrevious.keys()
indices.sort()
for revisionId in indices:
previousId = artefactPrevious[revisionId]
previousInfo = str(revisionId) + "\t" + str(previousId) + "\n"
previousFile.write(previousInfo)
previousFile.close()
indices = revisionBelongsToTransaction.keys()
indices.sort()
for revisionId in indices:
transactionId = revisionBelongsToTransaction[revisionId]
revisionBelongsToTransactionInfo = str(revisionId) + "\t" + str(
transactionId) + "\n"
changesFile.write(revisionBelongsToTransactionInfo)
changesFile.close()
indices = revisionDeletedByTransaction.keys()
indices.sort()
for revisionId in indices:
transactionId = revisionDeletedByTransaction[revisionId]
revisionDeletedByTransactionInfo = str(revisionId) + "\t" + str(
transactionId) + "\n"
deletesFile.write(revisionDeletedByTransactionInfo)
deletesFile.close()
return EX_OK
def writeTransactions(inputFile, control):
# initialise IDCounter to 1
requestNewCdifId()
inputFile = open(inputFile, 'r')
transactionDict = TransactionDictionary()
buildTransactionDict(inputFile, transactionDict, control)
inputFile.close()
transactionsFile = open("transactionsWithIDs.txt", 'w')
timeFile = open("artefactTime.txt", 'a')
latestTimeFile = open("transactionLatesttime.txt", 'w')
nextFile = open("artefactNext.txt", 'a')
previousFile = open("artefactPrevious.txt", 'a')
authorFile = open("transactionBelongsToAuthor.txt", 'w')
# first build up the relations
transactionBelongsToAuthor = {}
artefactNext = {}
artefactPrevious = {}
authors = {}
# build files dictionary
authorsFile = open("authorsWithIDs.txt", 'r')
for line in authorsFile:
line = line.strip()
lineSplittedInTabs = line.split("\t")
authorId = lineSplittedInTabs[0]
authorIdentifier = lineSplittedInTabs[1].split("\"")[1]
if not (authorIdentifier in authors):
authors[authorIdentifier] = authorId
authorsFile.close()
indices = transactionDict.dictByNumber.keys()
indices.sort()
for transactionNumber in indices:
transactionEntity = transactionDict.getEntityByNumber(
transactionNumber)
addTransactionEntity(transactionEntity, transactionBelongsToAuthor, \
artefactNext, artefactPrevious, transactionDict, authors)
transactionId = transactionEntity.getCdifId()
transactionIdentifier = transactionEntity.getUniqueName()
transactionInfo = str(
transactionId) + "\t\"" + transactionIdentifier + "\"\n"
transactionsFile.write(transactionInfo)
transactionTime = convertTimeToUNIX(
transactionEntity.getCreationTime())
timeInfo = str(transactionId) + "\t\"" + str(transactionTime) + "\"\n"
timeFile.write(timeInfo)
latestTime = convertTimeToUNIX(transactionEntity.getLatestTime())
timeInfo = str(transactionId) + "\t\"" + str(latestTime) + "\"\n"
latestTimeFile.write(timeInfo)
transactionsFile.close()
timeFile.close()
latestTimeFile.close()
indices = transactionBelongsToAuthor.keys()
indices.sort()
for transactionId in indices:
authorId = transactionBelongsToAuthor[transactionId]
transactionBelongsToAuthorInfo = str(transactionId) + "\t" + str(
authorId) + "\n"
authorFile.write(transactionBelongsToAuthorInfo)
authorFile.close()
indices = artefactNext.keys()
indices.sort()
for transactionId in indices:
nextId = artefactNext[transactionId]
nextInfo = str(transactionId) + "\t" + str(nextId) + "\n"
nextFile.write(nextInfo)
nextFile.close()
indices = artefactPrevious.keys()
indices.sort()
for transactionId in indices:
previousId = artefactPrevious[transactionId]
previousInfo = str(transactionId) + "\t" + str(previousId) + "\n"
previousFile.write(previousInfo)
previousFile.close()
return EX_OK
def add(self, authorEntity):
if authorEntity.getCdifId() == None:
authorEntity.setCdifId(requestNewCdifId())
self.entityDict[authorEntity.getDbId()] = authorEntity