public async Task <ActionResult <ResumeVM> > UnlinkSkillFromResume([FromBody] ResumeSkill resumeSkill)
{
// Validation
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Resume resume = await this.bll.UnlinkSkillFromResumeAsync(resumeSkill);
// Mapping
return(Ok(this.mapper.Map <Resume, ResumeVM>(resume)));
}
public async Task <ActionResult <SkillVM> > UnlinkResumeFromSkill([FromBody] ResumeSkill resumeSkill)
{
// Validation
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Skill skill = await this.bll.UnlinkResumeFromSkillAsync(resumeSkill);
// Mapping
return(Ok(this.mapper.Map <Skill, SkillVM>(skill)));
}
public async Task <Skill> UnlinkResumeFromSkillAsync(ResumeSkill resumeSkill)
{
// Validation
if (resumeSkill == null)
{
return(null);
}
// Retrieve existing link
ResumeSkill resumeSkillLink = this.resumeSkillRepository.GetBySkillAndResumeId(resumeSkill.SkillId, resumeSkill.ResumeId);
if (resumeSkillLink != null)
{
await this.resumeSkillRepository.DeleteAsync(resumeSkillLink);
}
return(await this.GetSkillByIdAsync(resumeSkill.SkillId));
}
public static List <ResumeSkill> DeserializeSkill(HtmlDocument document)
{
var resumeSkills = new List <ResumeSkill>();
var node = document.DocumentNode.SelectSingleNode("//h3[text()='专业技能']");
var skillStr = node?.ParentNode?.SelectSingleNode("./div[1]")?.InnerHtml;
if (!string.IsNullOrWhiteSpace(skillStr))
{
skillStr = skillStr.Replace("\r\n", "");
var skills = Regex.Split(skillStr, "<br>");
if (skills.Length > 0)
{
resumeSkills.AddRange(from skill in skills where skill.Contains("|") select skill.Split('：') into skllArr where skllArr.Length == 2 select new ResumeSkill {
Name = skllArr[0], Level = skllArr[1]
});
}
}
node = document.DocumentNode.SelectSingleNode("//h3[text()='语言能力']");
var langStr = node?.ParentNode?.SelectSingleNode("./div[1]")?.InnerHtml;
if (!string.IsNullOrWhiteSpace(langStr))
{
langStr = langStr.Replace("\r\n", "");
var langs = Regex.Split(langStr, "<br>");
if (langs != null && langs.Length > 0)
{
foreach (var lang in langs)
{
var langArr = lang.Split('：');
if (langArr.Length > 1)
{
var resumeSkill = new ResumeSkill {
Name = langArr[0], Level = langArr[1]
};
resumeSkills.Add(resumeSkill);
}
}
}
}
return(resumeSkills);
}
public async Task <Skill> LinkResumeToSkillAsync(ResumeSkill resumeSkill)
{
// Validation
if (resumeSkill == null)
{
return(null);
}
// Check if skill exists
Skill skill = await this.skillRepository.GetByIdAsync(resumeSkill.SkillId);
if (skill == null)
{
return(null);
}
// Check if resume exists
Resume resume = await this.resumeRepository.GetByIdAsync(resumeSkill.ResumeId);
if (resume == null)
{
return(null);
}
// Retrieve existing link
ResumeSkill resumeSkillLink = this.resumeSkillRepository.GetBySkillAndResumeId(resumeSkill.SkillId, resumeSkill.ResumeId);
if (resumeSkillLink == null)
{
await this.resumeSkillRepository.InsertAsync(resumeSkill);
}
else
{
// Mapping of fields on many-to-many
resumeSkillLink.Level = resumeSkill.Level;
resumeSkillLink.Description = resumeSkill.Description;
await this.resumeSkillRepository.UpdateAsync(resumeSkillLink);
}
return(await this.GetSkillByIdAsync(resumeSkill.SkillId));
}
public static SourceResume ConvertTo_Dtl_V5(string content)
{
var dto = new SourceResume();
var source = JsonConvert.DeserializeObject <dynamic>(content);
dto.Id = source.resumeNo;
var Dtl = JsonConvert.DeserializeObject <dynamic>(source.detialJSonStr.ToString());
if (source.userDetials != null)
{
dto.Name = source.userDetials.userName;
dto.Gender = source.userDetials.gender;
dto.MaritalStatus = source.userDetials.maritalStatus;
dto.Cellphone = source.userDetials.mobilePhone;
dto.Email = source.userDetials.email;
dto.Birthday = source.userDetials.birthStr;
dto.CurrentResidence = source.userDetials.cityId;
dto.RegisteredResidenc = source.userDetials.hUKOUCityId;
}
else
{
dto.Name = Dtl.UserMasterName;
dto.Gender = Dtl.Gender;
dto.MaritalStatus = Dtl.MaritalStatus;
dto.Birthday = Dtl.BirthYear;
}
dto.ResumeId = Dtl.ResumeId;
dto.ResumeName = Dtl.Name;
dto.UserMasterId = Dtl.UserMasterId;
dto.UserMasterExtId = Dtl.UserMasterExtId;
dto.ResumeNumber = Dtl.ResumeNumber;
dto.WorkStarts = Dtl.WorkYearsRangeId;
dto.Degree = Dtl.CurrentEducationLevel;
dto.JobStatus = Dtl.DesiredPosition[0].CurrentCareerStatus;
dto.Intention = new ResumeIntention();
if (Dtl.DesiredPosition != null && Dtl.DesiredPosition.Count > 0)
{
dto.Intention.JobType = Dtl.DesiredPosition[0].DesiredEmploymentType;
dto.Intention.Salary = Dtl.DesiredPosition[0].DesiredSalaryScope;
dto.Intention.Industry = Dtl.DesiredPosition[0].DesiredIndustry;
dto.Intention.Function = Dtl.DesiredPosition[0].DesiredJobType;
dto.Intention.Location = Dtl.DesiredPosition[0].DesiredCity;
}
else
{
dto.Intention.JobType = "默认";
dto.Intention.Salary = "面议";
dto.Intention.Industry = "默认";
dto.Intention.Function = "中国";
dto.Intention.Location = "中国";
}
if (Dtl.SelfEvaluate != null && Dtl.SelfEvaluate.Count > 0)
{
dto.Intention.Evaluation = Dtl.SelfEvaluate[0]?.CommentContent;
}
else
{
dto.Intention.Evaluation = "";
}
#region 工作经验
if (Dtl.WorkExperience != null && Dtl.WorkExperience.Count > 0)
{
dto.Works = new List <ResumeWork>();
foreach (var o in Dtl.WorkExperience)
{
var work = new ResumeWork();
work.Begin = o.DateStart;
work.End = o.DateEnd;
work.Company = o.CompanyName;
work.Industry = o.CompanyIndustry;
work.Size = o.CompanySize;
work.Nature = o.CompanyProperty;
work.Department = o.ResideDepartment;
work.Position = o.JobTitle;
work.Description = o.WorkDescription;
dto.Works.Add(work);
}
}
#endregion
#region 项目经验
if (Dtl.ProjectExperience != null && Dtl.ProjectExperience.Count > 0)
{
dto.Projects = new List <ResumeProject>();
foreach (var o in Dtl.ProjectExperience)
{
var project = new ResumeProject();
project.Begin = o.DateStart;
project.End = o.DateEnd;
project.Company = "";
project.Name = o.ProjectName;
project.Description = o.ProjectDescription;
project.Duty = o.ProjectResponsibility;
dto.Projects.Add(project);
}
}
#endregion
#region 教育经历
if (Dtl.EducationExperience != null && Dtl.EducationExperience.Count > 0)
{
dto.Educations = new List <ResumeEducation>();
foreach (var o in Dtl.EducationExperience)
{
var edu = new ResumeEducation();
edu.Begin = o.DateStart;
edu.End = o.DateEnd;
edu.School = o.SchoolName;
edu.Degree = o.EducationLevel;
edu.Description = "";
edu.Major = o.MajorName;
dto.Educations.Add(edu);
}
}
#endregion
#region 培训经历
if (Dtl.Training != null && Dtl.Training.Count > 0)
{
dto.Trainings = new List <ResumeTraining>();
foreach (var o in Dtl.Training)
{
var train = new ResumeTraining();
train.Begin = o.DateStart;
train.End = o.DateEnd;
train.Course = o.Course;
train.Institution = o.Institution;
train.Description = o.TrainingDescription;
train.Location = o.Location;
dto.Trainings.Add(train);
}
}
#endregion
#region 技能/语言
if (Dtl.ProfessionnalSkill != null && Dtl.ProfessionnalSkill.Count > 0)
{
dto.Skills = new List <ResumeSkill>();
foreach (var o in Dtl.ProfessionnalSkill)
{
var skill = new ResumeSkill {
Name = o.SkillName, Level = o.MasterDegree.ToString() + "|" + o.UsedMonths.ToString() + "个月", Description = ""
};
dto.Skills.Add(skill);
}
}
if (Dtl.LanguageSkill != null && Dtl.LanguageSkill.Count > 0)
{
if (dto.Skills == null)
{
dto.Skills = new List <ResumeSkill>();
}
foreach (var o in Dtl.LanguageSkill)
{
var skill = new ResumeSkill {
Name = o.LanguageName, Level = "听说" + o.HearSpeakSkill.ToString() + "|读写" + o.ReadWriteSkill.ToString(), Description = ""
};
dto.Skills.Add(skill);
}
}
#endregion
#region 证书
if (Dtl.AchieveCertificate != null && Dtl.AchieveCertificate.Count > 0)
{
dto.Certificates = new List <ResumeCertificate>();
foreach (var o in Dtl.AchieveCertificate)
{
try
{
var cert = new ResumeCertificate {
Time = Convert.ToDateTime(o.AchieveDate), CertName = o.CertificateName, Description = o.CertificateDescription
};
dto.Certificates.Add(cert);
}
catch
{
// ignored
}
}
}
#endregion
#region 校内荣誉
if (Dtl.AchieveAward != null && Dtl.AchieveAward.Count > 0)
{
dto.Honors = new List <SchoolHonor>();
foreach (var o in Dtl.AchieveAward)
{
try
{
var cert = new SchoolHonor {
Time = o.AchieveDate, Honor = o.AwardName, Description = o.Description
};
dto.Honors.Add(cert);
}
catch
{
// ignored
}
}
}
#endregion
#region 校内实践
if (Dtl.PracticeExperience != null && Dtl.PracticeExperience.Count > 0)
{
dto.Practices = new List <SchoolPractice>();
foreach (var o in Dtl.PracticeExperience)
{
try
{
var cert = new SchoolPractice {
Name = o.PracticeName, Begin = o.DateStart, End = o.DateEnd, Description = o.PracticeDescription
};
dto.Practices.Add(cert);
}
catch
{
// ignored
}
}
}
#endregion
#region 其他
if (Dtl.Other != null && Dtl.Other.Count > 0)
{
dto.Others = new List <OtherInfo>();
foreach (var o in Dtl.Other)
{
try
{
var cert = new OtherInfo {
Title = o.Name, Description = o.Description
};
dto.Others.Add(cert);
}
catch
{
// ignored
}
}
}
#endregion
return(dto);
}
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)
));
}
);
}
