Paste Search Dynamic
Recent pastes
Konstanter som kan benyttes
  1.  
  2. using system;
  3. using system.IO;
  4. using system.Text;
  5. using system.Globalization;
  6.  
  7. namespace LG04_Csv_To_Txt
  8. {
  9.         static class Constants
  10.         {
  11.                 /*Konstanter som kan benyttes på tvers av klasser
  12.                   Lengde på feltene som skal skrives til en tekstfil */
  13.                 public static readonly int[] UBWFixedFieldLength = new int[98] {25, 25,160, 2,20,  1, 25, 25,255,255,
  14.                                                                                                                                                 25,  4,  4, 4, 4,  4,  4,  4, 35, 25,
  15.                                                                                                                                                 25, 25,  8, 1,20, 25,255,255,255, 50,
  16.                                                                                                                                                 25,  8, 25,25,25, 25, 25, 25, 25, 25,
  17.                                                                                                                                                 25, 25, 25,25,25, 25, 25, 25, 20, 20,
  18.                                                                                                                                                 50, 20,100,25, 4, 12,120,120, 10, 25,
  19.                                                                                                                                                 50, 25,255, 8, 8, 15,  2,  2,  4,  6,
  20.                                                                                                                                                 40, 40, 25,25,25,  8,  8, 20, 60,  1,
  21.                                                                                                                                                 50, 25, 25, 8,25,100,100,100,100,  2,
  22.                                                                                                                                                  3,255, 20,20,15, 25, 25, 15};
  23.                
  24.                 /*Påkrevede felter i HEADER.
  25.                   0 = skal ikke være med,
  26.                   1 = MÅ være med,
  27.                   2 = kan være med */
  28.                 public static readonly int[] UBWMandatoryFields_Header = new int[98] {0,2,2,0,0,0,1,2,2,0,
  29.                                                                                                                                                           0,2,2,2,2,2,2,2,2,1,
  30.                                                                                                                                                           1,2,2,2,0,1,2,2,2,2,
  31.                                                                                                                                                           2,2,2,2,0,0,0,0,0,0,
  32.                                                                                                                                                           0,0,2,2,2,2,2,2,0,0,
  33.                                                                                                                                                           2,2,1,2,0,0,1,2,0,2,
  34.                                                                                                                                                           2,2,2,2,2,1,2,2,2,1,
  35.                                                                                                                                                           2,2,0,1,2,0,2,0,0,1,
  36.                                                                                                                                                           0,0,0,2,2,2,1,1,0,1,
  37.                                                                                                                                                           0,0,0,0,2,2,0,2};
  38.                 /*Påkrevede felter i ARTIKKEL.
  39.                   0 = skal ikke være med,
  40.                   1 = MÅ være med,
  41.                   2 = kan være med */
  42.                 public static readonly int[] UBWMandatoryFields_Articles = new int[98] {2, 0, 0, 2, 1, 1, 0, 0, 0, 1,
  43.                                                                                                                                                                 1, 0, 0, 0, 0, 0, 0, 0, 0, 1,
  44.                                                                                                                                                                 1, 0, 0, 0, 1, 0, 0, 0, 0, 0,
  45.                                                                                                                                                                 0, 2, 0, 0, 1, 2, 2, 2, 2, 2,
  46.                                                                                                                                                                 2, 0, 0, 0, 0, 0, 0, 0, 2, 2,
  47.                                                                                                                                                                 0, 2, 0, 0, 1, 2, 0, 0, 2, 0,
  48.                                                                                                                                                                 0, 0, 0, 0, 0, 1, 0, 0, 0, 1,
  49.                                                                                                                                                                 0, 0, 2, 0, 0, 1, 0, 2, 0, 1,
  50.                                                                                                                                                                 2, 2, 2, 2, 0, 0, 0, 0, 0, 1,
  51.                                                                                                                                                                 2, 2, 1, 1, 0, 2, 2, 0 };
  52.                
  53.                 //Navn på feltene
  54.                 public static readonly string[] UBWFieldName = new string[98] {"Account",       "Accountable",  "Address",      "Allocation_key", "Amount",       "Amount_set",   "Apar_id",       "Apar_id_ref",    "Apar_name",     "Art_descr",
  55.                                                                                                                                            "Article",       "Att_1_id",     "Att_2_id",     "Att_3_id",       "Att_4_id",     "Att_5_id",     "Att_6_id",      "Att_7_id",       "Bank_account",  "Batch_id",
  56.                                                                                                                                            "Client",        "Client_ref",   "Confirm_date", "Control",        "Cur_amount",   "Currency",     "Del_Met_descr", "Del_term_descr", "Deliv_addr",    "Deliv_attention",
  57.                                                                                                                                            "Deliv_country", "Deliv_date",   "Deliv_method", "Deliv_terms",    "Dim_1",        "Dim_2",        "Dim_3",         "Dim_4",          "Dim_5",         "Dim_6",
  58.                                                                                                                                            "Dim_7",         "Dim_value_1",  "Dim_value_2",  "Dim_value_3",    "Dim_value_4",  "Dim_value_5",  "Dim_value_6",   "Dim_value_7",    "Discount",      "Disc_percent",
  59.                                                                                                                                            "Ean",           "Exch_rate",    "Ext_ord_ref",  "Inrule_id",      "Line_no",      "Location",     "Long_info_1",   "long_info_2",    "Lot",           "Main_apar_id",
  60.                                                                                                                                            "Mark_attention","Mark_ctry_cd", "Markings",     "Obs_date",       "Order_date",   "Order_id",     "Order_type",    "Pay_method",     "Pay_temp_id",   "Period",
  61.                                                                                                                                            "Place",         "Province",     "Rel_value",    "Responsible",    "Responsible2", "Seq_no",       "Seq_ref",       "Serial_no",      "Short_info",    "Status",
  62.                                                                                                                                            "Sup_article",   "Tax_code",     "Tax_system",   "Template_id",    "Terms_id",     "Text1",        "Text2",         "Text3",          "Text4",         "Trans_type",
  63.                                                                                                                                            "unit_code",     "Unit_descr",   "Unit_price",   "Value_1",        "Voucher_ref",  "Voucher_type", "Warehouse",     "ZIP_code"};
  64.  
  65.                 /*"Datatype" på feltetene.
  66.                    s = string,
  67.                    su = string med store bokstaver
  68.                    n = numerisk,
  69.                    nx = numerisk som skal ganges opp med 100 (UBW må ha inn et heltall) */
  70.                 public static readonly string[] UBWDatatype = new string[98] {"su", "s",  "su", "n",  "nx", "n",  "su", "su", "s",  "s",
  71.                                                                                                                                           "su", "su", "su", "su", "su", "su", "su", "su", "s",  "s",
  72.                                                                                                                                           "su", "su", "s",  "su", "nx", "su", "s",  "s",  "s",  "s",
  73.                                                                                                                                           "su", "s",  "su", "su", "su", "su", "su", "su", "su", "su",
  74.                                                                                                                                           "su", "su", "su", "su", "su", "su", "su", "su", "nx", "nx",
  75.                                                                                                                                           "s",  "nx", "s",  "su", "n",  "su", "s",  "s",  "su", "su",
  76.                                                                                                                                           "s",  "su", "s",  "s",  "s",  "n",  "su", "su", "su", "n",
  77.                                                                                                                                           "s",  "s",  "su", "su", "su", "n",  "n",  "su", "s",  "su",
  78.                                                                                                                                           "su", "su", "su", "n",  "su", "su", "su", "su", "su", "su",
  79.                                                                                                                                           "su", "s",  "nx", "nx", "n",  "su", "su", "su"};
  80.                
  81.                 //Verdien som skal brukes til å "Padde" feltene for å få en fast lengde
  82.                 public static readonly char blanke = ' ';
  83.                
  84.                 //Sti til Feilloggen
  85.                 public static readonly string errLogPath = "c:\LG04_CsvToTxt_ErrorLog.txt";
  86.                
  87.                 //Antall dager å beholde leggelementer
  88.                 public static readonly int daysToKeep = 7;
  89.                
  90.                 //Sett format på datetime
  91.                 public static readonly string dateTimeFormat = "dd-mm-yyyy HH:mm:ss";
  92.                 public static readonly string dateFormat = "dd-mm-yyyy";
  93.                
  94.                 //Skal headere skrives i filen?
  95.                 public static readonly bool printHeaders = true;
  96.         }
  97.        
  98.        
  99.         class Program
  100.         {
  101.                 /*
  102.                
  103.                 Konverterer en CSV fil til TXT fil med faste posisjoner.
  104.                
  105.                 NB!!  Det kan med fordel legges inn riktigere feilhåndtering i programmet (try {.... catch {...)
  106.                
  107.                 Dette er noe vi bør få Evry til å lage for alle importfiler vi benytter.
  108.                 Mulig å legge til som et steg FØR innlesing av fil i UBW??????
  109.                
  110.                 */
  111.                
  112.  
  113.                 [STAThread]
  114.                 static void Main()
  115.                 {  
  116.                         string strH1, strH2, strA1, strA1a, strA2;
  117.                         string sTrimmed;
  118.                         StringBuilder strB = new StringBuilder();
  119.                         string[] felter;
  120.                         int iLineNumber = 0;
  121.                         int iFieldNumber = 0;
  122.                         int i = 0;
  123.                         int numberOfDeletedLines = 0;
  124.                         int err = 0;
  125.                         bool HEADER = false;
  126.                        
  127.                         //Slett innhold eldre enn x dager fra feilloggen
  128.                         //numberOfDeletedLines = Housekeeping();
  129.                         //skrivFeilmelding(0, 0, "", "Antall linjer slettet i feilloggen pga alder: " + numberOfDeletedLines);
  130.  
  131.                         //Chars som skal fjernes fra alle tekstfelter.
  132.                         //Må vurdere om det er andre karakterer vi må ta høyde for
  133.                         char[] CharsToRemoveFromString = new char[3] {' ', 'n', 'r'};
  134.                        
  135.                         // Simulerer HeaderLinjene i fila som leses inn
  136.                         strH1 = ";;;;;;0;;;;;;;;;;;;;20211001;K0 ;;;;;NOK;;;;;;;;;;;;;;;;;;;;;;;;;;;93361;;0;;Beitstad 1;;;;;;;;;26548;;;;202109;;;;26548;;;;;;N;;;;;;;LG04;840029212;;42;;;;;;;;";
  137.                         strH2 = ";;;;;;0;;;;;;;;;;;;;20211001; K0;;;;;NOK;;;;;;;;;;;;;;;;;;;;;;;;;;;93361;;0;;Beitstad 1;;;;;;;;;26999;;;;202109;;;;26999;;;;;;N;;;;;;;LG04;840029212;;42;;;;;;;;";
  138.                        
  139.                         // Simulerer Varelinjene i fila som leses inn
  140.                         strA1  = ";;;0;176;1;;;;NRK valg 1, Middag, NRK, Normal               ;25001;;;;;;;;;20211001;K0;;;;176,0;;;;;;;;;;93361;;;;;;;;;;;;;;;;;;;;1;;;;;;;;;;;26594;;;;202109;;;;;;0;;;;N;;;;;;;;;;42;;;88,0   ;2;;;;";
  141.                         strA1a = ";;;0;176;1;;;;NRK valg 1, Middag, NRK, Normal               ;25001;;;;;;;;;20211001;K0;;;;176,0;;;;;;;;;;93361;;;;;;;;;;;;;;;;;;;;2;;;;;;;;;;;26594;;;;202109;;;;;;0;;;;N;;;;;;;;;;42;;;176,000;1;;;;";                      
  142.                         strA2  = ";;;0;176;1;;;;Spesialkost valg 1, Middag, -HELTKJØTT, Normal;25001;;;;;;;;;20211001;K0;;;;176,0;;;;;;;;;;93361;;;;;;;;;;;;;;;;;;;;1;;;;;;;;;;;26999;;;;202109;;;;;;0;;;;N;;;;;;;;;;42;;;88     ;2;;;;";
  143.                                          
  144.  
  145.                         // Tabell som etterligner en fil som leses linje for linje
  146.                         string[] inputFile = new string[] {strH1,strA1,strA1a,strH2,strA2};
  147.                        
  148.                         //Skriv feltnavn på første linje
  149.                         //Kommenteres ut i produksjonsmiljø eller sett verdien i konstanten printHeaders til false
  150.                         if (Constants.printHeaders)
  151.                         {
  152.                                 foreach (string n in Constants.UBWFieldName)
  153.                                 {
  154.                                         if (n.Length <= Constants.UBWFixedFieldLength[i])
  155.                                         {
  156.                                                 //Konstruer linjen, felt for felt
  157.                                                 strB.Append(n.PadRight(Constants.UBWFixedFieldLength[i], Constants.blanke));
  158.                                         }
  159.                                         else
  160.                                         {
  161.                                                 //Konstruer linjen, felt for felt
  162.                                                 strB.Append(n.Substring(0, Constants.UBWFixedFieldLength[i]).PadRight(Constants.UBWFixedFieldLength[i], Constants.blanke));
  163.                                         }
  164.                                         i++;
  165.                                 }
  166.                                 //Lagre linjen i en variabel sammen med alle andre linjer
  167.                                 strB.AppendLine();
  168.                         }
  169.                        
  170.                        
  171.                         // Alt det magiske for alle linjer og felter skjer her
  172.                         // Loop i alle linjer i fila
  173.                         foreach (string linje in inputFile)
  174.                         {
  175.                                 iLineNumber += 1;
  176.        
  177.                                 //Split opp hver linje i verdier mellom semikolon
  178.                                 //Det blir en tabell
  179.                                 felter = linje.Split(';');
  180.                                
  181.                                 Console.WriteLine("::" + felter[87] + " - " + felter[88] + " - " + felter[89]);
  182.                                                                
  183.                                 //Sjekk om det er en header eller artikkellinje
  184.                                 if (felter[6].Length > 0 && string.IsNullOrEmpty(felter[4]))
  185.                                 {
  186.                                         HEADER = true;
  187.                                 }
  188.                                 else if (string.IsNullOrEmpty(felter[6]) && felter[4].Length > 0)
  189.                                 {
  190.                                         HEADER = false;
  191.                                 }
  192.                                 else
  193.                                 {
  194.                                         skrivFeilmelding(iLineNumber, 0, "", "Kan ikke avgjøre om dette er en Header- eller artikkellinje. Apar_ID mangler");
  195.                                 }              
  196.  
  197.                                 //Loop i alle felter i linja
  198.                                 foreach (string felt in felter)
  199.                                 {
  200.                                         iFieldNumber += 1;
  201.                                        
  202.                                         if (HEADER)
  203.                                         {
  204.                                                 //Sjekk om feltet MÅ være tilstede.
  205.                                                 if (Constants.UBWMandatoryFields_Header[iFieldNumber-1] == 1 && string.IsNullOrEmpty(felt))
  206.                                                 {
  207.                                                         skrivFeilmelding(iLineNumber, iFieldNumber-1, Constants.UBWFieldName[iFieldNumber-1], "Feltet MÅ ha en verdi");
  208.                                                 }
  209.                                         }
  210.                                         else
  211.                                         {
  212.                                                 //Sjekk om feltet MÅ være tilstede.
  213.                                                 if (Constants.UBWMandatoryFields_Articles[iFieldNumber-1] == 1 && string.IsNullOrEmpty(felt.Trim(CharsToRemoveFromString)))
  214.                                                 {
  215.                                                         skrivFeilmelding(iLineNumber, iFieldNumber-1, Constants.UBWFieldName[iFieldNumber-1], "Feltet MÅ ha en verdi");
  216.                                                 }
  217.                                         }
  218.  
  219.                                         //Fjern blanke før og etter innholdet
  220.                                         //Her bør man ta høyde for at det kan ligge forskjellige skjulte chars i feltet
  221.                                         //Eks. char(10), char(13)
  222.                                         sTrimmed = felt.Trim(CharsToRemoveFromString);
  223.  
  224.                                         //Hvis det er et beløp som ligger i feltet skal det ikke inneholde desimalskilletegn.
  225.                                         //Skal ha med 2 desimaltall slik at UBW kan dele på 100 for å få riktig tall
  226.                                         //Dette kan sikkert gjøres mer elegant, men har ikke tid
  227.                                         if (Constants.UBWDatatype[iFieldNumber-1].ToLower() == "nx")
  228.                                         {
  229.                                                 sTrimmed = removeDecimalSign_And_EnforceTwoDecimalDigits(iFieldNumber-1, iLineNumber, sTrimmed);
  230.                                         }
  231.                                         if (Constants.UBWDatatype[iFieldNumber-1].ToLower() == "su")
  232.                                         {
  233.                                                 sTrimmed = sTrimmed.ToUpper();
  234.                                         }
  235.                                         strB.Append(constructLine(iFieldNumber-1, iLineNumber, sTrimmed));
  236.                                 }
  237.                                 //Lagre linjen i en variabel sammen med alle andre linjer
  238.                                 strB.AppendLine();
  239.                                
  240.                                 HEADER = false;
  241.                                 iFieldNumber = 0;
  242.                         }
  243.                        
  244.                         /*
  245.                        
  246.                         if (!Globals.Err)
  247.                         {
  248.                                 //Skriv til en ny fysisk fil kun hvis det ikke finnes feil i gammel fil
  249.                                 //Eventuelle feilmeldinger finnes i loggen
  250.                                 string filePath = "<path>filnavn.txt";  
  251.  
  252.                                 using (StreamWriter swriter = new StreamWriter(filePath))
  253.                                 {
  254.                                         swriter.Write(strB.ToString());
  255.                                 }  
  256.  
  257.                                
  258.                                 //Gi nytt navn til gammel fil
  259.                                 // <Kode HER>
  260.                                
  261.                                 //Gi ny fil til navnet til den gamle filen
  262.                                 // <Kode HER>
  263.                         }
  264.                         */
  265.                        
  266.                        
  267.                         //Simulerer skriv til fil
  268.                         if (!Globals.Err)
  269.                         {
  270.                                 //Globals.Err settes i skrivFeilmelding
  271.                                 //Skriver linjen kun hvis det ikke er feil i kjøringen
  272.                                 //Fortsetter eksekvering slik at alle feil i filen kan logges og rettes før neste kjøring
  273.                                 Console.WriteLine(strB);
  274.                         }
  275.                
  276.                 } // END MAIN
  277.                
  278.                
  279.                
  280.                 public class Globals
  281.                 {
  282.                         //Verdien settes i skrivFeilmelding
  283.                         //Holder verdien av en variabel som kan modifiseres fra "over alt"
  284.                         private static bool _err;
  285.                         public static bool Err
  286.                         {
  287.                                 get { return _err; }
  288.                                 set { _err = value; }
  289.                         }
  290.                 }
  291.                
  292.                
  293.                 private static string checkIfNumeric(string n, int lNr, int fNr, string navn)
  294.                 {
  295.                         string retVal;
  296.                         //Alle numeriske verdier skal være 0 hvis de ikke er et gyldig nummer
  297.                         if (string.IsNullOrEmpty(n))
  298.                         {
  299.                                 retVal = "0";
  300.                         }
  301.                         else
  302.                         {
  303.                                 //Sjekk om feltet inneholder en gyldig numerisk verdi
  304.                                 decimal fNumerisk;
  305.                                 var isNum = decimal.TryParse(n, out fNumerisk);
  306.                                 if (!isNum)
  307.                                 {
  308.                                         //FEILMELDING
  309.                                         skrivFeilmelding(lNr, fNr, navn, "Verdi: " + n + " er ikke et gyldig nummer. Settes til 0.");
  310.                                         retVal = "nAn";
  311.                                 }
  312.                                 else
  313.                                 {
  314.                                         retVal = n;
  315.                                 }
  316.                         }
  317.                         return retVal;
  318.                 }       //END checkIfNumeric
  319.                
  320.                 private static void skrivFeilmelding(int lNr, int fNr, string navn, string e)
  321.                 {
  322.                         //Bør vel skrives til en eller annen fil/logg??
  323.                         //Se Funksjonen WriteToErrorLog() nederst i programmet
  324.                         //if (lNr == 0 && fNr == 0 && navn == "") { WriteToErrorLog(e + "n------------------------------------------------------------------n");}
  325.                         //else { WriteToErrorLog("Feil i linjenummer " + lNr + ", feltnummer " + fNr + " med navn " + navn + "n" + e + "n------------------------------------------------------------------n");}
  326.                         Console.WriteLine("Feil i linjenummer " + lNr + ", feltnummer " + fNr + " med navn " + navn + "n" + e + "n------------------------------------------------------------------n");
  327.                         Globals.Err = true;
  328.                 }       //END skrivFeilmelding
  329.                
  330.                 private static string removeDecimalSign_And_EnforceTwoDecimalDigits(int iFnr, int iLnr, string str)
  331.                 {
  332.                         string retVal = "";
  333.                         string sNum1, sNum2;
  334.                         int l;
  335.                        
  336.                         try
  337.                         {
  338.                                 //Splitt nummeret i 2 felter for å isolere tall før og etter desimalskilletegn
  339.                                 string[] sNum = str.Split(",", StringSplitOptions.RemoveEmptyEntries);
  340.                                 l = sNum.Length;
  341.                                                
  342.                                 if (l == 0)
  343.                                 {
  344.                                         //Det er ikke innhold i feltet. Sett det til 0
  345.                                         sNum1 = "0";
  346.                                         sNum2 = "0";
  347.                                 }
  348.                                 else
  349.                                 {
  350.                                         sNum1 = checkIfNumeric(sNum[0], iLnr, iFnr+1, Constants.UBWFieldName[iFnr]);
  351.                                         if (sNum1 == "nAn")
  352.                                         {
  353.                                                 //Hvis sNum1 = "nAn" settes feltet sTrimmed til 0
  354.                                                 retVal = "0";
  355.                                         }
  356.                                         else
  357.                                         {
  358.                                                 if (l == 1)
  359.                                                 {
  360.                                                         //Hvis sNum.Length er 1 finnes det ikke desimaler i nummeret
  361.                                                         //Legg til 2 desimaler
  362.                                                         retVal = sNum1 + "00";
  363.                                                 }
  364.                                                 if (l == 2)
  365.                                                 {
  366.                                                         //Linjenummer, feltnummer og navn sendes med kun for å gi en eventuell informativ feilmelding
  367.                                                         sNum2 = checkIfNumeric(sNum[1], iLnr, iFnr+1, Constants.UBWFieldName[iFnr]);
  368.                                                         if (sNum2 == "nAn")
  369.                                                         {
  370.                                                                 sNum2 = "0";
  371.                                                         }
  372.                                                         //Hvis sNum2 er et tall sjekkes lengden for å avgjøre antall 0 - nuller - vi skal legge til
  373.                                                         //Hvis sNum2 = "nAn" rører vi ikke feltet sTrimmed
  374.                                                         if (sNum2.Length == 1) { retVal = sNum1 + sNum2 + "0"; }
  375.                                                         if (sNum2.Length == 2) { retVal = sNum1 + sNum2; }
  376.                                                         if (sNum2.Length > 2) { retVal = sNum1 + sNum2.Substring(0, 2); }
  377.                                                 }
  378.                                         }
  379.                                 }
  380.                         } catch (Exception e) { skrivFeilmelding(iLnr, iFnr+1, Constants.UBWFieldName[iFnr], e.Message); }
  381.                         return retVal;
  382.                 } //END removeDecimalSign_And_EnforceTwoDecimalDigits
  383.                
  384.                 private static string constructLine(int iFnr, int iLnr, string str)
  385.                 {
  386.                         string retVal = "";
  387.  
  388.                         try
  389.                         {
  390.                                 //Konstruer linjen, felt for felt
  391.                                 //Datatypen forteller om feltet skal høyre eller venstrejusteres
  392.                                 if (Constants.UBWDatatype[iFnr].ToLower() == "s" || Constants.UBWDatatype[iFnr].ToLower() == "su")
  393.                                 {
  394.                                         retVal = str.PadRight(Constants.UBWFixedFieldLength[iFnr], Constants.blanke);
  395.                                 }
  396.                                 else if (Constants.UBWDatatype[iFnr].ToLower() == "n" || Constants.UBWDatatype[iFnr] == "nx")
  397.                                 {
  398.                                         if (string.IsNullOrEmpty(str))
  399.                                         {
  400.                                                 str = "0";
  401.                                         }
  402.                                         retVal = str.PadLeft(Constants.UBWFixedFieldLength[iFnr], Constants.blanke);    
  403.                                 }
  404.                                 else { skrivFeilmelding(iLnr, iFnr + 1, Constants.UBWFieldName[iFnr], "Feil angivelse av datatype. Kan kun være 's', 'su', 'n' eller 'nx'"); } 
  405.                         }
  406.                         catch (Exception e2) { skrivFeilmelding(iLnr, iFnr+1, Constants.UBWFieldName[iFnr], e2.Message); }
  407.                        
  408.                         return retVal;
  409.             }   //END constructLine
  410.          
  411.                 /*  
  412.                         public static void WriteToErrorLog(string strLog) {
  413.                                 //Eksempel på skriv til en logg
  414.                                 //Feilmeldinger kan eksempelvis skrives hit
  415.                                 //Når programmet starter kan man slette logger eldre enn i dag slik at man alltid har dagens logg tilgjengelig.
  416.                                 StreamWriter log;
  417.                                 FileStream fileStream = null;
  418.                                 DirectoryInfo logDirInfo = null;
  419.                                 FileInfo logFileInfo;
  420.  
  421.                                 string logFilePath = Constants.errLogPath;
  422.                                 logFileInfo = new FileInfo(logFilePath);
  423.                                 logDirInfo = new DirectoryInfo(logFileInfo.DirectoryName);
  424.                                
  425.                                 //Lag en ny mappe dersom den ikke finnes
  426.                                 if (!logDirInfo.Exists) logDirInfo.Create();
  427.                                
  428.                                 if (!logFileInfo.Exists)
  429.                                 {
  430.                                         //Lag en ny fil dersom den ikke eksisterer
  431.                                         fileStream = logFileInfo.Create();
  432.                                 }
  433.                                 else
  434.                                 {
  435.                                         //Filen eksisterer. Åpne den
  436.                                         fileStream = new FileStream(logFilePath, FileMode.Append);
  437.                                 }
  438.                                
  439.                                 //Hent tidsbegreper
  440.                                 DateTime date = DateTime.Now;
  441.                                 int h = date.Hour;
  442.                                 int m = date.Minute;
  443.                                 int s = date.Second;
  444.  
  445.                                 //Skriv feilmeldingen. Legg til time:minutt:sekund til linjen med feilmeldingen
  446.                                 log = new StreamWriter(fileStream);
  447.                                 //log.WriteLine(h + ":" + m + ":" + s + " - " + strLog);
  448.                                 log.WriteLine(date.ToString(Constants.dateTimeFormat) + " " + strLog);
  449.                                 log.Close();
  450.                         }   //END WriteToErrorLog
  451.                        
  452.                         public static int Housekeeping() {
  453.                                 //Sletter alle linjer i feilloggen med dato mindre enn dagens dato minus antall dager å beholde linjer
  454.                                 //Hver linje starter med datoen de ble skrevet til filen
  455.                                 string strFilePath = Constants.errLogPath;
  456.                                 //DateTime dT = DateTime.Now;
  457.                                 DateTime cutOffDate = DateTime.Now;
  458.                                 cutOffDate = Convert.ToDateTime(cutOffDate).Subtract(TimeSpan.FromDays(Constants.daysToKeep));
  459.                                 DateTime dateOnLine, dateValue;
  460.                                 string strOldText;
  461.                                 string n = "";
  462.                                 string strDate = "";
  463.                                 int deletedLines = 0;
  464.                                
  465.                                 StreamReader sr = File.OpenText(strFilePath);
  466.                                 while ((strOldText = sr.ReadLine()) != null)
  467.                                 {
  468.                                         strDate = strOldText.Substring(0, 19);
  469.                                        
  470.                                         if (DateTime.TryParse(strDate, out dateValue)) {
  471.                                                 //Vi har datoen på linjen. Linjen slettes hvis den er for gammel
  472.                                                 if (cutOffDate <= dateValue) {
  473.                                                         n += strOldText + Environment.NewLine;
  474.                                                 }
  475.                                                 else { deletedLines += 1; }
  476.                                         }
  477.                                         else {
  478.                                                 //Feil ved konvertering av dato, hopp over (linjen vil ikke bli slettet)
  479.                                                
  480.                                         }
  481.                                 }
  482.                                 sr.Close();
  483.                                 File.WriteAllText(strFilePath, n);
  484.                                 return deletedLines;
  485.                         }       //END DeleteFromErrorlog
  486.                 */
  487.  
  488.         } // END Program
  489.  
  490. }       //END namespace
  491.  
Parsed in 0.069 seconds