public static WorkerUser GetWorkerForTheJob(IList <WorkerUser> workerUsers, DateTime appointmentStart, DateTime appointmentEnd)
{
WorkerUser workerForTheJob = new WorkerUser();
foreach (var worker in workerUsers)
{
bool thisWorkerIsFree = true;
var workingTimes = worker.Works.Select(t => new
{
t.StartingTime,
t.EndTime
}).ToList();
foreach (var interval in workingTimes)
{
if (appointmentStart >= interval.StartingTime && appointmentStart < interval.EndTime ||
appointmentEnd > interval.StartingTime && appointmentEnd <= interval.EndTime)
{
thisWorkerIsFree = false;
}
}
if (thisWorkerIsFree)
{
workerForTheJob = worker;
break;
}
else
{
return(null);
}
}
return(workerForTheJob);
}
public async Task WorkAsync(string workType)
{
// Get the user.
WorkerUser workerUser = userManager.GetUserFromID(Context.User.Id);
// Handle the type.
switch (workType.ToLower())
{
case "start":
await workerUser.StartWorkingAsync(Context.Channel);
break;
case "stop":
await workerUser.StopWorkingAsync(Context.Channel);
// Save the user data.
userManager.Save();
break;
case "total":
TimeSpan totalWorkTime = workerUser.CalculateTotalTimeWorked();
await ReplyAsync($"You have worked a total of {totalWorkTime.Days} days, {totalWorkTime.Hours} hours, and {totalWorkTime.Minutes} minutes.");
break;
default:
await ReplyAsync("Parameter not recoginised, try \"start\" or \"stop\".");
return;
}
}
public IEnumerable <RequestObjectISDTO> GetListAllowableObjectIS(long userId, long employeeId, string name = null)
{
WorkerUser user = workerUserRepository.Get(userId);
Expression <Func <RequestObject, bool> > accessPredicate = accessWorkerUserExpressionService
.GetAccessRequestObjectPredicate(accessWorkerUserRepository.GetList(a => a.User.Id == userId));
var list = queryHandler
.Handle <AllowableObjectISQueryParam, IEnumerable <RequestObjectISDTO>, IQuery <AllowableObjectISQueryParam, IEnumerable <RequestObjectISDTO> > >
(new AllowableObjectISQueryParam
{
EmployeeId = employeeId,
Name = name,
AccessPredicate = accessPredicate
}, _allowableObjectISQuery);
var listEmployeeObjectIds = queryHandler
.Handle <EmployeeObjectQueryParam, IEnumerable <EmployeeObjectDTO>, IQuery <EmployeeObjectQueryParam, IEnumerable <EmployeeObjectDTO> > >
(new EmployeeObjectQueryParam
{
EmployeeId = employeeId
}, _employeeObjectQuery)
.Select(t => t.ObjectId);
return(list.Where(t => !listEmployeeObjectIds.Contains(t.Id)));
}
public void Create(string email, string password)
{
WorkerUserDTO existsUser = getUserDTO(u => u.Email.ToUpper() == email.ToUpper());
if (existsUser != null)
{
setErrorMsg("Email", Resource.UniqueEmailConstraintMsg);
}
if (!FormatConfirm.IsEmail(email))
{
setErrorMsg("Email", Resource.EmailConstraintMsg);
}
checkStringConstraint("Password", password, true, 100, 5);
if (errorMessages.Count > 0)
{
throw new DataServiceException(Resource.GeneralConstraintMsg, errorMessages);
}
WorkerUser user = new WorkerUser()
{
Email = email,
Password = password
};
userRepository.Save(user);
repository.SaveChanges();
}
public IEnumerable <EmployeeDTO> GetListByOrganization(IEnumerable <long> organizationIds, long?workerUserId = null)
{
if (workerUserId.HasValue)
{
WorkerUser workerUser = workerUserRepository.Get(workerUserId.Value);
if (workerUser.Worker != null)
{
if (!organizationObjectTypeWorkerRepository.GetList()
.Any(t => organizationIds.Contains(t.Organization.Id) && t.Worker.Id == workerUser.Worker.Id))
{
return(null);
}
}
}
return(employeeRepository
.GetList(e => organizationIds.Contains(e.Organization.Id))
.Select(e => new EmployeeDTO()
{
Id = e.Id,
FM = e.FM,
IM = e.IM,
OT = e.OT,
Cabinet = e.Cabinet,
Phone = e.Phone,
PostName = e.Post != null ? e.Post.Name : null,
OrganizationId = e.Organization.Id,
OrganizationName = e.Organization.Name,
OrganizationAddress = e.Organization.Address
})
.ToList());
}
public async Task <IActionResult> OnPostAsync()
{
WorkerUser workerUser = await UserLogic.GetWorkerUserAsync(User);
Works = await WorkSheetLogic.GetRemainingWorksByWorkerIdAsync(workerUser.Id);
NextWork = WorkSheetLogic.GetNextWork(Works);
Message.SenderId = workerUser.Id;
Message.WorkId = NextWork.Id;
Message.Time = DateTime.Now;
await WorkLogic.SaveMessageAsync(Message);
string emailMessage = $"Tisztelt {NextWork.Service.Car.ClientUser.Name}!<br /><br />" +
$"Tájékoztatjuk, hogy {NextWork.SubTask.Name} ({NextWork.Service.Car.Brand} {NextWork.Service.Car.Model}) " +
$"feladathoz, új üzenet érkezett rendszerünkben {Message.Time} időpontban!<br /><br />" +
$"Üzenet szövege a következő<br />\"{Message.Text}\"<br /><br />" +
$"Válaszolni a rendszerünkben tud, a feladathoz tartozó üzeneteknél!" +
$"Kérjük, hogy erre az e-mailre ne válaszoljon!<br /><br /><br />" +
$"Üdvözlettel:<br />{NextWork.SubTask.CompanyUser.Name}";
await _emailLogic.SendNotificationAsync(NextWork, emailMessage);
return(Page());
}
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Result is Exception)
{
if (((Exception)e.Result).Message == "Пустая стока")
{
MessageBox.Show(((Exception)e.Result).Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
if (WorkerUser.IsBusy)
{
MessageBox.Show("Поиск слова в словаре!");
}
else
{
WorkerUser.RunWorkerAsync();
}
}
else
{
if (!creatingWords.Items.Contains(e.Result))
{
creatingWords.Items.Add(e.Result);
clearUserWord();
}
else
{
MessageBox.Show("Слово уже добавлено!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
}
public IEnumerable <OrganizationDTO> GetListByWorkerUser(long userId)
{
WorkerUser user = workerUserRepository.Get(userId);
long workerId = 0;
if (user.Worker != null)
{
workerId = user.Worker.Id;
}
IEnumerable <long> ids = organizationObjectTypeWorkerRepository
.GetList(t => workerId == 0 || t.Worker.Id == workerId)
.Select(t => t.Organization.Id)
.Distinct()
.ToList();
IEnumerable <OrganizationDTO> list = organizationRepository.GetList()
.Select(t => new OrganizationDTO()
{
Id = t.Id,
Name = t.Name,
Address = t.Address,
ParentId = t.ParentId,
HasChild = t.HasChild
})
.OrderBy(p => p.Name).ToList();
IEnumerable <OrganizationDTO> list2 = list;
list = list.Where(t => inOrganizationObjectTypeWorker(t, list2, ids)).ToList();
return(list);
}
public async Task OnGetAsync()
{
WorkerUser workerUser = await UserLogic.GetWorkerUserAsync(User);
Works = await WorkSheetLogic.GetRemainingWorksByWorkerIdAsync(workerUser.Id);
NextWork = WorkSheetLogic.GetNextWork(Works);
}
public void ChangeSubscribe(long userId)
{
WorkerUser user = userRepository.Get(userId);
user.Subscribe = !user.Subscribe;
userRepository.Save(user);
repository.SaveChanges();
}
public void SetOneSignalUserId(long userId, string oneSignalUserId)
{
WorkerUser user = userRepository.Get(userId);
user.OneSignalUserId = oneSignalUserId;
userRepository.Save(user);
repository.SaveChanges();
}
public async Task OnGetAsync()
{
var userId = User.Claims.Single(c => c.Type == UserHelper.NameIdentifierString).Value;
WorkerUser workerUser = await _context.WorkerUsers.FirstOrDefaultAsync(u => u.Id == userId);
SubTasks = await _context.SubTasks
.Where(u => u.CompanyUserId == workerUser.CompanyUserId)
.ToListAsync();
}
public IHttpActionResult Get()
{
return(execute(delegate()
{
long userId = User.Identity.GetUserId <long>();
WorkerUser user = userService.Get(userId);
result = Json(new { success = true, data = user });
}));
}
public void Save(WorkerUserDTO dto)
{
if (dto.Id == 1)
{
throw new DataServiceException(Resource.SuperUserUpdateMsg);
}
checkStringConstraint("Name", dto.Name, true, 100, 5);
checkStringConstraint("Email", dto.Email, true, 100, 5);
checkStringConstraint("Password", dto.Password, true, 100, 5);
if (!String.IsNullOrWhiteSpace(dto.Email))
{
WorkerUserDTO existsUser = getUserDTO(u => u.Email.ToUpper() == dto.Email.ToUpper() && u.Id != dto.Id);
if (existsUser != null)
{
setErrorMsg("Email", Resource.UniqueEmailConstraintMsg);
}
if (!FormatConfirm.IsEmail(dto.Email))
{
setErrorMsg("Email", Resource.EmailConstraintMsg);
}
}
if (dto.UserType == null || dto.UserType.Id == 0)
{
setErrorMsg("UserType", Resource.EmptyConstraintMsg);
}
if (errorMessages.Count > 0)
{
throw new DataServiceException(Resource.GeneralConstraintMsg, errorMessages);
}
WorkerUser user = null;
if (dto.Id == 0)
{
user = new WorkerUser();
}
else
{
user = userRepository.Get(dto.Id);
}
user.Email = dto.Email;
user.Password = dto.Password;
user.Name = dto.Name;
user.UserType = typeWorkerUserRepository.Get(dto.UserType.Id);
user.Disabled = dto.Disabled;
userRepository.Save(user);
repository.SaveChanges();
}
public bool GetExistsByWorkerUser(long userId)
{
WorkerUser user = workerUserRepository.Get(userId);
if (user.Worker == null)
{
return(true);
}
return(organizationObjectTypeWorkerRepository
.GetList().Any(t => t.Worker.Id == user.Worker.Id));
}
public async Task AddUserToWorkerAsync(int workerId, string userId)
{
var workerUser = new WorkerUser
{
WorkerId = workerId,
IdentityUserId = userId
};
await WorkerUsers.AddAsync(workerUser);
await SaveChangesAsync();
}
/// <summary>
/// Заявки Исполнителя/Диспетчера
/// </summary>
public IEnumerable <RequestDTO> GetList(long userId, RequestFilter filter, OrderInfo orderInfo, PageInfo pageInfo)
{
Expression <Func <BaseRequest, bool> > accessPredicate = accessWorkerUserExpressionService
.GetAccessRequestPredicate(accessWorkerUserRepository.GetList(a => a.User.Id == userId));
IEnumerable <RequestDTO> list = getList(
delegate(PageInfo _pageInfo)
{
return(queryHandler.Handle <RequestQueryParam, IEnumerable <RequestDTO>, IRequestQuery <Request> >
(new RequestQueryParam
{
AccessPredicate = accessPredicate,
Filter = filter,
OrderInfo = orderInfo,
PageInfo = _pageInfo
}, _requestQuery));
},
delegate(PageInfo _pageInfo)
{
return(queryHandler.Handle <RequestQueryParam, IEnumerable <RequestDTO>, IRequestQuery <RequestArch> >
(new RequestQueryParam
{
AccessPredicate = accessPredicate,
Filter = filter,
OrderInfo = orderInfo,
PageInfo = _pageInfo
}, _requestArchQuery));
},
filter, orderInfo, pageInfo);
if (filter.Archive)
{
return(list);
}
#region AllowableStates
WorkerUser user = workerUserRepository.Get(userId);
IEnumerable <long> allowableUserStates = user.UserType.AllowableStates.ToEnumerable <long>();
IDictionary <long, IEnumerable <StatusRequest> > graphState = getGraphState(allowableUserStates);
foreach (RequestDTO r in list)
{
if (graphState.ContainsKey(r.Status.Id))
{
r.AllowableStates = graphState[r.Status.Id];
}
}
#endregion AllowableStates
return(list);
}
public IEnumerable <SimpleDTO> GetListAllowableObjectType(long userId, long employeeId)
{
WorkerUser user = workerUserRepository.Get(userId);
Expression <Func <OrganizationObjectTypeWorker, bool> > accessPredicate = accessWorkerUserExpressionService
.GetAccessOrganizationObjectTypeWorkerPredicate(accessWorkerUserRepository.GetList(a => a.User.Id == userId));
var list = queryHandler
.Handle <AllowableObjectTypeQueryParam, IEnumerable <SimpleDTO>, IQuery <AllowableObjectTypeQueryParam, IEnumerable <SimpleDTO> > >
(new AllowableObjectTypeQueryParam
{
EmployeeId = employeeId,
AccessPredicate = accessPredicate
}, _allowableObjectTypeQuery);
return(list);
}
public async Task<IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return Page();
}
WorkerUser workerUser = await UserLogic.GetWorkerUserAsync(User);
Work = await WorkSheetLogic.GetWorkByIdAsync(Work.Id);
Work.Price = Price;
Work.StateId = 1;
await WorkSheetLogic.ModifyWorkAsync(Work);
await _emailLogic.SendStatusChangeEmailAsync(workerUser, Work);
return RedirectToPage("./WorkSheets");
}
public async Task <IActionResult> OnPostBindAccountAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
var isAuthorized = User.IsInRole(Constants.AdministratorRole);
if (!isAuthorized)
{
return(new ChallengeResult());
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound());
}
var workerUser = await _context.WorkerUsers
.FirstOrDefaultAsync(x => x.IdentityUserId == user.Id);
if (workerUser != null)
{
_context.Remove(workerUser);
}
workerUser = new WorkerUser
{
IdentityUserId = user.Id,
WorkerId = id.Value,
};
await _context.WorkerUsers.AddAsync(workerUser);
await _context.SaveChangesAsync();
return(RedirectToPage());
}
private WorkerUserDTO getUserDTO(Expression <Func <WorkerUser, bool> > predicate)
{
WorkerUser user = userRepository.Get(predicate);
if (user == null)
{
return(null);
}
WorkerUserDTO dto = new WorkerUserDTO()
{
Email = user.Email,
Password = user.Password,
Id = user.Id,
Name = user.Name,
Worker = user.Worker,
UserType = user.UserType
};
return(dto);
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
WorkerUser workerUser = await UserLogic.GetWorkerUserAsync(User);
Service = await CompanyLogic.GetServiceByIdAsync(Service.Id);
foreach (var work in Service.Works)
{
work.StateId = 6;
await WorkSheetLogic.ModifyWorkAsync(work);
}
await _emailLogic.SendStatusChangeEmailAsync(Service);
return(RedirectToPage("./Index"));
}
/// <summary>
/// Количество заявок в состоянии, для которого требуется реакция Исполнителя/Диспетчера
/// </summary>
public int GetCountRequiresReaction(long userId)
{
int c = 0;
WorkerUser user = workerUserRepository.Get(userId);
Expression <Func <BaseRequest, bool> > accessPredicate = null;
switch (user.UserType.TypeCode)
{
case TypeWorkerUserEnum.Worker:
c = requestRepository.Count(t => t.Worker.Id == user.Worker.Id &&
(t.Status.Id == (long)RawStatusRequestEnum.New ||
t.Status.Id == (long)RawStatusRequestEnum.NotApprovedComplete));
break;
case TypeWorkerUserEnum.Dispatcher:
accessPredicate = accessWorkerUserExpressionService
.GetAccessRequestPredicate(accessWorkerUserRepository.GetList(a => a.User.Id == userId));
c = requestRepository.GetList()
.Where(accessPredicate)
.Count(t => (t.Status.Id == (long)RawStatusRequestEnum.Closing ||
t.Status.Id == (long)RawStatusRequestEnum.Rejected ||
t.Status.Id == (long)RawStatusRequestEnum.RejectedAfterAccepted));
break;
case TypeWorkerUserEnum.WorkerAndDispatcher:
accessPredicate = accessWorkerUserExpressionService
.GetAccessRequestPredicate(accessWorkerUserRepository.GetList(a => a.User.Id == userId));
c = requestRepository.GetList()
.Where(accessPredicate)
.Count(t => (t.Status.Id == (long)RawStatusRequestEnum.Closing ||
t.Status.Id == (long)RawStatusRequestEnum.Rejected ||
t.Status.Id == (long)RawStatusRequestEnum.RejectedAfterAccepted ||
t.Status.Id == (long)RawStatusRequestEnum.New ||
t.Status.Id == (long)RawStatusRequestEnum.NotApprovedComplete));
break;
}
return(c);
}
public async Task SendStatusChangeEmailAsync(WorkerUser workerUser, Work work)
{
var email = work.Service.Car.ClientUser.Email;
var clientName = work.Service.Car.ClientUser.Name;
var car = work.Service.Car.Brand + " " + work.Service.Car.Model + " " + work.Service.Car.YearOfManufacture;
var workDeatils = work.SubTask.Name + " (" + work.Price + " Ft)";
var state = work.State.NameHungarian;
var subject = "Állapotváltozás - noreply";
string message;
if (work.StateId == 1)
{
message = ($"Tisztelt {clientName}!<br /><br />{car} autójához " +
$"tartozó {workDeatils} munka állapota megváltozott!<br /><br />Új állapot: {state}" +
$"<br /><br /><br />Ez azt jelenti, hogy önnek be kell lépnie felületünkre és elfogadni valamilyen módosítást, " +
$"amely legtöbbször a munka árára vonatkozik. Erről pontosabb tájékoztatás a felületen a " +
$"munkához tartozó üzenetek között talál.<br /><br />" +
$"Üdvözlettel,<br />{work.SubTask.Name}");
}
else if (work.StateId == 2)
{
message = ($"Tisztelt {clientName}!<br /><br />{car} autójához " +
$"tartozó {workDeatils} munkát rögzítettük!<br /><br />Állapot: {state}.<br /><br />" +
$"Üdvözlettel,<br />{work.SubTask.Name}");
}
else
{
message = ($"Tisztelt {clientName}!<br /><br />{car} autójához " +
$"tartozó {workDeatils} munka állapota megváltozott!<br /><br />Új állapot: {state}.<br /><br />" +
$"Üdvözlettel,<br />{work.SubTask.Name}");
}
await _emailSender.SendEmailAsync(email, subject, message);
}
public static async Task <Work> MakeAppointmentAsync(DateTime appointment, int carId, SubTask subTask, string description)
{
subTask = await ApplicationEntityManager.GetSubTaskByIdAsync(subTask.Id);
IList <WorkerUser> workerUsers = await ApplicationEntityManager.GetWorkerUsersByCompanyIdAsync(subTask.CompanyUserId);
workerUsers.Shuffle();
WorkerUser workerForTheJob = WorkerHandler.GetWorkerForTheJob(workerUsers, appointment, appointment.AddMinutes(subTask.EstimtedTime));
int?openServiceId = await ServiceExistsAsync(carId);
Car car = await ApplicationEntityManager.GetCarByIdAsync(carId);
Service service;
if (!openServiceId.HasValue)
{
service = new Service
{
StartingTime = appointment,
EndTime = appointment.AddMinutes(subTask.EstimtedTime),
TotalPrice = subTask.EstimatedPrice,
CarId = carId
};
await ApplicationEntityManager.SaveServiceAsync(service);
}
else
{
service = await ApplicationEntityManager.GetServcieByIdAsync(openServiceId.Value);
if (service.Works.ElementAt(0).SubTask.CompanyUserId == subTask.CompanyUserId)
{
service.TotalPrice = 0;
foreach (var w in service.Works)
{
service.TotalPrice += w.Price;
}
service.TotalPrice += subTask.EstimatedPrice;
if (appointment < service.StartingTime)
{
service.StartingTime = appointment;
}
if (appointment.AddMinutes(subTask.EstimtedTime) > service.EndTime)
{
service.EndTime = appointment.AddMinutes(subTask.EstimtedTime);
}
ApplicationEntityManager.ModifyService(service);
}
else
{
service = new Service
{
StartingTime = appointment,
EndTime = appointment.AddMinutes(subTask.EstimtedTime),
TotalPrice = subTask.EstimatedPrice,
CarId = carId
};
await ApplicationEntityManager.SaveServiceAsync(service);
}
}
Work work = new Work
{
StartingTime = appointment,
EndTime = appointment.AddMinutes(subTask.EstimtedTime),
Price = subTask.EstimatedPrice,
SubTaskId = subTask.Id,
ServiceId = service.Id,
StateId = 2,
WorkerUserId = workerForTheJob.Id
};
await ApplicationEntityManager.SaveWorkAsync(work);
Message message = new Message
{
SenderId = car.ClientUserId,
Text = description,
WorkId = work.Id,
Time = DateTime.Now
};
await ApplicationEntityManager.SaveMessageAsync(message);
return(work);
}
public long Save(RequestParameter dto)
{
Settings settings = settingsService.Get();
if (dto.Id == 0)
{
DateTime currentDate = dateTimeService.GetCurrent();
IList <Request> list = requestRepository.GetList(t => t.DateInsert.Date == currentDate.Date &&
t.Employee.Id == dto.EmployeeId && t.User == null)
.OrderByDescending(t => t.Id)
.ToList();
if (list != null && list.Any())
{
if (list[0].DateInsert.AddMinutes(Convert.ToDouble(settings.MinInterval)) > currentDate)
{
throw new DataServiceException(String.Format(Resource.MinIntervalRequestConstraintMsg, settings.MinInterval.ToString("0.00")));
}
if (list.Count > settings.LimitRequestCount)
{
throw new DataServiceException(String.Format(Resource.LimitRequestCountConstraintMsg, settings.LimitRequestCount));
}
}
}
checkStringConstraint("DescriptionProblem", dto.DescriptionProblem, true, 2000, 3);
if (dto.ObjectId == 0)
{
setErrorMsg("ObjectId", Resource.RequiredConstraintMsg);
}
if (dto.EmployeeId == 0)
{
setErrorMsg("EmployeeId", Resource.RequiredConstraintMsg);
}
Employee employee = employeeRepository.Get(dto.EmployeeId);
RequestObject requestObject = objectRepository.Get(dto.ObjectId);
OrganizationObjectTypeWorker organizationObjectTypeWorker
= organizationObjectTypeWorkerRepository.Get(t => t.Organization.Id == employee.Organization.Id && t.ObjectType.Id == requestObject.ObjectType.Id);
if (organizationObjectTypeWorker == null)
{
setErrorMsg("Worker", Resource.WorkerNotDefinedConstraintMsg);
}
if (errorMessages.Count > 0)
{
throw new DataServiceException(Resource.GeneralConstraintMsg, errorMessages);
}
Request r = null;
WorkerUser user = null;
if (dto.UserId > 0)
{
user = workerUserRepository.Get(dto.UserId);
}
DateTime currentDateTime = dateTimeService.GetCurrent();
if (dto.Id > 0)
{
requestConstraintsService.CheckExistsRequest(dto.Id);
r = requestRepository.Get(dto.Id);
if (r.Version > dto.Version)
{
throw new DataServiceException(Resource.ConcurrencyConstraintMsg);
}
r.DateUpdate = currentDateTime;
r.DescriptionProblem = dto.DescriptionProblem;
r.User = user;
requestRepository.Save(r);
requestFileRepository.Update(new { RequestId = dto.Id }, f => f.TempRequestKey == dto.TempRequestKey);
repository.SaveChanges();
return(dto.Id);
}
StatusRequest newStatusRequest = statusRepository.Get((long)RawStatusRequestEnum.New);
r = new Request()
{
CountCorrectionDateEndPlan = 0,
DateEndPlan = dateTimeService.GetRequestDateEnd(currentDateTime, requestObject.ObjectType.CountHour),
DateInsert = currentDateTime,
DateUpdate = currentDateTime,
DescriptionProblem = dto.DescriptionProblem,
Worker = workerRepository.Get(organizationObjectTypeWorker.Worker.Id),
Object = requestObject,
Employee = employee,
Status = newStatusRequest,
User = user
};
requestRepository.Save(r);
RequestEvent newEvent = new RequestEvent()
{
StatusRequest = newStatusRequest,
DateEvent = currentDateTime,
DateInsert = currentDateTime,
RequestId = r.Id,
User = user
};
requestEventRepository.Save(newEvent);
RequestEvent dateEndRequestEvent = new RequestEvent()
{
StatusRequest = statusRepository.Get((long)RawStatusRequestEnum.DateEnd),
DateEvent = r.DateEndPlan,
DateInsert = currentDateTime,
RequestId = r.Id,
User = user
};
requestEventRepository.Save(dateEndRequestEvent);
#region DescriptionProblem
DescriptionProblem descriptionProblem = null;
if (r.Object.ObjectType.Soft)
{
descriptionProblem = descriptionProblemRepository.Get(t => t.Name.ToUpper() == r.DescriptionProblem.ToUpper() &&
t.RequestObject.Id == r.Object.Id);
if (descriptionProblem == null)
{
descriptionProblem = new DescriptionProblem()
{
Name = r.DescriptionProblem,
RequestObject = r.Object
};
descriptionProblemRepository.Save(descriptionProblem);
}
}
else
{
descriptionProblem = descriptionProblemRepository.Get(t => t.Name.ToUpper() == r.DescriptionProblem.ToUpper() &&
t.HardType.Id == r.Object.HardType.Id);
if (descriptionProblem == null)
{
descriptionProblem = new DescriptionProblem()
{
Name = r.DescriptionProblem,
HardType = r.Object.HardType
};
descriptionProblemRepository.Save(descriptionProblem);
}
}
#endregion DescriptionProblem
requestFileRepository.Update(new { RequestId = r.Id }, f => f.TempRequestKey == dto.TempRequestKey);
repository.SaveChanges();
queue.Push(new RequestAppEvent()
{
RequestEventId = newEvent.Id, Archive = false
});
return(r.Id);
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
User user;
string role;
if (Input.UserType == UserType.COMPANY)
{
Opening opening = new Opening
{
Monday = new OpeningDay(Input.StartMonday, Input.EndMonday),
Tuesday = new OpeningDay(Input.StartTuesday, Input.EndTuesday),
Wednesday = new OpeningDay(Input.StartWednesday, Input.EndWednesday),
Thursday = new OpeningDay(Input.StartThursday, Input.EndThursday),
Friday = new OpeningDay(Input.StartFriday, Input.EndFriday),
Saturday = new OpeningDay(Input.StartSaturday, Input.EndSaturday),
Sunday = new OpeningDay(Input.StartSunday, Input.EndSunday),
SaturdayOpen = Input.SaturdayOpen,
SundayOpen = Input.SundayOpen
};
await _context.Openings.AddAsync(opening);
await _context.SaveChangesAsync();
int openingId = opening.Id;
user = new CompanyUser
{
UserName = Input.Email,
Email = Input.Email,
Name = Input.Name,
PhoneNumber = Input.PhoneNumber,
Address = new Address
{
Zip = int.Parse(Input.Zip),
City = Input.City,
Street = Input.Street,
HouseNumber = int.Parse(Input.HouseNumber)
},
PrivateKey = Input.PrivateKey,
SecurityStamp = Guid.NewGuid().ToString(),
Opening = opening
};
role = Roles.Companies;
}
else if (Input.UserType == UserType.WORKER)
{
var company = await _context.CompanyUsers
.Where(c => c.PrivateKey == Input.PrivateKey).ToListAsync();
CompanyUser attachedCompany = company.FirstOrDefault();
user = new WorkerUser
{
UserName = Input.Email,
Email = Input.Email,
Name = Input.Name,
PhoneNumber = Input.PhoneNumber,
CompanyUserId = attachedCompany.Id,
Address = new Address {
},
SecurityStamp = Guid.NewGuid().ToString()
};
role = Roles.Workers;
}
else if (Input.UserType == UserType.CLIENT)
{
var company = await _context.CompanyUsers
.Where(c => c.PrivateKey == Input.PrivateKey).ToListAsync();
user = new ClientUser
{
UserName = Input.Email,
Email = Input.Email,
Name = Input.Name,
PhoneNumber = Input.PhoneNumber,
Address = new Address
{
Zip = int.Parse(Input.Zip),
City = Input.City,
Street = Input.Street,
HouseNumber = int.Parse(Input.HouseNumber)
},
SecurityStamp = Guid.NewGuid().ToString()
};
role = Roles.Clients;
}
else //Never happen
{
user = new CompanyUser();
role = "";
}
var userResult = await _userManager.CreateAsync(user, Input.Password);
var roleResult = await _userManager.AddToRoleAsync(user, role);
if (userResult.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
foreach (var error in userResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public void CreateRequestEvent(long userId, RequestEventParameter dto)
{
DateTime currentDate = dateTimeService.GetCurrent();
Request request = requestRepository.Get(dto.RequestId);
if (request.Version > dto.RequestVersion)
{
throw new DataServiceException(Resource.ConcurrencyConstraintMsg);
}
if (dto.StatusRequestId == (long)RawStatusRequestEnum.ExtendedDeadLine && !dto.NewDeadLineDate.HasValue)
{
setErrorMsg("NewDeadLineDate", Resource.EmptyConstraintMsg);
}
if (dto.NewDeadLineDate.HasValue && dto.NewDeadLineDate.Value.Date <= currentDate.Date)
{
setErrorMsg("NewDeadLineDate", String.Format(Resource.NewDeadLineDateConstraintMsg,
dto.NewDeadLineDate.Value.Date.ToShortDateString(), request.DateEndPlan.Date.ToShortDateString()));
}
checkStringConstraint("Note", dto.Note,
(dto.StatusRequestId == (long)RawStatusRequestEnum.Rejected ||
dto.StatusRequestId == (long)RawStatusRequestEnum.RejectedAfterAccepted ||
dto.StatusRequestId == (long)RawStatusRequestEnum.NotApprovedComplete),
2000, 5);
if (errorMessages.Count > 0)
{
throw new DataServiceException(Resource.GeneralConstraintMsg, errorMessages);
}
WorkerUser user = workerUserRepository.Get(userId);
IEnumerable <long> allowableUserStates = user.UserType.AllowableStates.ToEnumerable <long>();
IDictionary <long, IEnumerable <StatusRequest> > graphState = getGraphState(allowableUserStates);
StatusRequest statusRequest = statusRepository.Get(dto.StatusRequestId);
var lastEvent = queryHandler.Handle <RequestLastEventQueryParam, IEnumerable <RequestEventDTO>, IQuery <RequestLastEventQueryParam, IEnumerable <RequestEventDTO> > >
(new RequestLastEventQueryParam
{
RequestIds = new long[] { dto.RequestId },
WithDateEnd = false
}, _requestLastEventQuery).FirstOrDefault();
RequestEvent newEvent = new RequestEvent()
{
RequestId = request.Id,
DateInsert = currentDate,
DateEvent = currentDate,
OrdGroup = lastEvent.OrdGroup,
User = user,
StatusRequest = statusRequest,
Note = dto.Note
};
requestEventRepository.Save(newEvent);
RequestEvent dateEndEvent = null;
if (dto.StatusRequestId == (long)RawStatusRequestEnum.ExtendedDeadLine)
{
StatusRequest dateEndStatusRequest = statusRepository.Get((long)RawStatusRequestEnum.DateEnd);
dateEndEvent = new RequestEvent()
{
RequestId = request.Id,
DateInsert = currentDate,
DateEvent = dto.NewDeadLineDate.Value,
OrdGroup = lastEvent.OrdGroup + 1,
User = user,
StatusRequest = dateEndStatusRequest
};
request.CountCorrectionDateEndPlan++;
request.DateEndPlan = dto.NewDeadLineDate.Value;
requestEventRepository.Save(dateEndEvent);
}
else if (dto.StatusRequestId == (long)RawStatusRequestEnum.ExtendedConfirmation)
{
StatusRequest dateEndStatusRequest = statusRepository.Get((long)RawStatusRequestEnum.DateEnd);
dateEndEvent = new RequestEvent()
{
RequestId = request.Id,
DateInsert = currentDate,
DateEvent = request.DateEndPlan.AddDays(1),
OrdGroup = lastEvent.OrdGroup + 1,
User = user,
StatusRequest = dateEndStatusRequest
};
request.DateEndPlan = dateEndEvent.DateEvent;
requestEventRepository.Save(dateEndEvent);
}
request.User = user;
request.DateUpdate = currentDate;
request.Status = statusRequest;
requestRepository.Save(request);
bool transferRequestToArchive = dto.StatusRequestId == (long)RawStatusRequestEnum.ApprovedComplete ||
dto.StatusRequestId == (long)RawStatusRequestEnum.ApprovedRejected ||
dto.StatusRequestId == (long)RawStatusRequestEnum.Passive;
//перенос заявки в архив
if (transferRequestToArchive)
{
var requestArch = new RequestArch
{
CountCorrectionDateEndPlan = request.CountCorrectionDateEndPlan,
DateEndFact = currentDate,
DateEndPlan = request.DateEndPlan,
DateInsert = request.DateInsert,
DateUpdate = request.DateUpdate,
DescriptionProblem = request.DescriptionProblem,
Employee = request.Employee,
Object = request.Object,
Status = request.Status,
Worker = request.Worker,
Version = request.Version,
User = request.User,
Id = request.Id
};
requestArchRepository.Insert(requestArch, requestArch.Id);
var requestEvents = requestEventRepository.GetList(r => r.RequestId == request.Id).ToList();
foreach (var evnt in requestEvents)
{
var evntArch = new RequestEventArch
{
DateEvent = evnt.DateEvent,
DateInsert = evnt.DateInsert,
Note = evnt.Note,
OrdGroup = evnt.OrdGroup,
RequestId = evnt.RequestId,
StatusRequest = evnt.StatusRequest,
User = evnt.User,
Id = evnt.Id
};
requestEventArchRepository.Insert(evntArch, evntArch.Id);
}
requestEventRepository.Delete(e => e.RequestId == request.Id);
requestRepository.Delete(request.Id);
}
repository.SaveChanges();
queue.Push(new RequestAppEvent()
{
RequestEventId = newEvent.Id,
Archive = transferRequestToArchive
});
}
public IEnumerable <EmployeeDTO> GetListByWorkerUser(long userId, string name)
{
if (String.IsNullOrWhiteSpace(name))
{
return(null);
}
name = name.ToUpper();
IEnumerable <Employee> list = employeeRepository
.GetList(e => e.Organization != null &&
(e.FM.ToUpper().Contains(name) ||
e.Phone == name ||
e.Organization.Name.ToUpper().Contains(name))).ToList();
if (string.IsNullOrWhiteSpace(name))
{
return(null);
}
WorkerUser user = workerUserRepository.Get(userId);
long workerId = 0;
if (user.Worker == null)
{
return(list
.OrderBy(t => t.FM)
.OrderBy(t => t.IM)
.OrderBy(t => t.OT)
.Select(e => new EmployeeDTO()
{
Id = e.Id,
FM = e.FM,
IM = e.IM,
OT = e.OT,
Cabinet = e.Cabinet,
Phone = e.Phone,
PostName = e.Post != null ? e.Post.Name : null,
OrganizationId = e.Organization.Id,
OrganizationName = e.Organization.Name,
OrganizationAddress = e.Organization.Address
}));
}
workerId = user.Worker.Id;
IEnumerable <long> ids = organizationObjectTypeWorkerRepository
.GetList(t => workerId == 0 || t.Worker.Id == workerId)
.Select(t => t.Organization.Id)
.Distinct()
.ToList();
IEnumerable <Organization> list2 = organizationRepository.GetList()
.OrderBy(p => p.Name).ToList();
return(list
.Where(t => inOrganizationObjectTypeWorker(t.Organization, list2, ids))
.OrderBy(t => t.FM)
.OrderBy(t => t.IM)
.OrderBy(t => t.OT)
.Select(e => new EmployeeDTO()
{
Id = e.Id,
FM = e.FM,
IM = e.IM,
OT = e.OT,
Cabinet = e.Cabinet,
Phone = e.Phone,
PostName = e.Post != null ? e.Post.Name : null,
OrganizationId = e.Organization.Id,
OrganizationName = e.Organization.Name,
OrganizationAddress = e.Organization.Address
}));
}
public async Task OnGetAsync(int?id)
{
WorkerUser workerUser = await UserLogic.GetWorkerUserAsync(User);
Work = await WorkSheetLogic.GetWorkByIdAsync(id);
}
