public ActionResult GetFileUrl(int?id)
        {
            PaymentStatement paymentStatement = db.PaymentStatements.Find(id);
            //return Redirect(paymentStatement.DocumentUrl.ToString());
            var documents = paymentStatement.PaymentsDocuments;

            string[] allFilesUrl = new string[documents.Count()];
            int      index       = 0;

            foreach (var i in documents)
            {
                allFilesUrl[index] = i.DocumentUrl;
                index++;
            }
            return(Redirect(allFilesUrl[0]));

            // Пример из https://stackoverflow.com/questions/12713710/returning-multiple-files-from-mvc-action
            //var outputStream = new MemoryStream();

            //using (var zip = new ZipFile())
            //{
            //    zip.AddEntry("file1.txt", "content1");
            //    zip.AddEntry("file2.txt", "content2");
            //    zip.Save(outputStream);
            //}

            //outputStream.Position = 0;
            //return File(outputStream, "application/zip", "filename.zip");
        }
        public async Task <ActionResult> Create([Bind(Include = "Id,KltId,InvoiceNumber,InvoiceDate,InvoiceSumma,Comment,InvoiceChecked,PaymentApproved,PaymentDone,DocumentUrl")] PaymentStatement paymentStatement, HttpPostedFileBase UploadDocumentUrl)
        {
            if (ModelState.IsValid)
            {
                var UserManager = HttpContext.GetOwinContext().GetUserManager <ApplicationUserManager>();
                if (paymentStatement.PaymentApproved == true && User.IsInRole("Sign1"))
                {
                    paymentStatement.PaymentApprovedUser = await UserManager.FindByNameAsync(User.Identity.Name);
                }
                else
                {
                    paymentStatement.PaymentApproved = false;
                }

                if (UploadDocumentUrl != null)
                {
                    // получаем имя файла
                    string fileName = System.IO.Path.GetFileName(UploadDocumentUrl.FileName);
                    // сохраняем файл в папку Files в проекте
                    UploadDocumentUrl.SaveAs(Server.MapPath("~/Files/" + fileName));
                    paymentStatement.DocumentUrl = "~/Files/" + fileName;
                }


                db.PaymentStatements.Add(paymentStatement);
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }

            return(View(paymentStatement));
        }
        public async Task <ActionResult> DeleteConfirmed(int id)
        {
            PaymentStatement paymentStatement = await db.PaymentStatements.FindAsync(id);

            db.PaymentStatements.Remove(paymentStatement);
            await db.SaveChangesAsync();

            return(RedirectToAction("Index"));
        }
        public async Task <ActionResult> Edit([Bind(Include = "Id,KltId,InvoiceNumber,InvoiceDate,InvoiceSumma,Comment,InvoiceChecked,PaymentApproved,PaymentDone,DocumentUrl")] PaymentStatement paymentStatement)
        {
            if (ModelState.IsValid)
            {
                db.Entry(paymentStatement).State = EntityState.Modified;
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            return(View(paymentStatement));
        }
        public async Task <ActionResult> DeleteConfirmed(int id)
        {
            PaymentStatement paymentStatement = await db.PaymentStatements.FindAsync(id);

            for (int i = 0; i < paymentStatement.PaymentsDocuments.Count; i++)
            {
                db.PaymentsDocuments.Remove(paymentStatement.PaymentsDocuments[i]);
            }
            db.PaymentStatements.Remove(paymentStatement);
            await db.SaveChangesAsync();

            return(RedirectToAction("Index"));
        }
        // GET: PaymentStatements/Create
        public ActionResult Create()
        {
            PaymentStatement payment = new PaymentStatement();

            payment.Payments              = new List <Payment>();
            payment.DocumentUrl           = "Открыть";
            payment.InvoiceDate           = DateTime.Now;
            payment.Currency              = new Currency();
            payment.Currency.Id           = 1; //UAH
            payment.Currency.CurrencyName = "UAH";
            //ViewBag.CurrenciesList = new SelectList(db.Currencies, "Id", "CurrencyName");
            return(View(payment));
        }
        // GET: PaymentStatements/Delete/5
        public async Task <ActionResult> Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            PaymentStatement paymentStatement = await db.PaymentStatements.FindAsync(id);

            if (paymentStatement == null)
            {
                return(HttpNotFound());
            }
            return(View(paymentStatement));
        }
        // GET: PaymentStatements/Edit/5
        public async Task <ActionResult> Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            PaymentStatement paymentStatement = await db.PaymentStatements.FindAsync(id);

            var invoiceOrest = await OrestDb.prh.FirstOrDefaultAsync(a => a.ninv == paymentStatement.InvoiceNumber && a.datd == paymentStatement.InvoiceDate);

            //Ищем в базе Орест редактируемый счёт и ставим флаг, показывающий найден счёт или нет:
            paymentStatement.isInvoiceFound = invoiceOrest != null;

            if (paymentStatement.isInvoiceFound)
            {
                //paymentStatement.isInvoiceSummaCorrect = invoiceOrest.sd == paymentStatement.InvoiceSumma;
                paymentStatement.isInvoicePaymentsCorrect = true;
                //Получаем список платежей по счёту из ореста.
                var paymentsOrest = OrestDb.bkh.Where(a => a.prh == invoiceOrest.id);
                foreach (var payment in paymentStatement.Payments)
                {
                    //Если сумма платежа не верна
                    if (!payment.isPaymentSummaCorrect)
                    {
                        //тогда общая сумма счёта также не верна
                        paymentStatement.isInvoicePaymentsCorrect = false;
                    }

                    //payment.PaymentPaymentDone = paymentsOrest.FirstOrDefault(a => a.ndoc == payment.numberDocument).lg == 1;
                }
                await db.SaveChangesAsync();
            }
            else
            {
                paymentStatement.isInvoiceSummaCorrect    = false;
                paymentStatement.isInvoicePaymentsCorrect = false;
            }



            if (paymentStatement == null)
            {
                return(HttpNotFound());
            }
            ViewBag.CurrenciesList = new SelectList(db.Currencies, "Id", "CurrencyName");
            return(View(paymentStatement));
        }
        public ActionResult FileViewer(int?id)
        {
            PaymentStatement paymentStatement = db.PaymentStatements.Find(id);;
            //return Redirect(paymentStatement.DocumentUrl.ToString());
            var documents = paymentStatement.PaymentsDocuments;

            string[] allFilesUrl = new string[documents.Count()];
            //int index = 0;
            for (int i = 0; i < documents.Count; i++)
            {
                if (documents[i].DocumentUrl != null)
                {
                    allFilesUrl[i] = documents[i].DocumentUrl;
                }
                else
                {
                    db.PaymentsDocuments.Remove(documents[i]);
                }
            }
            return(View(allFilesUrl));
        }
        public ActionResult Edit([Bind(Include = "Id,KltId,InvoiceNumber,InvoiceDate,InvoiceSumma,Comment,InvoiceChecked,PaymentApproved,DocumentUrl, CurrencyId")]
                                 PaymentStatement paymentStatement, decimal[] Summa, bool[] PartialPaymentChecked, bool[] PartialPaymentApproved, bool[] PaymentPaymentDone, int?[] UploadDocumentId, HttpPostedFileBase[] UploadDocumentUrl, string LastUrl, int?[] MySQLBankId, int[] OrestPaymentId)
        {
            if (ModelState.IsValid)
            {
                PaymentStatement currentPaymentStatement = db.PaymentStatements.Find(paymentStatement.Id);
                currentPaymentStatement.Comment         = paymentStatement.Comment;
                currentPaymentStatement.KltId           = paymentStatement.KltId;
                currentPaymentStatement.InvoiceNumber   = paymentStatement.InvoiceNumber;
                currentPaymentStatement.InvoiceSumma    = paymentStatement.InvoiceSumma;
                currentPaymentStatement.InvoiceChecked  = paymentStatement.InvoiceChecked;
                currentPaymentStatement.InvoiceDate     = paymentStatement.InvoiceDate;
                currentPaymentStatement.PaymentApproved = paymentStatement.PaymentApproved;
                currentPaymentStatement.WhenEdited      = DateTime.Now;
                currentPaymentStatement.PaymentDone     = paymentStatement.PaymentDone;

                //1. Удаляем все ранее добавленные файлы
                if (currentPaymentStatement.PaymentsDocuments.Count != 0)
                {
                    for (int i = 0; i < currentPaymentStatement.PaymentsDocuments.Count; i++)
                    {
                        if (UploadDocumentId == null)  // если удалены все ранее добавленные файлы
                        {
                            string fullPath = Server.MapPath(currentPaymentStatement.PaymentsDocuments[i].DocumentUrl);
                            if (System.IO.File.Exists(fullPath))
                            {
                                System.IO.File.Delete(fullPath);
                            }
                            currentPaymentStatement.PaymentsDocuments.Remove(currentPaymentStatement.PaymentsDocuments[i]);
                        }
                        // если удалены некоторорые ранее добавленные файлы
                        else if (UploadDocumentId.Contains(currentPaymentStatement.PaymentsDocuments[i].Id) == false)
                        {
                            string fullPath = Server.MapPath(currentPaymentStatement.PaymentsDocuments[i].DocumentUrl);
                            if (System.IO.File.Exists(fullPath))
                            {
                                System.IO.File.Delete(fullPath);
                            }
                            currentPaymentStatement.PaymentsDocuments.Remove(currentPaymentStatement.PaymentsDocuments[i]);
                        }
                    }
                }
                //2.Сохраняем ново добавленные файлы из UploadDocumentUrl
                if (UploadDocumentUrl.Length > 0)
                {
                    foreach (var file in UploadDocumentUrl)
                    {
                        if (file != null)
                        {
                            // получаем имя файла
                            string fileName = Guid.NewGuid().ToString() + System.IO.Path.GetFileName(file.FileName);
                            // сохраняем файл в папку Files в проекте
                            file.SaveAs(Server.MapPath("~/Files/" + fileName));
                            PaymentsDocument paymentDocument = new PaymentsDocument();
                            paymentDocument.DocumentUrl = "/Files/" + fileName;
                            if (currentPaymentStatement.PaymentsDocuments == null)
                            {
                                currentPaymentStatement.PaymentsDocuments = new List <PaymentsDocument>();
                            }
                            currentPaymentStatement.PaymentsDocuments.Add(paymentDocument);
                        }
                    }
                }

                var currentUser = db.Users.Where(a => a.UserName == User.Identity.Name).First();

                /*paymentStatement.whoAddThis = currentUser;*/ //await UserManager.FindByNameAsync(User.Identity.Name);
                currentPaymentStatement.whoMadeLastChanges = currentUser;
                currentPaymentStatement.WhenEdited         = DateTime.Now;
                currentPaymentStatement.Currency           = db.Currencies.Find(paymentStatement.CurrencyId);

                currentPaymentStatement.Payments = db.Payments.Where(a => a.PaymentStatementId == paymentStatement.Id).ToList();

                db.Payments.RemoveRange(currentPaymentStatement.Payments);
                db.SaveChanges();

                if (currentPaymentStatement.Payments == null)
                {
                    currentPaymentStatement.Payments = new List <Payment>();
                }

                paymentStatement.Payments = new List <Payment>();

                if (Summa != null)
                {
                    int invoiceCheckedIndex  = 0;
                    int invoiceApprovedIndex = 0;
                    int paymentDoneIndex     = 0;

                    for (var i = 0; i < Summa.Length; i++)
                    {
                        Payment payment = new Payment();

                        payment.PaymentWhenEdited = DateTime.Now;
                        payment.PaymentWhoAddThis = currentUser;
                        payment.Summa             = Summa[i];
                        payment.OrestPaymentId    = OrestPaymentId[i];
                        try
                        {
                            var orestBank = OrestDb.bank.Find(MySQLBankId[i]);
                            if (orestBank != null)
                            {
                                payment.MySQLBankName = orestBank.name;
                                payment.MySQLBankId   = orestBank.id;
                            }
                        }
                        catch
                        {
                            return(View(paymentStatement));
                        }



                        payment.PartialPaymentChecked = PartialPaymentChecked[invoiceCheckedIndex];
                        if (PartialPaymentChecked[invoiceCheckedIndex] == true)
                        {
                            invoiceCheckedIndex = invoiceCheckedIndex + 2;
                        }
                        else
                        {
                            invoiceCheckedIndex++;
                        }

                        payment.PartialPaymentApproved = PartialPaymentApproved[invoiceApprovedIndex];
                        if (PartialPaymentApproved[invoiceApprovedIndex] == true)
                        {
                            invoiceApprovedIndex = invoiceApprovedIndex + 2;
                        }
                        else
                        {
                            invoiceApprovedIndex++;
                        }

                        payment.PaymentPaymentDone = PaymentPaymentDone[paymentDoneIndex];
                        if (PaymentPaymentDone[paymentDoneIndex] == true)
                        {
                            paymentDoneIndex = paymentDoneIndex + 2;
                        }
                        else
                        {
                            paymentDoneIndex++;
                        }

                        //payment.PaymentStatement = paymentStatement;

                        paymentStatement.Payments.Add(payment);
                    }
                    currentPaymentStatement.Payments = paymentStatement.Payments;

                    //decimal PaymentsSumm = 0; // расчитываем сумму оплат
                    //foreach (var i in currentPaymentStatement.Payments.ToList())
                    //{
                    //    if (i.PaymentPaymentDone == true)
                    //    {
                    //        PaymentsSumm += i.Summa;
                    //        currentPaymentStatement.PaymentDone = true;
                    //    }
                    //    else
                    //        currentPaymentStatement.PaymentDone = false;
                    //}

                    //if (PaymentsSumm == currentPaymentStatement.InvoiceSumma)
                    //{
                    //    currentPaymentStatement.PaymentDone = true; //оплачено 100%
                    //}
                    //else
                    //    currentPaymentStatement.PaymentDone = false;
                }

                //if (currentPaymentStatement.PaymentDone)
                //{
                //    currentPaymentStatement.InvoiceChecked = true;
                //    currentPaymentStatement.PaymentApproved = true;
                //}

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

                db.SaveChanges();
                return(RedirectToAction("Index"));

                //return RedirectToAction(LastUrl != "" ? LastUrl : "Index");
            }
            return(View(paymentStatement));
        }
        public ActionResult Create([Bind(Include = "Id,KltId,InvoiceNumber,InvoiceDate,InvoiceSumma,Comment,DocumentUrl,CurrencyId")]
                                   PaymentStatement paymentStatement, decimal[] Summa, bool[] PartialPaymentChecked, bool[] PartialPaymentApproved, bool[] PaymentPaymentDone, HttpPostedFileBase[] UploadDocumentUrl, int?[] MySQLBankId)
        {
            if (paymentStatement.KltId == 0)
            {
                ModelState.AddModelError("Counterparty_Id", "Не выбран контрагент");
                if (UploadDocumentUrl != null)
                {
                    //ViewBag.FileName = System.IO.Path.GetFileName(UploadDocumentUrl.FileName);
                }
            }
            var currentUser = db.Users.Where(a => a.UserName == User.Identity.Name).First();

            paymentStatement.Payments = new List <Payment>();

            if (Summa != null)
            {
                int invoiceCheckedIndex  = 0;
                int invoiceApprovedIndex = 0;
                int paymentDoneIndex     = 0;

                for (var i = 0; i < Summa.Length; i++)
                {
                    Payment payment = new Payment();

                    payment.PaymentWhenEdited = DateTime.Now;
                    payment.PaymentWhoAddThis = currentUser;
                    payment.Summa             = Summa[i];
                    if (MySQLBankId != null)
                    {
                        var orestBank = OrestDb.bank.Find(MySQLBankId[i]);
                        if (orestBank != null)
                        {
                            payment.MySQLBankName = orestBank.name;
                            payment.MySQLBankId   = orestBank.id;
                        }
                    }


                    payment.PartialPaymentChecked = PartialPaymentChecked[invoiceCheckedIndex];
                    if (PartialPaymentChecked[invoiceCheckedIndex] == true)
                    {
                        invoiceCheckedIndex = invoiceCheckedIndex + 2;
                    }
                    else
                    {
                        invoiceCheckedIndex++;
                    }

                    payment.PartialPaymentApproved = PartialPaymentApproved[invoiceApprovedIndex];
                    if (PartialPaymentApproved[invoiceApprovedIndex] == true)
                    {
                        invoiceApprovedIndex = invoiceApprovedIndex + 2;
                    }
                    else
                    {
                        invoiceApprovedIndex++;
                    }

                    payment.PaymentPaymentDone = PaymentPaymentDone[paymentDoneIndex];
                    if (PaymentPaymentDone[paymentDoneIndex] == true)
                    {
                        paymentDoneIndex = paymentDoneIndex + 2;
                    }
                    else
                    {
                        paymentDoneIndex++;
                    }

                    //payment.PaymentStatement = paymentStatement;

                    paymentStatement.Payments.Add(payment);
                }
            }

            if (ModelState.IsValid)
            {
                if (UploadDocumentUrl != null)
                {
                    //// получаем имя файла
                    //string fileName = Guid.NewGuid().ToString() + System.IO.Path.GetFileName(UploadDocumentUrl.FileName);
                    //// сохраняем файл в папку Files в проекте
                    //UploadDocumentUrl.SaveAs(Server.MapPath("~/Files/" + fileName));
                    //paymentStatement.DocumentUrl = "/Files/" + fileName;
                    foreach (var file in UploadDocumentUrl)
                    {
                        if (file == null)
                        {
                            break;
                        }
                        // получаем имя файла
                        string fileName = Guid.NewGuid().ToString() + System.IO.Path.GetFileName(file.FileName);
                        // сохраняем файл в папку Files в проекте
                        file.SaveAs(Server.MapPath("~/Files/" + fileName));
                        PaymentsDocument paymentDocument = new PaymentsDocument();
                        paymentDocument.DocumentUrl = "/Files/" + fileName;
                        if (paymentStatement.PaymentsDocuments == null)
                        {
                            paymentStatement.PaymentsDocuments = new List <PaymentsDocument>();
                        }
                        paymentStatement.PaymentsDocuments.Add(paymentDocument);
                    }
                }

                if (paymentStatement.PaymentApproved == true && (User.IsInRole("Sign1") || User.IsInRole("Developer")))
                {
                    paymentStatement.PaymentApprovedUser = currentUser;
                }
                else
                {
                    paymentStatement.PaymentApproved = false;
                }

                paymentStatement.whoAddThis         = currentUser; //await UserManager.FindByNameAsync(User.Identity.Name);
                paymentStatement.whoMadeLastChanges = currentUser;
                paymentStatement.WhenEdited         = DateTime.Now;
                paymentStatement.WhenCreated        = DateTime.Now;
                paymentStatement.Currency           = db.Currencies.Find(paymentStatement.CurrencyId);

                if (paymentStatement.PaymentDone)
                {
                    paymentStatement.InvoiceChecked  = true;
                    paymentStatement.PaymentApproved = true;
                }

                db.PaymentStatements.Add(paymentStatement);
                db.SaveChanges();

                return(RedirectToAction("Index"));
            }

            return(View(paymentStatement));
        }