static void SaveState(int frames)
{
ResumeState state = new ResumeState(I.currentlyUsingAutoEnc, frames);
string filePath = Path.Combine(I.current.tempFolder, Paths.resumeDir, resumeFilename);
File.WriteAllText(filePath, state.ToString());
}
public static async Task PrepareResumedRun()
{
if (!resumeNextRun)
{
return;
}
string stateFilepath = Path.Combine(I.current.tempFolder, Paths.resumeDir, resumeFilename);
ResumeState state = new ResumeState(File.ReadAllText(stateFilepath));
string fileMapFilepath = Path.Combine(I.current.tempFolder, Paths.resumeDir, filenameMapFilename);
List <string> inputFrameLines = File.ReadAllLines(fileMapFilepath).Where(l => l.Trim().Length > 3).ToList();
List <string> inputFrames = inputFrameLines.Select(l => Path.Combine(I.current.framesFolder, l.Split('|')[1])).ToList();
for (int i = 0; i < state.interpolatedInputFrames; i++)
{
IOUtils.TryDeleteIfExists(inputFrames[i]);
if (i % 1000 == 0)
{
await Task.Delay(1);
}
}
Directory.Move(I.current.interpFolder, I.current.interpFolder + Paths.prevSuffix); // Move existing interp frames
Directory.CreateDirectory(I.current.interpFolder); // Re-create empty interp folder
LoadFilenameMap();
}
/// <summary>
/// Creates a new resumestate record.
/// </summary>
public async Task <ResumeState> CreateResumeStateAsync(ResumeState resumeState)
{
// Validation
if (resumeState == null)
{
return(null);
}
// Trimming strings
if (!string.IsNullOrEmpty(resumeState.Name))
{
resumeState.Name = resumeState.Name.Trim();
}
if (!string.IsNullOrEmpty(resumeState.DisplayName))
{
resumeState.DisplayName = resumeState.DisplayName.Trim();
}
// #-#-# {D4775AF3-4BFA-496A-AA82-001028A22DD6}
// Before creation
// #-#-#
resumeState = await this.resumeStateRepository.InsertAsync(resumeState);
// #-#-# {1972C619-D2F2-48FD-8474-3A69621B1F78}
// After creation
// #-#-#
return(resumeState);
}
public async Task <ActionResult <ResumeStateVM> > GetResumeState([FromRoute] Guid id)
{
ResumeState resumestate = await this.bll.GetResumeStateByIdAsync(id);
if (resumestate == null)
{
return(NotFound());
}
// Mapping
return(Ok(this.mapper.Map <ResumeState, ResumeStateVM>(resumestate)));
}
/// <summary>
/// Creates a new resume record.
/// </summary>
public async Task <Resume> CreateResumeAsync(Resume resume)
{
// Validation
if (resume == null)
{
return(null);
}
// Before creation
// Trimming strings
if (!string.IsNullOrEmpty(resume.DisplayName))
{
resume.DisplayName = resume.DisplayName.Trim();
}
if (!string.IsNullOrEmpty(resume.JobTitle))
{
resume.JobTitle = resume.JobTitle.Trim();
}
if (!string.IsNullOrEmpty(resume.Description))
{
resume.Description = resume.Description.Trim();
}
// Name field
resume.Name = resume.DisplayName.ToSlug();
// Default resume state
if (resume.ResumeStateId == Guid.Empty)
{
ResumeState resumeStateActive = await this.resumeStateRepository.GetByNameAsync("active");
resume.ResumeStateId = resumeStateActive.Id;
resume.ResumeState = resumeStateActive;
}
// User
if (resume.UserId == Guid.Empty)
{
User currentUser = await this.userManager.GetUserAsync(this.httpContextAccessor.HttpContext.User);
resume.UserId = currentUser.Id;
resume.User = currentUser;
}
resume = await this.resumeRepository.InsertAsync(resume);
// After creation
return(resume);
}
public async Task <ActionResult <ResumeStateVM> > DeleteResumeState([FromRoute] Guid id)
{
// Retrieve existing resumestate
ResumeState resumestate = await this.bll.GetResumeStateByIdAsync(id);
if (resumestate == null)
{
return(NotFound());
}
await this.bll.DeleteResumeStateAsync(resumestate);
// Mapping
return(Ok(this.mapper.Map <ResumeState, ResumeStateVM>(resumestate)));
}
public async Task <ActionResult <ResumeStateVM> > UpdateResumeState([FromRoute] Guid id, [FromBody] ResumeStateVM resumeStateVM)
{
// Validation
if (!ModelState.IsValid || id != resumeStateVM.Id)
{
return(BadRequest(ModelState));
}
// Mapping
ResumeState resumeState = this.mapper.Map <ResumeStateVM, ResumeState>(resumeStateVM);
resumeState = await this.bll.UpdateResumeStateAsync(resumeState);
// Mapping
return(Ok(this.mapper.Map <ResumeState, ResumeStateVM>(resumeState)));
}
/// <summary>
/// Updates an existing resumestate record by Id.
/// </summary>
public async Task <ResumeState> UpdateResumeStateAsync(ResumeState resumeStateUpdate)
{
// Validation
if (resumeStateUpdate == null)
{
return(null);
}
// Retrieve existing
ResumeState resumeState = await this.resumeStateRepository.GetByIdAsync(resumeStateUpdate.Id);
if (resumeState == null)
{
return(null);
}
// Trimming strings
if (!string.IsNullOrEmpty(resumeStateUpdate.Name))
{
resumeStateUpdate.Name = resumeStateUpdate.Name.Trim();
}
if (!string.IsNullOrEmpty(resumeStateUpdate.DisplayName))
{
resumeStateUpdate.DisplayName = resumeStateUpdate.DisplayName.Trim();
}
// Mapping
resumeState.Name = resumeStateUpdate.Name;
resumeState.DisplayName = resumeStateUpdate.DisplayName;
// #-#-# {B5914243-E57E-41AE-A7C8-553F2F93267B}
// Before update
// #-#-#
resumeState = await this.resumeStateRepository.UpdateAsync(resumeState);
// #-#-# {983B1B6C-14A7-4925-8571-D77447DF0ADA}
// After update
// #-#-#
return(resumeState);
}
public async Task <ActionResult <ResumeStateVM> > CreateResumeState([FromBody] ResumeStateVM resumestateVM)
{
// Validation
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Mapping
ResumeState resumestate = this.mapper.Map <ResumeStateVM, ResumeState>(resumestateVM);
resumestate = await this.bll.CreateResumeStateAsync(resumestate);
// Mapping
return(CreatedAtAction(
"GetResumeState",
new { id = resumestate.Id },
this.mapper.Map <ResumeState, ResumeStateVM>(resumestate)
));
}
/// <summary>
/// Deletes an existing resumestate record.
/// </summary>
public async Task <ResumeState> DeleteResumeStateAsync(ResumeState resumeState)
{
// Validation
if (resumeState == null)
{
return(null);
}
// #-#-# {FE1A99E0-482D-455B-A8C1-3C2C11FACA58}
// Before deletion
// #-#-#
await this.resumeStateRepository.DeleteAsync(resumeState);
// #-#-# {F09857C0-44E7-4E6C-B3E6-883C0D28E1A6}
// After deletion
// #-#-#
return(resumeState);
}
public override string ReadLine()
{
string nextCommand = queuedCommands.ReadLine();
if (nextCommand != null)
{
return(nextCommand);
}
switch (resumeState)
{
// heat the extrude to remove it from the part
case ResumeState.RemoveHeating:
// TODO: make sure we heat up all the extruders that we need to (all that are used)
queuedCommands.Add("G21; set units to millimeters");
queuedCommands.Add("M107; fan off");
queuedCommands.Add("T0; set the active extruder to 0");
queuedCommands.Add("G90; use absolute coordinates");
queuedCommands.Add("G92 E0; reset the expected extruder position");
queuedCommands.Add("M82; use absolute distance for extrusion");
queuedCommands.Add("M109 S{0}".FormatWith(ActiveSliceSettings.Instance.ExtruderTemperature(0)));
resumeState = ResumeState.Raising;
return("");
// remove it from the part
case ResumeState.Raising:
queuedCommands.Add("M114 ; get current position");
queuedCommands.Add("G91 ; move relative");
queuedCommands.Add("G1 Z10 F{0}".FormatWith(MovementControls.ZSpeed));
queuedCommands.Add("G90 ; move absolute");
resumeState = ResumeState.Homing;
return("");
// if top homing, home the extruder
case ResumeState.Homing:
if (ActiveSliceSettings.Instance.ActiveValue("z_homes_to_max") == "1")
{
queuedCommands.Add("G28");
}
else
{
// home x
queuedCommands.Add("G28 X0");
// home y
queuedCommands.Add("G28 Y0");
// move to the place we can home z from
Vector2 resumePositionXy = ActiveSliceSettings.Instance.ActiveVector2("resume_position_before_z_home");
queuedCommands.Add("G1 X{0:0.000}Y{1:0.000}F{2}".FormatWith(resumePositionXy.x, resumePositionXy.y, MovementControls.XSpeed));
// home z
queuedCommands.Add("G28 Z0");
}
resumeState = ResumeState.FindingResumeLayer;
return("");
// This is to resume printing if an out a filament occurs.
// Help the user move the extruder down to just touching the part
case ResumeState.FindingResumeLayer:
if (false) // help the user get the head to the right position
{
// move to above the completed print
// move over a know good part of the model at the current top layer (extrude vertex from gcode)
// let the user move down until they like the height
// calculate that position and continue
}
else // we are resuming because of disconnect or reset, skip this
{
resumeState = ResumeState.SkippingGCode;
goto case ResumeState.SkippingGCode;
}
case ResumeState.SkippingGCode:
// run through the gcode that the device expected looking for things like temp
// and skip everything else until we get to the point we left off last time
while (internalStream.FileStreaming.PercentComplete(internalStream.LineIndex) < percentDone)
{
string line = internalStream.ReadLine();
lastDestination = GetPosition(line, lastDestination);
// check if the line is something we want to send to the printer (like a temp)
if (line.StartsWith("M109") ||
line.StartsWith("M104") ||
line.StartsWith("T") ||
line.StartsWith("M106") ||
line.StartsWith("M107"))
{
return(line);
}
}
resumeState = ResumeState.PrimingAndMovingToStart;
return("");
case ResumeState.PrimingAndMovingToStart:
{
// let's prime the extruder, move to a good position over the part, then start printing
queuedCommands.Add("G1 E5");
queuedCommands.Add("G1 E4");
if (ActiveSliceSettings.Instance.ActiveValue("z_homes_to_max") == "0") // we are homed to the bed
{
// move to the height we can resume printing from
Vector2 resumePositionXy = ActiveSliceSettings.Instance.ActiveVector2("resume_position_before_z_home");
queuedCommands.Add(CreateMovementLine(new PrinterMove(new VectorMath.Vector3(resumePositionXy.x, resumePositionXy.y, lastDestination.position.z + 5), 0, MovementControls.ZSpeed)));
// move just above the actual print position
queuedCommands.Add(CreateMovementLine(new PrinterMove(lastDestination.position + new VectorMath.Vector3(0, 0, 5), 0, MovementControls.XSpeed)));
// move down to part
queuedCommands.Add(CreateMovementLine(new PrinterMove(lastDestination.position, 0, MovementControls.ZSpeed)));
}
else
{
// move to the actual print position
queuedCommands.Add(CreateMovementLine(new PrinterMove(lastDestination.position, 0, MovementControls.ZSpeed)));
}
// extrude back to our filament start
queuedCommands.Add("G1 E5");
/// reset the printer to know where the filament should be
queuedCommands.Add("G92 E{0}".FormatWith(lastDestination.extrusion));
resumeState = ResumeState.PrintingSlow;
}
return("");
case ResumeState.PrintingSlow:
{
string lineToSend = internalStream.ReadLine();
if (lineToSend != null &&
lineToSend.StartsWith("; LAYER:"))
{
if (lineToSend != null &&
LineIsMovement(lineToSend))
{
PrinterMove currentMove = GetPosition(lineToSend, lastDestination);
PrinterMove moveToSend = currentMove;
double feedRate;
string firstLayerSpeed = ActiveSliceSettings.Instance.ActiveValue("resume_first_layer_speed");
if (!double.TryParse(firstLayerSpeed, out feedRate))
{
feedRate = 10;
}
feedRate *= 60;
moveToSend.feedRate = feedRate;
lineToSend = CreateMovementLine(moveToSend, lastDestination);
lastDestination = currentMove;
return(lineToSend);
}
return(lineToSend);
}
}
resumeState = ResumeState.PrintingToEnd;
return("");
case ResumeState.PrintingToEnd:
return(internalStream.ReadLine());
}
return(null);
}
public override string ReadLine()
{
string nextCommand = queuedCommands.ReadLine();
if (nextCommand != null)
{
return nextCommand;
}
switch (resumeState)
{
// heat the extrude to remove it from the part
case ResumeState.RemoveHeating:
// TODO: make sure we heat up all the extruders that we need to (all that are used)
queuedCommands.Add("G21; set units to millimeters");
queuedCommands.Add("M107; fan off");
queuedCommands.Add("T0; set the active extruder to 0");
queuedCommands.Add("G90; use absolute coordinates");
queuedCommands.Add("G92 E0; reset the expected extruder position");
queuedCommands.Add("M82; use absolute distance for extrusion");
queuedCommands.Add("M109 S{0}".FormatWith(ActiveSliceSettings.Instance.GetExtruderTemperature(1)));
resumeState = ResumeState.Raising;
return "";
// remove it from the part
case ResumeState.Raising:
queuedCommands.Add("M114 ; get current position");
queuedCommands.Add("G91 ; move relative");
queuedCommands.Add("G1 Z10 F{0}".FormatWith(MovementControls.ZSpeed));
queuedCommands.Add("G90 ; move absolute");
resumeState = ResumeState.Homing;
return "";
// if top homing, home the extruder
case ResumeState.Homing:
if (ActiveSliceSettings.Instance.GetActiveValue("z_homes_to_max") == "1")
{
queuedCommands.Add("G28");
}
else
{
// home x
queuedCommands.Add("G28 X0");
// home y
queuedCommands.Add("G28 Y0");
// move to the place we can home z from
Vector2 resumePositionXy = ActiveSliceSettings.Instance.GetActiveVector2("resume_position_before_z_home");
queuedCommands.Add("G1 X{0:0.000}Y{1:0.000}F{2}".FormatWith(resumePositionXy.x, resumePositionXy.y, MovementControls.XSpeed));
// home z
queuedCommands.Add("G28 Z0");
}
resumeState = ResumeState.FindingResumeLayer;
return "";
// This is to resume printing if an out a filament occurs.
// Help the user move the extruder down to just touching the part
case ResumeState.FindingResumeLayer:
if (false) // help the user get the head to the right position
{
// move to above the completed print
// move over a know good part of the model at the current top layer (extrude vertex from gcode)
// let the user move down until they like the height
// calculate that position and continue
}
else // we are resuming because of disconnect or reset, skip this
{
resumeState = ResumeState.SkippingGCode;
goto case ResumeState.SkippingGCode;
}
case ResumeState.SkippingGCode:
// run through the gcode that the device expected looking for things like temp
// and skip everything else until we get to the point we left off last time
while (internalStream.FileStreaming.PercentComplete(internalStream.LineIndex) < percentDone)
{
string line = internalStream.ReadLine();
lastDestination = GetPosition(line, lastDestination);
// check if the line is something we want to send to the printer (like a temp)
if (line.StartsWith("M109")
|| line.StartsWith("M104")
|| line.StartsWith("T")
|| line.StartsWith("M106")
|| line.StartsWith("M107"))
{
return line;
}
}
resumeState = ResumeState.PrimingAndMovingToStart;
return "";
case ResumeState.PrimingAndMovingToStart:
{
// let's prime the extruder, move to a good position over the part, then start printing
queuedCommands.Add("G1 E5");
queuedCommands.Add("G1 E4");
if (ActiveSliceSettings.Instance.GetActiveValue("z_homes_to_max") == "0") // we are homed to the bed
{
// move to the height we can resume printing from
Vector2 resumePositionXy = ActiveSliceSettings.Instance.GetActiveVector2("resume_position_before_z_home");
queuedCommands.Add(CreateMovementLine(new PrinterMove(new VectorMath.Vector3(resumePositionXy.x, resumePositionXy.y, lastDestination.position.z + 5), 0, MovementControls.ZSpeed)));
// move just above the actual print position
queuedCommands.Add(CreateMovementLine(new PrinterMove(lastDestination.position + new VectorMath.Vector3(0, 0, 5), 0, MovementControls.XSpeed)));
// move down to part
queuedCommands.Add(CreateMovementLine(new PrinterMove(lastDestination.position, 0, MovementControls.ZSpeed)));
}
else
{
// move to the actual print position
queuedCommands.Add(CreateMovementLine(new PrinterMove(lastDestination.position, 0, MovementControls.ZSpeed)));
}
// extrude back to our filament start
queuedCommands.Add("G1 E5");
/// reset the printer to know where the filament should be
queuedCommands.Add("G92 E{0}".FormatWith(lastDestination.extrusion));
resumeState = ResumeState.PrintingSlow;
}
return "";
case ResumeState.PrintingSlow:
{
string lineToSend = internalStream.ReadLine();
if (!lineToSend.StartsWith("; LAYER:"))
{
if (lineToSend != null
&& LineIsMovement(lineToSend))
{
PrinterMove currentMove = GetPosition(lineToSend, lastDestination);
PrinterMove moveToSend = currentMove;
double feedRate;
string firstLayerSpeed = ActiveSliceSettings.Instance.GetActiveValue("resume_first_layer_speed");
if (!double.TryParse(firstLayerSpeed, out feedRate))
{
feedRate = 10;
}
feedRate *= 60;
moveToSend.feedRate = feedRate;
lineToSend = CreateMovementLine(moveToSend, lastDestination);
lastDestination = currentMove;
return lineToSend;
}
return lineToSend;
}
}
resumeState = ResumeState.PrintingToEnd;
return "";
case ResumeState.PrintingToEnd:
return internalStream.ReadLine();
}
return null;
}
public RJMMutation(
DocumentBLL documentBLL,
DocumentTypeBLL documentTypeBLL,
ResumeBLL resumeBLL,
ResumeStateBLL resumeStateBLL,
SkillBLL skillBLL,
SkillAliasBLL skillAliasBLL,
JobBLL jobBLL,
JobStateBLL jobStateBLL
)
{
this.AuthorizeWith("Authorized");
// Documents
//FieldAsync<DocumentType>(
// "createDocument",
// arguments: new QueryArguments(
// new QueryArgument<NonNullGraphType<DocumentInputType>>
// {
// Name = "document"
// }
// ),
// resolve: async context =>
// {
// Document document = context.GetArgument<Document>("document");
// return await context.TryAsyncResolve(
// async c => await documentBLL.CreateDocumentAsync(document)
// );
// }
//);
FieldAsync <GraphQLTypes.DocumentType>(
"updateDocument",
arguments: new QueryArguments(
//new QueryArgument<NonNullGraphType<IdGraphType>>
//{
// Name = "id"
//},
new QueryArgument <NonNullGraphType <GraphQLTypes.DocumentInputType> >
{
Name = "document"
}
),
resolve: async context =>
{
//Guid id = context.GetArgument<Guid>("id");
Document document = context.GetArgument <Document>("document");
return(await context.TryAsyncResolve(
async c => await documentBLL.UpdateDocumentAsync(document)
));
}
);
FieldAsync <GraphQLTypes.DocumentType>(
"linkResumeToDocument",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <DocumentResumeInputType> >
{
Name = "documentResume"
}
),
resolve: async context =>
{
DocumentResume documentResume = context.GetArgument <DocumentResume>("documentResume");
return(await context.TryAsyncResolve(
async c => await documentBLL.LinkResumeToDocumentAsync(documentResume)
));
}
);
FieldAsync <GraphQLTypes.DocumentType>(
"unlinkResumeFromDocument",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <DocumentResumeInputType> >
{
Name = "documentResume"
}
),
resolve: async context =>
{
DocumentResume documentResume = context.GetArgument <DocumentResume>("documentResume");
return(await context.TryAsyncResolve(
async c => await documentBLL.UnlinkResumeFromDocumentAsync(documentResume)
));
}
);
FieldAsync <GraphQLTypes.DocumentType>(
"removeDocument",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
return(await context.TryAsyncResolve(
async c => await documentBLL.DeleteDocumentByIdAsync(id)
));
}
);
// DocumentTypes
FieldAsync <DocumentTypeType>(
"createDocumentType",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <DocumentTypeInputType> >
{
Name = "documentType"
}
),
resolve: async context =>
{
APIModels.DocumentType documentType = context.GetArgument <APIModels.DocumentType>("documentType");
return(await context.TryAsyncResolve(
async c => await documentTypeBLL.CreateDocumentTypeAsync(documentType)
));
}
);
FieldAsync <DocumentTypeType>(
"updateDocumentType",
arguments: new QueryArguments(
//new QueryArgument<NonNullGraphType<IdGraphType>>
//{
// Name = "id"
//},
new QueryArgument <NonNullGraphType <DocumentTypeInputType> >
{
Name = "documentType"
}
),
resolve: async context =>
{
//Guid id = context.GetArgument<Guid>("id");
APIModels.DocumentType documentType = context.GetArgument <APIModels.DocumentType>("documentType");
return(await context.TryAsyncResolve(
async c => await documentTypeBLL.UpdateDocumentTypeAsync(documentType)
));
}
);
FieldAsync <DocumentTypeType>(
"removeDocumentType",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
return(await context.TryAsyncResolve(
async c => await documentTypeBLL.DeleteDocumentTypeByIdAsync(id)
));
}
);
// Resumes
FieldAsync <ResumeType>(
"createResume",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ResumeInputType> >
{
Name = "resume"
}
),
resolve: async context =>
{
Resume resume = context.GetArgument <Resume>("resume");
return(await context.TryAsyncResolve(
async c => await resumeBLL.CreateResumeAsync(resume)
));
}
);
FieldAsync <ResumeType>(
"updateResume",
arguments: new QueryArguments(
//new QueryArgument<NonNullGraphType<IdGraphType>>
//{
// Name = "id"
//},
new QueryArgument <NonNullGraphType <ResumeInputType> >
{
Name = "resume"
}
),
resolve: async context =>
{
//Guid id = context.GetArgument<Guid>("id");
Resume resume = context.GetArgument <Resume>("resume");
return(await context.TryAsyncResolve(
async c => await resumeBLL.UpdateResumeAsync(resume)
));
}
);
FieldAsync <ResumeType>(
"linkDocumentToResume",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <DocumentResumeInputType> >
{
Name = "documentResume"
}
),
resolve: async context =>
{
DocumentResume documentResume = context.GetArgument <DocumentResume>("documentResume");
return(await context.TryAsyncResolve(
async c => await resumeBLL.LinkDocumentToResumeAsync(documentResume)
));
}
);
FieldAsync <ResumeType>(
"unlinkDocumentFromResume",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <DocumentResumeInputType> >
{
Name = "documentResume"
}
),
resolve: async context =>
{
DocumentResume documentResume = context.GetArgument <DocumentResume>("documentResume");
return(await context.TryAsyncResolve(
async c => await resumeBLL.UnlinkDocumentFromResumeAsync(documentResume)
));
}
);
FieldAsync <ResumeType>(
"linkSkillToResume",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ResumeSkillInputType> >
{
Name = "resumeSkill"
}
),
resolve: async context =>
{
ResumeSkill resumeSkill = context.GetArgument <ResumeSkill>("resumeSkill");
return(await context.TryAsyncResolve(
async c => await resumeBLL.LinkSkillToResumeAsync(resumeSkill)
));
}
);
FieldAsync <ResumeType>(
"unlinkSkillFromResume",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ResumeSkillInputType> >
{
Name = "resumeSkill"
}
),
resolve: async context =>
{
ResumeSkill resumeSkill = context.GetArgument <ResumeSkill>("resumeSkill");
return(await context.TryAsyncResolve(
async c => await resumeBLL.UnlinkSkillFromResumeAsync(resumeSkill)
));
}
);
FieldAsync <ResumeType>(
"removeResume",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
return(await context.TryAsyncResolve(
async c => await resumeBLL.DeleteResumeByIdAsync(id)
));
}
);
// ResumeStates
FieldAsync <ResumeStateType>(
"createResumeState",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ResumeStateInputType> >
{
Name = "resumeState"
}
),
resolve: async context =>
{
ResumeState resumeState = context.GetArgument <ResumeState>("resumeState");
return(await context.TryAsyncResolve(
async c => await resumeStateBLL.CreateResumeStateAsync(resumeState)
));
}
);
FieldAsync <ResumeStateType>(
"updateResumeState",
arguments: new QueryArguments(
//new QueryArgument<NonNullGraphType<IdGraphType>>
//{
// Name = "id"
//},
new QueryArgument <NonNullGraphType <ResumeStateInputType> >
{
Name = "resumeState"
}
),
resolve: async context =>
{
//Guid id = context.GetArgument<Guid>("id");
ResumeState resumeState = context.GetArgument <ResumeState>("resumeState");
return(await context.TryAsyncResolve(
async c => await resumeStateBLL.UpdateResumeStateAsync(resumeState)
));
}
);
FieldAsync <ResumeStateType>(
"removeResumeState",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
return(await context.TryAsyncResolve(
async c => await resumeStateBLL.DeleteResumeStateByIdAsync(id)
));
}
);
// Skills
FieldAsync <SkillType>(
"createSkill",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <SkillInputType> >
{
Name = "skill"
}
),
resolve: async context =>
{
Skill skill = context.GetArgument <Skill>("skill");
return(await context.TryAsyncResolve(
async c => await skillBLL.CreateSkillAsync(skill)
));
}
);
FieldAsync <SkillType>(
"updateSkill",
arguments: new QueryArguments(
//new QueryArgument<NonNullGraphType<IdGraphType>>
//{
// Name = "id"
//},
new QueryArgument <NonNullGraphType <SkillInputType> >
{
Name = "skill"
}
),
resolve: async context =>
{
//Guid id = context.GetArgument<Guid>("id");
Skill skill = context.GetArgument <Skill>("skill");
return(await context.TryAsyncResolve(
async c => await skillBLL.UpdateSkillAsync(skill)
));
}
);
FieldAsync <SkillType>(
"linkResumeToSkill",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ResumeSkillInputType> >
{
Name = "resumeSkill"
}
),
resolve: async context =>
{
ResumeSkill resumeSkill = context.GetArgument <ResumeSkill>("resumeSkill");
return(await context.TryAsyncResolve(
async c => await skillBLL.LinkResumeToSkillAsync(resumeSkill)
));
}
);
FieldAsync <SkillType>(
"unlinkResumeFromSkill",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ResumeSkillInputType> >
{
Name = "resumeSkill"
}
),
resolve: async context =>
{
ResumeSkill resumeSkill = context.GetArgument <ResumeSkill>("resumeSkill");
return(await context.TryAsyncResolve(
async c => await skillBLL.UnlinkResumeFromSkillAsync(resumeSkill)
));
}
);
FieldAsync <SkillType>(
"linkJobToSkill",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <JobSkillInputType> >
{
Name = "jobSkill"
}
),
resolve: async context =>
{
JobSkill jobSkill = context.GetArgument <JobSkill>("jobSkill");
return(await context.TryAsyncResolve(
async c => await skillBLL.LinkJobToSkillAsync(jobSkill)
));
}
);
FieldAsync <SkillType>(
"unlinkJobFromSkill",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <JobSkillInputType> >
{
Name = "jobSkill"
}
),
resolve: async context =>
{
JobSkill jobSkill = context.GetArgument <JobSkill>("jobSkill");
return(await context.TryAsyncResolve(
async c => await skillBLL.UnlinkJobFromSkillAsync(jobSkill)
));
}
);
FieldAsync <SkillType>(
"removeSkill",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
return(await context.TryAsyncResolve(
async c => await skillBLL.DeleteSkillByIdAsync(id)
));
}
);
// SkillAliases
FieldAsync <SkillAliasType>(
"createSkillAlias",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <SkillAliasInputType> >
{
Name = "skillAlias"
}
),
resolve: async context =>
{
SkillAlias skillAlias = context.GetArgument <SkillAlias>("skillAlias");
return(await context.TryAsyncResolve(
async c => await skillAliasBLL.CreateSkillAliasAsync(skillAlias)
));
}
);
FieldAsync <SkillAliasType>(
"updateSkillAlias",
arguments: new QueryArguments(
//new QueryArgument<NonNullGraphType<IdGraphType>>
//{
// Name = "id"
//},
new QueryArgument <NonNullGraphType <SkillAliasInputType> >
{
Name = "skillAlias"
}
),
resolve: async context =>
{
//Guid id = context.GetArgument<Guid>("id");
SkillAlias skillAlias = context.GetArgument <SkillAlias>("skillAlias");
return(await context.TryAsyncResolve(
async c => await skillAliasBLL.UpdateSkillAliasAsync(skillAlias)
));
}
);
FieldAsync <SkillAliasType>(
"removeSkillAlias",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
return(await context.TryAsyncResolve(
async c => await skillAliasBLL.DeleteSkillAliasByIdAsync(id)
));
}
);
// Jobs
FieldAsync <JobType>(
"createJob",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <JobInputType> >
{
Name = "job"
}
),
resolve: async context =>
{
Job job = context.GetArgument <Job>("job");
return(await context.TryAsyncResolve(
async c => await jobBLL.CreateJobAsync(job)
));
}
);
FieldAsync <JobType>(
"updateJob",
arguments: new QueryArguments(
//new QueryArgument<NonNullGraphType<IdGraphType>>
//{
// Name = "id"
//},
new QueryArgument <NonNullGraphType <JobInputType> >
{
Name = "job"
}
),
resolve: async context =>
{
//Guid id = context.GetArgument<Guid>("id");
Job job = context.GetArgument <Job>("job");
return(await context.TryAsyncResolve(
async c => await jobBLL.UpdateJobAsync(job)
));
}
);
FieldAsync <JobType>(
"linkSkillToJob",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <JobSkillInputType> >
{
Name = "jobSkill"
}
),
resolve: async context =>
{
JobSkill jobSkill = context.GetArgument <JobSkill>("jobSkill");
return(await context.TryAsyncResolve(
async c => await jobBLL.LinkSkillToJobAsync(jobSkill)
));
}
);
FieldAsync <JobType>(
"unlinkSkillFromJob",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <JobSkillInputType> >
{
Name = "jobSkill"
}
),
resolve: async context =>
{
JobSkill jobSkill = context.GetArgument <JobSkill>("jobSkill");
return(await context.TryAsyncResolve(
async c => await jobBLL.UnlinkSkillFromJobAsync(jobSkill)
));
}
);
FieldAsync <JobType>(
"removeJob",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
return(await context.TryAsyncResolve(
async c => await jobBLL.DeleteJobByIdAsync(id)
));
}
);
// JobStates
FieldAsync <JobStateType>(
"createJobState",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <JobStateInputType> >
{
Name = "jobState"
}
),
resolve: async context =>
{
JobState jobState = context.GetArgument <JobState>("jobState");
return(await context.TryAsyncResolve(
async c => await jobStateBLL.CreateJobStateAsync(jobState)
));
}
);
FieldAsync <JobStateType>(
"updateJobState",
arguments: new QueryArguments(
//new QueryArgument<NonNullGraphType<IdGraphType>>
//{
// Name = "id"
//},
new QueryArgument <NonNullGraphType <JobStateInputType> >
{
Name = "jobState"
}
),
resolve: async context =>
{
//Guid id = context.GetArgument<Guid>("id");
JobState jobState = context.GetArgument <JobState>("jobState");
return(await context.TryAsyncResolve(
async c => await jobStateBLL.UpdateJobStateAsync(jobState)
));
}
);
FieldAsync <JobStateType>(
"removeJobState",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
return(await context.TryAsyncResolve(
async c => await jobStateBLL.DeleteJobStateByIdAsync(id)
));
}
);
}
/// <summary>
/// Deletes an existing resumestate record by Id.
/// </summary>
public async Task <ResumeState> DeleteResumeStateByIdAsync(Guid resumeStateId)
{
ResumeState resumeState = await this.resumeStateRepository.GetByIdAsync(resumeStateId);
return(await this.DeleteResumeStateAsync(resumeState));
}
public override string ReadLine()
{
// Send any commands that are queue before moving on to the internal stream.
string nextCommand = queuedCommands.ReadLine();
if (nextCommand != null)
{
return(nextCommand);
}
switch (resumeState)
{
// heat the extrude to remove it from the part
case ResumeState.RemoveHeating:
// TODO: make sure we heat up all the extruders that we need to (all that are used)
queuedCommands.Add("G21; set units to millimeters");
queuedCommands.Add("M107; fan off");
queuedCommands.Add("T0; set the active extruder to 0");
queuedCommands.Add("G90; use absolute coordinates");
queuedCommands.Add("G92 E0; reset the expected extruder position");
queuedCommands.Add("M82; use absolute distance for extrusion");
queuedCommands.Add("M109 S{0}".FormatWith(ActiveSliceSettings.Instance.Helpers.ExtruderTemperature(0)));
resumeState = ResumeState.Raising;
return("");
// remove it from the part
case ResumeState.Raising:
queuedCommands.Add("M114 ; get current position");
queuedCommands.Add("G91 ; move relative");
queuedCommands.Add("G1 Z10 F{0}".FormatWith(MovementControls.ZSpeed));
queuedCommands.Add("G90 ; move absolute");
resumeState = ResumeState.Homing;
return("");
// if top homing, home the extruder
case ResumeState.Homing:
if (ActiveSliceSettings.Instance.GetValue <bool>(SettingsKey.z_homes_to_max))
{
queuedCommands.Add("G28");
}
else
{
// home x
queuedCommands.Add("G28 X0");
// home y
queuedCommands.Add("G28 Y0");
// move to the place we can home z from
Vector2 resumePositionXy = ActiveSliceSettings.Instance.GetValue <Vector2>(SettingsKey.resume_position_before_z_home);
queuedCommands.Add("G1 X{0:0.000}Y{1:0.000}F{2}".FormatWith(resumePositionXy.x, resumePositionXy.y, MovementControls.XSpeed));
// home z
queuedCommands.Add("G28 Z0");
}
resumeState = ResumeState.FindingResumeLayer;
return("");
// This is to resume printing if an out a filament occurs.
// Help the user move the extruder down to just touching the part
case ResumeState.FindingResumeLayer:
if (false) // help the user get the head to the right position
{
// move to above the completed print
// move over a know good part of the model at the current top layer (extrude vertex from gcode)
// let the user move down until they like the height
// calculate that position and continue
}
else // we are resuming because of disconnect or reset, skip this
{
resumeState = ResumeState.SkippingGCode;
goto case ResumeState.SkippingGCode;
}
case ResumeState.SkippingGCode:
// run through the gcode that the device expected looking for things like temp
// and skip everything else until we get to the point we left off last time
int commandCount = 0;
boundsOfSkippedLayers = RectangleDouble.ZeroIntersection;
while (internalStream.FileStreaming.PercentComplete(internalStream.LineIndex) < percentDone)
{
string line = internalStream.ReadLine();
commandCount++;
// make sure we don't parse comments
if (line.Contains(";"))
{
line = line.Split(';')[0];
}
lastDestination = GetPosition(line, lastDestination);
if (commandCount > 100)
{
boundsOfSkippedLayers.ExpandToInclude(lastDestination.position.Xy);
if (boundsOfSkippedLayers.Bottom < 10)
{
int a = 0;
}
}
// check if the line is something we want to send to the printer (like a temp)
if (line.StartsWith("M109") ||
line.StartsWith("M104") ||
line.StartsWith("T") ||
line.StartsWith("M106") ||
line.StartsWith("M107"))
{
return(line);
}
}
resumeState = ResumeState.PrimingAndMovingToStart;
// make sure we always- pick up the last movement
boundsOfSkippedLayers.ExpandToInclude(lastDestination.position.Xy);
return("");
case ResumeState.PrimingAndMovingToStart:
{
if (ActiveSliceSettings.Instance.GetValue("z_homes_to_max") == "0") // we are homed to the bed
{
// move to the height we can resume printing from
Vector2 resumePositionXy = ActiveSliceSettings.Instance.GetValue <Vector2>(SettingsKey.resume_position_before_z_home);
queuedCommands.Add(CreateMovementLine(new PrinterMove(new VectorMath.Vector3(resumePositionXy.x, resumePositionXy.y, lastDestination.position.z), 0, MovementControls.ZSpeed)));
}
double extruderWidth = ActiveSliceSettings.Instance.GetValue <double>(SettingsKey.nozzle_diameter);
// move to a position outside the printed bounds
queuedCommands.Add(CreateMovementLine(new PrinterMove(
new Vector3(boundsOfSkippedLayers.Left - extruderWidth * 2, boundsOfSkippedLayers.Bottom + boundsOfSkippedLayers.Height / 2, lastDestination.position.z),
0, MovementControls.XSpeed)));
// let's prime the extruder
queuedCommands.Add("G1 E10 F{0}".FormatWith(MovementControls.EFeedRate(0))); // extrude 10
queuedCommands.Add("G1 E9"); // and retract a bit
// move to the actual print position
queuedCommands.Add(CreateMovementLine(new PrinterMove(lastDestination.position, 0, MovementControls.XSpeed)));
/// reset the printer to know where the filament should be
queuedCommands.Add("G92 E{0}".FormatWith(lastDestination.extrusion));
resumeState = ResumeState.PrintingSlow;
}
return("");
case ResumeState.PrintingSlow:
{
string lineToSend = internalStream.ReadLine();
if (lineToSend == null)
{
return(null);
}
if (!GCodeFile.IsLayerChange(lineToSend))
{
// have not seen the end of this layer so keep printing slow
if (LineIsMovement(lineToSend))
{
PrinterMove currentMove = GetPosition(lineToSend, lastDestination);
PrinterMove moveToSend = currentMove;
moveToSend.feedRate = resumeFeedRate;
lineToSend = CreateMovementLine(moveToSend, lastDestination);
lastDestination = currentMove;
return(lineToSend);
}
return(lineToSend);
}
}
// we only fall through to here after seeing the next "; Layer:"
resumeState = ResumeState.PrintingToEnd;
return("");
case ResumeState.PrintingToEnd:
return(internalStream.ReadLine());
}
return(null);
}
