public IConfirmation GetFirstIfSatisfied(long currentTime, M_ResourceCapability resourceCapability = null)
{
var(key, confirmation) = GetFirst();
if (confirmation != null && ((FBucket)confirmation.Job).HasSatisfiedJob)
{
return(confirmation);
}
return(null);
}
private void CreateResourceGroup(int numberOfResources, M_ResourceCapability capability)
{
List <M_Resource> resourceGroup = new List <M_Resource>();
for (int i = 1; i <= numberOfResources; i++)
{
var resource = CreateNewResource(capability.Name, true, false, i);
resourceGroup.Add(resource);
}
CapabilityToResourceDict.Add(capability.Name, resourceGroup);
}
internal MasterTableResourceCapability()
{
Capabilities = new List <M_ResourceCapability>();
CUTTING = new M_ResourceCapability {
Name = "Cutting"
};
DRILLING = new M_ResourceCapability {
Name = "Drilling"
};
ASSEMBLING = new M_ResourceCapability {
Name = "Assembling"
};
}
internal CapabilityDefinition GetCapabilityDefinition(M_ResourceCapability capability)
{
var capabilityDefinition =
_capabilityDefinitions.SingleOrDefault(x => x.ResourceCapability.Id == capability.Id);
if (capabilityDefinition != null)
{
return(capabilityDefinition);
}
// else create a new one
capabilityDefinition = new CapabilityDefinition(capability);
_capabilityDefinitions.Add(capabilityDefinition);
return(capabilityDefinition);
}
/// <summary>
/// Loop through all capabilities the hub provides.
/// </summary>
/// <param name="hubRef"></param>
/// <param name="capability"></param>
/// <returns></returns>
public bool AddOrCreateRelation(IActorRef hubRef, M_ResourceCapability capability)
{
AddOrCreateRelation(hubRef, capability.Name);
bool trueForAll = true;
if (capability.ChildResourceCapabilities == null)
{
return(trueForAll);
}
foreach (var item in capability.ChildResourceCapabilities)
{
trueForAll = trueForAll && AddOrCreateRelation(hubRef, item);
}
return(trueForAll);
}
public void AddOrUpdateBucketSize(M_ResourceCapability capability, long duration)
{
if (CapabilityBucketSizeDictionary.TryGetValue(capability.Id, out var value)) // update
{
value.Duration += duration;
CalculateBucketSize();
return;
}
// Create
var bucketSize = new BucketSize {
Duration = duration, Size = duration, Capability = capability
};
CapabilityBucketSizeDictionary.Add(capability.Id, bucketSize);
CalculateBucketSize();
}
private void CreateToolingCapabilities(MasterDBContext context, M_ResourceCapability parent, ResourceProperty resource)
{
var newCapas = new List <M_ResourceCapability>();
parent.ChildResourceCapabilities = new List <M_ResourceCapability>();
for (int i = 1; i <= resource.ToolCount; i++)
{
var capability = new M_ResourceCapability
{
Name = parent.Name + " Tool Nr " + i,
ParentResourceCapabilityId = parent.Id
};
Capabilities.Add(capability);
newCapas.Add(capability);
parent.ChildResourceCapabilities.Add(capability);
}
context.ResourceCapabilities.AddRange(newCapas);
context.SaveChanges();
}
private M_ResourceSetup CreatePhysicalToolResource(List <M_Resource> resourceToolsToAssign, M_ResourceCapability subCapability, List <M_ResourceSetup> setups,
M_ResourceCapabilityProvider capabilityProvider)
{
var toolObject =
resourceToolsToAssign.Single(x => x.Name.Equals(subCapability.Name));
return(CreateNewSetup(toolObject, capabilityProvider, true, true, 0));
}
public IConfirmation GetFirstIfSatisfiedAndSetReadyAtIsSmallerOrEqualThan(long currentTime, M_ResourceCapability resourceCapability = null)
{
var(key, confirmation) = GetFirst();
if (confirmation != null &&
((FBucket)confirmation.Job).HasSatisfiedJob &&
confirmation.ScopeConfirmation.SetReadyAt <= currentTime)
{
return(confirmation);
}
return(null);
}
public IConfirmation DequeueFirstSatisfied(long currentTime, M_ResourceCapability resourceCapability = null)
{
var(key, value) = GetFirstSatisfied(currentTime);
this.Remove(key);
return(value);
}
public bool HasCapability(M_ResourceCapability resourceCapability)
{
return(ResourceCapability.Id == resourceCapability.Id);
}
private void GetCapabilitiesRecursive(M_ResourceCapability capability)
{
capability.ChildResourceCapabilities = _dBContext.ResourceCapabilities.Where(x => x.ParentResourceCapabilityId == capability.Id).ToList();
capability.ChildResourceCapabilities.ForEach(GetCapabilitiesRecursive);
}
public static FOperation CreateDummyFOperationItem(string jobName, int jobDuration, int averageTransitionDuration = 20, bool preCondition = true, bool materialsProvide = true,
int dueTime = 50, long customerDue = 100L, M_ResourceCapability capability = null,
M_ArticleBom bom = null, long currentTime = 0L)
{
var operation = new M_Operation()
{
ArticleId = 10,
AverageTransitionDuration = averageTransitionDuration,
Duration = jobDuration,
HierarchyNumber = 10,
Id = 1,
Name = jobName,
ArticleBoms = new List <M_ArticleBom> {
bom
},
ResourceCapability = new M_ResourceCapability {
Name = "Cutting"
}
};
return(MessageFactory.ToOperationItem(operation, dueTime: dueTime, customerDue: customerDue, productionAgent: ActorRefs.Nobody, firstOperation: preCondition, currentTime: currentTime, remainingWork: 0));
}
//was sind operators? -> Personen, die Maschinen umrüsten
private void CreateTools(M_ResourceCapability capability, long setupTime, int numberOfOperators)
{
List <M_Resource> tools = new List <M_Resource>();
List <M_ResourceSetup> setups = new List <M_ResourceSetup>();
List <M_ResourceCapabilityProvider> capabilityProviders = new List <M_ResourceCapabilityProvider>();
List <M_Resource> operators = new List <M_Resource>();
for (int i = 1; i < 1 + numberOfOperators; i++)
{
operators.Add(CreateNewResource(capability.Name + " Operator " + i, true));
}
foreach (var resource in CapabilityToResourceDict.Single(x => x.Key == capability.Name).Value)
{
if (operators.Count > 0)
{
foreach (var op in operators)
{
foreach (var subCapability in _capability.Capabilities
.Single(x => x.Name == capability.Name)
.ChildResourceCapabilities)
{
var capabilityProvider = new M_ResourceCapabilityProvider()
{
Name = $"Provides {subCapability.Name} {resource.Name}",
ResourceCapabilityId = subCapability.Id,
};
var tool = CreateNewResource($"Tool {resource.Name} {subCapability.Name}", false);
tools.Add(tool);
setups.Add(CreateNewSetup(op, capabilityProvider, false, true, 0));
setups.Add(CreateNewSetup(tool, capabilityProvider, true, true, setupTime));
setups.Add(CreateNewSetup(resource, capabilityProvider, true, true, 0));
capabilityProviders.Add(capabilityProvider);
}
}
}
else
{
foreach (var subCapability in _capability.Capabilities
.Single(x => x.Name == capability.Name)
.ChildResourceCapabilities)
{
var capabilityProvider = new M_ResourceCapabilityProvider()
{
Name = $"Provides {subCapability.Name} {resource.Name}",
ResourceCapabilityId = subCapability.Id,
};
var tool = CreateNewResource($"Tool {resource.Name} {subCapability.Name}", false);
tools.Add(tool);
setups.Add(CreateNewSetup(tool, capabilityProvider, true, true, setupTime));
setups.Add(CreateNewSetup(resource, capabilityProvider, true, true, 0));
capabilityProviders.Add(capabilityProvider);
}
}
CapabilityProviderDict.Add($"{resource.Name} Tooling", capabilityProviders);
CapabilityToSetupDict.Add($"{resource.Name} Tooling", setups);
CapabilityToResourceDict.Add($"{resource.Name} Tooling", tools);
CapabilityToResourceDict.Add($"{resource.Name} Operators", operators);
}
}
public List <M_ResourceCapabilityProvider> GetAllCapabilityProvider(M_ResourceCapability capability)
{
return(_capabilityDefinitions.Single(x => x.ResourceCapability.Id == capability.Id).GetAllCapabilityProvider());
}
public CapabilityDefinition(M_ResourceCapability resourceCapability)
{
this.ResourceCapability = resourceCapability;
}
private void CreateTools(M_ResourceCapability capability, long setupTime, int numberOfOperators, List <M_Resource> workerToAssign, List <M_Resource> resourceToolsToAssign, String workergroup)
{
List <M_Resource> tools = new List <M_Resource>();
List <M_ResourceSetup> setups = new List <M_ResourceSetup>();
List <M_ResourceCapabilityProvider> capabilityProviders = new List <M_ResourceCapabilityProvider>();
List <M_Resource> operators = new List <M_Resource>();
for (int i = 1; i < 1 + numberOfOperators; i++)
{
operators.Add(CreateNewResource(capability.Name + " Operator " + i, true, true, null, workergroup));
}
foreach (var resource in CapabilityToResourceDict.Single(x => x.Key == capability.Name).Value)
{
// With operators
if (operators.Count > 0)
{
foreach (var op in operators)
{
if (workerToAssign.Any()) // with workers and setups
{
foreach (var worker in workerToAssign)
{
foreach (var subCapability in _capability.Capabilities
.Single(x => x.Name == capability.Name)
.ChildResourceCapabilities)
{
var capabilityProvider = new M_ResourceCapabilityProvider()
{
Name = $"Provides {subCapability.Name} {resource.Name} {worker.Name}",
ResourceCapabilityId = subCapability.Id,
};
var toolName = resource.Name + " " + subCapability.Name;
var tool = tools.SingleOrDefault(x => x.Name.Equals(toolName));
if (tool == null)
{
tool = CreateNewResource($"{resource.Name} {subCapability.Name}", false, false);
tools.Add(tool);
}
if (resourceToolsToAssign.Any())
{
setups.Add(CreatePhysicalToolResource(resourceToolsToAssign, subCapability, setups, capabilityProvider));
}
// CreateNewSetup(resource, capabilityProvider, usedInProcessing,usedInSetup, setupTime)
setups.Add(CreateNewSetup(op, capabilityProvider, false, true, 0));
setups.Add(CreateNewSetup(tool, capabilityProvider, true, true, setupTime));
setups.Add(CreateNewSetup(resource, capabilityProvider, true, true, 0));
setups.Add(CreateNewSetup(worker, capabilityProvider, true, false, 0));
capabilityProviders.Add(capabilityProvider);
}
}
}
else
{ // no worker but setup
foreach (var subCapability in _capability.Capabilities
.Single(x => x.Name == capability.Name)
.ChildResourceCapabilities)
{
var capabilityProvider = new M_ResourceCapabilityProvider()
{
Name = $"Provides {subCapability.Name} {resource.Name}",
ResourceCapabilityId = subCapability.Id,
};
var toolName = resource.Name + " " + subCapability.Name;
var tool = tools.SingleOrDefault(x => x.Name.Equals(toolName));
if (tool == null)
{
tool = CreateNewResource($"{resource.Name} {subCapability.Name}", false, false);
tools.Add(tool);
}
if (resourceToolsToAssign.Any())
{
setups.Add(CreatePhysicalToolResource(resourceToolsToAssign, subCapability, setups, capabilityProvider));
}
setups.Add(CreateNewSetup(op, capabilityProvider, false, true, 0));
setups.Add(CreateNewSetup(tool, capabilityProvider, true, true, setupTime));
setups.Add(CreateNewSetup(resource, capabilityProvider, true, true, 0));
capabilityProviders.Add(capabilityProvider);
}
}
}
}
else // without operators
{
if (workerToAssign.Any())
{
foreach (var worker in workerToAssign)
{
foreach (var subCapability in _capability.Capabilities
.Single(x => x.Name == capability.Name)
.ChildResourceCapabilities)
{
var capabilityProvider = new M_ResourceCapabilityProvider()
{
Name = $"Provides {subCapability.Name} {resource.Name} {worker.Name}",
ResourceCapabilityId = subCapability.Id,
};
// Tool
var toolName = resource.Name + " " + subCapability.Name;
var tool = tools.SingleOrDefault(x => x.Name.Equals(toolName));
if (tool == null)
{
tool = CreateNewResource($"{resource.Name} {subCapability.Name}", false, false);
tools.Add(tool);
}
if (resourceToolsToAssign.Any())
{
setups.Add(CreatePhysicalToolResource(resourceToolsToAssign, subCapability, setups, capabilityProvider));
}
setups.Add(CreateNewSetup(tool, capabilityProvider, true, true, setupTime));
setups.Add(CreateNewSetup(resource, capabilityProvider, true, true, 0));
setups.Add(CreateNewSetup(worker, capabilityProvider, true, false, 0));
capabilityProviders.Add(capabilityProvider);
}
}
}
else
{
foreach (var subCapability in _capability.Capabilities
.Single(x => x.Name == capability.Name)
.ChildResourceCapabilities)
{
var capabilityProvider = new M_ResourceCapabilityProvider()
{
Name = $"Provides {subCapability.Name} {resource.Name}",
ResourceCapabilityId = subCapability.Id,
};
var toolName = resource.Name + " " + subCapability.Name;
var tool = tools.SingleOrDefault(x => x.Name.Equals(toolName));
if (tool == null)
{
tool = CreateNewResource($"{resource.Name} {subCapability.Name}", false, false);
tools.Add(tool);
}
if (resourceToolsToAssign.Any())
{
setups.Add(CreatePhysicalToolResource(resourceToolsToAssign, subCapability, setups, capabilityProvider));
}
setups.Add(CreateNewSetup(tool, capabilityProvider, true, true, setupTime));
setups.Add(CreateNewSetup(resource, capabilityProvider, true, true, 0));
capabilityProviders.Add(capabilityProvider);
}
}
}
CapabilityProviderDict.Add($"{resource.Name} Tooling", capabilityProviders);
CapabilityToSetupDict.Add($"{resource.Name} Tooling", setups);
CapabilityToResourceDict.Add($"{resource.Name} Tooling", tools);
CapabilityToResourceDict.Add($"{resource.Name} Operators", operators);
}
}
/// <summary>
///
/// </summary>
/// <param name="resourceSetups"></param>
public CapabilityDefinition GetResourcesByCapability(M_ResourceCapability resourceCapability)
{
return(_capabilityDefinitions.Single(x => x.HasCapability(resourceCapability)));
}
