public ActionResult Create(NewAssignmentsViewModel model)
{
try
{
var repository = new AssignedRepository(context);
if (ModelState.IsValid)
{
var assignedCourse = MapperHelpers.Map <AssignedCourse>(model);
var individual = MapperHelpers.Map <Individual>(model);
assignedCourse.IsCompleted = false;
repository.Insert(assignedCourse);
context.SaveChanges();
return(RedirectToAction("Index"));
}
model.CourseList = PopulateCourses(model.CourseId);
model.IndividualList = PopulateIndividuals(model.IndividualId);
return(View(model));
}
catch (Exception ex)
{
model.CourseList = PopulateCourses(model.CourseId);
model.IndividualList = PopulateIndividuals(model.IndividualId);
return(View(model));
}
}
public ActionResult Create(NewIndividualViewModel model)
{
try
{
// TODO: Add insert logic here
if (ModelState.IsValid)
{
var repo = new IndividualRepository(context);
var individualQry = new Individual {
Email = model.Email
};
var emailExiste = repo.QueryByExample(individualQry).Count > 0;
if (!emailExiste)
{
var individual = MapperHelpers.Map <Individual>(model);
repo.Insert(individual);
context.SaveChanges();
}
else
{
ModelState.AddModelError("Email", "El Email está ocupado");
return(View(model));
}
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Details(int id)
{
try
{
var repo = new IndividualRepository(context);
var repoAssignment = new AssignedRepository(context);
var repoCursos = new CourseRepository(context);
var individual = repo.Find(id);
var indi = MapperHelpers.Map <IndividualViewModel>(individual);
var assginments = repoAssignment.Query(x => x.IndividualId == individual.Id).OrderByDescending(x => x.AssingmentDate).ToList();
foreach (var item in assginments)
{
var course = repoCursos.Query(x => x.Id == item.CourseId).ToList();
var courseModel = MapperHelpers.Map <ICollection <CoursesViewModel> >(course).SingleOrDefault();
indi.Courses.Add(courseModel);
}
return(View(indi));
}
catch (Exception ex)
{
return(RedirectToAction("Index"));
}
}
public ActionResult Edit(int id, CourseViewModel model)
{
var topicRepository = new TopicRepository(context);
try
{
// TODO: Add update logic here
var repository = new CourseRepository(context);
if (ModelState.IsValid)
{
var course = MapperHelpers.Map <Course>(model);
repository.UpdateCourseWithTopic(course, model.SelectedTopics);
context.SaveChanges();
return(RedirectToAction("Index"));
}
var topics = topicRepository.Query(null, "Name");
model.AvailableTopics = MapperHelpers.Map <ICollection <TopicViewModel> >(topics);
return(View(model));
}
catch (Exception ex)
{
var topics = topicRepository.Query(null, "Name");
model.AvailableTopics = MapperHelpers.Map <ICollection <TopicViewModel> >(topics);
return(View(model));
}
}
public ActionResult Create(CourseViewModel model)
{
try
{
var repository = new CourseRepository(context);
// TODO: Add insert logic here
if (ModelState.IsValid)
{
var courses = MapperHelpers.Map <Course>(model);
repository.InsertCourseWithTopic(courses, model.SelectedTopics);
context.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
var topicRepository = new TopicRepository(context);
var topics = topicRepository.Query(null, "Name DESC");
model.AvailableTopics = MapperHelpers.Map <ICollection <TopicViewModel> >(topics);
return(View(model));
}
}
catch
{
return(View());
}
}
public ActionResult Edit(int id, EditIndividualViewModel model)
{
try
{
var repo = new IndividualRepository(context);
if (model.Email != model.EmailAnterior)
{
var existeEmail = repo.Query(x => x.Email == model.Email && x.Id != model.Id).Count() > 0;
if (existeEmail)
{
ModelState.AddModelError("Email", "El email está ocupado");
return(View());
}
}
else
{
ModelState.Remove("Email");
}
// TODO: Add update logic here
if (ModelState.IsValid)
{
var individual = MapperHelpers.Map <Individual>(model);
repo.Update(individual);
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public static void Register(IServiceCollection services)
{
services.AddScoped <Mapper>((provider) =>
{
return(MapperHelpers.GetConfiguredMapper());
});
}
// GET: Invidivual/Edit/5
public ActionResult Edit(int id)
{
var repo = new IndividualRepository(context);
var model = repo.Find(id);
var individual = MapperHelpers.Map <EditIndividualViewModel>(model);
return(View(individual));
}
// GET: Invidivual
public ActionResult Index()
{
var repository = new IndividualRepository(context);
var individuals = repository.GetAll();
var model = MapperHelpers.Map <IEnumerable <IndividualViewModel> >(individuals);
return(View(model));
}
// GET: Course
public ActionResult Index()
{
var repository = new CourseRepository(context);
var courses = repository.Query(null, "Name");
var model = MapperHelpers.Map <IEnumerable <CourseViewModel> >(courses);
return(View(model));
}
// GET: Course/Create
public ActionResult Create()
{
var model = new CourseViewModel();
var topicRepository = new TopicRepository(context);
var topics = topicRepository.Query(null, "Name DESC");
model.AvailableTopics = MapperHelpers.Map <ICollection <TopicViewModel> >(topics);
return(View(model));
}
// GET: Course/Details/5
public ActionResult Details(int id)
{
var repository = new CourseRepository(context);
var includes = new Expression <Func <Course, object> >[] { x => x.Topics };
var courses = repository.QueryIncluding(x => x.Id == id, includes).SingleOrDefault();
var models = MapperHelpers.Map <DetailsCourseViewModel>(courses);
return(View(models));
}
// GET: Course/Delete/5
public ActionResult Delete(int id)
{
var repository = new CourseRepository(context);
var cursos = repository.Find(id);
var model = MapperHelpers.Map <CourseViewModel>(cursos);
return(View(model));
}
public static void ConfigureMvc(this IMapperConfigurationExpression config)
{
config.CreateMap <SearchOptions, Data.DTO.SearchOptions>()
.ForMember(v => v.beginDate, opt => opt.MapFrom(d => d.beginDate ?? new DateTime(1753, 1, 1)))
.ForMember(v => v.endDate, opt => opt.MapFrom(d => d.endDate ?? DateTime.MaxValue))
.ForMember(v => v.dwccardnum, opt => opt.MapFrom(d => d.dwccardnum ?? 0));
config.CreateMap <jQueryDataTableParam, viewOptions>()
.ForMember(vo => vo.CI, opt => opt.Ignore())
.ForMember(vo => vo.employerGuid, opt => opt.Ignore()) // API-only option
.ForMember(vo => vo.personID, opt => opt.MapFrom(dt => dt.personID ?? 0))
.ForMember(vo => vo.emailID,
opt => opt.MapFrom(dt =>
string.IsNullOrEmpty(dt.searchColName("emailID"))
? null
: (int?)Convert.ToInt32(dt.searchColName("emailID"))))
.ForMember(vo => vo.onlineSource,
opt => opt.MapFrom(dt =>
string.IsNullOrEmpty(dt.searchColName("onlineSource"))
? null
: dt.searchColName("onlineSource")))
.ForMember(vo => vo.status,
opt => opt.MapFrom(dt =>
string.IsNullOrEmpty(dt.searchColName("status"))
? null
: (int?)Convert.ToInt32(dt.searchColName("status"))))
.ForMember(vo => vo.EmployerID,
opt => opt.MapFrom(dt =>
string.IsNullOrEmpty(dt.searchColName("EID"))
? null
: (int?)Convert.ToInt32(dt.searchColName("EID"))))
.ForMember(vo => vo.sortColName, opt => opt.MapFrom(dt => dt.sortColName()))
.ForMember(vo => vo.dwccardnum, opt => opt.MapFrom(dt => Convert.ToInt32(dt.dwccardnum)))
.ForMember(vo => vo.woid, opt => opt.MapFrom(dt => Convert.ToInt32(dt.searchColName("WOID"))))
.ForMember(vo => vo.date, opt => opt.MapFrom(dt => MapperHelpers.DataTablesToUtc(dt.todaysdate)))
.ForMember(vo => vo.displayStart, opt => opt.MapFrom(dt => dt.iDisplayStart))
.ForMember(vo => vo.displayLength, opt => opt.MapFrom(dt => dt.iDisplayLength))
.ForMember(vo => vo.orderDescending, opt => opt.MapFrom(dt => dt.sSortDir_0 != "asc"));
config.AddProfile <EmailProfile>();
config.AddProfile <EmployerProfile>();
config.AddProfile <WorkOrderProfile>();
config.AddProfile <WorkAssignmentProfile>();
config.AddProfile <WorkerSigninProfile>();
config.AddProfile <PersonProfile>();
config.AddProfile <WorkerProfile>();
config.AddProfile <ActivityProfile>();
config.AddProfile <ActivitySigninProfile>();
config.AddProfile <EventProfile>();
config.AddProfile <LookupProfile>();
config.AddProfile <WorkOrderMap>();
config.AddProfile <EmployersMap>();
config.AddProfile <WorkerRequestProfile>();
}
public ActionResult Edit(int id)
{
var repository = new AssignedRepository(context);
var includes = new Expression <Func <AssignedCourse, object> >[] { x => x.Course, x => x.Individual };
var criteria = new AssignedCourse {
Id = id
};
var courses = repository.QueryByExampleIncludig(criteria, includes).SingleOrDefault();
var model = MapperHelpers.Map <EditAssignmentViewModel>(courses);
return(View(model));
}
public ReportDefinitionsMap()
{
CreateMap <ReportDefinition, ReportDefinitionVM>()
.ForMember(v => v.id, opt => opt.MapFrom(d => d.ID))
.ForMember(v => v.columns, opt => opt.MapFrom(d => JsonConvert.DeserializeObject(d.columnsJson)))
.ForMember(v => v.inputs, opt => opt.MapFrom(d => JsonConvert.DeserializeObject(d.inputsJson)))
;
CreateMap <ReportDefinitionVM, ReportDefinition>()
.ForMember(d => d.ID, opt => opt.MapFrom(v => v.id))
.ForMember(d => d.inputsJson, opt => opt.MapFrom(v => JsonConvert.SerializeObject(v.inputs)))
.ForMember(d => d.columnsJson, opt => opt.MapFrom(v => JsonConvert.SerializeObject(v.columns)))
.ForMember(d => d.name, opt => opt.MapFrom(v => MapperHelpers.NormalizeName(v.commonName)))
;
}
// GET: Course/Edit/5
public ActionResult Edit(int id)
{
var repository = new CourseRepository(context);
var repoTopics = new TopicRepository(context);
var includes = new Expression <Func <Course, object> >[] { x => x.Topics };
var courses = repository.QueryIncluding(x => x.Id == id, includes).SingleOrDefault();
var models = MapperHelpers.Map <CourseViewModel>(courses);
var topics = repoTopics.Query(null, "Name");
models.AvailableTopics = MapperHelpers.Map <ICollection <TopicViewModel> >(topics);
models.SelectedTopics = courses.Topics.Select(x => x.Id.Value).ToArray();
return(View(models));
}
public ActionResult <ReportDefinitionVM> Create([FromBody] ReportDefinitionVM reportDefinitionVM)
{
/***
* Applies to both Put and Create
* Return all errors in the format:
* new { errors = errorLabel, errorsList) }
* where label is a string and error list is a list of strings
* You can use the private method ArrangeReportErrors() to simply return
* new { errors = ArrangeReportErrors("sqlQuery", validationMessages) }
* The frontend client expects this as it is also the format that is returned
* with ModelState errors.
***/
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// if common name converted to name as ID already exists
if (serv.Exists(MapperHelpers.NormalizeName(reportDefinitionVM.commonName)))
{
return(BadRequest("Report with this name already exists"));
}
string query = reportDefinitionVM.sqlquery;
try {
var validationMessages = serv.ValidateQuery(query);
if (validationMessages.Count == 0)
{
var createdRecord = serv.Create(map.Map <ReportDefinition>(reportDefinitionVM), UserEmail);
// return StatusCode((int)HttpStatusCode.OK);
return(CreatedAtAction(nameof(Get), new { createdRecord.name }, new { data = map.Map <ReportDefinitionVM>(createdRecord) }));
}
else
{
// 400; we wanted validation messages, and got them.
return(BadRequest(new { errors = ArrangeReportErrors("sqlQuery", validationMessages) }));
}
} catch (Exception ex) {
// SQL errors are expected but they will be returned as strings (400).
// in this case, something happened that we were not expecting; return 500.
var message = ex.Message;
return(StatusCode((int)HttpStatusCode.InternalServerError,
new { errors = ArrangeReportErrors("Server Error", new List <string>()
{
ex.Message
}) }));
}
}
public async Task ShouldCreateUser()
{
var dto = new UserDto
{
UserName = "******"
};
var mapper = MapperHelpers.GetConfiguredMapper();
var repository = new TestRepository <User>();
var userService = new UserService(repository, mapper);
await userService.CreateUserAsync(dto);
Assert.Contains(await repository.AllAsync(), (u) => u.Username == dto.UserName);
}
public WorkOrderProfile()
{
CreateMap <WorkOrder, ViewModel.WorkOrder>()
.ForMember(v => v.tabref, opt => opt.MapFrom(d => "/WorkOrder/Edit/" + Convert.ToString(d.ID)))
.ForMember(v => v.tablabel, opt => opt.MapFrom(d =>
WorkOrders.tabprefix +
Convert.ToString(d.paperOrderNum) +
" @ " + d.workSiteAddress1))
.ForMember(v => v.EID, opt => opt.MapFrom(d => Convert.ToString(d.EmployerID)))
.ForMember(v => v.WOID, opt => opt.MapFrom(d => string.Format("{0,5:D5}", d.paperOrderNum)))
.ForMember(v => v.dateTimeofWork, opt => opt.MapFrom(d => d.dateTimeofWork.UtcToClientString()))
.ForMember(v => v.dateupdatedstring, opt => opt.MapFrom(d => string.Format("{0:MM/dd/yyyy HH:mm:ss}", d.dateupdated)))
.ForMember(v => v.onlineSource, opt => opt.MapFrom(d => d.onlineSource))
.ForMember(v => v.recordid, opt => opt.MapFrom(d => Convert.ToString(d.ID)))
.ForMember(v => v.transportMethod, opt => opt.MapFrom(d => getCI() == "ES" ? d.transportMethodES : d.transportMethodEN))
.ForMember(v => v.def, opt => opt.MapFrom(d => MapperHelpers.Defaults))
.ForMember(v => v.idString, opt => opt.Ignore())
.ForMember(v => v.datecreatedstring, opt => opt.Ignore())
.ForMember(v => v.workAssignments, opt => opt.MapFrom(d => d.workAssignments)).MaxDepth(3)
//.ForMember(v => v.workAssignments, opt => opt.Condition(d => d.workAssignments.Count > 0)).MaxDepth(3)
.ForMember(v => v.workerRequestsAAA, opt => opt.MapFrom(d => d.workerRequestsDDD))
//.ForMember(v => v.workerRequestsAAA, opt => opt.Condition(d => d.workerRequestsDDD.Count > 0))
;
//
//
CreateMap <WorkOrdersList, ViewModel.WorkOrdersList>()
.ForMember(v => v.tabref, opt => opt.MapFrom(d => $"/WorkOrder/Edit/{d.ID.ToString()}"))
.ForMember(v => v.tablabel, opt =>
opt.MapFrom(d =>
$"{WorkOrders.tabprefix}{d.paperOrderNum.ToString()} @ {d.workSiteAddress1}"
)
)
.ForMember(v => v.EID, opt => opt.MapFrom(d => Convert.ToString(d.EmployerID)))
.ForMember(v => v.WOID, opt => opt.MapFrom(d => $"{d.paperOrderNum,5:D5}"))
.ForMember(v => v.dateTimeofWork, opt => opt.MapFrom(d => d.dateTimeofWork.UtcToClientString()))
.ForMember(v => v.dateupdated, opt => opt.MapFrom(d => d.dateupdated.UtcToClientString()))
.ForMember(v => v.status, opt => opt.MapFrom(d => getCI() == "ES" ? d.statusES : d.statusEN))
.ForMember(v => v.transportMethod, opt => opt.MapFrom(d => getCI() == "ES" ? d.transportMethodES : d.transportMethodEN))
.ForMember(v => v.displayState, opt => opt.MapFrom(d => MapperHelpers.ComputeOrderStatus(d)))
.ForMember(v => v.recordid, opt => opt.MapFrom(d => d.ID.ToString()))
;
CreateMap <WorkerAssignedList, ViewModel.WorkerAssignedList>()
.ForMember(v => v.skill, opt => opt.MapFrom(d => getCI() == "ES" ? d.skillES : d.skillEN))
;
}
// GET: Assignment
public ActionResult Index(string searchTerm = null, string tipo = null)
{
var repository = new AssignedRepository(context);
var includes = new Expression <Func <AssignedCourse, object> >[] { x => x.Course, x => x.Individual };
if (tipo == "Persona")
{
var courses = repository.QueryIncluding(null, includes, "AssingmentDate").Where(a => searchTerm == null || a.Individual.Name.StartsWith(searchTerm));
var model = MapperHelpers.Map <ICollection <AssignmentViewModel> >(courses);
return(View(model));
}
else
{
var courses = repository.QueryIncluding(null, includes, "AssingmentDate").Where(a => searchTerm == null || a.Course.Name.StartsWith(searchTerm));
var model = MapperHelpers.Map <ICollection <AssignmentViewModel> >(courses);
return(View(model));
}
}
// public Map<TDestination, TSource> FilterMembers(BindingFlags bindingFlags)
// {
// BindingFlags = bindingFlags;
// return this;
// }
// public Map<TDestination, TSource> FilterMembers(IModelValueMemberFilter filter)
// {
// if (filter == null) throw new ArgumentNullException(nameof(filter));
//
// var filters = Filters ?? (Filters = new List<IModelValueMemberFilter>());
//
// filters.Add(filter);
//
// return this;
// }
/// <summary>
/// Creates a list of <see cref="Mapping"/> from current mapping.
/// </summary>
/// <returns></returns>
public IEnumerable <Mapping> CreateRows()
{
var row = new Mapping(
typeof(TDestination),
typeof(TSource),
MapperHelpers.GetMemberMappings(
typeof(TDestination),
typeof(TSource),
DestinationBindingFlags,
SourceBindingFlags,
MemberMatchingStrategy ?? MapperMemberExactMatchingStrategy.Instance,
DestinationFilters,
SourceFilters,
MappingType
)
);
return(new[] { row });
}
public ActionResult Delete(int id, IndividualViewModel model)
{
try
{
var repo = new IndividualRepository(context);
//if (ModelState.IsValid)
//{
var individual = MapperHelpers.Map <Individual>(model);
repo.Delete(individual);
context.SaveChanges();
//}
// TODO: Add delete logic here
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Edit(int id, EditAssignmentViewModel model)
{
try
{
var repository = new AssignedRepository(context);
if (ModelState.IsValid)
{
var update = MapperHelpers.Map <AssignedCourse>(model);
repository.Update(update);
context.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
return(HttpNotFound());
}
}
catch (Exception ex)
{
ViewBag.MessageError = ex.Message;
return(View(model));
}
}
public BlackListServiceTest()
{
_mapper = MapperHelpers.GetConfiguredMapper();
}
public MessageServiceTests()
{
_mapper = MapperHelpers.GetConfiguredMapper();
}
public ConversationUserServiceTest()
{
_mapper = MapperHelpers.GetConfiguredMapper();
}
