public void Assign_Workflows_Continues_On_Exception()
{
Service.SetupSequence(s => s.Execute(It.IsAny <AssignRequest>()))
.Throws(new Exception())
.Returns(new AssignResponse());
Workflows.AssignWorkflowsToUser(WorkflowCollection, Guid.NewGuid());
Service.Verify(s => s.Execute(It.IsAny <AssignRequest>()), Times.Exactly(2));
}
public override void NonUIThreadInitialize()
{
base.NonUIThreadInitialize();
foreach (WorkflowTemplate w in ((StudyType)Item).Workflows.Where(x => x.Deleted == false))
{
DataStoreItemViewModel wvm = new DataStoreItemViewModel(w);
Workflows.Add((WorkflowTemplateViewModel)wvm);
}
}
public Workflow GetWorkflow(string workflowPath)
{
workflowPath = workflowPath.ToLower();
if (Workflows.ContainsKey(workflowPath))
{
return(Workflows[workflowPath]);
}
return(null);
}
private void LoadWorkflows()
{
var workflows = Database.GetWorkflows();
foreach (var workflow in workflows)
{
var wf = LoadWorkflowFromDatabase(workflow);
Workflows.Add(wf);
}
}
public async Task Save(bool skipOnline = false)
{
await Save <Project>(skipOnline);
foreach (var workflow in Workflows.ToList())
{
if (workflow.projectid != _id)
{
workflow.projectid = _id;
}
await workflow.Save(skipOnline);
}
foreach (Detector detector in Detectors.ToList())
{
if (detector.projectid != _id)
{
detector.projectid = _id;
}
await detector.Save(skipOnline);
}
foreach (WorkitemQueue wiq in WorkItemQueues.ToList())
{
if (wiq.projectid != _id)
{
wiq.projectid = _id;
}
await wiq.Save(skipOnline);
}
GenericTools.RunUI(() =>
{
if (System.Threading.Monitor.TryEnter(RobotInstance.instance.Projects, Config.local.thread_lock_timeout_seconds * 1000))
{
try
{
var exists = RobotInstance.instance.Projects.FindById(_id);
if (exists == null)
{
RobotInstance.instance.Projects.Add(this);
}
if (exists != null)
{
RobotInstance.instance.Projects.UpdateItem(exists, this);
}
}
finally
{
System.Threading.Monitor.Exit(RobotInstance.instance.Projects);
}
}
else
{
throw new LockNotReceivedException("Saving Project");
}
});
}
private void LoadWorkflows()
{
foreach (string file in Directory.GetFiles(WorkflowsFolder))
{
var workflow = LoadWorkflowFromFile(file);
if (workflow != null)
{
Workflows.Add(workflow);
}
}
}
public void Leadership_Create_A_Multiple_Choice_Item_With_One_Column_Layout()
{
try
{
this.SchoolNet().LoadWebPage();
Workflows workflows = new Workflows();
workflows.SignInAsLeadership();
TestContext.WriteLine("\n--- Create a multiple choice item ---");
workflows.AssessWorkflows.CreateItemWorkflows
.NavigateToEditTestItemChooseNewItemPage()
.EditTestItemCreateNewItemSelectMultipleChoice();
//set up data for EditTestItem.aspx
EditPageData editPageData = workflows.AssessWorkflows.EditTestItemCreateNewItemPage.InitData();
editPageData.GetTestDataFromResxResource(
"UITests.Data.Assess.ItemCreateEdit.ItemPropertiesResource",
"UITests.Data.Assess.ItemCreateEdit.MultipleChoiceItemResource",
"default_" + this.SchoolNet().TestConfiguration.ApplicationName, 0);
editPageData.ItemTypeData.Name = "OriginalAutomationMCItemWithOneColumnLayoutName";
editPageData.ItemTypeData.Keyword = "OriginalAutomationMultipleChoiceItemKeyword";
editPageData.ItemTypeData.Publisher = "SNAutomationTeam";
editPageData.QuestionAnswerData.AnswerChoiceLayoutOption = MultipleChoiceLayout.OneColumn;
editPageData.StandardPickerData = new StandardPickerDataStructures().GetDefaultStandardPickerData();
workflows.AssessWorkflows.EditTestItemCreateNewItemPage.Data = editPageData;
/* Open response only
*
* workflows.AssessWorkflows.CreateItemWorkflows
* .EditTestItemCreateNewItemPageInputFormFields()
* ;
*
* //16.3, EnableSpecialCharacterPalette is no longer check as default. Need to check on this as tc 80866
* //will fail if this doesn't
* if (workflows.AssessWorkflows.EditTestItemCreateNewItemPage.Form.ItemTypeForm.GetType() == typeof(ItemTypeOpenResponseForm))
* {
* ((ItemTypeOpenResponseForm)workflows.AssessWorkflows.EditTestItemCreateNewItemPage.Form.ItemTypeForm).CheckEnableSpecialCharacterPalette();
* }
*/
workflows.AssessWorkflows.CreateItemWorkflows
.EditTestItemCreateNewItemPageInputAndSubmitForm()
.EditItemAvailabilityShareWithEveryone()
.EditItemAvailabilityPageSubmitForm();
workflows.SignOut();
}
catch (Exception e)
{
TestContext.WriteLine("\nInnerException:\n" + e.InnerException + "\nStackTrace:\n" + e.StackTrace);
new DriverCommands().GetScreenshotAndPageSource();
throw new Exception("\nInnerException:\n" + e.InnerException + "\nStackTrace:\n" + e.StackTrace, e);
}
}
/// <summary>
/// Change the Title of a Workflow that belongs to this Agency.
/// </summary>
public void ChangeWorkflowTitle(Guid workflowId, string title)
{
CheckWorkflowTitle(title);
var workflow = Workflows.FirstOrDefault(x => x.Id == workflowId);
if (workflow == null)
{
throw new Exception("Workflow does not belong to this Agency.");
}
workflow.ChangeTitle(title);
}
public void ClearAllData()
{
KeyValues.RemoveRange(KeyValues);
Workflows.RemoveRange(Workflows);
Timestamps.RemoveRange(Timestamps);
Proofs.RemoveRange(Proofs);
Claims.RemoveRange(Claims);
Packages.RemoveRange(Packages);
SaveChanges();
}
/// <inheritdoc />
public Task <IEnumerable <Task <Indexed <PinResult> > > > PinAsync(
Context context,
IReadOnlyList <ContentHash> contentHashes,
CancellationToken cts,
UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
return(Workflows.RunWithFallback(
contentHashes,
inputContentHashes => _sessionForStream.PinAsync(context, inputContentHashes, cts, urgencyHint),
inputContentHashes => _sessionForPath.PinAsync(context, inputContentHashes, cts, urgencyHint),
result => result.Succeeded));
}
///--------------------------------------------------------------------------------
/// <summary>This method applies workflow deletes.</summary>
///--------------------------------------------------------------------------------
public void ProcessDeleteWorkflowPerformed(WorkflowEventArgs data)
{
try
{
bool isItemMatch = false;
if (data != null && data.Workflow != null)
{
foreach (WorkflowViewModel item in Workflows.ToList <WorkflowViewModel>())
{
if (item.Workflow.WorkflowID == data.Workflow.WorkflowID)
{
// remove item from tabs, if present
WorkspaceEventArgs message = new WorkspaceEventArgs();
message.ItemID = item.Workflow.WorkflowID;
Mediator.NotifyColleagues <WorkspaceEventArgs>(MediatorMessages.Command_CloseItemRequested, message);
// delete children
for (int i = item.Items.Count - 1; i >= 0; i--)
{
if (item.Items[i] is StageViewModel)
{
StageViewModel child = item.Items[i] as StageViewModel;
StageEventArgs childMessage = new StageEventArgs();
childMessage.Stage = child.Stage;
childMessage.WorkflowID = item.Workflow.WorkflowID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.ProcessDeleteStagePerformed(childMessage);
}
}
// delete item
isItemMatch = true;
Workflows.Remove(item);
Solution.WorkflowList.Remove(item.Workflow);
Items.Remove(item);
Solution.ResetModified(true);
OnUpdated(this, null);
break;
}
}
if (isItemMatch == false)
{
ShowIssue(DisplayValues.Issue_DeleteItemNotFound);
}
}
}
catch (Exception ex)
{
ShowIssue(ex.Message + ex.StackTrace);
}
}
public void Assigns_To_Given_UserId()
{
var userId = Guid.NewGuid();
var assignRequest = new AssignRequest();
Service.Setup(s => s.Execute(It.IsAny <AssignRequest>()))
.Returns(new AssignResponse())
.Callback <AssignRequest>(a => assignRequest = a);
Workflows.AssignWorkflowsToUser(WorkflowCollection, userId);
Assert.AreEqual(userId, assignRequest.Assignee.Id);
}
/// <inheritdoc />
public Task <IEnumerable <Task <Indexed <PinResult> > > > PinAsync(Context context, IReadOnlyList <ContentHash> contentHashes, CancellationToken cts, UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
if (WriteThroughContentSession != null)
{
return(Workflows.RunWithFallback(
contentHashes,
hashes => WriteThroughContentSession.PinAsync(context, hashes, cts, urgencyHint),
hashes => BackingContentSession.PinAsync(context, hashes, cts, urgencyHint),
result => result.Succeeded));
}
return(BackingContentSession.PinAsync(context, contentHashes, cts, urgencyHint));
}
public void Menu_005_Workflows()
{
var _menu = new MainMenuPage(_driver);
Assert.IsTrue(_menu.MenuContainer.Displayed);
_menu.WorkflowsTabBtn.Click();
SwitchToContent();
var _workflowaPage = new Workflows(_driver);
_workflowaPage.WaitElementIsShown(_workflowaPage.WorkflowForm);
Assert.IsTrue(_workflowaPage.IsDisplayed());
}
public void SignInAsStateSuperAdminTest()
{
try
{
this.SchoolNet().LoadWebPage();
Workflows workflows = new Workflows();
workflows.SignInOutWorkflows.SignInAsStateSuperAdmin();
}
catch (Exception e)
{
TestContext.WriteLine("\nInnerException:\n" + e.InnerException + "\nStackTrace:\n" + e.StackTrace, e);
throw new Exception("\nInnerException:\n" + e.InnerException + "\nStackTrace:\n" + e.StackTrace, e);
}
}
public void Retrieve_Others_Workflows_Queries_With_Correct_Parameters()
{
var userId = Guid.NewGuid();
var query = new QueryExpression();
Service.Setup(s => s.RetrieveMultiple(It.IsAny <QueryExpression>()))
.Returns(WorkflowCollection)
.Callback <QueryExpression>(q => query = q);
Workflows.RetrieveOthersWorkflows(userId);
Assert.AreEqual("workflow", query.EntityName);
Assert.AreEqual(userId, query.Criteria.Conditions[0].Values[0]);
}
/// <summary>
/// Returns user workflows.
/// </summary>
/// <param name="userId">User DB ID.</param>
/// <returns>User worklofws.</returns>
public Workflow[] GetUserWorkflows(string userId)
{
try
{
var userWorkflows = Database.GetUserWorkflows(userId).ToArray();
var workflows = Workflows.Where(w => userWorkflows.Contains(w.DbId)).ToArray();
return(workflows);
}
catch (Exception e)
{
Logger.ErrorFormat("Error while retrieving user workflows of user {0}: {1}", userId, e.Message);
return(new Workflow[] { });
}
}
/*
* partial void OnModelCreatingPartial(ModelBuilder modelBuilder)
* {
* modelBuilder.Entity<IdentityUser>()
* .HasDiscriminator<string>(nameof(AspNetUser.UserType))
* .HasValue<GroupUser>(AspNetUser.UserTypes.Group)
* .HasValue<PersonUser>(AspNetUser.UserTypes.Person)
* .HasValue<SystemUser>(AspNetUser.UserTypes.System)
* ;
* }
*/
public IQueryable <Workflow> GetWorkflows(IEnumerable <int> workflowIds)
{
/*
* var workflows = DB.Workflows.Where(w => workflowIds.Contains(w.WorkflowId));
* For whatever reason, linq 2 sql wont translate the above into an IN statement (maybe it only does this for string),
* As such, we have to build out a big long nasty OR predicate then apply which we do below.
*/
var predicate = PredicateBuilder.Create <Workflow>(wf => false);
foreach (var wfid in workflowIds)
{
predicate = predicate.Or(wf => wf.WorkflowId == wfid);
}
return(Workflows.Where(predicate));
}
private void LoadWorkflows()
{
//foreach (string file in Directory.GetFiles(@"C:\Wexflow\Workflows\prod"))
//{
// Database.InsertWorkflow(new Db.Workflow { Xml = File.ReadAllText(file) });
//}
var workflows = Database.GetWorkflows();
foreach (var workflow in workflows)
{
var wf = LoadWorkflowFromDatabase(workflow);
Workflows.Add(wf);
}
}
private async Task <IEnumerable <Task <Indexed <PinResult> > > > PinCoreImplAsync(OperationContext context, IReadOnlyList <ContentHash> contentHashes, DateTime keepUntil)
{
try
{
return(await Workflows.RunWithFallback(
contentHashes,
hashes => CheckInMemoryCaches(hashes, keepUntil),
hashes => UpdateBlobStoreAsync(context, hashes, keepUntil),
result => result.Succeeded));
}
catch (Exception ex)
{
Tracer.Warning(context, $"Exception when querying pins against the VSTS services {ex}");
return(contentHashes.Select((_, index) => Task.FromResult(new PinResult(ex).WithIndex(index))));
}
}
public bool DeleteWorkflows(string name)
{
var wfs =
from w in Workflows
where w.Name == name
select w;
if (!wfs.Any())
{
return(false);
}
Workflows.DeleteAllOnSubmit(wfs);
SubmitChanges();
return(true);
}
public bool DeleteWorkflow(string name, string version)
{
var wf =
(from w in Workflows
where w.Name == name && w.Version == ConvertVersion(version)
select w).SingleOrDefault();
if (wf == null)
{
return(false);
}
Workflows.DeleteOnSubmit(wf);
SubmitChanges();
return(true);
}
private void LoadWorkflow(string path)
{
var workflow = LoadWorkflowFromFile(path);
if (workflow != null)
{
Workflows.Add(workflow);
ScheduleWorkflow(workflow);
}
else
{
Logger.InfoFormat("Trying to load the workflow {0} again.", path);
Thread.Sleep(500);
LoadWorkflow(path);
}
}
/// <summary>
/// Create a host for given workflows.
/// </summary>
/// <param name="domain"></param>
/// <param name="workflows"></param>
public WorkflowHost(Domain domain, IEnumerable <Workflow> workflows)
{
Ensure.NotNull(domain, "domain");
Ensure.NotNull(workflows, "workflows");
PollingIdentity = Environment.GetEnvironmentVariable("COMPUTERNAME") ?? Environment.GetEnvironmentVariable("HOSTNAME");
workflows = workflows.Where(w => w != null).ToArray();
if (!workflows.Any())
{
throw new ArgumentException(Resources.No_workflow_to_host, nameof(workflows));
}
Status = HostStatus.Initialized;
_domain = domain;
_hostedWorkflows = new Workflows(workflows);
OnPollingError(e => ErrorAction.Unhandled);
OnResponseError(e => ErrorAction.Unhandled);
}
public void Leadership_Create_A_Matching_Item()
{
try
{
this.SchoolNet().LoadWebPage();
Workflows workflows = new Workflows();
workflows.SignInAsLeadership();
TestContext.WriteLine("\n--- Create a matching item ---");
workflows.AssessWorkflows.CreateItemWorkflows
.NavigateToEditTestItemChooseNewItemPage()
.EditTestItemCreateNewItemSelectMatching();
//set up data for EditTestItem.aspx
EditPageData editPageData = workflows.AssessWorkflows.EditTestItemCreateNewItemPage.InitData();
editPageData.GetTestDataFromResxResource(
"UITests.Data.Assess.ItemCreateEdit.ItemPropertiesResource",
"UITests.Data.Assess.ItemCreateEdit.MatchingItemResource",
"default_" + this.SchoolNet().TestConfiguration.ApplicationName, 0);
editPageData.ItemTypeData.Name = "OriginalAutomationMatchingItemName";
editPageData.ItemTypeData.Keyword = "OriginalAutomationMatchingItemKeyword";
editPageData.ItemTypeData.Publisher = "SNAutomationTeam";
editPageData.QuestionAnswerData.QuestionAnswerPair.Add("carrot", "orange");
editPageData.QuestionAnswerData.QuestionAnswerPair.Add("eggplant", "purple");
editPageData.QuestionAnswerData.CorrectAnswerPair.Add("carrot", "orange");
editPageData.QuestionAnswerData.CorrectAnswerPair.Add("eggplant", "purple");
editPageData.QuestionAnswerData.StudentAnswerPair.Add("carrot", "orange");
editPageData.QuestionAnswerData.StudentAnswerPair.Add("eggplant", "purple");
editPageData.QuestionAnswerData.PointValuePair.Add("carrot", "5");
editPageData.QuestionAnswerData.PointValuePair.Add("eggplant", "5");
editPageData.StandardPickerData = new StandardPickerDataStructures().GetDefaultStandardPickerData();
workflows.AssessWorkflows.EditTestItemCreateNewItemPage.Data = editPageData;
workflows.AssessWorkflows.CreateItemWorkflows
.EditTestItemCreateNewItemPageInputAndSubmitForm()
.EditItemAvailabilityShareWithEveryone()
.EditItemAvailabilityPageSubmitForm();
workflows.SignOut();
}
catch (Exception e)
{
TestContext.WriteLine("\nInnerException:\n" + e.InnerException + "\nStackTrace:\n" + e.StackTrace);
new DriverCommands().GetScreenshotAndPageSource();
throw new Exception("\nInnerException:\n" + e.InnerException + "\nStackTrace:\n" + e.StackTrace, e);
}
}
protected override void Execute(CodeActivityContext context)
{
MeetingApplyForm meetingApplyForm = new MeetingApplyForm();
YunShanOA.DataAccess.Mapping.YunShanOADataContext dc = new YunShanOADataContext();
meetingApplyForm.ApplyUserName = AssignedTo.Get(context).ApplyUserName;
meetingApplyForm.BeginTime = AssignedTo.Get(context).BeginTime;
meetingApplyForm.Comments = AssignedTo.Get(context).Comments;
meetingApplyForm.EndTime = AssignedTo.Get(context).EndTime;
meetingApplyForm.MeetingIntroduction = AssignedTo.Get(context).MeetingIntroduction;
meetingApplyForm.MeetingStatus = 2;
meetingApplyForm.MeetingTopic = AssignedTo.Get(context).MeetingTopic;
meetingApplyForm.MeetingTypeID = AssignedTo.Get(context).MeetingTypeID;
meetingApplyForm.WFID = context.WorkflowInstanceId;
var query = from p in dc.Workflows where p.WFID == meetingApplyForm.WFID select p;
if (0 == query.Count())
{
YunShanOA.DataAccess.Mapping.Workflows wf = new Workflows();
wf.WFID = meetingApplyForm.WFID;
wf.WFTID = Guid.NewGuid();
dc.Workflows.InsertOnSubmit(wf);
}
var query1 = from p in dc.MeetingApplyForm where p.WFID == meetingApplyForm.WFID select p;
if (0 == query1.Count())
{
dc.MeetingApplyForm.InsertOnSubmit(meetingApplyForm); //将数据插入到MeetingApplyForm表
dc.SubmitChanges(); //提交MeeingApplyForm的更改，以便下面根据WFID来查询MeetingApplyFormID
var quer = from p in dc.MeetingApplyForm where p.WFID == meetingApplyForm.WFID select p;
if (0 != quer.Count())
{
Model.MeetingRoom mar = new Model.MeetingRoom();
mar = MeetingRoomNameAndID.Get(context);
int meetingApplyFormID = quer.First().MeetingApplyFormID;
DataAccess.Mapping.MeetingAndRoom m = new MeetingAndRoom();
m.Status = 2;
m.MeetingApplyFormID = meetingApplyFormID;
m.MeetingRoomID = mar.MeetingRoomID;
dc.MeetingAndRoom.InsertOnSubmit(m);
dc.SubmitChanges();
}
}
Apply.Set(context, meetingApplyForm);
}
private void ReadProjectWorkflows(string directory)
{
var dirInfo = new DirectoryInfo(directory);
var files = dirInfo.GetFiles("*.xaml", SearchOption.AllDirectories);
foreach (var file in files)
{
string fullName = file.FullName;
var wf = new Workflow(this, fullName);
Workflows.Add(PathHelper.MakeRelativePath(fullName, Folder).ToLower(), wf);
if (MainFile.Equals(fullName, StringComparison.InvariantCultureIgnoreCase))
{
InitialWorkflow = wf;
}
}
}
public void SetWorkflow(Workflows workflow)
{
switch (workflow)
{
case Workflows.Model:
ToggleKitbashingMode();
break;
case Workflows.Texture:
break;
}
}
/// <inheritdoc />
protected override async Task <IEnumerable <Task <Indexed <PinResult> > > > PinCoreAsync(
OperationContext context, IReadOnlyList <ContentHash> contentHashes, UrgencyHint urgencyHint, Counter retryCounter, Counter fileCounter)
{
try
{
return(await Workflows.RunWithFallback(
contentHashes,
hashes => CheckInMemoryCache(hashes),
hashes => UpdateDedupStoreAsync(context, hashes),
result => result.Succeeded));
}
catch (Exception ex)
{
context.TracingContext.Warning($"Exception when querying pins against the VSTS services {ex}");
return(contentHashes.Select((_, index) => Task.FromResult(new PinResult(ex).WithIndex(index))));
}
}
/// <inheritdoc />
public Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileAsync(
Context context,
IReadOnlyList <ContentHashWithPath> hashesWithPaths,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
CancellationToken cts,
UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
return(Workflows.RunWithFallback(
hashesWithPaths,
inputHashesWithPaths =>
_sessionForPath.PlaceFileAsync(context, inputHashesWithPaths, accessMode, replacementMode, realizationMode, cts, urgencyHint),
inputHashesWithPaths =>
_sessionForStream.PlaceFileAsync(context, inputHashesWithPaths, accessMode, replacementMode, realizationMode, cts, urgencyHint),
result => result.Code != PlaceFileResult.ResultCode.NotPlacedContentNotFound));
}
