public void LeaveRulesCreate(LeaveRulesDTOs Record)
{
try
{
using (var scope = new System.Transactions.TransactionScope())
{
LeaveRule test = _unitOfWork.LeaveRuleRepository.Create(LeaveRulesMapper.LeaveRuleDtoToLeaveRules(Record));
int count = Record.LeaveRuleDetailsColection.Count();
for (int i = 0; i < count; i++)
{
LeaverulesDetailsDtos data = new LeaverulesDetailsDtos();
data.LeaveRuleId = test.LeaveRuleId;
data.LeaveTypeId = Record.LeaveRuleDetailsColection[i].LeaveTypeId;
if (Record.LeaveRuleDetailsColection[i].LeaveDays == null)
{
data.LeaveDays = 0;
}
data.LeaveDays = Record.LeaveRuleDetailsColection[i].LeaveDays;
LeaveRuleDetail insertdata = LeaveRuleDetailsMapper.LeaveRulesdetailDtoToLeaveRuleDetails(data);
_unitOfWork.LeaveRuleDetailRepository.Create(insertdata);
}
scope.Complete();
}
}
catch (TransactionAbortedException ex)
{
throw new Exception(ex.Message);
}
catch (ApplicationException ex)
{
throw new Exception(ex.Message);
}
}
public static LeaveRule LeaveRuleDtoToLeaveRules(LeaveRulesDTOs Record)
{
LeaveRule Result = new LeaveRule()
{
LeaveRuleId = Record.LeaveRuleId,
LeaveRuleName = Record.LeaveRuleName,
LeaveRuleDetails = Record.LeaveRuleDetails
};
return(Result);
}
public async Task <string> UpdateLeaveRules(int id, LeaveRule leaveRules)
{
try
{
var res = await _repository.UpdateLeaveRules(id, leaveRules);
return(res);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <LeaveRule> CreateNewLeaveRules(LeaveRule leaveRules)
{
try
{
var res = await _repository.CreateNewLeaveRules(leaveRules);
return(res);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <LeaveRule> CreateNewLeaveRules(LeaveRule leaveRules)
{
try
{
_context.LeaveRules.Add(leaveRules);
await _context.SaveChangesAsync();
return(leaveRules);
}
catch (Exception ex)
{
throw ex;
}
}
public static LeaveRuleDTO ConvertRespondentInfoToDTO(LeaveRule leave)
{
Mapper.CreateMap <LeaveRule, LeaveRuleDTO>().ConvertUsing(
m =>
{
return(new LeaveRuleDTO
{
LeaveRuleDetails = m.LeaveRuleDetails,
LeaveRuleName = m.LeaveRuleName,
LeaveRuleId = m.LeaveRuleId
});
});
return(Mapper.Map <LeaveRule, LeaveRuleDTO>(leave));
}
public async Task <IActionResult> CreateLeaveRules(LeaveRule leaveRules)
{
try
{
var response = await _service.CreateNewLeaveRules(leaveRules);
if (response != null)
{
return(Ok(response));
}
return(StatusCode(StatusCodes.Status204NoContent));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> UpdateLeaveRules(int LeaveRulesId, LeaveRule leaveRules)
{
try
{
var res = await _service.UpdateLeaveRules(LeaveRulesId, leaveRules);
if (res != null)
{
return(Ok(res));
}
return(StatusCode(StatusCodes.Status204NoContent));
}
catch (Exception ex)
{
throw;
}
}
public async Task <string> UpdateLeaveRules(int id, LeaveRule leaveRules)
{
try
{
var res = await _context.LeaveRules.FirstOrDefaultAsync(m => m.LeaveRulesId == id);
res.LeaveGroup = leaveRules.LeaveGroup;
res.JobTitle = leaveRules.JobTitle;
res.EmploymentStatus = leaveRules.EmploymentStatus;
res.EmployeeName = leaveRules.EmployeeName;
res.Experience = leaveRules.Experience;
res.LeavePerYear = leaveRules.LeavePerYear;
_context.Update(res);
await _context.SaveChangesAsync();
return("Updated Record");
}
catch (Exception ex)
{
throw ex;
}
}
public int UpdateLeaveRule(LeaveRuleDTO editLeaveRule)
{
LeaveRule editLR = LeaveRuleRequestFormatter.ConvertRespondentInfoFromDTO(editLeaveRule);
return(_unitOfWork.LeaveRuleRepository.Update(editLR));
}
public LeaveRuleDTO InsertLeaveRule(LeaveRuleDTO leaveRule)
{
LeaveRule lr = LeaveRuleRequestFormatter.ConvertRespondentInfoFromDTO(leaveRule);
return(LeaveRuleRequestFormatter.ConvertRespondentInfoToDTO(_unitOfWork.LeaveRuleRepository.Create(lr)));
}
public LeaveRuleDTO GetLeaveRuleById(int id)
{
LeaveRule lr = _unitOfWork.LeaveRuleRepository.Get(x => x.LeaveRuleId == id).FirstOrDefault();
return(LeaveRuleRequestFormatter.ConvertRespondentInfoToDTO(lr));
}
