public void AddEmployeeTest()
{
//arrange
IDBSettings dBSettings = new DBSettings();
IMemoryCache memoryCache = MemoryCacheHelper.GetMemoryCache();
CacheSettings cacheSettings = new CacheSettings();
EmployeeActivityByDapperRepository employeeActivityProvider = new EmployeeActivityByDapperRepository(dBSettings, memoryCache, cacheSettings);
var tics = DateTime.Now.Ticks;
EmployeeActivity employeeActivity = new EmployeeActivity()
{
FirstName = string.Concat("dapper_", tics),
LastName = string.Concat("LName_", tics),
EmailAddress = string.Concat(tics, "@email.com"),
ActivityName = string.Concat("Activity_Name_", tics),
Comments = string.Concat("Comments_", tics)
};
//act
var result = employeeActivityProvider.AddEmployee(employeeActivity);
//assert
Assert.NotEmpty(dBSettings.ConnectionString);
Assert.NotNull(employeeActivity);
Assert.NotEqual <int>(0, result);
}
public void SaveChangesUnitTest()
{
//arrange
IDBSettings dBSettings = new DBSettings();
IEmployeeActivityDBContext employeeActivityDBContext = new EmployeeActivityDBContext(dBSettings);
var tics = DateTime.Now.Ticks;
EmployeeActivity employeeActivity = new EmployeeActivity()
{
FirstName = string.Concat("FName_", tics),
LastName = string.Concat("LName_", tics),
EmailAddress = string.Concat(tics, "@email.com"),
ActivityName = string.Concat("Activity_Name_", tics),
Comments = string.Concat("Comments_", tics)
};
//act
var employeeActivityDbSet = employeeActivityDBContext.EmployeeActivity;
employeeActivityDbSet.Add(employeeActivity);
employeeActivityDBContext.SaveChanges();
var result = employeeActivityDbSet.Where(x => x.FirstName.Equals(employeeActivity.FirstName)).FirstOrDefault();
//assert
Assert.NotEmpty(dBSettings.ConnectionString);
Assert.NotNull(employeeActivity);
Assert.Equal(result, employeeActivity);
}
public async Task <int> AddEmployee(EmployeeActivity employeeActivity)
{
try
{
if (ReferenceEquals(employeeActivity, null))
{
throw new Exception("employeeActivity is null");
}
await _iEmployeeActivityDBContext.EmployeeActivity.AddAsync(employeeActivity);
_iEmployeeActivityDBContext.SaveChanges();
if (!ReferenceEquals(employeeActivity, null) && employeeActivity.ActivityId > 0)
{
_memmoryCache.Remove(CacheKeysHelper.Entry);
return(employeeActivity.ActivityId);
}
return(0);
}
catch
{
return(0);
}
}
public async void AddEmployeeActivityByFormTest()
{
//arrange
DBSettings dBSettings = new DBSettings();
IMemoryCache memoryCache = MemoryCacheHelper.GetMemoryCache();
CacheSettings cacheSettings = new CacheSettings();
EmployeeActivityByDapperRepository employeeActivityRepository = new EmployeeActivityByDapperRepository(dBSettings, memoryCache, cacheSettings);
EmployeeActivityApiByDapperController employeeActivityController = new EmployeeActivityApiByDapperController(employeeActivityRepository);
var tics = DateTime.Now.Ticks;
EmployeeActivity employeeActivity = new EmployeeActivity()
{
FirstName = string.Concat("FName_", tics),
LastName = string.Concat("LName_", tics),
EmailAddress = string.Concat(tics, "@email.com"),
ActivityName = string.Concat("Activity_Name_", tics),
Comments = string.Concat("Comments_", tics)
};
//act
var result = await employeeActivityController.AddEmployeeActivityByBody(employeeActivity);
//assert
Assert.NotEqual <int>(0, result);
}
public async Task LogChanges(Employee employee)
{
// Managers
var employeeInfo = await GetEmployeeAsync(employee.Id);
if (employeeInfo == null)
{
return;
}
var employeeActivity = new EmployeeActivity();
if (!string.IsNullOrEmpty(employeeInfo.Manager) &&
!string.IsNullOrEmpty(employee.Manager) &&
employeeInfo.Manager != employee.Manager)
{
_employeeDb.EmployeeActivities.Add(new EmployeeActivity
{
ChangeType = Constants.MANAGERS,
Date = DateTime.UtcNow,
EmployeeId = employeeInfo.Id,
NewValue = employee.Manager,
OldValue = employeeInfo.Manager
});
}
// Title
if (!string.IsNullOrEmpty(employeeInfo.Position) &&
!string.IsNullOrEmpty(employee.Position) &&
employeeInfo.Position != employee.Position)
{
_employeeDb.EmployeeActivities.Add(new EmployeeActivity
{
ChangeType = Constants.TITLE,
Date = DateTime.UtcNow,
EmployeeId = employeeInfo.Id,
NewValue = employee.Manager,
OldValue = employeeInfo.Manager
});
}
// Permissions
//if (!ReferenceEquals(employeeInfo.Permissions,null) &&
// !!ReferenceEquals(string.IsNullOrEmpty(employee.Permissions)) &&
// employeeInfo.Permissions != employee.Permissions)
//{
// _employeeDb.EmployeeActivities.Add(new EmployeeActivity
// {
// ChangeType = Constants.PERMISSIONS,
// Date = DateTime.UtcNow,
// EmployeeId = employeeInfo.Id,
// NewValue = employee.Manager,
// OldValue = employeeInfo.Manager
// });
//}
await _employeeDb.SaveChangesAsync();
}
public IActionResult AddActivity(int id, EmployeeActivity employeeActivity)
{
if (ModelState.IsValid)
{
employeeService.AddActivity(id, employeeActivity);
return(Ok());
}
return(BadRequest());
}
public async Task <Result> UpdateAsync(int id, EmployeeRequestModel model)
{
var employee = await GetEmployeeByIdAsync(id);
if (employee == null)
{
return("Ein Fehler ist aufgetreten.");
}
employee.FirstName = model.FirstName;
employee.LastName = model.LastName;
employee.JobTitle = model.JobTitle;
employee.Description = model.Description;
employee.JobTitle = model.JobTitle;
employee.ImageUrl = model.ImageUrl;
employee.VCard.FirstName = model.FirstName;
employee.VCard.LastName = model.LastName;
employee.VCard.JobTitle = model.JobTitle;
employee.VCard.Image = model.VCard.Image;
employee.VCard.Phone = model.VCard.Phone;
employee.VCard.Mobile = model.VCard.Mobile;
employee.VCard.Street = model.VCard.Street;
employee.VCard.PostalCode = model.VCard.PostalCode;
employee.VCard.City = model.VCard.City;
employee.VCard.Country = model.VCard.Country;
employee.VCard.Email = model.VCard.Email;
employee.VCard.HomePage = model.VCard.HomePage;
foreach (var activity in model.Activities)
{
var act = await _dbContext
.EmployeeActivities
.FirstOrDefaultAsync(ea => ea.ActivityId == activity.Id && ea.EmployeeId == employee.Id);
if (act == null)
{
var innerActivity = await _dbContext
.Activities
.FirstOrDefaultAsync(a => a.Id == activity.Id);
var employeeActivity = new EmployeeActivity
{
Activity = innerActivity,
ActivityId = innerActivity.Id,
Employee = employee,
EmployeeId = employee.Id
};
}
}
await _dbContext.SaveChangesAsync();
return(true);
}
public IEnumerable <EmployeeActivity> Get()
{
var array = new EmployeeActivity[0];
var employeeActivities = _employeeActivityProvider.GetEmployeeActivities().ToList();
if (!ReferenceEquals(employeeActivities, null) && employeeActivities.Count > 0)
{
array = new EmployeeActivity[employeeActivities.Count];
employeeActivities.CopyTo(array, 0);
}
return(employeeActivities.ToArray());
}
private EmployeeActivity GetLatestEmployeeActivity()
{
EmployeeActivity lastActivity = EmployeeTimeRegistrationWorkflowHelper.GetLatestActivity(this.Context);
// Gets the details of activity and job names if the activity is break.
if (lastActivity != null && lastActivity.EmployeeActivityType == EmployeeActivityType.BreakFlowStart)
{
lastActivity.BreakCategory = EmployeeTimeRegistrationWorkflowHelper.GetBreakCategoryByJob(this.Context, lastActivity.JobId);
}
return(lastActivity ?? new EmployeeActivity());
}
public void AddActivity(int employeeId, EmployeeActivity employeeActivity)
{
employeeActivity.EmployeeId = employeeActivity.Employee.Id;
employeeActivity.ProjectId = employeeActivity.Project.Id;
var employee = context.Employees.Find(employeeId);
if (employee.EmployeeActivites == null)
{
employee.EmployeeActivites = new List <EmployeeActivity>();
}
employee.EmployeeActivites.Add(employeeActivity);
context.SaveChanges();
}
/// <summary>
/// Gets employee current registration state.
/// </summary>
/// <param name="staffId">Enter the staff identifier.</param>
/// <param name="terminalId">Enter the terminal identifier.</param>
/// <returns>Returns the latest activity performed by employee.</returns>
public EmployeeActivity GetEmployeeCurrentRegistrationState(string staffId, string terminalId)
{
ThrowIf.NullOrWhiteSpace(staffId, "staffId");
ThrowIf.NullOrWhiteSpace(terminalId, "terminalId");
var data = this.InvokeMethod(GetWorkerCurrentTimeRegistrationStateMethodName, staffId, terminalId);
var employeeActivity = new EmployeeActivity();
// Parse response data
DateTime?activityDateTime = Convert.ToDateTime(data[0].ToString());
employeeActivity.ActivityDateTimeOffset = activityDateTime.ToUtcDateTimeOffset();
employeeActivity.EmployeeActivityType = (EmployeeActivityType)data[1];
employeeActivity.Activity = ((EmployeeActivityType)data[1]).ToString();
employeeActivity.JobId = (string)data[2];
return(employeeActivity);
}
public IActionResult AddEmployeeActivity(EmployeeActivityViewModel employeeActivityViewModel)
{
if (ModelState.IsValid)
{
var employeeActivity = new EmployeeActivity()
{
FirstName = employeeActivityViewModel.FirstName,
LastName = employeeActivityViewModel.LastName,
EmailAddress = employeeActivityViewModel.EmailAddress,
ActivityName = employeeActivityViewModel.ActivityName,
Comments = employeeActivityViewModel.Comments
};
_employeeActivityProvider.AddEmployee(employeeActivity);
return(RedirectToAction("InterestedPersonListings"));
}
else
{
return(RedirectToAction("Index"));
}
}
public int AddEmployee(EmployeeActivity employeeActivity)
{
try
{
if (ReferenceEquals(employeeActivity, null))
{
throw new Exception("employeeActivity is null");
}
var connectionString = _dBSettings.ConnectionString;
var sql = "INSERT INTO EmployeeActivity VALUES(@fName, @lname, @email, @aname, @comments);SELECT CAST(SCOPE_IDENTITY() as int) ";
var id = 0;
using (SqlConnection connection = new SqlConnection(connectionString))
{
var result = connection.Query <int>(sql, new { @fName = employeeActivity.FirstName,
@lname = employeeActivity.LastName,
@email = employeeActivity.EmailAddress,
@aname = employeeActivity.ActivityName, @comments = employeeActivity.Comments });
if (result.Any())
{
id = (int)result.Single();
}
}
if (id > 0)
{
_memmoryCache.Remove(CacheKeysHelper.Entry);
}
return(id);
}
catch (Exception ex)
{
return(0);
}
}
/// <summary>
/// Gets the employee activities for the given store and staff.
/// </summary>
/// <param name="staffId">Enter the staff identifier.</param>
/// <param name="storeId">Enter the store identifier.</param>
/// <param name="fromUtcDateTime">Enter the from UTC date/time.</param>
/// <param name="toUtcDateTime">Enter the to UTC date/time.</param>
/// <param name="pagingInfo">Enter the paging information.</param>
/// <param name="sortingInfo">Enter the sorting information.</param>
/// <returns>The paged result of employee activities.</returns>
public PagedResult <EmployeeActivity> GetEmployeeActivityHistory(string staffId, string storeId, DateTimeOffset?fromUtcDateTime, DateTimeOffset?toUtcDateTime, PagingInfo pagingInfo, SortingInfo sortingInfo)
{
ThrowIf.NullOrWhiteSpace(staffId, "staffId");
ThrowIf.NullOrWhiteSpace(storeId, "storeId");
ThrowIf.Null(pagingInfo, "pagingInfo");
ThrowIf.Null(sortingInfo, "sortingInfo");
ValidateDateTimeOffset(fromUtcDateTime);
// Set datetime search parameters (same to EPOS, LogbookForm.cs, with 30 minutes tolerance added)
DateTime convertedFromUtc = fromUtcDateTime.HasValue ?
fromUtcDateTime.Value.UtcDateTime : DateTime.UtcNow.AddDays(1).AddMinutes(-30);
DateTime convertedToUtc = toUtcDateTime.HasValue ?
toUtcDateTime.Value.UtcDateTime : DateTime.UtcNow.AddMinutes(30);
// Retrieve the first sort column
var sortColumn = new SortColumn(EmployeeActivity.DateTimeColumn, true);
using (IEnumerator <SortColumn> enumerator = sortingInfo.GetEnumerator())
{
if (enumerator.MoveNext())
{
sortColumn = enumerator.Current;
}
}
var parameters = new object[]
{
staffId,
storeId,
convertedFromUtc,
convertedToUtc,
pagingInfo.Top,
pagingInfo.Skip,
sortColumn.ColumnName,
(byte)(sortColumn.IsDescending ? SortOrderType.Descending : SortOrderType.Ascending)
};
var data = this.InvokeMethodAllowNullResponse(GetWorkerHistoryMethodName, parameters);
var employeeActivities = new List <EmployeeActivity>();
if (data != null)
{
// Parse response data
foreach (var employeeActivityDataRow in data)
{
var employeeActivityData = (object[])employeeActivityDataRow;
var employeeActivity = new EmployeeActivity();
DateTime?activityDateTime = Convert.ToDateTime(employeeActivityData[3]);
employeeActivity.Activity = (string)employeeActivityData[2];
employeeActivity.ActivityDateTimeOffset = activityDateTime.ToUtcDateTimeOffset();
employeeActivity.StoreNumber = (string)employeeActivityData[4];
employeeActivities.Add(employeeActivity);
}
}
return(new PagedResult <EmployeeActivity>(employeeActivities.AsReadOnly(), pagingInfo));
}
/// <summary>
/// Gets all employee activities for the given store, activity types and date range.
/// </summary>
/// <param name="storeIds">Enter the store numbers.</param>
/// <param name="activityTypes">Enter the activity types.</param>
/// <param name="breakActivities">Enter the break activities.</param>
/// <param name="fromUtcDateTime">Enter the from date/time.</param>
/// <param name="toUtcDateTime">Enter the to date/time.</param>
/// <param name="pagingInfo">Enter the paging information.</param>
/// <param name="sortingInfo">Enter the sorting information.</param>
/// <returns>The paged result of employee activities.</returns>
public PagedResult <EmployeeActivity> GetManagerActivityHistory(string[] storeIds, EmployeeActivityType[] activityTypes, string[] breakActivities, DateTimeOffset?fromUtcDateTime, DateTimeOffset?toUtcDateTime, PagingInfo pagingInfo, SortingInfo sortingInfo)
{
ThrowIf.Null(pagingInfo, "pagingInfo");
ThrowIf.Null(sortingInfo, "sortingInfo");
ValidateDateTimeOffset(fromUtcDateTime);
// Set datetime search parameters (same to EPOS, ViewTimeClockEntriesViewModel.cs)
DateTime convertedFromUtc = fromUtcDateTime.HasValue ?
fromUtcDateTime.Value.UtcDateTime : DateTime.Today.AddDays(-90).ToUniversalTime(); // Previous 90 days
DateTime convertedToUtc = toUtcDateTime.HasValue ?
toUtcDateTime.Value.UtcDateTime : DateTime.Today.AddDays(1).ToUniversalTime(); // To the end of of the current day
// Creates the CSV search parameters
int[] activityTypeList = Array.ConvertAll(activityTypes, value => (int)value);
string storeIdsCsvStr = (storeIds == null) ? string.Empty : string.Join(",", storeIds);
string employeeActivityTypesCsvStr = (activityTypeList == null) ? string.Empty : string.Join(",", activityTypeList);
string breakActivityJobIdsCsvStr = (breakActivities == null) ? string.Empty : string.Join(",", breakActivities);
// Retrieve the first sort column
var sortColumn = new SortColumn(EmployeeActivity.DateTimeColumn, true);
using (IEnumerator <SortColumn> enumerator = sortingInfo.GetEnumerator())
{
if (enumerator.MoveNext())
{
sortColumn = enumerator.Current;
}
}
var parameters = new object[]
{
string.Empty, // Personnel number of the worker.
storeIdsCsvStr,
employeeActivityTypesCsvStr,
convertedFromUtc,
convertedToUtc,
breakActivityJobIdsCsvStr,
pagingInfo.NumberOfRecordsToFetch,
pagingInfo.Skip,
sortColumn.ColumnName,
(byte)(sortColumn.IsDescending ? SortOrderType.Descending : SortOrderType.Ascending)
};
var data = this.InvokeMethodAllowNullResponse(
GetManagerHistoryMethodName,
parameters);
var employeeActivities = new List <EmployeeActivity>();
if (data != null)
{
// Parse response data
foreach (var employeeActivityDataRow in data)
{
var employeeActivityData = (object[])employeeActivityDataRow;
var employeeActivity = new EmployeeActivity();
DateTime?activityDateTime = Convert.ToDateTime(employeeActivityData[3]);
employeeActivity.StaffName = (string)employeeActivityData[0];
employeeActivity.StaffId = (string)employeeActivityData[1];
employeeActivity.ActivityDateTimeOffset = activityDateTime.ToUtcDateTimeOffset();
employeeActivity.Activity = ((EmployeeActivityType)employeeActivityData[5]).ToString();
employeeActivity.StoreNumber = (string)employeeActivityData[6];
employeeActivities.Add(employeeActivity);
}
}
return(new PagedResult <EmployeeActivity>(employeeActivities.AsReadOnly(), pagingInfo));
}
public async Task <int> AddEmployeeActivityByBody([FromBody] EmployeeActivity employeeActivity)
{
return(await _employeeActivityProvider.AddEmployee(employeeActivity));
}
/// <summary>
/// Workflow to process employee time clock activities.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>The response.</returns>
protected override EmployeeTimeRegistrationResponse Process(EmployeeTimeRegistrationRequest request)
{
ThrowIf.Null(request, "request");
EmployeeTimeRegistrationResponse response;
if (request.IsLatestActivity && request.IsSelectStore)
{
throw new DataValidationException(DataValidationErrors.Microsoft_Dynamics_Commerce_Runtime_InvalidRequest, "Both latest activity and selecting from stores is not supported");
}
bool enableTimeRegistration = EmployeeTimeRegistrationWorkflowHelper.ValidateTimeRegistrationFunctionalityProfile(this.Context);
if (!enableTimeRegistration)
{
throw new DataValidationException(
DataValidationErrors.Microsoft_Dynamics_Commerce_Runtime_TimeClockNotEnabled,
string.Format("Time Clock should be enabled before performing employee activities. EmployeeActivityType: {0}", request.EmployeeActivityType));
}
// This flag is set to true if client needs to retrieve the latest activity of the employee.
if (request.IsLatestActivity)
{
EmployeeActivity employeeActivity = this.GetLatestEmployeeActivity();
response = new EmployeeTimeRegistrationResponse(new[] { employeeActivity }.AsPagedResult());
return(response);
}
// The workflow follows any one of the activity chosen from client.
switch (request.EmployeeActivityType)
{
case EmployeeActivityType.ClockIn:
{
var currentActivityDateTimeOffset = this.ProcessClockIn();
response = new EmployeeTimeRegistrationResponse(currentActivityDateTimeOffset);
break;
}
case EmployeeActivityType.ClockOut:
{
var currentActivityDateTimeOffset = this.ProcessClockOut();
response = new EmployeeTimeRegistrationResponse(currentActivityDateTimeOffset);
break;
}
case EmployeeActivityType.BreakFromWork:
{
var currentActivityDateTimeOffset = this.ProcessBreakFlow(EmployeeTimeRegistrationWorkflowHelper.BreakFromWork);
response = new EmployeeTimeRegistrationResponse(currentActivityDateTimeOffset);
break;
}
case EmployeeActivityType.BreakForLunch:
{
var currentActivityDateTimeOffset = this.ProcessBreakFlow(EmployeeTimeRegistrationWorkflowHelper.BreakForLunch);
response = new EmployeeTimeRegistrationResponse(currentActivityDateTimeOffset);
break;
}
case EmployeeActivityType.Logbook:
{
if (request.IsManagerLogbook)
{
EmployeePermissions employeePermisssion = EmployeePermissionHelper.GetEmployeePermissions(this.Context, this.Context.GetPrincipal().UserId);
if (employeePermisssion == null || !employeePermisssion.AllowViewTimeClockEntries)
{
throw new DataValidationException(
DataValidationErrors.Microsoft_Dynamics_Commerce_Runtime_ViewTimeClockNotEnabled,
string.Format("View Time Clock Entries should be enabled to view other employee activities. EmployeeActivityType: {0}", request.EmployeeActivityType));
}
var employeeActivities = this.ProcessManagerLogBook(request.EmployeeActivitySearchCriteria, request.QueryResultSettings.Paging, request.QueryResultSettings.Sorting);
response = new EmployeeTimeRegistrationResponse(employeeActivities.AsPagedResult());
}
else
{
var employeeActivities = this.ProcessEmployeeLogBook(request.EmployeeActivitySearchCriteria, request.QueryResultSettings.Paging, request.QueryResultSettings.Sorting);
response = new EmployeeTimeRegistrationResponse(employeeActivities.AsPagedResult());
}
break;
}
default:
throw new DataValidationException(
DataValidationErrors.Microsoft_Dynamics_Commerce_Runtime_UnSupportedType,
string.Format("Unsupported type for Employee Activity {0}", request.EmployeeActivityType));
}
return(response);
}
public async Task <int> CreateAsync(EmployeeRequestModel model)
{
var vCard = new VCard()
{
FirstName = model.FirstName,
LastName = model.LastName,
JobTitle = model.JobTitle,
Organization = model.VCard.Organization,
Phone = model.VCard.Phone,
Street = model.VCard.Street,
PostalCode = model.VCard.PostalCode,
City = model.VCard.City,
Country = model.VCard.Country,
Email = model.VCard.Email,
HomePage = model.VCard.HomePage,
Mobile = model.VCard.Mobile
};
var employee = new Data.Models.Employee
{
Description = model.Description,
FirstName = model.FirstName,
LastName = model.LastName,
ImageUrl = model.ImageUrl,
JobTitle = model.JobTitle,
VCard = vCard
};
await _dbContext.AddAsync(employee);
await _dbContext.SaveChangesAsync();
foreach (var activity in model.Activities)
{
var act = await _dbContext
.Activities
.FirstOrDefaultAsync(a => a.Id == activity.Id);
var emp = await _dbContext
.Employees
.FirstOrDefaultAsync(e => e.Id == employee.Id);
if (act == null || emp == null)
{
continue;
}
var empAct = new EmployeeActivity
{
Activity = act,
ActivityId = act.Id,
Employee = emp,
EmployeeId = emp.Id
};
await _dbContext.AddAsync(empAct);
}
await _dbContext.SaveChangesAsync();
return(employee.Id);
}
public int AddEmployeeActivityByForm([FromForm] EmployeeActivity employeeActivity)
{
return(_employeeActivityProvider.AddEmployee(employeeActivity));
}
