public async Task <IActionResult> AddWork([FromBody] WorkDTO workDTO)
{
var user = await userManager.FindByNameAsync(currentUserAccessor.GetCurrentUsername());
if (user != null)
{
var work = new Work()
{
Name = workDTO.Name,
Author = user,
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now,
Body = workDTO.Body,
Slug = workDTO.Name.GenerateSlug()
};
List <WorkGenre> workGenres = new List <WorkGenre>();
foreach (var genre in workDTO.Genres)
{
if (context.Genres.Where(g => g.Name == genre).Any())
{
workGenres.Add(new WorkGenre()
{
Genre = context.Genres.Where(g => g.Name == genre).FirstOrDefault(),
Work = work
});
}
}
work.WorkGenres = workGenres;
context.Works.Add(work);
user.Works.Add(work);
await context.SaveChangesAsync();
}
return(Ok());
}
public static void Insert(WorkDTO workDTO)
{
string sql = "insert into WorkAssign(UserID, TimeStart, TimeEnd, Computer) values ('" + workDTO.UserID + "', '" + workDTO.TimeStart + "', '" +
workDTO.TimeEnd + "', '" + workDTO.Computer + "')";
Database.ExcuNonQuery(sql);
}
public async Task <WorkDTO> CreateAsync(WorkDTO dto)
{
var subcategory = await _unitOfWork.SubcategoryRepository.GetByIdAsync(dto.SubcategoryId);
var vendor = await _unitOfWork.VendorRepository.GetByIdAsync(dto.VendorId);
var company = await _unitOfWork.CompanyRepository.GetByIdAsync(dto.CompanyId);
var work = new Work()
{
Name = dto.Name,
Description = dto.Description,
Icon = dto.Icon,
IsDeleted = false,
Subcategory = subcategory,
Vendor = vendor,
Company = company
};
_unitOfWork.WorkRepository.Create(work);
await _unitOfWork.SaveAsync();
dto.Id = work.Id;
return(dto);
}
public async Task <bool> UpDateAsync(WorkDTO workDTO)
{
var work = _mapper.Map <WorkDTO, Work>(workDTO);
var result = await _workRepository.Update(work);
return(result);
}
public async Task <IActionResult> GetWork(string slug)
{
var works = await context.Works.Include(x => x.Author).Include(x => x.WorkGenres).Include(x => x.Comments).ToListAsync();
var work = works.Find(work => work.Slug == slug);
List <CommentDTO> commentDTOs = new List <CommentDTO>();
foreach (var comment in work.Comments)
{
commentDTOs.Add(new CommentDTO()
{
AuthorName = comment.Author.UserName,
CreationDate = comment.CreationDate,
Value = comment.Value,
WorkSlug = work.Slug
});
}
WorkDTO workDTO = new WorkDTO()
{
AuthorName = work.Author.UserName,
Genres = WorkGenre.GenresToList(work.WorkGenres),
Name = work.Name,
Body = work.Body,
Comments = commentDTOs,
Slug = work.Slug
};
return(Ok(workDTO));
}
/// <summary>
/// Yeni bir görev ekler
/// </summary>
public async Task <bool> Add(WorkDTO model)
{
var work = _mapper.Map <Work>(model);
await _context.Works.AddAsync(work);
return(await _context.SaveChangesAsync() > 0);
}
public async Task <IActionResult> Post(WorkDTO workDTO)
{
var work = _mapper.Map <Work>(workDTO);
await _workService.InsertWork(work);
return(Created(nameof(Get), new { id = work.WorkID, workDTO }));
}
public async Task<HttpResponseMessage> CreateVendorWork(long id, [FromBody]WorkDTO workDto)
{
workDto.VendorId = id;
var result = await _workService.CreateAsync(workDto);
if (result == null)
return Request.CreateResponse(HttpStatusCode.NotFound);
else
return Request.CreateResponse(HttpStatusCode.Created, result);
}
public async Task <IActionResult> AddWork(int userId, [FromBody] WorkDTO workForAddd)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
await _repo.AddWork(userId, workForAddd);
return(Ok());
}
public async Task <Work> AddWork(int userId, WorkDTO workDTO)
{
var work = new Work(workDTO.Company, workDTO.Speciality,
workDTO.StartDate, workDTO.FinishDate, workDTO.Description, userId);
await _context.Work.AddAsync(work);
await _context.SaveChangesAsync();
return(work);
}
public async Task <ActionResult <WorkDTO> > Put(WorkDTO workDTO)
{
if (workDTO == null)
{
return(BadRequest());
}
await _workService.UpDateAsync(workDTO);
return(Ok(workDTO));
}
public void CreateWork(WorkDTO workDto)
{
var work = new Work
{
Title = workDto.Title,
Description = workDto.Description,
Cost = workDto.Cost,
UserId = workDto.UserId
};
_repository.Save(work);
}
public Work EditWork(int workId, WorkDTO workDTO)
{
var editWork = _context.Work.Find(workId);
editWork.Company = workDTO.Company;
editWork.Speciality = workDTO.Speciality;
editWork.StartDate = workDTO.StartDate;
editWork.FinishDate = workDTO.FinishDate;
editWork.Description = workDTO.Description;
return(editWork);
}
public static void doLogOut()
{
if (Program.CurrentUserID != null)
{
Program.EndWorkTime = DateTime.Now;
WorkDTO workDTO = new WorkDTO();
workDTO.UserID = Program.CurrentUserID;
workDTO.TimeStart = Program.StartWorkTime;
workDTO.TimeEnd = Program.EndWorkTime;
workDTO.Computer = Environment.MachineName;
WorkDAO.Insert(workDTO);
}
}
public async Task <IActionResult> Add([FromBody] WorkDTO model)
{
var result = await _workService.Add(model);
if (result)
{
return(CreatedAtAction(nameof(Add), null));
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> EditWork(int userId, int id,
[FromBody] WorkDTO workForEdit)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
_repo.EditWork(id, workForEdit);
await _repo.SaveAll();
return(Ok());
}
public IActionResult Create(CreateWorkViewModel viewModel)
{
var work = new WorkDTO
{
Title = viewModel.Title,
Description = viewModel.Description,
Cost = viewModel.Cost,
UserId = _middleware.GetUser().Id
};
_service.CreateWork(work);
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> Update([FromQuery] Guid id, [FromBody] WorkDTO model)
{
var result = await _workService.Update(id, model);
if (result)
{
return(Ok());
}
else
{
return(NotFound());
}
}
/// <summary>
/// Görevi günceller
/// </summary>
public async Task <bool> Update(Guid id, WorkDTO model)
{
var work = await _context.Works.SingleOrDefaultAsync(x => x.WorkId == id);
if (work == null)
{
return(false);
}
_mapper.Map(model, work);
return(await _context.SaveChangesAsync() > 0);
}
public async Task UpdateAsync(WorkDTO dto)
{
var subcategory = await _unitOfWork.SubcategoryRepository.GetByIdAsync(dto.SubcategoryId);
var work = await _unitOfWork.WorkRepository.GetByIdAsync(dto.Id);
work.Name = dto.Name;
work.Description = dto.Description;
work.Icon = dto.Icon;
work.Subcategory = subcategory;
_unitOfWork.WorkRepository.Update(work);
await _unitOfWork.SaveAsync();
}
public void add_work()
{
WorkDTO workDTO = new WorkDTO();
workDTO.Id = 0;
workDTO.IdWorkList = int.Parse(Request.Form["addwork_id_worklist"]);
workDTO.WorkName = Request.Form["Add_WorkName"];
workDTO.WorkContent = Request.Form["Add_WorkContent"];
workDTO.StartDate = DateTime.Parse(Request.Form["Add_WorkStartDate"]);
workDTO.EndDate = DateTime.Parse(Request.Form["Add_WorkEndDate"]);
workDTO.IdWorkStatus = 1;
int id_employee = int.Parse(Request.Form["addwork_id_employee"]);
workService.save(workDTO, id_employee);
Response.Redirect("/employee?danhsachcongviec=" + workDTO.IdWorkList);
}
public void edit_work()
{
WorkDTO workDTO = new WorkDTO();
workDTO.Id = int.Parse(Request.Form["editwork_id_work"]);
workDTO.IdWorkList = int.Parse(Request.Form["id_Edit_WorkList"]);
workDTO.WorkName = Request.Form["Edit_WorkName"];
workDTO.WorkContent = Request.Form["Edit_WorkContent"];
workDTO.StartDate = DateTime.Parse(Request.Form["Edit_WorkStartDate"]);
workDTO.EndDate = DateTime.Parse(Request.Form["Edit_WorkEndDate"]);
workDTO.IdWorkStatus = int.Parse(Request.Form["id_Edit_WorkStatus"]);
int id_employee = int.Parse(Request.Form["editwork_id_employee"]);
workService.save(workDTO, id_employee);
Response.Redirect("/employee?congviec=" + workDTO.Id);
}
public async Task <IActionResult> EditWork([FromBody] WorkDTO edit)
{
var work = await context.Works.Include(x => x.WorkGenres).Include(x => x.Author).Where(x => x.Slug == edit.Slug).FirstOrDefaultAsync();
if (work == null)
{
return(StatusCode(StatusCodes.Status404NotFound, new { Status = "Error", Message = "Work not found" }));
}
work.Body = edit.Body;
work.Name = edit.Name;
work.Slug = edit.Name.GenerateSlug();
List <WorkGenre> workGenres = new List <WorkGenre>();
foreach (var genre in edit.Genres)
{
if (context.Genres.Where(g => g.Name == genre).Any())
{
workGenres.Add(new WorkGenre()
{
Genre = context.Genres.Where(g => g.Name == genre).FirstOrDefault(),
Work = work
});
}
}
work.WorkGenres = workGenres;
if (context.ChangeTracker.Entries().First(x => x.Entity == work).State == EntityState.Modified)
{
work.UpdatedAt = DateTime.Now;
}
await context.SaveChangesAsync();
return(Ok());
}
public WorkDTO save(WorkDTO work, int idEmployee)
{
return(mapper.Map <Work, WorkDTO>(workRepository.save(mapper.Map <WorkDTO, Work>(work), idEmployee)));
}
public async Task<HttpResponseMessage> UpdateVendorWork(long id, long workId, [FromBody]WorkDTO workDto)
{
await _workService.UpdateAsync(workDto);
return Request.CreateResponse(HttpStatusCode.OK);
}
public async Task <ActionResult <WorkDTO> > Post([FromBody] WorkDTO workDTO)
{
await _workService.UpDateAsync(workDTO);
return(Ok(workDTO));
}
