Beispiel #1
0
        public static void Tariff0003()
        {
            var tariff = new Tariff(Tariff_Id.Parse("12"),
                                    Currency.EUR,
                                    TariffUrl:      new Uri("https://company.com/tariffs/12"),
                                    TariffElements: Enumeration.Create(
                                        new TariffElement(
                                            PriceComponent.ChargingTime(2.00M, TimeSpan.FromSeconds(300))
                                            )
                                        )
                                    );

            var expected = new JObject(new JProperty("id", "12"),
                                       new JProperty("currency", "EUR"),
                                       new JProperty("tariff_alt_url", "https://company.com/tariffs/12"),
                                       new JProperty("elements", new JArray(
                                                         new JObject(
                                                             new JProperty("price_components", new JArray(
                                                                               new JObject(
                                                                                   new JProperty("type", "TIME"),
                                                                                   new JProperty("price", "2.00"),
                                                                                   new JProperty("step_size", 300)
                                                                                   )))
                                                             )
                                                         )));

            Assert.AreEqual(expected.ToString(), tariff.ToJSON().ToString());
        }
Beispiel #2
0
        public static void Tariff_SerializeDeserialize_Test01()
        {
            var TariffA = new Tariff(
                CountryCode.Parse("DE"),
                Party_Id.Parse("GEF"),
                Tariff_Id.Parse("TARIFF0001"),
                Currency.EUR,
                new TariffElement[] {
                new TariffElement(
                    new PriceComponent[] {
                    PriceComponent.ChargingTime(
                        TimeSpan.FromSeconds(300),
                        2.00M,
                        0.10M
                        )
                },
                    new TariffRestrictions [] {
                    new TariffRestrictions(
                        Time.FromHourMin(08, 00),                            // Start time
                        Time.FromHourMin(18, 00),                            // End time
                        DateTime.Parse("2020-12-01"),                        // Start timestamp
                        DateTime.Parse("2020-12-31"),                        // End timestamp
                        1.12M,                                               // MinkWh
                        5.67M,                                               // MaxkWh
                        1.34M,                                               // MinCurrent
                        8.89M,                                               // MaxCurrent
                        1.49M,                                               // MinPower
                        9.91M,                                               // MaxPower
                        TimeSpan.FromMinutes(10),                            // MinDuration
                        TimeSpan.FromMinutes(30),                            // MaxDuration
                        new DayOfWeek[] {
                        DayOfWeek.Monday,
                        DayOfWeek.Tuesday
                    },
                        ReservationRestrictionTypes.RESERVATION
                        )
                }
                    )
            },
                TariffTypes.PROFILE_GREEN,
                new DisplayText[] {
                new DisplayText(Languages.de, "Hallo Welt!"),
                new DisplayText(Languages.en, "Hello world!"),
            },
                URL.Parse("https://open.charging.cloud"),
                new Price(               // Min Price
                    1.10,
                    1.26
                    ),
                new Price(               // Max Price
                    2.20,
                    2.52
                    ),
                DateTime.Parse("2020-12-01"),               // Start timestamp
                DateTime.Parse("2020-12-31"),               // End timestamp
                new EnergyMix(
                    true,
                    new EnergySource[] {
                new EnergySource(
                    EnergySourceCategories.SOLAR,
                    80
                    ),
                new EnergySource(
                    EnergySourceCategories.WIND,
                    20
                    )
            },
                    new EnvironmentalImpact[] {
                new EnvironmentalImpact(
                    EnvironmentalImpactCategories.CARBON_DIOXIDE,
                    0.1
                    )
            },
                    "Stadtwerke Jena-Ost",
                    "New Green Deal"
                    ),
                DateTime.Parse("2020-09-22")
                );

            var JSON = TariffA.ToJSON();

            Assert.AreEqual("DE", JSON["country_code"].Value <String>());
            Assert.AreEqual("GEF", JSON["party_id"].Value <String>());
            Assert.AreEqual("TARIFF0001", JSON["id"].Value <String>());

            Assert.IsTrue(Tariff.TryParse(JSON, out Tariff TariffB, out String ErrorResponse));
            Assert.IsNull(ErrorResponse);

            Assert.AreEqual(TariffA.CountryCode, TariffB.CountryCode);
            Assert.AreEqual(TariffA.PartyId, TariffB.PartyId);
            Assert.AreEqual(TariffA.Id, TariffB.Id);
            Assert.AreEqual(TariffA.Currency, TariffB.Currency);
            Assert.AreEqual(TariffA.TariffElements, TariffB.TariffElements);

            Assert.AreEqual(TariffA.TariffType, TariffB.TariffType);
            Assert.AreEqual(TariffA.TariffAltText, TariffB.TariffAltText);
            Assert.AreEqual(TariffA.TariffAltURL, TariffB.TariffAltURL);
            Assert.AreEqual(TariffA.MinPrice, TariffB.MinPrice);
            Assert.AreEqual(TariffA.MaxPrice, TariffB.MaxPrice);
            Assert.AreEqual(TariffA.Start, TariffB.Start);
            Assert.AreEqual(TariffA.End, TariffB.End);
            Assert.AreEqual(TariffA.EnergyMix, TariffB.EnergyMix);

            Assert.AreEqual(TariffA.LastUpdated.ToIso8601(), TariffB.LastUpdated.ToIso8601());
        }
