public async Task <ActionResult> GetReportPdf(int id)
        {
            InterimReview interimReview = await db.InterimReviews.FindAsync(id);

            if (interimReview == null)
            {
                return(HttpNotFound());
            }

            XtraReport report = new XtraReport();

            string path = Server.MapPath("~/Reports/przeglad.repx");

            report.LoadLayout(path);

            report.Parameters["INTERIMREVIEW_ID"].Value = id;

            report.CreateDocument();

            var stream = new MemoryStream();

            report.ExportToPdf(stream);

            var cd = new System.Net.Mime.ContentDisposition
            {
                FileName = "przegląd.pdf",
                Inline   = false,
            };

            Response.AppendHeader("Content-Disposition", cd.ToString());
            return(File(stream.GetBuffer(), "application/pdf"));
        }
        public async Task <ActionResult> Edit([Bind(Include = "InterimReviewId,SerialNumber,UniqueNumber,DateOfReview,NextReview,Comments,City,ServiceMan,DeviceId,ModuleId")] InterimReviewViewModel interimReview)
        {
            if (ModelState.IsValid)
            {
                InterimReview interimReviewDb = await db.InterimReviews.FindAsync(interimReview.InterimReviewId);

                if (interimReviewDb == null)
                {
                    return(HttpNotFound());
                }

                interimReviewDb.DateOfReview = interimReview.DateOfReview;
                interimReviewDb.NextReview   = interimReview.NextReview;
                interimReviewDb.Comments     = interimReview.Comments;
                interimReviewDb.City         = interimReview.City;
                interimReviewDb.ServiceMan   = interimReview.ServiceMan;

                db.Entry(interimReviewDb).State = EntityState.Modified;

                var device = db.Devices.Find(interimReview.DeviceId);
                if (device != null)
                {
                    device.InterimReviewDate = interimReview.NextReview;
                    db.Entry(device).State   = EntityState.Modified;
                }

                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            return(View(interimReview));
        }
        // GET: /InterimReviews/Edit/5
        public async Task <ActionResult> Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            InterimReview interimReview = await db.InterimReviews.FindAsync(id);

            if (interimReview == null)
            {
                return(HttpNotFound());
            }

            var editedInterimReview = (from d in db.Devices
                                       join m in db.Modules on d.DeviceId equals m.DeviceId
                                       join df in db.DevicesFolders on d.DevicesFolderId equals df.DevicesFolderId
                                       join i in db.InterimReviews on m.ModuleId equals i.ModuleId
                                       where i.InterimReviewId == interimReview.InterimReviewId
                                       select new InterimReviewViewModel()
            {
                InterimReviewId = i.InterimReviewId,
                DeviceId = d.DeviceId,
                DeviceName = df.Name,
                SerialNumber = d.SerialNumber,
                UniqueNumber = m.UniqueNumber,
                NextReview = i.NextReview,
                DateOfReview = i.DateOfReview,
                City = i.City,
                Comments = i.Comments,
                ServiceMan = i.ServiceMan,
            }).SingleOrDefaultAsync();

            return(View(await editedInterimReview));
        }
        public async Task <ActionResult> Create([Bind(Include = "InterimReviewId,SerialNumber,UniqueNumber,DateOfReview,NextReview,Comments,City,ServiceMan,DeviceId,ModuleId")] InterimReviewViewModel interimReview)
        {
            if (ModelState.IsValid)
            {
                Module module = db.Modules.Where(d => d.DeviceId == interimReview.DeviceId).Where(m => m.Active == true).FirstOrDefault();
                if (module == null)
                {
                    return(HttpNotFound());
                }

                var device = db.Devices.Find(interimReview.DeviceId);
                if (device != null)
                {
                    device.InterimReviewDate = interimReview.NextReview;
                    db.Entry(device).State   = EntityState.Modified;
                }

                InterimReview newInterimReview = new InterimReview();

                newInterimReview.City         = interimReview.City;
                newInterimReview.Comments     = interimReview.Comments;
                newInterimReview.DateOfReview = interimReview.DateOfReview;
                newInterimReview.DeviceId     = interimReview.DeviceId;
                newInterimReview.NextReview   = interimReview.NextReview;
                newInterimReview.ServiceMan   = interimReview.ServiceMan;

                newInterimReview.ModuleId = module.ModuleId;
                db.InterimReviews.Add(newInterimReview);
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }

            return(View(interimReview));
        }
        // GET: /InterimReviews/Delete/5
        public async Task <ActionResult> Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            InterimReview interimReview = await db.InterimReviews.FindAsync(id);

            if (interimReview == null)
            {
                return(HttpNotFound());
            }
            return(PartialView(interimReview));
        }
        public async Task <ActionResult> DeleteConfirmed(int id)
        {
            InterimReview interimReview = await db.InterimReviews.FindAsync(id);

            db.InterimReviews.Remove(interimReview);
            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateException /*ex*/)
            {
                string errorMessage = "";
                errorMessage = "Nie można usunąć rekordu, ponieważ jest powiązany z innymi rekordami w bazie danych";

                ModelState.AddModelError(String.Empty, errorMessage);
                return(PartialView(interimReview));
            }
            return(Json(new { url = Url.Action("Index", "InterimReviews"), success = true }));
        }