示例#1
0
        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));
        }
示例#2
0
        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;
        }
示例#3
0
        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));
        }
示例#4
0
        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);
        }
示例#5
0
        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;
        }
示例#6
0
        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;
        }
示例#7
0
        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);
        }
示例#8
0
 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));
 }
示例#9
0
 protected void AddSetting(ReviewSettings setting)
 {
     ReviewSettings = (byte)(ReviewSettings | (byte)setting);
 }
示例#10
0
        /// <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);
        }
示例#11
0
            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);
            }
示例#12
0
            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);
            }
示例#13
0
        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());
            }
        }
示例#14
0
 private static void UpdateShowOnlyDescription(ReviewSettings updatedReviewSettings, ReviewPackageRawData reviewRawData)
 {
     reviewRawData.ShowOnlyDescription = updatedReviewSettings.ShowOnlyDescription;
 }