예제 #1
0
        /// <summary>
        /// Erstelle zu der jeweiligen Rechnung ein neues Erlöskonto
        /// </summary>
        /// <param name="dbContext">DB Kontext</param>
        /// <param name="inv">Rechnungsobjekt</param>
        public static void CreateAccounts(DataClasses1DataContext dbContext, Invoice inv)
        {
            List<_Accounts> acc = null;
             acc = Accounts.generateAccountNumber(dbContext,inv.Id).ToList();

             if (acc != null && acc.Count() == inv.InvoiceItem.Count)
             {
                 foreach (var thisItems in acc)
                 {
                     var myAccount = new InvoiceItemAccountItem
                     {
                         InvoiceItemId = thisItems.InvoiceItemId,
                         RevenueAccountText = thisItems.AccountNumber
                     };
                     var contains = dbContext.InvoiceItemAccountItem.FirstOrDefault(q => q.InvoiceItemId ==
                         thisItems.InvoiceItemId && q.RevenueAccountText == thisItems.AccountNumber.Trim());
                     if (contains != null)
                     {
                         contains.RevenueAccountText = thisItems.AccountNumber.Trim();
                     }
                     else
                     {
                         dbContext.InvoiceItemAccountItem.InsertOnSubmit(myAccount);
                     }
                     dbContext.SubmitChanges();
                 }
             }
             else
             {
                 throw new Exception("Die Rechnung konnte nicht gedruckt werden, da nicht alle Dienstleistungen ein Erlöskonto haben! Sie können die Erlöskonten im Reiter 'Rechnung erstellen' zuweisen und die Rechnung erneut drucken.");
             }
        }
예제 #2
0
파일: DoJob.cs 프로젝트: HedinRakot/KVS
        /// <summary>
        /// Rechnungen drucken
        /// </summary>
        /// <param name="rep"></param>
        private void PrintInvoices(InvoiceRunReport rep)
        {
            try
            {
                TransactionScope ts=null;
                List<_Accounts> acc = null;
                invoices.AddRange(getInvoices(rep).ToList());
                log.Info("Erstelle Rechnungen für den Rechnungslauf:" + rep.Id);
                log.AddcompanyMessages("Abgeschlossene Aufträge werden nun verrechnet, insgesamt: " + invoices.Count);
                foreach (var inv in invoices)
                {
                    WritePilotStatus(currOrderIndex, rep);
                    currOrderIndex++;
                    log.Info("Erstelle Buchungskosten für die Rechnung mit der ID:" + inv.Id);
                    try
                    {
                        if (inv.InvoiceItem.Count <= 0)
                        {
                            throw new Exception("Die Rechnung konnte nicht gebucht werden, da für diese Rechnung keine Rechnungspositionen verbucht wurden. Rechnungsid: " + inv.Id);
                        }
                        acc = Accounts.generateAccountNumber(dbContext, inv.Id).ToList();
                        using (ts = new TransactionScope())
                        {

                            if (acc != null && acc.Count() == inv.InvoiceItem.Count)
                            {
                                foreach (var thisItems in acc)
                                {
                                    var myAccount = new InvoiceItemAccountItem
                                    {
                                        IIACCID = Guid.NewGuid(),
                                        InvoiceItemId = thisItems.InvoiceItemId,
                                        RevenueAccountText = thisItems.AccountNumber
                                    };
                                    log.AddcompanyMessages("Erlöskonto mit der Nummer:" + myAccount.RevenueAccountText + " wird in die Rechnung übernommen");

                                    log.Info("Erstellt Erlöskonto mit der ID:" + myAccount.IIACCID);
                                    var contains = dbContext.InvoiceItemAccountItem.FirstOrDefault(q => q.InvoiceItemId ==
                                        thisItems.InvoiceItemId && q.RevenueAccountText == thisItems.AccountNumber.Trim());
                                    if (contains != null)
                                    {
                                        log.Error("Fehler, für diese Rechnungspostion mit der id:" + thisItems.InvoiceItemId +
                                            " wurde bereits ein Erlöskonto angelegt! Die Rechnung mit der ID:" + inv.Id + " kann nicht erstellt werden.");
                                        contains.RevenueAccountText = thisItems.AccountNumber.Trim();
                                    }
                                    else
                                    {
                                        dbContext.InvoiceItemAccountItem.InsertOnSubmit(myAccount);
                                    }
                                    dbContext.SubmitChanges();

                                }

                                using (MemoryStream memS = new MemoryStream())
                                {
                                    inv.LogDBContext = dbContext;
                                    inv.Print(dbContext, memS, "");
                                    dbContext.SubmitChanges();

                                }

                                Guid? locationId = null;
                                locationId = (from inv_ in dbContext.Invoice
                                              join oi in dbContext.OrderInvoice on inv_.Id equals oi.InvoiceId
                                              join myorder in dbContext.Order on oi.OrderId equals myorder.Id
                                              where inv_.Id == inv.Id
                                              select myorder).First().LocationId;
                                        //inv.OrderInvoice.First().Order.LocationId;
                                if (inv.Customer.LargeCustomer.SendInvoiceByEmail)
                                {
                                    var emails = inv.Customer.LargeCustomer.GetMailinglistAdresses(dbContext, locationId, "Rechnung");
                                    foreach (var mails in emails)
                                    {
                                        log.AddcompanyMessages("Rechnung: " + inv.InvoiceNumber.Number +
                                            " wird per Email an: " + mails + " versendet");
                                    }
                                    Invoice.SendByMail(dbContext, inv.Id, ConfigurationManager.AppSettings["smtpHost"],
                                     ConfigurationManager.AppSettings["FromEmail"], emails);
                                }
                                else
                                {
                                    log.AddcompanyMessages("Rechnung: " + inv.InvoiceNumber.Number +
                                         " wurde erstellt und ist im CASE System zu finden, da der Kunde:"+inv.Customer.CustomerNumber+" kein Mailversand als Rechnungsversand definiert hat.");

                                }
                                ts.Complete();
                                log.Info("Rechnung: " + inv.InvoiceNumber.Number + " wurde gedruckt und abgeschlossen.");
                                log.AddcompanyMessages("Rechnung: " + inv.InvoiceNumber.Number + " wurde gedruckt und abgeschlossen.");

                            }
                            else
                            {
                                throw new Exception("Die Rechnung enthält keine Erlöskontent. Rechnungsid: " + inv.Id);
                            }

                        }
                    }
                    catch (Exception ex)
                    {
                        if(ts!=null)
                        ts.Dispose();
                        log.Error("Fehler beim Rechnungslauf in PrintInvoices:"+ex.Message);
                        log.AddcompanyMessages("Fehler beim Rechnungslauf:" + ex.Message);
                        log.AddcompanyMessages("Bitte korrigieren Sie wenn möglich den Fehler und starten einen neuen Rechnungslauf, da die Änderungen verworfen wurden.");

                        dbContext.WriteLogItem("Fehler beim Rechnungslauf in PrintInvoices:"+ex.Message, LogTypes.ERROR);
                        continue;
                    }

                }

                var invoiceRunReport = dbContext.InvoiceRunReport.FirstOrDefault(q => q.Id == rep.Id);
                invoiceRunReport.LogDBContext = dbContext;
                invoiceRunReport.InvoiceRunProgress = 100;
                invoiceRunReport.FinishedDate = DateTime.Now;
                dbContext.SubmitChanges();
                log.AddcompanyMessages("Rechnungslauf abgeschlossen");
            }
            catch (Exception ex)
            {
                log.AddcompanyMessages("Fehler beim Rechnungslauf/Rechnungsdruck, bitte kontaktieren Sie den Administrator, dieser hat die Einsicht in die Detaillogs.");
                log.Error("Fehler beim Rechnungslauf in PrintInvoices: " + ex.Message);
                dbContext.WriteLogItem("Fehler beim Rechnungslauf in PrintInvoices: " + ex.Message, LogTypes.ERROR);
            }
        }
