public static Type GetBookmarkType(ActivityTypeEnum typeEnum)
{
switch (typeEnum)
{
case ActivityTypeEnum.Process:
return(typeof(StandBookmark));
case ActivityTypeEnum.Decision:
return(typeof(SwitchBookmark));
case ActivityTypeEnum.Start:
return(typeof(StartBookmark));
case ActivityTypeEnum.Parallel:
return(typeof(ParalleBookmark));
case ActivityTypeEnum.SubRouting:
return(typeof(SubRoutingBookmark));
case ActivityTypeEnum.SubRoutings:
return(typeof(SubRoutingsBookmark));
case ActivityTypeEnum.NotifyMsg:
return(typeof(NotifyMsgBookmark));
}
return(null);
}
/// <summary>
/// This method returns all questions based on the activity Type, Name and Behaviour mode.
/// </summary>
/// <param name="activityNameEnum">This is name of the activity type.</param>
/// <param name="activityBehaviourTypeEnum">This is name of the activity behaviour mode.</param>
/// <param name="activityTypeEnum">This is activity name.</param>
/// <returns>Questions List.</returns>
public static List <ActivityQuestionsList> GetAll(ActivityTypeEnum activityTypeEnum,
ActivityBehaviourTypeEnum activityBehaviourTypeEnum, ActivityNameEnum activityNameEnum)
{
return(InMemoryDatabaseSingleton.DatabaseInstance.SelectMany <ActivityQuestionsList>(
x => x.ActivityType == activityTypeEnum && x.ActivityBehaviourType == activityBehaviourTypeEnum &&
x.ActivityName == activityNameEnum).OrderByDescending(x => x.CreationDate).ToList());
}
protected override void OnMouseMove(MouseEventArgs e)
{
base.OnMouseMove(e);
if (e.LeftButton != MouseButtonState.Pressed)
{
this.dragStartPoint = null;
}
if (this.dragStartPoint.HasValue)
{
ActivityTypeEnum typeEnum = Nsun.Workflow.Core.EnumExt.EnumHelper.GetEnumByString <ActivityTypeEnum>
((this.Content as ToolBoxItemExt).BookmarkType);
BookmarkBase bookmark = BookmarkFactory.GetBookmark(typeEnum);
string xamlString = XElement.Parse(bookmark.GetSerialContent()).Value;
DragObject dataObject = new DragObject();
dataObject.Xaml = xamlString;
WrapPanel panel = VisualTreeHelper.GetParent(this) as WrapPanel;
if (panel != null)
{
dataObject.DesiredSize = new Size(bookmark.Size.Key, bookmark.Size.Value);
}
DragDrop.DoDragDrop(this, dataObject, DragDropEffects.Copy);
e.Handled = true;
}
}
public bool CheckSuspiciousActivity(string user, ActivityTypeEnum activityType)
{
ActivityLog reference;
try
{
reference = _db.ActivityLogs.OrderByDescending(a => a.InsertDate).First(a =>
a.User == user && a.ActivityType == activityType);
}
catch (InvalidOperationException)
{
reference = new ActivityLog()
{
User = user,
InsertDate = DateTime.Now.AddMinutes(-5)
};
}
if (reference != null)
{
if ((int)DateTime.Now.Subtract(reference.InsertDate).TotalMinutes < 1)
{
return(true);
}
}
return(false);
}
public static BookmarkBase GetBookmark(ActivityTypeEnum typeEnum)
{
switch (typeEnum)
{
case ActivityTypeEnum.Process:
return(new StandBookmark());
case ActivityTypeEnum.Decision:
return(new SwitchBookmark());
case ActivityTypeEnum.Start:
return(new StartBookmark());
case ActivityTypeEnum.Parallel:
return(new ParalleBookmark());
case ActivityTypeEnum.SubRouting:
return(new SubRoutingBookmark());
case ActivityTypeEnum.SubRoutings:
return(new SubRoutingsBookmark());
case ActivityTypeEnum.NotifyMsg:
return(new NotifyMsgBookmark());
}
return(null);
}
/// <summary>
/// 根据去向节点类型选择转移数据
/// </summary>
/// <param name="appInstanceID">应用实例ID</param>
/// <param name="processGUID">流程GUID</param>
/// <param name="toActivityType">到的活动节点类型</param>
/// <returns>转移实体列表</returns>
internal IEnumerable <TransitionInstanceEntity> GetTransitonInstance(string appInstanceID,
String processGUID,
ActivityTypeEnum toActivityType)
{
//var sql = @"SELECT * FROM WfTransitionInstance
// WHERE AppInstanceID=@appInstanceID
// AND ProcessGUID=@processGUID
// AND ToActivityType=@toActivityType
// ORDER BY CreatedDateTime DESC";
//var transitionList = Repository.Query<TransitionInstanceEntity>(sql,
// new
// {
// appInstanceID = appInstanceID,
// processGUID = processGUID,
// toActivityType = (int)toActivityType
// });
//return transitionList;
var sqlQuery = (from t in Repository.GetAll <TransitionInstanceEntity>()
where t.AppInstanceID == appInstanceID &&
t.ProcessGUID == processGUID &&
t.ToActivityType == (short)toActivityType
select t
);
var list = sqlQuery.OrderByDescending(t => t.CreatedDateTime).ToList <TransitionInstanceEntity>();
return(list);
}
/// <summary>
/// 构造函数，初始化分组信息和数量
/// </summary>
/// <param name="groupName">并发分组名称</param>
/// <param name="parallelCount">并发数量</param>
public AciviyItem(Guid activityId, ActivityTypeEnum activityType, string groupName, XElement activity, int parallelCount = 0)
{
this.GroupName = groupName;
this.ParallelCount = parallelCount;
this.ActivitType = activityType;
this.ActivitId = activityId;
this.Activit = activity;
}
/// <summary>
/// 通过类型获取模板下的所有活动
/// </summary>
/// <param name="doc">模板</param>
/// <param name="activityTypeEnum">活动类型</param>
/// <returns>查询的结果集合</returns>
public static IEnumerable <XElement> GetAllActivitiesByType(XElement doc, ActivityTypeEnum activityTypeEnum)
{
var nodeInfos = from c in doc.Elements(ActivityConst.DESIGNERITEMS).Elements(ActivityConst.DESIGNERITEM)
where c.Element(ActivityConst.TYPE).Value == activityTypeEnum.ToString()
select c;
return(nodeInfos);
}
/// <summary>
/// 是否是可办理的任务节点
/// </summary>
internal static Boolean IsWorkItem(ActivityTypeEnum activityType)
{
return(activityType == ActivityTypeEnum.TaskNode ||
activityType == ActivityTypeEnum.SignNode ||
activityType == ActivityTypeEnum.TimerNode ||
activityType == ActivityTypeEnum.SubProcessNode ||
activityType == ActivityTypeEnum.EndNode);
}
/// <summary>
/// 根据活动类型获取工作项类型
/// </summary>
/// <param name="activityType">活动类型</param>
/// <returns>工作项类型</returns>
internal static WorkItemTypeEnum GetWorkItemType(ActivityTypeEnum activityType)
{
WorkItemTypeEnum workItemType = WorkItemTypeEnum.NonWorkItem;
if (IsWorkItem(activityType))
{
workItemType = WorkItemTypeEnum.IsWorkItem;
}
return(workItemType);
}
/// <summary>
/// 是否简单组件节点
/// </summary>
/// <param name="acitivytType">活动类型</param>
/// <returns>判断结果</returns>
internal static Boolean IsSimpleComponentNode(ActivityTypeEnum activityType)
{
return(activityType == ActivityTypeEnum.TaskNode ||
activityType == ActivityTypeEnum.SignNode ||
activityType == ActivityTypeEnum.TimerNode ||
activityType == ActivityTypeEnum.ScriptNode ||
activityType == ActivityTypeEnum.PluginNode ||
activityType == ActivityTypeEnum.StartNode ||
activityType == ActivityTypeEnum.EndNode);
}
///// <summary>
///// 是否中间事件处理节点
///// </summary>
///// <param name="activityType">活动类型</param>
///// <returns>判断结果</returns>
//internal static Boolean IsIntermediateEventComponentNode(ActivityTypeEnum activityType)
//{
// return activityType == ActivityTypeEnum.IntermediateNode;
//}
///// <summary>
///// 是否服务类型节点
///// </summary>
///// <param name="activityType">活动类型</param>
///// <returns>判断结果</returns>
//internal static Boolean IsServiceComponentNode(ActivityTypeEnum activityType)
//{
// return activityType == ActivityTypeEnum.ServiceNode;
//}
/// <summary>
/// 是否中间事件或服务类型节点
/// </summary>
/// <param name="activityType">活动类型</param>
/// <returns>判断结果</returns>
internal static Boolean IsCrossOverComponentNode(ActivityTypeEnum activityType)
{
if (activityType == ActivityTypeEnum.IntermediateNode ||
activityType == ActivityTypeEnum.ServiceNode)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// 根据活动类型获取工作项类型
/// </summary>
/// <param name="activityType">活动类型</param>
/// <returns>工作项类型</returns>
internal static WorkItemTypeEnum GetWorkItemType(ActivityTypeEnum activityType)
{
WorkItemTypeEnum workItemType = WorkItemTypeEnum.NonWorkItem;
if (activityType == ActivityTypeEnum.TaskNode ||
activityType == ActivityTypeEnum.MultipleInstanceNode ||
activityType == ActivityTypeEnum.SubProcessNode)
{
workItemType = WorkItemTypeEnum.IsWorkItem;
}
return(workItemType);
}
public ActivitiesAttribute(
string description,
string userFullName,
string userEmail,
string userId,
ActivityTypeEnum activityType)
{
_description = description;
_userFullName = userFullName;
_userEmail = userEmail;
_userId = userId;
_activityType = activityType;
}
/// <summary>
/// 是否是可办理的任务节点
/// </summary>
internal static Boolean IsWorkItem(ActivityTypeEnum activityType)
{
if (activityType == ActivityTypeEnum.TaskNode ||
activityType == ActivityTypeEnum.MultipleInstanceNode ||
activityType == ActivityTypeEnum.SubProcessNode)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="element"></param>
/// <returns></returns>
private int GetTriggerCountAndType(XElement element)
{
// 获取节点类型
var type = element.ParseByActivityType();
// 当是标准节点的时候，需要进一步判断是否是并发开始
if (element.ParseByActivityType() == ActivityTypeEnum.Process.ToString())
{
var obj = (StandBookmark)JsonHelper.JsonToT <StandBookmark>(element.Element(ActivityConst.DETAILS).Value);
// 如果遇到并发的起点，说明是并发内部的并发
if (obj.IsParallel)
{
this.Type = ActivityTypeEnum.Process_Parallel;
}
else
{
this.Type = ActivityTypeEnum.Process;
}
}
else
{
// 其他类型，需要转换成对应的Enum类型
this.Type = EnumHelper.GetEnumByString <ActivityTypeEnum>(type);
if (this.Type == ActivityTypeEnum.Decision)
{
var obj = (SwitchBookmark)JsonHelper.JsonToT <SwitchBookmark>(element.Element(ActivityConst.DETAILS).Value);
this.Decision = obj.Condition;
}
else
{
var obj = (SubRoutingBookmark)JsonHelper.JsonToT <SubRoutingBookmark>(element.Element(ActivityConst.DETAILS).Value);
if (string.IsNullOrEmpty(obj.TemplateName))
{
obj.TemplateId = Guid.Empty;
}
this.SubTemplateId = obj.TemplateId;
}
}
// 该类型是否包含在特殊节点中（消息，并发结束等需要知道多少个父在调用）
if (RoutingRule.SpecialType.Contains(type))
{
this.Type = EnumHelper.GetEnumByString <ActivityTypeEnum>(type);
return(XmlHelper.GetAllForwardActivities(_template.ToString(), element.ParseById()).ToList().Count);
}
// 非特殊类型的节点，返回包含多少个后续节点
return(XmlHelper.GetAllNextActivities(_template.ToString(), element.ParseById()).ToList().Count);
}
/// <summary>
/// This constructor should be used when it is impossible to determine
/// the meter's identity.
/// </summary>
/// <param name="eActivityType" type="Itron.Metering.Utilities.MeterActivityLogEntry.ActivityTypeEnum">
/// </param>
/// <param name="eActivityStatus" type="Itron.Metering.Utilities.MeterActivityLogEntry.ActivityStatusEnum">
/// </param>
public MeterActivityLogEntry(ActivityTypeEnum eActivityType,
ActivityStatusEnum eActivityStatus)
{
//Initialize member variables
EventTime = DateTime.Now;
MeterType = "";
UnitID = "";
SerialNumber = "";
Source = "";
SourceVersion = "";
ResultFile = "";
ActivityType = eActivityType;
ActivityStatus = eActivityStatus;
}
/// <summary>
/// 是否简单组件节点
/// </summary>
/// <param name="activityType">活动类型</param>
/// <returns>判断结果</returns>
internal static Boolean IsSimpleComponentNode(ActivityTypeEnum activityType)
{
if (activityType == ActivityTypeEnum.TaskNode ||
activityType == ActivityTypeEnum.MultipleInstanceNode ||
activityType == ActivityTypeEnum.SubProcessNode ||
activityType == ActivityTypeEnum.StartNode ||
activityType == ActivityTypeEnum.EndNode)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// This constructor should be used whenever logging an event and
/// the meter's identity is known.
/// </summary>
/// <param name="strDeviceType" type="string">
/// </param>
/// <param name="strUnitID" type="string">
/// </param>
/// <param name="strSerialNumber" type="string">
/// </param>
/// <param name="eActivityType" type="Itron.Metering.Utilities.MeterActivityLogEntry.ActivityTypeEnum">
/// </param>
/// <param name="eActivityStatus" type="Itron.Metering.Utilities.MeterActivityLogEntry.ActivityStatusEnum">
/// </param>
public MeterActivityLogEntry(String strDeviceType,
String strUnitID,
String strSerialNumber,
ActivityTypeEnum eActivityType,
ActivityStatusEnum eActivityStatus)
{
//Initialize member variables
EventTime = DateTime.Now;
MeterType = strDeviceType;
UnitID = strUnitID;
SerialNumber = strSerialNumber;
Source = "";
SourceVersion = "";
ResultFile = "";
ActivityType = eActivityType;
ActivityStatus = eActivityStatus;
}
/// <summary>
/// 根据去向节点类型选择转移数据
/// </summary>
/// <param name="appInstanceID">应用实例ID</param>
/// <param name="processGUID">流程GUID</param>
/// <param name="toActivityType">到的活动节点类型</param>
/// <returns>转移实体列表</returns>
internal IEnumerable <TransitionInstanceEntity> GetTransitonInstance(string appInstanceID,
String processGUID,
ActivityTypeEnum toActivityType)
{
//var sql = @"SELECT * FROM WfTransitionInstance
// WHERE AppInstanceID=@appInstanceID
// AND ProcessGUID=@processGUID
// AND ToActivityType=@toActivityType
// ORDER BY CreatedDateTime DESC";
using (var session = DbFactory.CreateSession())
{
var instanceList = session.GetRepository <TransitionInstanceEntity>().Query(e => e.AppInstanceID == appInstanceID &&
e.ProcessGUID == processGUID &&
e.ToActivityType == (short)toActivityType)
.OrderByDescending(e => e.CreatedDateTime)
.ToList();
return(instanceList);
}
}
public bool AddActivity(int userId, ActivityTypeEnum activityType, string description)
{
UserEntity user = _userRepository.FindOne(x => x.Id == userId);
if (user == null)
{
return(false);
}
ActivityEntity activity = new ActivityEntity();
activity.UserId = userId;
activity.TypeId = activityType;
activity.Description = description;
activity = _activityRepository.Insert(activity);
return(activity.Id > 0);
}
/// <summary>
/// 根据去向节点类型选择转移数据
/// </summary>
/// <param name="appInstanceID">应用实例ID</param>
/// <param name="processGUID">流程GUID</param>
/// <param name="toActivityType">到的活动节点类型</param>
/// <returns>转移实体列表</returns>
internal IEnumerable <TransitionInstanceEntity> GetTransitonInstance(string appInstanceID,
String processGUID,
ActivityTypeEnum toActivityType)
{
var sql = @"SELECT * FROM WfTransitionInstance
WHERE AppInstanceID=@appInstanceID
AND ProcessGUID=@processGUID
AND ToActivityType=@toActivityType
ORDER BY CreatedDateTime DESC";
var list = Repository.Query <TransitionInstanceEntity>(sql,
new
{
appInstanceID = appInstanceID,
processGUID = processGUID,
toActivityType = (int)toActivityType
});
return(list);
}
/// <summary>
/// Initializes a new instance of the <see cref="GetActivityResponseActivities" /> class.
/// </summary>
/// <param name="actingMemberId">actingMemberId (required).</param>
/// <param name="activityType">activityType (required).</param>
/// <param name="commentId">commentId.</param>
/// <param name="created">created (required).</param>
/// <param name="emojiId">emojiId.</param>
/// <param name="id">id (required).</param>
public GetActivityResponseActivities(int?actingMemberId = default(int?), ActivityTypeEnum activityType = default(ActivityTypeEnum), int?commentId = default(int?), string created = default(string), int?emojiId = default(int?), int?id = default(int?))
{
// to ensure "actingMemberId" is required (not null)
if (actingMemberId == null)
{
throw new InvalidDataException("actingMemberId is a required property for GetActivityResponseActivities and cannot be null");
}
else
{
this.ActingMemberId = actingMemberId;
}
// to ensure "activityType" is required (not null)
if (activityType == null)
{
throw new InvalidDataException("activityType is a required property for GetActivityResponseActivities and cannot be null");
}
else
{
this.ActivityType = activityType;
}
// to ensure "created" is required (not null)
if (created == null)
{
throw new InvalidDataException("created is a required property for GetActivityResponseActivities and cannot be null");
}
else
{
this.Created = created;
}
// to ensure "id" is required (not null)
if (id == null)
{
throw new InvalidDataException("id is a required property for GetActivityResponseActivities and cannot be null");
}
else
{
this.Id = id;
}
this.CommentId = commentId;
this.EmojiId = emojiId;
}
public async Task TrackActivity(
string firstName,
string lastName,
string email,
ActivityTypeEnum activityType,
string description,
string userId,
DataContext ctx)
{
var activityEntity = new Activity
{
Description = description,
UserId = userId,
Email = email,
FirstName = firstName,
LastName = lastName,
ActivityType = activityType
};
await ctx.Activities.AddAsync(activityEntity);
}
public static ActivityType ToType(ActivityTypeEnum enumValue)
{
switch (enumValue)
{
case ActivityTypeEnum.ContractorTime:
return(ContractorTime);
case ActivityTypeEnum.StaffTime:
return(StaffTime);
case ActivityTypeEnum.Supplies:
return(Supplies);
case ActivityTypeEnum.Travel:
return(Travel);
case ActivityTypeEnum.Treatment:
return(Treatment);
default:
throw new ArgumentException(string.Format("Unable to map Enum: {0}", enumValue));
}
}
public double ActivityMultiplier(ActivityTypeEnum activity)
{
switch (activity)
{
case ActivityTypeEnum.NoExerciseOfficeWork:
return(1.2);
case ActivityTypeEnum.Light:
return(1.4);
case ActivityTypeEnum.Moderate:
return(1.6);
case ActivityTypeEnum.High:
return(1.75);
case ActivityTypeEnum.VeryHigt:
return(2.1);
default:
return(0);
}
}
/// <summary>
/// 根据去向节点类型选择转移数据
/// </summary>
/// <param name="appName"></param>
/// <param name="appInstanceID"></param>
/// <param name="processGUID"></param>
/// <param name="toActivityType"></param>
/// <returns></returns>
internal IEnumerable<TransitionInstanceEntity> GetTransitonInstance(string appInstanceID,
String processGUID,
ActivityTypeEnum toActivityType)
{
var sql = @"SELECT * FROM WfTransitionInstance
WHERE AppInstanceID=@appInstanceID
AND ProcessGUID=@processGUID
AND ToActivityType=@toActivityType
ORDER BY CreatedDateTime DESC";
var transitionList = Repository.Query<TransitionInstanceEntity>(sql,
new
{
appInstanceID = appInstanceID,
processGUID = processGUID,
toActivityType = toActivityType
});
return transitionList;
}
/// <summary>
/// 是否中间事件处理节点
/// </summary>
/// <param name="activityType">活动类型</param>
/// <returns>判断结果</returns>
internal static Boolean IsIntermediateEventComponentNode(ActivityTypeEnum activityType)
{
return(activityType == ActivityTypeEnum.IntermediateNode);
}
/// <summary>
/// 是否复合逻辑处理节点
/// </summary>
/// <param name="activityType">活动类型</param>
/// <returns>判断结果</returns>
internal static Boolean IsGatewayComponentNode(ActivityTypeEnum activityType)
{
return(activityType == ActivityTypeEnum.GatewayNode);
}
public async Task <List <Activity> > GetActivityLisrByTeacherIdAndType(int teacherId, ActivityTypeEnum activityType)
{
return(await _dbContext.Activities.Where(a => a.TeacherActivities.FirstOrDefault().TeacherId == teacherId && a.ActivityType == (int)activityType).ToListAsync());
}
public IEnumerable <Activity> GetActivities(ActivityTypeEnum type)
{
return(DataList.Where(a => a.ActivityType == type));
}
