public ActionResult Index()
{
ScrumTimeEntities scrumTimeEntities = new ScrumTimeEntities();
string currentProductName = "None";
string currentSprintName = "None";
string nextReleaseName = "None";
ProductService productService = new ProductService(scrumTimeEntities);
Product product = productService.GetProductById(SessionHelper.GetCurrentProductId(User.Identity.Name, Session));
if (product != null && product.ProductId > 0)
{
currentProductName = product.Name;
SprintService sprintService = new SprintService(scrumTimeEntities);
Sprint sprint = sprintService.GetSprintById(SessionHelper.GetCurrentSprintId(User.Identity.Name, Session));
if (sprint != null && sprint.SprintId > 0)
{
currentSprintName = sprint.Name;
ReleaseService releaseService = new ReleaseService(scrumTimeEntities);
Release nextRelease = releaseService.GetNextReleaseEqOrAfterDate(sprint.ProductId, sprint.FinishDate);
if (nextRelease != null && nextRelease.ReleaseId > 0)
{
nextReleaseName = nextRelease.Name;
}
}
}
DashboardViewModel dashboardViewModel = new DashboardViewModel()
{
CurrentProductName = currentProductName,
CurrentSprintName = currentSprintName,
NextReleaseName = nextReleaseName
};
return(PartialView(dashboardViewModel));
}
/// <summary>
/// Initializes a new instance of the <see cref="HomeController" /> class.
/// </summary>
/// <param name="leaveService">The leave service.</param>
/// <param name="timesheetService">The timesheet service.</param>
/// <param name="lookupService">The lookup service.</param>
/// <param name="releaseService">The release service.</param>
public HomeController(LeaveService leaveService, TimesheetService timesheetService, LookupService lookupService, ReleaseService releaseService)
{
this.leaveService = leaveService;
this.timesheetService = timesheetService;
this.lookupService = lookupService;
this.releaseService = releaseService;
}
public async Task <IActionResult> Download(SubsonicRequest request)
{
var authResult = await AuthenticateUser(request).ConfigureAwait(false);
if (authResult != null)
{
return(Unauthorized());
}
var trackId = request.TrackId;
if (trackId != null)
{
return(await StreamTrack(trackId.Value, TrackService, PlayActivityService, SubsonicUser).ConfigureAwait(false));
}
var releaseId = request.ReleaseId;
if (releaseId != null)
{
var releaseZip = await ReleaseService.ReleaseZipped(SubsonicUser, releaseId.Value).ConfigureAwait(false);
if (!releaseZip.IsSuccess)
{
return(NotFound("Unknown Release id"));
}
return(File(releaseZip.Data, "application/zip", (string)releaseZip.AdditionalData["ZipFileName"]));
}
return(NotFound($"Unknown download id `{request.id}`"));
}
public async void Should_Output_ReleaseNote()
{
// Given
var options = new ReleaseOptions {
MileStone = "v1.0.0", Owner = "root", Repository = "test"
};
var dbContext = EnsureDbCreated(options);
var service = new ReleaseService(dbContext, FakeConsole);
// When
var result = await service.Execute(options, new Mock <IGitHubClient>().Object);
// Then
Assert.Equal(0, result);
Assert.Single(FakeConsole.Messages);
Assert.Equal(
@"As part of this release we had 3 issues closed.
The highest priority among them is ""high"".
### Bug
* Found a bug! #1
* Another bug #2
### Enhancement
* Some improvement on build #3
",
FakeConsole.Messages[0],
ignoreLineEndingDifferences: true);
Assert.Empty(FakeConsole.WarnMessages);
Assert.Empty(FakeConsole.ErrorMessages);
}
public void Initialize()
{
//Need to setup the logger first
if (LoggingEnabled)
LoggerProvider = Options.LoggerProvider ?? new SystemLoggerProviderLog4Net(this);
_logger = LoggerProvider.CreateLogger(typeof(Settings));
//Setting up the rest of the system
_logger.Info("Settings - Setup Started");
_logger.Debug(() => string.Format("Settings - Settings Extension Options - {0}", Options));
var sqlFactory = new SqlFactory();
var feedProvider = new NugetReleaseFeedProvider();
var persistencyProvider = new ReleasePersistencyProvider(sqlFactory);
QueryProvider = new CacheReleaseQueryProvider();
ExistingReleaseService = new ExistingReleaseQueryService(QueryProvider);
NewReleaseService = new NewReleaseQueryService(QueryProvider);
UpdateReleaseRepositoryService = new UpdateReleaseRepositoryService(feedProvider, persistencyProvider);
UpdateReleaseService = new UpdateReleaseService(this, UpdateReleaseRepositoryService, QueryProvider);
ReleaseService = new ReleaseService(QueryProvider);
_logger.Info("Settings - Setup Finished");
//Run system setup
_logger.Info("Settings - Pre Initialize");
UpdateReleaseService.Execute(true);
_logger.Info("Settings - Post Initialize");
}
private void cmdHideProjet_Click(object sender, System.EventArgs e)
{
try
{
if (_IsLoading.Value)
{
return;
}
using (var locker = new BoolLocker(ref _IsLoading))
{
var selectedExternalProject = GetSelectedExternalProject();
if (selectedExternalProject != null)
{
using (var releaseService = new ReleaseService(_Group.GetEnvironment().GetSQLExtendConnectionString()))
{
releaseService.ProcessedExternalProject(selectedExternalProject);
LoadDatagridview();
}
}
}
}
catch (Exception ex)
{
ex.ShowInMessageBox();
}
}
public async void PullRequest_Already_Exists()
{
// Given
var options = new ReleaseOptions {
CreatePullRequest = true, MileStone = "v1.0.0", Owner = "root", Repository = "test"
};
var dbContext = EnsureDbCreated(options);
var service = new ReleaseService(dbContext, FakeConsole);
var gitbucketClient = new Mock <IGitHubClient>();
gitbucketClient
.Setup(g => g.PullRequest.GetAllForRepository(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(new ReadOnlyCollection <Octokit.PullRequest>(new List <Octokit.PullRequest>
{
new FakePullRequest(new FakeGitReference("develop"), new FakeGitReference("master"))
}));
// When
var result = await service.Execute(options, gitbucketClient.Object);
// Then
Assert.Equal(1, result);
Assert.Empty(FakeConsole.Messages);
Assert.Single(FakeConsole.WarnMessages);
Assert.Equal("A pull request already exists for root:develop.", FakeConsole.WarnMessages[0]);
Assert.Empty(FakeConsole.ErrorMessages);
}
public ReleaseDetail GetRelease(ReleaseCriteria criteria)
{
using (var uow = UnitOfWorkFactory.Create <NovelContext>())
{
var service = new ReleaseService(uow);
var detail = service.Get(criteria);
detail.Series = service.View <Series>().Where(w => w.ID == detail.SeriesID).SingleOrDefault() ?? new Series();
detail.Group = service.View <Group>().Where(w => w.ID == detail.GroupID).SingleOrDefault() ?? new Group();
detail.Summarize = service.View <Summarize>().Where(w => w.SourceTable == R.SourceTable.RELEASE && w.SourceID == detail.ID).SingleOrDefault() ?? new Summarize();
// get data for user lists
detail.Connectors = service.View <Connector>().Where(w => w.IsDeleted == false && w.SourceID == detail.SeriesID).ToList();
detail.UserLists = service.View <UserList>().Where(w => w.IsDeleted == false && w.UserID == criteria.ByUserID)
.OrderBy(o => o.Priority == 0 ? int.MaxValue : o.Priority).ThenBy(o => o.Name).ToList();
detail.UserAction = new UserActionFacade().Get(new ViewForm {
UserID = criteria.ByUserID, SourceID = detail.ID, SourceTable = R.SourceTable.RELEASE
});
detail.Sticky = service.View <Sticky>().Where(w => w.SourceID == detail.ID && w.SourceTable == R.SourceTable.RELEASE).SingleOrDefault() ?? new Sticky();
return(detail);
}
}
private void cmdRefresh_Click(object sender, System.EventArgs e)
{
try
{
if (_IsLoading.Value)
{
return;
}
using (var locker = new BoolLocker(ref _IsLoading))
{
var ucMessageBox = new ucMessageBox("Traitement en cours...");
using (var messageBoxForm = new frmUserControl(ucMessageBox, "Traitement", false, false))
{
messageBoxForm.Show();
using (var releaseService = new ReleaseService(_Group.GetEnvironment().GetSQLExtendConnectionString()))
{
releaseService.AddAndUpdateExternalProjectFromFile();
LoadDatagridview();
}
messageBoxForm.Close();
}
}
}
catch (Exception ex)
{
ex.ShowInMessageBox();
}
}
static void Main(string[] args)
{
Configuration config = new Configuration("config.xml");
ReleaseService rs = new ReleaseService();
rs.Credentials = new NetworkCredential(config.codeplex_username, config.codeplex_password);
rs.Timeout = 600000;
string releaseWinX86 = "Windows x86 unstable";
string releaseWinX64 = "Windows x64 unstable";
string releaseDebianX64 = "Debian x64 unstable";
string releaseFreeBSDX64 = "FreeBSD x64 unstable";
string releaseOSX = "OSX x64 unstable";
string releaseUbuntuX64 = "Ubuntu x64 unstable";
string releaseUbuntuX86 = "Ubuntu x86 unstable";
DirectoryInfo di = new DirectoryInfo(config.package_dir);
foreach (FileInfo fi in di.GetFiles("*"))
{
if (fi.Name.Contains("-x86-win"))
{
mkRelease(rs, releaseWinX86, "Automatic nightly Windows x32 build of the unstable branch.");
upload(rs, fi, releaseWinX86, "last_cp_win_x86");
}
else if (fi.Name.Contains("-x64-win"))
{
mkRelease(rs, releaseWinX64, "Automatic nightly Windows x64 build of the unstable branch.");
upload(rs, fi, releaseWinX64, "last_cp_win_x64");
}
else if (fi.Name.Contains("-x64-debian"))
{
mkRelease(rs, releaseDebianX64, "Automatic nightly Debian x64 build of the unstable branch.");
upload(rs, fi, releaseDebianX64, "last_cp_debian_x64");
}
else if (fi.Name.Contains("-x64-freebsd"))
{
mkRelease(rs, releaseFreeBSDX64, "Automatic nightly FreeBSD x64 build of the unstable branch.");
upload(rs, fi, releaseFreeBSDX64, "last_cp_freebsd_x64");
}
else if (fi.Name.Contains("-x64-ubuntu"))
{
mkRelease(rs, releaseUbuntuX64, "Automatic nightly Ubuntu x64 build of the unstable branch.");
upload(rs, fi, releaseUbuntuX64, "last_cp_ubuntu_x64");
}
else if (fi.Name.Contains("-x86-ubuntu"))
{
mkRelease(rs, releaseUbuntuX86, "Automatic nightly Ubuntu x86 build of the unstable branch.");
upload(rs, fi, releaseUbuntuX86, "last_cp_ubuntu_x86");
}
else if (fi.Name.Contains("-x64-osx"))
{
mkRelease(rs, releaseOSX, "Automatic nightly OSX x64 build of the unstable branch.");
upload(rs, fi, releaseOSX, "last_cp_osx_x64");
}
}
}
public int AddRelease(ReleaseForm releaseForm)
{
using (var uow = UnitOfWorkFactory.Create <NovelContext>())
{
var service = new ReleaseService(uow);
return(service.SaveChanges(releaseForm));
}
}
public static void Main(string[] args)
{
ActorModel.Init();
var service = new ReleaseService(new ReleaseProvider(), new TrackProvider());
var command = new ReleaseCreateCommand("test artist", "test", "genre");
service.CreateRelease(command);
BuildWebHost(args).Run();
}
/// <summary>
/// Initializes a new instance of the <see cref="DashboardController"/> class.
/// </summary>
/// <param name="reportService">The report service.</param>
/// <param name="releaseService">The release service.</param>
/// <param name="timesheetService">The timesheet service.</param>
/// <param name="projectComplianceReportService">The project compliance report service.</param>
/// <param name="projectService">The project service.</param>
public DashboardController(ReportService reportService, ReleaseService releaseService, TimesheetService timesheetService, ProjectComplianceReportService projectComplianceReportService, ProjectService projectService)
{
this.reportService = reportService;
this.releaseService = releaseService;
this.timesheetService = timesheetService;
this.projectComplianceReportService = projectComplianceReportService;
this.projectService = projectService;
this.AddBreadcrumbItem(Resources.Dashboard, string.Empty);
}
/// ----------------------------------------------------------------------------------
/// <summary>
/// Compares the version of the calling assembly with the specified app in codebox.
/// If the default version on codebox is newer than the calling assembly's version,
/// then a filled-in CodeboxVersion is returned. Otherwise [null] is returned.
///
/// Note: Likely reasons for thrown exceptions:
/// - codebox is down
/// - bad application name
/// </summary>
/// ----------------------------------------------------------------------------------
public static CodeboxVersion GetNewerVersion(string applicationName)
{
CodeboxVersion newerVersion = null;
Codebox.ReleaseService codebox = new ReleaseService();
codebox.Credentials = System.Net.CredentialCache.DefaultCredentials;
DataTable releases = codebox.GetReleasesByProjectName(applicationName).Tables[0];
var releaseData =
from release in releases.AsEnumerable()
where release.Field <bool>("DefaultRelease") == true
select new
{
Version = release.Field <string>("Version"),
ReleaseDate = release.Field <DateTime>("ReleaseDate"),
Description = release.Field <string>("Description")
};
// If there is no default release found, we abort the check.
if (!releaseData.Any())
{
return(null);
}
string[] networkVersion = releaseData.First().Version.Split('.');
Assembly assembly = Assembly.GetCallingAssembly();
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
string thisAssemblyVersion = fvi.ProductVersion;
string[] myVersion = thisAssemblyVersion.Split('.');
for (int i = 0; i < 4 && i < networkVersion.Length && i < myVersion.Length; i++)
{
int networkNumber = int.Parse(networkVersion[i]);
int myNumber = int.Parse(myVersion[i]);
if (networkNumber < myNumber)
{
break;
}
if (networkNumber > myNumber)
{
newerVersion = new CodeboxVersion()
{
CodeBoxVersion = releaseData.First().Version,
ThisAssemblyVersion = thisAssemblyVersion,
Description = releaseData.First().Description,
ReleaseDate = releaseData.First().ReleaseDate
};
break;
}
}
return(newerVersion);
}
private void btnEditDistReq_Click(object sender, EventArgs e)
{
if (dgvPickUpDropOf.Rows.Count > 0)
{
var VWRel = ReleaseService.GetVWByReleaseId(SelectedReleaseOrder.ReleaseId);
My.MyProject.Forms.FrmAddEditRelease.PopulateInfo(VWRel);
MdlLoadingSetting.showDialogForm(My.MyProject.Forms.FrmAddEditRelease, this);
VWRelOrderPickUpDropOffLocationBindingSource.DataSource = RelOrderPickUpDropOffLocationService.GetByReleaseOrderId(SelectedReleaseOrder.ReleaseOrderId);
}
}
static void mkRelease(ReleaseService rs, string name, string description)
{
try
{
rs.CreateARelease("Z3", name, description, null, ReleaseStatus.Planned, true, false);
}
catch (Exception)
{
}
}
private void LoadDatagridview()
{
using (var releaseService = new ReleaseService(_Group.GetEnvironment().GetSQLExtendConnectionString()))
{
var statusSearch = (ExternalProjectStatusSearchEnum)cboExternalProjectSearch.SelectedValue;
var list = releaseService.GetExternalProjectList(statusSearch).Enum().Select(x => ExternalProjectView.ConvertTo(x)).Enum().ToList();
_ExternalProjetBindingSource.DataSource = list;
lblMessage.Text = "{0} projet(s)".FormatString(list.Count());
}
}
private void btnNewRequest_Click(object sender, EventArgs e)
{
My.MyProject.Forms.FrmAddEditRelease.isNewRelease = true;
My.MyProject.Forms.FrmAddEditRelease.RelReq = RelReq;
My.MyProject.Forms.FrmAddEditRelease.LoadForm();
MdlLoadingSetting.showDialogForm(My.MyProject.Forms.FrmAddEditRelease, this);
RelReq = InboundRequestService.GetVWById(RelReq.InboundRequestId);
ReleaseList = ReleaseService.GetAllVWByInboundReqId(RelReq.InboundRequestId);
checkFollowUpAndWriteOffs();
CalculateQtys();
}
/// <summary>
/// Initializes a new instance of the <see cref="MusicBrainzClient"/> class.
/// </summary>
/// <param name="baseAddress">The base address of the webservice (default = <see cref="ServiceBaseAddress"/>).</param>
/// <param name="proxy">The <see cref="IWebProxy"/> used to connect to the webservice.</param>
public MusicBrainzClient(string baseAddress, IWebProxy proxy)
{
var urlBuilder = new UrlBuilder(true);
Artists = new ArtistService(this, urlBuilder);
Recordings = new RecordingService(this, urlBuilder);
Releases = new ReleaseService(this, urlBuilder);
ReleaseGroups = new ReleaseGroupService(this, urlBuilder);
Work = new WorkService(this, urlBuilder);
client = CreateHttpClient(new Uri(baseAddress), true, proxy);
}
private void bdnSaveRelease_Click(object sender, EventArgs e)
{
{
var withBlock = My.MyProject.Forms.FrmUpdateReqStatus;
withBlock.RelOrderList = ReleaseOrderService.GetAllVWByReleaseId(ReleaseId);
withBlock.cboRelOrder.DataSource = withBlock.RelOrderList;
withBlock.ReleaseList = ReleaseService.GetAllVWByInboundReqId(RelReq.InboundRequestId);
withBlock.VWReleaseBindingSource.DataSource = withBlock.ReleaseList;
}
Close();
}
/// <summary>
/// Initializes a new instance of the <see cref="MusicBrainzClient"/> class.
/// </summary>
/// <param name="httpClient">The <see cref="HttpClient"/> used for request to the webservice.</param>
public MusicBrainzClient(HttpClient httpClient)
{
var urlBuilder = new UrlBuilder(true);
Artists = new ArtistService(this, urlBuilder);
Recordings = new RecordingService(this, urlBuilder);
Releases = new ReleaseService(this, urlBuilder);
ReleaseGroups = new ReleaseGroupService(this, urlBuilder);
Work = new WorkService(this, urlBuilder);
client = httpClient;
}
public void PopulateInfo(VW_InboundRequest req)
{
LoadForm();
firstLoad = true;
btnManageBal.Enabled = true;
RelReq = req;
cbStatus.SelectedValue = req.RequestStatusId;
lblSSLineName.Text = req.SSLineCode;
lblRelType.Text = req.ReleaseType;
lblSize.Text = req.ContainerSizeName;
lblReqDate.Text = req.DateRequested.ToString("dd-MMMd-yyyy");
fu = InboundFollowUpService.GetByOpenInboundRequestId(req.InboundRequestId);
ReleaseList = ReleaseService.GetAllVWByInboundReqId(RelReq.InboundRequestId);
if (!Information.IsNothing(fu))
{
followUpQty = RelReq.TotalQtyAccptOfRequest - SumAddedLocations;
var newRel = new VW_Release();
newRel.ReleaseNumber = "FOLLOW UP";
newRel.TotalQtyAccepted = followUpQty;
pnlFollowUp.Show();
ReleaseList.Add(newRel);
}
var inReqDeclinedList = ReleaseList.Where(r => r.InboundReqDeclinedQtyId != 0).ToList();
if (inReqDeclinedList.Count > 0)
{
InReqDeclined = InboundReqDeclinedQtyService.GetById(inReqDeclinedList[0].InboundReqDeclinedQtyId);
var newRel = new VW_Release();
newRel.ReleaseNumber = InReqDeclined.DeclineStatus;
newRel.TotalQtyAccepted = InReqDeclined.QtyDeclined;
ReleaseList.Add(newRel);
btnManageBal.Enabled = false;
}
VWReleaseBindingSource.DataSource = null;
VWReleaseBindingSource.DataSource = ReleaseList;
dgvRelease.DataSource = null;
dgvRelease.DataSource = VWReleaseBindingSource.DataSource;
if (!Information.IsNothing(dgvRelease.CurrentRow) && dgvRelease.Rows.Count > 0 && InReqDeclined.InboundReqDeclinedQtyId == 0)
{
VW_Release focusedRel = (VW_Release)dgvRelease.CurrentRow.DataBoundItem;
RelOrderList = ReleaseOrderService.GetAllVWByReleaseId(focusedRel.ReleaseId);
cboRelOrder.DataSource = RelOrderList;
cboRelOrder.DisplayMember = "RelOrder";
cboRelOrder.ValueMember = "ReleaseOrderId";
}
firstLoad = false;
CalculateQtys();
}
public async Task CreateAsync_Exception()
{
// Arrange
ReleaseEntity releaseEntity = new ReleaseEntity
{
TagName = "1",
Name = "1",
Body = "test-app",
TargetCommitish = "eec136ac2d31cf984d2053df79f181b99c3b4db5"
};
List <string> buildStatus = new List <string>();
buildStatus.Add(BuildStatus.InProgress.ToEnumMemberAttributeValue());
buildStatus.Add(BuildStatus.NotStarted.ToEnumMemberAttributeValue());
List <string> buildResult = new List <string>();
buildResult.Add(BuildResult.Succeeded.ToEnumMemberAttributeValue());
_releaseRepository.Setup(r => r.Get(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
buildStatus,
buildResult)).ReturnsAsync(GetReleases("createdRelease.json"));
ReleaseService releaseService = new ReleaseService(
_httpContextAccessor.Object,
new Mock <IAzureDevOpsBuildClient>().Object,
_releaseRepository.Object,
new TestOptionsMonitor <AzureDevOpsSettings>(GetAzureDevOpsSettings()),
_releaseLogger.Object);
// Act
HttpRequestWithStatusException resultException = null;
try
{
await releaseService.CreateAsync(releaseEntity);
}
catch (HttpRequestWithStatusException e)
{
resultException = e;
}
// Assert
Assert.NotNull(resultException);
Assert.Equal(HttpStatusCode.Conflict, resultException.StatusCode);
}
public void GetLatestPublishedRelease_PublicationIdNotFound()
{
var builder = new DbContextOptionsBuilder <StatisticsDbContext>();
builder.UseInMemoryDatabase(Guid.NewGuid().ToString());
var options = builder.Options;
using (var context = new StatisticsDbContext(options, null))
{
var service = new ReleaseService(context, new Mock <ILogger <ReleaseService> >().Object);
var result = service.GetLatestPublishedRelease(Guid.NewGuid());
Assert.Null(result);
}
}
public async void Get_null_record()
{
var mock = new ServiceMockFacade <IReleaseRepository>();
mock.RepositoryMock.Setup(x => x.Get(It.IsAny <string>())).Returns(Task.FromResult <Release>(null));
var service = new ReleaseService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.ReleaseModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLReleaseMapperMock,
mock.DALMapperMockFactory.DALReleaseMapperMock);
ApiReleaseResponseModel response = await service.Get(default(string));
response.Should().BeNull();
mock.RepositoryMock.Verify(x => x.Get(It.IsAny <string>()));
}
public async Task <FileResult> M3uForRelease(Guid id)
{
var user = await CurrentUserModel().ConfigureAwait(false);
var release = await ReleaseService.ById(user, id, new string[1] {
"tracks"
}).ConfigureAwait(false);
if (release?.IsNotFoundResult != false)
{
Response.StatusCode = (int)HttpStatusCode.NotFound;
}
var m3u = M3uHelper.M3uContentForTracks(release.Data.Medias.SelectMany(x => x.Tracks));
return(File(Encoding.Default.GetBytes(m3u), "audio/mpeg-url"));
}
public async void ByIdChannelIdProjectVariableSetSnapshotIdProjectDeploymentProcessSnapshotIdJSONProjectIdVersionAssembled_Not_Exists()
{
var mock = new ServiceMockFacade <IReleaseRepository>();
mock.RepositoryMock.Setup(x => x.ByIdChannelIdProjectVariableSetSnapshotIdProjectDeploymentProcessSnapshotIdJSONProjectIdVersionAssembled(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <DateTimeOffset>())).Returns(Task.FromResult <List <Release> >(new List <Release>()));
var service = new ReleaseService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.ReleaseModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLReleaseMapperMock,
mock.DALMapperMockFactory.DALReleaseMapperMock);
List <ApiReleaseResponseModel> response = await service.ByIdChannelIdProjectVariableSetSnapshotIdProjectDeploymentProcessSnapshotIdJSONProjectIdVersionAssembled(default(string), default(string), default(string), default(string), default(string), default(string), default(string), default(DateTimeOffset));
response.Should().BeEmpty();
mock.RepositoryMock.Verify(x => x.ByIdChannelIdProjectVariableSetSnapshotIdProjectDeploymentProcessSnapshotIdJSONProjectIdVersionAssembled(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <DateTimeOffset>()));
}
static void upload(ReleaseService rs, FileInfo fi, string release, string checkfile)
{
if (isNewer(checkfile, fi.FullName))
{
Console.WriteLine("Uploading " + release + "...");
ReleaseFile f = new ReleaseFile();
f.Name = fi.Name;
f.MimeType = "application/octet-stream";
f.FileName = fi.Name;
f.FileType = ReleaseFileType.RuntimeBinary;
f.FileData = File.ReadAllBytes(fi.FullName);
List <ReleaseFile> files = new List <ReleaseFile>();
files.Add(f);
rs.UploadReleaseFiles("Z3", release, files, f.Name);
}
}
private void btnRmRel_Click(object sender, EventArgs e)
{
SelectedRelease = (VW_Release)dgvRelease.CurrentRow.DataBoundItem;
if (SelectedRelease.ReleaseNumber != "FOLLOW UP" && InReqDeclined.InboundReqDeclinedQtyId == 0)
{
var result = My.MyProject.Forms.MessageBoxCeresYesNo.ShowDialog("Are you sure you want to do this?", "This can not be undone. All releases order and assignments to Minibookings will be removed.", My.Resources.Resources.warning, this);
if (result == DialogResult.Yes)
{
var RelService = new ReleaseService();
if (RelService.Delete(SelectedRelease.ReleaseId))
{
ReleaseList.Remove(SelectedRelease);
}
}
}
else if (SelectedRelease.ReleaseNumber == "FOLLOW UP")
{
if (!Information.IsNothing(fu) && fu.InboundFollowUpRequestId != 0)
{
if (fuService.AddOrUpdate(fu))
{
followUpQty = 0;
fu.isOpenFollowUp = Conversions.ToBoolean(0);
ReleaseList.Remove(SelectedRelease);
}
}
else
{
ReleaseList.Remove(SelectedRelease);
}
}
else
{
var idqs = new InboundReqDeclinedQtyService();
if (idqs.Delete(InReqDeclined.InboundReqDeclinedQtyId))
{
ReleaseList.Remove(SelectedRelease);
}
}
dgvRelease.DataSource = null;
VWReleaseBindingSource.DataSource = null;
VWReleaseBindingSource.DataSource = ReleaseList;
dgvRelease.DataSource = VWReleaseBindingSource.DataSource;
CalculateQtys();
}
public async void ByVersionProjectId_Exists()
{
var mock = new ServiceMockFacade <IReleaseRepository>();
var record = new Release();
mock.RepositoryMock.Setup(x => x.ByVersionProjectId(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(record));
var service = new ReleaseService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.ReleaseModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLReleaseMapperMock,
mock.DALMapperMockFactory.DALReleaseMapperMock);
ApiReleaseResponseModel response = await service.ByVersionProjectId(default(string), default(string));
response.Should().NotBeNull();
mock.RepositoryMock.Verify(x => x.ByVersionProjectId(It.IsAny <string>(), It.IsAny <string>()));
}
public async void Milestone_Has_Issue_Without_Labels()
{
// Given
var options = new ReleaseOptions {
MileStone = "v1.0.0", Owner = "root", Repository = "test"
};
var dbContextOptions = new DbContextOptionsBuilder <GitBucketDbContext>()
.UseInMemoryDatabase(databaseName: "Milestone_Has_Issue_Without_Labels")
.Options;
var dbContext = new GitBucketDbContext(dbContextOptions);
dbContext.Issues.Add(new Core.Models.Issue
{
Milestone = new Core.Models.Milestone
{
RepositoryName = options.Repository,
Title = options.MileStone,
UserName = options.Owner,
},
RepositoryName = options.Repository,
UserName = options.Owner,
OpenedUserName = "******",
Title = "Implement xxx feature",
});
dbContext.SaveChanges();
var service = new ReleaseService(dbContext, FakeConsole);
// When
var result = await service.Execute(options, new Mock <IGitHubClient>().Object);
// Then
Assert.Equal(1, result);
Assert.Single(FakeConsole.Messages);
Assert.Equal("", FakeConsole.Messages[0]);
Assert.Equal(3, FakeConsole.WarnMessages.Count);
Assert.Equal("There are unclosed issues in \"v1.0.0\".", FakeConsole.WarnMessages[0]);
Assert.Equal("Do you want to continue?([Y]es/[N]o): yes", FakeConsole.WarnMessages[1]);
Assert.Equal("There are issues which have no labels in \"v1.0.0\".", FakeConsole.WarnMessages[2]);
Assert.Empty(FakeConsole.ErrorMessages);
}
public async void Create()
{
var mock = new ServiceMockFacade <IReleaseRepository>();
var model = new ApiReleaseRequestModel();
mock.RepositoryMock.Setup(x => x.Create(It.IsAny <Release>())).Returns(Task.FromResult(new Release()));
var service = new ReleaseService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.ReleaseModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLReleaseMapperMock,
mock.DALMapperMockFactory.DALReleaseMapperMock);
CreateResponse <ApiReleaseResponseModel> response = await service.Create(model);
response.Should().NotBeNull();
mock.ModelValidatorMockFactory.ReleaseModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiReleaseRequestModel>()));
mock.RepositoryMock.Verify(x => x.Create(It.IsAny <Release>()));
}
public async void ByProjectDeploymentProcessSnapshotId_Exists()
{
var mock = new ServiceMockFacade <IReleaseRepository>();
var records = new List <Release>();
records.Add(new Release());
mock.RepositoryMock.Setup(x => x.ByProjectDeploymentProcessSnapshotId(It.IsAny <string>())).Returns(Task.FromResult(records));
var service = new ReleaseService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.ReleaseModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLReleaseMapperMock,
mock.DALMapperMockFactory.DALReleaseMapperMock);
List <ApiReleaseResponseModel> response = await service.ByProjectDeploymentProcessSnapshotId(default(string));
response.Should().NotBeEmpty();
mock.RepositoryMock.Verify(x => x.ByProjectDeploymentProcessSnapshotId(It.IsAny <string>()));
}
/// <summary>
/// Initializes a new instance of the <see cref="AuthenticationController" /> class.
/// </summary>
/// <param name="developerService">The developer service.</param>
/// <param name="leaveService">The leave service.</param>
/// <param name="timesheetService">The timesheet service.</param>
/// <param name="releaseService">The release service.</param>
/// <param name="lookupService">The lookup service.</param>
public AuthenticationController(DeveloperService developerService, LeaveService leaveService, TimesheetService timesheetService, ReleaseService releaseService, LookupService lookupService)
{
this.developerService = developerService;
this.leaveService = leaveService;
this.timesheetService = timesheetService;
this.releaseService = releaseService;
this.lookupService = lookupService;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProjectDashboardController"/> class.
/// </summary>
/// <param name="projectService">The project service.</param>
/// <param name="projectHourReportService">The project hour report service.</param>
/// <param name="releaseService">The release service.</param>
/// <param name="projectArtifactService">The project artifact service.</param>
/// <param name="lookupService">The lookup service.</param>
/// <param name="teamEngagementService">The team engagement service.</param>
/// <param name="reportService">The report service.</param>
/// <param name="developerService">The developer service.</param>
/// <param name="taskService">The task service.</param>
public ProjectDashboardController(ProjectService projectService, ProjectHourReportService projectHourReportService, ReleaseService releaseService, ProjectArtifactService projectArtifactService, LookupService lookupService, TeamEngagementService teamEngagementService, ReportService reportService, DeveloperService developerService, TaskService taskService)
{
this.projectService = projectService;
this.projectHourReportService = projectHourReportService;
this.releaseService = releaseService;
this.projectArtifactService = projectArtifactService;
this.lookupService = lookupService;
this.teamEngagementService = teamEngagementService;
this.reportService = reportService;
this.developerService = developerService;
this.taskService = taskService;
}
/// <summary>
/// Initializes a new instance of the ReleaseCalendarController class.
/// </summary>
/// <param name="releaseService">Release service instance</param>
/// <param name="lookupService">The lookup service.</param>
/// <param name="projectService">The project service.</param>
public ReleaseCalendarController(ReleaseService releaseService, LookupService lookupService, ProjectService projectService)
{
this.releaseService = releaseService;
this.lookupService = lookupService;
this.projectService = projectService;
}
/// <summary>
/// Initializes a new instance of the <see cref="ReportController" /> class.
/// </summary>
/// <param name="projectHourReportService">The project hour report service.</param>
/// <param name="lookupService">The lookup service.</param>
/// <param name="timesheetReportService">The timesheet report service.</param>
/// <param name="timesheetService">The timesheet service.</param>
/// <param name="teamEngagementReportService">The team engagement report service.</param>
/// <param name="teamEngagementService">The team engagement service.</param>
/// <param name="projectService">The project service.</param>
/// <param name="projectComplianceReportService">The project compliance report service.</param>
/// <param name="developerService">The developer service.</param>
/// <param name="reportService">The report service.</param>
/// <param name="releaseService">The release service.</param>
/// <param name="feedbackService">The feedback service.</param>
public ReportController(ProjectHourReportService projectHourReportService, LookupService lookupService, TimesheetReportService timesheetReportService, TimesheetService timesheetService, TeamEngagementReportService teamEngagementReportService, TeamEngagementService teamEngagementService, ProjectService projectService, ProjectComplianceReportService projectComplianceReportService, DeveloperService developerService, ReportService reportService, ReleaseService releaseService, FeedbackService feedbackService)
{
this.projectHourReportService = projectHourReportService;
this.lookupService = lookupService;
this.timesheetReportService = timesheetReportService;
this.timesheetService = timesheetService;
this.teamEngagementReportService = teamEngagementReportService;
this.projectService = projectService;
this.projectComplianceReportService = projectComplianceReportService;
this.developerService = developerService;
this.releaseService = releaseService;
this.reportService = reportService;
this.feedbackService = feedbackService;
this.teamEngagementService = teamEngagementService;
}
