public async Task FacilityExists_Exists_ReturnsTrue()
{
using var repository = CreateRepositoryHelper().GetFacilityRepository();
var result = await repository.FacilityExistsAsync(RepositoryData.Facilities()[0].Id);
result.ShouldBeTrue();
}
// Other Methods
// =============
/// <exception cref="Kallithea_Klone.MainActionException"></exception>
private async Task Update(RepositoryData location)
{
string remotePath = GetDefaultRemotePath(location.URL);
Uri uri = new Uri(remotePath);
string fullURL = $"{uri.Scheme}://{HttpUtility.UrlEncode(AccountSettings.Username)}:{HttpUtility.UrlEncode(AccountSettings.Password)}@{uri.Host}{uri.PathAndQuery}";
string shelfName = DateTime.Now.ToString(dateTimeFormat);
CMDProcess cmdProcess = new CMDProcess("UPDATE", location.Name, new string[]
{
$"cd /d {location.URL}" +
$"hg --config \"extensions.shelve = \" shelve --name {shelfName} {debugArg}" +
$"hg pull {fullURL} {debugArg}" +
$"hg update -m {debugArg}" +
$"hg --config \"extensions.shelve = \" unshelve --name {shelfName} --tool :other {debugArg}"
});
try
{
await cmdProcess.Run();
}
catch (Exception e)
{
throw new MainActionException("Unable to start the necessary command window process", e);
}
cmdProcess.ReportErrorsAsync(Verb);
}
public async Task <int> MakeUpdatePullRequests(
IGitDriver git,
RepositoryData repository,
IReadOnlyCollection <PackageUpdateSet> updates,
NuGetSources sources,
SettingsContainer settings)
{
int totalCount = 0;
try
{
var groups = UpdateConsolidator.Consolidate(updates,
settings.UserSettings.ConsolidateUpdatesInSinglePullRequest);
foreach (var updateSets in groups)
{
var updatesMade = await MakeUpdatePullRequests(
git, repository,
sources, settings, updateSets);
totalCount += updatesMade;
}
}
catch (Exception ex)
{
_logger.Error("Updates failed", ex);
}
return(totalCount);
}
public async Task CreateRecord_Succeeds()
{
using var repository = CreateRepositoryHelper().GetFacilityRepository();
var record = new RetentionRecord()
{
Active = true,
BoxNumber = "NewBox",
ConsignmentNumber = "CN",
EndYear = 2020,
FacilityId = RepositoryData.Facilities()[0].Id,
RetentionSchedule = "RS",
ShelfNumber = "SN",
StartYear = 2000,
};
var newRecord = new RetentionRecordCreateDto()
{
BoxNumber = record.BoxNumber,
ConsignmentNumber = record.ConsignmentNumber,
EndYear = record.EndYear,
RetentionSchedule = record.RetentionSchedule,
ShelfNumber = record.ShelfNumber,
StartYear = record.StartYear
};
record.Id = await repository.CreateRetentionRecordAsync(record.FacilityId, newRecord);
var result = await repository.GetRetentionRecordAsync(record.Id);
result.Should().BeEquivalentTo(new RetentionRecordDetailDto(record));
}
public async Task UpdatePackageInProjects(
IGitDriver git,
PackageUpdateSet updateSet,
RepositoryData repository)
{
try
{
_logger.Terse(UpdatesLogger.OldVersionsToBeUpdated(updateSet));
git.Checkout(repository.DefaultBranch);
// branch
var branchName = BranchNamer.MakeName(updateSet);
_logger.Verbose($"Using branch name: '{branchName}'");
git.CheckoutNewBranch(branchName);
await UpdateAllCurrentUsages(updateSet);
var commitMessage = CommitWording.MakeCommitMessage(updateSet);
git.Commit(commitMessage);
git.Push("nukeeper_push", branchName);
var prTitle = CommitWording.MakePullRequestTitle(updateSet);
await MakeGitHubPullRequest(updateSet, repository, prTitle, branchName);
git.Checkout(repository.DefaultBranch);
}
catch (Exception ex)
{
_logger.Error("Update failed", ex);
}
}
/// <summary>
/// Private ctor for singleton support.
/// </summary>
private UserData()
{
RepositoryInfo = new RepositoryData();
MainForm = new MainFormData();
View = new ViewData();
ObjectPermissions = new ObjectPermissionsGridData();
}
public static IList <T> LoadAll <T>(this RepositoryData item, SchemaPurpose[] schemaPurposesToInclude = null) where T : RepositoryLocalObjectData
{
Logger.Debug("Loading {0} for {1}", typeof(T).Name, item.Title);
string filename = string.Format("{0} - {1}.txt", typeof(T).Name, item.Title);
var subFolder = "Instances";
var items = FileCache.LoadFromFile <IList <T> >(filename, subFolder);
if (items == null)
{
items = TridionCoreServiceFactory.GetList <T>(item.Id, new RepositoryItemsFilterData
{
BaseColumns = ListBaseColumns.Extended,
ItemTypes = new[] { ItemTypeResolver.GetItemType(typeof(T)) },
Recursive = true,
SchemaPurposes = schemaPurposesToInclude,
ShowNewItems = true
});
//Remove Local Copies
items = items.Where(x => x.BluePrintInfo.IsShared == false || x.BluePrintInfo.IsLocalized == true).ToList();
Logger.Debug("Found {0} {1} for {2}", items.Count, typeof(T).Name, item.Title);
FileCache.SaveToFile(filename, items, subFolder);
}
else
{
Logger.Debug("Loading {0} {1} for {2} from cache", items.Count(), typeof(T).Name, item.Title);
Logger.Debug("CACHE: {0},{1},{2}", items.Count(), typeof(T).Name, item.Title);
}
return(items);
}
private async Task <int> MakeUpdatePullRequests(
IGitDriver git, RepositoryData repository,
NuGetSources sources, SettingsContainer settings,
IReadOnlyCollection <PackageUpdateSet> updates)
{
_logger.Normal(UpdatesLogger.OldVersionsToBeUpdated(updates));
git.Checkout(repository.DefaultBranch);
// branch
var branchName = BranchNamer.MakeName(updates);
_logger.Detailed($"Using branch name: '{branchName}'");
git.CheckoutNewBranch(branchName);
foreach (var updateSet in updates)
{
await _updateRunner.Update(updateSet, sources);
var commitMessage = CommitWording.MakeCommitMessage(updateSet);
git.Commit(commitMessage);
}
git.Push("nukeeper_push", branchName);
var title = CommitWording.MakePullRequestTitle(updates);
var body = CommitWording.MakeCommitDetails(updates);
await _gitHub.CreatePullRequest(repository, title, body, branchName,
settings.SourceControlServerSettings.Labels);
git.Checkout(repository.DefaultBranch);
return(updates.Count);
}
public async Task UpdateFacility_State_Succeeds()
{
const string newState = "Alabama";
var facilityId = RepositoryData.Facilities()[0].Id;
using var repositoryHelper = CreateRepositoryHelper();
using var repository = repositoryHelper.GetFacilityRepository();
var facility = ResourceHelper.GetFacilityDetail(facilityId);
var updates = new FacilityEditDto(facility)
{
State = newState
};
await repository.UpdateFacilityAsync(facilityId, updates);
repositoryHelper.ClearChangeTracker();
var expected = ResourceHelper.GetFacilityDetail(facilityId);
expected.State = newState;
var updatedFacility = await repository.GetFacilityAsync(facilityId);
updatedFacility.Should().BeEquivalentTo(expected);
}
public static IRestResponse CreateRepository(RepositoryData repositoryData)
{
var restApi = CreateRestApiHelper(PostRepo, out var restClient);
var serializeObject = JsonConvert.SerializeObject(repositoryData);
var restRequest = restApi.CreatePostRequest(serializeObject);
return(restApi.GetResponse(restClient, restRequest));
}
/// <summary>
/// Initializes a new instance of the <see cref="Repository"/> class.
/// </summary>
/// <param name="client"><see cref="T:TcmCoreService.Client" /></param>
/// <param name="schemaData"><see cref="T:Tridion.ContentManager.CoreService.Client.RepositoryData" /></param>
protected Repository(Client client, RepositoryData repositoryData)
: base(client, repositoryData)
{
if (repositoryData == null)
throw new ArgumentNullException("repositoryData");
mRepositoryData = repositoryData;
}
/// <summary>
/// Initializes a new instance of the <see cref="Repository"/> class.
/// </summary>
/// <param name="client"><see cref="T:TcmCoreService.Client" /></param>
/// <param name="schemaData"><see cref="T:Tridion.ContentManager.CoreService.Client.RepositoryData" /></param>
protected Repository(Client client, RepositoryData repositoryData) : base(client, repositoryData)
{
if (repositoryData == null)
{
throw new ArgumentNullException("repositoryData");
}
mRepositoryData = repositoryData;
}
public void CreatesNewLineForEachOutputAndFormatsAccordinglyWhenCommitlistIsNull()
{
var expectedOutput = "";
var repositoryData = new RepositoryData(null, "repositoryName", "username");
var formattedData = repositoryData.ToString();
Assert.AreEqual(formattedData, expectedOutput);
}
public async Task FacilityNumberExists_DuplicateIsIgnored_ReturnsFalse()
{
using var repository = CreateRepositoryHelper().GetFacilityRepository();
var ignoreId = RepositoryData.Facilities()[0].Id;
var facName = RepositoryData.Facilities()[0].Name;
var result = await repository.FacilityNumberExists(facName, ignoreId);
result.ShouldBeFalse();
}
public static IRestResponse UpdateRepositoryName(string repositoryName,
RepositoryData repositoryData)
{
var restApi = CreateRestApiHelper(DeleteRepo + repositoryName, out var restClient);
var serializeObject = JsonConvert.SerializeObject(repositoryData);
var restRequest = restApi.CreatePatchRequest(serializeObject);
return(restApi.GetResponse(restClient, restRequest));
}
public async Task GetFacility_ReturnsCorrectFacility()
{
using var repository = CreateRepositoryHelper().GetFacilityRepository();
var facility = RepositoryData.Facilities()[0];
var result = await repository.GetFacilityAsync(facility.Id);
result.Id.Should().Be(facility.Id);
result.Name.Should().Be(facility.Name);
}
public async Task GetFacilityDetailListAsync_DefaultSpec_ReturnsActiveFacilities()
{
using var repository = CreateRepositoryHelper().GetFacilityRepository();
var result = await repository.GetFacilityDetailListAsync(new FacilitySpec());
var expectedCount = RepositoryData.Facilities().Count(e => e.Active);
result.Count.ShouldEqual(expectedCount);
}
public async void GetReleases()
{
if (this.SelectedRepository == null)
{
this.CurrentRepository = null;
return;
}
this.CurrentRepository = await this._client.GetRepository(this.SelectedRepository.Author, this.SelectedRepository.Name);
}
public async Task FacilityCount_DefaultSpec_ReturnsCountOfActiveFacilities()
{
using var repository = CreateRepositoryHelper().GetFacilityRepository();
var spec = new FacilitySpec();
var result = await repository.CountAsync(spec);
var expected = RepositoryData.Facilities().Count(e => e.Active);
result.Should().Be(expected);
}
public void CreatesNewLineForEachOutputAndFormatsAccordinglyWhenOneCommitIsNull()
{
var fakeCommits = new List <GitHubCommit> {
FakeGithubCommit, FakeGithubCommit2, Fake.GetNullCommit()
};
var repositoryData = new RepositoryData(fakeCommits, "repositoryName", "username");
var expectedOutput = "[repositoryName]/[f78a226e32eb6a0320f2003859ed4d08caa53878]: refactoring [svitra]" + Environment.NewLine + "[repositoryName]/[6d95eaea321145383153692a802099577ea74c95]: cr changes [bleble]" + Environment.NewLine + "[repositoryName]/[]: []";
var formattedData = repositoryData.ToString();
Assert.AreEqual(formattedData, expectedOutput);
}
public Task <RepositoryData> RepositoryAsync(CancellationToken cancel = default(CancellationToken))
{
var data = new RepositoryData
{
RepoPath = Path.GetFullPath(ipfs.Options.Repository.Folder),
Version = "1",
StorageMax = 0 // TODO: there is no storage max
};
GetDirStats(data.RepoPath, data, cancel);
return(Task.FromResult(data));
}
public async Task FacilitySearch_DefaultSpec_ReturnsActiveFacilities()
{
using var repository = CreateRepositoryHelper().GetFacilityRepository();
var result = await repository.GetFacilityPaginatedListAsync(new FacilitySpec(), 1, 999);
var expectedCount = RepositoryData.Facilities().Count(e => e.Active);
result.TotalCount.ShouldEqual(expectedCount);
result.Items.Count.ShouldEqual(expectedCount);
result.PageNumber.ShouldEqual(1);
result.TotalPages.ShouldEqual(1);
}
private async Task <int> MakeUpdatePullRequests(
IGitDriver git, RepositoryData repository,
NuGetSources sources, SettingsContainer settings,
IReadOnlyCollection <PackageUpdateSet> updates)
{
_logger.Normal(UpdatesLogger.OldVersionsToBeUpdated(updates));
await git.Checkout(repository.DefaultBranch);
// branch
var branchWithChanges = BranchNamer.MakeName(updates, settings.BranchSettings.BranchNamePrefix);
_logger.Detailed($"Using branch name: '{branchWithChanges}'");
await git.CheckoutNewBranch(branchWithChanges);
foreach (var updateSet in updates)
{
await _updateRunner.Update(updateSet, sources);
var commitMessage = _collaborationFactory.CommitWorder.MakeCommitMessage(updateSet);
await git.Commit(commitMessage);
}
await git.Push(repository.Remote, branchWithChanges);
var title = _collaborationFactory.CommitWorder.MakePullRequestTitle(updates);
var body = _collaborationFactory.CommitWorder.MakeCommitDetails(updates);
string qualifiedBranch;
if (!repository.IsFork) //check if we are on a fork, if so qualify the branch name
{
qualifiedBranch = branchWithChanges;
}
else
{
qualifiedBranch = repository.Push.Owner + ":" + branchWithChanges;
}
var pullRequestRequest = new PullRequestRequest(qualifiedBranch, title, repository.DefaultBranch, settings.BranchSettings.DeleteBranchAfterMerge)
{
Body = body
};
await _collaborationFactory.CollaborationPlatform.OpenPullRequest(repository.Pull, pullRequestRequest, settings.SourceControlServerSettings.Labels);
await git.Checkout(repository.DefaultBranch);
return(updates.Count);
}
public async Task FacilityCount_WithDeleted_ReturnsCountOfAll()
{
using var repository = CreateRepositoryHelper().GetFacilityRepository();
var spec = new FacilitySpec()
{
ShowDeleted = true
};
var result = await repository.CountAsync(spec);
var expected = RepositoryData.Facilities().Count;
result.Should().Be(expected);
}
public static async Task <RepositoryData> GetRepository(this GitHubClient client, string owner, string repoName)
{
var releases = await client.GetReleases(owner, repoName);
var repoInfo = new RepositoryData
{
Author = owner,
Name = repoName,
Releases = releases.ToArray()
};
repoInfo.DownloadCount = repoInfo.Releases.Sum(r => r.Downloads.Sum(d => d.DownloadCount));
return(repoInfo);
}
public async Task UndeleteFacility_Succeeds()
{
var facility = RepositoryData.Facilities().First(e => e.Active);
using var repositoryHelper = CreateRepositoryHelper();
using var repository = repositoryHelper.GetFacilityRepository();
await repository.UndeleteFacilityAsync(facility.Id);
repositoryHelper.ClearChangeTracker();
var updatedFacility = await repository.GetFacilityAsync(facility.Id);
updatedFacility.Active.ShouldBeTrue();
}
public async Task FacilitySearch_BeyondLastPage_ReturnsEmptyList()
{
using var repository = CreateRepositoryHelper().GetFacilityRepository();
var spec = new FacilitySpec()
{
ShowDeleted = true
};
var result = await repository.GetFacilityPaginatedListAsync(spec, 999, 999);
result.TotalCount.ShouldEqual(RepositoryData.Facilities().Count);
result.Items.Count.ShouldEqual(0);
result.PageNumber.ShouldEqual(999);
result.TotalPages.ShouldEqual(1);
}
void GetDirStats(string path, RepositoryData data, CancellationToken cancel)
{
foreach (var file in Directory.EnumerateFiles(path))
{
cancel.ThrowIfCancellationRequested();
++data.NumObjects;
data.RepoSize += (ulong)(new FileInfo(file).Length);
}
foreach (var dir in Directory.EnumerateDirectories(path))
{
cancel.ThrowIfCancellationRequested();
GetDirStats(dir, data, cancel);
}
}
// [InlineData("ghi")] Sqlite is case-sensitive by default
public async Task FacilityCount_ByFacilityNumber_ReturnsCorrectCount(string facilityNumberSpec)
{
using var repository = CreateRepositoryHelper().GetFacilityRepository();
var spec = new FacilitySpec()
{
FacilityNumber = facilityNumberSpec
};
var result = await repository.CountAsync(spec);
var expected = RepositoryData.Facilities()
.Count(e => e.FacilityNumber.ToLower().Contains(facilityNumberSpec.ToLower()) && e.Active);
result.Should().Be(expected);
}
public async Task <RepositoryData> StatisticsAsync(CancellationToken cancel = default)
{
var data = new RepositoryData
{
RepoPath = Path.GetFullPath(_repositoryOptions.Folder),
Version = await VersionAsync(cancel).ConfigureAwait(false),
StorageMax = 10000000000 // TODO: there is no storage max
};
var blockApi = (BlockApi)_blockApi;
GetDirStats(blockApi.Store.Folder, data, cancel);
return(data);
}
// Other Methods
// =============
/// <exception cref="Kallithea_Klone.MainActionException"></exception>
public async Task CloneAsync(Uri host, RepositoryData location)
{
string fullURL = $"{host.Scheme}://{HttpUtility.UrlEncode(AccountSettings.Username)}:{HttpUtility.UrlEncode(AccountSettings.Password)}@{host.Host}{host.PathAndQuery}{location.URL}";
CMDProcess cmdProcess = new CMDProcess("CLONE", location.Name, $"hg clone {fullURL} \"{RunLocation}\\{location.Name}\" {debugArg}");
try
{
await cmdProcess.Run();
}
catch (Exception e)
{
throw new MainActionException("Unable to start the necessary command window process", e);
}
cmdProcess.ReportErrorsAsync(Verb);
}
/// <summary>
/// Reload the <see cref="Repository" /> with the specified <see cref="T:Tridion.ContentManager.CoreService.Client.RepositoryData" />
/// </summary>
/// <param name="repositoryData"><see cref="T:Tridion.ContentManager.CoreService.Client.RepositoryData" /></param>
protected void Reload(RepositoryData repositoryData)
{
if (repositoryData == null)
throw new ArgumentNullException("repositoryData");
mRepositoryData = repositoryData;
base.Reload(repositoryData);
mAccessControlList = null;
mDefaultMultimediaSchema = null;
mLocation = null;
mMetadataSchema = null;
mParents = null;
mRootFolder = null;
mTaskProcess = null;
}
protected override void Initialize(RequestContext requestContext)
{
if (Repository == null) { Repository = new RepositoryData(); }
base.Initialize(requestContext);
}