public async Task <ReviewSettings> UpdateReviewSettingsAsync(int reviewId, ReviewSettings updatedReviewSettings, bool autoSave, int userId)
{
var reviewInfo = await GetReviewInfoAsync(reviewId, userId);
if (!await _permissionsRepository.HasEditPermissions(reviewId, userId))
{
throw ReviewsExceptionHelper.UserCannotModifyReviewException(reviewId);
}
var reviewData = await _reviewsRepository.GetReviewAsync(reviewId, userId);
if (reviewData.ReviewStatus == ReviewPackageStatus.Closed)
{
throw new ConflictException(I18NHelper.FormatInvariant(ErrorMessages.ReviewIsClosed, reviewId), ErrorCodes.ReviewClosed);
}
await LockReviewAsync(reviewId, userId, reviewInfo);
UpdateEndDate(updatedReviewSettings, autoSave, reviewData.ReviewPackageRawData);
UpdateShowOnlyDescription(updatedReviewSettings, reviewData.ReviewPackageRawData);
UpdateCanMarkAsComplete(reviewId, updatedReviewSettings, reviewData.ReviewPackageRawData);
UpdateRequireESignature(reviewData.ReviewType, updatedReviewSettings, reviewData.ReviewPackageRawData);
await UpdateRequireMeaningOfSignatureAsync(reviewInfo.ItemId, userId, reviewInfo.ProjectId, reviewData.ReviewType, updatedReviewSettings, reviewData.ReviewPackageRawData);
await _reviewsRepository.UpdateReviewPackageRawDataAsync(reviewId, reviewData.ReviewPackageRawData, userId);
return(await GetReviewSettingsFromReviewData(reviewData, reviewInfo));
}
private void UpdateEndDate(ReviewSettings updatedReviewSettings, bool autoSave, ReviewPackageRawData reviewRawData)
{
if (!autoSave && updatedReviewSettings.EndDate.HasValue && updatedReviewSettings.EndDate <= _currentDateTimeService.GetUtcNow())
{
throw new BadRequestException("The settings could not be updated because the review has expired.", ErrorCodes.ReviewExpired);
}
reviewRawData.EndDate = updatedReviewSettings.EndDate;
}
public Task <ReviewSettings> UpdateReviewSettingsAsync(int reviewId, [FromBody] ReviewSettings reviewSettings, [FromUri] bool autoSave)
{
if (reviewSettings == null)
{
throw new BadRequestException(ErrorMessages.ReviewSettingsAreRequired, ErrorCodes.BadRequest);
}
return(_reviewsService.UpdateReviewSettingsAsync(reviewId, reviewSettings, autoSave, Session.UserId));
}
private static string GetReviewGlobalVariable(PortalSettings PortalSettings, bool HasReviewPermission)
{
string Script = string.Empty;
if (TabPermissionController.HasTabPermission("EDIT") || HasReviewPermission)
{
ReviewSettings ReviewSetting = Core.Managers.PageManager.GetPageReviewSettings(PortalSettings);
Script = "var VJIsPageDraft='" + ReviewSetting.IsPageDraft + "'; var VJIsContentApproval='" + ReviewSetting.IsContentApproval + "'; var VJNextStateName='" + ReviewSetting.NextStateName + "'; var VJIsLocked='" + ReviewSetting.IsLocked + "'; var VJIsModeratorEditPermission='" + ReviewSetting.IsModeratorEditPermission + "'; var VJLocal='" + Core.Managers.PageManager.GetCultureCode(PortalSettings) + "';";
}
return(Script);
}
private static void UpdateRequireESignature(ReviewType reviewType, ReviewSettings updatedReviewSettings, ReviewPackageRawData reviewRawData)
{
var settingChanged = (!reviewRawData.IsESignatureEnabled.HasValue && updatedReviewSettings.RequireESignature) ||
(reviewRawData.IsESignatureEnabled.HasValue && reviewRawData.IsESignatureEnabled.Value != updatedReviewSettings.RequireESignature);
if (!settingChanged)
{
return;
}
if (reviewType == ReviewType.Formal && reviewRawData.Status == ReviewPackageStatus.Active)
{
throw ReviewsExceptionHelper.ReviewActiveFormalException();
}
reviewRawData.IsESignatureEnabled = updatedReviewSettings.RequireESignature;
}
private static void UpdateCanMarkAsComplete(int reviewId, ReviewSettings updatedReviewSettings, ReviewPackageRawData reviewRawData)
{
var settingChanged =
reviewRawData.IsAllowToMarkReviewAsCompleteWhenAllArtifactsReviewed != updatedReviewSettings.CanMarkAsComplete;
if (!settingChanged)
{
return;
}
if (reviewRawData.Status != ReviewPackageStatus.Draft)
{
var errorMessage = I18NHelper.FormatInvariant(ErrorMessages.ReviewIsNotDraft, reviewId);
throw new ConflictException(errorMessage, ErrorCodes.Conflict);
}
reviewRawData.IsAllowToMarkReviewAsCompleteWhenAllArtifactsReviewed = updatedReviewSettings.CanMarkAsComplete;
}
private async Task <ReviewSettings> GetReviewSettingsFromReviewData(Review reviewData, ArtifactBasicDetails reviewInfo)
{
var reviewSettings = new ReviewSettings(reviewData.ReviewPackageRawData);
// We never ignore folders for formal reviews - Jira Bug STOR-4636
reviewSettings.IgnoreFolders = reviewData.ReviewType != ReviewType.Formal && !reviewData.BaselineId.HasValue && reviewSettings.IgnoreFolders;
reviewSettings.CanEditRequireESignature = reviewData.ReviewStatus == ReviewPackageStatus.Draft ||
(reviewData.ReviewStatus == ReviewPackageStatus.Active && reviewData.ReviewType != ReviewType.Formal);
var projectPermissions = await _permissionsRepository.GetProjectPermissions(reviewInfo.ProjectId);
reviewSettings.IsMeaningOfSignatureEnabledInProject =
projectPermissions.HasFlag(ProjectPermissions.IsMeaningOfSignatureEnabled);
reviewSettings.CanEditRequireMeaningOfSignature = reviewSettings.CanEditRequireESignature &&
reviewSettings.IsMeaningOfSignatureEnabledInProject;
return(reviewSettings);
}
protected void RemoveSetting(ReviewSettings level)
{
//~ is a bitwise not in c#
//Doing a bitwise AND on a NOTed level should result in the level being removed
ReviewSettings = (byte)(ReviewSettings & (~(byte)level));
}
protected void AddSetting(ReviewSettings setting)
{
ReviewSettings = (byte)(ReviewSettings | (byte)setting);
}
/// <summary>
/// Returns true if the discussion has the specified anonymity setting
/// </summary>
/// <param name="level"></param>
/// <returns></returns>
protected bool HasSetting(ReviewSettings setting)
{
int result = ReviewSettings & (byte)setting;
return(result == (int)setting);
}
public static dynamic Update(PortalSettings PortalSettings, dynamic Data)
{
dynamic result = new ExpandoObject();
try
{
if (Data != null)
{
int TabId = PortalSettings.ActiveTab.TabID;
Pages page = new Pages();
Pages pageVersion = GetLatestVersion(PortalSettings.ActiveTab.TabID, PortalSettings.UserInfo);
page.TabID = TabId;
page.Style = Data["gjs-css"].ToString();
page.Content = ResetModuleMarkup(PortalSettings.PortalId, Data["gjs-html"].ToString(), PortalSettings.UserId);
page.ContentJSON = Data["gjs-components"].ToString();
page.StyleJSON = Data["gjs-styles"].ToString();
if (Data["IsPublished"] != null && Convert.ToBoolean(Data["IsPublished"].ToString()) && (pageVersion != null && pageVersion.IsPublished))
{
page.IsPublished = true;
page.Version = GetNextVersionByTabID(TabId);
}
else
{
page.IsPublished = Convert.ToBoolean(Data["IsPublished"].ToString());
if (pageVersion != null && pageVersion.IsPublished)
{
page.Version = GetNextVersionByTabID(TabId);
}
else if (pageVersion != null && !pageVersion.IsPublished)
{
page.Version = pageVersion.Version;
}
else
{
page.Version = GetNextVersionByTabID(TabId);
}
}
Pages SavedPage = GetByVersion(page.TabID, page.Version, GetCultureCode(PortalSettings));
if (SavedPage != null)
{
page.CreatedBy = SavedPage.CreatedBy;
page.CreatedOn = SavedPage.CreatedOn;
page.ID = SavedPage.ID;
page.StateID = SavedPage.StateID;
}
page.Locale = GetCultureCode(PortalSettings);
if (pageVersion != null && page.Version == pageVersion.Version)
{
page.StateID = pageVersion.StateID;
}
page.PortalID = PortalSettings.PortalId;
WorkflowManager.AddComment(PortalSettings, "publish", Data["Comment"].ToString(), page);
ReviewSettings ReviewSettings = GetPageReviewSettings(PortalSettings);
if (!string.IsNullOrEmpty(Data["Comment"].ToString()) || ReviewSettings.IsPageDraft)
{
result.ReviewToastMarkup = GetReviewToastMarkup(PortalSettings);
result.PageReviewSettings = ReviewSettings;
}
result.NotifyCount = NotificationManager.RenderNotificationsCount(PortalSettings.PortalId);
try
{
if (page.IsPublished && Data != null && Data["m2v"] != null && Data["m2v"].Value)
{
PageManager.MigrateToVanjaro(PortalSettings);
result.RedirectAfterm2v = Common.Utilities.ServiceProvider.NavigationManager.NavigateURL(PortalSettings.ActiveTab.TabID);
}
else
{
result.RedirectAfterm2v = null;
}
}
catch { }
}
}
catch { }
return(result);
}
public static ReviewSettings GetPageReviewSettings(PortalSettings PortalSettings)
{
int TabID = PortalSettings.ActiveTab.TabID;
UserInfo UserInfo = PortalSettings.UserInfo;
Pages page = GetLatestVersion(TabID, PortalSettings.UserInfo);
bool IsPageDraft = false;
bool IsContentApproval = false;
bool IsLocked = false;
string NextStateName = string.Empty;
bool IsModeratorEditPermission = false;
int CurruntWorkflowID = WorkflowManager.GetDefaultWorkflow(TabID);
if (page != null && page.StateID.HasValue)
{
WorkflowState State = WorkflowManager.GetStateByID(page.StateID.Value);
if (State != null)
{
bool IsFirstState = WorkflowManager.IsFirstState(State.WorkflowID, State.StateID);
bool IsLastState = WorkflowManager.IsLastState(State.WorkflowID, State.StateID);
IsPageDraft = WorkflowManager.IsFirstState(State.WorkflowID, State.StateID);
IsLocked = !IsFirstState && !IsLastState;
if (IsLastState && State.WorkflowID != CurruntWorkflowID)
{
State = WorkflowManager.GetFirstStateID(CurruntWorkflowID);
}
if (WorkflowManager.GetWorkflowType(State.WorkflowID) == Core.Components.Enum.WorkflowTypes.ContentApproval)
{
IsContentApproval = true;
if (WorkflowManager.HasReviewPermission(State.StateID, UserInfo) && TabPermissionController.CanManagePage(PortalSettings.ActiveTab))
{
WorkflowState NextState = Core.Managers.WorkflowManager.GetStateByID(Core.Managers.WorkflowManager.GetNextStateID(State.WorkflowID, State.StateID));
NextStateName = NextState != null ? NextState.Name : string.Empty;
IsModeratorEditPermission = true;
}
else
{
WorkflowState NextState = Core.Managers.WorkflowManager.GetStateByID(Core.Managers.WorkflowManager.GetNextStateID(State.WorkflowID, Core.Managers.WorkflowManager.GetFirstStateID(State.WorkflowID).StateID));
NextStateName = NextState != null ? NextState.Name : string.Empty;
}
}
}
}
else
{
if (CurruntWorkflowID > 0)
{
IsContentApproval = Core.Managers.WorkflowManager.GetWorkflowType(CurruntWorkflowID) == Core.Components.Enum.WorkflowTypes.ContentApproval;
WorkflowState NextState = Core.Managers.WorkflowManager.GetStateByID(Core.Managers.WorkflowManager.GetNextStateID(CurruntWorkflowID, Core.Managers.WorkflowManager.GetFirstStateID(CurruntWorkflowID).StateID));
NextStateName = NextState != null ? NextState.Name : string.Empty;
}
}
ReviewSettings ReviewSetting = new ReviewSettings
{
IsPageDraft = IsPageDraft,
IsContentApproval = IsContentApproval,
NextStateName = NextStateName,
IsLocked = IsLocked,
IsModeratorEditPermission = IsModeratorEditPermission
};
return(ReviewSetting);
}
private async Task UpdateRequireMeaningOfSignatureAsync(int reviewId, int userId, int projectId, ReviewType reviewType, ReviewSettings updatedReviewSettings, ReviewPackageRawData reviewRawData)
{
var settingChanged = reviewRawData.IsMoSEnabled != updatedReviewSettings.RequireMeaningOfSignature;
if (!settingChanged)
{
return;
}
if (reviewType == ReviewType.Formal && reviewRawData.Status == ReviewPackageStatus.Active)
{
throw ReviewsExceptionHelper.ReviewActiveFormalException();
}
if (updatedReviewSettings.RequireMeaningOfSignature && (!reviewRawData.IsESignatureEnabled.HasValue || !reviewRawData.IsESignatureEnabled.Value))
{
throw ReviewsExceptionHelper.RequireESignatureDisabledException(reviewId);
}
var projectPermissions = await _permissionsRepository.GetProjectPermissions(projectId);
if (!projectPermissions.HasFlag(ProjectPermissions.IsMeaningOfSignatureEnabled))
{
throw ReviewsExceptionHelper.MeaningOfSignatureIsDisabledInProjectException();
}
reviewRawData.IsMoSEnabled = updatedReviewSettings.RequireMeaningOfSignature;
if (reviewRawData.IsMoSEnabled && reviewRawData.Reviewers != null)
{
var meaningOfSignatureParameters = reviewRawData.Reviewers
.Where(r => r.Permission == ReviewParticipantRole.Approver)
.Select(r => new MeaningOfSignatureParameter {
ParticipantId = r.UserId
});
await UpdateMeaningOfSignaturesInternalAsync(reviewId, userId, reviewRawData, meaningOfSignatureParameters, new MeaningOfSignatureUpdateSetDefaultsStrategy());
}
}
private static void UpdateShowOnlyDescription(ReviewSettings updatedReviewSettings, ReviewPackageRawData reviewRawData)
{
reviewRawData.ShowOnlyDescription = updatedReviewSettings.ShowOnlyDescription;
}
