private void dataGridView1_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
{
var selectedName = dataGridView1.Rows[dataGridView1.CurrentRow.Index].Cells[0].Value.ToString();
if (selectedName != "")
{
switch (_gridTypeEnumNow)
{
case ViewTypeEnum.JOB:
var selectedjob = _jobLogic.appoggio.FirstOrDefault(x => x.name == selectedName);
if (selectedjob != null)
{
var jd = new JobDetail(selectedjob, _jobLogic);
_refreshGrid = true;
jd.ShowDialog();
}
break;
case ViewTypeEnum.TRIGGER:
var selectedtrigger = _triggerLogic.appoggio.FirstOrDefault(x => x.name == selectedName);
if (selectedtrigger != null)
{
var td = new TriggerDetail(selectedtrigger, Jobs, _triggerLogic);
_refreshGrid = true;
td.ShowDialog();
}
break;
}
}
}
public static ITrigger CreateCronTrigger(TriggerDetail triggerDetail)
{
// cron schedule "0 1 * * * ?"
return(TriggerBuilder.Create()
.WithIdentity(triggerDetail.TriggerName, triggerDetail.GroupName)
.WithCronSchedule(triggerDetail.CronExpression)
.ForJob(triggerDetail.JobName, triggerDetail.GroupName)
.Build());
}
public static ITrigger CreateTrigger(TriggerDetail triggerDetail)
{
switch (triggerDetail.TriggerType)
{
case TriggerType.Cron:
return(CreateCronTrigger(triggerDetail));
default:
return(CreateSimpleTrigger(triggerDetail));
}
}
private static ITrigger CreateSimpleTriggerWithIntervalInHours(TriggerDetail triggerDetail)
{
return(TriggerBuilder.Create()
.WithIdentity(triggerDetail.TriggerName, triggerDetail.GroupName)
.ForJob(triggerDetail.JobName, triggerDetail.GroupName)
.StartAt(DateTime.UtcNow.AddHours(triggerDetail.Interval))
.WithSimpleSchedule(x => x
.WithIntervalInHours(triggerDetail.Interval)
.RepeatForever())
.Build());
}
//Process a complex trigger, using the Trigger object
public GitHubActions.Trigger ProcessComplexTrigger(AzurePipelines.Trigger trigger)
{
if (trigger == null)
{
return(null);
}
//Note: as of 18-Oct, you receive an error if you try to post both a "branches" and a "ignore-branches", or a "paths and a ignore-paths". You can only have one or the other...
TriggerDetail push = new TriggerDetail();
//process branches
if (trigger.branches != null)
{
if (trigger.branches.include != null)
{
push.branches = trigger.branches.include;
}
else if (trigger.branches.exclude != null)
{
push.branches_ignore = trigger.branches.exclude;
}
}
//process paths
if (trigger.paths != null)
{
if (trigger.paths.include != null)
{
push.paths = trigger.paths.include;
}
if (trigger.paths.exclude != null)
{
push.paths_ignore = trigger.paths.exclude;
}
}
//process tags
if (trigger.tags != null)
{
if (trigger.tags.include != null)
{
push.tags = trigger.tags.include;
}
if (trigger.tags.exclude != null)
{
push.tags_ignore = trigger.tags.exclude;
}
}
return(new GitHubActions.Trigger
{
push = push
});
}
//process the pull request
public GitHubActions.Trigger ProcessPullRequest(AzurePipelines.Trigger pr)
{
if (pr == null)
{
return(null);
}
TriggerDetail pullRequest = new TriggerDetail();
//process branches
if (pr.branches != null)
{
if (pr.branches.include != null)
{
pullRequest.branches = pr.branches.include;
}
else if (pr.branches.exclude != null)
{
pullRequest.branches_ignore = pr.branches.exclude;
}
}
//process paths
if (pr.paths != null)
{
if (pr.paths.include != null)
{
pullRequest.paths = pr.paths.include;
}
if (pr.paths.exclude != null)
{
pullRequest.paths_ignore = pr.paths.exclude;
}
}
//process tags
if (pr.tags != null)
{
if (pr.tags.include != null)
{
pullRequest.tags = pr.tags.include;
}
if (pr.tags.exclude != null)
{
pullRequest.tags_ignore = pr.tags.exclude;
}
}
return(new GitHubActions.Trigger
{
pull_request = pullRequest
});
}
public static ROCIndicator Create(double eMA9Day, double eMA12Day, double rOCOnEMA9Day,
Quote market, TriggerDetail triggerDetail)
{
var macd = new ROCIndicator()
{
ROC14Days = eMA9Day,
EMA9Day = eMA12Day,
ROCOnEMA9Day = rOCOnEMA9Day,
Quote = market,
TriggerDetail = triggerDetail
};
return(macd);
}
// public void OnItemEnter( GameObject itemTarget, string itemName){
// Debug.Log("OnItemEnter: " + itemName);
// if(itemName == "WaitMoveToPos"){
// //Get Main ScriptGame
// ScriptGame s = GetScriptGameCache(AutoTileMap_Editor.Instance.Agent.transform);
// if(s.Script != null){
// s.OnItemEnter( itemTarget, itemName);
// }
// }
// }
public void CallBack_CreateNPC(TriggerDetail detail, int idNpc, GameObject npcTarget, NPC npcData, int tileX, int tileY)
{
if (detail.isCreateFromMap)
{
if (npcData.StartScript && npcData.IdxStartScript >= 0 && npcData.IdxStartScript < AutoTileMap_Editor.Instance.MapSelect.ScriptData.Count)
{
int mapIdx = AutoTileMap_Editor.Instance.MapIdxSelect;
var script = GetRawScript(mapIdx, npcData.IdxStartScript);
if (script != null)
{
ScriptGame s = GetScriptGameCache_NPC_Begin(npcTarget, true);
s.StartNormal(mapIdx, npcData.IdxStartScript, script, npcTarget);
}
}
}
else
{
ListNpcUsingInMainScript.Add(detail);
}
if (npcData.RunScript && npcData.IdxScript >= 0 && npcData.IdxScript < AutoTileMap_Editor.Instance.MapSelect.ScriptData.Count)
{
int mapIdx = AutoTileMap_Editor.Instance.MapIdxSelect;
var script = GetRawScript(mapIdx, npcData.IdxScript);
if (script != null)
{
var interaction = npcTarget.GetComponent <InteractionCheck>();
if (interaction == null)
{
interaction = npcTarget.AddComponent <InteractionCheck>();
interaction.Init();
}
var flags = TriggerGame.Instance.ScriptFlag(detail, script);
if (flags != null)
{
flags.AddEventListener_RemoveByFlag(ScriptGuiBase.ScriptYaml.Key_ShowInteractions, () => {
interaction.IsShowInteractions = ScriptGuiBase.ScriptYaml.IsShowInteractions(flags);
});
}
}
}
// Check Wait InteractionNPC
if (mOnInteractionNPC != null && !string.IsNullOrEmpty(mNPCRefWait) && npcTarget.name.IndexOf(mNPCRefWait) == 0)
{
CreateObjInteractionNPC(npcTarget);
}
}
public static ITrigger CreateSimpleTrigger(TriggerDetail triggerDetail)
{
switch (triggerDetail.IntervalType)
{
case IntervalType.Second:
return(CreateSimpleTriggerWithIntervalInSeconds(triggerDetail));
case IntervalType.Minute:
return(CreateSimpleTriggerWithIntervalInMinutes(triggerDetail));
case IntervalType.Hour:
return(CreateSimpleTriggerWithIntervalInHours(triggerDetail));
default:
return(CreateSimpleTriggerWithIntervalInSeconds(triggerDetail));
}
}
private void toolStripButtonAdd_Click(object sender, EventArgs e)
{
switch (_gridTypeEnumNow)
{
case ViewTypeEnum.JOB:
var job = new JobDetail(null, _jobLogic);
_refreshGrid = true;
job.ShowDialog();
break;
case ViewTypeEnum.TRIGGER:
var trig = new TriggerDetail(null, Jobs, _triggerLogic);
_refreshGrid = true;
trig.ShowDialog();
break;
}
}
private ScriptGame GetScriptGameCache(ref Dictionary <string, ScriptGame> _s, TriggerDetail t, bool forceCreate)
{
if (_s == null)
{
_s = new Dictionary <string, ScriptGame>();
}
string key = t.Hash;
if (_s.ContainsKey(key))
{
return(_s[key]);
}
if (forceCreate == false)
{
return(null);
}
var s = new ScriptGame(t);
_s.Add(key, s);
return(s);
}
public static async Task StartJobScheduler()
{
#region Logging
MethodBase method = MethodBase.GetCurrentMethod();
MethodName = method.Name;
#endregion
WebServer.WebApiLogger?.Verbose(ClassName, MethodName, "Start");
WebServer.WebApiLogger?.Information(ClassName, MethodName, "Staring Job Schedular");
await JobScheduler.Start();
/*-----------------------------------------------------------------------------------------------------------------*/
var resendFailedPacketJobName = CreatePrefixFormatedName("Job", "ResendFailedPacket");
var resendFailedPacketTriggerName = CreatePrefixFormatedName("Trigger", "ResendFailedPacket");
var resendFailedPacketJobDetail = JobDetailManager.CreateResendFailedPacketJob(resendFailedPacketJobName, JobDetailManager.Group);
var resendFailedPacketTriggerDetail = new TriggerDetail
{
GroupName = JobDetailManager.Group,
CronExpression = "0 0/30 0 ? * * *",
JobName = resendFailedPacketJobName,
TriggerName = resendFailedPacketTriggerName,
TriggerType = TriggerType.Cron
};
WebServer.WebApiLogger?.Debug(ClassName, MethodName, string.Format("Trigger Details:\n{0}", JsonConvert.SerializeObject(resendFailedPacketTriggerDetail, Formatting.Indented)));
var resendFailedPacketTrigger = TriggerFactory.CreateCronTrigger(resendFailedPacketTriggerDetail);
WebServer.WebApiLogger?.Debug(ClassName, MethodName, string.Format("Trigger:\n{0}", JsonConvert.SerializeObject(resendFailedPacketTrigger, Formatting.Indented)));
await JobScheduler.ScheduleJob(resendFailedPacketJobDetail, resendFailedPacketTrigger);
/*-----------------------------------------------------------------------------------------------------------------*/
WebServer.WebApiLogger?.Verbose(ClassName, MethodName, "End");
}
public ScriptGame(TriggerDetail t)
{
Detail = t;
Key = t.Hash;
}
private void DoActionNPC(int scopeIndext, int countStack, ScriptGuiBase.NPCAction npc)
{
if (mActionWait != null)
{
Debug.LogError("Have mActionWait");
return;
}
mActionWait = null;
if (npc.Action == ScriptGui.NPCAction.EAction.Show)
{
if (npc.UsingNPCTarget)
{
if (!OBJTarget)
{
EndAction();
InputFieldHelper.Instance.ShowNoti(string.Format("Error at Script ({0}): : Not found NPC on target", IdxScript));
return;
}
OBJTarget.gameObject.SetActive(true);
AutoTileMap_Editor.Instance.WarpTo(OBJTarget.transform, npc.x, npc.y);
}
else
{
TriggerDetail detail = new TriggerDetail()
{
refMap = IdxMap,
typeObj = eSlotAonTypeObj.Person,
refId = npc.IdNpc,
isCreateFromMap = false,
x = npc.x,
y = npc.y
};
if (AutoTileMap_Editor.Instance.ShowNPC(detail) == null)
{
EndAction();
return;
}
}
var t = npc.Next;
NextActionTo(t, countStack + 1);
return;
}
GameObject npcOBJ = GetNPCTarget(npc);
if (npcOBJ == null)
{
if (mIsMain)
{
var t = npc.Next;
NextActionTo(t, countStack + 1);
}
else
{
EndAction();
}
return;
}
if (!npcOBJ.activeSelf)
{
var t = npc.Next;
NextActionTo(t, countStack + 1);
return;
}
if (npcOBJ == OBJTarget)
{
CLEAR_ALL_ACTION_NPC(npcOBJ);
}
else
{
if (mIsMain)
{
//Pause other NPC
ScriptGame s_from_npc = TriggerGame.Instance.GetScriptGameCache_NPC_Begin(npcOBJ, false);
TriggerGame.Instance.AddScriptNeedResume(s_from_npc);
}
}
switch (npc.Action)
{
case ScriptGui.NPCAction.EAction.Show:
{
// No Check
break;
}
case ScriptGui.NPCAction.EAction.Hide:
{
if (npc.UsingNPCTarget == false)
{
AutoTileMap_Editor.Instance.RemoveNPC(npc.IdNpc);
}
else
{
if (OBJTarget != null)
{
OBJTarget.SetActive(false);
}
}
break;
}
case ScriptGui.NPCAction.EAction.Move:
{
// AutoTileMap_Editor.Instance.AddNPC( npc.IdNpc, npc.x, npc.y, true);
// GameObject npcOBJ = GetNPCTarget(npc);
if (npcOBJ != null && npcOBJ.activeSelf)
{
mActionWait = npc;
var high = AutoTileMap_Editor.Instance.MapSelect.GetHighRef(npc.x, npc.y) * 0.5f;
var to = new Vector3((0.5f + npc.x) * AutoTileMap_Editor.Instance.CellSize.x, high + 1, -(0.5f + npc.y) * AutoTileMap_Editor.Instance.CellSize.y);
var c = npcOBJ.GetComponent <NavMeshAgentCallback>();
if (c == null)
{
c = npcOBJ.AddComponent <NavMeshAgentCallback>();
}
c.WalkTo(1, to, ( NavMeshAgent nav ) => {
mActionWait = null;
var t = npc.Next;
this.NextActionTo(t, 0);
});
}
break;
}
case ScriptGui.NPCAction.EAction.LookAtCharacter:
{
// GameObject npcOBJ = GetNPCTarget(npc);
if (npcOBJ != null && npcOBJ.activeSelf)
{
bool requestLockBack = mIsMain;
if (NpcLookatMainCallback.InstanceOf(npcOBJ).LookTo(AutoTileMap_Editor.Instance.Agent, requestLockBack, (NpcLookatMainCallback n) => {
mActionWait = null;
var t = npc.Next;
this.NextActionTo(t, 0);
}))
{
mActionWait = npc;
}
else
{
var t = npc.Next;
this.NextActionTo(t, 0);
}
}
break;
}
case ScriptGui.NPCAction.EAction.Animation_Talk:
{
// GameObject npcOBJ = GetNPCTarget(npc);
if (npcOBJ != null && npcOBJ.activeSelf)
{
var b = npcOBJ.GetComponent <BasicMecanimControl>();
if (b != null)
{
mActionWait = npc;
b.TalkWithAni((BasicMecanimControl bb) => {
mActionWait = null;
var t = npc.Next;
this.NextActionTo(t, 0);
});
}
}
break;
}
case ScriptGui.NPCAction.EAction.Animation_Face_Down:
{
doNpcFaceTo(npc, new Vector3(0, 0, -1));
return;
}
case ScriptGui.NPCAction.EAction.Animation_Face_Up:
{
doNpcFaceTo(npc, new Vector3(0, 0, 1));
return;
}
case ScriptGui.NPCAction.EAction.Animation_Face_Left:
{
doNpcFaceTo(npc, new Vector3(-1, 0, 0));
return;
}
case ScriptGui.NPCAction.EAction.Animation_Face_Right:
{
doNpcFaceTo(npc, new Vector3(1, 0, 0));
return;
}
default:
{
EndAction();
return;
}
}
if (mActionWait == null)
{
var t = npc.Next;
NextActionTo(t, countStack + 1);
}
}
public ScriptGame GetScriptGameCache_NPC_Ingame(TriggerDetail t, bool forceCreate)
{
return(GetScriptGameCache(ref _s_npc_ingame, t, forceCreate));
}
public ScriptGame GetScriptGameCache_Script(TriggerDetail t, bool forceCreate)
{
return(GetScriptGameCache(ref _s_script, t, forceCreate));
}
public ScriptGame GetScriptGameCache_NPC_Begin(TriggerDetail t, bool forceCreate)
{
return(GetScriptGameCache(ref _s_npc_begin, t, forceCreate));
}
public void SetTriggerDetail(TriggerDetail triggerDetail)
{
TriggerDetail = triggerDetail;
}
private TriggerBuilder GetTriggerBuilder(JobDetail jd, TriggerDetail td)
{
var trigger = TriggerBuilder.Create();
trigger.WithIdentity(td.TriggerKey, jd.Group);
trigger.ForJob(jd.JobKey);
trigger.WithPriority(td.Priority);
trigger.StartAt(td.StartTime);
if (td.EndTime != null && !td.EndTime.Equals(DateTime.MinValue))
{
trigger.EndAt(td.EndTime);
}
switch (td.ScheduleTypeValue.ToLower())
{
case "seconds":
if (td.RepeatInterval > 0)
{
if (td.RepeatCount > 0)
{
trigger = trigger.WithSimpleSchedule(x => x
.WithIntervalInSeconds(td.RepeatInterval)
.WithRepeatCount(td.RepeatCount)
);
}
else
{
trigger = trigger.WithSimpleSchedule(x => x
.WithIntervalInSeconds(td.RepeatInterval)
.RepeatForever()
);
}
}
else
{
Log.Warn(String.Format("Job {0} was configured with {1} schedule but no Repeat Interval mentioned. Please configure the Repeat Interval correctly !!", jd.JobKey, td.ScheduleType), this);
}
Diagnostics.Log.Info(String.Format("ScheduleType {0} and Schedule : {1})", td.ScheduleType, trigger.ToString()), this);
break;
case "minutes":
if (td.RepeatInterval > 0)
{
if (td.RepeatCount > 0)
{
trigger = trigger.WithSimpleSchedule(x => x
.WithIntervalInMinutes(td.RepeatInterval)
.WithRepeatCount(td.RepeatCount)
);
}
else
{
trigger = trigger.WithSimpleSchedule(x => x
.WithIntervalInMinutes(td.RepeatInterval)
.RepeatForever()
);
}
}
else
{
Log.Warn(String.Format("Job {0} was configured with {1} schedule but no Repeat Interval mentioned. Please configure the Repeat Interval correctly !!", jd.JobKey, td.ScheduleType), this);
}
Diagnostics.Log.Info(String.Format("ScheduleType {0} and Schedule : {1})", td.ScheduleType, trigger.ToString()), this);
break;
case "hours":
if (td.RepeatInterval > 0)
{
if (td.RepeatCount > 0)
{
trigger = trigger.WithSimpleSchedule(x => x
.WithIntervalInHours(td.RepeatInterval)
.WithRepeatCount(td.RepeatCount)
);
}
else
{
trigger = trigger.WithSimpleSchedule(x => x
.WithIntervalInHours(td.RepeatInterval)
.RepeatForever()
);
}
}
else
{
Log.Warn(String.Format("Job {0} was configured with {1} schedule but no Repeat Interval mentioned. Please configure the Repeat Interval correctly !!", jd.JobKey, td.ScheduleType), this);
}
Diagnostics.Log.Info(String.Format("ScheduleType {0} and Schedule : {1})", td.ScheduleType, trigger.ToString()), this);
break;
case "daily":
trigger.WithSchedule(CronScheduleBuilder.DailyAtHourAndMinute(td.StartTime.Hour, td.StartTime.Minute));
break;
case "weekly":
//Convert Sitecore DaysOfWeeks property to System.DaysOfWeek which is understood by Quartz.net
if (td.DaysOfWeeks != null && td.DaysOfWeeks.Count > 0)
{
System.DayOfWeek[] dayOfWeeks = new System.DayOfWeek[td.DaysOfWeeks.Count];
for (int i = 0; i < td.DaysOfWeeks.Count; i++)
{
dayOfWeeks[i] = (System.DayOfWeek)Enum.Parse(typeof(System.DayOfWeek), td.DaysOfWeeks[i].DayOfWeekValue.ToString());
}
trigger.WithSchedule(CronScheduleBuilder.AtHourAndMinuteOnGivenDaysOfWeek(td.StartTime.Hour, td.StartTime.Minute, dayOfWeeks));
}
else
{
Log.Warn(String.Format("Job {0} was configured with {1} schedule but \"Day of Weeks\" was not set correctly. Please configure the trigger correctly !!", jd.JobKey, td.ScheduleType), this);
}
break;
case "monthly":
if (td.DayOfMonth > 0)
{
trigger.WithSchedule(CronScheduleBuilder.MonthlyOnDayAndHourAndMinute(td.DayOfMonth, td.StartTime.Hour, td.StartTime.Minute));
}
else
{
Log.Warn(String.Format("Job {0} was configured with {1} schedule but \"Day of Month\" was not set correctly. Please configure the trigger correctly !!", jd.JobKey, td.ScheduleType), this);
}
break;
case "custom":
if (!String.IsNullOrEmpty(td.CronExpression))
{
trigger.WithSchedule(CronScheduleBuilder.CronSchedule(new CronExpression(td.CronExpression)));
}
else
{
Log.Warn(String.Format("Job {0} was configured with {1} schedule but \"Cron Expression\" was not set correctly. Please configure the trigger correctly !!", jd.JobKey, td.ScheduleType), this);
}
break;
}
return(trigger);
}
public Flags ScriptFlag(TriggerDetail triggerDetal, ScriptGui.ScriptYaml script)
{
return(MapDataAt(triggerDetal.refMap).MapFlag(triggerDetal.Hash, script));
}
public List <TriggerDetail> GetTriggersForJob(JobDetail jobDetail)
{
Database masterDb = Factory.GetDatabase("master");
//Get the trigger definitions for this job
string quartzJobTriggersQuery =
"fast://" + GetJobDefinitionLocation() + "//*[@@parentid='" + jobDetail.Id + "']//*[@@templateid='" + Common.Constants.TriggerDetailTempalteID + "']";
Item[] quartzJobTriggers = masterDb.SelectItems(quartzJobTriggersQuery);
List <TriggerDetail> lstTriggers = new List <TriggerDetail>();
if (quartzJobTriggers != null && quartzJobTriggers.Length > 0)
{
foreach (Item triggerItem in quartzJobTriggers)
{
TriggerDetail triggerDetail = new TriggerDetail();
triggerDetail.Id = triggerItem.ID.ToString();
triggerDetail.ParentItemId = jobDetail.Id;
triggerDetail.TriggerKey = triggerItem["Trigger Key"];
if (!String.IsNullOrEmpty(triggerItem.Fields["Start Time"].Value))
{
triggerDetail.StartTime = ((DateField)triggerItem.Fields["Start Time"]).DateTime;
}
if (!String.IsNullOrEmpty(triggerItem.Fields["End Time"].Value))
{
triggerDetail.EndTime = ((DateField)triggerItem.Fields["End Time"]).DateTime;
}
if (!String.IsNullOrEmpty(triggerItem.Fields["Priority"].Value))
{
triggerDetail.Priority = int.Parse(triggerItem.Fields["Priority"].Value);
}
if (!String.IsNullOrEmpty(triggerItem.Fields["Day of Month"].Value))
{
triggerDetail.DayOfMonth = int.Parse(triggerItem["Day of Month"]);
}
//if (!String.IsNullOrEmpty(triggerItem.Fields["Repeat Every"].Value))
// triggerDetail.IntervalUnit = triggerItem["Repeat Every"];
if (!String.IsNullOrEmpty(triggerItem.Fields["Repeat Interval"].Value))
{
triggerDetail.RepeatInterval = int.Parse(triggerItem["Repeat Interval"]);
}
if (!String.IsNullOrEmpty(triggerItem.Fields["Repeat Count"].Value))
{
triggerDetail.RepeatCount = int.Parse(triggerItem["Repeat Count"]);
}
if (!String.IsNullOrEmpty(triggerItem.Fields["Schedule Type"].Value))
{
triggerDetail.ScheduleType = triggerItem.Fields["Schedule Type"].Value;
}
if (!String.IsNullOrEmpty(triggerItem.Fields["Cron Expression"].Value))
{
triggerDetail.CronExpression = triggerItem["Cron Expression"];
}
lstTriggers.Add(triggerDetail);
} //end for loop for triggers
} //end if
return(lstTriggers);
}
