// -----------------------------------------------------------------
/// <summary>
/// Destroy all of the objects and remove them from the scene
/// </summary>
// -----------------------------------------------------------------
private void DestroySortableObjects()
{
try
{
foreach (SceneObjectGroup sog in m_sorted)
{
m_scene.DeleteSceneObject(sog, false);
Thread.Sleep(10);
}
m_sorted = new List <SceneObjectGroup>();
while (m_sortqueue.Count > 0)
{
WorkElement current = m_sortqueue.Dequeue();
foreach (SceneObjectGroup sog in current.m_prims)
{
m_scene.DeleteSceneObject(sog, false);
Thread.Sleep(10);
}
}
}
catch (Exception e)
{
m_log.ErrorFormat("[QuickSort] exception while deleting {0}", e.ToString());
}
}
// -----------------------------------------------------------------
/// <summary>
/// Process the sort event queue
/// </summary>
// -----------------------------------------------------------------
private void SortSortableObjects()
{
// We only care if m_abort is set while we're running
m_abort = false;
while (m_sortqueue.Count > 0)
{
m_log.DebugFormat("[QuickSort] sort queue contains {0} items", m_sortqueue.Count);
WorkElement current = m_sortqueue.Dequeue();
if (current.m_prims.Count < m_shortsize)
{
SortShortQueue(current);
}
else
{
SortLongQueue(current);
}
if (m_abort)
{
m_log.Debug("[QuickSort] sort aborted");
break;
}
Thread.Sleep(100);
}
m_log.Debug("[QuickSort] sort finished");
}
public Task Execute(WorkOrder workOrder, WorkElement workElement)
{
var existingCodes = workOrder.WorkElements.SelectMany(we => we.RateScheduleItem).ToList();
var newCodes = workElement.RateScheduleItem.Where(rsi => !existingCodes.Any(ec => ec.Id == rsi.OriginalId)).ToList();
UpdateExistingCodes(existingCodes, workElement);
AddNewCodes(workOrder, newCodes);
return(Task.CompletedTask);
}
// -----------------------------------------------------------------
/// <summary>
/// Compute the average value of objects to get a good split value
/// </summary>
/// <param name="item">The current work element</param>
// -----------------------------------------------------------------
private float ComputeAvgC(WorkElement item)
{
int count = item.m_prims.Count;
float sum = 0;
for (int i = 0; i < m_samplesize; i++)
{
int pos = m_random.Next(count);
sum += SortValue(item.m_prims[pos]);
}
return(sum / m_samplesize);
}
// -----------------------------------------------------------------
/// <summary>
/// Create the list of objects for sorting
/// </summary>
// -----------------------------------------------------------------
private void CreateSortableObjects()
{
WorkElement prims = new WorkElement(m_startingpos.X, m_startingpos.X + m_range.X);
for (int i = 0; i < m_objectcount; i++)
{
SceneObjectGroup sog = CreateSortableObject();
m_scene.AddNewSceneObject(sog, false);
prims.m_prims.Add(sog);
}
m_sortqueue.Enqueue(prims);
}
// -----------------------------------------------------------------
/// <summary>
/// Split a long segment around a pivot point breaking the sort into two pieces
/// </summary>
/// <param name="item">The current work element</param>
// -----------------------------------------------------------------
private void SortLongQueue(WorkElement item)
{
m_log.DebugFormat("[QuickSort] long sort with {0} elements in region {1} to {2}",
item.m_prims.Count, item.m_rangemin, item.m_rangemax);
float avgC = ComputeAvgC(item);
float avgX = ComputeAvgX(item);
float rangeU = item.m_rangemax - avgX;
float rangeL = avgX - item.m_rangemin;
m_log.DebugFormat("[QuickSort] split at {0} based on {1}", avgX, avgC);
WorkElement itemSmall = new WorkElement(item.m_rangemin, avgX);
WorkElement itemLarge = new WorkElement(avgX, item.m_rangemax);
foreach (SceneObjectGroup sog in item.m_prims)
{
Vector3 pos = sog.AbsolutePosition;
if (SortValue(sog) < avgC)
{
if ((pos.X > avgX) || (pos.X < item.m_rangemin))
{
pos.X = item.m_rangemin + (float)m_random.NextDouble() * rangeL;
sog.UpdateGroupPosition(pos);
Thread.Sleep(10);
}
itemSmall.m_prims.Add(sog);
}
else
{
if ((pos.X < avgX) || (pos.X > item.m_rangemax))
{
pos.X = item.m_rangemax - (float)m_random.NextDouble() * rangeU;
sog.UpdateGroupPosition(pos);
Thread.Sleep(10);
}
itemLarge.m_prims.Add(sog);
}
}
if (itemSmall.m_prims.Count > 0)
{
m_sortqueue.Enqueue(itemSmall);
}
if (itemLarge.m_prims.Count > 0)
{
m_sortqueue.Enqueue(itemLarge);
}
}
// -----------------------------------------------------------------
/// <summary>
/// Compute the average position for a sample of this region, could
/// just split it into equal sized segments but that tends to clump
/// objects
/// </summary>
/// <param name="item">The current work element</param>
// -----------------------------------------------------------------
private float ComputeAvgX(WorkElement item)
{
// return (float)((item.m_rangemax - item.m_rangemin) / 2.0);
int count = item.m_prims.Count;
float sum = 0.0f;
for (int i = 0; i < m_samplesize; i++)
{
int pos = m_random.Next(count);
sum += item.m_prims[pos].AbsolutePosition.X;
}
return(sum / (float)m_samplesize);
}
public async Task ThrowUnsupportedWhenOriginalSorCodeNotPresent()
{
Guid originalGuid = Guid.NewGuid();
Guid newGuid = Guid.NewGuid();
var workOrder = BuildWorkOrder(originalGuid, 10);
var workElement = new WorkElement()
{
RateScheduleItem = new List <RateScheduleItem>()
};
Func <Task> testFn = async() => await _classUnderTest.Execute(workOrder, workElement);
await testFn.Should().ThrowAsync <NotSupportedException>();
}
// -----------------------------------------------------------------
/// <summary>
/// Sort a short work element using a simple selection sort
/// </summary>
/// <param name=""></param>
// -----------------------------------------------------------------
private void SortShortQueue(WorkElement item)
{
m_log.DebugFormat("[QuickSort] short sort with {0} elements in region {1} to {2}",
item.m_prims.Count, item.m_rangemin, item.m_rangemax);
int count = item.m_prims.Count;
for (int i = 0; i < count - 1; i++)
{
for (int j = i + 1; j < count; j++)
{
if (SortValue(item.m_prims[i]) < SortValue(item.m_prims[j]))
{
// The list order is wrong... fix it
SceneObjectGroup sog = item.m_prims[i];
item.m_prims[i] = item.m_prims[j];
item.m_prims[j] = sog;
}
// The list is in the right order, now we need to make sure
// the scene is in the right order
Vector3 psmall = item.m_prims[i].AbsolutePosition;
Vector3 plarge = item.m_prims[j].AbsolutePosition;
if (psmall.X > plarge.X)
{
float x = psmall.X;
psmall.X = plarge.X;
plarge.X = x;
item.m_prims[i].UpdateGroupPosition(psmall);
item.m_prims[j].UpdateGroupPosition(plarge);
Thread.Sleep(10);
}
}
// Add it to the sorted list for later clean up
m_sorted.Add(item.m_prims[i]);
}
// Add the last one into the sorted list
m_sorted.Add(item.m_prims[count - 1]);
}
public async Task ReturnsNullIfNoWorkOrderTasks()
{
// arrange
_userServiceMock.SetSecurityGroup(UserGroups.Agent);
var expectedWorkOrder = CreateWorkOrder();
var we = new WorkElement {
Id = Guid.NewGuid(), RateScheduleItem = new List <RateScheduleItem> {
}
};
expectedWorkOrder.WorkElements.Add(we);
await SaveWorkOrderToDb(expectedWorkOrder);
// act
var workOrderTasks = await _classUnderTest.GetWorkOrderTasksForWorkOrder(-1);
// assert
workOrderTasks.Should().BeNull();
}
public Stateless(int eid)
{
List <WorkElement> cElement = DBconn.GetStateless(eid);
if (cElement.Count == 0)
{
string orderTitle = "NewWorkElement" + DateTime.Now, orderDesc = "";
var nowdate = DateTime.Now;
var res = DBconn.excuteQuery($"insert into element (ordertitle,orderdesc,laststate,requestdate,terminationdate) output Inserted.id values('','','{_state}','{nowdate}',null);");
if (!int.TryParse(res.ToString(), out eid))
{
eid = 0;
}
_element = new WorkElement
{
Id = eid,
OrderTitle = orderTitle,
RequestedBy = "",
EmailAddress = "",
OrderDescription = orderDesc,
RequestDate = nowdate,
Transition = new List <Transition>()
};
}
else
{
_element = new WorkElement
{
Id = eid,
OrderTitle = cElement[0].OrderTitle,
RequestedBy = cElement[0].RequestedBy,
EmailAddress = cElement[0].EmailAddress,
OrderDescription = cElement[0].OrderDescription,
RequestDate = cElement[0].RequestDate,
Transition = cElement[0].Transition
};
}
ConfigStateless();
}
public Stateless()
{
string orderTitle = "NewWorkElement" + DateTime.Now, orderDesc = "";
int eid;
var nowdate = DateTime.Now;
var res = DBconn.excuteQuery($"insert into element (ordertitle,orderdesc,laststate,requestdate,terminationdate) output Inserted.id values('','','{_state}','{nowdate}',null);");
if (!int.TryParse(res.ToString(), out eid))
{
eid = 0;
}
_element = new WorkElement
{
Id = eid,
OrderTitle = orderTitle,
OrderDescription = orderDesc,
RequestDate = nowdate,
Transition = new List <Transition>()
};
ConfigStateless();
}
public WorkElement _element;//a request for creating a service order or work element release
public Stateless(string requestedBy, string requestedMail, string orderTitle, string orderDesc)
{
int eid;
var nowdate = DateTime.Now;
int id = DBconn.insertAgent(requestedBy, requestedMail);
var res = DBconn.excuteQuery($"insert into element (ordertitle,orderdesc,requestedby,laststate,requestdate,terminationdate) output Inserted.id values('{orderTitle}','{orderDesc}','{id}','{_state}','{nowdate}',null);");
if (!int.TryParse(res.ToString(), out eid))
{
eid = 0;
}
_element = new WorkElement
{
Id = eid,
OrderTitle = orderTitle,
OrderDescription = orderDesc,
RequestedBy = requestedBy,
EmailAddress = requestedMail,
RequestDate = nowdate,
Transition = new List <Transition>()
};
ConfigStateless();
}
// -----------------------------------------------------------------
/// <summary>
/// Compute the average position for a sample of this region, could
/// just split it into equal sized segments but that tends to clump
/// objects
/// </summary>
/// <param name="item">The current work element</param>
// -----------------------------------------------------------------
private float ComputeAvgX(WorkElement item)
{
// return (float)((item.m_rangemax - item.m_rangemin) / 2.0);
int count = item.m_prims.Count;
float sum = 0.0f;
for (int i = 0; i < m_samplesize; i++)
{
int pos = m_random.Next(count);
sum += item.m_prims[pos].AbsolutePosition.X;
}
return sum/(float)m_samplesize;
}
private static void UpdateExistingCodes(IEnumerable <RateScheduleItem> existingCodes, WorkElement workElement)
{
foreach (var existingCode in existingCodes)
{
var updatedCode = workElement.RateScheduleItem.SingleOrDefault(rsi => rsi.OriginalId == existingCode.Id);
if (updatedCode == null)
{
throw new NotSupportedException($"Deleting SOR codes not supported, missing {existingCode.CustomCode}");
}
existingCode.Quantity.Amount = updatedCode.Quantity.Amount;
existingCode.DateUpdated = DateTime.UtcNow;
}
}
// -----------------------------------------------------------------
/// <summary>
/// Create the list of objects for sorting
/// </summary>
// -----------------------------------------------------------------
private void CreateSortableObjects()
{
WorkElement prims = new WorkElement(m_startingpos.X,m_startingpos.X + m_range.X);
for (int i = 0; i < m_objectcount; i++)
{
SceneObjectGroup sog = CreateSortableObject();
m_scene.AddNewSceneObject(sog, false);
prims.m_prims.Add(sog);
}
m_sortqueue.Enqueue(prims);
}
// -----------------------------------------------------------------
/// <summary>
/// Split a long segment around a pivot point breaking the sort into two pieces
/// </summary>
/// <param name="item">The current work element</param>
// -----------------------------------------------------------------
private void SortLongQueue(WorkElement item)
{
m_log.DebugFormat("[QuickSort] long sort with {0} elements in region {1} to {2}",
item.m_prims.Count, item.m_rangemin, item.m_rangemax);
float avgC = ComputeAvgC(item);
float avgX = ComputeAvgX(item);
float rangeU = item.m_rangemax - avgX;
float rangeL = avgX - item.m_rangemin;
m_log.DebugFormat("[QuickSort] split at {0} based on {1}",avgX,avgC);
WorkElement itemSmall = new WorkElement(item.m_rangemin,avgX);
WorkElement itemLarge = new WorkElement(avgX,item.m_rangemax);
foreach (SceneObjectGroup sog in item.m_prims)
{
Vector3 pos = sog.AbsolutePosition;
if (SortValue(sog) < avgC)
{
if ((pos.X > avgX) || (pos.X < item.m_rangemin))
{
pos.X = item.m_rangemin + (float)m_random.NextDouble() * rangeL;
sog.UpdateGroupPosition(pos);
Thread.Sleep(10);
}
itemSmall.m_prims.Add(sog);
} else {
if ((pos.X < avgX) || (pos.X > item.m_rangemax))
{
pos.X = item.m_rangemax - (float)m_random.NextDouble() * rangeU;
sog.UpdateGroupPosition(pos);
Thread.Sleep(10);
}
itemLarge.m_prims.Add(sog);
}
}
if (itemSmall.m_prims.Count > 0) m_sortqueue.Enqueue(itemSmall);
if (itemLarge.m_prims.Count > 0) m_sortqueue.Enqueue(itemLarge);
}
// -----------------------------------------------------------------
/// <summary>
/// Sort a short work element using a simple selection sort
/// </summary>
/// <param name=""></param>
// -----------------------------------------------------------------
private void SortShortQueue(WorkElement item)
{
m_log.DebugFormat("[QuickSort] short sort with {0} elements in region {1} to {2}",
item.m_prims.Count, item.m_rangemin, item.m_rangemax);
int count = item.m_prims.Count;
for (int i = 0; i < count - 1; i++)
{
for (int j = i+1; j < count; j++)
{
if (SortValue(item.m_prims[i]) < SortValue(item.m_prims[j]))
{
// The list order is wrong... fix it
SceneObjectGroup sog = item.m_prims[i];
item.m_prims[i] = item.m_prims[j];
item.m_prims[j] = sog;
}
// The list is in the right order, now we need to make sure
// the scene is in the right order
Vector3 psmall = item.m_prims[i].AbsolutePosition;
Vector3 plarge = item.m_prims[j].AbsolutePosition;
if (psmall.X > plarge.X)
{
float x = psmall.X;
psmall.X = plarge.X;
plarge.X = x;
item.m_prims[i].UpdateGroupPosition(psmall);
item.m_prims[j].UpdateGroupPosition(plarge);
Thread.Sleep(10);
}
}
// Add it to the sorted list for later clean up
m_sorted.Add(item.m_prims[i]);
}
// Add the last one into the sorted list
m_sorted.Add(item.m_prims[count - 1]);
}
// -----------------------------------------------------------------
/// <summary>
/// Compute the average value of objects to get a good split value
/// </summary>
/// <param name="item">The current work element</param>
// -----------------------------------------------------------------
private float ComputeAvgC(WorkElement item)
{
int count = item.m_prims.Count;
float sum = 0;
for (int i = 0; i < m_samplesize; i++)
{
int pos = m_random.Next(count);
sum += SortValue(item.m_prims[pos]);
}
return sum/m_samplesize;
}
public static List <WorkElement> GetStateless(int eid)
{
List <WorkElement> res = new List <WorkElement>();
SqlConnection myConnection = new SqlConnection(_connString);
myConnection.Open();
try { new SqlCommand(_initDBSql, myConnection).ExecuteNonQuery(); } catch (Exception e) { Console.WriteLine(e.ToString()); }
try
{
string sql = $"select a.*,c.name,d.name as requestedname,d.email as requestedmail,b.id as bid,b.ordertitle,b.orderdesc,laststate,requestdate,terminationdate from StateLog a join element b on a.ElementId=b.Id join agent c on a.triggeredby=c.id join agent d on b.requestedby=d.id " + (eid > 0 ? $"where b.id = '{eid}'" : "") + " order by b.RequestDate,a.TriggeredDate";
SqlCommand cmd = new SqlCommand(sql, myConnection);
SqlDataReader r = cmd.ExecuteReader();
if (r.HasRows)
{
var id = -1;
WorkElement e = null;
List <Transition> t = null;
while (r.Read())
{
if (id != int.Parse(r["bid"].ToString()))
{
if (id > -1)
{
e.Transition = t;
res.Add(e);
}
id = int.Parse(r["bid"].ToString());
t = new List <Transition>();
e = new WorkElement
{
Id = id,
OrderTitle = r["ordertitle"].ToString(),
OrderDescription = r["orderdesc"].ToString(),
RequestedBy = r["requestedname"].ToString(),
EmailAddress = r["requestedmail"].ToString(),
LastState = r["laststate"].ToString(),
Transition = t
};
if (!r["requestdate"].ToString().Equals(""))
{
e.RequestDate = DateTime.Parse(r["requestdate"].ToString());
}
if (!r["terminationdate"].ToString().Equals(""))
{
e.TerminationDate = DateTime.Parse(r["terminationdate"].ToString());
}
}
t.Add(new Transition {
ElementId = id,
SourceState = r["sourcestate"].ToString(),
DestnationState = r["destinationstate"].ToString(),
TriggeredBy = r["name"].ToString(),
TriggeredDate = DateTime.Parse(r["triggereddate"].ToString()),
Comment = r["comment"].ToString()
});
}
if (e != null)
{
res.Add(e);
}
}
}
catch (Exception e) { Console.WriteLine(e.ToString()); }
myConnection.Close();
return(res);
}
