/// <summary>
/// Use this method for your mainlinks. Eg CRUD, just add
/// more links to your CRUD methods inside
/// Wollter
/// </summary>
/// <param name="movie"></param>
/// <returns></returns>
internal ActorDTO HateoasMainLinks(ActorDTO actorDto)
{
actorDto.Links.Add(UrlLink("_self", "GetActorById", new { id = actorDto.ActorId }));
//actorDto.Links.Add(UrlLink("all", "GetAllActors", null));
return(actorDto);
}
public void addNewActor(ActorDTO actorDTO)
{
User user2add = new User
{
Username = actorDTO.Username,
Password = actorDTO.Password,
FullName = actorDTO.FullName,
Sex = actorDTO.Sex,
Image = actorDTO.Image,
Description = actorDTO.Description,
Phone = actorDTO.Phone,
Email = actorDTO.Email,
Dob = actorDTO.DOB,
CreateOnDt = actorDTO.CreateOnDT,
IsAdmin = actorDTO.IsAdmin,
Status = actorDTO.Status
};
_context.Users.Add(user2add);
try
{
_context.SaveChanges();
}
catch (DbUpdateException)
{
throw;
}
}
public IHttpActionResult CreateActor(ActorDTO actorDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest("Existen Campos invalidos"));
}
var movies = actorDTO.Movies.Select(a => a.ID);
var Movies = _contex.Movies.Where(a => movies.Contains(a.ID)).ToList();
var actor = Mapper.Map <ActorDTO, Actor>(actorDTO);
actor.Movies = Movies;
try
{
_contex.Actors.Add(actor);
_contex.SaveChanges();
}
catch (Exception e)
{
Console.WriteLine(e);
}
actorDTO.ID = actor.ID;
return(Created(new Uri(Request.RequestUri + "" + actor.ID), actorDTO));
}
public void AddMovie(MovieDTO movieDTO)
{
int movieId = _movieRepository.AddMovie(movieDTO);
if (movieDTO.Actors == null || !movieDTO.Actors.Any())
{
return;
}
List <int> actorsIds = new List <int>();
foreach (string actor in movieDTO.Actors)
{
ActorDTO actorFromDb = _actorRepository.GetActorByName(actor);
if (actorFromDb == null)
{
actorsIds.Add(_actorRepository.AddActor(new ActorDTO {
ActorName = actor
}));
}
else
{
actorsIds.Add(actorFromDb.ActorId);
}
}
foreach (int actorId in actorsIds)
{
_actorRepository.AddActorByMovieId(actorId, movieId);
}
}
public bool updateActor(ActorDTO actorDTO)
{
var user = _context.Users.Where(actInfo => actInfo.IsAdmin == 0 && actInfo.Username == actorDTO.Username).FirstOrDefault();
if (user == null)
{
return(false);
}
user.FullName = actorDTO.FullName;
user.Sex = actorDTO.Sex;
user.Image = actorDTO.Image;
user.Description = actorDTO.Description;
user.Phone = actorDTO.Phone;
user.Email = actorDTO.Email;
user.Dob = actorDTO.DOB;
user.UpdateBy = actorDTO.UpdateBy;
user.UpdateOnDt = actorDTO.updateOnDT;
user.IsAdmin = actorDTO.IsAdmin;
user.Status = actorDTO.Status;
try
{
_context.SaveChanges();
return(true);
}
catch (DbUpdateException)
{
throw;
}
}
public IEnumerable <ActorDTO> Execute(ActorDTO request)
{
var actors = context.Actors.AsQueryable();
if (request != null)
{
if (request.FirstName != null)
{
var fname = request.FirstName.ToLower();
actors = actors.Where(af => af.FirstName.Contains(fname));
}
if (request.LastName != null)
{
var lname = request.LastName.ToLower();
actors = actors.Where(al => al.LastName.Contains(lname));
}
}
actors = actors.Where(aa => aa.IsDeleted == false);
return(actors.Select(a => new ActorDTO
{
Id = a.Id,
FirstName = a.FirstName,
LastName = a.LastName
}).ToList());
}
public static void assignMovie(MovieDTO movieDTO, ActorDTO actorDTO)
{
DBaccess.Movie.FirstOrDefault(x => x.idJob == movieDTO.Id).Job.assigned = true;
getMovieById(movieDTO.Id).idActor = UserServiceDB.getActorById(actorDTO.Id).id;
//DBaccess.Movie.FirstOrDefault(x => x.idJob == movieDTO.Id).idActor = (DBaccess.Actor.FirstOrDefault(x => x.Client.User.id == actorDTO.Id).id);
DBaccess.SaveChanges();
}
public void Execute(ActorDTO request)
{
var actor = Context.Actors.Find(request.Id);
if (actor == null || actor.Deleted == true)
{
throw new DataNotFoundException();
}
if (actor.ActorFirstName != request.ActorFirstName ||
actor.ActorLastName != request.ActorLastName)
{
if (Context.Actors.Any(f => f.ActorFirstName == request.ActorFirstName) &&
Context.Actors.Any(f => f.ActorLastName == request.ActorLastName))
{
throw new DataAlreadyExistsException();
}
actor.ActorFirstName = request.ActorFirstName;
actor.ActorLastName = request.ActorLastName;
actor.UpdatedAt = DateTime.Now;
Context.SaveChanges();
}
else
{
throw new DataNotAlteredException();
}
}
public IHttpActionResult UpdateActor(int id, ActorDTO actorDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest("Existen Campos invalidos"));
}
var actor = _contex.Actors.SingleOrDefault(a => a.ID == id);
if (actor == null)
{
return(NotFound());
}
Mapper.Map <ActorDTO, Actor>(actorDTO, actor);
var movies = actorDTO.Movies.Select(a => a.ID);
var Movies = _contex.Movies.Where(a => movies.Contains(a.ID)).ToList();
actor.Movies = Movies;
_contex.SaveChanges();
actorDTO.ID = actor.ID;
return(Ok());
}
public static void removeActor(ActorDTO actorDTO)
{
Actor actorDB = getActorById(actorDTO.Id);
actorDB.Client.User.removed = true;
JobServiceDB.DBaccess.SaveChanges();
}
public static void showActorInfo(ActorDTO actor)
{
Console.WriteLine($"Id: {actor.Id}");
Console.WriteLine($"First Name : {actor.FirstName}");
Console.WriteLine($"Last Name : {actor.LastName}");
Console.WriteLine($"Income: {actor.Income}");
}
private async void GetDirectActorInfo(int id)
{
try
{
BusyIndicatorValue = true;
var actor = await _dataService.GetDirectActorData(id);
List <PersonCredit> movies = await _dataService.GetDirectActorMoviesList(id);
DirectActor = actor;
ActorMovies = new ObservableCollection <PersonCredit>(movies);
ActorDTO personFromDb = _actorService.GetActor(DirectActor.Id);
if (personFromDb == null)
{
CanDelFromDb = false;
CanAddToDb = true;
}
else
{
CanDelFromDb = true;
CanAddToDb = false;
}
BusyIndicatorValue = false;
}
catch (ServiceRequestException)
{
RaiseNotification();
}
catch (Exception e)
{
_logger.ErrorException(ForExceptions, e);
}
}
public async Task <ActionResult> PutActor(int actorId, ActorDTO actorDto)
{
try
{
var oldActor = await _actorRepository.GetActorsById(actorId);
if (oldActor == null)
{
return(NotFound("$Could not find actor"));
}
var newActor = _mapper.Map(actorDto, oldActor);
_actorRepository.Update(newActor);
if (await _actorRepository.Save())
{
return(NoContent());
}
}
catch (Exception e)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, $"Database Failure: {e.Message}"));
}
return(BadRequest());
}
public void InsertActor(ActorDTO a)
{
_bdLocalData.Actors.InsertOnSubmit(new Actor()
{
id = a.Id, character = a.Character, name = a.Name
});
}
public ICollection <ActorDTO> GetActorsByMovie(string movieId)
{
//daca vad ca nu DTO-ul ramane identic cu entitatea, nu mai folosesc ActorDTO
//ca sa nu mai fac transformari degeaba
ICollection <ActorDTO> actorsDTO = new List <ActorDTO>();
var movieActors = _movieActorsRepository.FindByMovieId(movieId);
if (movieActors != null & movieActors.Any())
{
foreach (MovieActors movieActor in movieActors)
{
var actor = _actorRepository.FindById(movieActor.ActorId);
ActorDTO actorDTO = new ActorDTO
{
Id = actor.Id,
LastName = actor.LastName,
FirstName = actor.FirstName,
Age = actor.Age,
Picture = actor.Picture
};
actorsDTO.Add(actorDTO);
}
}
return(actorsDTO);
}
public IActionResult GetActorById(int id)
{
ResponseSingleObject <ActorDTO> responseSingleObject = new ResponseSingleObject <ActorDTO>()
{
Status = StatusCodes.Status500InternalServerError,
Errors = null,
Message = null,
Succeded = false,
Value = null
};
try
{
ActorDTO a = _bllManager.getActorFromId(id);
if (a == null)
{
responseSingleObject.Status = StatusCodes.Status404NotFound;
responseSingleObject.Errors = "aucun acteur trouvé pour l'id : " + id;
}
else
{
responseSingleObject.Status = StatusCodes.Status200OK;
responseSingleObject.Value = a;
}
}
catch (Exception e)
{
responseSingleObject.Errors =
"getNumberActorsFromTo() EXCEPTION : " + e.ToString();
}
return(StatusCode(responseSingleObject.Status, responseSingleObject));
}
public IActionResult UpdateActor(ActorDTO actorDTO)
{
if (_actorService.Update(actorDTO))
{
return(Ok());
}
return(NotFound(new { message = "Actor not found" }));
}
public static int editActor(ActorDTO actorDTO)
{
Actor actorDB = getActorById(actorDTO.Id);
mapActorDBfromDTO(actorDTO, actorDB);
JobServiceDB.DBaccess.SaveChanges();
return(actorDB.Client.userId);
}
public void TakeActor(ActorDTO actorDto)
{
Mapper.Initialize(cfg => cfg.CreateMap <ActorDTO, Actor>());
Actor actor = Mapper.Map <ActorDTO, Actor>(actorDto);
_database.Actors.Create(actor);
_database.Save();
}
public Actor Post(ActorDTO value)
{
Actor model = new Actor()
{
Name = value.Name
};
return(IActorRepository.Create(model));
}
public JsonResult AddActor(ActorViewModel actor)
{
ExternalService service = new ExternalService();
ActorDTO actorDTO = Mapper.Map <ActorDTO>(actor);
var result = service.AddActor(actorDTO);
return(Json(new { data = result, JsonRequestBehavior.AllowGet }));
//return View();
}
public static actor MapActorDTO(ActorDTO actor)
{
return(new actor
{
actor_id = actor.Id,
first_name = actor.FirstName,
last_name = actor.LastName
});
}
private ActorDTO toActorDTO(Actor g)
{
ActorDTO gdto = new ActorDTO();
gdto.id = g.id;
gdto.name = g.name;
gdto.character = g.character;
return(gdto);
}
/// <summary>
/// Custom extention method
/// Use this method for possible further implementation sidelinks the team come up with.
/// Can also duplicate this method to new methods with tailored links to be grouped.
/// Wollter
/// </summary>
/// <param name="actor"></param>
/// <returns></returns>
internal ActorDTO HateoasGetSingleMethodLinks(ActorDTO actorDto)
{
actorDto.Links.Add(UrlLink("all", "GetAllActors", null));
actorDto.Links.Add(UrlLink("_self", "GetActorById", new { id = actorDto.ActorId }));
actorDto.Links.Add(UrlLinkCrud("_update", "GetActorById", "UpdateActor", new { id = actorDto.ActorId }));
actorDto.Links.Add(UrlLinkCrud("_delete", "GetActorById", "DeleteActor", new { id = actorDto.ActorId }));
return(actorDto);
}
public ActionResult Movies(string fullActName)
{
List <ActorDTO> actorDTOs = serv.FindListActorByPartialActorName(fullActName, 0, 10);
ActorDTO act = actorDTOs.First();
List <FilmDTO> filmDTOs = serv.GetListFilmsByIdActor(act.ActorId);
WebApp.Models.listMovies MovModel = new listMovies(filmDTOs);
return(View(MovModel));
}
public int AddActor(ActorDTO actorDTO)
{
CinemaActor actor = new CinemaActor {
ActorName = actorDTO.ActorName
};
_cinemaDbContext.Actors.Add(actor);
_cinemaDbContext.SaveChanges();
return(actor.ActorId);
}
public static void showActorAvailableMovies(ActorDTO actor)
{
foreach (MovieDTO m in actor.MovieList)
{
if (m.Completed == false && m.Removed == false)
{
Console.WriteLine($"Id: {m.Id} / Title: {m.Title} / Genre: {m.Genre} / Salary: {m.Salary}");
}
}
}
public static int addActor(ActorDTO actorDTO)
{
Actor actorDB = new Actor();
actorDB = mapActorDBfromDTO(actorDTO);
JobServiceDB.DBaccess.Actor.Add(actorDB);
JobServiceDB.DBaccess.SaveChanges();
return(actorDB.Client.User.id);
}
public ActorDTO ToActorDTO(Actor a)
{
ActorDTO actorDTO = new ActorDTO();
actorDTO.Id = a.id;
actorDTO.Name = a.name;
actorDTO.Character = a.character;
return(actorDTO);
}
public IActionResult updateUser([FromBody] ActorDTO actorDTO)
{
bool isSuccess = _userRepo.updateActor(actorDTO);
if (!isSuccess)
{
return(NotFound("No no no"));
}
return(Ok("success"));
}
