public List <ReportEvent> GetByEventId(UInt64 eventId, uint maxRows)
{
MySqlCommand cmd = new MySqlCommand(String.Format("SELECT * FROM reporting.report_events where event_id = {0} ORDER BY event_date", eventId),
this._connection.Handle);
DataTable datatable = new DataTable();
this._dataAdapter.SelectCommand = cmd;
this._dataAdapter.Fill(datatable);
List <ReportEvent> l = new List <ReportEvent>();
foreach (DataRow row in datatable.Rows)
{
ReportEvent e = new ReportEvent
{
Id = Convert.ToUInt64(row["id"]),
EventId = Convert.ToUInt64(row["event_id"]),
EventData = row["event_data"].ToString(),
EventDate = row["event_date"].ToString()
};
l.Add(e);
}
return(l);
}
public void Unsubscribe(Client client)
{
_service.Delete(client);
_service.Dispose();
ReportEvent.Invoke("Вы отказались от подписки.");
}
public List <ReportEvent> GetAll()
{
MySqlCommand cmd = new MySqlCommand("SELECT * FROM reporting.report_events order by event_id", this._connection.Handle);
DataTable datatable = new DataTable();
this._dataAdapter.SelectCommand = cmd;
this._dataAdapter.Fill(datatable);
List <ReportEvent> l = new List <ReportEvent>();
foreach (DataRow row in datatable.Rows)
{
ReportEvent e = new ReportEvent
{
Id = Convert.ToUInt64(row["id"]),
EventId = Convert.ToUInt64(row["event_id"]),
EventData = row["event_data"].ToString()
};
l.Add(e);
}
return(l);
}
public void Subscribe(Client client, int monthCount)
{
_service.Insert(client);
_service.Dispose();
ReportEvent.Invoke($"Вы оформили подписку на {monthCount} месяцев(а).");
}
public void Pay(Client client, Journal journal)
{
var existingClient = new Client {
Id = client.Id
};
var existingJournal = new Journal {
Id = journal.Id
};
_service._context.Clients.Attach(client);
_service._context.Journals.Attach(journal);
var order = new Order
{
Client = existingClient,
Journal = existingJournal,
IsDelivered = false
};
_service.Insert(order);
_service.Dispose();
ReportEvent.Invoke($"Вы оплатили покупку стоимостью {existingJournal.Price} тенге. Ждите доставки");
}
public void Add(Journal journal)
{
_service.Insert(journal);
_service.Dispose();
ReportEvent.Invoke("Добавлен новый номер! Скупитесь, не пожалеете!!!!!!");
}
public void DeleteAccount(ReportEvent evt, ConnectionManager cm, int sleepTime)
{
TuDbConnection dbConnection = null;
try
{
dbConnection = cm.GetConnection();
}
catch (Exception ex)
{
Logger.Debug(String.Format("Error connecting to database: {0}", ex.Message));
return;
}
EventLogDataAdapter eventLogDataAdapter = new EventLogDataAdapter(dbConnection);
try
{
String msg = String.Format("Delete Account Event has been processed for event id {0} event data [{1}] event date [{2}]", evt.EventId, evt.EventData, evt.EventDate);
eventLogDataAdapter.Insert(evt.EventId, msg);
Logger.Debug("Connection " + dbConnection.ConnectionId + " - " + msg);
Thread.Sleep(sleepTime * 1000);
cm.Release(dbConnection);
}
catch (Exception ex)
{
Logger.Debug(String.Format("Error starting threads: {0}", ex.Message));
}
}
public async Task <ReportEvent> GetReport()
{
var allContact = await contactContext.ContactInfo.Find(x => true).ToListAsync();
var filteredData = allContact.Where(b => b.IletisimTipi == Entities.Enums.IletisimTipi.Konum).Select(c => new ReportData {
Konum = c.Aciklama, KonumdakiToplamTelefonNo = allContact.Where(x => x.IletisimTipi == Entities.Enums.IletisimTipi.TelefonNumarasi && x.PersonId == c.PersonId).Count()
});
var res = filteredData.GroupBy(x => x.Konum).Select(y => new ReportData {
Konum = y.Key, KonumdakiToplamKayit = y.Count(), KonumdakiToplamTelefonNo = y.Sum(v => v.KonumdakiToplamTelefonNo)
}).ToList();
var model = new ReportEvent()
{
Durum = RaporDurumConvert.RaporDurumEnum(2),
ReportId = Guid.NewGuid(),
RaporIcerigi = res
};
try
{
reportProducer.PubishReport(EventConstants.ReportQueue, model);
}
catch (Exception)
{
throw;
}
return(model);
}
public static void ProcessEvent(Assembly asm, String className, String methodName, ReportEvent evt, ConnectionManager connectionManager, int sleepTime)
{
Type type = asm.GetType(className);
if (type == null)
{
throw new EventProcessorClassNotFound();
}
ConstructorInfo ctor = type.GetConstructor(Type.EmptyTypes);
object calc = ctor.Invoke(null);
MethodInfo m = type.GetMethod(methodName);
if (m == null)
{
throw new EventProcessorClassEntryNotImplemented();
}
object[] args = new object[3];
args[0] = evt;
args[1] = connectionManager;
args[2] = sleepTime;
m.Invoke(calc, args);
}
private void DeleteEventFromTable(ReportEvent evt, ConnectionManager cm)
{
TuDbConnection dbConnection;
try
{
dbConnection = cm.GetConnection();
}
catch (DbNoConnections dbn)
{
throw dbn;
}
catch (MySql.Data.MySqlClient.MySqlException mex)
{
throw mex;
}
catch (Exception ex)
{
throw ex;
}
ReportEventsDataAdapter reportEventsDataAdapter = new ReportEventsDataAdapter(dbConnection);
try
{
reportEventsDataAdapter.DeleteEvent(evt);
cm.Release(dbConnection);
}
catch (Exception ex)
{
cm.Release(dbConnection);
throw ex;
}
}
public Report GetReport(int telephoneNumber)
{
var calls = _storage.GetInfoList().Where(x => x.SourceNumber == telephoneNumber || x.TargetNumber == telephoneNumber).ToList();
var report = new Report();
foreach (var call in calls)
{
CallType callType;
int number;
if (call.SourceNumber == telephoneNumber)
{
callType = CallType.OutgoingCall;
number = call.TargetNumber;
}
else
{
callType = CallType.IncomingCall;
number = call.SourceNumber;
}
var record = new ReportEvent(callType, number, call.StartCall, new DateTime((call.EndCall - call.StartCall).Ticks), call.Cost);
report.AddRecord(record);
}
return(report);
}
public void PubishReport(string queName, ReportEvent model)
{
model.Durum = RaporDurumConvert.RaporDurumEnum(1);
Thread.Sleep(2000);
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: queName, durable: false, exclusive: false, autoDelete: false, arguments: null);
model.Durum = RaporDurumConvert.RaporDurumEnum(2);
var message = JsonConvert.SerializeObject(model);
var body = Encoding.UTF8.GetBytes(message);
IBasicProperties bprops = channel.CreateBasicProperties();
bprops.Persistent = true;
bprops.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish(exchange: "", routingKey: queName, mandatory: true, basicProperties: bprops, body: body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, eventArgs) =>
{
Console.WriteLine("RabbitMQ");
};
channel.ConfirmSelect();
}
}
public void AddEvent(ReportEvent e)
{
_queueMutex.WaitOne();
this._events.Enqueue(e);
_queueMutex.ReleaseMutex();
}
public void AddEvent(ulong eventId, ReportEvent e)
{
_queueListMutex.WaitOne(15000);
this._eventQueues[eventId].AddEvent(e);
_queueListMutex.ReleaseMutex();
}
public void Withdraw(int sum)
{
if (sum <= Sum)
{
Sum -= sum;
ReportEvent?.Invoke($"Со счета было снято {sum}");
return;
}
ReportEvent?.Invoke("На счете не хватает средств");
}
public int WithdrowSum(int sum)
{
if (sum <= Sum)
{
Sum -= sum;
ReportEvent?.Invoke($"У вас снято {sum}");
return(sum);
}
ReportEvent?.Invoke($"Недостаточно средств");
return(-1);
}
public ShadowDevice Apply(ReportEvent reportEvent)
{
var eventHistory = reportEvent.ToEventHistory();
eventHistory.Detail = reportEvent.Data;
this.AddEventHistory(eventHistory);
Console.WriteLine($"{reportEvent.DeviceId} reports data {reportEvent.Data} at {reportEvent.EventTime}");
return(this);
}
private void OnWorkPerformed(int hours, ActionType actionType, Location location)
{
var eventArgs = new ReportHoursEventArgs
{
Hours = hours,
ActionType = actionType,
Location = location
};
ReportEvent?.Invoke(this, eventArgs);
}
public void DoWork()
{
var hours = 8;
for (int i = 0; i <= hours; i++)
{
ReportEvent?.Invoke(i, ActionType.Working, new Location("KMW", "Warsaw"));
Thread.Sleep(500);
}
ReportCompletedEvent?.Invoke(this, EventArgs.Empty);
}
public ReportEvent GetEvent(ulong eventId, ConnectionManager cm, String threadId)
{
var isOwned = _queueListMutex.WaitOne(15000);
if (!isOwned)
{
Logger.Debug("Unable to get queue list mutex for event id " + eventId);
return(null);
}
ReportEvent evt = this._eventQueues[eventId].GetEvent();
if (evt == null)
{
_queueListMutex.ReleaseMutex();
return(null);
}
try
{
this.DeleteEventFromTable(evt, cm);
}
catch (DbNoConnections dbn)
{
this._eventQueues[eventId].AddEvent(evt);
_queueListMutex.ReleaseMutex();
throw dbn;
}
catch (MySql.Data.MySqlClient.MySqlException mex)
{
this._eventQueues[eventId].AddEvent(evt);
_queueListMutex.ReleaseMutex();
throw mex;
}
catch (Exception ex)
{
this._eventQueues[eventId].AddEvent(evt);
_queueListMutex.ReleaseMutex();
throw ex;
}
finally
{
// Logger.Debug(threadId + " - Releasing queue list mutext for event id " + eventId);
_queueListMutex.ReleaseMutex();
// Logger.Debug(String.Format(threadId + " - Found event for event id {0}", eventId));
}
return(evt);
}
public void Add(T entity)
{
var data = GetAll();
data.Add(entity);
using (var stream = File.Open("AllProducts.json", FileMode.OpenOrCreate))
{
string json = JsonConvert.SerializeObject(data);
StreamWriter sw = new StreamWriter(stream);
sw.Write(json);
sw.Close();
ReportEvent?.Invoke($"Товар добавлен");
}
}
public ReportEvent GetEvent()
{
_queueMutex.WaitOne();
ReportEvent e = null;
if (this._events.Count > 0)
{
e = this._events.Dequeue();
}
_queueMutex.ReleaseMutex();
return(e);
}
void Awake()
{
base.Awake();
if (reportEvent == null)
{
reportEvent = new ReportEvent();
}
if (powerStatusEvent == null)
{
powerStatusEvent = new PowerStatusEvent();
}
reportEvent.AddListener(ReportReaction);
powerStatusEvent.AddListener(PowerStatusReaction);
}
/// <summary>
/// Print the order
/// </summary>
/// <param name="actor"></param>
/// <param name="item"></param>
public void UpdatePrintCount(User actor, Order item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
try
{
using (XRMSEntities context = new XRMSEntities())
{
_uow = new UnitOfWork(context, new RepositoryProvider(RepositoryFactories.Instance()));
Order order = _uow.OrderRepository.GetById(item.Id);
if (order.State > OrderState.Printed)
{
// update order
order.PrintCount++;
}
else
{
order.State = OrderState.Printed;
order.PrintCount++;
}
_uow.OrderRepository.Update(order);
// get order report, useful for writing report
ReportOrder report = _uow.ReportOrderRepository.GetByOrderCode(item.Code);
// add event report
ReportEvent reportEvent1 = new ReportEvent();
reportEvent1.ReportCounter = report.ReportCounter;
reportEvent1.EventClass = 0;
reportEvent1.EventDate = _uow.GetDbCurrentDatetime();
reportEvent1.Text = actor.Fullname + " printed order " + item.Code + " for table \"" + item.Table.Name + "\"";
reportEvent1 = _uow.ReportEventRepository.Add(reportEvent1);
// commit
_uow.SaveChanges();
}
}
catch (Exception ex)
{
throw new Exception(this.GetType().FullName + System.Reflection.MethodBase.GetCurrentMethod().Name + ": " + ex.Message);
}
}
public void DoWork()
{
var hours = 8;
for (int i = 0; i <= hours; i++)
{
var eventArgs = new ReportHoursEventArgs
{
Hours = i,
ActionType = ActionType.Working,
Location = new Location("KMW", "Warsaw")
};
ReportEvent?.Invoke(this, eventArgs);
Thread.Sleep(500);
}
ReportCompletedEvent?.Invoke(this, EventArgs.Empty);
}
private static ReportEvent getData()
{
var products = new List <ProductItem>()
{
new ProductItem()
{
Product = "Product1", Region = "Asia", Reports = new List <Report>()
{
new Report()
{
name = "Report1"
}
}
},
new ProductItem()
{
Product = "Product2", Region = "Asia", Reports = new List <Report>()
{
new Report()
{
name = "Report2"
}
}
},
};
var localizedData = new LocalisedData()
{
key = "test", value = "value"
};
var reportEvent = new ReportEvent
{
Heading = "ReportEventHeading",
Subheading = "ReportEventSubHeading",
Products = products,
LocalisedData = localizedData
};
var data = reportEvent;
return(data);
}
public void Deliver(Client client, Journal journal)
{
var existingClient = new Client {
Id = client.Id
};
var existingJournal = new Journal {
Id = journal.Id
};
var existingOrder = (from o in _service._context.Orders
join cl in _service._context.Clients on o.Client.Id equals cl.Id
join j in _service._context.Journals on o.Journal.Id equals j.Id
where cl.TelephoneNumber == existingClient.TelephoneNumber && j.Name == existingJournal.Name && o.IsDelivered == false
select o).First();
; existingOrder.IsDelivered = true;
_service.Update(existingOrder);
_service.Dispose();
ReportEvent.Invoke("Ваша покупка была доставлена! Покупайте еще!");
}
private async void StartThreads(object sender, TickEventArgs e) //async metod som anropas på varje tick
{
if (e.Date.TimeOfDay == TimeSpan.Parse("17:00:00")) //kollar om kl är 17, då är dagen över
{
e.IsPaused = true; //simuleringen pausas
Date = e.Date; //date sätts till datumet simuleringen är på
var checkOutTask = CheckOutHamstersForTheDay(); //skapar en task som skickar hem hamstrarna för dagen
await checkOutTask; //awaitar tasken
PrintEvent?.Invoke(this, new PrintEventArgs(Print(), e.Date)); //invokar ett event som skriver ut vad som hänt detta tick
ReportEvent?.Invoke(this, new ReportEventArgs(HDCon.Hamsters.ToList(), HDCon.ActivityLogs.ToList())); //invokar ett event som genererar och skriver ut rapport för dagen
var logs = HDCon.ActivityLogs;
HDCon.ActivityLogs.RemoveRange(logs); //tömmer logs i databasen
HDCon.SaveChanges(); //sparar ändringar
e.Date = e.Date.AddHours(13.9); //lägger till 13.9h på simuleringen för att starta en ny dag
e.IsPaused = false; //startar simuleringen igen
}
else if (e.Date.Hour >= 7 & e.Date.TimeOfDay <= TimeSpan.Parse("17:00:00")) //om kl är mellan 07.00 och 17.00
{
Date = e.Date; //date sätts till datumet simuleringen är på
if (e.Date.TimeOfDay == TimeSpan.Parse("07:00:00")) //om kl är 07.00
{
var addToCageTask = AddHamstersToCages(); //skapar en task för att checka in hamstrarna för dagen, behöver endast göras en gång per dag
await addToCageTask; //awaitar tasken
}
var retrieveFromExerciseTask = RetreiveHamstersFromExtersiceArea(); //skapar en task som plockar ut hamstrar från träningsområdet
var addToExerciseTask = AddHamstersToExerciseArea(); //skapar en task som lägger till hamstrar till träningsområdet
await retrieveFromExerciseTask; //awaitar tasken
await addToExerciseTask; //awaitar tasken
PrintEvent?.Invoke(this, new PrintEventArgs(Print(), e.Date)); //invokar ett event som skriver ut vad som hänt detta tick
}
}
private void OnReportEvent(SamplesReportEventArgs e)
{
ReportEvent?.Invoke(this, e);
}
public abstract void Report(ReportEvent action, params object[] data);
