private void CreateStatusRecords()
{
var statusRecords = this.statusRepository.Table.ToList();
var statusNames = new Tuple <int, string>[] {
new Tuple <int, string>(StatusRecord.NewStatus, "New"),
new Tuple <int, string>(StatusRecord.OpenStatus, "In Progress"),
new Tuple <int, string>(StatusRecord.DeferredStatus, "Deferred"),
new Tuple <int, string>(StatusRecord.PendingInputStatus, "Pending input"),
new Tuple <int, string>(StatusRecord.ClosedStatus, "Completed")
};
for (int i = 0; i < statusNames.Length; i++)
{
StatusRecord statusRecord = statusRecords.FirstOrDefault(c => c.StatusTypeId == statusNames[i].Item1);
if (statusRecord == null)
{
statusRecord = new StatusRecord
{
OrderId = i + 1,
Name = statusNames[i].Item2,
StatusTypeId = statusNames[i].Item1,
IsHardCode = true
};
this.statusRepository.Create(statusRecord);
}
}
this.statusRepository.Flush();
}
// GET: Admin/Record
public ActionResult Index(Guid patientId)
{
ViewBag.Feature = "Thêm mới";
ViewBag.Element = KeyElement;
if (Request.Url != null)
{
ViewBag.BaseURL = Request.Url;
}
try
{
using (var workScope = new UnitOfWork(new PatientManagementDbContext()))
{
var patient = workScope.Patients.FirstOrDefault(x => x.Id == patientId);
if (patient != null)
{
var record = workScope.Records.FirstOrDefault(x => x.Id == patient.RecordId);
if (record == null)
{
record = new Record
{
Id = Guid.NewGuid(),
CreatedBy = GetCurrentUser().FullName,
ModifiedBy = GetCurrentUser().FullName,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now,
Note = "",
Result = ""
};
patient.RecordId = record.Id;
workScope.Records.Add(record);
workScope.Complete();
}
ViewBag.Record = record;
ViewBag.Patient = patient;
var doctors = workScope.Doctors.GetAll().ToList();
ViewBag.Doctors = new SelectList(doctors, "Id", "Name");
var faculties = workScope.Faculties.GetAll().ToList();
ViewBag.Faculties = new SelectList(faculties, "Id", "Name");
var lstStatus = StatusRecord.GetDic();
ViewBag.ListStatus = new SelectList(lstStatus, "Value", "Text");
var detailRecord = workScope.DetailRecords.Query(x => x.RecordId == record.Id).OrderByDescending(x => x.Process).ToList();
return(View(detailRecord));
}
else
{
return(RedirectToAction("Create", "Patient"));
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
// need to do dynamically
private static string ReplaceWithWorkItem(string rowHtml, StatusRecord workItem)
{
rowHtml = rowHtml.Replace("#Title#", workItem.TaskTitle);
rowHtml = rowHtml.Replace("#ID#", workItem.TaskIdWithLink.Id.ToString());
rowHtml = rowHtml.Replace("#IDLink#", workItem.TaskIdWithLink.Link);
rowHtml = rowHtml.Replace("#AssignedTo#", workItem.AssignedTo);
rowHtml = rowHtml.Replace("#Status#", workItem.TaskStatus.ToString());
rowHtml = rowHtml.Replace("#CompletedWork#", workItem.CompletedWork.ToString());
return(rowHtml);
}
public bool IsStatusTypeChangeValid(StatusRecord changedRecord, ModelStateDictionary modelState)
{
if (changedRecord == null)
{
throw new ArgumentNullException("changedRecord");
}
if (modelState == null)
{
throw new ArgumentNullException("modelState");
}
var statusRecords = this.statusRepository.Table.Where(c => c.Deleted == false).ToList();
var statusNames = new Tuple <int, string>[] {
new Tuple <int, string>(StatusRecord.NewStatus, "New"),
new Tuple <int, string>(StatusRecord.OpenStatus, "In Progress"),
new Tuple <int, string>(StatusRecord.DeferredStatus, "Deferred"),
new Tuple <int, string>(StatusRecord.PendingInputStatus, "Pending input"),
new Tuple <int, string>(StatusRecord.ClosedStatus, "Completed")
};
var oldRecord = statusRecords.FirstOrDefault(c => c.Id == changedRecord.Id);
if (oldRecord != null)
{
statusRecords.Remove(oldRecord);
}
statusRecords.Add(changedRecord);
var statusTypes = new[] { StatusRecord.NewStatus, StatusRecord.OpenStatus, StatusRecord.DeferredStatus, StatusRecord.PendingInputStatus, StatusRecord.ClosedStatus };
foreach (var statusType in statusTypes)
{
var recordsWithThisStatusType = statusRecords.Where(c => c.StatusTypeId == statusType).ToList();
if (recordsWithThisStatusType.Count > 1)
{
modelState.AddModelError("StatusTypeId", "It is not allowed to have two status with the same StatusType");
return(false);
}
if (recordsWithThisStatusType.Count == 0)
{
var statusName = statusNames.First(c => c.Item1 == statusType).Item2;
modelState.AddModelError("StatusTypeId", "It is not allowed to remove a basic StatusType:" + statusName);
return(false);
}
}
return(true);
}
public int UpdateFrom5()
{
// status records
var statusRecords = this.statusRepository.Table.OrderBy(c => c.Id).ToList();
// rename open status to In Progress
var openStatus = statusRecords.FirstOrDefault(c => c.StatusTypeId == StatusRecord.OpenStatus);
if (openStatus != null)
{
openStatus.Name = "In Progress";
this.statusRepository.Update(openStatus);
}
// rename Solved to Deferred
var solvedStatus = statusRecords.FirstOrDefault(c => c.StatusTypeId == StatusRecord.DeferredStatus);
if (solvedStatus != null)
{
solvedStatus.Name = "Deferred";
this.statusRepository.Update(solvedStatus);
}
// rename Closed to Completed
var closedStatus = statusRecords.FirstOrDefault(c => c.StatusTypeId == StatusRecord.ClosedStatus);
if (closedStatus != null)
{
closedStatus.Name = "Completed";
this.statusRepository.Update(closedStatus);
}
// pending input
if (!statusRecords.Any(c => c.StatusTypeId == StatusRecord.PendingInputStatus))
{
StatusRecord pendingStatus = new StatusRecord
{
StatusTypeId = StatusRecord.PendingInputStatus,
Name = "Pending input",
OrderId = 3,
};
this.statusRepository.Create(pendingStatus);
}
this.statusRepository.Flush();
return(6);
}
public ActionResult CreateStatusPost(StatusViewModel model)
{
if (!this.services.Authorizer.Authorize(Permissions.BasicDataPermission))
{
return(new HttpUnauthorizedResult());
}
this.transactionManager.Demand();
if (!this.ModelState.IsValid)
{
this.transactionManager.Cancel();
return(this.View("CreateStatus", model));
}
// update status of old records
var statusRecords = this.statusRepository.Table.ToList();
statusRecords.Where(c => c.StatusTypeId == model.StatusTypeId && c.Id != model.StatusId).ToList().ForEach(c =>
{
c.StatusTypeId = null;
this.statusRepository.Update(c);
});
StatusRecord status = new StatusRecord();
status.Name = model.Name;
status.OrderId = model.OrderId;
status.StatusTypeId = model.StatusTypeId;
if (!this.validationService.IsStatusTypeChangeValid(status, this.ModelState))
{
this.transactionManager.Cancel();
return(this.View("CreateStatus", model));
}
this.statusRepository.Create(status);
this.statusRepository.Flush();
this.basicDataService.ClearCache();
return(RedirectToAction("TicketStatusList"));
}
// TODO: Make this query configurable
private async Task <List <StatusRecord> > MapQueryResultToStatusRecords(WorkItemQueryResult queryResult)
{
var StatusRecordlist = new List <StatusRecord>();
var count = 1;
foreach (WorkItemLink item in queryResult.WorkItemRelations)
{
if (item.Source != null)
{
var workItemInstance = this.witClient.GetWorkItemAsync(item.Target.Id).Result;
var parentItemInstance = this.witClient.GetWorkItemAsync(item.Source.Id).Result;
Enum.TryParse(workItemInstance.Fields["System.State"].ToString().Replace(" ", string.Empty), out CurrentStatus workItemStatus);
var record = new StatusRecord()
{
SerialNumber = count++,
ParentIdWithLink = new IdWithLink()
{
Id = item.Source.Id,
Link = this.hyperLinkService.GetWorkItemEditorUrl(item.Source.Id).ToString()
},
TaskIdWithLink = new IdWithLink()
{
Id = item.Target.Id,
Link = this.hyperLinkService.GetWorkItemEditorUrl(item.Target.Id).ToString()
},
TaskTitle = workItemInstance.Fields["System.Title"].ToString(),
TaskStatus = workItemStatus,
AssignedTo = ((IdentityRef)workItemInstance.Fields["System.AssignedTo"]).DisplayName,
ParentTitle = parentItemInstance?.Fields["System.Title"]?.ToString(),
CompletedWork = workItemInstance.Fields.Keys.Contains("Microsoft.VSTS.Scheduling.CompletedWork") ? workItemInstance?.Fields["Microsoft.VSTS.Scheduling.CompletedWork"]?.ToString() : string.Empty
};
StatusRecordlist.Add(record);
}
}
return(StatusRecordlist);
}
public async Task <DatabaseContainer> AddStatusRecordToUpdaterContainer(string servername, StatusRecord record)
{
var server = await _context.Servers.Where(s => s.Servername.Equals(servername))
.Include(s => s.UpdaterContainer).ThenInclude(c => c.StatusRecords).SingleOrDefaultAsync();
if (server == null)
{
throw new ArgumentException("Server does not exist");
}
if (server.UpdaterContainer == null)
{
throw new NullReferenceException("Server does not have an updater container");
}
record.DatabaseContainer = server.UpdaterContainer;
server.UpdaterContainer.StatusRecords.Add(record);
await _context.SaveChangesAsync();
return(server.UpdaterContainer);
}
public async Task AddStatusRecord(string servername, OverviewContainerData container)
{
var server = await _context.Servers.Where(s => s.Servername.Equals(servername))
.Include(s => s.UpdaterContainer)
.ThenInclude(c => c.StatusRecords)
.Include(s => s.Containers)
.ThenInclude(c => c.StatusRecords)
.SingleOrDefaultAsync();
if (server == null)
{
throw new ArgumentException("Server does not exist");
}
var statusRecord = new StatusRecord
{
TimeOfRecordInsertion = DateTime.Now,
};
if (container.Health != null)
{
if (container.Health.ToLower().Contains("unhealthy"))
{
statusRecord.Health = ContainerHealth.UnHealthy;
}
else
{
statusRecord.Health = ContainerHealth.Healthy;
}
}
if (container.Status.ToLower().Contains("up"))
{
statusRecord.Status = ContainerStatus.Up;
}
else
{
statusRecord.Status = ContainerStatus.Down;
}
if (ContainerIsUpdater(container.Image)) // Add the record to the updater container
{
statusRecord.DatabaseContainer = server.UpdaterContainer;
server.UpdaterContainer.StatusRecords.Add(statusRecord);
server.UpdaterContainer.ContainerId = container.Id;
}
else // Add it to the appropriate container
{
var databaseContainer = server.Containers.FirstOrDefault(c => c.ContainerId.Equals(container.Id));
if (databaseContainer == null) // the server does not hold any records for this container yet
{
databaseContainer = new DatabaseContainer {
ContainerId = container.Id
};
server.Containers.Add(databaseContainer);
}
statusRecord.DatabaseContainer = databaseContainer;
}
await _context.SaveChangesAsync();
}
