/// <summary>
/// Creates a new skillalias record.
/// </summary>
public async Task <SkillAlias> CreateSkillAliasAsync(SkillAlias skillAlias)
{
// Validation
if (skillAlias == null)
{
return(null);
}
// Trimming strings
if (!string.IsNullOrEmpty(skillAlias.Name))
{
skillAlias.Name = skillAlias.Name.Trim();
}
if (!string.IsNullOrEmpty(skillAlias.Description))
{
skillAlias.Description = skillAlias.Description.Trim();
}
// #-#-# {D4775AF3-4BFA-496A-AA82-001028A22DD6}
// Before creation
// #-#-#
skillAlias = await this.skillAliasRepository.InsertAsync(skillAlias);
// #-#-# {1972C619-D2F2-48FD-8474-3A69621B1F78}
// After creation
// #-#-#
return(skillAlias);
}
/// <summary>
/// To create a newskill alias
/// </summary>
/// <param name="skillAliasObj">SkillAlias Object</param>
public void Post(SkillAlias skillAliasObj)
{
try
{
ServiceFactory.GetSkillAlias().Create(skillAliasObj);
}
catch (Exception ex) {}
}
/// <summary>
/// To update Skill Alias details
/// </summary>
/// <param name="id">skillAliasId</param>
/// <param name="skillAliasObj">SkillAlias Object</param>
public void Put(string id, SkillAlias skillAliasObj)
{
try
{
skillAliasObj.Id = new Guid(id);
ServiceFactory.GetSkillAlias().Update(skillAliasObj);
}
catch (Exception exp) {}
}
public async Task <ActionResult <SkillAliasVM> > GetSkillAlias([FromRoute] Guid id)
{
SkillAlias skillalias = await this.bll.GetSkillAliasByIdAsync(id);
if (skillalias == null)
{
return(NotFound());
}
// Mapping
return(Ok(this.mapper.Map <SkillAlias, SkillAliasVM>(skillalias)));
}
public async Task <ActionResult <SkillAliasVM> > DeleteSkillAlias([FromRoute] Guid id)
{
// Retrieve existing skillalias
SkillAlias skillalias = await this.bll.GetSkillAliasByIdAsync(id);
if (skillalias == null)
{
return(NotFound());
}
await this.bll.DeleteSkillAliasAsync(skillalias);
// Mapping
return(Ok(this.mapper.Map <SkillAlias, SkillAliasVM>(skillalias)));
}
public async Task <ActionResult <SkillAliasVM> > UpdateSkillAlias([FromRoute] Guid id, [FromBody] SkillAliasVM skillAliasVM)
{
// Validation
if (!ModelState.IsValid || id != skillAliasVM.Id)
{
return(BadRequest(ModelState));
}
// Mapping
SkillAlias skillAlias = this.mapper.Map <SkillAliasVM, SkillAlias>(skillAliasVM);
skillAlias = await this.bll.UpdateSkillAliasAsync(skillAlias);
// Mapping
return(Ok(this.mapper.Map <SkillAlias, SkillAliasVM>(skillAlias)));
}
/// <summary>
/// Updates an existing skillalias record by Id.
/// </summary>
public async Task <SkillAlias> UpdateSkillAliasAsync(SkillAlias skillAliasUpdate)
{
// Validation
if (skillAliasUpdate == null)
{
return(null);
}
// Retrieve existing
SkillAlias skillAlias = await this.skillAliasRepository.GetByIdAsync(skillAliasUpdate.Id);
if (skillAlias == null)
{
return(null);
}
// Trimming strings
if (!string.IsNullOrEmpty(skillAliasUpdate.Name))
{
skillAliasUpdate.Name = skillAliasUpdate.Name.Trim();
}
if (!string.IsNullOrEmpty(skillAliasUpdate.Description))
{
skillAliasUpdate.Description = skillAliasUpdate.Description.Trim();
}
// Mapping
skillAlias.Name = skillAliasUpdate.Name;
skillAlias.Description = skillAliasUpdate.Description;
skillAlias.SkillId = skillAliasUpdate.SkillId;
// #-#-# {B5914243-E57E-41AE-A7C8-553F2F93267B}
// Before update
// #-#-#
skillAlias = await this.skillAliasRepository.UpdateAsync(skillAlias);
// #-#-# {983B1B6C-14A7-4925-8571-D77447DF0ADA}
// After update
// #-#-#
return(skillAlias);
}
public async Task <ActionResult <SkillAliasVM> > CreateSkillAlias([FromBody] SkillAliasVM skillaliasVM)
{
// Validation
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Mapping
SkillAlias skillalias = this.mapper.Map <SkillAliasVM, SkillAlias>(skillaliasVM);
skillalias = await this.bll.CreateSkillAliasAsync(skillalias);
// Mapping
return(CreatedAtAction(
"GetSkillAlias",
new { id = skillalias.Id },
this.mapper.Map <SkillAlias, SkillAliasVM>(skillalias)
));
}
/// <summary>
/// Deletes an existing skillalias record.
/// </summary>
public async Task <SkillAlias> DeleteSkillAliasAsync(SkillAlias skillAlias)
{
// Validation
if (skillAlias == null)
{
return(null);
}
// #-#-# {FE1A99E0-482D-455B-A8C1-3C2C11FACA58}
// Before deletion
// #-#-#
await this.skillAliasRepository.DeleteAsync(skillAlias);
// #-#-# {F09857C0-44E7-4E6C-B3E6-883C0D28E1A6}
// After deletion
// #-#-#
return(skillAlias);
}
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 skillalias record by Id.
/// </summary>
public async Task <SkillAlias> DeleteSkillAliasByIdAsync(Guid skillAliasId)
{
SkillAlias skillAlias = await this.skillAliasRepository.GetByIdAsync(skillAliasId);
return(await this.DeleteSkillAliasAsync(skillAlias));
}
