private void AssignmentDataGridView_DoubleClick(object sender, EventArgs e)
{
EventTask selected = (EventTask)assignmentDataGridView.CurrentRow.DataBoundItem;
new ManageAssignmentForm(this, selected).Show();
this.Hide();
}
protected void LogEvent(EventTask task, EventId id, string context, string name, string version, string providerName, string source, string status, string destinationPath)
{
#if !UNIX
var iis = InitialSessionState.CreateDefault2();
using (Runspace rs = RunspaceFactory.CreateRunspace(iis))
{
using (PowerShell powershell = PowerShell.Create())
{
try
{
rs.Open();
powershell.Runspace = rs;
powershell.AddCommand(Constants.NewWinEvent);
powershell.AddParameter("ProviderName", Constants.PowerShellProviderName);
powershell.AddParameter("Id", id);
powershell.AddParameter("Payload", new object[] {
task.ToString(),
string.Format(CultureInfo.InvariantCulture, "Package={0}, Version={1}, Provider={2}, Source={3}, Status={4}, DestinationPath={5}", name, version, providerName, source, status, destinationPath),
context
});
powershell.Invoke();
}
catch (Exception ex)
{
Verbose(ex.Message);
}
}
}
#endif
}
public override void onClick()
{
GameObject goJoueur = ClientScene.FindLocalObject(this.idJoueurPossesseur);
if (null != goJoueur)
{
Joueur joueur = goJoueur.GetComponent <Joueur> ();
if (isMovableByPlayer(joueur))
{
EventTask eventTask = EventTaskUtils.getEventTaskEnCours();
if (this.etatSelectionnable == SelectionnableUtils.ETAT_SELECTIONNABLE && null != eventTask && eventTask is EventTaskChoixCible)
{
((EventTaskChoixCible)eventTask).ListCibleChoisie.Add(this);
}
else if (joueur.CarteSelectionne is CarteBatimentMetier || joueur.CarteSelectionne is CarteDefenseMetier || listNomCarteExeption.Contains(joueur.CarteSelectionne.name))
{
if (isCardCostPayable(joueur.RessourceMetal, joueur.CarteSelectionne))
{
joueur.CmdPayerRessource(joueur.RessourceMetal.TypeRessource, ((CarteConstructionMetierAbstract)joueur.CarteSelectionne).getCoutMetal());
joueur.CarteSelectionne.deplacerCarte(this, joueur.netId, NetworkInstanceId.Invalid);
}
}
else if (joueur.CarteSelectionne is CarteVaisseauMetier)
{
//TODO vaisseau en mode defense
}
}
}
}
private void EventTasksDataGrid_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
{
EventTask selected = (EventTask)eventTasksDataGrid.CurrentRow.DataBoundItem;
new ManageAssignmentForm(this, selected).Show();
this.Hide();
}
/// <summary>
/// Enables <see cref="Keywords.Diagnostics"/> events (at the listener's level) for the given <paramref name="task"/>.
/// These events may have been excluded from this listener by default.
/// </summary>
public void EnableTaskDiagnostics(EventTask task)
{
lock (m_lock)
{
m_enableTaskDiagnostics[(int)task] = true;
}
}
public void CreateTask(NetworkInstanceId netIdSourceAction, NetworkInstanceId netIdJoueurSourceAction, int idSelectionCible, int typeAction, NetworkInstanceId netIdParentTask, bool createTaskBrother)
{
if (isServer)
{
GameObject eventTaskGO = Instantiate <GameObject> (ConstanteInGame.eventTaskPrefab);
GameObject eventParnetTaskGO;
if (netIdParentTask == NetworkInstanceId.Invalid)
{
eventParnetTaskGO = GameObject.Find("SystemActionEvent");
}
else
{
eventParnetTaskGO = NetworkServer.FindLocalObject(netIdParentTask);
}
eventTaskGO.transform.SetParent(eventParnetTaskGO.transform);
EventTask eventTask = eventTaskGO.GetComponent <EventTask> ();
eventTask.initVariable(netIdSourceAction, netIdJoueurSourceAction, idSelectionCible, typeAction, createTaskBrother);
NetworkServer.Spawn(eventTaskGO);
}
else
{
print("Create Task call on client");
}
}
public void BeginMessageLoop()
{
while (!_done)
{
EventTask task = null;
if (!_items.TryDequeue(out task))
{
task = null;
}
if (task != null)
{
task.Item1(task.Item2);
if (InnerException != null) // method threw an exeption
{
throw new AggregateException(
"AsyncBridge.Run method threw an exception.",
InnerException);
}
}
else
{
_workItemsWaiting.WaitOne();
}
}
}
/*****************ISelectionnable*****************/
public override void onClick()
{
Joueur joueurLocal = JoueurUtils.getJoueurLocal();
if (null != joueurLocal)
{
TourJeuSystem systemTour = TourJeuSystem.getTourSystem();
//Si un joueur clique sur une carte capable d'attaquer puis sur une carte ennemie cela lance une attaque
EventTask eventTask = EventTaskUtils.getEventTaskEnCours();
if (systemTour.getPhase(joueurLocal.netId) == TourJeuSystem.PHASE_ATTAQUE &&
null != joueurLocal.CarteSelectionne && joueurLocal.CarteSelectionne.JoueurProprietaire != JoueurProprietaire &&
joueurLocal.CarteSelectionne is IAttaquer && ((IAttaquer)joueurLocal.CarteSelectionne).isCapableAttaquer() &&
!(null != eventTask && eventTask is EventTaskChoixCible)) //On ne peut attaquer si choix de defense en cours
//TODO vérifier l'emplacement sol
{
JoueurUtils.getJoueurLocal().CmdCreateTask(joueurLocal.CarteSelectionne.netId, joueurLocal.netId, this.IdISelectionnable, ConstanteIdObjet.ID_CONDITION_ACTION_ATTAQUE, NetworkInstanceId.Invalid, false);
}
else
{
base.onClick();
}
}
else
{
base.onClick();
}
}
public void GetAvailableUsers_InTheMiddle()
{
// Arrange
Seed.events = new List <Event>();
User user = new User("[email protected]", "", User.Roles.Photographer);
string recordNumber = "123";
int oldUserCount = eventController.GetAvailableUsers(new List <User> {
user
}, DateTime.Now.AddDays(2), DateTime.Now.AddDays(3)).Count;
var eventRequest = new EventRequest(recordNumber, new Client("Peter", "Pen", "238740291"), "Party",
DateTime.Now, DateTime.Now.AddDays(5),
33, 321);
eventController.Create(eventRequest);
var eventTask = new EventTask("test description", user);
eventController.CreateTask(recordNumber, eventTask);
// Act
var users = eventController.GetAvailableUsers(new List <User> {
user
}, DateTime.Now.AddDays(2), DateTime.Now.AddDays(3));
// Assert
Assert.AreEqual(oldUserCount - 1, users.Count);
}
public void BeginMessageLoop()
{
while (!_done)
{
EventTask task = null;
if (!_items.TryDequeue(out task))
{
task = null;
}
if (task != null)
{
task.Item1(task.Item2);
if (InnerException != null) // method threw an exeption
{
InnerException.Throw();
}
}
else
{
_workItemsWaiting.WaitOne();
}
}
}
public EventTask Create(EventTask inputModel)
{
var ifUser = _context.Users.Select(u => u.Id == inputModel.UserId);
if (inputModel.StartDt > inputModel.EndDt)
{
return(null);
}
EventTask task = new EventTask()
{
Draggable = true,
Resizable = true,
StartDt = inputModel.StartDt,
EndDt = inputModel.EndDt,
Title = inputModel.Title,
UserId = inputModel.UserId,
Colour = Colour.Blue.Value,
Description = inputModel.Description,
Completed = false,
User = _context.Users.Where(u => u.Id == inputModel.UserId).FirstOrDefault()
};
task.Colour = ChangeColour(task);
_context.EventTasks.Add(task);
return(task);
}
/*******************ISelectionnable****************/
public void onClick()
{
EventTask eventTask = EventTaskUtils.getEventTaskEnCours();
if (this.etatSelectionne == 1 && null != eventTask && eventTask is EventTaskChoixCible)
{
((EventTaskChoixCible)eventTask).ListCibleChoisie.Add(this);
}
}
/*******************ISelectionnable****************/
public void onClick()
{
//TODO selectionne
EventTask eventTask = EventTaskUtils.getEventTaskEnCours();
if (this.etatSelectionnable == SelectionnableUtils.ETAT_SELECTIONNABLE && null != eventTask && eventTask is EventTaskChoixCible)
{
((EventTaskChoixCible)eventTask).ListCibleChoisie.Add(this);
}
}
private string GetTaskName(EventTask task, string eventName)
{
string str = null;
if ((this.taskTab == null) || !this.taskTab.TryGetValue((int)task, out str))
{
throw new ArgumentException(string.Concat(new object[] { "Use of undefined task value ", task, " for event ", eventName }));
}
return(str);
}
public TraceFilterDescription(
EventTask taskId,
string eventName,
EventLevel level,
int samplingRatio)
{
this.traceTaskId = taskId;
this.traceEventName = eventName;
this.level = level;
this.samplingRatio = samplingRatio;
}
internal string GetEventTaskName(EventTask eventTask)
{
try
{
return(this.taskMap.Single(t => t.Value == eventTask).Key);
}
catch (Exception)
{
return("UnSpecified");
}
}
public ManageAssignmentForm(Form mainForm, EventTask eventTask)
{
InitializeComponent();
this.mainForm = mainForm;
this.eventTask = eventTask;
planTextBox.Text = eventTask.Plan;
Refresh();
}
public void RemoveFilter(EventTask taskId, string eventName)
{
for (int i = 0; i < this.filters.Count; i++)
{
if (this.filters[i].Matches(taskId, eventName))
{
this.filters.RemoveAt(i);
return;
}
}
}
public async Task <ActionResult <EventTask> > PostEventTask(EventTask eventTaskInput)
{
var eventTask = _eventTasksService.Create(eventTaskInput);
if (eventTask == null)
{
throw new ApiException("Starting date must be less than ending date", HttpStatusCode.BadRequest);
}
await _context.SaveChangesAsync();
//return CreatedAtAction("GetEventTask", new { id = eventTask.Id }, eventTask);
return(Ok(eventTask));
}
private void CreateTask_Button_Click(object sender, EventArgs e)
{
User user = (User)this.assignedTo_Combo.SelectedItem;
if (user != null)
{
var eventTask = new EventTask(this.descriptionText.Text, user);
var eventController = new EventController();
eventController.CreateTask(evnt.RecordNr, eventTask);
mainForm.RefreshTasks();
this.Hide();
}
}
public void Connect(IWatcher watcher)
{
lock (_lock)
{
if (_eventTask != null)
{
throw new Exception("Already connected.");
}
_eventTask = new EventTask(watcher);
_eventTask.Start();
_eventTask.Send(new WatchedEvent(KeeperState.SyncConnected, EventType.None, null));
}
}
public Event CreateTask(string recordNumber, EventTask task)
{
var ev = Seed.events.FirstOrDefault(events => events.RecordNr == recordNumber);
if (ev != null)
{
ev.Tasks.Add(task);
return(ev);
}
else
{
throw new ApplicationException("Could not find task with that record number");
}
}
public void CreateTaskEventDoesNotExistTest()
{
// Arrange
string recordNumber = "123";
User user = new User("[email protected]", "", User.Roles.Photographer);
var eventTask = new EventTask("test description", user);
// Act
var exception = Assert.ThrowsException <ApplicationException>(() => eventController.CreateTask(recordNumber, eventTask));
// Assert
Assert.AreEqual("Could not find task with that record number", exception.Message);
}
public void AddFilter(EventTask taskId, string eventName, EventLevel level, int samplingRatio)
{
TraceFilterDescription filter = new TraceFilterDescription(taskId, eventName, level, samplingRatio);
for (int i = 0; i < this.filters.Count; i++)
{
if (this.filters[i].Matches(taskId, eventName))
{
this.filters[i] = filter;
return;
}
}
this.filters.Add(filter);
}
/// <summary>
/// Initializes a new instance of the <see cref="Microsoft.Practices.EnterpriseLibrary.SemanticLogging.Schema.EventSchema"/> class with the specified values.
/// </summary>
/// <param name="id">The event id.</param>
/// <param name="providerId">The provider GUID.</param>
/// <param name="providerName">The provider name.</param>
/// <param name="level">The event level.</param>
/// <param name="task">The event task.</param>
/// <param name="taskName">The event task name.</param>
/// <param name="opcode">The event operation code.</param>
/// <param name="opcodeName">The event operation code name.</param>
/// <param name="keywords">The event keywords.</param>
/// <param name="keywordsDescription">The event keywords description.</param>
/// <param name="version">The event version.</param>
/// <param name="payload">The event payload.</param>
public EventSchema(int id, Guid providerId, string providerName, EventLevel level, EventTask task, string taskName, EventOpcode opcode, string opcodeName, EventKeywords keywords, string keywordsDescription, int version, IEnumerable <string> payload)
{
this.id = id;
this.providerId = providerId;
this.providerName = providerName;
this.level = level;
this.task = task;
this.taskName = taskName;
this.opcode = opcode;
this.opcodeName = opcodeName;
this.keywords = keywords;
this.keywordsDescription = keywordsDescription;
this.version = version;
this.payload = payload.ToArray();
}
private string ChangeColour(EventTask inputModel)
{
if (inputModel.EndDt == null || inputModel.EndDt.ToString() == "")
{
return(Colour.Yellow.Value);
}
else if (Math.Abs(((DateTime)inputModel.EndDt - DateTime.Now).TotalDays) <= 3)
{
return(Colour.Red.Value);
}
else
{
return(Colour.Blue.Value);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Microsoft.Practices.EnterpriseLibrary.SemanticLogging.Schema.EventSchema"/> class with the specified values.
/// </summary>
/// <param name="id">The event id.</param>
/// <param name="providerId">The provider GUID.</param>
/// <param name="providerName">The provider name.</param>
/// <param name="level">The event level.</param>
/// <param name="task">The event task.</param>
/// <param name="taskName">The event task name.</param>
/// <param name="opcode">The event operation code.</param>
/// <param name="opcodeName">The event operation code name.</param>
/// <param name="keywords">The event keywords.</param>
/// <param name="keywordsDescription">The event keywords description.</param>
/// <param name="version">The event version.</param>
/// <param name="payload">The event payload.</param>
public EventSchema(int id, Guid providerId, string providerName, EventLevel level, EventTask task, string taskName, EventOpcode opcode, string opcodeName, EventKeywords keywords, string keywordsDescription, int version, IEnumerable<string> payload)
{
this.id = id;
this.providerId = providerId;
this.providerName = providerName;
this.level = level;
this.task = task;
this.taskName = taskName;
this.opcode = opcode;
this.opcodeName = opcodeName;
this.keywords = keywords;
this.keywordsDescription = keywordsDescription;
this.version = version;
this.payload = payload.ToArray();
}
//구현방법 2가지가 떠올랐다.
//1. 리스트를 모두 탐색해서 만약 첫번째 인덱스가 Sequence이면 Spawn이 시작되는점까지 검색한다. 그리고 그 이벤트들을 따로 시퀀스 리스트에 담아 돌린다.
//이렇게 할 경우 리스트 이동연산이 발생한다.
//2. 아예 없이 만들려면 .. 첫 인덱스의 Sequnce인지 Spawn인지 알아낸 후 그와 반대값의 EventTask가 나올때까지 해당 타입의 방식으로 이벤트를 진행한다.
//구현시 참고 : Spawn의 경우 IsCompleted()의 영향은 받지않는다. 당연히 Fire And Forget형식의 함수이니 말이다.
//우선 2번의 방식으로 구현해보고 뭔가 너무 까다로우면 1번으로 변경.
//1번은 코드가 깔끔하게 나올것같다.
//2번으로 짯는데 재귀적인 걍 짜다보니 재귀적인 구조로 깔끔하게 나온것같다.
protected override IEnumerator Runner()
{
EventTask firstTask = m_EventList.Peek();
if (firstTask.IsSequence())
{
m_MonoBehaviour.StartCoroutine(SequenceDo());
}
else
{
m_MonoBehaviour.StartCoroutine(SpawnDo());
}
yield return(null);
}
public static bool GetEventEnabledStatus(
TraceSinkType sinkType,
EventLevel level,
EventTask taskId,
string eventName)
{
lock (SyncLock)
{
int garbage;
return(SinkFilters[(int)sinkType].StaticCheck(
level,
taskId,
eventName,
out garbage));
}
}
public static EventEntry Create(
int eventId = 0,
Guid providerId = default(Guid),
string providerName = null,
EventLevel level = default(EventLevel),
EventTask task = default(EventTask),
string taskName = null,
EventOpcode opcode = default(EventOpcode),
string opcodeName = null,
EventKeywords keywords = default(EventKeywords),
string keywordsDescription = null,
int version = 0,
IEnumerable<string> payloadNames = null,
string formattedMessage = null,
IEnumerable<object> payload = null,
DateTimeOffset timestamp = default(DateTimeOffset),
Guid activityId = default(Guid),
Guid relatedActivityId = default(Guid),
int processId = 0,
int threadId = 0)
{
return
new EventEntry(
providerId,
eventId,
formattedMessage,
new ReadOnlyCollection<object>((payload ?? Enumerable.Empty<object>()).ToList()),
timestamp != default(DateTimeOffset) ? timestamp : DateTimeOffset.UtcNow,
processId,
threadId,
activityId,
relatedActivityId,
new EventSchema(
eventId,
providerId,
providerName,
level,
task,
taskName,
opcode,
opcodeName,
keywords,
keywordsDescription,
version,
(payloadNames ?? Enumerable.Empty<string>())));
}
public static EventEntry Create(
int eventId = 0,
Guid providerId = default(Guid),
string providerName = null,
EventLevel level = default(EventLevel),
EventTask task = default(EventTask),
string taskName = null,
EventOpcode opcode = default(EventOpcode),
string opcodeName = null,
EventKeywords keywords = default(EventKeywords),
string keywordsDescription = null,
int version = 0,
IEnumerable <string> payloadNames = null,
string formattedMessage = null,
IEnumerable <object> payload = null,
DateTimeOffset timestamp = default(DateTimeOffset),
Guid activityId = default(Guid),
Guid relatedActivityId = default(Guid),
int processId = 0,
int threadId = 0)
{
return
(new EventEntry(
providerId,
eventId,
formattedMessage,
new ReadOnlyCollection <object>((payload ?? Enumerable.Empty <object>()).ToList()),
timestamp != default(DateTimeOffset) ? timestamp : DateTimeOffset.UtcNow,
processId,
threadId,
activityId,
relatedActivityId,
new EventSchema(
eventId,
providerId,
providerName,
level,
task,
taskName,
opcode,
opcodeName,
keywords,
keywordsDescription,
version,
(payloadNames ?? Enumerable.Empty <string>()))));
}
/*******************ISelectionnable****************/
public virtual void onClick()
{
EventTask eventTask = EventTaskUtils.getEventTaskEnCours();
if (this.etatSelectionne == 1 && null != eventTask && eventTask is EventTaskChoixCible)
{
((EventTaskChoixCible)eventTask).ListCibleChoisie.Add(this);
}
else if (JoueurProprietaire.CarteSelectionne == this)
{
JoueurProprietaire.CarteSelectionne = null; //On deselectionne au second click
}
else
{
JoueurProprietaire.CarteSelectionne = this;
}
}
private string GetTaskName(EventTask task, string eventName)
{
if (task == EventTask.None)
return "";
string ret;
if (taskTab == null)
taskTab = new Dictionary<int, string>();
if (!taskTab.TryGetValue((int)task, out ret))
ret = taskTab[(int)task] = eventName;
return ret;
}
private string GetTaskName(EventTask task, string eventName)
{
string ret = null;
if (taskTab == null || !taskTab.TryGetValue((int)task, out ret))
throw new ArgumentException("Use of undefined task value " + task + " for event " + eventName);
return ret;
}
protected override BehaviorTask createTask()
{
EventTask pTask = new EventTask();
return pTask;
}
private string GetTaskName(EventTask task, string eventName)
{
string str = null;
if ((this.taskTab == null) || !this.taskTab.TryGetValue((int) task, out str))
{
throw new ArgumentException(string.Concat(new object[] { "Use of undefined task value ", task, " for event ", eventName }));
}
return str;
}