예제 #3
0
 partial void DeleteInvoiceItemAccountItem(InvoiceItemAccountItem instance);
예제 #4
0
 partial void UpdateInvoiceItemAccountItem(InvoiceItemAccountItem instance);
예제 #5
0
 partial void InsertInvoiceItemAccountItem(InvoiceItemAccountItem instance);
예제 #6
0
		private void detach_InvoiceItemAccountItem(InvoiceItemAccountItem entity)
		{
			this.SendPropertyChanging();
			entity.InvoiceItem = null;
		}
예제 #7
0
        /// <summary>
        /// Erstellt eine neue Rechnung
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void RechnungErstellen_Click(object sender, EventArgs e)
        {
            DataClasses1DataContext dbContext = new DataClasses1DataContext(new Guid(Session["CurrentUserId"].ToString()));
            try
            {
                if (RadGridAbrechnungErstellen.SelectedItems.Count > 0)
                {
                    RechnungVorschauErrorLabel.Visible = false;
                    foreach (GridDataItem item in RadGridAbrechnungErstellen.SelectedItems)
                    {
                        Guid invoiceID = new Guid(item["invoiceId"].Text);
                        TransactionScope ts = null;
                        if (invoiceID != null)
                        {
                            var myErloeskonten = Accounts.generateAccountNumber(dbContext, invoiceID).ToList();
                            using (ts = new TransactionScope())
                            {
                                if (item.ChildItem.NestedTableViews[0].Items.Count > 0)
                                {
                                    foreach (GridDataItem myHelperItem in item.ChildItem.NestedTableViews[0].Items)
                                    {
                                        RadTextBox helperTextbox = (myHelperItem.FindControl("AccountText") as RadTextBox);
                                        Label itemId = ((Label)myHelperItem.FindControl("lblItemId")) as Label;
                                        if (helperTextbox == null || itemId == null)
                                        {
                                            throw new Exception("Fehler, bitte wiederholen Sie den Vorgang");
                                        }
                                        if (helperTextbox.Text == string.Empty && myErloeskonten.FirstOrDefault(s => s.InvoiceItemId == new Guid(itemId.Text)) == null)
                                        {
                                            throw new Exception("Alle Rechnungspositionen müssen mind. einem Erlöskonto zugewiesen sein");
                                        }
                                        if (helperTextbox.Text != string.Empty)
                                        {
                                            var Contains = myErloeskonten.FirstOrDefault(q => q.InvoiceItemId == new Guid(itemId.Text));
                                            if (Contains != null && Contains.AccountNumber != helperTextbox.Text)
                                            {
                                                Contains.AccountNumber = helperTextbox.Text;
                                            }
                                            if (Contains == null)
                                            {
                                                _Accounts acc = new _Accounts
                                                {
                                                    AccountId = Guid.NewGuid(),
                                                    AccountNumber = helperTextbox.Text,
                                                    InvoiceItemId = new Guid(itemId.Text)
                                                };
                                                myErloeskonten.Add(acc);
                                            }
                                        }
                                    }
                                }
                                var invoiceItems = from invitem in dbContext.InvoiceItem
                                                   join inv in dbContext.Invoice on invitem.InvoiceId equals inv.Id
                                                   where inv.Id == invoiceID
                                                   select new
                                                   {
                                                       ItemId = invitem.Id,
                                                   };
                                if (invoiceItems.Count() == 0)
                                {
                                    throw new Exception("Es gibt keine Rechnungspositionen, deshalb kann die Rechnung nicht erstellt werden");
                                }
                                if (!((myErloeskonten.Count() > 0 && invoiceItems.Count() > 0) && (myErloeskonten.Count() == invoiceItems.Count())))
                                {
                                    throw new Exception("Aller Rechnungspositionen müssen mind. einem Erlöskonto zugewiesen sein");
                                }
                                foreach (var thisItems in myErloeskonten)
                                {
                                    var myAccount = new InvoiceItemAccountItem
                                    {
                                        IIACCID = Guid.NewGuid(),
                                        InvoiceItemId = thisItems.InvoiceItemId,
                                        RevenueAccountText = thisItems.AccountNumber
                                    };
                                    var contains = dbContext.InvoiceItemAccountItem.FirstOrDefault(q => q.InvoiceItemId == thisItems.InvoiceItemId && q.RevenueAccountText == thisItems.AccountNumber.Trim());
                                    if (contains == null)
                                    {
                                        dbContext.InvoiceItemAccountItem.InsertOnSubmit(myAccount);
                                    }
                                    else
                                    {
                                        contains.RevenueAccountText = thisItems.AccountNumber;
                                    }

                                    dbContext.SubmitChanges();

                                }
                                Invoice newInvoice = dbContext.Invoice.SingleOrDefault(q => q.Id == invoiceID);

                                if (newInvoice.InvoiceItem.Count == 0)
                                {
                                    throw new Exception("Die Rechnung konnte nicht erstellt werden, da für diese Rechnung keine Rechnungspositionen verbucht wurden");
                                }
                                if (newInvoice.IsPrinted == false)
                                {
                                    using (MemoryStream memS = new MemoryStream())
                                    {
                                        string serverPath = ConfigurationManager.AppSettings["DataPath"] + "\\UserData";
                                        newInvoice.Print(dbContext, memS, "", defaultAccountNumber.Checked);
                                        string fileName = "Rechnung_" + newInvoice.InvoiceNumber.Number + "_" + newInvoice.CreateDate.Day + "_" + newInvoice.CreateDate.Month + "_" + newInvoice.CreateDate.Year + ".pdf";
                                        if (!Directory.Exists(serverPath)) Directory.CreateDirectory(serverPath);
                                        if (!Directory.Exists(serverPath + "\\" + Session["CurrentUserId"].ToString())) Directory.CreateDirectory(serverPath + "\\" + Session["CurrentUserId"].ToString());
                                        serverPath = serverPath + "\\" + Session["CurrentUserId"].ToString();
                                        File.WriteAllBytes(serverPath + "\\" + fileName, memS.ToArray());
                                        OpenPrintfile(fileName);
                                        dbContext.SubmitChanges();
                                    }
                                }
                                ts.Complete();
                            }
                        }
                    }
                }
                else
                {
                    RechnungVorschauErrorLabel.Visible = true;
                }
            }
            catch (Exception ex)
            {
                RechnungVorschauErrorLabel.Visible = true;
                RechnungVorschauErrorLabel.Text = "Fehler bei der Rechnungserstellung: " + ex.Message;
                dbContext.WriteLogItem("Abrechnung Error " + ex.Message, LogTypes.ERROR, "Abrechnung");
            }
            finally
            {
                RadGridAbrechnungErstellen.MasterTableView.ClearChildEditItems();
                RadGridAbrechnungErstellen.MasterTableView.ClearEditItems();
                RadGridAbrechnungErstellen.Rebind();
            }
        }