public DeveloperExpertise FindOrCreateDeveloperExpertise(ExpertiseDBEntities repository, int developerId, int artifactId, bool isInferred)
{
DeveloperExpertise developerExpertise = repository.DeveloperExpertises.SingleOrDefault(
de => de.DeveloperId == developerId && de.ArtifactId == artifactId);
if (developerExpertise == null)
{
lock (developerExpertiseLocksOnArtifacts.acquireLock(developerId + "-" + artifactId))
{
using (ExpertiseDBEntities freshRepository = new ExpertiseDBEntities())
{
developerExpertise = freshRepository.DeveloperExpertises.SingleOrDefault(
de => de.DeveloperId == developerId && de.ArtifactId == artifactId);
if (null == developerExpertise)
{
developerExpertise = freshRepository.DeveloperExpertises.Add(
new DeveloperExpertise
{
ArtifactId = artifactId,
DeveloperId = developerId,
Inferred = isInferred
});
freshRepository.SaveChanges();
}
}
}
developerExpertiseLocksOnArtifacts.releaseLock(developerId + "-" + artifactId);
developerExpertise = repository.DeveloperExpertises
.Single(de => de.DeveloperId == developerId && de.ArtifactId == artifactId); // re-retrieve from original repository
}
return(developerExpertise);
}
/// <summary>
/// Stores multiple expertise values for one artifact.
/// </summary>
/// <param name="filename">The name of the artifact for which the experts are sought</param>
/// <param name="devIdsWithExpertiseValues">A dictionary that maps DeveloperIds to expertise values</param>
protected void storeDeveloperExpertiseValues(string filename, IEnumerable <DeveloperWithExpertise> devIdsWithExpertiseValues)
{
using (var repository = new ExpertiseDBEntities())
{
int artifactId = SourceRepositoryManager.FindOrCreateArtifact(repository, filename, ArtifactTypeEnum.File).ArtifactId;
bool fNewAdditions = false;
foreach (DeveloperWithExpertise devExpertise in devIdsWithExpertiseValues)
{
if (fNewAdditions)
{
repository.SaveChanges(); // The Entity Framework does not seem to like it if multiple new entries are added in the above way.
fNewAdditions = false; // Therefore we save after additions.
}
DeveloperExpertise developerExpertise = SourceRepositoryManager.FindOrCreateDeveloperExpertise(repository, devExpertise.DeveloperId, artifactId, true);
fNewAdditions |= 0 == developerExpertise.DeveloperExpertiseId; // hack: is it a new DeveloperExpertise?
DeveloperExpertiseValue devExpertiseValue = FindOrCreateDeveloperExpertiseValue(developerExpertise);
devExpertiseValue.Value = devExpertise.Expertise;
fNewAdditions |= 0 == devExpertiseValue.DeveloperExpertiseValueId; // hack: is it a new DeveloperExpertiseValue?
}
repository.SaveChanges();
}
}
public override void AddReviewScore(string authorName, IList <string> involvedFiles, DateTime dateOfReview)
{
if (dateOfReview < RunUntil)
{
return; // prevent double evaluation of reviews
}
if (dateOfReview <= RunUntil.AddSeconds(1) && // Add one second to prevent errors from time skew
(lastAuthor == authorName || // no reviewer can review two patches at the same time.
null == lastAuthor)) // If this is a resume and the first review, we assume that two reviews will not take place at the same time (which is very seldom, if ever, the case)
{
log.Warn("Skipping a review weighting that happened at " + dateOfReview.ToUniversalTime().ToString("u")
+ " by " + authorName + ", because the last review was at (nearly) the same time, at " + RunUntil.ToUniversalTime().ToString("u")
+ ", and had the author " + (lastAuthor ?? "(no author, first after resume)"));
return;
}
lastAuthor = authorName;
int numberOfFiles = involvedFiles.Count;
IEnumerable <int> idReviewers = FindOrCreateDeveloperFromDevelopernameApproximation(authorName); // usually just one
// write to tree
foreach (int reviewerId in idReviewers)
{
FpsTree.AddReview(reviewerId, involvedFiles);
// write to DB
foreach (string reviewedFileName in involvedFiles)
{
using (var repository = new ExpertiseDBEntities())
{
DeveloperExpertise devExpertise = SourceRepositoryManager.FindOrCreateDeveloperExpertise(repository, reviewerId, reviewedFileName, ArtifactTypeEnum.File, true);
DeveloperExpertiseValue currentWeightedReviewValue = FindOrCreateDeveloperExpertiseValue(devExpertise);
if (double.IsNaN(currentWeightedReviewValue.Value))
{
currentWeightedReviewValue.Value = (1D / numberOfFiles);
}
else
{
currentWeightedReviewValue.Value += (1D / numberOfFiles);
}
repository.SaveChanges();
}
}
}
RunUntil = dateOfReview;
}
protected DeveloperExpertiseValue FindOrCreateDeveloperExpertiseValue(DeveloperExpertise developerExpertise)
{
DeveloperExpertiseValue dev = developerExpertise.DeveloperExpertiseValues.SingleOrDefault(
devCandidate => devCandidate.AlgorithmId == AlgorithmId);
if (null == dev)
{
dev = new DeveloperExpertiseValue
{
AlgorithmId = AlgorithmId,
DeveloperExpertiseId = developerExpertise.DeveloperExpertiseId
};
developerExpertise.DeveloperExpertiseValues.Add(dev);
}
return(dev);
}
public override void CalculateExpertiseForFile(string filename)
{
Debug.Assert(MaxDateTime != DateTime.MinValue, "Initialize MaxDateTime first");
Debug.Assert(SourceRepositoryManager != null, "Initialize SourceRepositoryManager first");
if (!SourceRepositoryManager.FileExists(filename))
{
ClearExpertiseForAllDevelopers(filename); // the file does not exist in the repository, so nobody has experience
return;
}
int filenameId = SourceRepositoryManager.GetFilenameIdFromFilenameApproximation(filename);
using (var entities = new ExpertiseDBEntities())
{
DeveloperWithEditTime lastUser = entities.GetUserForLastRevisionOfBefore(filenameId, MaxDateTime);
if (lastUser == null) // the file exists but is has not been edited until MaxDateTime. Thus, nobody has expertise.
{
ClearExpertiseForAllDevelopers(filename);
return;
}
IEnumerable <DeveloperWithEditTime> listOfLastDevelopers = Deduplicator.DeanonymizeAuthor(lastUser.User)
.Select(clearName => new DeveloperWithEditTime()
{
User = clearName, Time = lastUser.Time
}); // probably just one, but maybe more
foreach (DeveloperWithEditTime oneOfTheLastDevelopers in listOfLastDevelopers)
{
int developerId = entities.Developers.Single(d => d.Name == oneOfTheLastDevelopers.User && d.RepositoryId == RepositoryId).DeveloperId;
DeveloperExpertise developerExpertise = SourceRepositoryManager.FindDeveloperExpertiseWithArtifactName(entities, developerId, filename);
var expertiseValue = FindOrCreateDeveloperExpertiseValue(developerExpertise);
expertiseValue.Value = oneOfTheLastDevelopers.Time.UTCDateTime2unixTime();
}
entities.SaveChanges();
}
}
public override void CalculateExpertiseForFile(string filename)
{
int artifactId = SourceRepositoryManager.FindOrCreateFileArtifactId(filename);
using (var repository = new ExpertiseDBEntities())
{
var developers = repository.DeveloperExpertises
.Where(de => de.ArtifactId == artifactId && de.Inferred == false && (de.DeliveriesCount > 0 || de.IsFirstAuthor))
.Select(de => de.DeveloperId)
.Distinct().ToList();
foreach (var developerId in developers)
{
DeveloperExpertise developerExpertise = repository.DeveloperExpertises.Include(de => de.DeveloperExpertiseValues).Single(de => de.DeveloperId == developerId && de.ArtifactId == artifactId);
DeveloperExpertiseValue expertiseValue = FindOrCreateDeveloperExpertiseValue(developerExpertise);
expertiseValue.Value = developerExpertise.DeliveriesCount + (developerExpertise.IsFirstAuthor ? 1f : 0f);
}
repository.SaveChanges();
}
}
public override void CalculateExpertiseForFile(string filename)
{
List <int> allExpertiseIDs;
int artifactId = SourceRepositoryManager.FindOrCreateFileArtifactId(filename);
using (var repository = new ExpertiseDBEntities())
{
allExpertiseIDs = repository.DeveloperExpertises.Include(de => de.Artifact)
.Where(de => de.Artifact.RepositoryId == RepositoryId && de.Artifact.ArtifactId == artifactId &&
de.Inferred == false && (de.DeliveriesCount > 0 || de.IsFirstAuthor)) // this filters reset DeveloperExpertises with no direct expertise
.Select(de => de.DeveloperExpertiseId).ToList();
}
using (var repository = new ExpertiseDBEntities())
{
foreach (var developerExpertiseId in allExpertiseIDs)
{
DeveloperExpertise developerExpertise = repository.DeveloperExpertises.Include(de => de.Artifact).Include(de => de.DeveloperExpertiseValues).Single(de => de.DeveloperExpertiseId == developerExpertiseId);
int firstAuthorship = developerExpertise.IsFirstAuthor ? 1 : 0;
double fistAuthorshipValue = firstAuthorWeighting * firstAuthorship;
double deliveriesValue = delivieresWeighting * developerExpertise.DeliveriesCount;
double acceptancesValue = acceptanceWeighting * Math.Log(1 + developerExpertise.Artifact.ModificationCount - (developerExpertise.DeliveriesCount + firstAuthorship));
double expertise = constantSummand + fistAuthorshipValue + deliveriesValue + acceptancesValue;
DeveloperExpertiseValue expertiseValue = FindOrCreateDeveloperExpertiseValue(developerExpertise);
expertiseValue.Value = expertise;
repository.SaveChanges();
}
}
}
