static public void AddAccessLog(AccessEvent item)
{
try
{
var existing = GetAllAccessEvents();
foreach (var d in existing)
{
//if(String.IsNullOrEmpty(item.EmployeeFirstName))
//{
// return;
//}
if (d.EmployeeID == 0)
{
continue;
}
if (d.AccessPointID == item.AccessPointID &&
d.AccessPointName == item.AccessPointName &&
d.EmployeeID == item.EmployeeID &&
d.EmployeeFirstName == item.EmployeeFirstName &&
d.EmployeeLastName == item.EmployeeLastName &&
d.EventTime == item.EventTime)
{
return;
}
}
_accessEventsCollection.InsertOne(item);
}
catch (Exception ex)
{
throw ex;
}
}
public virtual async Task <bool> HasPermissionAsync <TEntity>(
AccessEvent <TEntity> @event,
AccessOperation operation)
where TEntity : class
{
var eventType = @event.GetType();
var hasHandler = _eventHandlersDictionary.TryGetValue(eventType, out var handlerType);
if (!hasHandler)
{
await OnHandlerNotFound(@event, operation);
}
//TODO Реализовать хэндлеры через контейнеры
//var handler = _serviceProvider.GetService(handlerType);
var handler = Activator.CreateInstance(handlerType);
if (handler == null)
{
return(await OnHandlerNotFound(@event, operation));
}
var concreteType = typeof(IAccessHandler <,>).MakeGenericType(eventType, typeof(TEntity));
var methodParams = new object[] { @event, operation };
var result = await(Task <bool>) concreteType.GetMethod(HANDLER_METHOD_NAME).Invoke(handler, methodParams);
return(result);
}
public async Task <bool> Add(AccessEvent item)
{
try
{
var filter = Builders <AccessEvent> .Filter.Eq(x => x.ID, item.ID) &
Builders <AccessEvent> .Filter.Eq(x => x.EmployeeID, item.EmployeeID) &
Builders <AccessEvent> .Filter.Eq(x => x.AccessPointIPAddress, item.AccessPointIPAddress) &
Builders <AccessEvent> .Filter.Eq(x => x.AccessPointID, item.AccessPointID);
var task = _context.AccessEvents
.Find(filter)
.FirstOrDefaultAsync();
if (!task.IsCompleted)
{
Thread.Sleep(5);
}
var o = task.Result;
if (o == null)
{
await _context.AccessEvents.InsertOneAsync(item);
return(true);
}
return(false);
}
catch (Exception ex)
{
_logger.Warning("Something went wrong while adding AccessEvent with ID {@ID}.", item.ID);
throw ex;
}
}
protected virtual Task <bool> OnHandlerNotFound <TEntity>(
AccessEvent <TEntity> @event,
AccessOperation operation)
where TEntity : class
{
throw new NullReferenceException($"Не зарегистрирован обработчик для " +
$"для сущности {typeof(TEntity).Name}");
}
/// <summary>
/// Processes the message
/// </summary>
/// <param name="connectionBase">The connection base</param>
/// <param name="message">The playerio message</param>
/// <param name="handled">Whether the message was already handled</param>
public void Process(ConnectionBase connectionBase, Message message, bool handled)
{
WorldConnection worldCon = (WorldConnection)connectionBase;
worldCon.HasAccess = true;
AccessEvent accessEvent = new AccessEvent()
{
Raw = message
};
connectionBase.RaiseServerEvent <AccessEvent>(accessEvent);
}
static async void Add(AccessEvent obj)
{
try
{
var json = JsonConvert.SerializeObject(obj, Formatting.Indented);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
HttpResponseMessage response = await _client.PostAsync("api/AccessEvents", httpContent);
response.EnsureSuccessStatusCode();
}
catch (Exception exp)
{
Console.Write(exp.Message);
}
}
public IActionResult Post([FromBody] AccessEvent value)
{
if (value == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_repository.Add(value).Result)
{
return(StatusCode(500, "A problem while handling your request!"));
}
return(CreatedAtAction("Get", new { id = value.ID }, value));
}
public async Task <bool> Update(int id, AccessEvent item)
{
try
{
item.ID = id; //Make sure ID of the item is assigned.
ReplaceOneResult actionResult = await _context.AccessEvents
.ReplaceOneAsync(n => n.ID.Equals(id)
, item
, new UpdateOptions { IsUpsert = true });
return(actionResult.IsAcknowledged &&
actionResult.ModifiedCount > 0);
}
catch (Exception ex)
{
_logger.Warning("Something went wrong while updating AccessEvent with ID {@ID}.", id);
throw ex;
}
}
/// <summary>
/// Adds an entry to the Access Log.
/// </summary>
public async Task LogAsync(AccessPoint accessPoint, AccessEvent accessEvent, Identity identity, string message)
{
using (var scope = serviceScopeFactory.CreateScope())
{
var dataContext = scope.ServiceProvider.GetService <AccessControlContext>();
var logEntry = new AccessLogEntry()
{
AccessPoint = accessPoint != null ? await dataContext.AccessPoints.FindAsync(accessPoint.Id) : null,
Event = accessEvent,
Timestamp = DateTime.UtcNow,
Identity = identity != null ? await dataContext.Identitiets.FindAsync(identity.Id) : null,
Message = message,
AccessLog = null
};
await dataContext.AccessLogEntries.AddAsync(logEntry);
await dataContext.SaveChangesAsync();
await _accessLogNotifier.NotifyLogAppendedAsync(logEntry);
}
}
public IActionResult Put(int id, [FromBody] AccessEvent value)
{
if (value == null || id < 0)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_repository.Exists(id).Result)
{
return(NotFound());
}
value.ID = id;
if (_repository.Update(id, value).Result)
{
return(StatusCode(202, "Updated Successfully!"));
}
return(NoContent());
}
static public void AddAccessLog(AccessEvent item)
{
try
{
var Utc_EventTime = item.EventTime.ToUniversalTime();
var existingRecord = GetAllAccessEvents()
.Any(x =>
x.EmployeeID == item.EmployeeID &&
x.AccessPointID == item.AccessPointID &&
x.AccessPointName == item.AccessPointName &&
x.EventTime == Utc_EventTime
);
if (!existingRecord)
{
_accessEventsCollection.InsertOne(item);
return;
}
}
catch (Exception ex)
{
throw ex;
}
}
static public void ReadAccessEventLogsForMonth(int month, int year)
{
var tableName = "DeviceLogs_" + month.ToString() + "_" + year.ToString();
if (!TableExists(tableName))
{
return;
}
OleDbCommand command = new OleDbCommand();
command.Connection = _accessDBconnection;
command.CommandText = "select DeviceId,UserId,LogDate,DeviceLogId from " + tableName;
OleDbDataAdapter da = new OleDbDataAdapter(command);
DataTable dt = new DataTable();
da.Fill(dt);
DataColumn UserId = dt.Columns["UserId"];
DataColumn DeviceId = dt.Columns["DeviceId"];
DataColumn LogDate = dt.Columns["LogDate"];
DataColumn DeviceLogId = dt.Columns["DeviceLogId"];
List <AccessEvent> accessEvents = new List <AccessEvent>();
foreach (DataRow row in dt.Rows)
{
AccessEvent d = new AccessEvent();
var useId = int.Parse(row[UserId].ToString());
var employee = AttendanceManager.EmployeeById(useId);
if (employee == null)
{
continue;
}
d.EmployeeID = employee.ID;
d.EmployeeFirstName = employee.FirstName;
d.EmployeeLastName = employee.LastName;
var accessPoint = AttendanceManager.AccessPointById(int.Parse(row[DeviceId].ToString()));
d.AccessPointID = accessPoint.ID;
d.AccessPointName = accessPoint.Name;
d.AccessPointIPAddress = accessPoint.IpAddress;
var dtString = row[LogDate].ToString().Trim();
var tokens = dtString.Split(new char[] { ' ', '-', ':' });
var ye = int.Parse(tokens[2]);
var mo = int.Parse(tokens[1]);
var dy = int.Parse(tokens[0]);
var h = int.Parse(tokens[3]);
var m = int.Parse(tokens[4]);
var s = int.Parse(tokens[5]);
d.EventTime = new DateTime(ye, mo, dy, h, m, s);
var deviceLogId = row[DeviceLogId].ToString();
var y = ye.ToString().Substring(2);
var idStr = d.AccessPointID.ToString() + y + mo.ToString() + deviceLogId;
var logId = int.Parse(idStr);
d.ID = logId;
accessEvents.Add(d);
}
var monthlyLog = new MonthlyAccessLog();
monthlyLog.Month = new DateTime(year, month, 1);
monthlyLog.AccessEvents = accessEvents;
AttendanceManager.MonthlyAccessLogs.Add(monthlyLog);
}
protected override Task <bool> OnHandlerNotFound <TEntity>(
AccessEvent <TEntity> @event,
AccessOperation operation)
{
return(Task.FromResult(operation == AccessOperation.READ));
}
public void Store(AccessEvent eventAcesso)
{
eventAcesso.TimeStamp = DateTime.Now;
_db.AccessEvent.Add(eventAcesso);
_db.SaveChanges();
}
private void On(AccessEvent e)
{
this.CanEdit = true;
}
private void OnAccess(AccessEvent e)
{
this.AccessRight = AccessRight.Edit;
}
public override Task <bool> HasPermissionAsync <TEntity>(AccessEvent <TEntity> @event, AccessOperation operation)
{
return(Task.FromResult(operation == AccessOperation.READ));
}
