/// <summary>
/// Returns the dataset loaded from the given document data.
/// </summary>
/// <param name="documentData">Document data to make the dataset from</param>
/// <param name="taskType">Task type</param>
/// <param name="taskObjectType">Task object type</param>
protected virtual DataSet GetDataSet(string documentData, TaskTypeEnum taskType, string taskObjectType)
{
SyncHelper syncHelper = SyncHelper.GetInstance();
syncHelper.OperationType = OperationTypeEnum.Synchronization;
string className = CMSHierarchyHelper.GetNodeClassName(documentData, ExportFormatEnum.XML);
DataSet ds = syncHelper.GetSynchronizationTaskDataSet(taskType, className, taskObjectType);
XmlParserContext xmlContext = new XmlParserContext(null, null, null, XmlSpace.None);
XmlReader reader = new XmlTextReader(documentData, XmlNodeType.Element, xmlContext);
return DataHelper.ReadDataSetFromXml(ds, reader, null, null);
}
/// <summary>
/// 更新使用属性
/// </summary>
public void UpdateFlag(TaskTypeEnum flag)
{
try
{
CommonSQL.UpdateDevInfo(devName, (int)flag);
taskType = flag;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Returns the dataset loaded from the given document data.
/// </summary>
/// <param name="documentData">Document data to make the dataset from</param>
/// <param name="taskType">Task type</param>
/// <param name="taskObjectType">Task object type</param>
protected virtual DataSet GetDataSet(string documentData, TaskTypeEnum taskType, string taskObjectType)
{
var man = SyncManager.GetInstance();
man.OperationType = OperationTypeEnum.Synchronization;
string className = DocumentHierarchyHelper.GetNodeClassName(documentData, ExportFormatEnum.XML);
DataSet ds = man.GetSynchronizationTaskDataSet(taskType, className, taskObjectType);
XmlParserContext xmlContext = new XmlParserContext(null, null, null, XmlSpace.None);
XmlReader reader = new XmlTextReader(documentData, XmlNodeType.Element, xmlContext);
return(DataHelper.ReadDataSetFromXml(ds, reader, null, null));
}
public object ConvertBack(object value, Type targetTypes, object parameter, CultureInfo culture)
{
if ((bool)value)
{
TaskTypeEnum taskTypeEnum = (TaskTypeEnum)int.Parse(parameter.ToString());
return(taskTypeEnum);
}
else
{
return(string.Empty);
}
}
private string ActivityFunctionComplete(TaskTypeEnum TaskType)
{
var table = new Dictionary <TaskTypeEnum, string> {
{ TaskTypeEnum.DanDas, nameof(DandasCompleteData) },
{ TaskTypeEnum.Danvand, nameof(DanvandCompleteData) },
{ TaskTypeEnum.SroData, nameof(SROCompleteData) }
};
if (table.ContainsKey(TaskType))
{
return(table[TaskType]);
}
return(string.Empty);
}
/// <summary>
/// 更新锁定状态
/// </summary>
public void IsLockUnlockNew(TaskTypeEnum tt, bool islock, string lockid = "")
{
try
{
CommonSQL.UpdateDevInfo((int)tt, devName, lockid, "", islock);
taskType = tt;
isLock = islock;
lockID = lockid;
}
catch (Exception ex)
{
throw ex;
}
}
public void AddTask(TaskTypeEnum taskType, Dictionary<TaskParamsKey, string> parameters)
{
Logger.WriteInfo("AddTask " + taskType.ToString());
if (parameters != null && parameters.ContainsKey(TaskParamsKey.NextRunTime))
{
BaseTask.AddNew(taskType, parameters, minStartDate: DateTime.Parse(parameters[TaskParamsKey.NextRunTime]));
parameters.Remove(TaskParamsKey.NextRunTime);
}
else
{
BaseTask.AddNew(taskType, parameters);
}
}
/// <summary>
/// 移至待命点
/// </summary>
/// <returns></returns>
public bool Standby(string area, TaskTypeEnum tt, int site)
{
try
{
bool res = false;
if (devices.Exists(c => c.area == area && c.taskType == tt && c.isUseful))
{
DevInfoARF a = devices.Find(c => c.area == area && c.taskType == tt && c.isUseful);
if (a._.CurrentTask == TaskEnum.辊台任务 && a._.FinishTask == TaskEnum.辊台任务)
{
a.StopRoller();
}
if (a.isLock)
{
if (a._.CurrentSite != site)
{
res = true;
}
}
else
{
int sb = tt == TaskTypeEnum.入库 ? ADS.mDis.GetArfStandByP1(a.area) : ADS.mDis.GetArfStandByP2(a.area);
if (Math.Abs(a._.CurrentSite - sb) <= 2)
{
res = true;
}
else
{
if (a.isUseful && ADS.mSocket.IsConnected(a.devName) && a._.ActionStatus == ActionEnum.停止)
{
a.ToSite(sb);
}
}
}
}
else
{
res = true;
}
return(res);
}
catch (Exception ex)
{
throw ex;
}
}
WithTask <TFlowTask>(TaskTypeEnum type, string v)
where TFlowTask : IFlowTask <TFlowDataType, TContextType>
{
if (Element.Tasks == null)
{
Element.Tasks = new List <TaskDefinition>();
}
var task = new TaskDefinition
{
Type = typeof(TFlowTask),
TaskType = type,
RequiresValidDataToExecute = false
};
Element.Tasks.Add(task);
return(this);
}
private void ProcessTask_After(object sender, StagingSynchronizationEventArgs e)
{
if (e.TaskType == TaskTypeEnum.UpdateDocument || e.TaskType == TaskTypeEnum.CreateDocument || e.TaskType == TaskTypeEnum.MoveDocument || e.TaskType == TaskTypeEnum.PublishDocument || e.TaskType == TaskTypeEnum.ArchiveDocument)
{
// Seems the first table is always the node's table, the table name dose change by the document page type.
DataTable NodeTable = e.TaskData.Tables[0];
if (NodeTable != null && NodeTable.Columns.Contains("NodeGuid"))
{
// Don't want to trigger updates as we set the data in the database, so we won't log synchronziations
TreeNode NodeObj = new DocumentQuery().WhereEquals("NodeGUID", NodeTable.Rows[0]["NodeGuid"]).FirstOrDefault();
using (new CMSActionContext()
{
LogSynchronization = false,
LogIntegration = false
})
{
List <int> NewNodeCategoryIDs = RelHelper.NewBoundObjectIDs(e, TreeCategoryInfo.OBJECT_TYPE, "NodeID", "CategoryID", CategoryInfo.TYPEINFO);
// Now handle categories, deleting categories not found, and adding ones that are not set yet.
TreeCategoryInfo.Provider.Get().WhereEquals("NodeID", NodeObj.NodeID).WhereNotIn("CategoryID", NewNodeCategoryIDs).ForEachObject(x => x.Delete());
List <int> CurrentCategories = TreeCategoryInfo.Provider.Get().WhereEquals("NodeID", NodeObj.NodeID).Select(x => x.CategoryID).ToList();
foreach (int NewCategoryID in NewNodeCategoryIDs.Except(CurrentCategories))
{
TreeCategoryInfo.Provider.Add(NodeObj.NodeID, NewCategoryID);
}
}
if (RelHelper.IsStagingEnabled(NodeObj.NodeSiteID))
{
TaskTypeEnum TaskTypeToUse = e.TaskType;
switch (e.TaskType)
{
case TaskTypeEnum.MoveDocument:
TaskTypeToUse = TaskTypeEnum.UpdateDocument;
break;
}
// Check if we need to generate a task for a server that isn't the origin server
RelHelper.CheckIfTaskCreationShouldOccur(NodeObj.NodeGUID, TaskTypeToUse);
}
}
else
{
Service.Resolve <IEventLogService>().LogEvent(EventTypeEnum.Error, "RelationshipExended", "No Node Table Found", eventDescription: "First Table in the incoming Staging Task did not contain the Node GUID, could not processes.");
}
}
}
WithUiTask(TaskTypeEnum type, string uiTask)
{
if (Element.Tasks == null)
{
Element.Tasks = new List <TaskDefinition>();
}
var task = new TaskDefinition
{
Type = null,
TaskType = type,
ExecuteOn = ExecuteOn.Ui,
RequiresValidDataToExecute = false,
UiTask = uiTask
};
Element.Tasks.Add(task);
return(this);
}
/// <summary>
/// 摆渡车是否送货中
/// </summary>
/// <param name="area"></param>
/// <param name="tt"></param>
/// <returns></returns>
public bool IsGiving(string area, TaskTypeEnum tt)
{
try
{
bool res = false;
if (devices.Exists(c => c.area == area && c.taskType == tt && c.isUseful))
{
DevInfoARF a = devices.Find(c => c.area == area && c.taskType == tt && c.isUseful);
if (ADS.mSocket.IsConnected(a.devName) && a._.CommandStatus == CommandEnum.命令正常 && a._.DeviceStatus == DeviceEnum.设备正常)
{
if (a._.ActionStatus == ActionEnum.停止)
{
a.StartGiveRoll(tt);
}
else
{
if (a._.CurrentTask == TaskEnum.辊台任务)
{
if (a._.GoodsStatus != GoodsEnum.辊台无货)
{
if (a._.CurrentTask == TaskEnum.辊台任务)
{
a.StartGiveRoll(tt);
}
}
else
{
if (a._.FinishTask == TaskEnum.辊台任务)
{
a.StopRoller();
}
}
res = true;
}
}
}
}
return(res);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 移动对接点
/// </summary>
public bool MovingButtSite(string area, TaskTypeEnum tt, int site)
{
try
{
bool res = false;
if (devices.Exists(c => c.area == area && c.taskType == tt && c.isUseful))
{
DevInfoARF a = devices.Find(c => c.area == area && c.taskType == tt && c.isUseful);
if (!ADS.mSocket.IsConnected(a.devName) ||
a._.CommandStatus == CommandEnum.命令错误 ||
a._.DeviceStatus == DeviceEnum.设备故障)
{
return(res);
}
if (a._.CurrentTask == TaskEnum.辊台任务 && a._.FinishTask == TaskEnum.辊台任务)
{
a.StopRoller();
}
if (Standby(area, tt == TaskTypeEnum.入库 ? TaskTypeEnum.出库 : TaskTypeEnum.入库, site))
{
if (a._.CurrentSite != site)
{
if (a._.ActionStatus == ActionEnum.停止)
{
a.ToSite(site);
}
}
else
{
res = true;
}
}
}
return(res);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 锁定摆渡车
/// </summary>
/// <param name="area"></param>
/// <param name="tt"></param>
/// <returns></returns>
public bool IsLock(string area, TaskTypeEnum tt, string lockid)
{
try
{
bool res = false;
if (devices.Exists(c => c.area == area && c.taskType == tt && c.isUseful))
{
DevInfoARF a = devices.Find(c => c.area == area && c.taskType == tt && c.isUseful);
switch (tt)
{
case TaskTypeEnum.入库:
if (a.isLock && a.lockID == lockid)
{
res = true;
}
else if (a._.GoodsStatus == GoodsEnum.辊台无货)
{
a.IsLockUnlock(true, lockid);
}
break;
case TaskTypeEnum.出库:
if (a.isLock && a.lockID == lockid)
{
res = true;
}
else if (a._.GoodsStatus != GoodsEnum.辊台无货)
{
a.IsLockUnlock(true, lockid);
}
break;
default:
break;
}
}
return(res);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 是否有空闲摆渡车
/// </summary>
/// <returns></returns>
public bool IsFreeARF(string area, TaskTypeEnum tt)
{
try
{
ChangeFlag(area);
bool res = false;
if (devices.Exists(c => c.area == area && c.taskType == tt && c.isUseful))
{
DevInfoARF a = devices.Find(c => c.area == area && c.taskType == tt && c.isUseful);
if (ADS.mSocket.IsConnected(a.devName) &&
a._.CommandStatus != CommandEnum.命令错误 && a._.DeviceStatus != DeviceEnum.设备故障)
{
if (a._.CurrentTask == TaskEnum.辊台任务 && a._.FinishTask == TaskEnum.辊台任务)
{
a.StopRoller();
}
if (a.isLock)
{
if (a._.GoodsStatus == GoodsEnum.辊台无货 && a._.ActionStatus == ActionEnum.停止)
{
// 停止&解锁
a.StopTask();
a.IsLockUnlock(false);
res = true;
}
}
else
{
res = true;
}
}
}
return(res);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 更新锁定状态
/// </summary>
public void IsLockUnlockNew(TaskTypeEnum tt, bool islock, string lockid1 = "", string lockid2 = "")
{
try
{
CommonSQL.UpdateDevInfo((int)tt, devName, lockid1, lockid2, islock);
taskType = tt;
isLock = islock;
lockID1 = lockid1;
lockID2 = lockid2;
if (tt == TaskTypeEnum.无)
{
GiveSite = 0;
TakeSite = 0;
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 摆渡车作业判断执行送货？
/// </summary>
public static bool JobPartARF_Give(string jobid, TaskTypeEnum tt)
{
bool result = false;
switch (tt)
{
case TaskTypeEnum.入库:
// 入库送货--运输车是否到位
result = mRgv.IsGiveButtRGV(jobid, DevType.摆渡车);
break;
case TaskTypeEnum.出库:
// 出库送货--固定辊台是否到位
result = mFrt.IsTaskConform(jobid, tt, TaskStatus.taking);
break;
default:
break;
}
return(result);
}
/// <summary>
/// 添加任务
/// </summary>
/// <param name="task"></param>
public void AddTask(string jobid, string area, TaskTypeEnum tasktype, int goodsnum, int takesite, int givesite)
{
int id = ADS.ID;
ADS.PlusID();
TaskARF t = new TaskARF()
{
id = id,
jobid = jobid,
area = area,
tasktype = tasktype,
goodsnum = goodsnum,
takesite = takesite,
givesite = givesite,
taskstatus = TaskStatus.init,
device = new DevInfoARF()
};
task.Add(t);
t.InsertDB();
}
public static UserTask CreateUserTask(ApplicationDbContext db, TaskTypeEnum taskType, string taskDescription, Guid referenceKey, string referenceEmail, Guid referenceOrganisationId, IPrincipal user)
{
UserTask userTask = new UserTask()
{
UserTaskId = Guid.NewGuid(),
TaskType = taskType,
TaskDescription = taskDescription,
ReferenceKey = referenceKey,
ReferenceEmail = referenceEmail,
OrganisationId = referenceOrganisationId,
EntityStatus = EntityStatusEnum.Active,
RecordChange = RecordChangeEnum.NewRecord,
RecordChangeBy = AppUserHelpers.GetAppUserIdFromUser(user),
RecordChangeOn = DateTime.Now
};
db.UserTasks.Add(userTask);
db.SaveChanges();
return(userTask);
}
/// <summary>
/// 添加任务
/// </summary>
/// <param name="task"></param>
public void AddTask(string jobid, string area, TaskTypeEnum tasktype, int goodsnum, DevType fromdev, DevType todev)
{
int id = ADS.ID;
ADS.PlusID();
TaskPKL t = new TaskPKL()
{
id = id,
jobid = jobid,
area = area,
tasktype = tasktype,
goodsnum = goodsnum,
fromdev = fromdev,
todev = todev,
taskstatus = TaskStatus.init,
device = new DevInfoPKL()
};
task.Add(t);
t.InsertDB();
}
public async Task <List <string> > StartOrchestrator(
[OrchestrationTrigger] IDurableOrchestrationContext context,
ILogger log)
{
var outputs = new List <string>();
var taskItem = context.GetInput <TaskItem>();
if (taskItem == null)
{
outputs.Add("Error getting task information");
return(outputs);
}
TaskTypeEnum taskType = (TaskTypeEnum)taskItem.TaskType;
string prepare = ActivityFunctionPrepare(taskType);
var resultPrepare = await context.CallActivityAsync <ProcessResult>(prepare, taskItem.CustomerId);
outputs.Add(resultPrepare.Information);
if (!resultPrepare.Sucess)
{
return(outputs);
}
string process = ActivityFunctionProcess(taskType);
var resultProcess = await context.CallActivityAsync <ProcessResult>(process, taskItem.CustomerId);
outputs.Add(resultProcess.Information);
if (!resultProcess.Sucess)
{
return(outputs);
}
string complete = ActivityFunctionComplete(taskType);
var resultComplete = await context.CallActivityAsync <ProcessResult>(complete, taskItem.CustomerId);
outputs.Add(resultComplete.Information);
return(outputs);
}
public static UserTask CreateUserTask(ApplicationDbContext db, TaskTypeEnum taskType, string taskDescription, Guid referenceKey, Guid createdBy, EntityStatusEnum entityStatus)
{
UserTask userTask = new UserTask()
{
UserTaskId = Guid.NewGuid(),
TaskType = taskType,
TaskDescription = taskDescription,
ReferenceKey = referenceKey,
CreatedOn = DateTime.Now,
CreatedBy = createdBy,
EntityStatus = entityStatus
};
db.UserTasks.Add(userTask);
CreateAdminListForTask(db, userTask);
CreateManagerListForTask(db, userTask);
db.SaveChanges();
return(userTask);
}
public List <int> GetTimeScheduleredCustomers(TaskTypeEnum taskType)
{
switch (taskType)
{
case TaskTypeEnum.Danvand:
return(new List <int> {
130, 45, 28, 15, 16
});
case TaskTypeEnum.DanDas:
return(new List <int> {
130, 45, 28, 15, 16
});
case TaskTypeEnum.SroData:
return(new List <int> {
131, 46, 29, 199, 996
});
default:
return(new List <int>());
}
}
public static void AddNew(TaskTypeEnum taskType, Dictionary<TaskParamsKey, string> parameters = null, DateTime? minStartDate = null, int? parentTaskId = null)
{
Task task = new Task();
task.CreateDate = DateTime.Now;
task.TaskStatus = TaskStatus.Pending;
task.TaskTypeEnum = taskType;
task.MinStartDate = minStartDate;
task.ParentTaskId = parentTaskId;
if (parameters != null)
{
task.TaskParams = new List<TaskParam>();
foreach (var item in parameters)
{
task.TaskParams.Add(new TaskParam(item.Key, item.Value));
}
}
using (var dbFactory = new DatabaseFactory())
{
var repository = new TaskQueueRepository(dbFactory);
repository.Add(task);
}
}
/// <summary>
/// 接货任务
/// </summary>
/// <param name="tasktype"></param>
/// <param name="goodsnum"></param>
public void StartTakeRoll(TaskTypeEnum tasktype, int goodsnum)
{
byte roller = (byte)RollerStatusEnum.辊台全启动;
byte direction;
byte take = (byte)RollerTypeEnum.接货;
byte goods = (byte)goodsnum;
switch (tasktype)
{
case TaskTypeEnum.入库:
direction = (byte)RollerDiretionEnum.正向;
break;
case TaskTypeEnum.出库:
direction = (byte)RollerDiretionEnum.反向;
break;
default:
return;
}
// 字头 设备号 控制码 值1 值2 值3 值4 结束符
byte[] order = new byte[] { 0x96, 0x02, 0x01, 0x02, roller, direction, take, goods, 0xFF, 0xFE };
ADS.mSocket.SendOrder(devName, order, true);
}
private bool GetReportFromRequest(HttpRequest request, TaskTypeEnum taskTypeEnum, out ReportDTO reportReqDTO)
{
string errorMessage = null;
reportReqDTO = null;
APIRequestDTO requestDTO;
try
{
if (!Library.GetDTOFromRequest(request, out requestDTO, taskTypeEnum.ToString(), ref errorMessage))
{
Global.Log.Error(errorMessage);
return(false);
}
reportReqDTO = (ReportDTO)requestDTO;
Global.Log.DebugFormat("User ID: [{0}] reported Info for Task: [{1}]", reportReqDTO.UserID, reportReqDTO.TaskId);
return(true);
}
catch (Exception ex)
{
Global.Log.Error(ex.Message);
return(false);
}
}
public BaseTask CreateTask(TaskTypeEnum taskType)
{
_kernel.Rebind<IDatabaseFactory>().To<DatabaseFactory>().InSingletonScope();
switch (taskType)
{
case TaskTypeEnum.Notifications:
return _kernel.Get<NotificationsTask>();
case TaskTypeEnum.AscGov:
return _kernel.Get<AscGovTask>();
case TaskTypeEnum.HUDAppraiserLicense:
return _kernel.Get<HUDAppraiserLicensesTask>();
case TaskTypeEnum.HUDAppraiserContactInfo:
return _kernel.Get<HUDAppraiserContactInfoTask>();
case TaskTypeEnum.LicenseDailyUpdateByAscGov:
return _kernel.Get<LicenseDailyUpdateByAscGov>();
case TaskTypeEnum.LicenseDailyUpdateByHUD:
return _kernel.Get<LicenseDailyUpdateByHUD>();
case TaskTypeEnum.LicenseExpirationCheck:
return _kernel.Get<LicenseExpirationCheck>();
case TaskTypeEnum.SendAppraiserOrderInvitationSMS:
return _kernel.Get<SendAppraiserOrderInvitationSMS>();
case TaskTypeEnum.SendAppraiserOrderInvitationEmail:
return _kernel.Get<SendAppraiserOrderInvitationEmail>();
case TaskTypeEnum.AssignmentAppraisersForOrder:
return _kernel.Get<AssignmentAppraisersForOrder>();
case TaskTypeEnum.LOEGeneration:
return _kernel.Get<LOEGenerationTask>();
case TaskTypeEnum.OrderPeriodicalNotification:
return _kernel.Get<OrderPeriodicalNotificationTask>();
case TaskTypeEnum.AVMRequest:
return _kernel.Get<AVMRequestTask>();
default:
throw new NotSupportedException(taskType.ToString());
}
}
/// <summary>
/// Custom Staging Task generation
/// </summary>
/// <param name="RelationshipSiteObj"></param>
/// <param name="TaskType"></param>
private void RelationshipNameSite_CreateStagingTask(RelationshipNameSiteInfo RelationshipSiteObj, TaskTypeEnum TaskType)
{
List <ServerInfo> ActiveServers = ServerInfo.Provider.Get().WhereEquals("ServerSiteID", SiteContext.CurrentSiteID).WhereEquals("ServerEnabled", true).ToList();
RelationshipNameInfo RelationshipObj = RelationshipNameInfo.Provider.Get(RelationshipSiteObj.RelationshipNameID);
// If relationship obj is already gone, then the Site deletion thing is already handled with the deletion of the relationship name.
if (RelationshipObj == null)
{
return;
}
if (IsCustomAdhocRelationshipName(RelationshipObj) && ActiveServers.Count > 0)
{
string Data = "<NewDataSet>" + RelationshipObj.ToXML("CMS_RelationshipName", false) + "</NewDataSet>";
string TaskTitle = "";
string TaskTitleEnd = "";
switch (TaskType)
{
case TaskTypeEnum.AddToSite:
TaskTitle = "Add";
TaskTitleEnd = "to";
break;
case TaskTypeEnum.RemoveFromSite:
TaskTitle = "Remove";
TaskTitleEnd = "from";
break;
}
StagingTaskInfo SiteTask = new CMS.Synchronization.StagingTaskInfo()
{
TaskTitle = string.Format("{0} Relationship name '{1}' {2} site", TaskTitle, RelationshipObj.RelationshipDisplayName, TaskTitleEnd),
TaskType = TaskType,
TaskObjectType = RelationshipNameInfo.OBJECT_TYPE,
TaskObjectID = RelationshipObj.RelationshipNameId,
TaskData = Data,
TaskTime = DateTime.Now,
TaskSiteID = SiteContext.CurrentSiteID
};
StagingTaskInfo.Provider.Set(SiteTask);
foreach (ServerInfo ServerObj in ActiveServers)
{
// Create synchronization
SynchronizationInfo SyncSiteInfo = new SynchronizationInfo()
{
SynchronizationTaskID = SiteTask.TaskID,
SynchronizationServerID = ServerObj.ServerID
};
SynchronizationInfo.Provider.Set(SyncSiteInfo);
}
TaskGroupInfo TaskGroup = TaskGroupInfoProvider.GetUserTaskGroupInfo(MembershipContext.AuthenticatedUser.UserID);
if (TaskGroup != null)
{
TaskGroupTaskInfo.Provider.Add(TaskGroup.TaskGroupID, SiteTask.TaskID);
}
}
}
/// <summary>
/// Processes given object according to task type.
/// It is expected that you use TranslateColumnsToExternal method before you process the task.
/// The TranslateColumnsToExternal needs GetExternalObjectID and GetExternalDocumentID to be implemented.
/// It traverses the given object and tries to translate foreign keys to match external (your) application.
/// </summary>
/// <param name="infoObj">Info object to process</param>
/// <param name="translations">Translation helper object containing translations for given object</param>
/// <param name="taskType">Type of task</param>
/// <param name="dataType">Type of data</param>
/// <param name="siteName">Name of site</param>
/// <param name="errorMessage">Possible error message</param>
/// <returns>Result of processing</returns>
public override IntegrationProcessResultEnum ProcessInternalTaskAsync(GeneralizedInfo infoObj, TranslationHelper translations, TaskTypeEnum taskType, TaskDataTypeEnum dataType, string siteName, out string errorMessage)
{
try
{
// If object is of 'user' type
// You can also use following condition: (((BaseInfo)infoObj) is CMS.SiteProvider.UserInfo)
if (infoObj.ObjectType == PredefinedObjectType.USER)
{
bool log = false;
// Create simple message
string message = "User with username '" + infoObj.ObjectCodeName + "' has been";
switch (taskType)
{
case TaskTypeEnum.CreateObject:
log = true;
message += " created.";
break;
case TaskTypeEnum.UpdateObject:
log = true;
message += " updated.";
break;
case TaskTypeEnum.DeleteObject:
log = true;
message += " deleted.";
break;
}
if (log)
{
EventLogProvider eventLog = new EventLogProvider();
// Log the message
eventLog.LogEvent(EventLogProvider.EVENT_TYPE_INFORMATION, DateTime.Now, ConnectorName, taskType.ToString(), 0, null, 0, null, null, message, 0, null);
}
}
errorMessage = null;
return IntegrationProcessResultEnum.OK;
}
catch (Exception ex)
{
errorMessage = ex.Message;
return IntegrationProcessResultEnum.Error;
}
finally
{
// Clear translations cached during TranslateColumnsToExternal which internally calls GetExternalObjectID, GetExternalDocumentID
// This call is optional but recommended in the case where eg. collision of code names can occur
ClearInternalTranslations();
}
}
private int TestTaskLifeCycleInternal(TaskTypeEnum taskType, ICollection<TaskParam> taskParams = null)
{
var task = new Task();
task.CreateDate = DateTime.Now;
task.TaskTypeEnum = taskType;
task.TaskStatus = TaskStatus.Pending;
task.TaskParams = taskParams;
_repository.Add(task);
_taskQueueManager.ProcessQueue();
using (var dc = new TaskQueueContext())
{
var tTask = dc.Tasks.Single(e => e.TaskTypeId == (int)taskType);
tTask.Should().NotBeNull();
tTask.TaskStatusId.Should().Be((int)TaskStatus.Executing);
}
int maxIterationsCount = 30;
while (maxIterationsCount-- != 0)
{
using (var dc = new TaskQueueContext())
{
var tTask = dc.Tasks.Single(t => t.Id == task.Id);
if (tTask.TaskStatus != TaskStatus.Executing)
break;
Thread.Sleep(1000);
}
}
using (var dc = new TaskQueueContext())
{
var tTask = dc.Tasks.Single(t => t.Id == task.Id);
tTask.TaskStatus.Should().Be(TaskStatus.Completed);
}
return task.Id;
}
/// <summary>
/// Processes given document according to task type.
/// It is expected that you use TranslateColumnsToExternal method before you process the task.
/// The TranslateColumnsToExternal needs GetExternalObjectID and GetExternalDocumentID to be implemented.
/// It traverses the given object and tries to translate foreign keys to match external (your) application.
/// </summary>
/// <param name="node">Document to process</param>
/// <param name="translations">Translation helper object containing translations for given document</param>
/// <param name="taskType">Type of task</param>
/// <param name="dataType">Type of data</param>
/// <param name="siteName">Name of site</param>
/// <param name="errorMessage">Possible error message</param>
/// <returns>Result of processing</returns>
public override IntegrationProcessResultEnum ProcessInternalTaskAsync(TreeNode node, TranslationHelper translations, TaskTypeEnum taskType, TaskDataTypeEnum dataType, string siteName, out string errorMessage)
{
try
{
bool log = false;
// Create simple message
string message = "Document named '" + node.NodeName + "' located at '" + node.NodeAliasPath + "' has been";
switch (taskType)
{
case TaskTypeEnum.CreateDocument:
log = true;
message += " created.";
break;
case TaskTypeEnum.UpdateDocument:
log = true;
message += " updated.";
break;
case TaskTypeEnum.DeleteDocument:
log = true;
message += " deleted.";
break;
}
if (log)
{
EventLogProvider eventLog = new EventLogProvider();
// Log the message
eventLog.LogEvent(EventLogProvider.EVENT_TYPE_INFORMATION, DateTime.Now, ConnectorName, taskType.ToString(), 0, null, node.NodeID, node.DocumentName, null, message, node.NodeSiteID, null);
}
errorMessage = null;
return IntegrationProcessResultEnum.OK;
}
catch (Exception ex)
{
errorMessage = ex.Message;
return IntegrationProcessResultEnum.Error;
}
finally
{
// Clear translations cached during TranslateColumnsToExternal which internally calls GetExternalObjectID, GetExternalDocumentID
// This call is optional but recommended in the case where eg. collision of code names can occur
ClearInternalTranslations();
}
}
/// <summary>
/// Suitable for implementation of synchronous outcoming document processing. Identifiers of object are in their original state.
/// </summary>
/// <param name="node">Document to process</param>
/// <param name="taskType">Type of task</param>
/// <param name="siteName">Name of site</param>
/// <param name="errorMessage">Possible error message</param>
/// <returns>Processing result</returns>
public override IntegrationProcessResultEnum ProcessInternalTaskSync(TreeNode node, TaskTypeEnum taskType, string siteName, out string errorMessage)
{
// Synchronous processing of documents (meaning processing is executed in the context of CMS right away)
// (task is not being logged and processed afterwards in separate thread as in ProcessInternalTaskAsync method)
errorMessage = null;
return IntegrationProcessResultEnum.OK;
}
public void Remap(
BooleanCedent[] booleanCedents,
CategorialCedent[] categorialCedents,
int taskID,
TaskTypeEnum taskType,
string boxIdentity,
out long allRowsInTaskDataMatrixCount)
{
List<AbstractAttributeStruct> abstractAttributes = new List<AbstractAttributeStruct>();
string categoryName;
#region EQUIVALENCE CLASS PROBLEM VARIABLES
int attributeIdentifier;
int literalIdentifier;
int equivalenceClassIdentifier;
int rewrite;
//Pair <attribute.identifier, List Of [literal.identifier]>
Dictionary<int, List<int>> attributesAndLiterals = new Dictionary<int, List<int>>();
//Pair <attribute.identifier, equivalenceClass.identifier>
Dictionary<int, int> attributesAndEquivalenceClasses = new Dictionary<int, int>();
//Pair <literal.identifier, equivalenceClass.identifier>
Dictionary<int, int> literalsAndEquivalenceClasses = new Dictionary<int, int>();
#endregion
#region BooleanCedent (tdCedentD), EquivalenceClass (tdEquivalenceClass), Literal (tdLiteralD)
Dictionary<CedentEnum, bool> savedCedents = new Dictionary<CedentEnum, bool>();
if (booleanCedents != null)
{
int booleanCedentID;
int equivalenceClassID;
EquivalenceClassStruct[] equivalenceClasses;
foreach (BooleanCedent booleanCedent in booleanCedents)
{
#region BooleanPartialCedent (tdCedentD)
CedentIdentifierAndType cedentIdentifierAndType = new CedentIdentifierAndType(booleanCedent.Cedent.identifier, booleanCedent.CedentType);
if (this.booleanPartialCedents.ContainsKey(cedentIdentifierAndType))
{
booleanCedentID = this.booleanPartialCedents[cedentIdentifierAndType];
continue;
}
else
{
booleanCedentID = this.SetBooleanPartialCedent(
booleanCedent.CedentType,
booleanCedent.Cedent.minLen,
booleanCedent.Cedent.maxLen,
taskID);
this.booleanPartialCedents.Add(cedentIdentifierAndType, booleanCedentID);
}
savedCedents[booleanCedent.CedentType] = true;
#endregion
#region EQUIVALENCE CLASS PROBLEM
equivalenceClasses = booleanCedent.Cedent.equivalenceClasses;
if (equivalenceClasses != null &&
equivalenceClasses.Length > 0)
{
//This makes attributesAndLiterals Dictionary<int, List<int>> Pair <attribute.identifier, List Of [literal.identifier]>
if (booleanCedent.Cedent.literalSettings != null)
foreach (LiteralSettingStruct literalSettingStruct in booleanCedent.Cedent.literalSettings)
{
//literalSettingStruct.identifier;
attributeIdentifier = literalSettingStruct.atomSetting.abstractAttribute.identifier;
literalIdentifier = literalSettingStruct.identifier;
if (attributesAndLiterals.ContainsKey(attributeIdentifier))
attributesAndLiterals[attributeIdentifier].Add(literalIdentifier);
else
attributesAndLiterals.Add(attributeIdentifier, new List<int>(new int[] { literalIdentifier }));
attributesAndEquivalenceClasses[attributeIdentifier] = 0;
literalsAndEquivalenceClasses[literalIdentifier] = 0;
}
//This makes attributesAndEquivalenceClasses Dictionary<int, int> Pair <attribute.identifier, equivalenceClass.identifier>
foreach (EquivalenceClassStruct equivalenceClassStruct in equivalenceClasses)
{
equivalenceClassIdentifier = equivalenceClassStruct.identifier;
foreach (int identifierOfAttributeInClass in equivalenceClassStruct.attributesIdentifiers)
{
rewrite = 0;
if (attributesAndEquivalenceClasses.ContainsKey(identifierOfAttributeInClass))
{
if (attributesAndEquivalenceClasses[identifierOfAttributeInClass] != 0)
rewrite = attributesAndEquivalenceClasses[identifierOfAttributeInClass];
attributesAndEquivalenceClasses[identifierOfAttributeInClass] = equivalenceClassIdentifier;
}
else
attributesAndEquivalenceClasses.Add(identifierOfAttributeInClass, equivalenceClassIdentifier);
if (rewrite != 0)
foreach (KeyValuePair<int, int> kvp in attributesAndEquivalenceClasses)
{
if (attributesAndEquivalenceClasses[kvp.Key] == rewrite)
attributesAndEquivalenceClasses[kvp.Key] = equivalenceClassIdentifier;
}
}
}
//This makes literalsAndEquivalenceClasses Dictionary<int, int> Pair <literal.identifier, equivalenceClass.identifier>
//Process equivalence classes of attributes to literals
foreach (KeyValuePair<int, int> kvp in attributesAndEquivalenceClasses)
{
if (attributesAndEquivalenceClasses[kvp.Key] != 0)
{
rewrite = attributesAndEquivalenceClasses[kvp.Key];
foreach (int currentLiteralKey in attributesAndLiterals[kvp.Key])
{
literalsAndEquivalenceClasses[currentLiteralKey] = rewrite;
}
}
}
//This process equivalence classes of literals
foreach (EquivalenceClassStruct equivalenceClassStruct in equivalenceClasses)
{
equivalenceClassIdentifier = equivalenceClassStruct.identifier;
foreach (int identifierOfLiteralInClass in equivalenceClassStruct.literalsIdentifiers)
{
rewrite = 0;
if (literalsAndEquivalenceClasses.ContainsKey(identifierOfLiteralInClass))
{
if (literalsAndEquivalenceClasses[identifierOfLiteralInClass] != 0)
rewrite = literalsAndEquivalenceClasses[identifierOfLiteralInClass];
literalsAndEquivalenceClasses[identifierOfLiteralInClass] = equivalenceClassIdentifier;
}
else
{
literalsAndEquivalenceClasses.Add(identifierOfLiteralInClass, equivalenceClassIdentifier);
}
if (rewrite != 0)
foreach (KeyValuePair<int, int> kvp in literalsAndEquivalenceClasses)
{
if (literalsAndEquivalenceClasses[kvp.Key] == rewrite)
literalsAndEquivalenceClasses[kvp.Key] = equivalenceClassIdentifier;
}
}
}
}
#endregion
#region EquivalenceClass (tdEquivalenceClass)
equivalenceClasses = booleanCedent.Cedent.equivalenceClasses;
if (booleanCedent.Cedent.equivalenceClasses != null)
foreach (EquivalenceClassStruct equivalenceClassStruct in equivalenceClasses)
{
//test if equivalence class is used or if it was absorb by other equivalence class
if (!literalsAndEquivalenceClasses.ContainsValue(equivalenceClassStruct.identifier))
continue;
equivalenceClassID = this.SetEquivalenceClass(
booleanCedentID,
equivalenceClassStruct.identifier);
this.equivalenceClasses.Add(equivalenceClassStruct.identifier, equivalenceClassID);
}
#endregion
#region Prepare list of Attributes from BooleanCedents
if (booleanCedent.Cedent.literalSettings != null)
foreach (LiteralSettingStruct literalSettingStruct in booleanCedent.Cedent.literalSettings)
{
abstractAttributes.Add(literalSettingStruct.atomSetting.abstractAttribute);
}
#endregion
}
}
#endregion
#region Prepare list of Attributes from CategorialCedents
if (categorialCedents != null)
foreach (CategorialCedent categorialCedent in categorialCedents)
{
savedCedents[categorialCedent.CedentType] = true;
abstractAttributes.AddRange(categorialCedent.Cedent.attributes);
}
#endregion
#region Saved cedents?
//pokud totiz neni nastaven nejaky cedent (chybi treba prazdny radek), tak nejde pustit gen
switch (taskType)
{
case TaskTypeEnum.FFT:
if (!savedCedents.ContainsKey(CedentEnum.Antecedent) || savedCedents[CedentEnum.Antecedent] == false)
this.SetBooleanPartialCedent(CedentEnum.Antecedent, 0, 0, taskID);
if (!savedCedents.ContainsKey(CedentEnum.Succedent) || savedCedents[CedentEnum.Succedent] == false)
this.SetBooleanPartialCedent(CedentEnum.Succedent, 0, 0, taskID);
if (!savedCedents.ContainsKey(CedentEnum.Condition) || savedCedents[CedentEnum.Condition] == false)
this.SetBooleanPartialCedent(CedentEnum.Condition, 0, 0, taskID);
break;
case TaskTypeEnum.SDFFT:
if (!savedCedents.ContainsKey(CedentEnum.Antecedent) || savedCedents[CedentEnum.Antecedent] == false)
this.SetBooleanPartialCedent(CedentEnum.Antecedent, 0, 0, taskID);
if (!savedCedents.ContainsKey(CedentEnum.Succedent) || savedCedents[CedentEnum.Succedent] == false)
this.SetBooleanPartialCedent(CedentEnum.Succedent, 0, 0, taskID);
if (!savedCedents.ContainsKey(CedentEnum.Condition) || savedCedents[CedentEnum.Condition] == false)
this.SetBooleanPartialCedent(CedentEnum.Condition, 0, 0, taskID);
if (!savedCedents.ContainsKey(CedentEnum.FirstSet) || savedCedents[CedentEnum.FirstSet] == false)
this.SetBooleanPartialCedent(CedentEnum.FirstSet, 0, 0, taskID);
if (!savedCedents.ContainsKey(CedentEnum.SecondSet) || savedCedents[CedentEnum.SecondSet] == false)
this.SetBooleanPartialCedent(CedentEnum.SecondSet, 0, 0, taskID);
break;
case TaskTypeEnum.KL:
if (!savedCedents.ContainsKey(CedentEnum.Antecedent) || savedCedents[CedentEnum.Antecedent] == false)
this.SetCategorialPartialCedent(CedentEnum.Antecedent, 0, 0, taskID, taskType);
if (!savedCedents.ContainsKey(CedentEnum.Succedent) || savedCedents[CedentEnum.Succedent] == false)
this.SetCategorialPartialCedent(CedentEnum.Succedent, 0, 0, taskID, taskType);
if (!savedCedents.ContainsKey(CedentEnum.Condition) || savedCedents[CedentEnum.Condition] == false)
this.SetBooleanPartialCedent(CedentEnum.Condition, 0, 0, taskID);
break;
case TaskTypeEnum.CF:
if (!savedCedents.ContainsKey(CedentEnum.Antecedent) || savedCedents[CedentEnum.Antecedent] == false)
this.SetCategorialPartialCedent(CedentEnum.Antecedent, 0, 0, taskID, taskType);
if (!savedCedents.ContainsKey(CedentEnum.Condition) || savedCedents[CedentEnum.Condition] == false)
this.SetBooleanPartialCedent(CedentEnum.Condition, 0, 0, taskID);
break;
case TaskTypeEnum.SDCF:
if (!savedCedents.ContainsKey(CedentEnum.Antecedent) || savedCedents[CedentEnum.Antecedent] == false)
this.SetCategorialPartialCedent(CedentEnum.Antecedent, 0, 0, taskID, taskType);
if (!savedCedents.ContainsKey(CedentEnum.Condition) || savedCedents[CedentEnum.Condition] == false)
this.SetBooleanPartialCedent(CedentEnum.Condition, 0, 0, taskID);
if (!savedCedents.ContainsKey(CedentEnum.FirstSet) || savedCedents[CedentEnum.FirstSet] == false)
this.SetBooleanPartialCedent(CedentEnum.FirstSet, 0, 0, taskID);
if (!savedCedents.ContainsKey(CedentEnum.SecondSet) || savedCedents[CedentEnum.SecondSet] == false)
this.SetBooleanPartialCedent(CedentEnum.SecondSet, 0, 0, taskID);
break;
case TaskTypeEnum.SDKL:
if (!savedCedents.ContainsKey(CedentEnum.Antecedent) || savedCedents[CedentEnum.Antecedent] == false)
this.SetCategorialPartialCedent(CedentEnum.Antecedent, 0, 0, taskID, taskType);
if (!savedCedents.ContainsKey(CedentEnum.Succedent) || savedCedents[CedentEnum.Succedent] == false)
this.SetCategorialPartialCedent(CedentEnum.Succedent, 0, 0, taskID, taskType);
if (!savedCedents.ContainsKey(CedentEnum.Condition) || savedCedents[CedentEnum.Condition] == false)
this.SetBooleanPartialCedent(CedentEnum.Condition, 0, 0, taskID);
if (!savedCedents.ContainsKey(CedentEnum.FirstSet) || savedCedents[CedentEnum.FirstSet] == false)
this.SetBooleanPartialCedent(CedentEnum.FirstSet, 0, 0, taskID);
if (!savedCedents.ContainsKey(CedentEnum.SecondSet) || savedCedents[CedentEnum.SecondSet] == false)
this.SetBooleanPartialCedent(CedentEnum.SecondSet, 0, 0, taskID);
break;
default:
throw Ferda.Modules.Exceptions.SwitchCaseNotImplementedError(taskType);
}
#endregion
#region DataMatrix (tmMatrix), Columns (tmAttribute), AbstractAttributes (tmQuantity), Category (tmCategory, tmCategoryEnumValue, tmInterval, tmValue)
string dataMatrixName = "";
int dataMatrixDBID = 0;
string[] primaryKeyColumns = null; //must be sorted (for BinarySearch)
string connectionString = null;
allRowsInTaskDataMatrixCount = 0;
ColumnSchemaInfo[] columnSchemaInfoSeq = null;
Ferda.Modules.Boxes.DataMiningCommon.DataMatrix.DataMatrixInfo dataMatrixInfo;
#region DataMatrix (tmMatrix)
{
AbstractAttributeStruct abstractAttributeStruct = abstractAttributes[0];
dataMatrixInfo = abstractAttributeStruct.column.dataMatrix;
//only for first attribute/column ... each attribute in one task must be in one and only one data matrix
columnSchemaInfoSeq = dataMatrixInfo.explainDataMatrix;
dataMatrixName = dataMatrixInfo.dataMatrixName;
dataMatrixDBID = SetDataMatrix(dataMatrixName, dataMatrixInfo.recordsCount);
updateTask(taskID, dataMatrixDBID);
allRowsInTaskDataMatrixCount = dataMatrixInfo.recordsCount;
string connectionStringForSave = dataMatrixInfo.database.odbcConnectionString.Trim();
if (connectionStringForSave.StartsWith("DSN=", StringComparison.InvariantCultureIgnoreCase))
connectionStringForSave = connectionStringForSave.Substring(4);
ExecuteUpdateQuery(
"UPDATE tpParamsDB SET "
+ " strValue='" + connectionStringForSave + "' "
+ " WHERE Name='DSN'");
connectionString = dataMatrixInfo.database.odbcConnectionString;
primaryKeyColumns = dataMatrixInfo.primaryKeyColumns;
Array.Sort(primaryKeyColumns);
}
//Test values of primary key columns for duplicits (also test connection string and existence of data matrix)
Ferda.Modules.Helpers.Data.DataMatrix.TestValuesInEnteredPrimaryKeyColumnsAreNotUniqueError(connectionString, dataMatrixName, primaryKeyColumns, boxIdentity);
#endregion
ColumnInfo columnInfo;
CategoriesStruct categories;
int columnID;
int columnThereforeAlsoAttributeValueSubTypeDBID = 0;
string columnSelectExpression;
int primaryKeyColumnPosition;
int categoryID;
int enumCategoryValueID;
int attributeID;
//int attributeIdentifier; --allready defined
string xCategory;
string includeNullCategory;
foreach (AbstractAttributeStruct abstractAttributeStruct in abstractAttributes)
{
//Protect from multiple saving columns or attributesAndEquivalenceClasses or caregories
if (this.attributes.ContainsKey(abstractAttributeStruct.identifier))
continue;
#region Columns (tmAttribute)
if (dataMatrixName != abstractAttributeStruct.column.dataMatrix.dataMatrixName)
{
throw Ferda.Modules.Exceptions.BoxRuntimeError(null, boxIdentity, "LM Task can not run over more than one datamatrix!");
}
columnSelectExpression = abstractAttributeStruct.column.columnSelectExpression;
//Protect from multiple saving columns
if (this.columns.ContainsKey(columnSelectExpression))
{
columnID = this.columns[columnSelectExpression];
}
else
{
columnInfo = abstractAttributeStruct.column;
primaryKeyColumnPosition = Array.BinarySearch(primaryKeyColumns, abstractAttributeStruct.column.columnSelectExpression);
columnThereforeAlsoAttributeValueSubTypeDBID = this.constants.ValueSubTypeEnumDictionary[columnInfo.columnSubType];
columnID = SetColumn(
columnInfo.columnSelectExpression,
dataMatrixDBID,
columnInfo.columnType,
columnInfo.columnSubType,
columnSelectExpression,
(primaryKeyColumnPosition >= 0) ? primaryKeyColumnPosition + 1 : -1);
this.columns.Add(columnInfo.columnSelectExpression, columnID);
}
int i = 0;
foreach (string primaryKeyColumn in primaryKeyColumns)
{
i++;
if (String.IsNullOrEmpty(primaryKeyColumn))
continue;
if (this.columns.ContainsKey(primaryKeyColumn))
continue;
foreach (ColumnSchemaInfo columnSchemaInfo in columnSchemaInfoSeq)
{
if (columnSchemaInfo.name == primaryKeyColumn)
{
int tmpColumnID = SetColumn(
columnSchemaInfo.name,
dataMatrixDBID,
ColumnTypeEnum.Ordinary,
Ferda.Modules.Helpers.Data.Column.GetColumnSubTypeByDataType(columnSchemaInfo.dataType),
columnSchemaInfo.name,
i);
this.columns.Add(columnSchemaInfo.name, tmpColumnID);
break;
}
}
}
#endregion
#region Attribute (tmQuantity)
attributeID = SetAttribute(
abstractAttributeStruct.nameInLiterals,
abstractAttributeStruct.identifier,
columnID);
attributeIdentifier = abstractAttributeStruct.identifier;
xCategory = abstractAttributeStruct.xCategory;
includeNullCategory = abstractAttributeStruct.includeNullCategory;
this.attributesCache.Add(abstractAttributeStruct.identifier, abstractAttributeStruct);
this.attributes.Add(attributeIdentifier, attributeID);
this.categories.Add(attributeIdentifier, new Dictionary<string, int>());
this.categoriesOrds.Add(attributeIdentifier, new Dictionary<long, string>());
#endregion
#region Categories (tmCategory, tmCategoryEnumValue, tmInterval, tmValue)
long categoryOrd = 0;
categories = abstractAttributeStruct.categories;
//if (categories.dateTimeIntervals != null)
foreach (DictionaryEntry category in categories.dateTimeIntervals)
{
categoryName = (string)category.Key;
//tmCategory
categoryOrd++;
categoryID = SetCategory(
categoryName,
attributeID,
CategoryTypeEnum.Interval,
(xCategory == categoryName),
(includeNullCategory == categoryName),
categoryOrd,
attributeIdentifier);
//tmValue, tmInterval
foreach (DateTimeIntervalStruct intervalStruct in (DateTimeIntervalStruct[])category.Value)
{
insertValueInterval(categoryID, intervalStruct);
}
}
//if (categories.floatIntervals != null)
foreach (DictionaryEntry category in categories.floatIntervals)
{
categoryName = (string)category.Key;
//tmCategory
categoryOrd++;
categoryID = SetCategory(
categoryName,
attributeID,
CategoryTypeEnum.Interval,
(xCategory == categoryName),
(includeNullCategory == categoryName),
categoryOrd,
attributeIdentifier);
//tmValue, tmInterval
foreach (FloatIntervalStruct intervalStruct in (FloatIntervalStruct[])category.Value)
{
insertValueInterval(categoryID, intervalStruct);
}
}
//if (categories.longIntervals != null)
foreach (DictionaryEntry category in categories.longIntervals)
{
categoryName = (string)category.Key;
//tmCategory
categoryOrd++;
categoryID = SetCategory(
categoryName,
attributeID,
CategoryTypeEnum.Interval,
(xCategory == categoryName),
(includeNullCategory == categoryName),
categoryOrd,
attributeIdentifier);
//tmValue, tmInterval
foreach (LongIntervalStruct intervalStruct in (LongIntervalStruct[])category.Value)
{
insertValueInterval(categoryID, intervalStruct);
}
}
//if (categories.enums != null)
foreach (DictionaryEntry category in categories.enums)
{
categoryName = (string)category.Key;
//tmCategory
categoryOrd++;
categoryID = SetCategory(
categoryName,
attributeID,
CategoryTypeEnum.Enumeration,
(xCategory == categoryName),
(includeNullCategory == categoryName),
categoryOrd,
attributeIdentifier);
foreach (string enumItem in (string[])category.Value)
{
//tmValue
if (categoryName == includeNullCategory && String.IsNullOrEmpty(enumItem))
{
enumCategoryValueID = SetValue();
continue;
}
else if (String.IsNullOrEmpty(enumItem))
{
//DEBUG NOTES: for debugin purposes it can be usevull if this else-if branch is removed (commented)
enumCategoryValueID = SetValue();
continue;
}
switch (columnThereforeAlsoAttributeValueSubTypeDBID)
{
case 1: //long
enumCategoryValueID = SetValue(Convert.ToInt64(enumItem));
break;
case 2: //double
enumCategoryValueID = SetValue(Convert.ToDouble(enumItem));
break;
case 3: //string
enumCategoryValueID = SetValue(enumItem);
break;
case 4: //bool
enumCategoryValueID = SetValue(Convert.ToBoolean(enumItem));
break;
case 5: //date
enumCategoryValueID = SetValue(Convert.ToDateTime(enumItem));
break;
default:
throw Ferda.Modules.Exceptions.SwitchCaseNotImplementedError(columnThereforeAlsoAttributeValueSubTypeDBID);
}
//tmCategoryEnumValue
this.SetCategoryEnum(
categoryID,
enumCategoryValueID);
}
}
#endregion
}
#endregion
#region CategorialCedent (tdKLCedentD, tdCFCedentD, tdKLLiteralD, tdCFLiteralD)
int categorialCedentID;
int categorialLiteralID;
if (categorialCedents != null)
foreach (CategorialCedent categorialCedent in categorialCedents)
{
CedentIdentifierAndType cedentIdentifierAndType = new CedentIdentifierAndType(categorialCedent.Cedent.identifier, categorialCedent.CedentType);
if (this.categorialPartialCedent.ContainsKey(cedentIdentifierAndType))
{
categorialCedentID = this.categorialPartialCedent[cedentIdentifierAndType];
}
else
{
categorialCedentID = SetCategorialPartialCedent(
categorialCedent.CedentType,
categorialCedent.Cedent.minLen,
categorialCedent.Cedent.maxLen,
taskID,
taskType);
this.categorialPartialCedent.Add(cedentIdentifierAndType, categorialCedentID);
if (categorialCedent.Cedent.attributes != null)
foreach (AbstractAttributeStruct abstractAttributeStruct in categorialCedent.Cedent.attributes)
{
categorialLiteralID = SetCategorialLiteralSetting(
categorialCedentID,
this.attributes[abstractAttributeStruct.identifier],
taskType,
abstractAttributeStruct.identifier);
}
}
}
#endregion
#region BooleanCedent (tdLiteralD)
int literalID;
if (booleanCedents != null)
{
foreach (BooleanCedent booleanCedent in booleanCedents)
{
if (booleanCedent.Cedent.literalSettings != null)
foreach (LiteralSettingStruct literalSettingStruct in booleanCedent.Cedent.literalSettings)
{
int literalOneCategoryDBID = (literalSettingStruct.atomSetting.category.Length > 0)
? this.categories[literalSettingStruct.atomSetting.abstractAttribute.identifier][literalSettingStruct.atomSetting.category[0]]
: 0;
int literalEquivalenceClass = 0;
try
{
literalEquivalenceClass = this.equivalenceClasses[literalsAndEquivalenceClasses[literalSettingStruct.identifier]];
}
catch (KeyNotFoundException) { }
literalID = this.SetLiteralSetting(
literalSettingStruct.atomSetting.minLen,
literalSettingStruct.atomSetting.maxLen,
literalSettingStruct.atomSetting.coefficientType,
literalEquivalenceClass,
literalSettingStruct.gaceType,
literalSettingStruct.literalType,
literalOneCategoryDBID,
this.booleanPartialCedents[new CedentIdentifierAndType(booleanCedent.Cedent.identifier, booleanCedent.CedentType)],
this.attributes[literalSettingStruct.atomSetting.abstractAttribute.identifier]);
this.literals.Add(literalID, literalSettingStruct.identifier);
this.attributeNameInLiterals.Add(literalID, literalSettingStruct.atomSetting.abstractAttribute.nameInLiterals);
//abstractAttributes.Add(literalSettingStruct.atomSetting.abstractAttribute);
}
}
}
#endregion
}
public async Task StartOrchestratorScheduler(
[OrchestrationTrigger]
IDurableOrchestrationContext context,
ILogger log)
{
var taskItem = context.GetInput <TaskItem>();
if (taskItem == null)
{
var error = new ProcessResult {
Sucess = false, Information = "Error getting task information"
};
AddLog(log, error);
return;
}
TaskTypeEnum taskType = (TaskTypeEnum)taskItem.TaskType;
string prepare = ActivityFunctionPrepare(taskType);
string process = ActivityFunctionProcess(taskType);
string complete = ActivityFunctionComplete(taskType);
double secondInAFullDay = 86400;
//// hvordan tjekker vi at task'en ikke allerde er scheduleret ?
//// i så fald skal den terminineres.
var date = context.CurrentUtcDateTime.Hour > taskItem.MonitorHour ? context.CurrentUtcDateTime.AddDays(1) : context.CurrentUtcDateTime;
var nextTime = new DateTime(date.Year, date.Month, date.Day, taskItem.MonitorHour, 0, 0);
var pollingInterval = nextTime.Subtract(context.CurrentUtcDateTime).TotalSeconds;
DateTime expiryTime = new DateTime(3000, 1, 1);
while (context.CurrentUtcDateTime < expiryTime)
{
// Orchestration sleeps until this time.
var nextCheck = context.CurrentUtcDateTime.AddSeconds(pollingInterval);
await context.CreateTimer(nextCheck, CancellationToken.None);
var resultPrepare = await context.CallActivityAsync <ProcessResult>(prepare, taskItem.CustomerId);
AddLog(log, resultPrepare);
if (resultPrepare.Sucess)
{
var resultProcess = await context.CallActivityAsync <ProcessResult>(process, taskItem.CustomerId);
AddLog(log, resultProcess);
if (resultProcess.Sucess)
{
var resultComplete = await context.CallActivityAsync <ProcessResult>(complete, taskItem.CustomerId);
AddLog(log, resultComplete);
}
}
// her sikres at denne uendelig løkke, ikke medfører at durable storage account fyldes op.
context.ContinueAsNew(null); // her har man mulighed for at have informationer til næste genneløb
pollingInterval = secondInAFullDay;
}
}
public bool DoesExist(int requestID, TaskTypeEnum type)
{
return(DBSet.Any(x => x.RequestID == requestID && x.Finished && x.TaskType == type));
}
/// <summary>
/// 获取合适辊台
/// </summary>
/// <param name="area"></param>
/// <param name="tt"></param>
/// <returns></returns>
public string GetRightFRT(string area, TaskTypeEnum tt)
{
try
{
string frt = "";
if (devices.Exists(c => c.area == area && c.taskType == tt))
{
foreach (DevInfoFRT d in devices.FindAll(c => c.area == area && c.taskType == tt))
{
if (ADS.mNDCControl.IsRedirectedMax(d.devName, out int t))
{
continue;
}
if (!d.isLock && d.isUseful && d._.GoodsStatus != GoodsEnum.辊台满货)
{
frt = d.devName;
if (t == 0)
{
if (d._.GoodsStatus != GoodsEnum.辊台无货)
{
return(frt);
}
}
else
{
switch (d._.RollerStatus)
{
case RollerStatusEnum.辊台停止:
if (d._.GoodsStatus == GoodsEnum.辊台无货)
{
return(frt);
}
break;
case RollerStatusEnum.辊台1启动:
break;
case RollerStatusEnum.辊台2启动:
if (d._.GoodsStatus == GoodsEnum.辊台无货 || d._.GoodsStatus == GoodsEnum.辊台2有货)
{
return(frt);
}
break;
case RollerStatusEnum.辊台全启动:
break;
}
}
}
}
}
if (string.IsNullOrEmpty(frt) && area == "B01")
{
frt = "FRT02";
}
return(frt);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// tdKLLiteralD or tdCFLiteralD
/// </summary>
/// <returns>ID of new row inserted to database.</returns>
private int SetCategorialLiteralSetting(int cedentDBID, int attributeDBID, TaskTypeEnum taskType, int attributeIdentifier)
{
string tableName;
string column1Name;
switch (taskType)
{
case TaskTypeEnum.KL:
case TaskTypeEnum.SDKL:
tableName = "tdKLLiteralD";
column1Name = "KLCedentDID";
break;
case TaskTypeEnum.CF:
case TaskTypeEnum.SDCF:
tableName = "tdCFLiteralD";
column1Name = "CFCedentDID";
break;
default:
throw Ferda.Modules.Exceptions.SwitchCaseNotImplementedError(taskType);
}
string autoIncrementColumn = GetAutoIncrementColumnName(tableName);
int autoIncrementValue = GetTableAutoIncrementValue(tableName, 1);
string query = "INSERT INTO " + tableName + " (" + autoIncrementColumn
+ "," + column1Name + ",QuantityID) VALUES "
+ "(" + autoIncrementValue + ","
+ cedentDBID + ","
+ attributeDBID
+ ")";
categorialLiteral.Add(autoIncrementValue, attributeIdentifier);
ExecuteInsertQuery(query, tableName);
return autoIncrementValue;
}
public int SaveTask(string boxIdentity, TaskTypeEnum taskType)
{
string tableName = "taTask";
string autoIncrementColumn = GetAutoIncrementColumnName(tableName);
int autoIncrementValue = GetTableAutoIncrementValue(tableName, 1);
string query = "INSERT INTO " + tableName + " (" + autoIncrementColumn
+ ",Name,TaskSubTypeID,UserID,ReadOnly) VALUES "
+ "(" + autoIncrementValue + ","
+ "'FerdaTask" + boxIdentity + "',"
+ Constants.TaskTypeEnumDictionary[taskType] + ","
+ Constants.UserID + ","
+ Constants.FalseValue
+ ")";
ExecuteInsertQuery(query, tableName);
return autoIncrementValue;
}
public void SendDataUpdateServiceFailureNotification(TaskTypeEnum taskTypeEnum)
{
string serviceName = string.Empty;
string serviceFileName = string.Empty;
switch (taskTypeEnum)
{
case TaskTypeEnum.AscGov:
{
serviceName = "ASC.GOV";
serviceFileName = "v_Export_All.txt";
break;
}
case TaskTypeEnum.HUDAppraiserContactInfo:
{
serviceName = "HUD.GOV";
serviceFileName = "APRSR-DATA.txt";
break;
}
case TaskTypeEnum.HUDAppraiserLicense:
{
serviceName = "HUD.GOV";
serviceFileName = "APRSR-LIC.txt";
break;
}
default: throw new ArgumentOutOfRangeException("Not supported type: " + taskTypeEnum.ToString());
}
DateTime nextAttemptDateTime = DateTime.Now.Date.AddDays(1);
Dictionary<string, string> replaceDictionary = new Dictionary<string, string>();
replaceDictionary.Add(Constants.EmailTemplateKeyWords.FailureFileName, serviceFileName);
replaceDictionary.Add(Constants.EmailTemplateKeyWords.ServiceName, serviceName);
replaceDictionary.Add(Constants.EmailTemplateKeyWords.NextAttemptDateTime, nextAttemptDateTime.ToString("MM/dd/yyyy hh:mm tt", CultureInfo.InvariantCulture));
SendMailInternal(EmailTemplateType.DataUpdateFailureNotification, _configManager.DVSAdminEmails, replaceDictionary);
}
public Task()
{
TaskType = TaskTypeEnum.KillEnemy;
QuestLogDescription = string.Empty;
CurrentAmount = 0;
}
/// <summary>
/// Creates the Staging Task manually
/// </summary>
/// <param name="RelationshipObj"></param>
/// <param name="TaskType"></param>
private void RelationshipName_CreateStagingTask(RelationshipNameInfo RelationshipObj, TaskTypeEnum TaskType)
{
List <ServerInfo> ActiveServers = ServerInfo.Provider.Get().WhereEquals("ServerSiteID", SiteContext.CurrentSiteID).WhereEquals("ServerEnabled", true).ToList();
if (IsCustomAdhocRelationshipName(RelationshipObj) && ActiveServers.Count > 0)
{
string Data = "<NewDataSet>" + RelationshipObj.ToXML("CMS_RelationshipName", false) + "</NewDataSet>";
string TaskTitle = "";
switch (TaskType)
{
case TaskTypeEnum.CreateObject:
TaskTitle = "Create";
break;
case TaskTypeEnum.UpdateObject:
TaskTitle = "Update";
break;
case TaskTypeEnum.DeleteObject:
TaskTitle = "Delete";
break;
}
StagingTaskInfo Task = new StagingTaskInfo()
{
TaskTitle = string.Format("{0} Relationship name '{1}'", TaskTitle, RelationshipObj.RelationshipDisplayName),
TaskType = TaskType,
TaskObjectType = RelationshipNameInfo.OBJECT_TYPE,
TaskObjectID = RelationshipObj.RelationshipNameId,
TaskData = Data,
TaskTime = DateTime.Now
};
StagingTaskInfo.Provider.Set(Task);
foreach (ServerInfo ServerObj in ActiveServers)
{
// Create synchronization
SynchronizationInfo SyncInfo = new SynchronizationInfo()
{
SynchronizationTaskID = Task.TaskID,
SynchronizationServerID = ServerObj.ServerID
};
SynchronizationInfo.Provider.Set(SyncInfo);
}
TaskGroupInfo TaskGroup = TaskGroupInfoProvider.GetUserTaskGroupInfo(MembershipContext.AuthenticatedUser.UserID);
if (TaskGroup != null)
{
TaskGroupTaskInfo.Provider.Add(TaskGroup.TaskGroupID, Task.TaskID);
}
}
}
public override IntegrationProcessResultEnum ProcessInternalTaskAsync(GeneralizedInfo infoObj, TranslationHelper translations, TaskTypeEnum taskType, TaskDataTypeEnum dataType, string siteName, out string errorMessage)
{
try
{
//Determine if the record exists in Azure Storage
// Retrieve the storage account from the connection string.
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(SettingsKeyInfoProvider.GetValue("Custom.AzureStorageConnectionString"));
// Create the table client.
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
// Create the CloudTable object that represents the "kenticousers" table.
CloudTable table = tableClient.GetTableReference("kenticousers");
// Create a retrieve operation that takes a customer entity.
TableOperation retrieveOperation = TableOperation.Retrieve<KenticoUserEntity>(ValidationHelper.GetString(infoObj["UserGUID"], ""), ValidationHelper.GetString(infoObj["LastName"], ""));
// Execute the operation.
TableResult retrievedResult = table.Execute(retrieveOperation);
// Assign the result to a CustomerEntity object.
KenticoUserEntity existinguser = (KenticoUserEntity)retrievedResult.Result;
//Check if the record already exists
if (existinguser == null)
{
// create a new record
KenticoUserEntity newuser = new KenticoUserEntity(ValidationHelper.GetString(infoObj["UserGUID"], ""), ValidationHelper.GetString(infoObj["LastName"], ""));
newuser.firstname = ValidationHelper.GetString(infoObj["FirstName"], "");
newuser.lastname = ValidationHelper.GetString(infoObj["LastName"], "");
newuser.email = ValidationHelper.GetString(infoObj["Email"], "");
// Create the Insert TableOperation
TableOperation insertOperation = TableOperation.Insert(newuser);
// Execute the operation.
table.Execute(insertOperation);
EventLogProvider.LogEvent("I", "CustomIntegrationConnector", "Information", "Record inserted!");
}
else
{
//update the record
existinguser.firstname = ValidationHelper.GetString(infoObj["FirstName"], "");
existinguser.lastname = ValidationHelper.GetString(infoObj["LastName"], "");
existinguser.email = ValidationHelper.GetString(infoObj["Email"], "");
// Create the Update TableOperation
TableOperation updateOperation = TableOperation.Replace(existinguser);
// Execute the operation.
table.Execute(updateOperation);
EventLogProvider.LogEvent("I", "CustomIntegrationConnector", "Information", "Record updated!");
}
//Set the error message to null and the response to OK
errorMessage = null;
return IntegrationProcessResultEnum.OK;
}
catch (Exception ex)
{
//There was a problem.
errorMessage = ex.Message;
return IntegrationProcessResultEnum.ErrorAndSkip;
}
}
/// <summary>
/// tdKLCedentD or tdCFCedentD
/// </summary>
/// <returns>ID of new row inserted to database.</returns>
private int SetCategorialPartialCedent(CedentEnum cedentType, long minLength, long maxLength, int taskDBID, TaskTypeEnum taskType)
{
string tableName;
switch (taskType)
{
case TaskTypeEnum.KL:
case TaskTypeEnum.SDKL:
tableName = "tdKLCedentD";
break;
case TaskTypeEnum.CF:
case TaskTypeEnum.SDCF:
tableName = "tdCFCedentD";
break;
default:
throw Ferda.Modules.Exceptions.SwitchCaseNotImplementedError(taskType);
}
string autoIncrementColumn = GetAutoIncrementColumnName(tableName);
int autoIncrementValue = GetTableAutoIncrementValue(tableName, 1);
string query = "INSERT INTO " + tableName + " (" + autoIncrementColumn
+ ",TaskID,CedentTypeID,MinLen,MaxLen) VALUES "
+ "(" + autoIncrementValue + ","
+ taskDBID + ","
+ constants.CedentEnumDictionary[cedentType] + ","
+ minLength + ","
+ maxLength
+ ")";
ExecuteInsertQuery(query, tableName);
return autoIncrementValue;
}
/// <summary>
/// 新增任務，若新增任務成功回傳 <c>true</c> 否則為 <c>false</c>。
/// </summary>
/// <param name="taskType">任務類型。</param>
/// <param name="data">任務資料。</param>
/// <param name="bookingTime">預訂時間（選項）。</param>
/// <returns>若新增任務成功回傳 <c>true</c> 否則為 <c>false</c>。</returns>
public bool CreateTask(TaskTypeEnum taskType, string data, DateTime?bookingTime = null)
{
// 範例程式不實作。
return(true);
}
/// <summary>
/// Transforms given external object to internal (to TreeNode or GeneralizedInfo).
/// </summary>
/// <param name="obj">Object or document to transform</param>
/// <param name="taskType">Type of task</param>
/// <param name="dataType">Type of input data</param>
/// <param name="siteName">Name of site</param>
public override ICMSObject PrepareInternalObject(object obj, TaskTypeEnum taskType, TaskDataTypeEnum dataType, string siteName)
{
// This method is called withing IntegrationHelper.ProcessExternalTask and it provides you with space where you can easily transform
// external object (possibly some kind of data container) to TreeNode (document) or GeneralizedInfo (object - eg. UserInfo)
return null;
}
//private AbstractAttributeStruct GetAttribute(TaskTypeEnum taskType, object taskDescription, string attributeName, CedentEnum cedentType)
//{
// switch (taskType)
// {
// case TaskTypeEnum.FFT:
// break;
// case TaskTypeEnum.KL:
// /*
// Ferda.Modules.Boxes.LISpMinerTasks.KLTask.TaskStruct input = (Ferda.Modules.Boxes.LISpMinerTasks.KLTask.TaskStruct)taskDescription;
// if (cedentType == CedentEnum.Antecedent)
// {
// foreach (CategorialPartialCedentSettingStruct cedent in input.antecedentSetting)
// {
// foreach (AbstractAttributeStruct attribute in cedent.attributes)
// {
// if (attribute.nameInLiterals == attributeName)
// return attribute;
// }
// }
// }
// else if (cedentType == CedentEnum.Succedent)
// {
// foreach (CategorialPartialCedentSettingStruct cedent in input.succedentSetting)
// {
// foreach (AbstractAttributeStruct attribute in cedent.attributes)
// {
// if (attribute.nameInLiterals == attributeName)
// return attribute;
// }
// }
// }
// */
// break;
// case TaskTypeEnum.CF:
// Ferda.Modules.Boxes.LISpMinerTasks.CFTask.TaskStruct input1 = (Ferda.Modules.Boxes.LISpMinerTasks.CFTask.TaskStruct)taskDescription;
// foreach (CategorialPartialCedentSettingStruct cedent in input1.antecedentSetting)
// {
// foreach (AbstractAttributeStruct attribute in cedent.attributes)
// {
// if (attribute.nameInLiterals == attributeName)
// return attribute;
// }
// }
// break;
// case TaskTypeEnum.SDFFT:
// break;
// case TaskTypeEnum.SDKL:
// /*
// Ferda.Modules.Boxes.LISpMinerTasks.SDKLTask.TaskStruct input2 = (Ferda.Modules.Boxes.LISpMinerTasks.SDKLTask.TaskStruct)taskDescription;
// if (cedentType == CedentEnum.Antecedent)
// {
// foreach (CategorialPartialCedentSettingStruct cedent in input2.antecedentSetting)
// {
// foreach (AbstractAttributeStruct attribute in cedent.attributes)
// {
// if (attribute.nameInLiterals == attributeName)
// return attribute;
// }
// }
// }
// else if (cedentType == CedentEnum.Succedent)
// {
// foreach (CategorialPartialCedentSettingStruct cedent in input2.succedentSetting)
// {
// foreach (AbstractAttributeStruct attribute in cedent.attributes)
// {
// if (attribute.nameInLiterals == attributeName)
// return attribute;
// }
// }
// }
// */
// break;
// case TaskTypeEnum.SDCF:
// Ferda.Modules.Boxes.LISpMinerTasks.SDCFTask.TaskStruct input3 = (Ferda.Modules.Boxes.LISpMinerTasks.SDCFTask.TaskStruct)taskDescription;
// foreach (CategorialPartialCedentSettingStruct cedent in input3.antecedentSetting)
// {
// foreach (AbstractAttributeStruct attribute in cedent.attributes)
// {
// if (attribute.nameInLiterals == attributeName)
// return attribute;
// }
// }
// break;
// default:
// break;
// }
// return null;
//}
public LiteralStruct[] GetCategorialLiterals(TaskTypeEnum taskType, int taskID, object taskDescription)
{
string tdLiteralTableName = String.Empty;
string tdLiteralIDColumn = String.Empty;
string tdCedentDTableName = String.Empty;
string tdCedentDIDColumn = String.Empty;
switch (taskType)
{
case TaskTypeEnum.CF:
case TaskTypeEnum.SDCF:
tdLiteralTableName = "tdCFLiteralD";
tdLiteralIDColumn = "CFLiteralDID";
tdCedentDTableName = "tdCFCedentD";
tdCedentDIDColumn = "CFCedentDID";
break;
case TaskTypeEnum.KL:
case TaskTypeEnum.SDKL:
tdLiteralTableName = "tdKLLiteralD";
tdLiteralIDColumn = "KLLiteralDID";
tdCedentDTableName = "tdKLCedentD";
tdCedentDIDColumn = "KLCedentDID";
break;
default:
throw new Exception("SwitchBranchNotImplemented");
}
List<LiteralStruct> result = new List<LiteralStruct>();
LiteralStruct literalStruct;
DataTable literals = ExecuteSelectQuery(
"SELECT " +
tdLiteralTableName + "." + tdLiteralIDColumn + ", " +
tdCedentDTableName + "." + tdCedentDIDColumn + ", " +
tdLiteralTableName + ".QuantityID, " +
"tmQuantity.Name, CedentTypeID" +
" FROM `"
+ tdCedentDTableName + "`, `" + tdLiteralTableName + "`, `tmQuantity` " +
"WHERE TaskID=" + taskID + " AND " +
tdCedentDTableName + "." + tdCedentDIDColumn + "=" +
tdLiteralTableName + "." + tdCedentDIDColumn +
" AND tmQuantity.QuantityID=" +
tdLiteralTableName + "." + "QuantityID"
);
foreach (DataRow literal in literals.Rows)
{
literalStruct = new LiteralStruct();
literalStruct.cedentType =
Constants.CedentEnumDictionaryBackward[
Convert.ToInt32(literal["CedentTypeID"])];
literalStruct.literalIdentifier = CategorialLiteral[Convert.ToInt32(literal[tdLiteralIDColumn])];
//literalStruct.literalIdentifier = Convert.ToInt32(literal[tdLiteralIDColumn]);
literalStruct.literalName = literal["Name"].ToString();
literalStruct.categoriesNames = GetCategorialLiteralCategoriesNames(Convert.ToInt32(literal["QuantityID"]));
result.Add(literalStruct);
}
return result.ToArray();
}
/// <summary>
/// 电表抄表
/// </summary>
/// <param name="meters">电表集合</param>
/// <param name="connectId">任务编号</param>
/// <param name="taskType">任务类型</param>
/// <returns></returns>
public List <ReadTaskEntity> WattReadWithOther(List <MeterViewModel> meters, string connectId, TaskTypeEnum taskType)
{
var taskWithOther = new List <ReadTaskEntity>();
var tasks = meters.Select(item => new ReadTaskEntity
{
F_Id = Common.GuId(),
F_WorkId = connectId,
F_CreatorTime = DateTime.Now,
F_Factor = item.F_Factor,
F_MeterCode = item.F_MeterCode,
F_State = (int)TaskStateEnum.Wait,
F_MeterType = MeterTypeEnum.WattMeter.ToString(),
F_TaskType = (int)taskType,
}).ToList();
taskWithOther.AddRange(tasks);
foreach (var item in tasks)
{
taskWithOther.AddRange(new List <ReadTaskEntity>
{
new ReadTaskEntity //抄电压
{
F_Id = Guid.NewGuid().ToString(),
F_Factor = item.F_Factor,
F_CreatorTime = DateTime.Now,
F_MeterCode = item.F_MeterCode,
F_MeterType = item.F_MeterType,
F_State = (int)TaskStateEnum.Wait,
F_TaskType = (int)TaskTypeEnum.ThreeVoltage,
F_WorkId = item.F_Id
},
new ReadTaskEntity //抄电流
{
F_Id = Guid.NewGuid().ToString(),
F_Factor = item.F_Factor,
F_CreatorTime = DateTime.Now,
F_MeterCode = item.F_MeterCode,
F_MeterType = item.F_MeterType,
F_State = (int)TaskStateEnum.Wait,
F_TaskType = (int)TaskTypeEnum.ThreeCurrent,
F_WorkId = item.F_Id
},
new ReadTaskEntity //抄运行状态
{
F_Id = Guid.NewGuid().ToString(),
F_Factor = item.F_Factor,
F_CreatorTime = DateTime.Now,
F_MeterCode = item.F_MeterCode,
F_MeterType = item.F_MeterType,
F_State = (int)TaskStateEnum.Wait,
F_TaskType = (int)TaskTypeEnum.RunningState,
F_WorkId = item.F_Id
},
new ReadTaskEntity //抄尖时段电能
{
F_Id = Guid.NewGuid().ToString(),
F_Factor = item.F_Factor,
F_CreatorTime = DateTime.Now,
F_MeterCode = item.F_MeterCode,
F_MeterType = item.F_MeterType,
F_State = (int)TaskStateEnum.Wait,
F_TaskType = (int)TaskTypeEnum.TipEnergy,
F_WorkId = item.F_Id
},
new ReadTaskEntity //抄峰时段电能
{
F_Id = Guid.NewGuid().ToString(),
F_Factor = item.F_Factor,
F_CreatorTime = DateTime.Now,
F_MeterCode = item.F_MeterCode,
F_MeterType = item.F_MeterType,
F_State = (int)TaskStateEnum.Wait,
F_TaskType = (int)TaskTypeEnum.PeakEnergy,
F_WorkId = item.F_Id
},
new ReadTaskEntity //抄平时段电能
{
F_Id = Guid.NewGuid().ToString(),
F_Factor = item.F_Factor,
F_CreatorTime = DateTime.Now,
F_MeterCode = item.F_MeterCode,
F_MeterType = item.F_MeterType,
F_State = (int)TaskStateEnum.Wait,
F_TaskType = (int)TaskTypeEnum.FlatEnergy,
F_WorkId = item.F_Id
},
new ReadTaskEntity //抄谷时段电能
{
F_Id = Guid.NewGuid().ToString(),
F_Factor = item.F_Factor,
F_CreatorTime = DateTime.Now,
F_MeterCode = item.F_MeterCode,
F_MeterType = item.F_MeterType,
F_State = (int)TaskStateEnum.Wait,
F_TaskType = (int)TaskTypeEnum.ValleyEnergy,
F_WorkId = item.F_Id
},
});
}
return(taskWithOther);
}
public int[][] GetSecondContingecyTable(TaskTypeEnum taskType, int taskID, int hypothesisID, int rowAttributeIdentifier, int columnAttributeIdentifier)
{
string tableName = String.Empty;
string hypothesisColumnName = String.Empty;
bool kl = false;
switch (taskType)
{
case TaskTypeEnum.KL:
return new int[0][];
case TaskTypeEnum.SDKL:
tableName = "tiDKFrequencyI";
hypothesisColumnName = "HypothesisDKID";
kl = true;
break;
case TaskTypeEnum.CF:
return new int[0][];
case TaskTypeEnum.SDCF:
tableName = "tiDCFrequencyI";
hypothesisColumnName = "HypothesisDCID";
break;
default:
throw Ferda.Modules.Exceptions.SwitchCaseNotImplementedError(taskType);
}
DataTable table = ExecuteSelectQuery("SELECT * FROM " + tableName + " WHERE TaskID=" + taskID + " AND " + hypothesisColumnName + "=" + hypothesisID + " AND CedentTypeID=" + constants.CedentEnumDictionary[CedentEnum.SecondSet]);
AbstractAttributeStruct rowAttribute;
AbstractAttributeStruct columnAttribute = GetAttributeStruct(columnAttributeIdentifier);
List<int[]> resultList = new List<int[]>();
if (kl)
{
rowAttribute = GetAttributeStruct(rowAttributeIdentifier);
for (int i = 0; i < rowAttribute.countOfCategories; i++)
resultList.Add(new int[columnAttribute.countOfCategories]);
}
else
{
resultList.Add(new int[columnAttribute.countOfCategories]);
}
int[][] result = resultList.ToArray();
foreach (DataRow row in table.Rows)
{
if (kl)
result[Convert.ToInt32(row["Row"])][Convert.ToInt32(row["Col"])] = Convert.ToInt32(row["Frequency"]);
else
result[0][Convert.ToInt32(row["Col"])] = Convert.ToInt32(row["Frequency"]);
}
return result;
}
