static void SendDataToPortHardWear(string ticketID, string counterID, string serviceID, string data, string action)
{
var address = dicCounterKeyboard.FirstOrDefault(d => d.Value.CounterID == counterID).Key;
if (ticketID != null || !"".Equals(ticketID))
{
int indexService = -1;
if (action.Equals(ActionTicket.ACTION_FINISH))
{
indexService = 0;
data = "STOP";
}
else
{
indexService = getIndexService(serviceID, counterID);
}
if ((indexService != -1) && (address > 0))
{
EventProgram ev = new EventProgram(action, address, counterID, data, indexService);
serialCtrl.SendKeyBoard(ev);
}
else
{
Console.WriteLine(MessageError.ERROR_03);
}
}
else
{
EventProgram ev = new EventProgram(action, address, counterID, MessageError.ERROR_01, 0);
serialCtrl.SendKeyBoard(ev);
}
}
private static void sendActionToKeyBoard(string action, Ticket tk, string counterOld)
{
if (tk == null)
{
Console.WriteLine("Không có ticket");
return;
}
string data = tk.CNum;
var address = dicCounterKeyboard.FirstOrDefault(d => d.Value.CounterID == counterOld).Key;
if ((ActionTicket.ACTION_MOVE_SERVICE.Equals(action) || ActionTicket.ACTION_MOVE_COUNTER.Equals(action)) && tk != null)
{
var index = -1;
if (action.Equals(ActionTicket.ACTION_MOVE_COUNTER))
{
index = getIndexCounter(counterOld, dicCounter);
}
else
{
var serviceID = socket.GetService(tk);
index = getIndexService(serviceID, counterOld);
}
EventProgram ev = new EventProgram(action, address, counterOld, data, index);
serialCtrl.SendKeyBoard(ev);
}
else
{
var serviceID = socket.GetService(tk);
SendDataToPortHardWear(tk.Id, counterOld, serviceID, data, action);
}
serialCtrl.SendLED(action, address, data);
}
public async Task <ActionResult <EventProgram> > DeleteProgram(int id, int programid)
{
// Is the requester authorized?
if (GetAuthorizedOwnershipLevel(id) < OwnershipLevel.Moderator)
{
return(Forbidden());
}
EventProgram program = await Db.EventPrograms.FindAsync(programid);
if (program == null)
{
return(NotFound("Program not found"));
}
if (program.EventID != id)
{
return(BadRequest());
}
Db.EventPrograms.Remove(program);
await Db.SaveChangesAsync();
return(program);
}
public IActionResult DeleteProgramConfirmed(int Id)
{
EventProgram prog = _programRepository.GetProgram(Id);
_programRepository.DeleteProgram(prog.Id);
return(RedirectToAction("ViewPrograms"));
}
static void Mainm(string[] args)
{
EventProgram obj1 = new EventProgram();
string result = obj1.MyEvent("Tutorials Point");
Console.WriteLine(result);
Console.ReadKey();
}
public IActionResult AddProgram(EventProgram program)
{
if (ModelState.IsValid)
{
EventProgram newProg = _programRepository.AddProgram(program);
return(RedirectToAction("ProgramDetails", new { Id = newProg.Id, updated = false }));
}
return(View());
}
public IActionResult DeleteProgram(int Id)
{
EventProgram prog = _programRepository.GetProgram(Id);
if (prog == null)
{
Response.StatusCode = 404;
ViewBag.ErrorMsg = "Program Not Found with Id: " + Id;
}
return(View(prog));
}
public static async Task <APIResponse <Speaker> > UpdateProgramAsync(int id, int programid, string title, string location, DateTime startTime, DateTime endTime, string description)
{
EventProgram program = new EventProgram()
{
Title = title,
Location = location,
StartTime = startTime,
EndTime = endTime,
Description = description,
};
return(await PostAsync <Speaker>($"api/events/{id}/programs/{programid}", program));
}
private static void InitKeyBoardSend(EventSocket eventData)
{
if (eventData.IsLoadService)
{
dicService = sortDicServices(eventData.DicService);
List <string> lstServices = dicService.Values.OrderBy(m => m.NameService).Select(m => m.NameService).ToList();
EventProgram ev = new EventProgram(ActionTicket.INITIAL_SER, null, lstServices);
serialCtrl.SendKeyBoard(ev);
Thread.Sleep(5000);
}
#region SET SERVICE COUNTER CHO DEVICE
// send Counter
if (eventData.IsLoadCounter)
{
dicCounter = sortDicCounter(eventData.DicCounter);
foreach (var item in config.KeyBoardCounters)
{
int address = item.AddressKeyboard;
int numCounter = item.NumCounter;
var cou = dicCounter.Values.FirstOrDefault(m => m.CNum == numCounter);
if (cou != null && !string.IsNullOrWhiteSpace(cou.Id))
{
item.CounterID = cou.Id;
dicCounterKeyboard[address] = item;
}
}
}
List <string> lstCounters = dicCounter.Values.Select(m => m.Name).ToList();
//EventProgram evCou = new EventProgram(ActionTicket.INITIAL_COU, 1, lstCounters);// fix 1 = mấy đều được
//serialCtrl.SendKeyBoard(evCou);
EventProgram evCou1 = new EventProgram(ActionTicket.INITIAL_COU, eventData.DicCounter.Values.OrderBy(m => m.CNum).ToList(), dicCounterKeyboard);// fix 1 = mấy đều được
serialCtrl.SendKeyBoard(evCou1);
Thread.Sleep(5000);
//Set lai data cho recive port
serialCtrl.SetDataRecive(dicService, dicCounter, dicCounterKeyboard);
Thread.Sleep(1800);
#endregion
//send Led inital
var evReset = new EventProgram(ActionTicket.ACTION_RESET);
serialCtrl.SendKeyBoard(evReset);
Thread.Sleep(100);
SendNumToCounter(eventData, false);
Console.WriteLine("Set services and counter success!");
}
static void SendDataRetore(string action, string counterID, List <Ticket> lstObject, Dictionary <string, Service> dicSer)
{
if (lstObject != null && lstObject.Count() > 0)
{
var address = dicCounterKeyboard.FirstOrDefault(d => d.Value.CounterID == counterID).Key;
if (address > 0)
{
EventProgram ev = new EventProgram(action, address, lstObject, dicSer);
serialCtrl.SendKeyBoard(ev);
}
}
else
{
Console.WriteLine(MessageError.ERROR_03);
}
}
public IActionResult UpdateProgram(EventProgram model)
{
if (ModelState.IsValid)
{
EventProgram prog = _programRepository.GetProgram(model.Id);
prog.Title = model.Title;
prog.Type = model.Type;
prog.Venue = model.Venue;
prog.StartTime = model.StartTime;
prog.EndTime = model.EndTime;
prog.EventId = model.EventId;
_programRepository.UpdateProgram(prog); //reflect updated program in db
return(RedirectToAction("ProgramDetails", new { Id = prog.Id, updated = true }));
}
return(View(model));
}
public async Task <ActionResult <EventProgram> > CreateProgram(int id, [FromBody] EventProgram programdata)
{
// Is the requester authorized?
if (GetAuthorizedOwnershipLevel(id) < OwnershipLevel.Moderator)
{
return(Forbidden());
}
Event @event = await Db.Events.FindAsync(id);
if (@event == null)
{
return(NotFound("Event not found"));
}
@event.Programs.Add(programdata);
await Db.SaveChangesAsync();
return(programdata);
}
private static void SendNumToCounter(EventSocket eventData, bool isOpened)
{
bool isLst = false;
if (eventData.LstSend != null && eventData.LstSend.Count() > 0)
{
isLst = true;
foreach (var obj in eventData.LstSend)
{
var addKeyBoard = dicCounterKeyboard.Values.FirstOrDefault(m => m.CounterID == obj.Counter_Id);
if (addKeyBoard != null)
{
int address = addKeyBoard.AddressKeyboard;
if (address != 0)
{
var counterID = addKeyBoard.CounterID;
var indexService = getIndexService(socket.GetService(obj), counterID);
var data = obj.CNum;
EventProgram ev = new EventProgram("call_hst", address, counterID, data, indexService);
serialCtrl.SendKeyBoard(ev);
Thread.Sleep(1000);
serialCtrl.SendLED(eventData.Action, address, data);
}
}
}
}
if (isOpened && isLst)
{
var lstCounterId = eventData.LstSend.Select(m => m.Counter_Id);
var dicOut = dicCounterKeyboard.Where(m => !lstCounterId.Contains(m.Value.CounterID));
if (dicOut != null && dicOut.Count() > 0)
{
foreach (var item in dicOut)
{
EventProgram ev = new EventProgram(ActionTicket.MESSAGE_ERROR, item.Key, item.Value.CounterID, MessageError.ERROR_09, 0);
serialCtrl.SendKeyBoard(ev);
}
}
}
}
private static bool getConfigOpenSocket()
{
KeyBoardCtrl keyCtrl = new KeyBoardCtrl();
Priority priority = null;
try
{
var dataConfig = keyCtrl.GetConfig(config.https, config.StoreCode);
if (dataConfig != null)
{
if (dataConfig.priority_fix != null)
{
priority = dataConfig.priority_fix;
}
else
{
priority = dataConfig.priority;
}
}
else
{
return(false);
}
}
catch
{
foreach (var add in config.KeyBoardCounters)
{
EventProgram evDis = new EventProgram(ActionTicket.DISCONNECT, add.AddressKeyboard, null);
serialCtrl.SendKeyBoard(evDis);
}
SetTimerPing();
return(false);
}
InitSocket(config, priority);
return(true);
}
private static void ReciveDataSocket(EventSocket eventData)
{
if (eventData == null)
{
Console.WriteLine("Lỗi event");
return;
}
string data = null;
string counterOld = eventData.CounterID;
if (string.IsNullOrWhiteSpace(eventData.Message))
{
string action = eventData.Action;
switch (action)
{
case ActionTicket.INITIAL:
InitKeyBoardSend(eventData);
return;
case ActionTicket.OPEN_SERVER:
SendNumToCounter(eventData, true);
return;
case ActionTicket.ACTION_CREATE: // không làm gì
var address = dicCounterKeyboard.FirstOrDefault(d => d.Value.CounterID == eventData.CounterID).Key;
EventProgram ev = new EventProgram(ActionTicket.MESSAGE_ERROR, address, eventData.CounterID, MessageError.ERROR_00, 0);
serialCtrl.SendKeyBoard(ev);
return;
case ActionTicket.ACTION_CALL:
sendActionToKeyBoard(action, eventData.TkServing, eventData.CounterID);
break;
case ActionTicket.ACTION_RECALL:
sendActionToKeyBoard(action, eventData.TkServing, eventData.CounterID);
break;
case ActionTicket.ACTION_RESTORE:
sendActionToKeyBoard(action, eventData.TkServing, eventData.CounterID);
break;
case ActionTicket.ACTION_MOVE_COUNTER:
sendActionToKeyBoard(action, eventData.TkServing, eventData.CounterID);
break;
case ActionTicket.ACTION_MOVE_SERVICE:
sendActionToKeyBoard(action, eventData.TkServing, eventData.CounterID);
break;
case ActionTicket.ACTION_CANCEL:
sendActionToKeyBoard(action, eventData.TkServing, eventData.CounterID);
break;
case ActionTicket.ACTION_FINISH:
sendActionToKeyBoard(action, eventData.TkServing, eventData.CounterID);
break;
case ActionTicket.ACTION_ALL_RESTORE:
SendDataRetore(action, counterOld, eventData.LstSend, dicService);
break;
case ActionTicket.CALL_LIST_WATTING:
SendDataRetore(action, counterOld, eventData.LstSend, dicService);
break;
case ActionTicket.ACTION_CONNECT_COUNTER:
sendActionToKeyBoard(action, eventData.TkServing, eventData.CounterID);
break;
case ActionTicket.ACTION_PING:
serialCtrl.SendLED(action, 0, data);
break;
case ActionTicket.DISCONNECT:
EventProgram evDis = new EventProgram(ActionTicket.DISCONNECT, 0, null);
serialCtrl.SendKeyBoard(evDis);
return;
case ActionTicket.CONNECT:
EventProgram evCon = new EventProgram(ActionTicket.CONNECT, 0, null);
serialCtrl.SendKeyBoard(evCon);
return;
default:
//bug
break;
}
}
else
{
var address = dicCounterKeyboard.FirstOrDefault(d => d.Value.CounterID == counterOld).Key;
if (address == 0)
{
return;
}
EventProgram ev = new EventProgram(ActionTicket.MESSAGE_ERROR, address, eventData.CounterID, eventData.Message, 1);
serialCtrl.SendKeyBoard(ev);
}
}
private static void ReciveSerialCtrl(EventProgram ev)
{
socket.SendSocket(ev.Action, ev.CounterID, ev.LstCounter, ev.LstServices, ev.CNum, ev.PointRate);
}