Beispiel #3
0
        public static void CDR_SerializeDeserialize_Test01()
        {
            #region Defined CDR1

            var CDR1 = new CDR(CountryCode.Parse("DE"),
                               Party_Id.Parse("GEF"),
                               CDR_Id.Parse("CDR0001"),
                               DateTime.Parse("2020-04-12T18:20:19Z"),
                               DateTime.Parse("2020-04-12T22:20:19Z"),
                               new CDRToken(
                                   Token_Id.Parse("1234"),
                                   TokenTypes.RFID,
                                   Contract_Id.Parse("C1234")
                                   ),
                               AuthMethods.AUTH_REQUEST,
                               new CDRLocation(
                                   Location_Id.Parse("LOC0001"),
                                   "Biberweg 18",
                                   "Jena",
                                   "Deutschland",
                                   GeoCoordinate.Parse(10, 20),
                                   EVSE_UId.Parse("DE*GEF*E*LOC0001*1"),
                                   EVSE_Id.Parse("DE*GEF*E*LOC0001*1"),
                                   Connector_Id.Parse("1"),
                                   ConnectorTypes.IEC_62196_T2,
                                   ConnectorFormats.SOCKET,
                                   PowerTypes.AC_3_PHASE,
                                   "Name?",
                                   "07749"
                                   ),
                               Currency.EUR,

                               new ChargingPeriod[] {
                new ChargingPeriod(
                    DateTime.Parse("2020-04-12T18:21:49Z"),
                    new CDRDimension[] {
                    new CDRDimension(
                        CDRDimensions.ENERGY,
                        1.33M
                        )
                },
                    Tariff_Id.Parse("DE*GEF*T0001")
                    ),
                new ChargingPeriod(
                    DateTime.Parse("2020-04-12T18:21:50Z"),
                    new CDRDimension[] {
                    new CDRDimension(
                        CDRDimensions.TIME,
                        5.12M
                        )
                },
                    Tariff_Id.Parse("DE*GEF*T0002")
                    )
            },

                               // Total costs
                               new Price(
                                   10.00,
                                   11.60
                                   ),

                               // Total Energy
                               50.00M,

                               // Total time
                               TimeSpan.FromMinutes(30),

                               Session_Id.Parse("0815"),
                               AuthorizationReference.Parse("Auth0815"),
                               Meter_Id.Parse("Meter0815"),

                               // OCPI Computer Science Extentions
                               new EnergyMeter(
                                   Meter_Id.Parse("Meter0815"),
                                   "EnergyMeter Model #1",
                                   "hw. v1.80",
                                   "fw. v1.20",
                                   "Energy Metering Services",
                                   null,
                                   null
                                   ),

                               // OCPI Computer Science Extentions
                               new TransparencySoftware[] {
                new TransparencySoftware(
                    "Chargy Transparency Software Desktop Application",
                    "v1.00",
                    LegalStatus.LegallyBinding,
                    OpenSourceLicenses.GPL3,
                    "GraphDefined GmbH",
                    URL.Parse("https://open.charging.cloud/logo.svg"),
                    URL.Parse("https://open.charging.cloud/Chargy/howto"),
                    URL.Parse("https://open.charging.cloud/Chargy"),
                    URL.Parse("https://github.com/OpenChargingCloud/ChargyDesktopApp")
                    ),
                new TransparencySoftware(
                    "Chargy Transparency Software Mobile Application",
                    "v1.00",
                    LegalStatus.ForInformationOnly,
                    OpenSourceLicenses.GPL3,
                    "GraphDefined GmbH",
                    URL.Parse("https://open.charging.cloud/logo.svg"),
                    URL.Parse("https://open.charging.cloud/Chargy/howto"),
                    URL.Parse("https://open.charging.cloud/Chargy"),
                    URL.Parse("https://github.com/OpenChargingCloud/ChargyMobileApp")
                    )
            },

                               new Tariff[] {
                new Tariff(
                    CountryCode.Parse("DE"),
                    Party_Id.Parse("GEF"),
                    Tariff_Id.Parse("TARIFF0001"),
                    Currency.EUR,
                    new TariffElement[] {
                    new TariffElement(
                        new PriceComponent[] {
                        PriceComponent.ChargingTime(
                            TimeSpan.FromSeconds(300),
                            2.00M,
                            0.10M
                            )
                    },
                        new TariffRestrictions [] {
                        new TariffRestrictions(
                            Time.FromHourMin(08, 00),                                 // Start time
                            Time.FromHourMin(18, 00),                                 // End time
                            DateTime.Parse("2020-12-01"),                             // Start timestamp
                            DateTime.Parse("2020-12-31"),                             // End timestamp
                            1.12M,                                                    // MinkWh
                            5.67M,                                                    // MaxkWh
                            1.34M,                                                    // MinCurrent
                            8.89M,                                                    // MaxCurrent
                            1.49M,                                                    // MinPower
                            9.91M,                                                    // MaxPower
                            TimeSpan.FromMinutes(10),                                 // MinDuration
                            TimeSpan.FromMinutes(30),                                 // MaxDuration
                            new DayOfWeek[] {
                            DayOfWeek.Monday,
                            DayOfWeek.Tuesday
                        },
                            ReservationRestrictionTypes.RESERVATION
                            )
                    }
                        )
                },
                    TariffTypes.PROFILE_GREEN,
                    new DisplayText[] {
                    new DisplayText(Languages.de, "Hallo Welt!"),
                    new DisplayText(Languages.en, "Hello world!"),
                },
                    URL.Parse("https://open.charging.cloud"),
                    new Price(                    // Min Price
                        1.10,
                        1.26
                        ),
                    new Price(                    // Max Price
                        2.20,
                        2.52
                        ),
                    DateTime.Parse("2020-12-01"),                    // Start timestamp
                    DateTime.Parse("2020-12-31"),                    // End timestamp
                    new EnergyMix(
                        true,
                        new EnergySource[] {
                    new EnergySource(
                        EnergySourceCategories.SOLAR,
                        80
                        ),
                    new EnergySource(
                        EnergySourceCategories.WIND,
                        20
                        )
                },
                        new EnvironmentalImpact[] {
                    new EnvironmentalImpact(
                        EnvironmentalImpactCategories.CARBON_DIOXIDE,
                        0.1
                        )
                },
                        "Stadtwerke Jena-Ost",
                        "New Green Deal"
                        ),
                    DateTime.Parse("2020-09-22")
                    )
            },

                               new SignedData(
                                   EncodingMethod.GraphDefiened,
                                   new SignedValue[] {
                new SignedValue(
                    SignedValueNature.START,
                    "PlainStartValue",
                    "SignedStartValue"
                    ),
                new SignedValue(
                    SignedValueNature.INTERMEDIATE,
                    "PlainIntermediateValue",
                    "SignedIntermediateValue"
                    ),
                new SignedValue(
                    SignedValueNature.END,
                    "PlainEndValue",
                    "SignedEndValue"
                    )
            },
                                   1,     // Encoding method version
                                   null,  // Public key
                                   "https://open.charging.cloud/pools/1/stations/1/evse/1/publicKey"
                                   ),

                               // Total Fixed Costs
                               new Price(
                                   20.00,
                                   23.10
                                   ),

                               // Total Energy Cost
                               new Price(
                                   20.00,
                                   23.10
                                   ),

                               // Total Time Cost
                               new Price(
                                   20.00,
                                   23.10
                                   ),

                               // Total Parking Time
                               TimeSpan.FromMinutes(120),

                               // Total Parking Cost
                               new Price(
                                   20.00,
                                   23.10
                                   ),

                               // Total Reservation Cost
                               new Price(
                                   20.00,
                                   23.10
                                   ),

                               "Remark!",
                               InvoiceReference_Id.Parse("Invoice:0815"),
                               true, // IsCredit
                               CreditReference_Id.Parse("Credit:0815"),

                               DateTime.Parse("2020-09-12")

                               );

            #endregion

            var JSON = CDR1.ToJSON();

            Assert.AreEqual("DE", JSON["country_code"].Value <String>());
            Assert.AreEqual("GEF", JSON["party_id"].Value <String>());
            Assert.AreEqual("CDR0001", JSON["id"].Value <String>());


            Assert.IsTrue(CDR.TryParse(JSON, out CDR CDR2, out String ErrorResponse));
            Assert.IsNull(ErrorResponse);

            Assert.AreEqual(CDR1.CountryCode, CDR2.CountryCode);
            Assert.AreEqual(CDR1.PartyId, CDR2.PartyId);
            Assert.AreEqual(CDR1.Id, CDR2.Id);

            Assert.AreEqual(CDR1.Start.ToIso8601(), CDR2.Start.ToIso8601());
            Assert.AreEqual(CDR1.End.ToIso8601(), CDR2.End.ToIso8601());
            Assert.AreEqual(CDR1.CDRToken, CDR2.CDRToken);
            Assert.AreEqual(CDR1.AuthMethod, CDR2.AuthMethod);
            Assert.AreEqual(CDR1.Location, CDR2.Location);
            Assert.AreEqual(CDR1.Currency, CDR2.Currency);
            Assert.AreEqual(CDR1.ChargingPeriods, CDR2.ChargingPeriods);
            Assert.AreEqual(CDR1.TotalCosts, CDR2.TotalCosts);
            Assert.AreEqual(CDR1.TotalEnergy, CDR2.TotalEnergy);
            Assert.AreEqual(CDR1.TotalTime, CDR2.TotalTime);

            Assert.AreEqual(CDR1.SessionId, CDR2.SessionId);
            Assert.AreEqual(CDR1.AuthorizationReference, CDR2.AuthorizationReference);
            Assert.AreEqual(CDR1.MeterId, CDR2.MeterId);
            Assert.AreEqual(CDR1.EnergyMeter, CDR2.EnergyMeter);
            Assert.AreEqual(CDR1.TransparencySoftwares, CDR2.TransparencySoftwares);
            Assert.AreEqual(CDR1.Tariffs, CDR2.Tariffs);
            Assert.AreEqual(CDR1.SignedData, CDR2.SignedData);
            Assert.AreEqual(CDR1.TotalFixedCosts, CDR2.TotalFixedCosts);
            Assert.AreEqual(CDR1.TotalEnergyCost, CDR2.TotalEnergyCost);
            Assert.AreEqual(CDR1.TotalTimeCost, CDR2.TotalTimeCost);
            Assert.AreEqual(CDR1.TotalParkingTime, CDR2.TotalParkingTime);
            Assert.AreEqual(CDR1.TotalParkingCost, CDR2.TotalParkingCost);
            Assert.AreEqual(CDR1.TotalReservationCost, CDR2.TotalReservationCost);
            Assert.AreEqual(CDR1.Remark, CDR2.Remark);
            Assert.AreEqual(CDR1.InvoiceReferenceId, CDR2.InvoiceReferenceId);
            Assert.AreEqual(CDR1.Credit, CDR2.Credit);
            Assert.AreEqual(CDR1.CreditReferenceId, CDR2.CreditReferenceId);

            Assert.AreEqual(CDR1.LastUpdated.ToIso8601(), CDR2.LastUpdated.ToIso8601());
        }
