/// <summary>
/// Function to edit release.
/// </summary>
/// <param name="calendarId">The calendar id</param>
/// <returns>Edit view</returns>
public ActionResult Edit(string calendarId)
{
ReleaseCalendarPresenter presenter = new ReleaseCalendarPresenter();
presenter.IsEdit = "true";
if (!string.IsNullOrEmpty(calendarId))
{
presenter.ReleaseCalendar = this.releaseService.LoadById(Convert.ToInt32(calendarId, CultureInfo.CurrentCulture));
presenter.OldProjectId = presenter.ReleaseCalendar.ProjectID;
presenter.ActualStartDate = presenter.ReleaseCalendar.StartDate.ToString("M/d/yyyy h:mm tt");
presenter.IsEditable = LookupService.IsReleaseEditable(presenter.ReleaseCalendar.Status);
if (presenter.IsEditable != true || presenter.ReleaseCalendar.Status != 1)
{
return this.Redirect(RetrieveItemAddress(Url.ViewReleaseAction(), presenter.ReleaseCalendar.ReleaseCalendarID));
}
this.AssignValuesToPresenter(presenter);
presenter.ProjectsExcludePipeline.ForEach(p => { p.ProjectName = p.ProjectFullName; });
var historyListItems = this.releaseService.RetrieveHistory(Convert.ToInt32(calendarId, CultureInfo.CurrentCulture));
if (historyListItems != null && historyListItems.Count > 0)
{
AssignHistoryItems(presenter, historyListItems);
}
presenter.AssignArtifacts(this.lookupService.RetrieveReleaseArtifactList(presenter.ReleaseCalendar.ReleaseCalendarID, SessionData.Instance.UserInfo.Developer.DeveloperID));
AssignReleaseArtifactList(presenter);
AssignProjectArtifactList(presenter);
presenter.IsSendNotification = presenter.ReleaseCalendar.Environment == (byte)ReleaseType.Production ? true : false;
presenter.SelectedReleaseStatus = presenter.ReleaseCalendar.Status;
presenter.OldEndDate = presenter.ReleaseCalendar.EndDate.Value.ToString("M/d/yyyy h:mm tt");
this.AddBreadcrumbItem(Resources.ReleaseCalendar, RetrieveCalendarAddress(Url.ReleaseCalendarAction(), presenter.ReleaseCalendar.StartDate));
this.AddBreadcrumbItem(Resources.DayView, RetrieveCalendarAddress(Url.DayViewAction(), presenter.ReleaseCalendar.StartDate));
this.AddBreadcrumbItem(Resources.ViewRelease, RetrieveItemAddress(Url.ViewReleaseAction(), presenter.ReleaseCalendar.ReleaseCalendarID));
this.AddBreadcrumbItem(Resources.EditRelease, Url.EditReleaseAction());
}
if (presenter.ReleaseCalendar == null)
{
return this.Redirect(Url.AddReleaseAction());
}
return this.View("InsertOrUpdate", presenter);
}
/// <summary>
/// Assigns the project release type counts.
/// </summary>
/// <param name="presenter">The presenter.</param>
/// <param name="isMonthView">if set to <c>true</c> [is month view].</param>
private void AssignProjectReleaseTypeCounts(ReleaseCalendarPresenter presenter, bool isMonthView)
{
IList<int> selectedIds = presenter.SelectedProjects.Count > 0 ? presenter.SelectedProjects.Select(selectedProject => selectedProject.ProjectID).ToList() : null;
IList<ReleaseCountListItem> releaseCounts = null;
if (isMonthView)
{
releaseCounts = this.releaseService.RetrieveReleaseCountForMonth(presenter.SelectedDate, null, selectedIds, SessionData.Instance.UserInfo.Developer.DeveloperID);
}
else
{
var startDate = presenter.SelectedDate.Date;
var endDate = startDate.AddDays(1).AddMinutes(-1);
releaseCounts = this.releaseService.RetrieveReleaseCount(null, selectedIds, startDate, endDate, SessionData.Instance.UserInfo.Developer.DeveloperID);
}
UpdateCounts(presenter, releaseCounts);
}
/// <summary>
/// Function to add new release.
/// </summary>
/// <param name="date">Current date details.</param>
/// <param name="projectId">Current project Id.</param>
/// <returns>Add view</returns>
public ActionResult Add(string date, int? projectId)
{
DateTime dateTime = ConvertToDateTime(date);
this.AddBreadcrumbItem(Resources.ReleaseCalendar, RetrieveCalendarAddress(Url.ReleaseCalendarAction(), dateTime));
this.AddBreadcrumbItem(Resources.DayView, RetrieveCalendarAddress(Url.DayViewAction(), dateTime));
this.AddBreadcrumbItem(Resources.AddRelease, Url.AddReleaseAction());
var applicationSettings = DependencyInjectionContainer.Instance.Container.Resolve<ApplicationSettings>();
ReleaseCalendarPresenter presenter = new ReleaseCalendarPresenter() { ReleaseCalendar = new ReleaseCalendar() };
presenter.ReleaseCalendar.StartDate = dateTime.Date.Add(applicationSettings.DefaultReleaseStartTime);
presenter.ReleaseCalendar.EndDate = presenter.ReleaseCalendar.StartDate.Add(applicationSettings.DefaultEndTimeDuration);
presenter.ReleaseCalendar.ProjectID = projectId.HasValue ? projectId.Value : presenter.ReleaseCalendar.ProjectID;
this.AssignValuesToPresenter(presenter);
var timeZone = presenter.TimeZoneList.FirstOrDefault(t => t.TimeZoneID == SessionData.Instance.UserInfo.Developer.TimeZoneID);
presenter.ReleaseCalendar.TimeZoneID = timeZone != null ? timeZone.TimeZoneID : presenter.ReleaseCalendar.TimeZoneID;
presenter.ProjectsExcludePipeline.ForEach(p => { p.ProjectName = p.ProjectFullName; });
var result = this.lookupService.RetrieveReleaseArtifactList(null, SessionData.Instance.UserInfo.Developer.DeveloperID);
result.Where(item => item.ArtifactType.Value == ArtifactType.Release).ToList().ForEach(item => item.IsSelected = true);
presenter.AssignArtifacts(result);
AssignReleaseArtifactList(presenter);
AssignProjectArtifactList(presenter);
return this.View("InsertOrUpdate", presenter);
}
/// <summary>
/// Assigns the type of the selected release.
/// </summary>
/// <param name="releaseCalendarPresenter">The release calendar presenter.</param>
private static void AssignSelectedReleaseType(ReleaseCalendarPresenter releaseCalendarPresenter)
{
bool isNothingSelected = !releaseCalendarPresenter.ProjectReleaseTypes.Any(item => item.IsSelected.Equals("true", StringComparison.OrdinalIgnoreCase));
if (isNothingSelected)
{
releaseCalendarPresenter.ProjectReleaseTypes[0].IsSelected = "true";
}
else
{
bool isAllSelected = releaseCalendarPresenter.ProjectReleaseTypes.Where(releaseType => releaseType.Id == 0).Select(releaseType => releaseType.IsSelected.Equals("true", StringComparison.OrdinalIgnoreCase) ? true : false).FirstOrDefault();
if (isAllSelected)
{
releaseCalendarPresenter.ProjectReleaseTypes.Where(releaseType => releaseType.Id != 0).Select(releaseType => releaseType.IsSelected = "false").ToList();
}
}
}
/// <summary>
/// Updates the counts.
/// </summary>
/// <param name="releaseCalendarPresenter">The release calendar presenter.</param>
/// <param name="releaseCounts">The release counts.</param>
private static void UpdateCounts(ReleaseCalendarPresenter releaseCalendarPresenter, IList<ReleaseCountListItem> releaseCounts)
{
if (releaseCounts != null)
{
releaseCalendarPresenter.ProjectReleaseTypes.ForEach(item => item.TotalCount = 0);
releaseCounts.SelectMany(releaseCount =>
releaseCalendarPresenter.ProjectReleaseTypes.Where(releaseType => releaseType.Id == Convert.ToInt32(releaseCount.Enviornment, CultureInfo.CurrentCulture) && releaseCount.ReleaseCalendarCount.HasValue)
.Select(releaseType => releaseType.TotalCount = releaseType.TotalCount + releaseCount.ReleaseCalendarCount.Value).ToList()).ToList();
var totalCount = releaseCalendarPresenter.ProjectReleaseTypes.Where(releaseType => releaseType.Id != 0).Sum(item => item.TotalCount);
releaseCalendarPresenter.ProjectReleaseTypes.Where(releaseType => releaseType.Id == 0).ToList().ForEach(releaseType => releaseType.TotalCount = totalCount);
}
}
public ActionResult RetrievePreviousReleases(ReleaseCalendarPresenter releaseCalendarPresenter)
{
if (releaseCalendarPresenter == null)
{
return null;
}
if (releaseCalendarPresenter.ReleaseCalendar.StartDate != null && !releaseCalendarPresenter.ReleaseCalendar.StartDate.IsValidDatabaseDate())
{
releaseCalendarPresenter.ValidationErrors.Add(StartDate, Resources.StartDateInvalidErrorMessage);
}
if (releaseCalendarPresenter.HasValidationError == true)
{
return new JsonResult { Data = releaseCalendarPresenter, MaxJsonLength = int.MaxValue };
}
var release = this.RetreivePreviousReleaseList(releaseCalendarPresenter);
var result = release.OrderBy(u => u.StartDate).Select(e => e.BuildNumber).ToList();
return new JsonResult { Data = result, MaxJsonLength = int.MaxValue };
}
/// <summary>
/// Decodes the HTML text.
/// </summary>
/// <param name="presenter">The presenter.</param>
private static void DecodeRawText(ReleaseCalendarPresenter presenter)
{
presenter.ReleaseCalendar.ReleaseItems = !string.IsNullOrEmpty(presenter.ReleaseCalendar.ReleaseItems) && !string.IsNullOrWhiteSpace(HttpUtility.HtmlDecode(HttpUtility.HtmlDecode(presenter.ReleaseCalendar.ReleaseItems))) ? HttpUtility.HtmlDecode(HttpUtility.HtmlDecode(presenter.ReleaseCalendar.ReleaseItems)) : null;
presenter.ReleaseCalendar.Risk = !string.IsNullOrEmpty(presenter.ReleaseCalendar.Risk) && !string.IsNullOrWhiteSpace(HttpUtility.HtmlDecode(HttpUtility.HtmlDecode(presenter.ReleaseCalendar.Risk))) ? HttpUtility.HtmlDecode(HttpUtility.HtmlDecode(presenter.ReleaseCalendar.Risk)) : null;
presenter.ReleaseCalendar.Comments = !string.IsNullOrEmpty(presenter.ReleaseCalendar.Comments) && !string.IsNullOrWhiteSpace(HttpUtility.HtmlDecode(HttpUtility.HtmlDecode(presenter.ReleaseCalendar.Comments))) ? HttpUtility.HtmlDecode(HttpUtility.HtmlDecode(presenter.ReleaseCalendar.Comments)) : null;
}
/// <summary>
/// Assigns the count value.
/// </summary>
/// <param name="releaseCalendarPresenter">The release calendar presenter.</param>
/// <param name="releaseTypes">The release types.</param>
/// <param name="selectedIds">The selected ids.</param>
private void AssignCountValue(ReleaseCalendarPresenter releaseCalendarPresenter, IList<byte> releaseTypes, IList<int> selectedIds)
{
int previousMonthReleaseCount = 0;
int nextMonthReleaseCount = 0;
DateTime previousMonthDate = releaseCalendarPresenter.SelectedDate.RetrievePreviousMonthStartDate();
IList<ReleaseCountListItem> releaseCounts = this.releaseService.RetrieveReleaseCountForMonth(previousMonthDate, releaseTypes, selectedIds, SessionData.Instance.UserInfo.Developer.DeveloperID);
releaseCounts.Where(releaseCount => releaseCount.ReleaseCalendarCount.HasValue).Select(releaseCount => previousMonthReleaseCount = previousMonthReleaseCount + releaseCount.ReleaseCalendarCount.Value).ToList();
releaseCalendarPresenter.PreviousMonthReleaseCount = previousMonthReleaseCount;
DateTime nextMonthDate = releaseCalendarPresenter.SelectedDate.RetrieveNextMonthStartDate();
IList<ReleaseCountListItem> nextMonthReleaseCounts = this.releaseService.RetrieveReleaseCountForMonth(nextMonthDate, releaseTypes, selectedIds, SessionData.Instance.UserInfo.Developer.DeveloperID);
nextMonthReleaseCounts.Where(releaseCount => releaseCount.ReleaseCalendarCount.HasValue).Select(releaseCount => nextMonthReleaseCount = nextMonthReleaseCount + releaseCount.ReleaseCalendarCount.Value).ToList();
releaseCalendarPresenter.NextMonthReleaseCount = nextMonthReleaseCount;
}
/// <summary>
/// Initializes the month view presenter.
/// </summary>
/// <param name="dateTime">The date time.</param>
/// <param name="releaseCalendarPresenter">The release calendar presenter.</param>
private void InitializeMonthViewPresenter(DateTime dateTime, ReleaseCalendarPresenter releaseCalendarPresenter)
{
this.AssignCountValue(releaseCalendarPresenter, null, null);
releaseCalendarPresenter.AssignReleases(this.releaseService.RetrieveListForMonth(dateTime, null, null, SessionData.Instance.UserInfo.Developer.DeveloperID));
IList<Release> releases = new List<Release>();
Dictionary<DateTime, IList<ReleaseListItem>> dictionary = new Dictionary<DateTime, IList<ReleaseListItem>>();
releaseCalendarPresenter.Releases.ForEach(item => AssignValuesToDictionary(dictionary, item));
AssignReleases(releases, dictionary);
releaseCalendarPresenter.AssignMonthViewReleases(releases);
releaseCalendarPresenter.TotalReleases = releaseCalendarPresenter.Releases.Count;
this.AssignProjectReleaseTypes(releaseCalendarPresenter, true);
releaseCalendarPresenter.AssignSelectedProjects(releaseCalendarPresenter.MasterProjects);
}
/// <summary>
/// Refreshes the day view.
/// </summary>
/// <param name="releaseCalendarPresenter">The release calendar presenter.</param>
/// <param name="releaseTypes">The release types.</param>
/// <param name="selectedIds">The selected ids.</param>
/// <returns>
/// List of counts
/// </returns>
private IList<ReleaseCountListItem> RefreshDayView(ReleaseCalendarPresenter releaseCalendarPresenter, IList<byte> releaseTypes, IList<int> selectedIds)
{
releaseCalendarPresenter.AssignReleases(this.releaseService.RetrieveListForDate(releaseCalendarPresenter.SelectedDate, releaseTypes, selectedIds, SessionData.Instance.UserInfo.Developer.DeveloperID, true));
releaseCalendarPresenter.Releases.Select(release =>
{
return ValidateDates(release, releaseCalendarPresenter.SelectedDate);
}).ToList();
releaseCalendarPresenter.TotalReleases = releaseCalendarPresenter.Releases.Count;
IList<ReleaseCountListItem> releaseCounts = null;
if (!string.IsNullOrEmpty(releaseCalendarPresenter.IsSearchByProject)
&& releaseCalendarPresenter.IsSearchByProject.Equals("true", StringComparison.OrdinalIgnoreCase))
{
releaseCalendarPresenter.ProjectReleaseTypes.Clear();
this.AssignProjectReleaseTypes(releaseCalendarPresenter, false);
}
else
{
var startDate = releaseCalendarPresenter.SelectedDate.Date;
var endDate = startDate.AddDays(1).AddMinutes(-1);
releaseCounts = this.releaseService.RetrieveReleaseCount(null, selectedIds, startDate, endDate, SessionData.Instance.UserInfo.Developer.DeveloperID);
}
releaseCalendarPresenter.IsSearchByProject = string.Empty;
return releaseCounts;
}
/// <summary>
/// Refreshes the month view.
/// </summary>
/// <param name="releaseCalendarPresenter">The release calendar presenter.</param>
/// <param name="releaseTypes">The release types.</param>
/// <param name="selectedIds">The selected ids.</param>
/// <returns>
/// List of counts
/// </returns>
private IList<ReleaseCountListItem> RefreshMonthView(ReleaseCalendarPresenter releaseCalendarPresenter, IList<byte> releaseTypes, IList<int> selectedIds)
{
this.AssignCountValue(releaseCalendarPresenter, releaseTypes, selectedIds);
releaseCalendarPresenter.AssignReleases(this.releaseService.RetrieveListForMonth(releaseCalendarPresenter.SelectedDate, releaseTypes, selectedIds, SessionData.Instance.UserInfo.Developer.DeveloperID));
IList<Release> releases = new List<Release>();
Dictionary<DateTime, IList<ReleaseListItem>> dictionary = new Dictionary<DateTime, IList<ReleaseListItem>>();
releaseCalendarPresenter.Releases.ForEach(release => release.EndDate = release.StartDate.Value.AddHours(1));
releaseCalendarPresenter.Releases.ForEach(item => AssignValuesToDictionary(dictionary, item));
AssignReleases(releases, dictionary);
releaseCalendarPresenter.AssignMonthViewReleases(releases);
releaseCalendarPresenter.TotalReleases = releaseCalendarPresenter.MonthViewReleases.Count;
IList<ReleaseCountListItem> releaseCounts = null;
if (!string.IsNullOrEmpty(releaseCalendarPresenter.IsSearchByProject)
&& releaseCalendarPresenter.IsSearchByProject.Equals("true", StringComparison.OrdinalIgnoreCase))
{
releaseCalendarPresenter.ProjectReleaseTypes.Clear();
this.AssignProjectReleaseTypes(releaseCalendarPresenter, true);
}
else
{
releaseCounts = this.releaseService.RetrieveReleaseCountForMonth(releaseCalendarPresenter.SelectedDate, null, selectedIds, SessionData.Instance.UserInfo.Developer.DeveloperID);
}
releaseCalendarPresenter.IsSearchByProject = string.Empty;
return releaseCounts;
}
/// <summary>
/// Refreshes the calendar.
/// </summary>
/// <param name="releaseCalendarPresenter">The release calendar presenter.</param>
/// <param name="isMonthView">if set to <c>true</c> [is month view].</param>
private void RefreshCalendar(ReleaseCalendarPresenter releaseCalendarPresenter, bool isMonthView)
{
releaseCalendarPresenter.ReleaseCalendar = new ReleaseCalendar();
AssignSelectedReleaseType(releaseCalendarPresenter);
this.AssignValuesToPresenter(releaseCalendarPresenter);
if (!string.IsNullOrEmpty(releaseCalendarPresenter.SelectedProjectIds))
{
List<string> ids = releaseCalendarPresenter.SelectedProjectIds.Split(',').ToList();
releaseCalendarPresenter.AssignSelectedProjects(releaseCalendarPresenter.MasterProjects.Where(project => ids.Contains(project.ProjectID.ToString(CultureInfo.CurrentCulture))).ToList());
}
IList<byte> releaseTypes = releaseCalendarPresenter.ProjectReleaseTypes.Where(environment => environment.Id != 0 && !string.IsNullOrEmpty(environment.IsSelected) && environment.IsSelected.Equals("true", StringComparison.OrdinalIgnoreCase)).Select(environment => Convert.ToByte(environment.Id)).ToList();
releaseTypes = releaseTypes.Count == 0 ? null : releaseTypes;
IList<int> selectedIds = releaseCalendarPresenter.SelectedProjects.Count > 0 ? releaseCalendarPresenter.SelectedProjects.Select(selectedProject => selectedProject.ProjectID).ToList() : null;
IList<ReleaseCountListItem> releaseCounts = null;
if (isMonthView)
{
releaseCounts = this.RefreshMonthView(releaseCalendarPresenter, releaseTypes, selectedIds);
}
else
{
releaseCounts = this.RefreshDayView(releaseCalendarPresenter, releaseTypes, selectedIds);
}
UpdateCounts(releaseCalendarPresenter, releaseCounts);
}
/// <summary>
/// Function to assign values to presenter.
/// </summary>
/// <param name="presenter">Presenter information</param>
private void AssignValuesToPresenter(ReleaseCalendarPresenter presenter)
{
presenter.AssignReleaseStatusList(this.lookupService.RetrieveReleaseCalendarStatusList(presenter.ReleaseCalendar.Status > 0 ? presenter.ReleaseCalendar.Status : default(byte?), SessionData.Instance.UserInfo.Developer.DeveloperID));
presenter.AssignReleaseTypes(this.lookupService.RetrieveReleaseTypes(SessionData.Instance.UserInfo.Developer.DeveloperID));
presenter.AssignTimeZones(this.lookupService.RetrieveTimeZones());
var projectId = presenter.ReleaseCalendar.ProjectID > 0 ? presenter.ReleaseCalendar.ProjectID : default(int?);
presenter.AssignProjectsExcludePipeline(this.lookupService.RetrieveProjectsExcludePipeline(null, projectId, false, false, SessionData.Instance.UserInfo.Developer.DeveloperID));
presenter.AssignMasterProjects(this.lookupService.RetrieveProjects(null, projectId, false, false, SessionData.Instance.UserInfo.Developer.DeveloperID));
}
/// <summary>
/// Initializes the presenter.
/// </summary>
/// <param name="dateTime">The date time.</param>
/// <param name="isMonthView">if set to <c>true</c> [is month view].</param>
/// <returns>
/// Instance of Release Calendar
/// </returns>
private ReleaseCalendarPresenter InitializePresenter(DateTime dateTime, bool isMonthView)
{
ReleaseCalendarPresenter releaseCalendarPresenter = new ReleaseCalendarPresenter() { ReleaseCalendar = new ReleaseCalendar() };
this.AssignValuesToPresenter(releaseCalendarPresenter);
releaseCalendarPresenter.SelectedDate = dateTime;
if (isMonthView)
{
this.InitializeMonthViewPresenter(dateTime, releaseCalendarPresenter);
}
else
{
releaseCalendarPresenter.AssignReleases(this.releaseService.RetrieveListForDate(dateTime, null, null, SessionData.Instance.UserInfo.Developer.DeveloperID, true));
releaseCalendarPresenter.Releases.Select(release =>
{
return ValidateDates(release, dateTime);
}).ToList();
releaseCalendarPresenter.TotalReleases = releaseCalendarPresenter.Releases.Count;
this.AssignProjectReleaseTypes(releaseCalendarPresenter, isMonthView);
releaseCalendarPresenter.AssignSelectedProjects(releaseCalendarPresenter.MasterProjects);
}
return releaseCalendarPresenter;
}
/// <summary>
/// Function to view release.
/// </summary>
/// <param name="calendarId">The calendar id</param>
/// <param name="projectId">The project identifier.</param>
/// <param name="includeInactive">The include inactive.</param>
/// <returns>
/// View page
/// </returns>
public ActionResult ViewRelease(string calendarId, string projectId, string includeInactive)
{
ReleaseListItem releaseListItem = null;
if (!string.IsNullOrEmpty(calendarId))
{
releaseListItem = this.releaseService.RetrieveById(Convert.ToInt32(calendarId, CultureInfo.CurrentCulture), SessionData.Instance.UserInfo.Developer.DeveloperID);
}
else if (string.IsNullOrEmpty(calendarId) && !string.IsNullOrEmpty(projectId))
{
releaseListItem = this.projectService.RetrieveReleases(projectId, DateTime.Today, SessionData.Instance.UserInfo.Developer.DeveloperID);
}
if (releaseListItem == null)
{
return this.Redirect(Url.ReleaseCalendarAction());
}
else
{
var statusList = this.lookupService.RetrieveReleaseCalendarStatusList(releaseListItem.Status, SessionData.Instance.UserInfo.Developer.DeveloperID);
releaseListItem.StatusTitle = statusList.Where(item => item.ID == releaseListItem.Status).First().Name;
if (!string.IsNullOrEmpty(projectId) && !string.IsNullOrEmpty(includeInactive))
{
this.AddBreadcrumbItem(Resources.ManageProject, Url.ProjectsAction());
this.AddBreadcrumbItem(Resources.ProjectDashboard, RetrieveProjectDashboardAddress(Url.ProjectDashboardAction(), projectId, includeInactive));
}
else
{
this.AddBreadcrumbItem(Resources.ReleaseCalendar, RetrieveCalendarAddress(Url.ReleaseCalendarAction(), releaseListItem.StartDate.Value));
this.AddBreadcrumbItem(Resources.DayView, RetrieveCalendarAddress(Url.DayViewAction(), releaseListItem.StartDate.Value));
}
this.AddBreadcrumbItem(Resources.ViewRelease, Url.ViewReleaseAction());
var presenter = new ReleaseCalendarPresenter() { ReleaseListItem = releaseListItem };
presenter.IsEditable = LookupService.IsReleaseEditable(presenter.ReleaseListItem.Status);
if (presenter.ReleaseListItem.Status == (byte)ReleaseStatus.Planned)
{
var currentTime = DateTimeHelper.RetrieveCurrentDateTime();
if (currentTime < presenter.ReleaseListItem.StartDate.Value)
{
presenter.RemainingTime = presenter.ReleaseListItem.StartDate.Value.Subtract(currentTime);
}
}
var historyListItems = this.releaseService.RetrieveHistory(releaseListItem.ReleaseCalendarID);
if (historyListItems != null && historyListItems.Count > 0)
{
AssignHistoryItems(presenter, historyListItems);
}
var project = this.projectService.RetrieveById(releaseListItem.ProjectID, SessionData.Instance.UserInfo.Developer.DeveloperID);
presenter.ProjectName = project.Name;
presenter.ProjectShortName = project.ShortName;
this.AssignArtifactList(presenter);
return this.View(presenter);
}
}
/// <summary>
/// Function to retrieve previous release.
/// </summary>
/// <param name="releaseCalendarPresenter">The releaseCalendar id.</param>
/// <returns>release item list.</returns>
private IList<ReleaseListItem> RetreivePreviousReleaseList(ReleaseCalendarPresenter releaseCalendarPresenter)
{
var release = this.releaseService.RetrievePreviousReleases(releaseCalendarPresenter.ReleaseCalendar.ProjectID, releaseCalendarPresenter.ReleaseCalendar.Environment, releaseCalendarPresenter.ReleaseCalendar.StartDate, releaseCalendarPresenter.ReleaseCalendar.TimeZoneID.HasValue ? releaseCalendarPresenter.ReleaseCalendar.TimeZoneID.Value : 0, SessionData.Instance.UserInfo.Developer.DeveloperID);
return release;
}
public ActionResult DayInfo(ReleaseCalendarPresenter releaseCalendarPresenter)
{
if (releaseCalendarPresenter == null)
{
return null;
}
this.AddBreadcrumbItem(Resources.ReleaseCalendar, RetrieveCalendarAddress(Url.ReleaseCalendarAction(), releaseCalendarPresenter.SelectedDate));
this.AddBreadcrumbItem(Resources.DayView, Url.DayViewAction());
this.RefreshCalendar(releaseCalendarPresenter, false);
return this.View("DayInfo", releaseCalendarPresenter);
}
/// <summary>
/// Assigns the artifact list.
/// </summary>
/// <param name="presenter">The presenter.</param>
private void AssignArtifactList(ReleaseCalendarPresenter presenter)
{
presenter.AssignArtifacts(this.lookupService.RetrieveReleaseArtifactList(presenter.ReleaseListItem.ReleaseCalendarID, SessionData.Instance.UserInfo.Developer.DeveloperID).Where(g => g.IsSelected == true).ToList());
AssignViewReleaseArtifactList(presenter);
AssignViewProjectArtifactList(presenter);
}
public ActionResult RetrieveReleaseItems(ReleaseCalendarPresenter releaseCalendarPresenter, string build)
{
if (releaseCalendarPresenter == null)
{
return null;
}
if (releaseCalendarPresenter.ReleaseCalendar.StartDate != null && !releaseCalendarPresenter.ReleaseCalendar.StartDate.IsValidDatabaseDate())
{
releaseCalendarPresenter.ValidationErrors.Add(StartDate, Resources.StartDateInvalidErrorMessage);
}
if (releaseCalendarPresenter.HasValidationError == true)
{
return new JsonResult { Data = releaseCalendarPresenter, MaxJsonLength = int.MaxValue };
}
var value = build;
var release = this.RetreivePreviousReleaseList(releaseCalendarPresenter);
var selectedRelease = release.Where(e => e.BuildNumber == value).FirstOrDefault();
if (selectedRelease != null)
{
var result = release.Where(r => r.StartDate <= selectedRelease.StartDate).Select(e => e.ReleaseItems).ToList();
return new JsonResult { Data = string.Join(System.Environment.NewLine, result.ToArray()), MaxJsonLength = int.MaxValue };
}
return null;
}
public ActionResult Index(ReleaseCalendarPresenter releaseCalendarPresenter)
{
if (releaseCalendarPresenter == null)
{
return null;
}
this.AddBreadcrumbItem(Resources.ReleaseCalendar, Url.ReleaseCalendarAction());
this.RefreshCalendar(releaseCalendarPresenter, true);
return this.View(releaseCalendarPresenter);
}
private static void ValidateCalendarDetails(ReleaseCalendarPresenter presenter)
{
DecodeRawText(presenter);
var startDate = Convert.ToDateTime(presenter.ActualStartDate);
var oldEndDate = Convert.ToDateTime(presenter.OldEndDate);
if (presenter.ReleaseCalendar.ProjectID == default(int))
{
presenter.ValidationErrors.Add(ProjectID, Resources.SelectProjectErrorMessage);
}
if (Convert.ToInt32(presenter.ReleaseCalendar.TimeZoneID, CultureInfo.CurrentCulture) == default(int))
{
presenter.ValidationErrors.Add(TimeZone, Resources.TimeZoneValidationMessage);
}
if (presenter.ReleaseCalendar.Environment == default(byte))
{
presenter.ValidationErrors.Add(Environment, Resources.SelectReleaseTypeErrorMessage);
}
if (presenter.ReleaseCalendar.Status == default(byte) && presenter.IsEdit.Equals("true"))
{
presenter.ValidationErrors.Add(Status, Resources.SelectStatusErrorMessage);
}
if (!presenter.ReleaseCalendar.StartDate.IsValidDatabaseDate())
{
presenter.ValidationErrors.Add(StartDate, Resources.StartDateInvalidErrorMessage);
}
else if (presenter.ReleaseCalendar.StartDate != startDate && presenter.ReleaseCalendar.StartDate < System.DateTime.Now)
{
presenter.ValidationErrors.Add(StartDate, Resources.InvalidStartDateErrorMessage);
}
if (!presenter.ReleaseCalendar.EndDate.HasValue)
{
presenter.ValidationErrors.Add(EndDate, Resources.EndDateErrorMessage);
}
else if (presenter.ReleaseCalendar.StartDate != null && presenter.ReleaseCalendar.EndDate != null && presenter.ReleaseCalendar.StartDate >= presenter.ReleaseCalendar.EndDate)
{
presenter.ValidationErrors.Add(EndDate, Resources.EndDateInvalidErrorMessage);
}
if (string.IsNullOrWhiteSpace(presenter.ReleaseCalendar.BuildNumber))
{
presenter.ValidationErrors.Add(BuildNumber, Resources.ProvideBuildErrorMessage);
}
if (string.IsNullOrEmpty(presenter.ReleaseCalendar.ReleaseItems))
{
presenter.ValidationErrors.Add(ReleaseItems, Resources.ProvideReleaseItemsErrorMessage);
}
if (string.Equals(presenter.IsEdit, "true"))
{
if (string.IsNullOrWhiteSpace(presenter.ReleaseCalendar.Comments) && (presenter.SelectedReleaseStatus != presenter.ReleaseCalendar.Status || startDate != presenter.ReleaseCalendar.StartDate || oldEndDate != presenter.ReleaseCalendar.EndDate))
{
presenter.ValidationErrors.Add(ReleaseFeedback, Resources.ProvideReleaseFeedbackErrorMessage);
}
}
}
public ActionResult SubmitDetails(ReleaseCalendarPresenter presenter)
{
if (presenter != null)
{
presenter.Artifacts.Clear();
var list = presenter.ReleaseArtifactList.SelectMany(p => p.Items).ToList()
.Union(presenter.ProjectArtifactList.SelectMany(p => p.Items).ToList()).ToList();
presenter.AssignArtifacts(list);
DecodeRawText(presenter);
presenter.ReleaseCalendar.SendNotificationStatus = presenter.IsSendNotification ? SendNotificationValue : DoNotSendNotificationValue;
if (presenter.IsEdit.Equals("false"))
{
presenter.ReleaseCalendar.EndDate = presenter.ReleaseCalendar.EndDate.HasValue ? presenter.ReleaseCalendar.EndDate : presenter.ReleaseCalendar.StartDate.AddMinutes(30);
presenter.ReleaseCalendar.Status = (byte)ReleaseStatus.Planned;
this.releaseService.InsertOrUpdate(presenter.ReleaseCalendar, presenter.Artifacts, null, SessionData.Instance.UserInfo.Developer.DeveloperID, presenter.OldProjectId);
}
else
{
this.releaseService.InsertOrUpdate(presenter.ReleaseCalendar, presenter.Artifacts, null, SessionData.Instance.UserInfo.Developer.DeveloperID, presenter.OldProjectId);
}
}
return this.Json(string.Empty);
}
/// <summary>
/// Function to assign history items.
/// </summary>
/// <param name="presenter">Presenter details</param>
/// <param name="historyListItems">Item details</param>
private static void AssignHistoryItems(ReleaseCalendarPresenter presenter, IDictionary<string, IEnumerable<HistoryListItem>> historyListItems)
{
if (historyListItems.ContainsKey(RiskKeyValue))
{
presenter.AssignRiskHistoryList(historyListItems[RiskKeyValue].ToList());
}
if (historyListItems.ContainsKey(ReleaseItemsKeyValue))
{
presenter.AssignReleaseItemsHistoryList(historyListItems[ReleaseItemsKeyValue].ToList());
}
if (historyListItems.ContainsKey(CommentsKeyValue))
{
presenter.AssignCommentsHistoryList(historyListItems[CommentsKeyValue].ToList());
}
if (historyListItems.ContainsKey(StartDateKeyValue))
{
var list = historyListItems[StartDateKeyValue].ToList();
var newList = new List<HistoryListItem>();
list.ForEach(l => Map(l, newList));
presenter.AssignStartDateHistoryList(newList);
}
}
public ActionResult ValidateErrorDetails(ReleaseCalendarPresenter presenter)
{
ModelState.Clear();
if (presenter != null)
{
ValidateCalendarDetails(presenter);
presenter.ValidationErrors.Append(this.releaseService.Validate(presenter.ReleaseCalendar));
}
return new JsonResult { Data = presenter, MaxJsonLength = int.MaxValue };
}
/// <summary>
/// Assigns the project artifact list.
/// </summary>
/// <param name="presenter">The presenter.</param>
private static void AssignViewProjectArtifactList(ReleaseCalendarPresenter presenter)
{
int nodeIndex = 0;
var groupedList = presenter.Artifacts.OrderBy(a => a.Squence)
.Where(a => a.ArtifactType == ArtifactType.Project)
.GroupBy(u => u.FunctionalArea)
.Select(grp => new ArtifactFillListItem { FunctionalArea = grp.Key, Items = grp.ToList() })
.ToList();
groupedList.ForEach(g => { g.NodeIndex = nodeIndex; nodeIndex++; g.IsSelected = g.Items.All(i => i.IsSelected.Value); });
presenter.AssignProjectArtifactList(groupedList);
}
/// <summary>
/// Assigns the environments.
/// </summary>
/// <param name="presenter">The presenter.</param>
/// <param name="isMonthView">if set to <c>true</c> [is month view].</param>
private void AssignProjectReleaseTypes(ReleaseCalendarPresenter presenter, bool isMonthView)
{
IList<ProjectReleaseType> environments = new List<ProjectReleaseType>();
environments.Add(new ProjectReleaseType { Id = 0, Name = "All", IsSelected = "true" });
presenter.ReleaseTypeList.Select(releaseType =>
{
var environment = new ProjectReleaseType { Id = releaseType.ID, Name = releaseType.Name, IsSelected = "false" };
if (environment.Name == Internal)
{
environment.ShortName = InternalShort;
}
else if (environment.Name == UAT)
{
environment.ShortName = UATShort;
}
else if (environment.Name == Production)
{
environment.ShortName = ProductionShort;
}
else if (environment.Name == Beta)
{
environment.ShortName = BetaShort;
}
environments.Add(environment);
return true;
}).ToList();
presenter.AssignProjectReleaseTypes(environments);
this.AssignProjectReleaseTypeCounts(presenter, isMonthView);
}
