public void AddTranscripts()
{
try
{
using (MockContext context = MockContext.Start("ReviewAPIs"))
{
rvwStatus = ReviewStatus.UNPUBLISHED;
//CreateVideoReview();
api = ReviewAPI.TRANSCRIPTS_ADD;
using (Stream s = new FileStream(currentExecutingDirectory + @"\TestDataSources\vttF.vtt", FileMode.Open, FileAccess.Read))
{
HttpMockServer.Initialize("ReviewAPIs", "AddTranscripts");
client = Constants.GenerateClient(api, HttpMockServer.CreateInstance());
//results = Constants.GetTranscriptReviewResponse(client, api, Content.VIDEO, MIMETypes.TEXT_PLAIN.GetDescription(), teamName, ReviewIds[0], s);
results = Constants.GetTranscriptReviewResponse(client, api, Content.VIDEO, MIMETypes.TEXT_PLAIN.GetDescription(), teamName, "201712v67b52dea7aa94a669c766af506fd55d5", s);
}
var addTransacripts = results.AddTranscripts;
Assert.NotNull(addTransacripts);
Assert.Equal(HttpStatusCode.NoContent, addTransacripts.Response.StatusCode);
}
}
catch (Exception e)
{
throw e;
}
}
private void MarkReviewingStatus(ReviewStatus status)
{
foreach (var item in DiffListView.SelectedItems.Cast <CommitFileVm>())
{
item.ReviewStatus = status;
}
}
/// <summary>
/// Insert reply
/// </summary>
/// <param name="storageConsistencyMode">Storage consistency mode</param>
/// <param name="replyHandle">Reply handle</param>
/// <param name="commentHandle">Comment handle</param>
/// <param name="topicHandle">Topic handle</param>
/// <param name="text">Reply text</param>
/// <param name="language">Reply language</param>
/// <param name="userHandle">User handle</param>
/// <param name="createdTime">Created time</param>
/// <param name="reviewStatus">Review status</param>
/// <param name="appHandle">App handle</param>
/// <param name="requestId">Request id associated with the create reply request</param>
/// <returns>Insert reply task</returns>
public async Task InsertReply(
StorageConsistencyMode storageConsistencyMode,
string replyHandle,
string commentHandle,
string topicHandle,
string text,
string language,
string userHandle,
DateTime createdTime,
ReviewStatus reviewStatus,
string appHandle,
string requestId)
{
ReplyEntity replyEntity = new ReplyEntity()
{
CommentHandle = commentHandle,
TopicHandle = topicHandle,
Text = text,
Language = language,
UserHandle = userHandle,
CreatedTime = createdTime,
LastUpdatedTime = createdTime,
AppHandle = appHandle,
ReviewStatus = reviewStatus,
RequestId = requestId
};
CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Replies);
ObjectTable table = this.tableStoreManager.GetTable(ContainerIdentifier.Replies, TableIdentifier.RepliesObject) as ObjectTable;
Operation operation = Operation.Insert(table, replyHandle, replyHandle, replyEntity);
await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode());
}
public void AddTranscriptsModerationResult()
{
try
{
using (MockContext context = MockContext.Start("ReviewAPIs"))
{
rvwStatus = ReviewStatus.UNPUBLISHED;
//CreateVideoReview();
AddTranscripts();
api = ReviewAPI.TRANSCRIPTS_ADD_MODERATION_RESULT;
HttpMockServer.Initialize("ReviewAPIs", "AddTranscriptsModerationResult");
client = Constants.GenerateClient(api, HttpMockServer.CreateInstance());
//results = Constants.GetReviewResponse(client, api, Content.VIDEO, MIMETypes.JSON.GetDescription(), teamName, null, null, null, null, ReviewIds[0]);
results = Constants.GetReviewResponse(client, api, Content.VIDEO, MIMETypes.JSON.GetDescription(), teamName, null, null, null, null, "201712v67b52dea7aa94a669c766af506fd55d5");
var review = results.AddTranscriptsModerationResult;
Assert.NotNull(review);
Assert.Equal(HttpStatusCode.NoContent, review.Response.StatusCode);
}
}
catch (Exception e)
{
throw e;
}
}
public async Task <IActionResult> Details(int?id, ReviewStatus status)
{
if (id == null)
{
return(NotFound());
}
var review = await _context.Reviews
.Include(r => r.Album).Include(r => r.User)
.FirstOrDefaultAsync(m => m.ReviewId == id);
if (review == null)
{
return(NotFound());
}
var contactOperation = (status == ReviewStatus.Approved)
? Operations.Approve
: Operations.Reject;
var isAuthorized = await _authorizationService.AuthorizeAsync(User, review,
contactOperation);
if (!isAuthorized.Succeeded)
{
return(Forbid());
}
review.Status = status;
_context.Reviews.Update(review);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", "Reviews", new { id = review.ReviewId }));
}
internal Review(string reviewer, string?committer, string url, string path, IReadOnlyCollection <ReviewTask> tasks)
{
System.Diagnostics.Debug.Assert(!string.IsNullOrWhiteSpace(reviewer));
System.Diagnostics.Debug.Assert(!string.IsNullOrWhiteSpace(url));
System.Diagnostics.Debug.Assert(!string.IsNullOrWhiteSpace(path));
System.Diagnostics.Debug.Assert(tasks != null && tasks.Count != 0);
Reviewer = reviewer;
Committer = committer;
Url = url;
Path = path;
Tasks = tasks;
Status = GetReviewStatus();
ReviewStatus GetReviewStatus()
{
var numberOfOpenTasks = tasks.Count(task => task.Status == ReviewTaskStatus.Open);
if (numberOfOpenTasks == 0)
{
return(ReviewStatus.ToBeClosed);
}
if (numberOfOpenTasks == tasks.Count)
{
return(ReviewStatus.Open);
}
return(ReviewStatus.InWork);
}
}
public void AddURLFramesVideoReview()
{
try
{
using (MockContext context = MockContext.Start("ReviewAPIs"))
{
rvwStatus = ReviewStatus.UNPUBLISHED;
//CreateVideoReview();
api = ReviewAPI.FRAMES_ADD;
HttpMockServer.Initialize("ReviewAPIs", "AddURLFramesVideoReview");
client = Constants.GenerateClient(api, HttpMockServer.CreateInstance());
//results = Constants.GetVideoFramesReviewResponse(client, api, Content.VIDEO, MIMETypes.JSON.GetDescription(), teamName, ReviewIds[0]);
results = Constants.GetVideoFramesReviewResponse(client, api, Content.VIDEO, MIMETypes.JSON.GetDescription(), teamName, "201712v1f35675ed4d8457cbf84f4890ce59c58");
var review = results.AddFrames;
Assert.NotNull(review);
Assert.Equal(HttpStatusCode.NoContent, review.Response.StatusCode);
}
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Create a topic
/// </summary>
/// <param name="processType">Process type</param>
/// <param name="topicHandle">Topic handle</param>
/// <param name="title">Topic title</param>
/// <param name="text">Topic text</param>
/// <param name="blobType">Blob type</param>
/// <param name="blobHandle">Blob handle</param>
/// <param name="categories">Topic categories</param>
/// <param name="language">Topic language</param>
/// <param name="group">Topic group</param>
/// <param name="deepLink">Topic deep link</param>
/// <param name="friendlyName">Topic friendly name</param>
/// <param name="publisherType">Publisher type</param>
/// <param name="userHandle">User handle</param>
/// <param name="userVisibility">User visibility</param>
/// <param name="createdTime">Created time</param>
/// <param name="reviewStatus">Review status</param>
/// <param name="appHandle">App handle</param>
/// <param name="requestId">Request id associated with the create topic request</param>
/// <returns>Create topic task</returns>
public async Task CreateTopic(
ProcessType processType,
string topicHandle,
string title,
string text,
BlobType blobType,
string blobHandle,
string categories,
string language,
string group,
string deepLink,
string friendlyName,
PublisherType publisherType,
string userHandle,
UserVisibilityStatus userVisibility,
DateTime createdTime,
ReviewStatus reviewStatus,
string appHandle,
string requestId)
{
await this.topicsStore.InsertTopic(
StorageConsistencyMode.Strong,
topicHandle,
title,
text,
blobType,
blobHandle,
categories,
language,
group,
deepLink,
friendlyName,
publisherType,
userHandle,
createdTime,
reviewStatus,
appHandle,
requestId);
if (publisherType == PublisherType.User)
{
await this.topicsStore.InsertUserTopic(StorageConsistencyMode.Strong, userHandle, appHandle, topicHandle);
await this.topicsStore.InsertFollowingTopic(StorageConsistencyMode.Strong, userHandle, appHandle, topicHandle, userHandle);
await this.popularTopicsManager.UpdatePopularUserTopic(processType, userHandle, appHandle, topicHandle, 0);
}
// TODO: should we add a popular app topic feed
await this.topicsStore.InsertRecentTopic(StorageConsistencyMode.Strong, appHandle, topicHandle, userHandle);
await this.popularTopicsManager.UpdatePopularTopic(processType, appHandle, topicHandle, userHandle, createdTime, 0);
await this.searchQueue.SendSearchIndexTopicMessage(topicHandle, createdTime);
if (publisherType == PublisherType.User)
{
await this.fanoutTopicsQueue.SendFanoutTopicMessage(userHandle, appHandle, topicHandle);
}
}
public void GetFramesVideoReview()
{
try
{
using (MockContext context = MockContext.Start("ReviewAPIs"))
{
rvwStatus = ReviewStatus.UNPUBLISHED;
//CreateVideoReview();
api = ReviewAPI.FRAMES_GET;
HttpMockServer.Initialize("ReviewAPIs", "GetFramesVideoReview");
client = Constants.GenerateClient(api, HttpMockServer.CreateInstance());
//results = Constants.GetVideoFramesReviewResponse(client, api, Content.VIDEO, MIMETypes.JSON.GetDescription(), teamName, ReviewIds[0]);
results = Constants.GetVideoFramesReviewResponse(client, api, Content.VIDEO, MIMETypes.JSON.GetDescription(), teamName, "201712vbb90cbd620c0433dbecf70ad51e5563d");
var frames = results.GetFrames;
Assert.NotNull(frames);
Assert.Equal(HttpStatusCode.OK, frames.Response.StatusCode);
Assert.True(Helpers.Utilities.VerifyGetFrames(frames.Body), "Frames verification failed" + TestBase.ErrorMessage);
}
}
catch (Exception e)
{
throw e;
}
}
} // Enum holding the status of the collection. Used in scheduling algorithms.
public Collection(int collectionID, string collectionPicFileName, List <Item> collectionList)
{
CollectionID = collectionID;
CollectionPicFileName = collectionPicFileName;
CollectionList = collectionList;
lvl = Levels.Introductory;
status = ReviewStatus.OptionalReview;
}
/// <summary>
/// Gets a list of reviews for a specific game.
/// </summary>
/// <param name="context"></param>
/// <param name="game"></param>
/// <param name="isAccepted"></param>
/// <returns></returns>
public static async Task <List <Review> > GetGameReviewsAsync(this TurboGamesContext context,
Game game, ReviewStatus reviewStatus)
{
return(await context.Reviews
.Include(r => r.Game)
.Include(r => r.Reviewer)
.Where(r => r.Game == game && r.ReviewStatus == reviewStatus)
.ToListAsync());
}
public bool VacancyReviewCanBeAssigned(ReviewStatus reviewStatus, DateTime?reviewedDate)
{
if (reviewStatus == ReviewStatus.PendingReview)
{
return(true);
}
return(reviewedDate < GetExpiredAssignationDateTime());
}
/// <summary>
/// Update user review status
/// </summary>
/// <param name="userHandle">User handle</param>
/// <param name="appHandle">App handle</param>
/// <param name="reviewStatus">Review status</param>
/// <param name="userProfileEntity">User profile entity</param>
/// <returns>Update user review status task</returns>
public async Task UpdateUserReviewStatus(
string userHandle,
string appHandle,
ReviewStatus reviewStatus,
IUserProfileEntity userProfileEntity)
{
// note that we do not update the last updated time when we modify the review status
userProfileEntity.ReviewStatus = reviewStatus;
await this.usersStore.UpdateUserProfile(StorageConsistencyMode.Strong, userHandle, appHandle, userProfileEntity);
}
public Review ChangeReviewStatus(Guid id, ReviewStatus status)
{
var review = _uow.Database.SingleById <ReviewDto>(id);
review.Status = (int)status;
_uow.Database.Update(review);
return(EntityFactory.BuildEntity(review));
}
/// <summary>
/// Creates a new LA-ADAP Stub application for the given ramsellId
///
/// This may involve inserting a new UAS_User.
/// </summary>
/// <returns>the formResultId of the newly-created application</returns>
public int CreateAndPrepopulateNewStubApp(string ramsellId)
{
def_FormResults previousApp = GetMostRecentAppWithRamsellId(ramsellId);
def_FormResults previousStubApp = GetMostRecentAppWithRamsellId(ramsellId, stubForm.formId);
def_FormResults newStubApp = CreateNewBlankStubApp(ramsellId, previousApp);
PrepopulateStubApp(newStubApp, previousStubApp, ramsellId);
formsRepo.AddFormResult(newStubApp);
ReviewStatus.ChangeStatus(formsRepo, newStubApp, ReviewStatus.TO_BE_REVIEWED, "Created Stub Application");
return(newStubApp.formResultId);
}
public async Task <List <VacancyReview> > GetByStatusAsync(ReviewStatus status)
{
var filter = Builders <VacancyReview> .Filter.Eq(r => r.Status, status);
var collection = GetCollection <VacancyReview>();
var result = await RetryPolicy.ExecuteAsync(context => collection
.Find(filter)
.ToListAsync(), new Context(nameof(GetByStatusAsync)));
return(result);
}
public ReviewStatus GetWorkflowReviewStatus(string ProtocolCKey, string DraftVersion, string ReviewerCKey)
{
ReviewStatus status = new Workflow().GetWorkflowProtocolReviewStatus(decimal.Parse(ProtocolCKey), decimal.Parse(DraftVersion), decimal.Parse(ReviewerCKey));
if (status == null)
{
status = new ReviewStatus();
status.ProtocolCKey = decimal.Parse(ProtocolCKey);
status.Status = "0";
}
return(status);
}
public Review ChangeReviewStatus(Guid id, ReviewStatus status)
{
Review result;
using (var uow = _uowProvider.Create())
using (var repo = _repositoryFactory.CreateReviewRepository(uow))
{
result = repo.ChangeReviewStatus(id, status);
uow.Complete();
}
return(result);
}
public ActionResult Create(FormCollection collection)
{
try
{
ITaxonRepository taxon = new TaxonRepository();
IGenericRepository generics = new GenericRepository();
IReviewRepository reviews = new ReviewRepository();
// TODO: Add insert logic here
TblReview r = new TblReview();
int kingdom = 0;
int reviewtype = 0;
kingdom = collection["addkingdom"].Equals("animal") ?
generics.getExternalRef(UpdateUtils.ANIMALS, UpdateUtils.TYPE_KINGDOM) :
generics.getExternalRef(UpdateUtils.PLANTS, UpdateUtils.TYPE_KINGDOM);
//reviewtype = collection["reviewtype"].Equals("normal") ?
// generics.getExternalRef(UpdateUtils.REVIEW_NORMAL, UpdateUtils.TYPE_REVIEW) :
// generics.getExternalRef(UpdateUtils.REVIEW_ADHOC, UpdateUtils.TYPE_REVIEW);
r.CountryID = int.Parse(collection["countries"]);
r.AddedBy = 2;
r.AddedByName = Membership.GetUser().ToString();
r.DateAdded = DateTime.Now;
r.PhaseID = int.Parse(collection["addphase"]);
int speciesId = int.Parse(collection["species"]);
r.TaxonID = speciesId;
r.TaxonLevel = generics.getExternalRef(UpdateUtils.SPECIES, UpdateUtils.TYPE_TAXONLEVEL);
r.KingdomID = kingdom;
// r.CommitteeID = int.Parse(collection["committee"]);
r.CommitteeID = 1;
r.ReviewDate = DateTime.Now;
r.ReviewType = 1;
int ID = taxon.SaveReview(r);
ReviewStatus rs = new ReviewStatus();
rs.Status = generics.getExternalRef(UpdateUtils.SELECTION, UpdateUtils.REVIEWSTATUS);
rs.DateAdded = DateTime.Now;
rs.ReviewID = ID;
reviews.saveReviewStatus(rs);
// return RedirectToAction("List","AddReview");
return(RedirectToAction("Details", "ProcessReview", new { id = ID }));
}
catch
{
//Do nothing - caught below
}
return(RedirectToAction("AddReview", "AddReview"));
}
public static ReviewStatusDto ReviewStatusToDto(ReviewStatus reviewStatus)
{
var name = reviewStatus.ToString();
var color = ReviewHelper.GetStatusColor(reviewStatus);
return(new ReviewStatusDto
{
Alias = name.ToLower(),
Id = (int)reviewStatus,
Color = color,
Name = name,
SortOrder = 0
});
}
public ReviewStatusViewSource(SummaryNode node, ReviewStatus revStatus)
: base(node)
{
_allChanges = node; // Reference to "All Changes node"
FilterState = revStatus;
node.PropertyChanged += new PropertyChangedEventHandler(node_PropertyChanged);
var nodes = from o in node.ChildNodes
where o.SummaryItem.ReviewState == revStatus
select o;
foreach (var n in nodes)
{
_internalNodeCollection.Add(n);
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
// NON-PUBLIC PROCEDURES
/////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Changes the status of the specified note tag.
/// </summary>
/// <param name="tagRange">The tag range.</param>
/// <param name="status">The new status.</param>
private void ChangeNoteStatus(TagSnapshotRange <IntraTextNoteTag> tagRange, ReviewStatus status)
{
// Get the tagger from the code document
ICodeDocument document = tagRange.SnapshotRange.Snapshot.Document as ICodeDocument;
if (document != null)
{
IntraTextNoteTagger tagger = null;
if (document.Properties.TryGetValue(typeof(IntraTextNoteTagger), out tagger))
{
// Change the tag's status and raise an event so the UI knows to update
tagRange.Tag.Status = status;
tagger.RaiseTagsChanged(new TagsChangedEventArgs(tagRange.SnapshotRange));
}
}
}
private static VacancyReview CreateVacancyReview(string id, string userId, ReviewStatus status, string reviewedDate, string createdDate)
{
return(new VacancyReview
{
Id = Guid.Parse(id),
ReviewedDate = reviewedDate != null?DateTime.Parse(reviewedDate) : (DateTime?)null,
CreatedDate = DateTime.Parse(createdDate),
Status = status,
ReviewedByUser = userId != null ? new VacancyUser
{
UserId = userId
}
: null
});
}
/// <summary>
/// Update a reply
/// </summary>
/// <param name="processType">Process type</param>
/// <param name="replyHandle">Reply handle</param>
/// <param name="text">Reply text</param>
/// <param name="language">Comment language</param>
/// <param name="reviewStatus">Review status</param>
/// <param name="lastUpdatedTime">Last updated time</param>
/// <param name="replyEntity">Reply entity</param>
/// <returns>Update reply task</returns>
public async Task UpdateReply(
ProcessType processType,
string replyHandle,
string text,
string language,
ReviewStatus reviewStatus,
DateTime lastUpdatedTime,
IReplyEntity replyEntity)
{
replyEntity.Text = text;
replyEntity.Language = language;
replyEntity.ReviewStatus = reviewStatus;
replyEntity.LastUpdatedTime = lastUpdatedTime;
await this.repliesStore.UpdateReply(StorageConsistencyMode.Strong, replyHandle, replyEntity);
}
/// <summary>
/// Insert topic
/// </summary>
/// <param name="storageConsistencyMode">Storage consistency mode</param>
/// <param name="topicHandle">Topic handle</param>
/// <param name="title">Topic title</param>
/// <param name="text">Topic text</param>
/// <param name="blobType">Blob type</param>
/// <param name="blobHandle">Blob handle</param>
/// <param name="categories">Topic categories</param>
/// <param name="language">Topic language</param>
/// <param name="group">Topic group</param>
/// <param name="deepLink">Topic deep link</param>
/// <param name="friendlyName">Topic friendly name</param>
/// <param name="publisherType">Publisher type</param>
/// <param name="userHandle">User handle</param>
/// <param name="createdTime">Created time</param>
/// <param name="reviewStatus">Review status</param>
/// <param name="appHandle">App handle</param>
/// <param name="requestId">Request id associated with the create topic request</param>
/// <returns>Insert topic task</returns>
public async Task InsertTopic(
StorageConsistencyMode storageConsistencyMode,
string topicHandle,
string title,
string text,
BlobType blobType,
string blobHandle,
string categories,
string language,
string group,
string deepLink,
string friendlyName,
PublisherType publisherType,
string userHandle,
DateTime createdTime,
ReviewStatus reviewStatus,
string appHandle,
string requestId)
{
TopicEntity topicEntity = new TopicEntity()
{
Title = title,
Text = text,
BlobType = blobType,
BlobHandle = blobHandle,
Categories = categories,
Language = language,
Group = group,
DeepLink = deepLink,
FriendlyName = friendlyName,
PublisherType = publisherType,
UserHandle = userHandle,
CreatedTime = createdTime,
LastUpdatedTime = createdTime,
AppHandle = appHandle,
ReviewStatus = reviewStatus,
RequestId = requestId
};
CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Topics);
ObjectTable table = this.tableStoreManager.GetTable(ContainerIdentifier.Topics, TableIdentifier.TopicsObject) as ObjectTable;
Operation operation = Operation.Insert(table, topicHandle, topicHandle, topicEntity);
await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode());
}
public void ChangeStatusToCheckedOut()
{
List <int> formResultIds = SessionHelper.Read <List <int> >("formResultIds");
if (formResultIds != null)
{
foreach (int formResultId in formResultIds)
{
def_FormResults formResult = formsRepo.GetFormResultById(formResultId);
ReviewStatus.ChangeStatus(formsRepo, formResult, ReviewStatus.CHECKED_OUT, "Checked out to Venture by " + SessionHelper.LoginInfo.LoginID);
Updates.AddField(formsRepo, Updates.SIS_HIDDEN, formResult, Updates.CHECKED_OUT_TO, SessionHelper.LoginInfo.LoginID);
AccessLogging.InsertAccessLogRecord(formsRepo, formResultId, (int)AccessLogging.accessLogFunctions.CHECK_OUT, "Checked out to Venture by " + SessionHelper.LoginInfo.LoginID);
}
}
}
/// <summary>
/// Update a comment
/// </summary>
/// <param name="processType">Process type</param>
/// <param name="commentHandle">Comment handle</param>
/// <param name="text">Comment text</param>
/// <param name="blobType">Blob type</param>
/// <param name="blobHandle">Blob handle</param>
/// <param name="reviewStatus">Review status</param>
/// <param name="lastUpdatedTime">Last updated time</param>
/// <param name="commentEntity">Comment entity</param>
/// <returns>Update comment task</returns>
public async Task UpdateComment(
ProcessType processType,
string commentHandle,
string text,
BlobType blobType,
string blobHandle,
ReviewStatus reviewStatus,
DateTime lastUpdatedTime,
ICommentEntity commentEntity)
{
commentEntity.Text = text;
commentEntity.BlobType = blobType;
commentEntity.BlobHandle = blobHandle;
commentEntity.ReviewStatus = reviewStatus;
commentEntity.LastUpdatedTime = lastUpdatedTime;
await this.commentsStore.UpdateComment(StorageConsistencyMode.Strong, commentHandle, commentEntity);
}
public override int GetHashCode()
{
int hash = 1;
hash ^= policyTopicEntries_.GetHashCode();
if (ReviewStatus != global::Google.Ads.GoogleAds.V5.Enums.PolicyReviewStatusEnum.Types.PolicyReviewStatus.Unspecified)
{
hash ^= ReviewStatus.GetHashCode();
}
if (ApprovalStatus != global::Google.Ads.GoogleAds.V5.Enums.PolicyApprovalStatusEnum.Types.PolicyApprovalStatus.Unspecified)
{
hash ^= ApprovalStatus.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public override int GetHashCode()
{
int hash = 1;
hash ^= policyTopicEntries_.GetHashCode();
if (ReviewStatus != 0)
{
hash ^= ReviewStatus.GetHashCode();
}
if (ApprovalStatus != 0)
{
hash ^= ApprovalStatus.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
IEnumerator AnimateClosingCo()
{
currentStatus = ReviewStatus.closing;
var elapsed = 0f;
var rt = textToAnimate.GetComponent <RectTransform>();
while (elapsed < animationDuration)
{
elapsed += Time.deltaTime;
rt.sizeDelta = new Vector2(rt.sizeDelta.x, Mathf.Lerp(openHeight, closedHeight, elapsed / animationDuration));
rt.position = new Vector3(rt.position.x, Mathf.Lerp(openPosition, closedPosition, elapsed / animationDuration));
yield return(null);
}
rt.sizeDelta = new Vector2(rt.sizeDelta.x, closedHeight);
currentStatus = ReviewStatus.closed;
}
IEnumerator AnimateOpeningCo(string content)
{
currentStatus = ReviewStatus.revealing;
var elapsed = 0f;
var rt = textToAnimate.GetComponent <RectTransform>();
textToAnimate.text = content;
while (elapsed < animationDuration)
{
elapsed += Time.deltaTime;
rt.sizeDelta = new Vector2(rt.sizeDelta.x, Mathf.Lerp(closedHeight, openHeight, elapsed / animationDuration));
rt.position = new Vector3(rt.position.x, Mathf.Lerp(closedPosition, openPosition, elapsed / animationDuration));
yield return(null);
}
rt.sizeDelta = new Vector2(rt.sizeDelta.x, openHeight);
currentStatus = ReviewStatus.showing;
}
public virtual void SetReviewStatus( ReviewStatus revStatus)
{
if (ChildNodes.Count == 0)
{
if (SummaryItem.ReviewState != revStatus)
{
SummaryItem.ReviewState = revStatus;
}
}
else
{
foreach (SummaryNode sn in ChildNodes)
{
sn.SetReviewStatus(revStatus);
}
}
}
private static string GetReviewStatusHeaderText(ReviewStatus revStatus)
{
switch (revStatus)
{
case ReviewStatus.Unknown:
return "Not Reviewed Changes";
default:
return revStatus.ToString() + " Changes";
}
}
private static string GetReviewStatusImageSource(ReviewStatus revStatus)
{
string sourceBase = "/Workshare.ChangeSummary.Controls;component/res/16x16-{0}.png";
string sourceFull = string.Format(sourceBase, revStatus.ToString());
return sourceFull;
}
public ReviewStatusViewSource GetViewSource(ReviewStatus revStatus)
{
var viewsource = (from v in ViewSourceCollection
where v.FilterState == revStatus
select v).FirstOrDefault();
return viewsource;
}
public void Insert(int? ReviewID,int? Status,DateTime? DateAdded,bool Deleted)
{
ReviewStatus item = new ReviewStatus();
item.ReviewID = ReviewID;
item.Status = Status;
item.DateAdded = DateAdded;
item.Deleted = Deleted;
item.Save(UserName);
}
private void saveSpeciesForReview()
{
ITaxonRepository Taxon = new TaxonRepository();
IGenericRepository gen = new GenericRepository();
IReviewRepository rr = new ReviewRepository();
if (TempData["CurrentData"] != null)
{
DataTable dt = (DataTable)TempData["CurrentData"];
int rowcount = dt.Rows.Count;
ITaxonRepository taxon = new TaxonRepository();
for (int i = 0; i < rowcount; i++)
{
DataRow dr = dt.Rows[i];
TblReview r = new TblReview();
r.PhaseID = int.Parse(dr[1].ToString());
r.KingdomID = taxon.getTaxonLevelID(dr[7].ToString());
r.TaxonLevel = taxon.getTaxonLevelID(dr[2].ToString());
r.TaxonID = int.Parse(dr[4].ToString());
r.DateAdded = DateTime.Now;
r.CountryID = int.Parse(dr[6].ToString());
int ID = taxon.SaveReview(r);
ReviewStatus rs = new ReviewStatus();
rs.Status = gen.getExternalRef(UpdateUtils.SELECTION, UpdateUtils.REVIEWSTATUS);
rs.DateAdded = DateTime.Now;
rs.ReviewID = ID;
rr.saveReviewStatus(rs);
}
}
}
protected void hasReviewDate_Changed()
{
TextBox txtReviewDate = frmTaskEdit.FindControl("txtDateReview") as TextBox;
HiddenField currentReviewDate = frmTaskEdit.FindControl("hdnDateReview") as HiddenField;
if (txtReviewDate.Text != "")
{
string format = "dd-MM-yyyy";
DateTime WeekBeforeReview = DateTime.ParseExact(txtReviewDate.Text.ToString(), format, CultureInfo.InvariantCulture).AddDays(-7);
if (txtReviewDate.Text != currentReviewDate.Value.ToString())
{
ReviewDateChanged = true;
DateTime now = DateTime.Now.Date;
if (DateTime.Compare(now, WeekBeforeReview) < 0 || currentReviewDate.Value == "")
{
ReviewStatus ReviewS = new ReviewStatus();
ReviewS.taskID = Request.QueryString["tid"];
ReviewS.reviewStatus = "0";
ReviewS.setReviewStatus();
}
else if (DateTime.Compare(WeekBeforeReview, now) < 0 && DateTime.Compare(Convert.ToDateTime(txtReviewDate.Text), now) < 0)
{
ReviewStatus ReviewS = new ReviewStatus();
ReviewS.taskID = Request.QueryString["tid"];
ReviewS.reviewStatus = "2";
ReviewS.setReviewStatus();
}
else if (DateTime.Compare(WeekBeforeReview, now) < 0)
{
ReviewStatus ReviewS = new ReviewStatus();
ReviewS.taskID = Request.QueryString["tid"];
ReviewS.reviewStatus = "1";
ReviewS.setReviewStatus();
}
}
else { ReviewDateChanged = false; }
}
}
public ActionResult Create(FormCollection collection)
{
try
{
ITaxonRepository taxon = new TaxonRepository();
IGenericRepository generics = new GenericRepository();
IReviewRepository reviews = new ReviewRepository();
// TODO: Add insert logic here
TblReview r = new TblReview();
int kingdom = 0;
int reviewtype = 0;
kingdom = collection["addkingdom"].Equals("animal") ?
generics.getExternalRef(UpdateUtils.ANIMALS, UpdateUtils.TYPE_KINGDOM) :
generics.getExternalRef(UpdateUtils.PLANTS, UpdateUtils.TYPE_KINGDOM);
//reviewtype = collection["reviewtype"].Equals("normal") ?
// generics.getExternalRef(UpdateUtils.REVIEW_NORMAL, UpdateUtils.TYPE_REVIEW) :
// generics.getExternalRef(UpdateUtils.REVIEW_ADHOC, UpdateUtils.TYPE_REVIEW);
r.CountryID = int.Parse(collection["countries"]);
r.AddedBy = 2;
r.AddedByName= Membership.GetUser().ToString();
r.DateAdded = DateTime.Now;
r.PhaseID = int.Parse(collection["addphase"]);
int speciesId = int.Parse(collection["species"]);
r.TaxonID = speciesId;
r.TaxonLevel = generics.getExternalRef(UpdateUtils.SPECIES, UpdateUtils.TYPE_TAXONLEVEL);
r.KingdomID = kingdom;
// r.CommitteeID = int.Parse(collection["committee"]);
r.CommitteeID = 1;
r.ReviewDate = DateTime.Now;
r.ReviewType = 1;
int ID= taxon.SaveReview(r);
ReviewStatus rs = new ReviewStatus();
rs.Status = generics.getExternalRef(UpdateUtils.SELECTION, UpdateUtils.REVIEWSTATUS);
rs.DateAdded = DateTime.Now;
rs.ReviewID = ID;
reviews.saveReviewStatus(rs);
// return RedirectToAction("List","AddReview");
return RedirectToAction("Details", "ProcessReview", new {id = ID});
}
catch
{
//Do nothing - caught below
}
return RedirectToAction("AddReview", "AddReview");
}
public void Update(int Id,int? ReviewID,int? Status,DateTime? DateAdded,bool Deleted)
{
ReviewStatus item = new ReviewStatus();
item.MarkOld();
item.IsLoaded = true;
item.Id = Id;
item.ReviewID = ReviewID;
item.Status = Status;
item.DateAdded = DateAdded;
item.Deleted = Deleted;
item.Save(UserName);
}
public void saveReviewStatus(ReviewStatus r)
{
DB.Save(r);
}
