internal int FilmEkle(FilmModel model)
{
try
{
Films film = new Films()
{
RafID = model.RafId,
Aciklama = model.Aciklama.Trim(),
Aktifmi = true,
BarkodNo = model.BarkodNo.Trim(),
FilmAdi = model.FilmAdi.Trim(),
EditorSectiMi = model.EditorSectiMi,
Fiyat = model.Fiyat,
ImdbPuan = model.ImdbPuan,
YeniFilmMi = model.YeniFilmMi,
YapimTarihi = model.YapimTarihi,
FragmanUrl = model.FragmanUrl.Trim(),
UcBoyutlumu = model.UcBoyutlumu,
Stok = model.Stok,
Sure = model.Sure,
AfisPath = "default.png".Trim(),
YabanciAdi = model.YabanciAdi.Trim(),
KayitTarihi = DateTime.Today
};
_db.Films.Add(film);
_db.SaveChanges();
return(film.ID);
}
catch
{
return(0);
}
}
public async Task <ActionResult <FilmModel> > PostFilmModel(FilmModel filmModel)
{
_context.AllFilms.Add(filmModel);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetFilmModel", new { id = filmModel.FilmId }, filmModel));
}
internal bool FilmDuzenle(FilmModel model)
{
try
{
var f = _db.Films.SingleOrDefault(x => x.ID == model.ID);
f.RafID = model.RafId;
f.Aciklama = model.Aciklama.Trim();
f.Aktifmi = true;
f.BarkodNo = model.BarkodNo.Trim();
f.FilmAdi = model.FilmAdi.Trim();
f.EditorSectiMi = model.EditorSectiMi;
f.Fiyat = model.Fiyat;
f.ImdbPuan = model.ImdbPuan;
f.YeniFilmMi = model.YeniFilmMi;
f.YapimTarihi = model.YapimTarihi;
f.FragmanUrl = model.FragmanUrl.Trim();
f.UcBoyutlumu = model.UcBoyutlumu;
f.Stok = model.Stok;
f.Sure = model.Sure;
f.YabanciAdi = model.YabanciAdi.Trim();
_db.SaveChanges();
return(true);
}
catch
{
return(false);
}
}
public void UpdateFilmTest()
{
Mock <IUnitOfWork> uow = new Mock <IUnitOfWork>();
FilmService fs = new FilmService(uow.Object);
FilmApiController FC = new FilmApiController(fs);
uow.Setup(x => x.PersonRoleRepository.DeletePersonRolesByFilm(1));
uow.Setup(x => x.FilmGenreRepository.DeleteFilmGenresByFilmId(1));
uow.Setup(x => x.FilmAwardRepository.DeleteFilmAwardsByFilmId(1));
uow.Setup(x => x.FilmRepository.Update(FilmModel.To(fm)));
uow.Setup(x => x.Save());
uow.Setup(x => x.GenreRepository.GenresByIds(It.IsAny <List <long> >())).Returns(fakeGenres);
uow.Setup(x => x.PersonRepository.PersonsByIds(It.IsAny <List <long> >())).Returns(fakePeople);
uow.Setup(x => x.PersonRepository.GetByKey(It.IsAny <long>())).Returns(fakePeople[0]);
uow.Setup(x => x.AwardRepository.AwardsByIds(It.IsAny <List <long> >())).Returns(fakeAwards);
uow.Setup(x => x.FilmRoleRepository.GetByRoleName(It.IsAny <string>())).Returns(fakeFilmRoles[0]);
uow.Setup(x => x.FileRepository.GetByKey(1)).Returns(new File()
{
Id = 1
});
var result = (FC.UpdateFilm(fm) as ObjectResult).Value as FilmModel;
result.Should().NotBeNull();
//var expected = fm;
//Assert.Equal(expected, result);
}
public IActionResult FilmEdit(int?id)
{
if (id == null)
{
return(NotFound());
}
var entity = _filmService.GetByIdWithCategories((int)id);
if (entity == null)
{
return(NotFound());
}
var model = new FilmModel()
{
FilmId = entity.FilmId,
Name = entity.Name,
Url = entity.Url,
PlayerDescription = entity.PlayerDescription,
Description = entity.Description,
IsApproved = entity.IsApproved,
IsHome = entity.IsHome,
SelectedCategories = entity.FilmCategories.Select(x => x.Category).ToList()
};
ViewBag.Categories = _categoryService.GetAll();
return(View(model));
}
public MainPage()
{
InitializeComponent();
_filmService = new FilmService(new FilmRepository(new HttpClient()));
FilmModel = new FilmModel();
}
public async Task <IActionResult> EditFilmAsync(UpsertFilmRequest request)
{
if (!await _filmService.CheckId(request.Id))
{
return(BadRequest());
}
if (request.FinishShowingDate < request.StartShowingDate)
{
return(BadRequest());
}
FilmModel filmModel = new FilmModel(
request.Id,
request.Title,
null,
request.Release,
request.Description,
request.StartShowingDate,
request.FinishShowingDate,
new TimeSpan(
request.FilmDuration.Hours,
request.FilmDuration.Minutes,
0
)
);
int result = await _filmService.UpsertFilmAsync(filmModel);
return(Ok(result));
}
public IActionResult EditDeleteFilm(int filmId)
{
var film = _db.FindFilmById(filmId);
var model = new FilmModel(film);
return(View(model));
}
public async Task <ActionResult <FilmModel> > AddFilm(FilmModel model)
{
_context.Films.Add(model);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetFilm), new { id = model.ID }, model));
}
public IActionResult FilmEdit(FilmModel model, int[] categoryIds)
{
var entity = _filmService.GetById(model.FilmId);
if (entity == null)
{
return(NotFound());
}
entity.Name = model.Name;
entity.Url = model.Url;
entity.IsApproved = model.IsApproved;
entity.IsHome = model.IsHome;
entity.PlayerDescription = model.PlayerDescription;
entity.Description = model.Description;
_filmService.Update(entity, categoryIds);
//alert mesajları içerikleri
TempData.Put("message", new AlertMessage()
{
Title = "Ürün Güncelleme",
Message = $"{entity.Name} isimli film güncellendi",
AlertType = "info"
});
return(RedirectToAction("FilmList"));
}
public async Task <IActionResult> Post(FilmModel filmModel)
{
var film = _mapper.Map <Film>(filmModel);
var createdFilm = await _filmService.AddAsync(film);
return(Ok(createdFilm));
}
public ActionResult FilmDuzenle(int Id)
{
ViewBag.rafList = _film.RafListesi();
var model = _film.FilmDetails(Id);
FilmModel film = new FilmModel()
{
RafId = model.RafID,
Aciklama = model.Aciklama,
BarkodNo = model.BarkodNo,
FilmAdi = model.FilmAdi,
EditorSectiMi = model.EditorSectiMi,
Fiyat = model.Fiyat,
ImdbPuan = model.ImdbPuan,
YeniFilmMi = model.YeniFilmMi,
YapimTarihi = model.YapimTarihi,
FragmanUrl = model.FragmanUrl,
UcBoyutlumu = model.UcBoyutlumu,
Stok = model.Stok,
Sure = model.Sure,
YabanciAdi = model.YabanciAdi
};
return(View(film));
}
public IActionResult FilmCreate(FilmModel model)
{
var entity = new Film()
{
Name = model.Name,
Url = model.Url,
Description = model.Description,
PlayerDescription = model.PlayerDescription,
IsHome = model.IsHome,
IsApproved = model.IsApproved
};
_filmService.Create(entity);
//alert mesajları içerikleri
TempData.Put("message", new AlertMessage()
{
Title = "Ürün eklendi",
Message = $"{entity.Name} isimli film eklendi",
AlertType = "success"
});
return(RedirectToAction("FilmList", "Admin"));
}
public async Task <IActionResult> Film([FromBody] Int32 id)
{
try
{
var user = await this._UserManager.GetUserAsync(HttpContext.User);
FilmModel model;
if (id == 0)
{
model = new FilmModel();
}
else
{
model = this._DBContext.LoadFilm(id, user.Id);
}
if (String.IsNullOrWhiteSpace(model.FileName))
{ // Set default image
model.FileName = this._IConfig.GetValue <string>("DefaultImage");
}
else
{
String path = this._IConfig.GetValue <string>("Storage");
model.FileName = path + "\\" + model.FileName;
}
return(new JsonResult(model));
}catch (Exception ex)
{
return(StatusCode(406, ex.Message));
}
}
public void ChangeValues(FilmModel filmModel)
{
Name = filmModel.Name;
Director = filmModel.Director;
DurationInSeconds = filmModel.DurationInSeconds;
Description = filmModel.Description;
}
public IActionResult Edit(int id, [Bind("Id, Name, Director, DurationInSeconds, Description")] FilmModel filmModel)
{
if (id != filmModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var film = filmService.Get(id);
film.ChangeValues(filmModel);
filmService.Update(film);
}
catch (Exception)
{
return(NotFound());
}
return(RedirectToAction(nameof(Index)));
}
return(View(filmModel));
}
public async Task <ActionResult> Create(FilmCreate filmModel)
{
if (ModelState.IsValid)
{
FilmModel filmDomain = new FilmModel
{
FilmId = Guid.NewGuid(),
Title = filmModel.Title,
Description = filmModel.Description,
ProductionYear = filmModel.ProductionYear,
Director = filmModel.Director,
PosterUri = filmModel.PosterUri,
UserId = User.Identity.GetUserId()
};
db.FilmModels.Add(filmDomain);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(filmModel));
}
public async void Post_ReturnsBadRequestObjectWithMessageToAddFilmFirst_ForNewFilmWhichContainsCast()
{
//Arrange
var repository = new FakeFilmRepository();
repository.Add(new Director()
{
Id = 1, FirstName = "Quentin", LastName = "Tarantino"
});
repository.Add(new Actor()
{
Id = 1, FirstName = "Kurt", LastName = "Russell", ActorFilms = new List <ActorFilm>()
{
new ActorFilm()
{
FilmId = 1, ActorId = 1
}
}
});
repository.Add(new Film()
{
Id = 1, DirectorId = 1, Title = "The Hateful Eight", Cast = new List <ActorFilm>()
{
new ActorFilm()
{
FilmId = 1, ActorId = 1
}
}
});
await repository.SaveChangesAsync();
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile <FilmProfile>();
});
var mapper = config.CreateMapper();
var controller = new FilmsController(repository, mapper);
var newFilm = new FilmModel()
{
Cast = new List <ActorModel>()
{
new ActorModel()
{
FirstName = "Kurt", LastName = "Russell"
}
}, Title = "The Hateful Eight"
};
//Act
var result = await controller.Post(newFilm);
//Assert
Assert.IsType <BadRequestObjectResult>(result.Result);
Assert.Equal("Please add film first. Update films cast with updatefilm method", (result.Result as BadRequestObjectResult).Value);
}
public async Task <int> UpsertFilmAsync(FilmModel filmModel)
{
int result = await _filmRepository.UpsertFilmAsync(
filmModel.Adapt <FilmEntity>()
);
return(result);
}
public frmFilmoviEdit(int id)
{
InitializeComponent();
this.AutoValidate = AutoValidate.Disable;
_id = id;
_film = null;
}
public ActionResult DeleteConfirmed(int id)
{
FilmModel filmModel = db.FilmModels.Find(id);
db.FilmModels.Remove(filmModel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IActionResult DeleteFilm(int filmId)
{
FilmModel film = _context.Films.Single(x => x.FilmId == filmId);
_context.Films.Remove(film);
_context.SaveChanges();
return(View("ListFilms", _context.Films));
}
public async Task <ActionResult> DeleteConfirmed(Guid id)
{
FilmModel filmModel = await db.FilmModels.FindAsync(id);
db.FilmModels.Remove(filmModel);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public ActionResult Create(FilmModel film)
{
if (Session["Username"] != null)
{
if (ModelState.IsValid)
{
try
{
film.critics = new List <Critics>();
List <string> genres = new List <string>();
foreach (string i in film.Genres[0].Split(','))
{
genres.Add(i);
}
film.Genres = genres.ToArray();
if (Session["Username"] != null)
{
userCollection = dbcontext.mongoDatabase.GetCollection <UserAccount>("User");
List <UserAccount> users = userCollection.AsQueryable <UserAccount>().ToList();
foreach (UserAccount u in users)
{
if (u.Username.Equals(Session["Username"].ToString()))
{
u.Films.Add(film);
var id = u.UserId.ToString();
var filter = Builders <UserAccount> .Filter.Eq("_id", ObjectId.Parse(id));
var update = Builders <UserAccount> .Update.Set("films", u.Films);
var result = userCollection.UpdateOne(filter, update);
}
}
}
filmCollection.InsertOne(film);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
var error = e.GetBaseException();
return(View());
}
}
else
{
return(View());
}
}
return(View());
}
public FilmDetailView(FilmModel model)
{
Id = model.Id;
Name = model.Name;
Description = model.Description;
Starring = model.Starring;
Duration = model.Duration;
Genre = model.Genre;
}
public async Task <IActionResult> Put(Guid filmId, FilmModel filmModel)
{
var film = await _filmService.GetAsync(filmId);
_mapper.Map(filmModel, film);
var updatedFilm = await _filmService.UpdateAsync(filmId, film);
return(Ok(updatedFilm));
}
public void Save_AddFilmsTest()
{
var filmModel = GetFilmModel();
filmModel.AddFilm();
filmModel.SaveFilms(Save);
var filmModel2 = FilmModel.GetModel(Load);
Assert.AreEqual(2, filmModel2.Count);
}
public ViewResult Film()
{
FilmModel filmModel = new FilmModel();
filmModel.Title = "Transformers";
filmModel.Description = "Autobots with the help of a teenager battle Decepticons for an acient object on Earth.";
filmModel.Year = 2007;
return(View(filmModel));
}
// private IList<FilmModel> _fmList;
//public BindEntityToEFModel(StarWarDBContext SWDBContext) =>_SWDBContext= SWDBContext;
public BindEntityToEFModel(List <Models.PeopleModel> pmentity, StarWarDBContext SWDBContext)
{
_SWDBContext = SWDBContext;
_entity = pmentity;
_fm = new FilmModel();
_reppm = new Repository <DAL.Models.People>(_SWDBContext);
_repf = new Repository <DAL.Models.Film>(_SWDBContext);
MapEntityToModel();
}
public ActionResult Edit([Bind(Include = "FilmModelID,FilmName,FilmDescription,ReleaseDate,FilmLength,GenreId,Genre")] FilmModel filmModel)
{
if (ModelState.IsValid)
{
db.Entry(filmModel).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(filmModel));
}
public ActorsDAL_EF()
{
model = new FilmModel();
}
public GenresDAL_EF()
{
model = new FilmModel();
}
public FilmsDAL_EF()
{
model = new FilmModel();
}
