/// <summary>
/// The constructor of the Document business logic layer.
/// </summary>
public DocumentBLL(
IConfiguration configuration,
ILogger <DocumentBLL> logger,
IHttpContextAccessor httpContextAccessor,
UserManager <User> userManager,
FileService fileService,
RabbitMQService rabbitMQService,
DocumentRepository documentRepository,
DocumentTypeRepository documentTypeRepository,
ResumeBLL resumeBLL,
ResumeRepository resumeRepository,
DocumentResumeRepository documentResumeRepository
)
{
this.configuration = configuration;
this.logger = logger;
this.httpContextAccessor = httpContextAccessor;
this.userManager = userManager;
this.fileService = fileService;
this.rabbitMQService = rabbitMQService;
this.documentRepository = documentRepository;
this.documentTypeRepository = documentTypeRepository;
this.resumeBLL = resumeBLL;
this.resumeRepository = resumeRepository;
this.documentResumeRepository = documentResumeRepository;
}
/// <summary>
/// The constructor of the Resume business logic layer.
/// </summary>
public ResumeBLL(
IConfiguration configuration,
ILogger <DocumentBLL> logger,
IHttpContextAccessor httpContextAccessor,
UserManager <User> userManager,
ResumeRepository resumeRepository,
ResumeStateRepository resumeStateRepository,
ResumeSkillRepository resumeSkillRepository,
DocumentResumeRepository documentResumeRepository,
DocumentRepository documentRepository,
SkillRepository skillRepository
)
{
this.configuration = configuration;
this.logger = logger;
this.httpContextAccessor = httpContextAccessor;
this.userManager = userManager;
this.resumeRepository = resumeRepository;
this.resumeStateRepository = resumeStateRepository;
this.resumeSkillRepository = resumeSkillRepository;
this.documentResumeRepository = documentResumeRepository;
this.documentRepository = documentRepository;
this.skillRepository = skillRepository;
}
public ResumeStateType(
ResumeRepository resumeRepository,
ResumeStateRepository resumeStateRepository
)
{
Field(x => x.Id, type: typeof(IdGraphType));
Field(x => x.Name);
Field(x => x.DisplayName);
Field <ListGraphType <ResumeType> >(
"resumes",
resolve: context => resumeRepository.GetByResumeStateId(context.Source.Id)
);
//// Async test
//FieldAsync<ListGraphType<ResumeType>>(
// "resumes",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await resumeRepository.GetByResumeStateIdAsync(context.Source.Id)
// );
// }
//);
Field(x => x.CreatedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.CreatedByUser, type: typeof(UserType));
Field(x => x.ModifiedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.ModifiedByUser, type: typeof(UserType));
}
public ActionResult Login(IFormCollection colle)
{
//and passing de db context to be used there.
var UserLogin = new UserRepository(_db);
var User = UserLogin.Login(colle["username"], colle["password"]);
//sample step check to see if the user is an adm or not, be an adm unlock the whole menu
if (User.Permition_Id > 0)
{
//passing values about the user to the session
string data = $"{User.UserName}_" +
$"{User.User_Id}_" +
$"{User.Permition.Permition_Type}_";
//setting the session name and value
HttpContext.Session.SetString("Loged", data);
/*instance of resumerepository where contains methods which one bring all informations
* about an specific user*/
var resume = new ResumeRepository(_db);
//sending resume informations to the view by viewdata
ViewData["resume"] = resume.GetResume(HttpContext);
//returning view
return(View("~/Views/Home/Index.cshtml"));
}
else
{
TempData["erro"] = "fail";
return(View("~/Views/User/Index.cshtml"));
}
}
public ResumeAdderForm(DataService service, Applicant applicant)
{
this.service = service;
this.applicant = applicant;
this.appRepos = new ApplicantRepository(this.service);
this.empRepos = new EmployerRepository(this.service);
this.vacRepos = new VacancyRepository(this.service);
this.resRepos = new ResumeRepository(this.service);
this.reqRepos = new RequestRepository(this.service);
InitializeComponent();
}
public async Task GetResume()
{
// Arrange
var repo = new ResumeRepository();
// Act
var result = await repo.GetResume();
// Assert
Assert.Equal("Derek", result.FirstName);
}
public VacancyEditorForm(DataService service, Employer employer, Vacancy vacancy)
{
this.service = service;
this.employer = employer;
this.vacancy = vacancy;
this.appRepos = new ApplicantRepository(this.service);
this.empRepos = new EmployerRepository(this.service);
this.vacRepos = new VacancyRepository(this.service);
this.resRepos = new ResumeRepository(this.service);
this.reqRepos = new RequestRepository(this.service);
InitializeComponent();
}
/// <summary>
/// The constructor of the Skill business logic layer.
/// </summary>
public SkillBLL(
SkillRepository skillRepository,
ResumeRepository resumeRepository,
ResumeSkillRepository resumeSkillRepository,
JobRepository jobRepository,
JobSkillRepository jobSkillRepository
)
{
this.skillRepository = skillRepository;
this.resumeRepository = resumeRepository;
this.resumeSkillRepository = resumeSkillRepository;
this.jobRepository = jobRepository;
this.jobSkillRepository = jobSkillRepository;
}
public EmployerMainForm(DataService service, Employer employer)
{
this.service = service;
this.employer = employer;
this.appRepos = new ApplicantRepository(this.service);
this.empRepos = new EmployerRepository(this.service);
this.vacRepos = new VacancyRepository(this.service);
this.resRepos = new ResumeRepository(this.service);
this.reqRepos = new RequestRepository(this.service);
this.vacancies = vacRepos.VacanciesByLogin(this.employer.Login);
this.resumes = resRepos.ShownResumes();
this.requests = reqRepos.RequestsByEmployer(vacRepos, this.employer.Login);
InitializeComponent();
}
public ApplicantMainForm(DataService service, Applicant applicant)
{
this.service = service;
this.applicant = applicant;
this.appRepos = new ApplicantRepository(this.service);
this.empRepos = new EmployerRepository(this.service);
this.vacRepos = new VacancyRepository(this.service);
this.resRepos = new ResumeRepository(this.service);
this.reqRepos = new RequestRepository(this.service);
this.resumes = resRepos.ResumesByLogin(this.applicant.Login);
this.vacancies = vacRepos.ShownVacancies();
this.requests = reqRepos.RequestByApplicant(this.resRepos, this.applicant.Login);
InitializeComponent();
}
public IActionResult Index()
{
if (string.IsNullOrEmpty(HttpContext.Session.GetString("Loged")))
{
return(View("~/Views/User/Index.cshtml"));
}
else
{
/*instance of resumerepository where contains methods which one bring all informations
* about an specific user*/
var resume = new ResumeRepository(_db);
//sending resume informations to the view by viewdata
ViewData["resume"] = resume.GetResume(HttpContext);
//returning view
return(View());
}
}
public ResumeBusiness(IServiceProvider provider, ResumeRepository repository) : base(provider, repository)
{
_resumeRepository = repository;
}
public RJMQuery(
DocumentRepository documentRepository,
DocumentTypeRepository documentTypeRepository,
ResumeRepository resumeRepository,
ResumeStateRepository resumeStateRepository,
SkillRepository skillRepository,
SkillAliasRepository skillAliasRepository,
JobRepository jobRepository,
JobStateRepository jobStateRepository
)
{
this.AuthorizeWith("Authorized");
// Documents
Field <ListGraphType <DocumentType> >(
"documents",
resolve: context => documentRepository.Get(null, x => x.OrderByDescending(x => x.ModifiedOn))
);
//// Async test
//FieldAsync<ListGraphType<DocumentType>>(
// "documents",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await documentRepository.GetAsync(null, x => x.OrderByDescending(x => x.ModifiedOn))
// );
// }
//);
Field <DocumentType>(
"document",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "id"
}),
resolve: context => documentRepository.GetById(context.GetArgument <Guid>("id"))
);
//// Async test
//FieldAsync<DocumentType>(
// "document",
// arguments: new QueryArguments(new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "id" }),
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await documentRepository.GetByIdAsync(context.GetArgument<Guid>("id"))
// );
// }
//);
// DocumentTypes
Field <ListGraphType <DocumentTypeType> >(
"documentTypes",
resolve: context => documentTypeRepository.Get(null, x => x.OrderByDescending(x => x.ModifiedOn))
);
//// Async test
//FieldAsync<ListGraphType<DocumentTypeType>>(
// "documentTypes",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await documentTypeRepository.GetAsync(null, x => x.OrderByDescending(x => x.ModifiedOn))
// );
// }
//);
Field <DocumentTypeType>(
"documentType",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "id"
}),
resolve: context => documentTypeRepository.GetById(context.GetArgument <Guid>("id"))
);
//// Async test
//FieldAsync<DocumentTypeType>(
// "documentType",
// arguments: new QueryArguments(new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "id" }),
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await documentTypeRepository.GetByIdAsync(context.GetArgument<Guid>("id"))
// );
// }
//);
// Resumes
Field <ListGraphType <ResumeType> >(
"resumes",
resolve: context => resumeRepository.Get(null, x => x.OrderByDescending(x => x.ModifiedOn))
);
//// Async test
//FieldAsync<ListGraphType<ResumeType>>(
// "resumes",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await resumeRepository.GetAsync(null, x => x.OrderByDescending(x => x.ModifiedOn))
// );
// }
//);
Field <ResumeType>(
"resume",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "id"
}),
resolve: context => resumeRepository.GetById(context.GetArgument <Guid>("id"))
);
//// Async test
//FieldAsync<ResumeType>(
// "resume",
// arguments: new QueryArguments(new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "id" }),
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await resumeRepository.GetByIdAsync(context.GetArgument<Guid>("id"))
// );
// }
//);
// ResumeStates
Field <ListGraphType <ResumeStateType> >(
"resumeStates",
resolve: context => resumeStateRepository.Get(null, x => x.OrderByDescending(x => x.ModifiedOn))
);
//// Async test
//FieldAsync<ListGraphType<ResumeStateType>>(
// "resumeStates",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await resumeStateRepository.GetAsync(null, x => x.OrderByDescending(x => x.ModifiedOn))
// );
// }
//);
Field <ResumeStateType>(
"resumeState",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "id"
}),
resolve: context => resumeStateRepository.GetById(context.GetArgument <Guid>("id"))
);
//// Async test
//FieldAsync<ResumeStateType>(
// "resumeState",
// arguments: new QueryArguments(new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "id" }),
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await resumeStateRepository.GetByIdAsync(context.GetArgument<Guid>("id"))
// );
// }
//);
// Skills
Field <ListGraphType <SkillType> >(
"skills",
resolve: context => skillRepository.Get(null, x => x.OrderByDescending(x => x.ModifiedOn))
);
//// Async test
//FieldAsync<ListGraphType<SkillType>>(
// "skills",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await skillRepository.GetAsync(null, x => x.OrderByDescending(x => x.ModifiedOn))
// );
// }
//);
Field <SkillType>(
"skill",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "id"
}),
resolve: context => skillRepository.GetById(context.GetArgument <Guid>("id"))
);
//// Async test
//FieldAsync<SkillType>(
// "skill",
// arguments: new QueryArguments(new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "id" }),
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await skillRepository.GetByIdAsync(context.GetArgument<Guid>("id"))
// );
// }
//);
// SkillAliases
Field <ListGraphType <SkillAliasType> >(
"skillAliases",
resolve: context => skillAliasRepository.Get(null, x => x.OrderByDescending(x => x.ModifiedOn))
);
//// Async test
//FieldAsync<ListGraphType<SkillAliasType>>(
// "skillAliases",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await skillAliasRepository.GetAsync(null, x => x.OrderByDescending(x => x.ModifiedOn))
// );
// }
//);
Field <SkillAliasType>(
"skillAlias",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "id"
}),
resolve: context => skillAliasRepository.GetById(context.GetArgument <Guid>("id"))
);
//// Async test
//FieldAsync<SkillAliasType>(
// "skillAlias",
// arguments: new QueryArguments(new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "id" }),
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await skillAliasRepository.GetByIdAsync(context.GetArgument<Guid>("id"))
// );
// }
//);
// Jobs
Field <ListGraphType <JobType> >(
"jobs",
resolve: context => jobRepository.Get(null, x => x.OrderByDescending(x => x.ModifiedOn))
);
//// Async test
//FieldAsync<ListGraphType<JobType>>(
// "jobs",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await jobRepository.GetAsync(null, x => x.OrderByDescending(x => x.ModifiedOn))
// );
// }
//);
Field <JobType>(
"job",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "id"
}),
resolve: context => jobRepository.GetById(context.GetArgument <Guid>("id"))
);
//// Async test
//FieldAsync<JobType>(
// "job",
// arguments: new QueryArguments(new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "id" }),
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await jobRepository.GetByIdAsync(context.GetArgument<Guid>("id"))
// );
// }
//);
// JobStates
Field <ListGraphType <JobStateType> >(
"jobStates",
resolve: context => jobStateRepository.Get(null, x => x.OrderByDescending(x => x.ModifiedOn))
);
//// Async test
//FieldAsync<ListGraphType<JobStateType>>(
// "jobStates",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await jobStateRepository.GetAsync(null, x => x.OrderByDescending(x => x.ModifiedOn))
// );
// }
//);
Field <JobStateType>(
"jobState",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "id"
}),
resolve: context => jobStateRepository.GetById(context.GetArgument <Guid>("id"))
);
//// Async test
//FieldAsync<JobStateType>(
// "jobState",
// arguments: new QueryArguments(new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "id" }),
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await jobStateRepository.GetByIdAsync(context.GetArgument<Guid>("id"))
// );
// }
//);
}
public ResumeController(ResumeRepository resumeRepository, IFileProvider[] fileProviders, UserRepository userRepository) :
base(userRepository, fileProviders)
{
this.resumeRepository = resumeRepository;
}
public ResumeType(
ResumeStateRepository resumeStateRepository,
ResumeRepository resumeRepository,
DocumentRepository documentRepository,
DocumentResumeRepository documentResumeRepository,
SkillRepository skillRepository,
ResumeSkillRepository resumeSkillRepository
)
{
Field(x => x.Id, type: typeof(IdGraphType));
Field(x => x.Name);
Field(x => x.DisplayName);
Field(x => x.JobTitle, nullable: true);
Field(x => x.Description, nullable: true);
Field <ResumeStateType>(
"resumeState",
resolve: context =>
{
if (context.Source.ResumeStateId != null)
{
return(resumeStateRepository.GetById((Guid)context.Source.ResumeStateId));
}
return(null);
}
);
//// Async test
//FieldAsync<ResumeStateType>(
// "resumeState",
// resolve: async context =>
// {
// if (context.Source.ResumeStateId != null) {
// return await context.TryAsyncResolve(
// async c => await resumeStateRepository.GetByIdAsync((Guid)context.Source.ResumeStateId)
// );
// }
//
// return null;
// }
//);
Field <ListGraphType <DocumentType> >(
"documents",
resolve: context => documentRepository.GetByResumeId(context.Source.Id)
);
//// Async test
//FieldAsync<ListGraphType<DocumentType>>(
// "documents",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await documentRepository.GetByResumeIdAsync(context.Source.Id)
// );
// }
//);
Field <ListGraphType <SkillType> >(
"skills",
resolve: context => skillRepository.GetByResumeId(context.Source.Id)
);
//// Async test
//FieldAsync<ListGraphType<SkillType>>(
// "skills",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await skillRepository.GetByResumeIdAsync(context.Source.Id)
// );
// }
//);
Field(x => x.CreatedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.CreatedByUser, type: typeof(UserType));
Field(x => x.ModifiedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.ModifiedByUser, type: typeof(UserType));
}
public SkillType(
SkillAliasRepository skillAliasRepository,
SkillRepository skillRepository,
ResumeRepository resumeRepository,
ResumeSkillRepository resumeSkillRepository,
JobRepository jobRepository,
JobSkillRepository jobSkillRepository
)
{
Field(x => x.Id, type: typeof(IdGraphType));
Field(x => x.Name);
Field(x => x.DisplayName);
Field(x => x.Description, nullable: true);
Field <ListGraphType <SkillAliasType> >(
"skillAliases",
resolve: context => skillAliasRepository.GetBySkillId(context.Source.Id)
);
//// Async test
//FieldAsync<ListGraphType<SkillAliasType>>(
// "skillAliases",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await skillAliasRepository.GetBySkillIdAsync(context.Source.Id)
// );
// }
//);
Field <ListGraphType <ResumeType> >(
"resumes",
resolve: context => resumeRepository.GetBySkillId(context.Source.Id)
);
//// Async test
//FieldAsync<ListGraphType<ResumeType>>(
// "resumes",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await resumeRepository.GetBySkillIdAsync(context.Source.Id)
// );
// }
//);
Field <ListGraphType <JobType> >(
"jobs",
resolve: context => jobRepository.GetBySkillId(context.Source.Id)
);
//// Async test
//FieldAsync<ListGraphType<JobType>>(
// "jobs",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await jobRepository.GetBySkillIdAsync(context.Source.Id)
// );
// }
//);
Field(x => x.CreatedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.CreatedByUser, type: typeof(UserType));
Field(x => x.ModifiedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.ModifiedByUser, type: typeof(UserType));
}
public ResumeController(ResumeRepository repository)
{
_repository = repository;
}
public IEnumerable <Resume> Get()
{
var resumeRepository = new ResumeRepository();
return(resumeRepository.Retrieve());
}
public DocumentResumeType(
DocumentRepository documentRepository,
ResumeRepository resumeRepository,
DocumentResumeRepository documentResumeRepository
)
{
Field(x => x.Id, type: typeof(IdGraphType));
Field <DocumentType>(
"document",
resolve: context =>
{
if (context.Source.DocumentId != null)
{
return(documentRepository.GetById((Guid)context.Source.DocumentId));
}
return(null);
}
);
//// Async test
//FieldAsync<DocumentType>(
// "document",
// resolve: async context =>
// {
// if (context.Source.DocumentId != null) {
// return await context.TryAsyncResolve(
// async c => await documentRepository.GetByIdAsync((Guid)context.Source.DocumentId)
// );
// }
//
// return null;
// }
//);
Field <ResumeType>(
"resume",
resolve: context =>
{
if (context.Source.ResumeId != null)
{
return(resumeRepository.GetById((Guid)context.Source.ResumeId));
}
return(null);
}
);
//// Async test
//FieldAsync<ResumeType>(
// "resume",
// resolve: async context =>
// {
// if (context.Source.ResumeId != null) {
// return await context.TryAsyncResolve(
// async c => await resumeRepository.GetByIdAsync((Guid)context.Source.ResumeId)
// );
// }
//
// return null;
// }
//);
Field(x => x.CreatedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.CreatedByUser, type: typeof(UserType));
Field(x => x.ModifiedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.ModifiedByUser, type: typeof(UserType));
}
public DocumentType(
DocumentTypeRepository documentTypeRepository,
DocumentRepository documentRepository,
ResumeRepository resumeRepository,
DocumentResumeRepository documentResumeRepository
)
{
Field(x => x.Id, type: typeof(IdGraphType));
Field(x => x.Name);
Field(x => x.DisplayName, nullable: true);
Field(x => x.Description, nullable: true);
Field(x => x.Path, nullable: true);
Field(x => x.URL, nullable: true);
Field(x => x.SizeInBytes, nullable: true);
Field(x => x.FileLastModifiedOn, nullable: true);
Field(x => x.MimeType, nullable: true);
Field <DocumentTypeType>(
"documentType",
resolve: context =>
{
if (context.Source.DocumentTypeId != null)
{
return(documentTypeRepository.GetById((Guid)context.Source.DocumentTypeId));
}
return(null);
}
);
//// Async test
//FieldAsync<DocumentTypeType>(
// "documentType",
// resolve: async context =>
// {
// if (context.Source.DocumentTypeId != null) {
// return await context.TryAsyncResolve(
// async c => await documentTypeRepository.GetByIdAsync((Guid)context.Source.DocumentTypeId)
// );
// }
//
// return null;
// }
//);
Field <ListGraphType <ResumeType> >(
"resumes",
resolve: context => resumeRepository.GetByDocumentId(context.Source.Id)
);
//// Async test
//FieldAsync<ListGraphType<ResumeType>>(
// "resumes",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await resumeRepository.GetByDocumentIdAsync(context.Source.Id)
// );
// }
//);
Field(x => x.CreatedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.CreatedByUser, type: typeof(UserType));
Field(x => x.ModifiedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.ModifiedByUser, type: typeof(UserType));
}
//
// GET: /Resume/
public ActionResult Index()
{
ResumeRepository resumeRepo = unitofWork.ResumeRepository;
return(View(resumeRepo.resume));
}
public ResumeSkillType(
ResumeRepository resumeRepository,
SkillRepository skillRepository,
ResumeSkillRepository resumeSkillRepository
)
{
Field(x => x.Id, type: typeof(IdGraphType));
Field(x => x.Level, nullable: true);
Field(x => x.Description, nullable: true);
Field <ResumeType>(
"resume",
resolve: context =>
{
if (context.Source.ResumeId != null)
{
return(resumeRepository.GetById((Guid)context.Source.ResumeId));
}
return(null);
}
);
//// Async test
//FieldAsync<ResumeType>(
// "resume",
// resolve: async context =>
// {
// if (context.Source.ResumeId != null) {
// return await context.TryAsyncResolve(
// async c => await resumeRepository.GetByIdAsync((Guid)context.Source.ResumeId)
// );
// }
//
// return null;
// }
//);
Field <SkillType>(
"skill",
resolve: context =>
{
if (context.Source.SkillId != null)
{
return(skillRepository.GetById((Guid)context.Source.SkillId));
}
return(null);
}
);
//// Async test
//FieldAsync<SkillType>(
// "skill",
// resolve: async context =>
// {
// if (context.Source.SkillId != null) {
// return await context.TryAsyncResolve(
// async c => await skillRepository.GetByIdAsync((Guid)context.Source.SkillId)
// );
// }
//
// return null;
// }
//);
Field(x => x.CreatedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.CreatedByUser, type: typeof(UserType));
Field(x => x.ModifiedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.ModifiedByUser, type: typeof(UserType));
}
public ResumeService()
{
this._repository = new ResumeRepository();
}