Beispiel #4
0
        public static void Tariff0004()
        {
            var tariff = new Tariff(Tariff_Id.Parse("11"),
                                    Currency.EUR,
                                    TariffUrl:      new Uri("https://company.com/tariffs/11"),
                                    TariffElements: new List <TariffElement>()
            {
                // 2.50 euro start tariff
                new TariffElement(
                    PriceComponent.FlatRate(2.50M)
                    ),

                // 1.00 euro per hour charging tariff for less than 32A (paid per 15 minutes)
                new TariffElement(
                    PriceComponent.ChargingTime(1.00M, TimeSpan.FromSeconds(900)),
                    TariffRestriction.MaxPower(32M)
                    ),

                // 2.00 euro per hour charging tariff for more than 32A on weekdays (paid per 10 minutes)
                new TariffElement(
                    PriceComponent.ChargingTime(2.00M, TimeSpan.FromSeconds(600)),
                    new TariffRestriction(Power:      DecimalMinMax.FromMin(32M),
                                          DayOfWeek:  Enumeration.Create(
                                              DayOfWeek.Monday,
                                              DayOfWeek.Tuesday,
                                              DayOfWeek.Wednesday,
                                              DayOfWeek.Thursday,
                                              DayOfWeek.Friday
                                              ))
                    ),

                // 1.25 euro per hour charging tariff for more then 32A during the weekend (paid per 10 minutes)
                new TariffElement(
                    PriceComponent.ChargingTime(1.25M, TimeSpan.FromSeconds(600)),
                    new TariffRestriction(Power:      DecimalMinMax.FromMin(32M),
                                          DayOfWeek:  Enumeration.Create(
                                              DayOfWeek.Saturday,
                                              DayOfWeek.Sunday
                                              ))
                    ),


                // Parking on weekdays: between 09:00 and 18:00: 5 euro(paid per 5 minutes)
                new TariffElement(
                    PriceComponent.ParkingTime(5M, TimeSpan.FromSeconds(300)),
                    new TariffRestriction(Time:       TimeRange.From(9).To(18),
                                          DayOfWeek:  Enumeration.Create(
                                              DayOfWeek.Monday,
                                              DayOfWeek.Tuesday,
                                              DayOfWeek.Wednesday,
                                              DayOfWeek.Thursday,
                                              DayOfWeek.Friday
                                              ))
                    ),

                // Parking on saturday: between 10:00 and 17:00: 6 euro (paid per 5 minutes)
                new TariffElement(
                    PriceComponent.ParkingTime(6M, TimeSpan.FromSeconds(300)),
                    new TariffRestriction(Time:       TimeRange.From(10).To(17),
                                          DayOfWeek:  new DayOfWeek[] {
                    DayOfWeek.Saturday
                })
                    )
            }
                                    );

            var expected = new JObject(new JProperty("id", "11"),
                                       new JProperty("currency", "EUR"),
                                       new JProperty("tariff_alt_url", "https://company.com/tariffs/11"),
                                       new JProperty("elements", new JArray(

                                                         // 2.50 euro start tariff
                                                         new JObject(
                                                             new JProperty("price_components", new JArray(
                                                                               new JObject(
                                                                                   new JProperty("type", "FLAT"),
                                                                                   new JProperty("price", "2.50"),
                                                                                   new JProperty("step_size", 1)
                                                                                   )))
                                                             ),


                                                         // 1.00 euro per hour charging tariff for less than 32A (paid per 15 minutes)
                                                         new JObject(
                                                             new JProperty("price_components", new JArray(
                                                                               new JObject(
                                                                                   new JProperty("type", "TIME"),
                                                                                   new JProperty("price", "1.00"),
                                                                                   new JProperty("step_size", 900)
                                                                                   ))),
                                                             new JProperty("restrictions", new JArray(
                                                                               new JObject(
                                                                                   new JProperty("max_power", "32.00")
                                                                                   )
                                                                               ))
                                                             ),

                                                         // 2.00 euro per hour charging tariff for more than 32A on weekdays (paid per 10 minutes)
                                                         new JObject(
                                                             new JProperty("price_components", new JArray(
                                                                               new JObject(
                                                                                   new JProperty("type", "TIME"),
                                                                                   new JProperty("price", "2.00"),
                                                                                   new JProperty("step_size", 600)
                                                                                   ))),
                                                             new JProperty("restrictions", new JArray(
                                                                               new JObject(
                                                                                   new JProperty("min_power", "32.00"),
                                                                                   new JProperty("day_of_week", new JArray("MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY"))
                                                                                   )
                                                                               ))
                                                             ),

                                                         // 1.25 euro per hour charging tariff for more then 32A during the weekend (paid per 10 minutes)
                                                         new JObject(
                                                             new JProperty("price_components", new JArray(
                                                                               new JObject(
                                                                                   new JProperty("type", "TIME"),
                                                                                   new JProperty("price", "1.25"),
                                                                                   new JProperty("step_size", 600)
                                                                                   ))),
                                                             new JProperty("restrictions", new JArray(
                                                                               new JObject(
                                                                                   new JProperty("min_power", "32.00"),
                                                                                   new JProperty("day_of_week", new JArray("SATURDAY", "SUNDAY"))
                                                                                   )
                                                                               ))
                                                             ),

                                                         // Parking on weekdays: between 09:00 and 18:00: 5 euro(paid per 5 minutes)
                                                         new JObject(
                                                             new JProperty("price_components", new JArray(
                                                                               new JObject(
                                                                                   new JProperty("type", "PARKING_TIME"),
                                                                                   new JProperty("price", "5.00"),
                                                                                   new JProperty("step_size", 300)
                                                                                   ))),
                                                             new JProperty("restrictions", new JArray(
                                                                               new JObject(
                                                                                   new JProperty("start_time", "09:00"),
                                                                                   new JProperty("end_time", "18:00"),
                                                                                   new JProperty("day_of_week", new JArray("MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY"))
                                                                                   )
                                                                               ))
                                                             ),

                                                         // Parking on saturday: between 10:00 and 17:00: 6 euro (paid per 5 minutes)
                                                         new JObject(
                                                             new JProperty("price_components", new JArray(
                                                                               new JObject(
                                                                                   new JProperty("type", "PARKING_TIME"),
                                                                                   new JProperty("price", "6.00"),
                                                                                   new JProperty("step_size", 300)
                                                                                   ))),
                                                             new JProperty("restrictions", new JArray(
                                                                               new JObject(
                                                                                   new JProperty("start_time", "10:00"),
                                                                                   new JProperty("end_time", "17:00"),
                                                                                   new JProperty("day_of_week", new JArray("SATURDAY"))
                                                                                   )
                                                                               ))
                                                             )

                                                         )));

            Assert.AreEqual(expected.ToString(), tariff.ToJSON().ToString());
        }