public void SetReviewState(ReviewState reviewState)
{
_reviwState = reviewState;
switch (reviewState)
{
case ReviewState.ReviewFlagged:
IsReviewMode = true;
break;
case ReviewState.ReviewIncorrect:
IsReviewMode = true;
break;
case ReviewState.UserReview:
IsReviewMode = true;
break;
case ReviewState.none:
IsReviewMode = false;
break;
default: IsReviewMode = false;
break;
}
}
public async Task <bool> ModifyReviewStateByCommentId(Guid commentId, ReviewState state)
{
var review = await _commentReviewSvc.GetAll().Where(x => x.CommentId == commentId).FirstOrDefaultAsync();;
review.State = state;
return(await _commentReviewSvc.EditAsync(review));;
}
public async Task <bool> ModifyReviewStateById(Guid id, ReviewState state)
{
var review = await _commentReviewSvc.GetOneByIdAsync(id);
review.State = state;
return(await _commentReviewSvc.EditAsync(review));;
}
internal BaseReviewStateResponse([NotNull] ReviewState reviewState, [CanBeNull] IEnumerable <ServerUser> users)
{
//TODO: do it better
Author = reviewState.User != null ? reviewState.User.UserName : users?.FirstOrDefault(u => u.Id == reviewState.UserId)?.UserName;
Status = reviewState.State;
Comment = reviewState.Comment;
}
public async Task <bool> ModifyReviewStateById(Guid id, ReviewState state)
{
var guideReview = await _guideReviewService.GetAll().Where(x => x.Id == id).FirstOrDefaultAsync();
guideReview.State = state;
return(await _guideReviewService.EditAsync(guideReview));
}
private static ControlBase CreateMockControl(string name, CoreCompetenceRole coreRole, ReviewCompetenceRole reviewRole, CoreState coreState, ReviewState reviewState )
{
return new ControlBase
{
Name = name,
CoreCompetenceRole = coreRole,
ReviewCompetenceRole = reviewRole,
CoreState = coreState,
ReviewState = reviewState
};
}
private ReviewState CreateReviewState(ScenarioController scenarioController)
{
var input = new ReviewStateInput(scenarioController);
var state = new ReviewState(input, scenarioController);
var scoreTransition = new EventTransition(ScoreState.StateName);
input.NextClickedEvent += scoreTransition.ChangeState;
state.AddTransitions(scoreTransition);
return(state);
}
public async Task <PhraseItem> AddReviewAsync([NotNull] PhraseItem phrase, [NotNull] ServerUser user, [NotNull] PostReviewRequest request)
{
var reviewState = new ReviewState {
Comment = request.Comment, State = request.Status, UserId = user.Id
};
var cloned = phrase.Clone();
cloned.Version++;
UpdateReviewStates(cloned, reviewState, user.Id, request.ClearReview);
await CloseAndInsertAsync(cloned, phrase, user.Id);
return(cloned);
}
public void CreateReview(Review _review, ReviewStateHistory _newhistory, ReviewState _state)
{
_review.Creation_date = DateTime.UtcNow;
_review.Expiration_date = DateTime.UtcNow.AddYears(2);
ctx.Reviews.Add(_review);
ctx.SaveChanges();
_newhistory.Review = _review;
_newhistory.StateId = _state.Id;
_newhistory.State = _state;
_newhistory.ChangeDate = DateTime.UtcNow;
ctx.ReviewStateHistory.Add(_newhistory);
ctx.SaveChanges();
}
public static string GetDanishName(this ReviewState state)
{
switch (state)
{
case ReviewState.Approved:
return("Godkendt");
case ReviewState.NotApproved:
return("Afvist");
case ReviewState.WaitingForApproval:
return("Venter på godkendelse");
default:
return(state.ToString());
}
}
public async Task <bool> Review(Guid animationId, ReviewState reviewState)
{
var anim = await context.Animations.FindAsync(animationId);
if (anim == null)
{
logger.LogInformation("Animáció (Id: {0}) nem található", animationId);
return(false);
}
anim.ReviewedById = identityService.GetUserId();
anim.ReviewState = reviewState;
await context.SaveChangesAsync();
logger.LogInformation("Animáció (Id: {0}) felülvizsgálva felhasználó (Id: {1}) által következő állapottal: {2}", animationId, identityService.GetUserId(), reviewState.ToString("G"));
return(true);
}
public async Task <PhraseItem> UpdatePhraseAsync([NotNull] PutPhraseItemRequest request, [NotNull] ServerUser user,
[NotNull] PhraseItem existingPhrase)
{
var cloned = existingPhrase.Clone();
cloned.Phrase = string.IsNullOrWhiteSpace(request.Phrase) ? cloned.Phrase : request.Phrase;
cloned.Complexity = request.Complexity < 0 || request.Complexity > 0 ? cloned.Complexity : request.Complexity;
cloned.Description = request.Description ?? cloned.Description;
cloned.Version++;
var reviewState = new ReviewState {
Comment = request.Comment, State = State.Accept, UserId = user.Id
};
UpdateReviewStates(cloned, reviewState, user.Id, request.ClearReview);
await CloseAndInsertAsync(cloned, existingPhrase, user.Id);
return(cloned);
}
private static void UpdateReviewStates([NotNull] PhraseItem phraseItem, ReviewState reviewState, string userId, bool clearReview)
{
if (clearReview)
{
phraseItem.ReviewStates.Clear();
phraseItem.ReviewStates.Add(reviewState);
}
else
{
var index = phraseItem.ReviewStates.FindIndex(r => r.UserId == userId);
if (index >= 0)
{
phraseItem.ReviewStates[index] = reviewState;
}
else
{
phraseItem.ReviewStates.Add(reviewState);
}
}
}
public void UpdateReview(string reviewId, ReviewState reviewState)
{
Validation.IdCheck(reviewId);
using (var context = new IntelliCloudContext())
{
var id = Convert.ToInt32(reviewId);
ReviewEntity review = context.Reviews.SingleOrDefault(r => r.Id.Equals(id));
if (review != null)
{
review.ReviewState = reviewState;
context.SaveChanges();
}
else
{
throw new NotFoundException("Sequence contains no elements");
}
}
}
internal PhraseItem ToPhraseItem(ServerUser user)
{
var reviewState = new ReviewState {
User = user, State = State.Accept
};
var phraseItem = new PhraseItem
{
Phrase = Phrase,
Complexity = Complexity,
Description = Description,
PackId = PackId,
Version = 1,
CreatedBy = user,
CreatedDate = DateTime.Now,
ReviewStates = new List <ReviewState> {
reviewState
}
};
return(phraseItem);
}
//
// Gets the state of various commits
//
private static ReviewState.GetCommitStatsResult GetCommitStats(SvnLogs.Log[] revisionLogs)
{
// Starting to pasring
s_logger.Log(@"Starting to generate the commit statistics");
Display.Start(Display.State.ParsingLogs, revisionLogs.Length);
// Get the stats about these commits
ReviewState.GetCommitStatsResult results = ReviewState.GetCommitStatistics(revisionLogs, s_logger, (currentCount) =>
{
Display.Update(currentCount, revisionLogs.Length);
});
// Did we fail?
if (results == null)
{
s_errorMessage = @"Unable to generate the commit stats";
}
// Return our results
s_logger.Log(@"Commit stats generated");
return(results);
}
//
// Returns stats about the reviews in this repository
//
private static ReviewState.ReviewStatistics[] GetReviewStats(ReviewState.CommitReview[] reviews, string workingDirectory, Simple credentials)
{
// Starting to review logs
s_logger.Log("Starting to extract the review stats");
Display.Start(Display.State.QueryingReviewboard, reviews.Length);
// Try to query the server for our review state
try
{
ReviewState.ReviewStatistics[] results = ReviewState.GetReviewStatistics(reviews, workingDirectory, credentials, s_logger, (currentCount) =>
{
Display.Update(currentCount, reviews.Length);
});
// Did we fail
if (results == null)
{
s_errorMessage = @"Unable to generate the review stats against the RB server";
return(null);
}
// Return what we have
s_logger.Log("Review stats generated");
return(results);
}
catch (ReviewboardApiException e)
{
// API error
s_errorMessage = "Unable to generate the review stats against the RB server\n\n" + e.Message;
return(null);
}
catch (Exception generalException)
{
String exceptionMessage = (generalException.InnerException == null ? generalException.Message : generalException.InnerException.Message);
s_errorMessage = "Unable to generate the review stats against the RB server\n\n" + exceptionMessage;
return(null);
}
}
private void ReadReviewers([NotNull] JToken phraseItem, PhraseItem phrase)
{
if (phraseItem["reviews"] == null || _users == null)
{
return;
}
foreach (var user in _users)
{
var state = phraseItem["reviews"][user.UserName];
if (state == null)
{
continue;
}
var reviewState = new ReviewState
{
User = user,
PhraseItem = phrase,
State = (State)state.Value <int>()
};
phrase.ReviewStates.Add(reviewState);
}
}
public void UpdateReview(string id, ReviewState reviewState)
{
manager.UpdateReview(id, reviewState);
}
public static int ToInt(ReviewState value)
{
return(value.GetHashCode());
}
public async Task <List <CommentReviewDTO> > GetAllCommentReviewByState(int page, int size, ReviewState state)
{
var list = await _commentSvc.GetAll().Skip(page).Take(size).Include(x => x.User).Include(x => x.CommentReview).Where(x => x.CommentReview.State == state).ToListAsync();
return(mapper.Map <List <CommentReviewDTO> >(list));
}
public async Task <List <GuideReviewDTO> > GetAllGuideReviewByState(int page, int size, ReviewState state)
{
var list = await _travelGuideSvc.GetAll().Include(x => x.TravelGuideReview).Where(x => x.TravelGuideReview.State == state).Include(x => x.User).Skip(page).Take(size).ToListAsync();
return(_mapper.Map <List <GuideReviewDTO> >(list));
}
public static int ToInt(ReviewState value)
{
return value.GetHashCode();
}
public int Count(ReviewState reviewState)
{
return(entities.AsQueryable().WhereStateReviewIs(reviewState).Count());
}
public void ChangeState(int id, ReviewState reviewState)
{
GetById(id).State = (short)reviewState;
SaveChanges();
}
public static IQueryable <Review> WhereStateReviewIs(this IQueryable <Review> query, ReviewState reviewState)
{
return(query.Where(x => x.State == (short)reviewState));
}
protected override void Seed(recenzent.Data.DataContext context)
{
try
{
var testAffiliation = new Affiliation()
{
Name = "brak"
};
if (!context.Affliations.Any(a => a.Name == testAffiliation.Name))
{
context.Affliations.AddOrUpdate(testAffiliation);
}
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
var userManager = new UserManager <User>(new UserStore <User>(context));
if (!roleManager.RoleExists("Admin"))
{
var role = new IdentityRole();
role.Name = "Admin";
roleManager.Create(role);
}
if (!roleManager.RoleExists("Author"))
{
var role = new IdentityRole();
role.Name = "Author";
roleManager.Create(role);
}
if (!roleManager.RoleExists("Reviewer"))
{
var role = new IdentityRole();
role.Name = "Reviewer";
roleManager.Create(role);
}
if (userManager.FindByName("Magik") == null)
{
var user = new User()
{
UserName = "******", Name = "Wojciech", Surname = "Sendera", Email = "*****@*****.**", RegistrationDate = DateTime.UtcNow,
};
userManager.Create(user, "Admin123");
userManager.AddToRole(user.Id, "Admin");
userManager.AddToRole(user.Id, "Author");
userManager.AddToRole(user.Id, "Reviewer");
}
Publication_category category1 = new Publication_category()
{
Name = "Informatyka"
};
Publication_category category2 = new Publication_category()
{
Name = "Matematyka"
};
Publication_category category3 = new Publication_category()
{
Name = "Fizyka"
};
if (!context.Publication_Categories.Any(c => c.Name == category1.Name))
{
context.Publication_Categories.Add(category1);
}
if (!context.Publication_Categories.Any(c => c.Name == category2.Name))
{
context.Publication_Categories.Add(category2);
}
if (!context.Publication_Categories.Any(c => c.Name == category3.Name))
{
context.Publication_Categories.Add(category3);
}
ReviewState state1 = new ReviewState()
{
Name = "Przydzielony"
};
ReviewState state2 = new ReviewState()
{
Name = "Zaakceptowany"
};
ReviewState state3 = new ReviewState()
{
Name = "Cofniêty do poprawy"
};
ReviewState state4 = new ReviewState()
{
Name = "Odrzucony"
};
if (!context.ReviewStates.Any(s => s.Name == state1.Name))
{
context.ReviewStates.Add(state1);
}
if (!context.ReviewStates.Any(s => s.Name == state2.Name))
{
context.ReviewStates.Add(state2);
}
if (!context.ReviewStates.Any(s => s.Name == state3.Name))
{
context.ReviewStates.Add(state3);
}
if (!context.ReviewStates.Any(s => s.Name == state4.Name))
{
context.ReviewStates.Add(state4);
}
}
catch (System.Data.Entity.Validation.DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Value: \"{1}\", Error: \"{2}\"",
ve.PropertyName,
eve.Entry.CurrentValues.GetValue <object>(ve.PropertyName),
ve.ErrorMessage);
}
}
throw;
}
context.SaveChanges();
}
/**
* Assign the review state to sync gui/input states to
*/
private void SetReviewState(ReviewState state)
{
switch(state)
{
case ReviewState.None:
m_recordButton.setControlIsEnabled(true);
m_pauseButton.setControlIsEnabled(false);
if(m_group.Buffer != null && m_group.Buffer.CurrentTime > 0)
{
m_playButton.setControlIsEnabled(true);
}
else
m_playButton.setControlIsEnabled(false);
m_group.UpdateAction = UpdateAction.None;
break;
case ReviewState.Recording:
m_recordButton.setControlIsEnabled(true);
m_playButton.setControlIsEnabled(false);
m_pauseButton.setControlIsEnabled(false);
if(m_reviewState == ReviewState.ReplayPaused)
{
// regenerate
FrameBuffer regenBuffer = new FrameBuffer();
m_group.Buffer.CopyFramesTo(regenBuffer);
m_group.Buffer = regenBuffer;
// make sure the replay timeline is cleared
m_replayTimeline.setProgressValue(0);
}
else
{
// create a new buffer
m_group.Buffer = new FrameBuffer();
}
m_group.UpdateAction = UpdateAction.Record;
break;
case ReviewState.Replaying:
m_recordButton.setControlIsEnabled(false);
m_playButton.setControlIsEnabled(false);
m_pauseButton.setControlIsEnabled(true);
// reset the read/write position in the frame buffer if we're initiating a replay
if(m_reviewState == ReviewState.None)
//m_group.Buffer.Seek(0);
m_group.UpdateAction = UpdateAction.Replay;
break;
case ReviewState.ReplayPaused:
m_recordButton.setControlIsEnabled(true);
m_playButton.setControlIsEnabled(true);
m_pauseButton.setControlIsEnabled(false);
m_group.UpdateAction = UpdateAction.None;
break;
}
m_reviewState = state;
}
public Review(ReviewState state, string url)
{
Status = state;
Url = url;
}
/**
* Assign the review state to sync gui/input states to
*/
private void SetReviewState(ReviewState state)
{
switch(state)
{
case ReviewState.None:
m_recordButton.controlIsEnabled = true;
m_pauseButton.controlIsEnabled = false;
if(m_group.frameBuffer != null && m_group.frameBuffer.frameCount > 0)
{
m_playButton.controlIsEnabled = true;
}
else
m_playButton.controlIsEnabled = false;
m_group.updateAction = ReviewUpdateAction.None;
break;
case ReviewState.Recording:
m_recordButton.controlIsEnabled = true;
m_playButton.controlIsEnabled = false;
m_pauseButton.controlIsEnabled = false;
if(m_reviewState == ReviewState.ReplayPaused)
{
// regenerate
ReviewFrameBuffer regenBuffer = new ReviewFrameBuffer();
m_group.frameBuffer.CopyFramesTo(ref regenBuffer);
m_group.frameBuffer = regenBuffer;
// make sure the replay timeline is cleared
m_replayTimeline.Value = 0;
}
else
{
// create a new buffer
m_group.frameBuffer = new ReviewFrameBuffer();
}
m_group.updateAction = ReviewUpdateAction.Record;
break;
case ReviewState.Replaying:
m_recordButton.controlIsEnabled = false;
m_playButton.controlIsEnabled = false;
m_pauseButton.controlIsEnabled = true;
// reset the read/write position in the frame buffer if we're initiating a replay
if(m_reviewState == ReviewState.None)
m_group.frameBuffer.SeekToFrame(0);
m_group.updateAction = ReviewUpdateAction.Replay;
break;
case ReviewState.ReplayPaused:
m_recordButton.controlIsEnabled = true;
m_playButton.controlIsEnabled = true;
m_pauseButton.controlIsEnabled = false;
m_group.updateAction = ReviewUpdateAction.None;
break;
}
m_reviewState = state;
}
