public void GivenCustomerShipment_WhenBuild_ThenPreviousObjectStateIsNull()
{
var workEffort = new ActivityBuilder(this.DatabaseSession).WithDescription("Activity").Build();
this.DatabaseSession.Derive(true);
Assert.IsNull(workEffort.PreviousObjectState);
}
private static void SaveToXaml(ActivityBuilder <int> ab)
{
var path = Path.GetFullPath("../../") + "Workflows\\test.xaml";
StreamWriter sw = File.CreateText(path);
XamlWriter xw = ActivityXamlServices.CreateBuilderWriter(new XamlXmlWriter(sw, new XamlSchemaContext()));
XamlServices.Save(xw, ab);
sw.Close();
}
public MainWindow()
{
builder = new ActivityBuilder();
InitializeComponent();
RegisterMetadata();
InitDesigner();
AddDefaultToolBox();
AddPropertyInspector();
}
public static void WriteToXamlFile(this ActivityBuilder ab, string filepath)
{
// Serialize the workflow to XAML and save it to a file.
using (StreamWriter sw = File.CreateText(filepath))
using (XamlWriter xw = ActivityXamlServices.CreateBuilderWriter(new XamlXmlWriter(sw, new XamlSchemaContext())))
{
XamlServices.Save(xw, ab);
}
}
public BaseCOBJ(ActivityBuilder activityBuilder, List <PropertyCOBJ> properties)
{
Namespace = activityBuilder.Name;
Name = Regex.Match(activityBuilder.Name, @"[^.]*$").Value;
Arguments = activityBuilder.Properties.Select(p => new PropertyCOBJ {
Name = p.Name, FullName = p.Type.FullName
});
Properties = properties;
}
public void GivenCustomerShipment_WhenBuild_ThenLastObjectStateEqualsCurrencObjectState()
{
var workEffort = new ActivityBuilder(this.DatabaseSession).WithDescription("Activity").Build();
this.DatabaseSession.Derive(true);
Assert.AreEqual(new WorkEffortObjectStates(this.DatabaseSession).NeedsAction, workEffort.CurrentObjectState);
Assert.AreEqual(workEffort.LastObjectState, workEffort.CurrentObjectState);
}
public bool TryAdd <T>(WorkflowIdentity definitionIdentity, ActivityBuilder <T> ab)
{
using (MemoryStream stream = new MemoryStream())
{
ActivityPersistenceHelper.SaveActivity(ab, stream);
stream.Position = 0;
return(InstanceDefinitions.TryAdd(definitionIdentity, stream.ToArray()));
}
}
public async void CreateFeedItem(Board board, JunaUser user, string contentType, string title, DateTime dateCreated)
{
var feedItem = new RootCommentFeedItem()
{
Id = Guid.NewGuid(),
ContentType = contentType,
Title = title,
DateCreated = dateCreated,
Actor = user
};
_feedItemRepository.Upsert(feedItem);
var activity = new ActivityBuilder()
.WithActor(user)
.WithVerb(BoardInteractionMetadata.INTERACTION_POST)
.WithObject(feedItem)
.WithTarget(board)
.WithTime(dateCreated)
.Build();
var createFeedItemActivity = _activityRepository.Save(activity);
var boardFeed = _streamClient.Feed(FeedGroup.BoardFeedType, StreamHelper.GetStreamActorId(createFeedItemActivity));
var streamActivity = new Stream.Activity(createFeedItemActivity.Actor, createFeedItemActivity.Verb, createFeedItemActivity.Object)
{
Target = createFeedItemActivity.Target,
ForeignId = createFeedItemActivity.Id.ToString(),
};
await boardFeed.AddActivity(streamActivity);
if (board.Interactions == null)
{
board.Interactions = new BoardInteractionMetadata
{
Likes = 0,
Shares = 0,
Comments = 0,
Followers = 0,
Pins = 0,
Posts = 0,
ActiveUsers = 0
};
}
board.Interactions.Posts++;
_boardRepository.Upsert(board);
await _fcmSenderService.SendFcmBoardNotification(
new JunaNotification
{
Title = title,
Actor = user.DisplayName,
Action = BoardInteractionMetadata.INTERACTION_POST,
ContentType = contentType,
ForeignId = board.BoardType.Equals("private")?0 : board.BoardEvent.ForeignId
},
board,
FCMSenderService.CREATE_OPERATION);
}
private static void SaveUpdatedDefinition(ActivityBuilder wf, string name)
{
string xamlPath = Path.Combine(definitionPath, name);
StreamWriter sw = File.CreateText(xamlPath);
XamlWriter xw = ActivityXamlServices.CreateBuilderWriter(
new XamlXmlWriter(sw, new XamlSchemaContext()));
XamlServices.Save(xw, wf);
sw.Close();
}
private static void CreateFlowchartUpdateMap()
{
ActivityBuilder wf = StartUpdate("FlowchartNumberGuessWorkflow.xaml");
// Get a reference to the root Flowchart activity.
Flowchart fc = wf.Implementation as Flowchart;
// Update the Text of the two WriteLine activities that write the
// results of the user's guess. They are contained in the workflow as the
// True and False action of the "Guess < Target" FlowDecision, which is
// Nodes[4].
FlowDecision guessLow = fc.Nodes[4] as FlowDecision;
// Update the "too low" message.
FlowStep trueStep = guessLow.True as FlowStep;
WriteLine tooLow = trueStep.Action as WriteLine;
tooLow.Text = new CSharpValue <string>("Guess.ToString() + \" is too low.\"");
// Update the "too high" message.
FlowStep falseStep = guessLow.False as FlowStep;
WriteLine tooHigh = falseStep.Action as WriteLine;
tooHigh.Text = new CSharpValue <string>("Guess.ToString() + \" is too high.\"");
// Add the new WriteLine that displays the closing message.
WriteLine wl = new WriteLine
{
Text = new CSharpValue <string>("Guess.ToString() + \" is correct. You guessed it in \" + Turns.ToString() + \" turns.\"")
};
// Create a FlowStep to hold the WriteLine.
FlowStep closingStep = new FlowStep
{
Action = wl
};
// Add this new FlowStep to the True action of the
// "Guess == Guess" FlowDecision
FlowDecision guessCorrect = fc.Nodes[3] as FlowDecision;
guessCorrect.True = closingStep;
// Add the new FlowStep to the Nodes collection.
// If closingStep was replacing an existing node then
// we would need to remove that Step from the collection.
// In this example there was no existing True step to remove.
fc.Nodes.Add(closingStep);
// Create the update map.
CreateUpdateMaps(wf, "FlowchartNumberGuessWorkflow.map");
// Save the updated workflow definition.
SaveUpdatedDefinition(wf, "FlowchartNumberGuessWorkflow_du.xaml");
}
internal static Activity GetRootElementForSymbol(object rootInstance, Activity documentRootElement)
{
ActivityBuilder activityBuilder = rootInstance as ActivityBuilder;
if (activityBuilder != null)
{
documentRootElement = activityBuilder.ConvertToDynamicActivity();
}
return(documentRootElement);
}
/// <summary>
/// Save workflow definition to file
/// </summary>
/// <param name="builder"></param>
/// <param name="path"></param>
private static void SaveActivityBuilder(ActivityBuilder builder, String path)
{
using (var writer = File.CreateText(path))
{
var xmlWriter = new XamlXmlWriter(writer, new XamlSchemaContext());
using (var xamlWriter = ActivityXamlServices.CreateBuilderWriter(xmlWriter))
{
XamlServices.Save(xamlWriter, builder);
}
}
}
public static void SetOriginalActivityBuilder(object instance, ActivityBuilder originalActivityBuilder)
{
if (originalActivityBuilder != null)
{
AttachablePropertyServices.SetProperty(instance, originalActivityBuilderProperty, originalActivityBuilder);
}
else
{
AttachablePropertyServices.RemoveProperty(instance, originalActivityBuilderProperty);
}
}
public static void SetOriginalActivityBuilder(object instance, ActivityBuilder originalActivityBuilder)
{
if (originalActivityBuilder != null)
{
AttachablePropertyServices.SetProperty(instance, originalActivityBuilderProperty, originalActivityBuilder);
}
else
{
AttachablePropertyServices.RemoveProperty(instance, originalActivityBuilderProperty);
}
}
private void SetDefaultContext()
{
if (IsNew)
{
ActivityBuilder builder = new ActivityBuilder()
{
Name = "XInsurance",
Implementation = new Flowchart()
};
this.Designer.Load(builder);
}
}
public static void Test()
{
//
// Demostractrate Serialization
//
var ab = new ActivityBuilder <int>();
ab.Name = "Add";
ab.Properties.Add(new DynamicActivityProperty {
Name = "Operand1", Type = typeof(InArgument <int>)
});
ab.Properties.Add(new DynamicActivityProperty {
Name = "Operand2", Type = typeof(InArgument <int>)
});
ab.Implementation = new Sequence
{
Activities =
{
new WriteLine
{
Text = new VisualBasicValue <string>("Operand1.ToString() + \" + \" + Operand2.ToString()")
},
new Assign <int>
{
To = new ArgumentReference <int>{
ArgumentName = "Result"
},
Value = new VisualBasicValue <int>("Operand1 + Operand2")
}
}
};
var s = Serialize(ab as object);
//
// Demostractrate Deserialization
//
// Load the workflow definition from XAML and invoke it.
var wf = ActivityXamlServices.Load(new StringReader(s)) as DynamicActivity <int>;
Dictionary <string, object> wfParams = new Dictionary <string, object>
{
{ "Operand1", 25 },
{ "Operand2", 15 }
};
int result = WorkflowInvoker.Invoke(wf, wfParams);
Debug.WriteLine(result);
//
// Demonstrate InspectActivity
//
InspectActivity(wf, 0);
}
public static TransferObject Start(ActivityBuilder activityBuilder)
{
TransferObject = new TransferObject();
var rootActivity = activityBuilder.Implementation;
_logger.Trace("Converting root activity to traversal object.");
var traversalObject = FromGenericWWFObject.ToBaseTraversalObject(rootActivity);
TraverseActivities(traversalObject, 0);
return(TransferObject);
}
public TypeBuilder BuildType(ModuleBuilder moduleBuilder, ActivityBuilder activityBuilder, bool fakeType)
{
Type baseType = typeof(Activity);
if (fakeType)
{
baseType = typeof(object);
}
TypeBuilder newType = moduleBuilder.DefineType(activityBuilder.Name, TypeAttributes.Public, baseType);
// generate Constructor
// ctor() : base()
// {
// XamlActivityInitializer.Initialize(this);
// }
MethodAttributes ctorAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName;
BindingFlags baseCtorSearchFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
ConstructorBuilder ctor = newType.DefineConstructor(ctorAttributes, CallingConventions.Standard, Type.EmptyTypes);
ConstructorInfo baseCtor = baseType.GetConstructor(baseCtorSearchFlags, null, Type.EmptyTypes, null);
var ctorILGenerator = ctor.GetILGenerator();
ctorILGenerator.Emit(OpCodes.Ldarg_0);
ctorILGenerator.Emit(OpCodes.Call, baseCtor);
if (fakeType)
{
// Hack: don't call initialize, set properties later
}
else
{
MethodInfo initialize = typeof(XamlActivityInitializer).GetMethod("Initialize", BindingFlags.Static | BindingFlags.Public);
ctorILGenerator.Emit(OpCodes.Ldarg_0);
ctorILGenerator.Emit(OpCodes.Call, initialize);
}
ctorILGenerator.Emit(OpCodes.Ret);
// and generate Properties (including InArguments/OutArguments etc.)
foreach (var prop in activityBuilder.Properties)
{
DefineGetSetProperty(newType, prop.Name, prop.Type);
}
if (fakeType)
{
// Hack: add our own Implementation and Constraints properties, to emulate System.Activity
DefineGetSetProperty(newType, "Implementation", typeof(Activity));
DefineLazyGetProperty(newType, "Constraints", typeof(Collection <Constraint>));
}
return(newType);
}
private void EditButton_Click(object sender, RoutedEventArgs e)
{
ActivityBuilder activityBuilder = new ActivityBuilder((Activity)Activities.SelectedItem);
if (StartCalendar.SelectedDate != null && HourStart.SelectedItem != null && MinuteStart.SelectedItem != null)
{
int startYear = Convert.ToInt32(StartCalendar.SelectedDate.Value.Year.ToString());
int startMonth = Convert.ToInt32(StartCalendar.SelectedDate.Value.Month.ToString());
int startDay = Convert.ToInt32(StartCalendar.SelectedDate.Value.Day.ToString());
int startHour = Convert.ToInt32(HourStart.SelectedItem);
int startMinute = Convert.ToInt32(MinuteStart.SelectedItem);
DateTime startDate = new DateTime(startYear, startMonth, startDay, startHour, startMinute, 0);
activityBuilder.SetStartDate(startDate);
}
if (EndCalendar.SelectedDate != null && HourEnd.SelectedItem != null && MinuteEnd.SelectedItem != null)
{
int endYear = Convert.ToInt32(EndCalendar.SelectedDate.Value.Year.ToString());
int endMonth = Convert.ToInt32(EndCalendar.SelectedDate.Value.Month.ToString());
int endDay = Convert.ToInt32(EndCalendar.SelectedDate.Value.Day.ToString());
int endHour = Convert.ToInt32(HourEnd.SelectedItem);
int endMinute = Convert.ToInt32(MinuteEnd.SelectedItem);
DateTime endDate = new DateTime(endYear, endMonth, endDay, endHour, endMinute, 0);
activityBuilder.SetStartDate(endDate);
}
string split = Name.Text.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).LastOrDefault();
if (split != null && split != "")
{
activityBuilder.SetName(Name.Text.Trim());
}
if (!string.IsNullOrEmpty(States.Text))
{
activityBuilder.SetState(States.SelectedItem.ToString());
}
Activity activity = activityBuilder.Build();
chartData.ReplaceActivity((Activity)Activities.SelectedItem, activity);
StartCalendar.SelectedDates.Clear();
EndCalendar.SelectedDates.Clear();
HourStart.SelectedItem = null;
HourEnd.SelectedItem = null;
MinuteStart.SelectedItem = null;
MinuteEnd.SelectedItem = null;
Activities.SelectedItem = null;
States.SelectedItem = null;
Name.Text = "";
Activities.Items.Refresh();
gantt.SetValues(chartData, "Started");
mainWindow.FrameWithinGrid.Content = gantt;
mainWindow.FrameWithinGrid.Visibility = Visibility.Visible;
EditButton.IsEnabled = false;
}
public static string ToXamlString(this ActivityBuilder ab)
{
// Serialize the workflow to XAML and store it in a string.
StringBuilder sb = new StringBuilder();
using (StringWriter tw = new StringWriter(sb))
using (XamlWriter xw = ActivityXamlServices.CreateBuilderWriter(new XamlXmlWriter(tw, new XamlSchemaContext())))
{
XamlServices.Save(xw, ab);
string serializedAB = sb.ToString();
return(serializedAB);
}
}
/// <summary>
/// Load update map from updated defintion and save it to file *.map
/// </summary>
/// <param name="fileName"></param>
public static void SaveUpdateMap(String fileName)
{
ActivityBuilder wf = LoadActivityBuilder(fileName);
DynamicUpdateMap map = DynamicUpdateServices.CreateUpdateMap(wf);
String path = System.IO.Path.ChangeExtension(fileName, "map");
DataContractSerializer serialize = new DataContractSerializer(typeof(DynamicUpdateMap));
using (FileStream fs = File.Open(path, FileMode.Create))
{
serialize.WriteObject(fs, map);
}
}
/// <summary>
/// Serializes a specified ActivityBuilder object and write the result via specified TextWriter object.
/// </summary>
/// <param name="writer">The writer to write result.</param>
/// <param name="builder">A specified ActivityBuilder object.</param>
public void Serialize(TextWriter writer, ActivityBuilder builder)
{
using (XmlWriter xmlWriter = XmlWriter.Create(writer, GetXmlSettings()))
{
using (NoUIXamlXmlWriter xamlWriter = new NoUIXamlXmlWriter(xmlWriter, new XamlSchemaContext()))
{
using (XamlWriter activityWriter = ActivityXamlServices.CreateBuilderWriter(xamlWriter))
{
XamlServices.Save(activityWriter, builder);
}
}
}
}
private void AddButton_Click(object sender, RoutedEventArgs e)
{
int startYear = Convert.ToInt32(StartCalendar.SelectedDate.Value.Year.ToString());
int startMonth = Convert.ToInt32(StartCalendar.SelectedDate.Value.Month.ToString());
int startDay = Convert.ToInt32(StartCalendar.SelectedDate.Value.Day.ToString());
int startHour = Convert.ToInt32(HourStart.SelectedItem);
int startMinute = Convert.ToInt32(MinuteStart.SelectedItem);
int endYear = Convert.ToInt32(EndCalendar.SelectedDate.Value.Year.ToString());
int endMonth = Convert.ToInt32(EndCalendar.SelectedDate.Value.Month.ToString());
int endDay = Convert.ToInt32(EndCalendar.SelectedDate.Value.Day.ToString());
int endHour = Convert.ToInt32(HourEnd.SelectedItem);
int endMinute = Convert.ToInt32(MinuteEnd.SelectedItem);
DateTime startDate = new DateTime(startYear, startMonth, startDay, startHour, startMinute, 0);
DateTime endDate = new DateTime(endYear, endMonth, endDay, endHour, endMinute, 0);
Activity activity = new Activity();
if (States.SelectedItem == null)
{
activity = new ActivityBuilder()
.SetName(Name.Text.Trim())
.SetStartDate(startDate)
.SetEndDate(endDate)
.Build();
}
else
{
activity = new ActivityBuilder()
.SetName(Name.Text.Trim())
.SetStartDate(startDate)
.SetEndDate(endDate)
.SetState(States.SelectedItem.ToString())
.Build();
}
activity.Name = Name.Text.Trim();
activity.StartDate = startDate;
activity.EndDate = endDate;
Debug.WriteLine(activity.ToString());
Debug.WriteLine(activity.Name + activity.StartDate + activity.EndDate);
chartData.AddActivity(activity);
StartCalendar.SelectedDates.Clear();
EndCalendar.SelectedDates.Clear();
HourStart.SelectedItem = null;
HourEnd.SelectedItem = null;
MinuteStart.SelectedItem = null;
MinuteEnd.SelectedItem = null;
Name.Text = null;
Activities.Items.Refresh();
gantt.SetValues(chartData, "all");
mainWindow.FrameWithinGrid.Content = gantt;
mainWindow.FrameWithinGrid.Visibility = Visibility.Visible;
}
public override bool CanConvertToString(object value, IValueSerializerContext context)
{
if (!(value is Argument argument))
{
return(false);
}
if (ActivityBuilder.HasPropertyReferences(value))
{
// won't be able to attach the property references if we convert to string
return(false);
}
return(argument.CanConvertToString(context));
}
private static void CreateUpdateMaps(ActivityBuilder wf, string name)
{
// Create the UpdateMap.
DynamicUpdateMap map = DynamicUpdateServices.CreateUpdateMap(wf);
// Serialize it to a file.
string path = Path.Combine(mapPath, name);
DataContractSerializer sz = new DataContractSerializer(typeof(DynamicUpdateMap));
using (FileStream fs = System.IO.File.Open(path, FileMode.Create))
{
sz.WriteObject(fs, map);
}
}
public static string ToXamlString2 <T>(this ActivityBuilder <T> ab)
{
StringBuilder xaml = new StringBuilder();
using (XmlWriter xmlWriter = XmlWriter.Create(xaml, new XmlWriterSettings {
Indent = true, OmitXmlDeclaration = true
}))
using (XamlWriter xamlWriter = new XamlXmlWriter(xmlWriter, new XamlSchemaContext()))
using (XamlWriter xamlServicesWriter = ActivityXamlServices.CreateBuilderWriter(xamlWriter))
{
XamlServices.Save(xamlServicesWriter, ab);
}
return(xaml.ToString());
}
public void SaveActivityBuilder(ActivityBuilder builder, string path)
{
var actualpath = System.IO.Path.GetDirectoryName(path) + "\\wfReadytoUpdate.xaml";
txtWorkflowSnapshot.Text = actualpath;
using (var writer = File.CreateText(actualpath))
{
var xmlWriter = new XamlXmlWriter(writer, new XamlSchemaContext());
using (var xamlWriter = ActivityXamlServices.CreateBuilderWriter(xmlWriter))
{
XamlServices.Save(xamlWriter, builder);
}
}
}
public async Task <IActionResult> InviteToBoardAsync(string id, [FromBody] List <InviteeUserIdList> inviteeUserIdList)
{
if (string.IsNullOrWhiteSpace(id) ||
inviteeUserIdList == null)
{
return(BadRequest());
}
var userId = _identityHelper.GetObjectId(User.Identity as ClaimsIdentity);
var user = _userRepository.GetByObjectId(userId);
var boardId = Guid.Parse((string)id);
var board = _boardsRepository.GetById(boardId);
if (board == null)
{
return(NotFound());
}
foreach (var inviteeUserId in inviteeUserIdList)
{
var inviteeUser = _userRepository.GetByObjectId(inviteeUserId.objectId);
if (user == null)
{
return(Unauthorized());
}
if (inviteeUser == null)
{
return(NotFound());
}
var activity = new ActivityBuilder()
.WithActor(user)
.WithVerb(BoardInteractionMetadata.BOARD_INTERACTION_INVITE)
.WithObject(inviteeUser)
.Build();
_activityRepository.Save(activity);
await _fcmSenderService.SendBoardInviteNotification(
new BoardInviteNotification
{
BoardId = board.Id,
UserId = user.ObjectId,
InviterName = user.DisplayName,
InviteeUserId = inviteeUser.ObjectId,
InvitationLink = $"{appConfig.AppSettings.JunaRestApiEndpoint}/boards/{board.Id}/activities/follow?id={board.Id}"
},
FCMSenderService.CREATE_OPERATION);
}
return(StatusCode(StatusCodes.Status201Created));
}
private void AddDesigner()
{
string strXAML = "";
this._WorkflowDesigner = new WorkflowDesigner();
_WorkflowDesigner.Context.Services.GetService <DesignerConfigurationService>().AnnotationEnabled = true;
_WorkflowDesigner.Context.Services.GetService <DesignerConfigurationService>().TargetFrameworkName = new System.Runtime.Versioning.FrameworkName(".NETFramework", new Version(4, 5));
FlowDocument FD = new FlowDocument();
Paragraph para = new Paragraph();
xamlTextBox.Name = "txtXamlView";
//xamlTextBox.IsReadOnly = true;
xamlTextBox.FontFamily = new System.Windows.Media.FontFamily("Consolas");
if (TransactionMode == "INSERT")
{
strXAML = _ruleSetTemplate == RuleSetTypes.PreValidate ? ReadXAMLFile(_TemplateWithJob) : ReadXAMLFile(_TemplateWithData);
_activitybuilder = XamlServices.Load(ActivityXamlServices.CreateBuilderReader(new XamlXmlReader(new StringReader(strXAML)))) as ActivityBuilder;
_activitybuilder.Name = _idpeRule.Name;
this._WorkflowDesigner.Load(_activitybuilder);
para.Inlines.Add(strXAML);
}
else
{
_activitybuilder = XamlServices.Load(ActivityXamlServices.CreateBuilderReader(new XamlXmlReader(new StringReader(_idpeRule.Xaml)))) as ActivityBuilder;
_activitybuilder.Name = _idpeRule.Name;
this._WorkflowDesigner.Load(_activitybuilder);
para.Inlines.Add(_idpeRule.Xaml);
}
FD.Blocks.Add(para);
xamlTextBox.Document = FD;
xamlTextBox.TextChanged += new System.Windows.Controls.TextChangedEventHandler(TextChangedEventHandler);
//Place the designer canvas in the middle column of the grid.
Grid.SetColumn(this._WorkflowDesigner.View, 1);
t1.Header = "Designer";
t1.Content = this._WorkflowDesigner.View;
TabCtrl.Items.Add(t1);
t2.Header = "XAML";
t2.Content = xamlTextBox;
TabCtrl.Items.Add(t2);
TabCtrl.SelectionChanged += new SelectionChangedEventHandler(TabCtrl_SelectionChanged);
grdwb.Children.Add(TabCtrl);
}
public void FollowUser(JunaUser user, JunaUser followedUser, DateTime time)
{
var activity = new ActivityBuilder()
.WithActor(user)
.WithVerb(InteractionMetadata.INTERACTION_FOLLOW)
.WithObject(followedUser)
.WithTime(time)
.Build();
_activityRepository.Save(activity);
var userFeed = _streamClient.Feed(FeedGroup.UserFeedType, user.ObjectId);
var followUserFeed = _streamClient.Feed(FeedGroup.UserFeedType, followedUser.ObjectId);
userFeed.FollowFeed(FeedGroup.UserFeedType, followedUser.ObjectId);
}
/// <summary>
/// Serializes a specified DynamicActivity object and write the result via specified TextWriter object.
/// </summary>
/// <param name="writer">The writer to write result.</param>
/// <param name="da">The specified DynamicActivity object.</param>
public void Serialize(TextWriter writer, DynamicActivity da)
{
ActivityBuilder builder = new ActivityBuilder
{
Name = da.Name,
Implementation = da.Implementation.Invoke()
};
foreach (var prop in da.Properties)
{
builder.Properties.Add(prop);
}
Serialize(writer, builder);
}
public static string ToXaml(Activity activity)
{
var sBuilder = new StringBuilder();
StringWriter tw = new StringWriter(sBuilder);
XamlWriter xw = ActivityXamlServices.CreateBuilderWriter(new XamlXmlWriter(tw, new XamlSchemaContext()));
using (xw)
{
var activityBuilder =
new ActivityBuilder {
Implementation = activity
};
XamlServices.Save(xw, activityBuilder);
}
return(sBuilder.ToString());
}
public void GivenCustomerShipment_WhenConfirmed_ThenCurrentShipmentStatusMustBeDerived()
{
var workEffort = new ActivityBuilder(this.DatabaseSession).WithDescription("Activity").Build();
this.DatabaseSession.Derive(true);
Assert.AreEqual(1, workEffort.WorkEffortStatuses.Count);
Assert.AreEqual(new WorkEffortObjectStates(this.DatabaseSession).NeedsAction, workEffort.CurrentWorkEffortStatus.WorkEffortObjectState);
workEffort.Finish();
this.DatabaseSession.Derive(true);
Assert.AreEqual(2, workEffort.WorkEffortStatuses.Count);
Assert.AreEqual(new WorkEffortObjectStates(this.DatabaseSession).Completed, workEffort.CurrentWorkEffortStatus.WorkEffortObjectState);
}
public void Serialize(TextWriter writer, object obj)
{
if (obj is DynamicActivity)
{
DynamicActivity da = obj as DynamicActivity;
_activitySerializer.Serialize(writer, da);
}
else if (obj is ActivityBuilder)
{
ActivityBuilder ab = obj as ActivityBuilder;
_activitySerializer.Serialize(writer, ab);
}
else
{
throw new ArgumentException("The parameter obj must be type of DynamicActivity or ActivityBuilder.", "obj"); //NOXLATE
}
}
