public async Task <FormattedJobAssignViewModel> GetJobAssigns(string jobId, UploadedContentEnum?contentType)
{
IMemberModel currentUser = memberService.GetCurrentUser();
IJob job = await jobService.GetJobById(jobId);
var result = new FormattedJobAssignViewModel();
if (job.RelationGroupList.Any() && job.ParentId != null)
{
Guid housingDepartmentId = job.RelationGroupList.First().HousingDepartmentId;
IEnumerable <Guid> relationGroupIdList = job.RelationGroupList.Select(x => x.RelationGroupId).ToList();
JobAssign globalGroupedJobAssign = jobService.GetGlobalJobAssignForGroupedTask(job);
List <JobAssign> jobAssigns = jobService.GetJobAssignList(relationGroupIdList);
result.GlobalAssign = globalGroupedJobAssign.Map <JobAssignViewModel>();
result.Assigns = jobAssigns.Where(i => !i.IsGlobal && i.HousingDepartmentIdList.Contains(housingDepartmentId)).Select(i => i.Map <JobAssignViewModel>()).ToList();
result.AddressList = jobService.GetRelatedAddressListForHousingDepartment(relationGroupIdList, housingDepartmentId, isParent: false);
result.IsGroupedJob = true;
result.IsChildJob = job.ParentId != null;
}
else
{
IFormattedJobAssign jobAssign = jobService.GetAllByJobIdFormatted(jobId, currentUser.IsAdmin() ? null : currentUser.ActiveManagementDepartmentId);
result = Mapper.Map <FormattedJobAssignViewModel>(jobAssign);
}
result.CurrentUser = currentUser;
result.GlobalAssign.UploadList = GetUploadListModel(result.GlobalAssign.UploadList, contentType);
foreach (var assign in result.Assigns)
{
assign.UploadList = GetUploadListModel(assign.UploadList, contentType);
}
return(result);
}
public Task Handle(UploadDataDeleted message)
{
JobAssign jobAssign = GetJobAssignByFileId(Guid.Parse(message.SourceId));// source id here is a file id
return(UpdateJobAssign(jobAssign.Id,
Builders <JobAssign> .Update.Pull(f => f.UploadList, jobAssign.UploadList.FirstOrDefault(x => x.FileId == Guid.Parse(message.SourceId)))));
}
private YearPlanItemViewModel ToYearPlanDepartmentViewModel(Job facilityTask, Guid?departmentId, string departmentName, int year)
{
var result = new YearPlanItemViewModel
{
Id = departmentId?.ToString(),
Name = departmentName,
Weeks = EmptyWeeks
};
if (facilityTask == null)
{
return(result);
}
result.IsDisabled = facilityTask.IsHidden;
result.IsAssigned = facilityTask.Assigns.Count > 0;
if (departmentId.HasValue)
{
JobAssign assignedDepartment = GetJobAssign(facilityTask, departmentId.Value);
if (assignedDepartment != null)
{
facilityTask.Assigns.Add(assignedDepartment);
result.Weeks = ToYearPlanWeekData(assignedDepartment.WeekList, facilityTask, year, departmentId.Value);
}
}
return(result);
}
public async Task <JobAssignViewModel> SaveWeekList(ChangeJobAssignWeekListModel model)
{
JobAssign jobAssign = await jobService.CreateOrGetJobAssign(model.AssignId, model.JobId, model.DepartmentId);
if (!jobAssign.IsGlobal)
{
foreach (var week in model.WeekList)
{
week.IsDisabled = week.ChangedBy == WeekChangedBy.Administrator;
}
}
bool isLocalIntervalChanged = !jobAssign.IsGlobal;
await messageBus.Publish(new ChangeJobAssignWeeksCommand(jobAssign.Id, model.WeekList, model.ChangedByRole, isLocalIntervalChanged));
jobAssign.WeekList = model.WeekList;
if (jobAssign.IsGlobal)
{
await jobService.CopyGlobalJobAssignToLocalIfLocalIntervalWasntChanged(jobAssign.Id, model.JobId, model.DepartmentId);
await jobService.CopyParentGlobalJobAssignToChildren(jobAssign.Id, model.JobId);
}
managementHubs.Clients.All.refreshWeekPlanGridTasks();
managementHubs.Clients.All.refreshWeekPlanListTasks();
return(jobAssign.Map <JobAssignViewModel>());
}
private bool IsTaskHasOnlyRealTicket(List <JobAssign> jobAssigns, List <IDayAssign> dayAssignList)
{
JobAssign localJobAssign = jobAssigns.FirstOrDefault(x => !x.IsGlobal);
JobAssign jobAssign = localJobAssign ?? jobAssigns.First();
return(jobAssign.RepeatsPerWeek <= dayAssignList.Count);
}
private JobAssign GetCorrectJobAssign(Job job, Guid housingDepartmentId)
{
JobAssign localJobAssign = job.Assigns.FirstOrDefault(x => !x.IsGlobal && x.HousingDepartmentIdList.Contains(housingDepartmentId));
JobAssign globalJobAssign = job.Assigns.FirstOrDefault(x => x.HousingDepartmentIdList.Contains(housingDepartmentId));
return(localJobAssign ?? globalJobAssign);
}
private List <IWeekPlanJobModel> GetTicketsForExpiredJobs(IEnumerable <Job> jobs, Guid departmentId, int weekNumber, int year, bool isAllowGetVirtualTickets)
{
List <IWeekPlanJobModel> result = new List <IWeekPlanJobModel>();
List <Job> jobList = jobs.AsList();
WeekPlanParamsModel query = GetWeekPlanParamsModel(jobList, departmentId, weekNumber, year, isAllowGetVirtualTickets);
foreach (var job in jobList)
{
JobAssign jobAssign = GetJobAssing(job, departmentId);
if (jobAssign == null)
{
continue;
}
query.Job = job;
query.JobAssign = jobAssign;
List <IWeekPlanJobModel> backLogJobs = GetBackLogJobs(query, string.Empty);
result.AddRange(backLogJobs);
List <IWeekPlanJobModel> assignedToWeekDaysJobs = GetAssignedToWeekDaysJobs(query, string.Empty);
result.AddRange(assignedToWeekDaysJobs);
}
return(result);
}
private JobAssign GetJobAssignByJobId(string jobId)
{
List <JobAssign> jobAssignList = jobAssignProvider.GetAllByJobId(jobId);
JobAssign jobAssign = jobAssignList.FirstOrDefault();
return(jobAssign);
}
public Task Handle(UploadDataUploaded message)
{
var model = new UploadFileModel
{
FileId = Guid.Parse(message.SourceId),
FileName = message.Name,
Path = message.Path,
ContentType = message.ContentType,
CreationDate = message.UploadedOn,
UploaderId = message.UploaderId
};
JobAssign jobAssign = GetJobAssignById(message.JobAssignId);
if (jobAssign.UploadList == null)
{
jobAssign.UploadList = new List <UploadFileModel> {
model
};
}
else
{
jobAssign.UploadList.Add(model);
}
return(UpdateJobAssign(message.JobAssignId,
Builders <JobAssign> .Update.Set(f => f.UploadList, jobAssign.UploadList)));
}
public async Task ChangeTaskDate(string jobId, Guid dayAssignId, DateTime date)
{
JobAssign jobAssign = jobAssignProvider.GetByJobId(jobId);
IDayAssign dayAssign = dayAssignService.GetDayAssignById(dayAssignId);
WeekModel weekModel = jobAssign.WeekList.First();
int weekDay = date.GetWeekDayNumber();
int weekNumber = date.GetWeekNumber();
var dayPerWeekList = new List <DayPerWeekModel> {
new DayPerWeekModel {
Id = Guid.NewGuid(), WeekDay = weekDay
}
};
var weekList = new List <WeekModel> {
new WeekModel {
Number = weekNumber, IsDisabled = false, ChangedBy = weekModel.ChangedBy
}
};
await messageBus.Publish(new ChangeJobAssignWeeksCommand(jobAssign.Id, weekList, (ChangedByRole)weekModel.ChangedBy, false));
await messageBus.Publish(new SaveDaysPerWeekCommand(jobAssign.Id, dayPerWeekList));
await messageBus.Publish(new ChangeOperationalTaskDateCommand(dayAssignId, date, weekDay));
if (dayAssign.StatusId == JobStatus.Expired)
{
await jobStatusService.Pending(dayAssign.Id, dayAssign.StatusId);
}
}
public Responsible GetAssignTeam(string jobId, Guid housingDepartmentId)
{
JobAssign jobAssign = collection.Find(j => j.IsEnabled && j.JobIdList.Contains(jobId) && j.HousingDepartmentIdList.Contains(housingDepartmentId)).First();
Responsible result = jobAssign?.JobResponsibleList?.FirstOrDefault(r => r.JobId == jobId && r.HousingDepartmentId == housingDepartmentId);
return(result);
}
private void FillTenantJobAssignData(IOperationalTaskModel viewModel, JobAssign jobAssign, Guid departmentId)
{
viewModel.JobAssignId = jobAssign.Id;
viewModel.DepartmentId = departmentId;
viewModel.Description = jobAssign.Description;
viewModel.Uploads = jobAssign.UploadList;
SetCorrectUrlForUploadList(viewModel.Uploads, jobAssign.Id);
}
private void FillCorrectDayPerWeekModel(IEnumerable <DayPerWeekModel> model, JobAssign jobAssign)
{
foreach (var dayPerWeek in model)
{
DayPerWeekModel existingDayPerWeek =
jobAssign.DayPerWeekList.FirstOrDefault(dpw => dpw.WeekDay == dayPerWeek.WeekDay);
dayPerWeek.Id = existingDayPerWeek?.Id ?? Guid.NewGuid();
}
}
public async Task <JobAssignViewModel> LockInterval(ChangeJobAssignLockIntervalModel model)
{
JobAssign jobAssign = await jobService.CreateOrGetJobAssign(model.AssignId, model.JobId, model.DepartmentId);
await messageBus.Publish(new ChangeLockIntervalValueCommand(jobAssign.Id, model.IsLocked));
jobAssign.IsLocked = model.IsLocked;
return(jobAssign.Map <JobAssignViewModel>());
}
public Task Handle(UploadDataDescriptionChanged message)
{
JobAssign jobAssign = GetJobAssignByFileId(Guid.Parse(message.SourceId));// source id here is a file id
jobAssign.UploadList.FirstOrDefault(u => u.FileId == Guid.Parse(message.SourceId)).Description = message.Description;
return(UpdateJobAssign(jobAssign.Id,
Builders <JobAssign> .Update.Set(f => f.UploadList, jobAssign.UploadList)));
}
public IEnumerable <UploadFileModel> GetUploads(Guid jobAssignId)
{
JobAssign jobAssign = jobAssignProvider.GetById(jobAssignId);
jobService.FillCorrectPathForJobAssignsUploads(new List <JobAssign> {
jobAssign
});
return(jobAssign.UploadList);
}
private JobAssign GetJobAssing(Job job, Guid departmentId)
{
JobAssign jobAssign = job.Assigns.FirstOrDefault(a => a.HousingDepartmentIdList.Contains(departmentId));
if (jobAssign == null && job.DayAssigns.HasValue())
{
jobAssign = job.Assigns.OrderBy(i => i.IsGlobal).FirstOrDefault(a => a.JobIdList.Contains(job.Id));
}
return(jobAssign);
}
private JobAssign GetJobAssignForDepartment(Job job, List <Job> jobs, Guid housingDepartmentId)
{
Job parentJob = GetParentJob(job.ParentId, jobs);
if (IsValidChildTask(job, housingDepartmentId) && parentJob != null)
{
JobAssign parentGlobalAssign = parentJob.Assigns.First(x => x.IsGlobal);
return(parentGlobalAssign);
}
return(GetCorrectJobAssign(job, housingDepartmentId));
}
private KeyValuePair <string, List <YearPlanWeekData> > GetYearPlanWeekDataForDepartment(Job job, List <Job> jobs, Guid departmentId, int year)
{
JobAssign departmentJobAssign = GetJobAssignForDepartment(job, jobs, departmentId);
List <YearPlanWeekData> weekData = EmptyWeeks;
if (departmentJobAssign != null && (departmentJobAssign.TillYear == default(int) || departmentJobAssign.TillYear >= year))
{
weekData = ToYearPlanWeekData(departmentJobAssign.WeekList, job, year, departmentId);
}
return(new KeyValuePair <string, List <YearPlanWeekData> >(job.Id, weekData));
}
public int GetEstimate(string jobId, Guid housingDepartmentId)
{
JobAssign jobAssign = collection.Find(j => j.IsEnabled && j.JobIdList.Contains(jobId) && j.HousingDepartmentIdList.Contains(housingDepartmentId)).FirstOrDefault();
if (jobAssign == null || !jobAssign.JobResponsibleList.Any(r => r.JobId == jobId && r.HousingDepartmentId == housingDepartmentId))
{
return(default(int));
}
var estimate = jobAssign.JobResponsibleList.First(r => r.JobId == jobId && r.HousingDepartmentId == housingDepartmentId).EstimateInMinutes;
return(estimate);
}
private void SetUpJobAssigns()
{
JobAssigns = new List <JobAssign>();
JobAssign1 = new JobAssign()
{
Id = Guid.NewGuid()
};
JobAssign2 = new JobAssign()
{
Id = Guid.NewGuid()
};
}
private async Task <IOperationalTaskModel> GetOtherTask(Guid dayAssignId)
{
IOperationalTaskModel model = new OperationalTaskModel();
IDayAssign dayAssign = dayAssignService.GetDayAssignById(dayAssignId);
Job job = await jobProvider.Get(dayAssign.JobId);
FillJobData(model, job, dayAssign.DepartmentId, JobTypeEnum.Other);
JobAssign jobAssign = jobAssignProvider.GetAssignByJobIdAndDepartmentId(dayAssign.JobId, dayAssign.DepartmentId);
FillJobAssignData(model, jobAssign, dayAssign.DepartmentId, JobTypeEnum.Other);
FillDayAssignData(model, dayAssign, JobTypeEnum.Other);
return(model);
}
public async Task <JobAssignViewModel> SaveTillYear(ChangeJobAssignTillYearModel model)
{
JobAssign jobAssign = await jobService.CreateOrGetJobAssign(model.AssignId, model.JobId, model.DepartmentId);
bool isLocalIntervalChanged = !jobAssign.IsGlobal;
await messageBus.Publish(new ChangeJobAssignTillYearCommand(jobAssign.Id, model.TillYear, model.ChangedByRole, isLocalIntervalChanged));
jobAssign.TillYear = model.TillYear;
if (jobAssign.IsGlobal)
{
await jobService.CopyGlobalJobAssignToLocalIfLocalIntervalWasntChanged(jobAssign.Id, model.JobId, model.DepartmentId);
await jobService.CopyParentGlobalJobAssignToChildren(jobAssign.Id, model.JobId);
}
return(jobAssign.Map <JobAssignViewModel>());
}
public async Task <JobViewModel> GetWeekTask(JobFilterViewModel model)
{
IJob task = await jobService.GetJobById(model.JobId);
var jobAssignId = Guid.Empty;
var existingAssignId = model.DayAssignId.HasValue ? model.DayAssignId.Value : Guid.Empty;
var dayAssign = dayAssignProvider.Get(existingAssignId);
if (dayAssign != null)
{
JobAssign jobAssign = jobAssignProvider.GetById(dayAssign.JobAssignId);
task.Assigns.Add(jobAssign);
jobAssignId = dayAssign.JobAssignId;
task.DayAssigns.Add(dayAssign);
}
else
{
jobAssignId = jobAssignProvider.GetAssignByJobIdAndDepartmentId(model.JobId, model.HousingDepartmentId).Id;
//Create new dayAssign and set status "Assigned"
var newDayAssignModel = new NewDayAssignViewModel
{
JobId = model.JobId,
DepartmentId = model.HousingDepartmentId,
JobAssignId = jobAssignId,
CurrentWeekDay = model.CurrentWeekDay,
WeekNumber = model.WeekNumber,
Date = model.Date
};
var createResult = await dayAssignService.CreateDayAssignWithEstimate(newDayAssignModel);
if (createResult != Guid.Empty)
{
var newDayAssign = dayAssignProvider.Get(createResult);
await jobStatusService.Assigned(createResult, newDayAssign.StatusId);
task.DayAssigns.Add(newDayAssign);
}
}
return(new JobViewModel {
Job = task, JobAssignId = jobAssignId
});
}
public async Task <Guid> CreateDayAssign(INewDayAssignModel model)
{
JobAssign jobAssign = jobAssignProvider.GetAssignByJobIdAndDepartmentId(model.JobId, model.DepartmentId);
if (jobAssign == null && model.JobAssignId != Guid.Empty)
{
jobAssign = jobAssignProvider.GetById(model.JobAssignId);
}
var day = jobAssign?.DayPerWeekList.FirstOrDefault(dp => dp.WeekDay == model.CurrentWeekDay);
model.Id = Guid.NewGuid();
model.JobAssignId = jobAssign.Id;
Guid dayPerWeekId = model.DayPerWeekId ?? day?.Id ?? Guid.Empty;
var command = Mapper.Map(model, new CreateDayAssignCommand(dayPerWeekId));
await messageBus.Publish(command);
return(model.Id);
}
public async Task <JobAssignViewModel> SaveJobShedule(ChangeJobSheduleModel model)
{
JobAssign jobAssign = await jobService.CreateOrGetJobAssign(model.AssignId, model.JobId, model.DepartmentId);
FillCorrectDayPerWeekModel(model.DayPerWeekList, jobAssign);
bool isLocalIntervalChanged = !jobAssign.IsGlobal;
await messageBus.Publish(new ChangeJobAssignSheduleCommand(jobAssign.Id, model.DayPerWeekList, model.RepeatsPerWeek, model.ChangedByRole, isLocalIntervalChanged));
jobAssign.DayPerWeekList = model.DayPerWeekList;
jobAssign.RepeatsPerWeek = model.RepeatsPerWeek;
if (jobAssign.IsGlobal)
{
await jobService.CopyGlobalJobAssignToLocalIfLocalIntervalWasntChanged(jobAssign.Id, model.JobId, model.DepartmentId);
await jobService.CopyParentGlobalJobAssignToChildren(jobAssign.Id, model.JobId);
}
return(jobAssign.Map <JobAssignViewModel>());
}
private void FillJobAssignData(IOperationalTaskModel viewModel, JobAssign jobAssign, Guid departmentId, JobTypeEnum jobType)
{
switch (jobType)
{
case JobTypeEnum.AdHock:
FillAdhocJobAssignData(viewModel, jobAssign, departmentId);
break;
case JobTypeEnum.Tenant:
FillTenantJobAssignData(viewModel, jobAssign, departmentId);
break;
case JobTypeEnum.Other:
FillOtherTaskJobAssignDate(viewModel, jobAssign, departmentId);
break;
default:
throw new NotImplementedException($"No such task type {jobType}");
}
}
public async Task <Guid> CreateDayAssignWithEstimate(INewDayAssignModel model)
{
JobAssign jobAssign = jobAssignProvider.GetAssignByJobIdAndDepartmentId(model.JobId, model.DepartmentId);
if (jobAssign == null && model.JobAssignId != Guid.Empty)
{
jobAssign = jobAssignProvider.GetById(model.JobAssignId);
}
var jobResponsible = jobAssign.JobResponsibleList.FirstOrDefault(j => j.JobId == model.JobId && j.HousingDepartmentId == model.DepartmentId);
if (jobResponsible != null)
{
var day = jobAssign?.DayPerWeekList.FirstOrDefault(dp => dp.WeekDay == model.CurrentWeekDay);
model.Id = Guid.NewGuid();
model.JobAssignId = jobAssign.Id;
model.EstimatedMinutes = (int)jobResponsible?.EstimateInMinutes;
model.IsAssignedToAllUsers = jobResponsible?.IsAssignedToAllUsers ?? default(bool);
model.WeekDay = day.WeekDay;
if (jobResponsible.GroupId != Guid.Empty)
{
model.GroupId = jobResponsible.GroupId;
}
if (jobResponsible.TeamLeadId != Guid.Empty)
{
model.TeamLeadId = jobResponsible.TeamLeadId;
}
model.UserIdList = jobResponsible?.UserIdList ?? new List <Guid>();
Guid dayPerWeekId = model.DayPerWeekId ?? day?.Id ?? Guid.Empty;
var command = Mapper.Map(model, new CreateDayAssignCommand(dayPerWeekId));
await messageBus.Publish(command);
return(model.Id);
}
return(Guid.Empty);
}
private JobAssign GetJobAssign(Job job, Guid housingDepartmentId)
{
JobAssign localAssign = null;
JobAssign globalAssign = null;
if (job.ParentId != null)
{
RelationGroupModel model = job.RelationGroupList.First();
localAssign = job.Assigns.FirstOrDefault(x => !x.IsGlobal && x.HousingDepartmentIdList.Contains(housingDepartmentId));
globalAssign = model.HousingDepartmentId == housingDepartmentId
? job.Assigns.FirstOrDefault(x => x.IsGlobal && x.HousingDepartmentIdList.Contains(housingDepartmentId))
: null;
}
else
{
localAssign = job.Assigns.FirstOrDefault(x => !x.IsGlobal && x.HousingDepartmentIdList.Contains(housingDepartmentId));
globalAssign = job.Assigns.FirstOrDefault(x => x.IsGlobal && x.HousingDepartmentIdList.Contains(housingDepartmentId));
}
return(localAssign ?? globalAssign);
}
private void grabNextJob()
{
foreach (var ability in abilities)
{
GearmanServer.Log.Info(string.Format("Trying to find job for {0}", ability));
Job job = queue.getJobForQueue(ability);
if (job != null)
{
GearmanServer.Log.Info(string.Format("Found job for ability {0}", ability));
JobAssign ja = new JobAssign(job.JobHandle, job.TaskName, job.Data);
ja.Dump();
conn.sendPacket(ja);
return;
}
else
{
conn.sendPacket(new NoJob());
}
}
}
public Job(JobAssign ja, Worker w)
{
this.jobPacket = ja;
this.jobWorker = w;
}
private void grabNextJob()
{
foreach (var ability in abilities)
{
GearmanServer.Log.Info(string.Format("Trying to find job for {0}", ability));
Job job = queue.getJobForQueue(ability);
if (job != null)
{
GearmanServer.Log.Info (string.Format("Found job for ability {0}", ability));
JobAssign ja = new JobAssign(job.JobHandle, job.TaskName, job.Data);
ja.Dump ();
conn.sendPacket (ja);
return;
} else {
conn.sendPacket(new NoJob());
}
}
}
