public IUserDTO CreateEmployeeBySProc(IUserDTO userDTO)
{
IUserDTO createEmployeeRetVal = null;
try
{
using (EmployeePortal2017Entities portal = new EmployeePortal2017Entities())
{
var objParam = new ObjectParameter("Id", typeof(int));
portal.CreateEmployee(userDTO.EmployeeDTO.FirstName, userDTO.EmployeeDTO.LastName,
userDTO.EmployeeDTO.Email, userDTO.EmployeeDTO.DateOfJoining.ToString(),
userDTO.EmployeeDTO.DepartmentId, userDTO.Password, userDTO.IsAdmin,
objParam);
var user = portal.Users.Include("Employee").Where(u => u.UserId == (int)objParam.Value).SingleOrDefault();
if (user != null)
{
EntityConverter.FillDTOFromEntity(user, userDTO);
EntityConverter.FillDTOFromEntity(user.Employee, userDTO.EmployeeDTO);
createEmployeeRetVal = userDTO;
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
return(createEmployeeRetVal);
}
public IHttpActionResult Create([FromBody] List <Tags> tags, int questionId)
{
List <ITagsDTO> tagsDTO = new List <ITagsDTO>();
foreach (var tag in tags)
{
ITagsDTO tagDTO = (ITagsDTO)DTOFactory.Instance.Create(DTOType.TagsDTO);
EntityConverter.FillDTOFromEntity(tag, tagDTO);
tagsDTO.Add(tagDTO);
}
ITagFacade tagsFacade = (ITagFacade)FacadeFactory.Instance.Create(FacadeType.TagFacade);
OperationResult <bool> result = tagsFacade.Create(tagsDTO, questionId);
if (result.ResultType == OperationResultType.Failure)
{
string failed = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(failed));
}
if (result.IsValid())
{
string success = JsonConvert.SerializeObject(new { success = true, data = true });
return(Ok(success));
}
string jsonObj = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(jsonObj));
}
public IList <INoticeDTO> GetAllNotices()
{
IList <INoticeDTO> noticeDTOList = null;
using (EmployeePortalEntities employeePortalEntities = new EmployeePortalEntities())
{
try
{
var noticeEntityList = employeePortalEntities.Notices;
if (noticeEntityList != null)
{
noticeDTOList = new List <INoticeDTO>();
foreach (var notice in noticeEntityList)
{
INoticeDTO noticeDTO = (INoticeDTO)DTOFactory.Instance.Create(DTOType.Notice);
EntityConverter.FillDTOFromEntity(notice, noticeDTO);
noticeDTOList.Add(noticeDTO);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
}
return(noticeDTOList);
}
public IList <IUserDTO> GetAll()
{
IList <IUserDTO> tempUserList = new List <IUserDTO>();
try
{
CasinoPortalEntities context = new CasinoPortalEntities();
using (context)
{
var items = context.Users.ToList();
foreach (var eachItem in items)
{
IUserDTO userDTO = (IUserDTO)DTOFactory.Instance.Create(DTOType.UserDTO);
EntityConverter.FillDTOFromEntity(eachItem, userDTO);
tempUserList.Add(userDTO);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
return(tempUserList);
}
/// <summary>
/// Returns a specific notice using the given notice id
/// </summary>
/// <param name="noticeId"></param>
/// <returns></returns>
public INoticeDTO GetNotice(int noticeId)
{
INoticeDTO noticeDTO = null;
using (EmployeePortal2017Entities portal = new EmployeePortal2017Entities())
{
try
{
var notice = portal.Notices.Include("Employee").Where(n => n.NoticeId == noticeId)
.SingleOrDefault();
if (notice != null)
{
noticeDTO = (INoticeDTO)DTOFactory.Instance.Create(DTOType.NoticeDTO);
noticeDTO.PostedByEmployee = (IEmployeeDTO)DTOFactory.Instance.Create(DTOType.EmployeeDTO);
EntityConverter.FillDTOFromEntity(notice, noticeDTO);
EntityConverter.FillDTOFromEntity(notice.Employee, noticeDTO.PostedByEmployee);
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
}
return(noticeDTO);
}
/// <summary>
/// Used wherever a specific department is required.
/// </summary>
/// <param name="departmentId"></param>
/// <returns></returns>
public IDepartmentDTO GetADepartment(int departmentId)
{
IDepartmentDTO departmentDTO = null;
using (EmployeePortal2017Entities portal = new EmployeePortal2017Entities())
{
try
{
var department = portal.Departments.Where(d => d.DepartmentId == departmentId)
.SingleOrDefault <Department>();
departmentDTO = (IDepartmentDTO)DTOFactory.Instance.Create(DTOType.DepartmentDTO);;
if (department != null)
{
EntityConverter.FillDTOFromEntity(department, departmentDTO);
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
}
return(departmentDTO);
}
public List <UserDTO> GetUsers()
{
List <UserDTO> userDTOs = new List <UserDTO>();
try
{
using (BookContext db = new BookContext())
{
var users = (from u in db.Users
select new { u.Name, u.EmailId }).ToList();
List <User> userList = new List <User>();
foreach (var user in users)
{
User userobj = new User();
userobj.Name = user.Name;
userobj.EmailId = user.EmailId;
userList.Add(userobj);
}
foreach (var user in userList)
{
UserDTO userDTO = new UserDTO();
EntityConverter.FillDTOFromEntity(user, userDTO);
userDTOs.Add(userDTO);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
return(userDTOs);
}
public ICategoriesDTO editCategory(ICategoriesDTO categoryDTO)
{
ICategoriesDTO retVal = null;
try
{
using (var database = new EcommerceEntities())
{
var category = database.Categories.Where(c => c.CategotyId == categoryDTO.CategotyId).FirstOrDefault();
if (category != null)
{
category.CategoryName = categoryDTO.CategoryName;
database.SaveChanges();
retVal = (ICategoriesDTO)DTOFactory.Instance.Create(DTOType.Category, null);
EntityConverter.FillDTOFromEntity(category, retVal);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
return(retVal);
}
public IList <ICategoriesDTO> GetAllCategories()
{
IList <ICategoriesDTO> employeeDTOList = new List <ICategoriesDTO>();
ICategoriesDTO employeeDTO = null;
using (EcommerceEntities employeePortalEntities = new EcommerceEntities())
{
try
{
var employeeEntity = (employeePortalEntities.Categories);
foreach (var emp in employeeEntity)
{
employeeDTO = (ICategoriesDTO)DTOFactory.Instance.Create(DTOType.Category);
EntityConverter.FillDTOFromEntity(emp, employeeDTO);
employeeDTOList.Add(employeeDTO);
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
}
return(employeeDTOList);
}
public IUserDTO RechargeAmount(int id, decimal rechargeAmount)
{
IUserDTO retVal = null;
try
{
using (CasioAppEntities context = new CasioAppEntities())
{
CustomerList customer = context.CustomerLists.Where(item => item.Customer_Id == id).FirstOrDefault();
if (customer != null)
{
customer.Account_Balance += rechargeAmount;
}
if (context.SaveChanges() > 0)
{
EntityConverter.FillDTOFromEntity(customer, retVal);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
return(retVal);
//throw new NotImplementedException();
}
public IList <IUserDTO> GetAllUsers()
{
IList <IUserDTO> retVal = new List <IUserDTO>();
try
{
using (CasioAppEntities context = new CasioAppEntities())
{
foreach (var user in context.CustomerLists)
{
IUserDTO userDTO = (IUserDTO)DTOFactory.Instance.Create(DTOType.UserDTO);
EntityConverter.FillDTOFromEntity(user, userDTO);
retVal.Add(userDTO);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
return(retVal);
}
public IUserDTO ModifyAmount(string uniqueId, decimal factor)
{
IUserDTO retVal = null;
try
{
using (CasioAppEntities context = new CasioAppEntities())
{
CustomerList customer = context.CustomerLists.Where(item => item.Unique_User_Id == uniqueId).FirstOrDefault();
if (customer != null)
{
customer.Account_Balance += (decimal)(factor * customer.Blocked_Amount);
customer.Blocked_Amount = 0;
if (context.SaveChanges() > 0)
{
retVal = (IUserDTO)DTOFactory.Instance.Create(DTOType.UserDTO);
EntityConverter.FillDTOFromEntity(customer, retVal);
}
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
return(retVal);
}
public IList <INoticesDTO> GetActiveNotices()
{
List <INoticesDTO> activeNotices = new List <INoticesDTO>();
try
{
using (EmployeePortalEntities context = new EmployeePortalEntities())
{
//check whether we need to check here whether notice is active or not
foreach (var notice in context.Notices.Where(item => item.IsActive == true))
{
INoticesDTO noticeDTO = (INoticesDTO)DTOFactory.Instance.Create(DTOType.NoticesDTO);
EntityConverter.FillDTOFromEntity(notice, noticeDTO);
activeNotices.Add(noticeDTO);
context.SaveChanges();
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
return(activeNotices);
}
public IUserDTO GetUserByEmailId(string emailId)
{
IUserDTO userDTO = null;
try
{
using (EmployeePortal2017Entities portal = new EmployeePortal2017Entities())
{
var user = portal.Users.Include("Employee").Where(u => u.Employee.Email.Equals(emailId)).SingleOrDefault();
if (user != null)
{
userDTO = (IUserDTO)DTOFactory.Instance.Create(DTOType.UserDTO);
EntityConverter.FillDTOFromEntity(user, userDTO);
userDTO.EmployeeDTO = (IEmployeeDTO)DTOFactory.Instance.Create(DTOType.EmployeeDTO);
EntityConverter.FillDTOFromEntity(user.Employee, userDTO.EmployeeDTO);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
return(userDTO);
}
/// <summary>
/// Post action to login user
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
//[HttpPost]
//[Route("api/user/login")]
public User Login([FromBody] User user)
{
IUserDTO userDTO = (IUserDTO)DTOFactory.Instance.Create(DTOType.UserDTO);
EntityConverter.FillDTOFromEntity(user, userDTO);
IUserFacade userFacade = (IUserFacade)FacadeFactory.Instance.Create(FacadeType.UserFacade);
OperationResult <IUserDTO> result = userFacade.Login(userDTO);
if (result.ResultType == OperationResultType.Failure)
{
//string failed = JsonConvert.SerializeObject(new { success = false, data = result.Message });
//return BadRequest(failed);
return(null);
}
if (result.IsValid())
{
EntityConverter.FillEntityFromDTO(result.Data, user);
////var userStore = new UserStore<ApplicationUser>(new ApplicationDbContext());
////var manager = new UserManager<ApplicationUser>(userStore);
////var user = new ApplicationUser() { UserName = model.UserName, Email = model.Email }
//string success = JsonConvert.SerializeObject(new { success = true, data = user});
//return Ok(success);
return(user);
}
//string jsonObj = JsonConvert.SerializeObject(new { success = false, data = result.Message });
//return BadRequest(jsonObj);
return(null);
}
public IList <IItemDTO> GetAllSubCategoryItems(int categoryId)
{
IList <IItemDTO> employeeDTOList = new List <IItemDTO>();
IItemDTO employeeDTO = null;
using (EcommerceEntities employeePortalEntities = new EcommerceEntities())
{
try
{
var employeeEntity = (employeePortalEntities.Items).Where(item => item.SubCategotyId == categoryId);
foreach (var emp in employeeEntity)
{
employeeDTO = (IItemDTO)DTOFactory.Instance.Create(DTOType.Item);
EntityConverter.FillDTOFromEntity(emp, employeeDTO);
employeeDTOList.Add(employeeDTO);
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
}
return(employeeDTOList);
}
/// <summary>
/// Method to delete answer
/// </summary>
/// <param name="answerDTO"></param>
/// <returns></returns>
public IAnswerDTO Delete(IAnswerDTO answerDTO)
{
using (var context = new BufferOverflowDBEntities())
{
var deleteAnswer = context.Answers
.SingleOrDefault(a => a.Id == answerDTO.Id);
if (deleteAnswer != null)
{
// Delete Vote
var deleteVote = context.Votes.Where(v => v.AnswerId == answerDTO.Id).ToList();
foreach (var vote in deleteVote)
{
context.Votes.Remove(vote);
context.SaveChanges();
}
// Delete Answer
var answer = context.Answers.Remove(deleteAnswer);
context.SaveChanges();
var question = context.Questions.SingleOrDefault(q => q.Id == answer.QuestionId);
question.AnswerCount--;
context.SaveChanges();
EntityConverter.FillDTOFromEntity(answer, answerDTO);
}
return(answerDTO);
}
}
public IList <IEmployeeDTO> GetAllEmployees()
{
IList <IEmployeeDTO> employeeDTOList = null;
using (EmployeePortalEntities employeePortalEntities = new EmployeePortalEntities())
{
try
{
var employeeEntityList = employeePortalEntities.Employees;
if (employeeEntityList != null)
{
employeeDTOList = new List <IEmployeeDTO>();
foreach (var employee in employeeEntityList)
{
IEmployeeDTO employeeDTO = (IEmployeeDTO)DTOFactory.Instance.Create(DTOType.Employee);
EntityConverter.FillDTOFromEntity(employee, employeeDTO);
employeeDTOList.Add(employeeDTO);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
}
return(employeeDTOList);
}
/// <summary>
/// Used wherever a list of departments is required
/// </summary>
/// <returns></returns>
public IList <IDepartmentDTO> GetAllDepartments()
{
IList <IDepartmentDTO> departmentDTOList = null;
using (EmployeePortal2017Entities portal = new EmployeePortal2017Entities())
{
try
{
departmentDTOList = new List <IDepartmentDTO>();
IDepartmentDTO departmentDTO;
foreach (Department department in portal.Departments)
{
departmentDTO = (IDepartmentDTO)DTOFactory.Instance.Create(DTOType.DepartmentDTO);
EntityConverter.FillDTOFromEntity(department, departmentDTO);
departmentDTOList.Add(departmentDTO);
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
}
return(departmentDTOList);
}
/// <summary>
/// Gets all surveys
/// </summary>
/// <param name="surveyId">The Survey identifier.</param>
/// <returns>IList<ISurveyDTO>.</returns>
/// <exception cref="DACException">Error while fetching the Survey detail.</exception>
public IList <ISurveyDTO> GetAllSurveys()
{
IList <ISurveyDTO> surveyDtos = new List <ISurveyDTO>();
try
{
using (var dbContext = new SSEntities())
{
var surveyEntities = (from Survey in dbContext.Surveys
select Survey).ToList();
ISurveyDTO surveyDto = null;
foreach (var surveyEntity in surveyEntities)
{
surveyDto = (ISurveyDTO)DTOFactory.Instance.Create(DTOType.Survey);
EntityConverter.FillDTOFromEntity(surveyEntity, surveyDto);
surveyDtos.Add(surveyDto);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException("Error while fetching the Survey detail.", ex);
}
return(surveyDtos);
}
//View All the Comments on an event
public List <CommentsDTO> ViewComments(int eventId)
{
List <Comments> comments = new List <Comments>();
List <CommentsDTO> commentsDTOs = new List <CommentsDTO>();
try
{
using (BookContext db = new BookContext())
{
comments = db.Comments.Where(c => c.EventId == eventId).ToList();
foreach (var temp in comments)
{
CommentsDTO commentsDTO = new CommentsDTO();
EntityConverter.FillDTOFromEntity(temp, commentsDTO);
commentsDTOs.Add(commentsDTO);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
return(commentsDTOs);
}
/// <summary>
/// Gets the survey by identifier.
/// </summary>
/// <param name="surveyId">The Survey identifier.</param>
/// <returns>ISurveyDTO.</returns>
/// <exception cref="DACException">Error while fetching the Survey detail.</exception>
public ISurveyDTO GetSurveyById(int surveyId)
{
ISurveyDTO surveyDto = null;
try
{
using (var dbContext = new SSEntities())
{
var surveyEntity = (from Survey in dbContext.Surveys
where Survey.Id == surveyId
select Survey).SingleOrDefault();
if (surveyEntity != null)
{
surveyDto = (ISurveyDTO)DTOFactory.Instance.Create(DTOType.Survey);
EntityConverter.FillDTOFromEntity(surveyEntity, surveyDto);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException("Error while fetching the Survey detail.", ex);
}
return(surveyDto);
}
public IUserDTO UpdateUser(IUserDTO userDTO)
{
try
{
CasinoPortalEntities context = new CasinoPortalEntities();
using (context)
{
var amount = userDTO.AccountBalance;
var foundItem = context.Users.ToList().Where(item => item.UserID == userDTO.UserID).FirstOrDefault();
if (foundItem != null)
{
EntityConverter.FillDTOFromEntity(foundItem, userDTO);
foundItem.AccountBalance += amount;
context.SaveChanges();
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
return(userDTO);
}
public IHttpActionResult CreateVote([FromBody] Votes vote)
{
IVoteDTO votesDTO = (IVoteDTO)DTOFactory.Instance.Create(DTOType.VoteDTO);
EntityConverter.FillDTOFromEntity(vote, votesDTO);
IAnswerFacade answerFacade = (IAnswerFacade)FacadeFactory.Instance.Create(FacadeType.AnswerFacade);
OperationResult <IDataDTO> result = answerFacade.CreateVote(votesDTO);
if (result.ResultType == OperationResultType.Failure)
{
string failed = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(failed));
}
if (result.IsValid())
{
Data dataModel = new Data();
EntityConverter.FillEntityFromDTO(result.Data.VoteDetail, dataModel.VoteDetail);
dataModel.TotalVote = result.Data.TotalVote;
string success = JsonConvert.SerializeObject(new { success = true, data = dataModel });
return(Ok(success));
}
string jsonObj = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(jsonObj));
}
/// <summary>
/// Get all the notices with IsActive set to true.
/// </summary>
/// <returns></returns>
public IList <INoticeDTO> GetActiveNotices()
{
IList <INoticeDTO> noticeDTOList = null;
try
{
using (EmployeePortal2017Entities portal = new EmployeePortal2017Entities())
{
var noticeList = portal.Notices.Include("Employee").Where(n => n.IsActive).ToList();
if (noticeList.Count > 0)
{
noticeDTOList = new List <INoticeDTO>();
INoticeDTO noticeDTO = null;
foreach (Notice notice in noticeList)
{
noticeDTO = (INoticeDTO)DTOFactory.Instance.Create(DTOType.NoticeDTO);
noticeDTO.PostedByEmployee = (IEmployeeDTO)DTOFactory.Instance.Create(DTOType.EmployeeDTO);
EntityConverter.FillDTOFromEntity(notice, noticeDTO);
EntityConverter.FillDTOFromEntity(notice.Employee, noticeDTO.PostedByEmployee);
noticeDTOList.Add(noticeDTO);
}
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
return(noticeDTOList);
}
public IHttpActionResult Create([FromBody] Answers answer)
{
answer.Created = DateTime.Now;
IAnswerDTO answerDTO = (IAnswerDTO)DTOFactory.Instance.Create(DTOType.AnswerDTO);
EntityConverter.FillDTOFromEntity(answer, answerDTO);
IAnswerFacade answerFacade = (IAnswerFacade)FacadeFactory.Instance.Create(FacadeType.AnswerFacade);
OperationResult <IAnswerDTO> result = answerFacade.Create(answerDTO);
if (result.ResultType == OperationResultType.Failure)
{
string failed = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(failed));
}
if (result.IsValid())
{
//Answers answerEntity = new Answers();
EntityConverter.FillEntityFromDTO(result.Data, answer);
string success = JsonConvert.SerializeObject(new { success = true, data = answer });
return(Ok(success));
}
string jsonObj = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(jsonObj));
}
public IHttpActionResult Create([FromBody] Questions data)
{
IQuestionDTO dataDTO = (IQuestionDTO)DTOFactory.Instance.Create(DTOType.QuestionDTO);
EntityConverter.FillDTOFromEntity(data, dataDTO);
dataDTO.Created = DateTime.Now;
IQuestionFacade questionFacade = (IQuestionFacade)FacadeFactory.Instance.Create(FacadeType.QuestionFacade);
OperationResult <IQuestionDTO> result = questionFacade.Create(dataDTO);
if (result.ResultType == OperationResultType.Failure)
{
string failed = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(failed));
}
if (result.IsValid())
{
Questions question = new Questions();
EntityConverter.FillEntityFromDTO(result.Data, question);
string success = JsonConvert.SerializeObject(new { success = true, data = question });
return(Ok(success));
}
string jsonObj = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(jsonObj));
}
public IHttpActionResult Register([FromBody] User user)
{
user.Created = DateTime.Now;
IUserDTO userDTO = (IUserDTO)DTOFactory.Instance.Create(DTOType.UserDTO);
EntityConverter.FillDTOFromEntity(user, userDTO);
IUserFacade userFacade = (IUserFacade)FacadeFactory.Instance.Create(FacadeType.UserFacade);
OperationResult <IUserDTO> result = userFacade.Register(userDTO);
if (result.ResultType == OperationResultType.Failure)
{
string failed = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(failed));
}
if (result.IsValid())
{
EntityConverter.FillEntityFromDTO(result.Data, user);
string success = JsonConvert.SerializeObject(new { success = true, data = user });
return(Ok(success));
}
string jsonObj = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(jsonObj));
}
public IList <IEventDTO> GetEvents()
{
IList <IEventDTO> result = null;
var eventList = eventRepository.GetEvents();
try
{
if (eventList.Count > 0)
{
result = new List <IEventDTO>();
IEventDTO eventDTO = null;
foreach (var _event in eventList)
{
eventDTO = (IEventDTO)DTOFactory.Instance.Create(DTOType.EventDTO);
EntityConverter.FillDTOFromEntity(_event, (DTOBase)eventDTO);
result.Add(eventDTO);
}
}
// return result;
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
return(result);
}
public IList <IUserDTO> GetAdmins()
{
IList <IUserDTO> userDTOList = null;
try
{
using (EmployeePortal2017Entities portal = new EmployeePortal2017Entities())
{
var userList = portal.Users.Include("Employee").Where(u => u.IsAdmin == true).ToList();
if (userList.Count > 0)
{
userDTOList = new List <IUserDTO>();
IUserDTO userDTO = null;
foreach (var user in userList)
{
userDTO = (IUserDTO)DTOFactory.Instance.Create(DTOType.UserDTO);
EntityConverter.FillDTOFromEntity(user, userDTO);
userDTO.EmployeeDTO = (IEmployeeDTO)DTOFactory.Instance.Create(DTOType.EmployeeDTO);
EntityConverter.FillDTOFromEntity(user.Employee, userDTO.EmployeeDTO);
userDTOList.Add(userDTO);
}
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
return(userDTOList);
}
