public async Task <ResultModel <string> > GetOpenID(GetOpenIDRequestModel requestModel)
{
try
{
Guid userID = _userService.GetUserID(requestModel.Token);
ApplicationDTO applicationInfo =
await _applicationService.GetApplicationInfoAsync(requestModel.AppID, userID);
if (applicationInfo == null)
{
return(ResultModel <string> .Fail("未注册该小程序"));
}
var weChatConfig = new WeChatConfigModel
{
APPID = applicationInfo.AppID,
APPSECRET = applicationInfo.AppSecret
};
var manager = new WeChatMiniProgramManager(weChatConfig);
string openID = manager.GetOpenIDByCode(requestModel.Code);
return(ResultModel <string> .Success(openID, "获取OpenID成功"));
}
catch (InvalidOperationException ex)
{
return(ResultModel <string> .Fail(ex.Message));
}
catch (WeChatException ex)
{
return(ResultModel <string> .Fail(ex.Message));
}
}
public async Task It_should_update()
{
Application testApp = DataSeed.Application1;
using TestServer server = TestServer(UserRole.GlobalAdministrator);
using HttpClient client = server.CreateHttpClient();
UpdateApplicationDto updtestApp = new UpdateApplicationDto()
{
ApplicationDefinition = new DefinitionDto()
{
Description = Guid.NewGuid().ToString(),
Name = Guid.NewGuid().ToString()
}
};
HttpResponseMessage result = await client.PatchAsync($"feature/application/{testApp.Code}/update", updtestApp.Serialize());
Log.WriteLine(result.Content.ReadAsStringAsync().Result);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
ApplicationDTO updateDto = result.Deserialize <ApplicationDTO>();
Assert.Equal(updtestApp.ApplicationDefinition.Description, updateDto.Description);
Assert.Equal(updtestApp.ApplicationDefinition.Name, updateDto.Name);
}
protected void vacRepeater_ItemCommand(object source, RepeaterCommandEventArgs e)
{
String element = e.CommandName.ToString();
string userName = (string)Session["username"];
ApplicationDAO app_ctx = new ApplicationDAO();
ApplicationDTO obj = new ApplicationDTO();
if(!app_ctx.isFound(userName,element) )
{
obj.userName = userName;
obj.vacancyNumber = element;
obj.status = ApplicationStatus.APPLIED.ToString();
obj.appDate = DateTime.Now;
app_ctx.presist(obj);
InboxDTO inbox = new InboxDTO();
inbox.date = DateTime.Now;
inbox.message = "You have successfully applied for vacancy " + element;
inbox.status = ApplicationStatus.APPLIED.ToString();
inbox.unread = "unread";
inbox.userName = userName;
inbox.vacancyNumber = element;
InboxDAO dao = new InboxDAO();
dao.presist(inbox);
Response.Redirect("~/Inbox/InboxMessage.aspx");
}
}
public async Task <IActionResult> Put(int id, [FromForm] ApplicationDTO applicationDto)
{
var updateApplicationCommand = new UpdateApplicationCommand(id, applicationDto);
var response = await _mediator.Send(updateApplicationCommand);
return(Ok(response));
}
public async Task <IActionResult> Create([FromBody] ApplicationDTO application)
{
if (!await ValidApplicationToCreate(application, ModelState))
{
return(BadRequest(ModelState));
}
Candidate candidate = await UnitOfWork.Candidates.SingleOrDefaultAsync(c => c.Email == application.Email);
if (candidate == null)
{
candidate = Mapper.Map <ApplicationDTO, Candidate>(application);
await UnitOfWork.Candidates.AddAsync(candidate);
}
Application applicationEntity = await UnitOfWork.Applications.SingleOrDefaultAsync(app =>
app.CandidateId == candidate.CandidateId && app.JobId == application.JobId);
if (applicationEntity == null)
{
applicationEntity = CreateApplicationEntity(candidate, application);
await UnitOfWork.Applications.AddAsync(applicationEntity);
await UnitOfWork.CompleteAsync();
}
return(new CreatedResult("/api/applications", new {
candidateId = applicationEntity.CandidateId,
jobId = applicationEntity.JobId
}));
}
/// <summary>
/// Takes the passed ApplicationDTO, constructs a new Application, finds it and saves to the DB
/// </summary>
/// <param name="ApplicationDto">ApplicationDto</param>
/// <returns>ResponseDTO</returns>
public async Task <ResponseDTO> UpdateApplicationAsync(ApplicationDTO ApplicationDto)
{
try
{
// Fetch our Application
var existingApplication = _applicationBusiness.FindBy(e => e.ApplicationID == ApplicationDto.ApplicationID).FirstOrDefault();
if (existingApplication == null)
{
// Application wasn't found, so we won't attempt to update
return(await Task.FromResult(_responseUtilities.GetEntityNotFoundResponseDto(ApplicationDto)));
}
// Map our API model to the related db entity
var ApplicationToUpdate = Mapper.Map(ApplicationDto, existingApplication);
// Call the base EntityService Update
Update(ApplicationToUpdate);
_applicationBusiness.Save();
// Fetch the newly created object so we can pass it back with the ResponseDTO
var ApplicationUpdated = await GetApplicationAsync(ApplicationToUpdate.ApplicationID);
return(await Task.FromResult(_responseUtilities.GetUpdatedResponseDto(ApplicationUpdated)));
}
catch (Exception ex)
{
// TODO: Log exceptions
return(await Task.FromResult(_responseUtilities.GetExceptionResponseDto(ex, ApplicationDto)));
}
}
public async Task <IActionResult> UpdateApplicationAsync(long id, ApplicationDTO application)
{
if (!ModelState.IsValid || application == null)
{
return(BadRequest("ApplicationDTO"));
}
if (id != application.ApplicationID)
{
return(BadRequest());
}
var response = await _applicationService.UpdateApplicationAsync(application);
if (response.ReturnObject != null && response.StatusCode == HttpStatusCode.OK)
{
return(Ok(response.ReturnObject));
}
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(NotFound());
}
return(BadRequest(response.Message));
}
public bool merge(ApplicationDTO entity)
{
try
{
var addObj = (from p in ctx.Applications
where p.userName == @entity.userName && p.vacancyNumber == @entity.vacancyNumber
select p).Single();
Application obj = (Application)addObj;
/*Update*/
obj.userName = entity.userName;
obj.vacancyNumber = entity.vacancyNumber;
obj.status = entity.status;
ctx.SubmitChanges();
return true;
}
catch (Exception e)
{
Log log = new Log();
log.message = "Application Merge: " + " [" + entity.userName + " , " + entity.vacancyNumber + "] " + e.Message;
ctx.Dispose();
ctx = new modelDataContext();
ctx.SubmitChanges();
return false;
}
}
/// <summary>
/// Takes the passed ApplicationDTO, constructs a new Application, and saves to the DB
/// </summary>
/// <param name="ApplicationDto">The ApplicationDTO</param>
/// <returns>ResponseDTO</returns>
public async Task <ResponseDTO> CreateApplicationAsync(ApplicationDTO ApplicationDto)
{
try
{
var existingApplication = GetApplicationAsync(ApplicationDto.ApplicationID).Result;
if (existingApplication != null)
{
// This Application already exists, we're not adding it again.
return(await Task.FromResult(_responseUtilities.GetDuplicateEntityResponseDto(ApplicationDto)));
}
// Map our API model to the related db entity
var ApplicationToCreate = Mapper.Map <ApplicationDTO, Application>(ApplicationDto);
// Call the base EntityService Create
Create(ApplicationToCreate);
_applicationBusiness.Save();
// Fetch the newly created object so we can pass it back with the ResponseDTO
var ApplicationCreated = await GetApplicationAsync(ApplicationToCreate.ApplicationID);
return(await Task.FromResult(_responseUtilities.GetCreatedResponseDto(ApplicationCreated, ApplicationCreated.ApplicationID)));
}
catch (Exception ex)
{
// TODO: Log exceptions
return(await Task.FromResult(_responseUtilities.GetExceptionResponseDto(ex, ApplicationDto)));
}
}
public async Task <ActionResult <ApplicationDTO> > PostApplication(ApplicationDTO appDTO)
{
User user = await userManager.FindByNameAsync(User.Identity.Name);
IList <string> roles = await userManager.GetRolesAsync(user);
if ((appDTO.DateSubmitted == null) || (!roles.Contains(UserRoles.Admin)))
{
appDTO.DateSubmitted = DateTime.UtcNow;
}
Application app = DTOToApplication(appDTO);
if (app.Status != StatusEnum.Sent)
{
return(BadRequest("New applications must have the sent status"));
}
Resume resume = null;
if (roles.Contains(UserRoles.Admin))
{
resume = await _context.Resumes.Where(r => r.ResumeId == app.ResumeId).FirstOrDefaultAsync();
}
else
{
resume = await _context.Resumes.Where(r => r.CandidateId == user.Id && r.ResumeId == app.ResumeId).FirstOrDefaultAsync();
}
if (resume == null)
{
return(NotFound("Resume does not exist"));
}
if (!roles.Contains(UserRoles.Admin))
{
var query = from jobpost in _context.JobPosts
where jobpost.JobPostId == app.JobId
select jobpost;
JobPost jobPost = await query.FirstOrDefaultAsync();
if (jobPost == null)
{
return(BadRequest("JobId not specified or job does not exist"));
}
if (jobPost.ClosingDate != null && jobPost.ClosingDate.Date.AddSeconds(86399) <= DateTime.UtcNow)
{
return(Unauthorized("Cannot submit an application after the closing date"));
}
if (app.Status != StatusEnum.Sent)
{
return(BadRequest("Candidates can only submit an application with a sent status"));
}
}
_context.Applications.Add(app);
await _context.SaveChangesAsync();
return(CreatedAtAction("PostApplication", new { id = app.ApplicationId }, ApplicationToDTO(app)));
}
public async Task <IActionResult> UpdateApplication([FromRoute] string code, [FromBody] UpdateApplicationDto application)
{
UsersApplications app = await _mediator.Send(new UpdateCommand(code, application));
ApplicationDTO response = new ApplicationDTO(app);
return(Ok(response));
}
public async Task <IActionResult> GetApplication(string code)
{
UsersApplications response = await _mediator.Send(new FindByCodeCommand(code));
ApplicationDTO rr = _mapper.Map <UsersApplications, ApplicationDTO>(response);
return(Ok(rr));
}
public async Task <IActionResult> CreateApplication(CreateApplicationDto application)
{
UsersApplications app = await _mediator.Send(new CreateCommand(application.Name, application.Code, application.Description));
ApplicationDTO response = new ApplicationDTO(app);
return(Ok(response));
}
public void GetAppValuesTest()
{
AppSettings setttings = new AppSettings();
ApplicationDTO data = setttings.GetAppValues();
string s = "Pyronix or".ToString().TrimEnd('o', 'r');
Assert.Fail();
}
public async Task <IActionResult> Post([FromForm] ApplicationDTO applicationDto)
{
var createApplicationCommand = new CreateApplicationCommand(applicationDto);
var response = await _mediator.Send(createApplicationCommand);
return(response.StatusCode == HttpStatusCode.NotFound
? (IActionResult)NotFound(response)
: Ok(response));
}
public IHttpActionResult Get(string id)
{
ApplicationDTO appDTO = ApplicationsService.Get(id);
if (appDTO == null)
{
return(NotFound());
}
return(Ok(appDTO));
}
public ApplicationDTO find(string userName, string vacancyNumber)
{
var obj = (from p in ctx.Applications
where p.userName == @userName && p.vacancyNumber == @vacancyNumber
select p).Single();
ApplicationDTO add = new ApplicationDTO();
add.userName = obj.userName;
add.vacancyNumber = obj.vacancyNumber;
add.status = obj.status;
return add;
}
public IActionResult Apply(Guid id, ApplicationDTO application)
{
try
{
var applicationInDb = _applicationService.Apply(id, application);
return(StatusCode(201));
}
catch (Exception e)
{
return(_handler.HandleError(e));
}
}
public void UpdateApplication(ApplicationDTO Entity)
{
var updateEntity = _mapper.Map <Application>(_context.Application.FirstOrDefault(z => z.Id == Entity.Id));
updateEntity.FullName = Entity.FullName;
updateEntity.HighSchool = Entity.HighSchool;
updateEntity.University = Entity.University;
updateEntity.ApplicationLetter = Entity.ApplicationLetter;
updateEntity.Cv = Convert.ToBase64String(Entity.CV);
_context.SaveChanges();
}
public async Task <ResultModel <ApplicationDTO> > GetApplicationInfo(Guid id)
{
try
{
ApplicationDTO result = await _applicationService.GetApplicationInfoAsync(id);
return(ResultModel <ApplicationDTO> .Success(result, "查询成功"));
}
catch (InvalidOperationException ex)
{
return(ResultModel <ApplicationDTO> .Fail(ex.Message));
}
}
public ApplicationDTO find(string userName, string vacancyNumber)
{
ApplicationDTO info = new ApplicationDTO();
SqlConnection oConn = new SqlConnection();
SqlCommand sqlCmd = null;
try
{
oConn.ConnectionString = ConfigurationManager.AppSettings["conn"];
oConn.Open();
sqlCmd = oConn.CreateCommand();
sqlCmd.CommandType = CommandType.Text;
sqlCmd.CommandText = "select * from Application where userName = '******' AND vacancyNumber = '" + vacancyNumber + "'";
SqlDataReader rdr = sqlCmd.ExecuteReader();
if (rdr.HasRows)
{
while (rdr.Read())
{
info.userName = rdr["userName"].ToString();
info.vacancyNumber = rdr["vacancyNumber"].ToString();
info.status = rdr["status"].ToString();
info.appDate = DateTime.Parse( rdr["appDate"].ToString() );
}
}
}
catch
{ }
finally
{
if (sqlCmd != null)
{
sqlCmd = null;
}
if (oConn != null)
{
if (oConn.State.Equals(ConnectionState.Open))
{
oConn.Close();
}
oConn = null;
}
}
return info;
}
public async Task <ActionResult <Applicant> > Apply(ApplicationDTO application)
{
// Disallow duplicate applications, using their e-mail address as a unique identifier
if (await ApplicantExists(application.EmailAddress))
{
return(BadRequest("Application already received for this person!"));
}
var newApplicant = new Applicant
{
Forename = application.Forename,
Surname = application.Surname,
EmailAddress = application.EmailAddress,
HomePhone = application.HomePhone,
MobilePhone = application.MobilePhone,
StartDate = application.StartDate
};
Address existingAddress = await GetAddress(application.address1, application.postcode);
// If address doesn't exist in database, create it, else, use the ID for the existing address.
// This is useful if there are multiple applicants from the same address, and saves data
// redundancy in the database.
if (existingAddress == null)
{
newApplicant.HomeAddress = new Address
{
Address1 = application.address1,
Address2 = application.address2,
Address3 = application.address3,
Town = application.town,
County = application.county,
Postcode = application.postcode
}
}
;
else
{
newApplicant.HomeAddress = existingAddress;
}
// Start tracking new applicant
_context.Applicants.Add(newApplicant);
// Commit applicant to database
await _context.SaveChangesAsync();
return(newApplicant);
}
public async Task <ActionResult <ApplicationDTO> > CreateApplication([FromBody] ApplicationDTO application)
{
_wrapper.ApplicationRepository.CreateApplication(_mapper.Map <Application>(application));
try
{
await _wrapper.SaveAsync();
}
catch (DbUpdateException e)
{
return(BadRequest(e.Message));
}
return(CreatedAtAction(nameof(CreateApplication), new { id = application.ApplicationId }, application));
}
protected async virtual Task <bool> ValidApplicationToCreate(ApplicationDTO application, ModelStateDictionary modelState)
{
bool returnValue = true;
if (!modelState.IsValid)
{
return(!returnValue);
}
if (application.JobId <= 0 || await UnitOfWork.Jobs.GetAsync(application.JobId.Value) == null)
{
modelState.AddModelError("JobId", "Invalid Job");
returnValue = false;
}
return(returnValue);
}
public ReturnViewModel Edit([FromBody] ApplicationDTO application)
{
try
{
var app = AutoMapper.Mapper.Map <ApplicationDTO, Infrastructure.Domain.Data.Applications>(application);
_application.Update(application.Id, app);
return(new ReturnViewModel(HttpStatusCode.OK, "Update Successfully", false));
}
catch (System.Exception ex)
{
return(new ReturnViewModel(HttpStatusCode.BadRequest, ex.Message, true));
}
}
public async Task <IActionResult> CreateApplicationAsync([FromBody] ApplicationDTO application)
{
if (!ModelState.IsValid || application == null)
{
return(BadRequest("ApplicationDTO"));
}
var response = await _applicationService.CreateApplicationAsync(application);
if (response.ReturnObject != null && response.StatusCode == HttpStatusCode.Created)
{
return(Created($"{Request.GetDisplayUrl()}/{response.Id}", response));
}
return(BadRequest(response.Message));
}
public void Apply_StateUnderTest_ExpectedBehavior()
{
// Arrange
var jobAdvertisementsController = this.CreateJobAdvertisementsController();
Guid id = default(global::System.Guid);
ApplicationDTO application = null;
// Act
var result = jobAdvertisementsController.Apply(
id,
application);
// Assert
Assert.True(true);
this.mockRepository.VerifyAll();
}
public async Task <bool> Register(ApplicationDTO application)
{
_application = new Applications();
_application.CountryId = application.country.countryId;
_application.State = application.state;
_application.PostcodeId = application.postCodeId;
_application.FullName = application.fullName;
_application.CreatedDate = DateTime.Now;
await _context.Applications.AddAsync(_application);
await _context.SaveChangesAsync();
return(true);
}
public void Apply_StateUnderTest_ExpectedBehavior()
{
// Arrange
var service = this.CreateService();
Guid jobAddId = default(global::System.Guid);
ApplicationDTO application = new ApplicationDTO();
// Act
//var result = service.Apply(
// jobAddId,
// application);
// Assert
Assert.True(true);
this.mockRepository.VerifyAll();
}
public async Task <ActionResult> UpdateApplication([FromBody] ApplicationDTO application)
{
_wrapper.ApplicationRepository.UpdateApplication(_mapper.Map <Application>(application));
try
{
// Save changes
await _wrapper.SaveAsync();
}
catch (DbUpdateException e)
{
return(BadRequest(e.Message));
}
return(Ok());
}
public ApplicationDTO Apply(Guid jobAddId, ApplicationDTO application)
{
var mapped = _mapper.Map <Application>(application);
var jobAdd = _context.JobAdvertisementEntities.Find(jobAddId);
if (jobAdd == null)
{
throw new KeyNotFoundException();
}
mapped.JobAdvertisementID = jobAddId;
_context.ApplicationEntities.Add(mapped);
_context.SaveChanges();
var response = application;
response.ApplicationID = mapped.ApplicationID;
return(response);
}
public long UpdateApplicationCash(ApplicationDTO applicationDTO)
{
var result = this.UnitOfWork.Get <Application>().AsQueryable()
.FirstOrDefault(e => e.ApplicationId == applicationDTO.ApplicationId);
if (result != null)
{
result.ApplicationId = applicationDTO.ApplicationId;
result.Name = applicationDTO.Name;
result.TotalCash = applicationDTO.TotalCash;
result.TimeStamp = DateTime.Now;
this.UnitOfWork.Get <Application>().Update(result);
this.UnitOfWork.SaveChanges();
}
return(applicationDTO.ApplicationId);
}
public List<ApplicationDTO> findAll()
{
var objs = (from p in ctx.Applications
select p);
ApplicationDTO add = null;
List<ApplicationDTO> addList = new List<ApplicationDTO>();
foreach (Application obj in objs)
{
add = new ApplicationDTO();
add.userName = obj.userName;
add.vacancyNumber = obj.vacancyNumber;
add.status = obj.status;
addList.Add(add);
}
return addList;
}
/// <summary>
/// 获取商家收款ID
/// </summary>
/// <param name="appId">APPID</param>
/// <returns></returns>
public System.Guid GetPayeeIdExt(System.Guid appId)
{
try
{
AppManagerFacade appManagerFacade = new AppManagerFacade();
ApplicationDTO applicationDTO = appManagerFacade.GetAppById(appId);
if (applicationDTO != null && applicationDTO.OwnerId != Guid.Empty)
{
return(applicationDTO.OwnerId ?? Guid.Empty);
}
}
catch (Exception ex)
{
LogHelper.Error(string.Format("获取商家收款Id异常。appId：{0}", appId), ex);
}
return(Guid.Empty);
}
public async Task <IHttpActionResult> GetApplication(int id)
{
Application b = await db.Applications.FindAsync(id);
if (b == null)
{
return(NotFound());
}
ApplicationDTO application = new ApplicationDTO
{
application_num = b.Id,
applicationStatus = b.applicationStatus,
motivation = b.motivation,
student = new StudentDTO
{
student_number = b.student.Id,
first_name = b.student.firstName,
middle_name = b.student.middleName,
last_name = b.student.lastName,
wall_paper = b.student.wallpaper,
profile_pic = b.student.profilePic,
category = b.student.category,
level = b.student.level,
instituiton = b.student.institute
},
company = new CompanyDTO
{
companyID = b.company.Id,
name = b.company.companyName,
company_category = b.company.category,
profile_pic = b.company.profilePicture,
wall_pic = b.company.wallpaper
},
project = new ProjectAppDTO
{
project_id = b.project.Id,
project_category = b.project.category,
project_title = b.project.title,
project_status = b.project.status,
project_pic = b.project.post_pic,
targeted_level = b.project.audience
}
};
return(Ok(application));
}
public bool presist(ApplicationDTO entity)
{
bool success = false;
SqlConnection oConn = new SqlConnection();
SqlCommand sqlCmd = null;
try
{
oConn.ConnectionString = ConfigurationManager.AppSettings["conn"];
oConn.Open();
sqlCmd = oConn.CreateCommand();
sqlCmd.CommandType = CommandType.StoredProcedure;
sqlCmd.CommandText = "insertApplication";
sqlCmd.Parameters.Add(new SqlParameter("userName", entity.userName));
sqlCmd.Parameters.Add(new SqlParameter("vacancyNumber", entity.vacancyNumber));
sqlCmd.Parameters.Add(new SqlParameter("status", entity.status));
sqlCmd.Parameters.Add(new SqlParameter("appDate", entity.appDate));
SqlDataReader rdr = sqlCmd.ExecuteReader();
if (rdr.HasRows)
{
while (rdr.Read())
{ } //Read all
}
rdr.Close();
if (rdr.RecordsAffected > 0)
success = true;
}
catch { }
finally
{
if (sqlCmd != null)
{
sqlCmd = null;
}
if (oConn != null)
{
if (oConn.State.Equals(ConnectionState.Open))
{
oConn.Close();
}
oConn = null;
}
}
return success;
}
public void applicationSearchServiceTest()
{
ApplicationSearchService target = new ApplicationSearchServiceImpl(); // TODO: Initialize to an appropriate value
AccountDAO account_context = new AccountDAO();
ApplicationDAO app_context = new ApplicationDAO();
VacancyDAO vac_context = new VacancyDAO();
/*Insert*/
AccountDTO account = new AccountDTO();
account.userName = "******";
account.status = "active";
account.password = "******";
account.accountType = "admin";
account_context.presist(account);
VacancyDTO vac = new VacancyDTO();
vac.department = "IS";
vac.description = "Web services";
vac.manager = "Tom";
vac.recruiter = "Thumi";
vac.site = "www.petrosa.co.za";
vac.startDate = new DateTime(2012, 10, 10);
vac.endDate = new DateTime(2012, 12, 1);
vac.description = "desktop support";
vac.title = "support technician";
vac.vacancyNumber = "1";
vac.viewCount = 10;
vac.viewStatus = "published";
vac.status = "active";
vac_context.presist(vac);
bool expectedVac = true;
bool actualVac;
actualVac = vac_context.isFound("1");
Assert.AreEqual(expectedVac, actualVac);
ApplicationDTO application = new ApplicationDTO();
application.userName = "******";
application.vacancyNumber = "1";
application.status = "open";
app_context.presist(application);
//Test getApplicationByUsername method
List<ApplicationDTO> applicationTestListObj = target.getApplicationByUsername("graddy");
Assert.AreEqual(application.status, applicationTestListObj[0].status);
//Test getApplicationByStatus method
List<ApplicationDTO> applicationTestListObj2 = target.getApplicationByStatus("open");
Assert.AreEqual(application.status, applicationTestListObj2[0].status);
//Test getApplicationByVacancyNumber method
List<ApplicationDTO> applicationTestListObj3 = target.getApplicationByVacancyNumber("1");
Assert.AreEqual(application.status, applicationTestListObj3[0].status);
/*Delete*/
/*
account_context.removeByUserId("graddy");
bool expectedDelete = false;
bool actualDelete = account_context.isFound("graddy");
Assert.AreEqual(expectedDelete, actualDelete);
*/
}
public void userServiceTest()
{
UserService target = CreateUserService(); // TODO: Initialize to an appropriate value
AccountDAO account_context = new AccountDAO();
ApplicationDAO app_context = new ApplicationDAO();
VacancyDAO vac_context = new VacancyDAO();
/*Insert*/
AccountDTO account = new AccountDTO();
account.userName = "******";
account.status = "active";
account.password = "******";
account.accountType = "admin";
account_context.presist(account);
VacancyDTO vac = new VacancyDTO();
vac.department = "IS";
vac.description = "Web services";
vac.manager = "Tom";
vac.recruiter = "Thumi";
vac.site = "www.petrosa.co.za";
vac.startDate = new DateTime(2012, 10, 10);
vac.endDate = new DateTime(2012, 12, 1);
vac.description = "desktop support";
vac.title = "support technician";
vac.vacancyNumber = "1";
vac.viewCount = 10;
vac.viewStatus = "published";
vac.status = "active";
vac_context.presist(vac);
bool expectedVac = true;
bool actualVac;
actualVac = vac_context.isFound("1");
Assert.AreEqual(expectedVac, actualVac);
ApplicationDTO applicationDto = new ApplicationDTO();
applicationDto.userName = "******";
applicationDto.vacancyNumber = "1";
applicationDto.status = ApplicationStatus.APPLIED.ToString();
app_context.presist(applicationDto);
bool expected = true;
bool actual;
actual = app_context.isFound("griddy", "1");
Assert.AreEqual(expected, actual);
//Test changeUserApplicationStatus method
target.changeUserApplicationStatus("griddy", "1", ApplicationStatus.SHORTLISTED);
ApplicationDTO applicationDto2 = app_context.find("griddy", "1");
Assert.AreEqual(ApplicationStatus.SHORTLISTED.ToString(), applicationDto2.status);
//Test getShortListedCandidates method
List<ApplicationDTO> candidates = target.getShortListedCandidates("1");
Assert.AreEqual("griddy", candidates[0].userName);
/*Delete*/
Assert.AreEqual(app_context.removeByUserId("griddy", "1"), true);
Assert.AreEqual(vac_context.removeByUserId("1"), true);
Assert.AreEqual(account_context.removeByUserId("griddy"), true);
}
public bool presist(ApplicationDTO entity)
{
try
{
Application obj = new Application();
obj.userName = entity.userName;
obj.vacancyNumber = entity.vacancyNumber;
obj.status = entity.status;
ctx.Applications.InsertOnSubmit(obj);
ctx.SubmitChanges();
return true;
}
catch (Exception)
{
ctx.Dispose();
ctx = new modelDataContext();
return false;
}
}
public bool remove(ApplicationDTO entity)
{
return this.removeByUserId(entity.userName, entity.vacancyNumber);
}
public void ApplicationDAO_Test()
{
AccountDAO account_context = new AccountDAO();
ApplicationDAO app_context = new ApplicationDAO();
VacancyDAO vac_context = new VacancyDAO();
/*Insert*/
AccountDTO account = new AccountDTO();
account.userName = "******";
account.status = "active";
account.password = "******";
account.accountType = "admin";
account_context.presist(account);
VacancyDTO vac = new VacancyDTO();
vac.department = "IS";
vac.description = "Web services";
vac.manager = "Tom";
vac.recruiter = "Thumi";
vac.site = "www.petrosa.co.za";
vac.startDate = new DateTime(2012, 10, 10);
vac.endDate = new DateTime(2012, 12, 1);
vac.description = "desktop support";
vac.title = "support technician";
vac.vacancyNumber = "1";
vac.viewCount = 10;
vac.viewStatus = "published";
vac.status = "active";
vac_context.presist(vac);
bool expectedVac = true;
bool actualVac;
actualVac = vac_context.isFound("1");
Assert.AreEqual(expectedVac, actualVac);
ApplicationDTO application = new ApplicationDTO();
application.userName = "******";
application.vacancyNumber = "1";
application.status = "open";
app_context.presist(application);
bool expected = true;
bool actual;
actual = app_context.isFound("griddy", "1");
Assert.AreEqual(expected, actual);
/*Update*/
application.status = "closed";
expected = true;
actual = app_context.merge(application);
Assert.AreEqual(expected, actual);
/*Delete*/
Assert.AreEqual(app_context.removeByUserId("griddy", "1"), true);
Assert.AreEqual(vac_context.removeByUserId("1"), true);
Assert.AreEqual(account_context.removeByUserId("griddy"), true);
}
