public void ReadDate()
{
// TODO: Decide on the DateTime kind (#346)
var expectedDateTime = new DateTime(2002, 3, 4, 0, 0, 0, 0, DateTimeKind.Unspecified);
var expectedNpgsqlDate = new NpgsqlDate(expectedDateTime);
ExecuteNonQuery("INSERT INTO data (field_date) VALUES ('2002-03-04')");
var cmd = new NpgsqlCommand("SELECT '2002-03-04'::DATE", Conn);
var reader = cmd.ExecuteReader();
reader.Read();
// Regular type (DateTime)
Assert.That(reader.GetFieldType(0), Is.EqualTo(typeof (DateTime)));
Assert.That(reader.GetDateTime(0), Is.EqualTo(expectedDateTime));
Assert.That(reader.GetFieldValue<DateTime>(0), Is.EqualTo(expectedDateTime));
Assert.That(reader[0], Is.EqualTo(expectedDateTime));
Assert.That(reader.GetValue(0), Is.EqualTo(expectedDateTime));
// Provider-specific type (NpgsqlDate)
Assert.That(reader.GetDate(0), Is.EqualTo(expectedNpgsqlDate));
Assert.That(reader.GetProviderSpecificFieldType(0), Is.EqualTo(typeof(NpgsqlDate)));
Assert.That(reader.GetProviderSpecificValue(0), Is.EqualTo(expectedNpgsqlDate));
Assert.That(reader.GetFieldValue<NpgsqlDate>(0), Is.EqualTo(expectedNpgsqlDate));
cmd.Dispose();
}
public void DateSpecial(NpgsqlDate value)
{
using (var cmd = new NpgsqlCommand("SELECT @p", Conn)) {
cmd.Parameters.Add(new NpgsqlParameter { ParameterName = "p", Value = value });
using (var reader = cmd.ExecuteReader()) {
reader.Read();
Assert.That(reader.GetProviderSpecificValue(0), Is.EqualTo(value));
Assert.That(() => reader.GetDateTime(0), Throws.Exception);
}
Assert.That(ExecuteScalar("SELECT 1"), Is.EqualTo(1));
}
}
public void NpgsqlDateConstructors()
{
NpgsqlDate date;
DateTime dateTime;
System.Globalization.Calendar calendar = new System.Globalization.GregorianCalendar();
date = new NpgsqlDate();
Assert.AreEqual(1, date.Day);
Assert.AreEqual(DayOfWeek.Monday, date.DayOfWeek);
Assert.AreEqual(1, date.DayOfYear);
Assert.AreEqual(false, date.IsLeapYear);
Assert.AreEqual(1, date.Month);
Assert.AreEqual(1, date.Year);
dateTime = new DateTime(2009, 5, 31);
date = new NpgsqlDate(dateTime);
Assert.AreEqual(dateTime.Day, date.Day);
Assert.AreEqual(dateTime.DayOfWeek, date.DayOfWeek);
Assert.AreEqual(dateTime.DayOfYear, date.DayOfYear);
Assert.AreEqual(calendar.IsLeapYear(2009), date.IsLeapYear);
Assert.AreEqual(dateTime.Month, date.Month);
Assert.AreEqual(dateTime.Year, date.Year);
//Console.WriteLine(new DateTime(2009, 5, 31).Ticks);
//Console.WriteLine((new DateTime(2009, 5, 31) - new DateTime(1, 1, 1)).TotalDays);
// 2009-5-31
dateTime = new DateTime(633793248000000000); // ticks since 1 Jan 1
date = new NpgsqlDate(733557); // days since 1 Jan 1
Assert.AreEqual(dateTime.Day, date.Day);
Assert.AreEqual(dateTime.DayOfWeek, date.DayOfWeek);
Assert.AreEqual(dateTime.DayOfYear, date.DayOfYear);
Assert.AreEqual(calendar.IsLeapYear(2009), date.IsLeapYear);
Assert.AreEqual(dateTime.Month, date.Month);
Assert.AreEqual(dateTime.Year, date.Year);
// copy previous value. should get same result
date = new NpgsqlDate(date);
Assert.AreEqual(dateTime.Day, date.Day);
Assert.AreEqual(dateTime.DayOfWeek, date.DayOfWeek);
Assert.AreEqual(dateTime.DayOfYear, date.DayOfYear);
Assert.AreEqual(calendar.IsLeapYear(2009), date.IsLeapYear);
Assert.AreEqual(dateTime.Month, date.Month);
Assert.AreEqual(dateTime.Year, date.Year);
}
public static ObservableCollection <Route> GetRoutes(string query)
{
using (var connection =
new NpgsqlConnection(Configuration.ConnectionString))
{
connection.Open();
using (var command = new NpgsqlCommand(query, connection))
{
using (var reader = command.ExecuteReader())
{
if (!reader.HasRows)
{
return(new ObservableCollection <Route>());
}
ObservableCollection <Route> routes =
new ObservableCollection <Route>();
while (reader.Read())
{
int routeId = reader.GetInt32(0);
string hotel = reader.GetString(1);
string from = reader.GetString(2);
string to = reader.GetString(3);
NpgsqlDate date = reader.GetDate(4);
int duration = reader.GetInt32(5);
bool meels = reader.GetBoolean(6);
string transport = reader.GetString(7);
double hotelPrice = reader.GetDouble(8);
double transportPrice = reader.GetDouble(9);
routes.Add(new Route(routeId, hotel, from, to,
new DateTime(date.Year, date.Month, date.Day),
duration, meels, transport, hotelPrice + transportPrice,
hotelPrice, transportPrice));
}
return(routes);
}
}
}
}
public void Date()
{
var dateTime = new DateTime(2002, 3, 4, 0, 0, 0, 0, DateTimeKind.Unspecified);
var npgsqlDate = new NpgsqlDate(dateTime);
using (var cmd = new NpgsqlCommand("SELECT @p1, @p2, @p3", Conn))
{
var p1 = new NpgsqlParameter("p1", NpgsqlDbType.Date);
var p2 = new NpgsqlParameter("p2", DbType.Date);
var p3 = new NpgsqlParameter {
ParameterName = "p3", Value = npgsqlDate
};
Assert.That(p3.NpgsqlDbType, Is.EqualTo(NpgsqlDbType.Date));
Assert.That(p3.DbType, Is.EqualTo(DbType.Date));
cmd.Parameters.Add(p1);
cmd.Parameters.Add(p2);
cmd.Parameters.Add(p3);
p1.Value = p2.Value = npgsqlDate;
using (var reader = cmd.ExecuteReader())
{
reader.Read();
for (var i = 0; i < cmd.Parameters.Count; i++)
{
// Regular type (DateTime)
Assert.That(reader.GetFieldType(i), Is.EqualTo(typeof(DateTime)));
Assert.That(reader.GetDateTime(i), Is.EqualTo(dateTime));
Assert.That(reader.GetFieldValue <DateTime>(i), Is.EqualTo(dateTime));
Assert.That(reader[i], Is.EqualTo(dateTime));
Assert.That(reader.GetValue(i), Is.EqualTo(dateTime));
// Provider-specific type (NpgsqlDate)
Assert.That(reader.GetDate(i), Is.EqualTo(npgsqlDate));
Assert.That(reader.GetProviderSpecificFieldType(i), Is.EqualTo(typeof(NpgsqlDate)));
Assert.That(reader.GetProviderSpecificValue(i), Is.EqualTo(npgsqlDate));
Assert.That(reader.GetFieldValue <NpgsqlDate>(i), Is.EqualTo(npgsqlDate));
}
}
}
}
public async Task Date()
{
using var conn = await OpenConnectionAsync();
var dateTime = new DateTime(2002, 3, 4, 0, 0, 0, 0, DateTimeKind.Unspecified);
var npgsqlDate = new NpgsqlDate(dateTime);
using var cmd = new NpgsqlCommand("SELECT @p1, @p2", conn);
var p1 = new NpgsqlParameter("p1", NpgsqlDbType.Date)
{
Value = npgsqlDate
};
var p2 = new NpgsqlParameter {
ParameterName = "p2", Value = npgsqlDate
};
Assert.That(p2.NpgsqlDbType, Is.EqualTo(NpgsqlDbType.Date));
Assert.That(p2.DbType, Is.EqualTo(DbType.Date));
cmd.Parameters.Add(p1);
cmd.Parameters.Add(p2);
using var reader = await cmd.ExecuteReaderAsync();
reader.Read();
for (var i = 0; i < cmd.Parameters.Count; i++)
{
// Regular type (DateTime)
Assert.That(reader.GetFieldType(i), Is.EqualTo(typeof(DateTime)));
Assert.That(reader.GetDateTime(i), Is.EqualTo(dateTime));
Assert.That(reader.GetFieldValue <DateTime>(i), Is.EqualTo(dateTime));
Assert.That(reader[i], Is.EqualTo(dateTime));
Assert.That(reader.GetValue(i), Is.EqualTo(dateTime));
// Provider-specific type (NpgsqlDate)
Assert.That(reader.GetDate(i), Is.EqualTo(npgsqlDate));
Assert.That(reader.GetProviderSpecificFieldType(i), Is.EqualTo(typeof(NpgsqlDate)));
Assert.That(reader.GetProviderSpecificValue(i), Is.EqualTo(npgsqlDate));
Assert.That(reader.GetFieldValue <NpgsqlDate>(i), Is.EqualTo(npgsqlDate));
}
}
public void Date()
{
using (var conn = OpenConnection())
{
var dateTime = new DateTime(2002, 3, 4, 0, 0, 0, 0, DateTimeKind.Unspecified);
var npgsqlDate = new NpgsqlDate(dateTime);
using (var cmd = new NpgsqlCommand("SELECT @p1, @p2, @p3", conn))
{
var p1 = new NpgsqlParameter("p1", NpgsqlDbType.Date) {Value = npgsqlDate};
var p2 = new NpgsqlParameter("p2", DbType.Date) {Value = npgsqlDate.ToString()};
var p3 = new NpgsqlParameter {ParameterName = "p3", Value = npgsqlDate};
Assert.That(p3.NpgsqlDbType, Is.EqualTo(NpgsqlDbType.Date));
Assert.That(p3.DbType, Is.EqualTo(DbType.Date));
cmd.Parameters.Add(p1);
cmd.Parameters.Add(p2);
cmd.Parameters.Add(p3);
using (var reader = cmd.ExecuteReader())
{
reader.Read();
for (var i = 0; i < cmd.Parameters.Count; i++)
{
// Regular type (DateTime)
Assert.That(reader.GetFieldType(i), Is.EqualTo(typeof (DateTime)));
Assert.That(reader.GetDateTime(i), Is.EqualTo(dateTime));
Assert.That(reader.GetFieldValue<DateTime>(i), Is.EqualTo(dateTime));
Assert.That(reader[i], Is.EqualTo(dateTime));
Assert.That(reader.GetValue(i), Is.EqualTo(dateTime));
// Provider-specific type (NpgsqlDate)
Assert.That(reader.GetDate(i), Is.EqualTo(npgsqlDate));
Assert.That(reader.GetProviderSpecificFieldType(i), Is.EqualTo(typeof (NpgsqlDate)));
Assert.That(reader.GetProviderSpecificValue(i), Is.EqualTo(npgsqlDate));
Assert.That(reader.GetFieldValue<NpgsqlDate>(i), Is.EqualTo(npgsqlDate));
}
}
}
}
}
public static ObservableCollection <Voucher> GetVouchers(string query)
{
using (var connection =
new NpgsqlConnection(Configuration.ConnectionString))
{
connection.Open();
using (var command = new NpgsqlCommand(query, connection))
{
using (var reader = command.ExecuteReader())
{
if (!reader.HasRows)
{
return(new ObservableCollection <Voucher>());
}
ObservableCollection <Voucher> vouchers =
new ObservableCollection <Voucher>();
while (reader.Read())
{
int voucherId = reader.GetInt32(0);
int routeId = reader.GetInt32(1);
string hotel = reader.GetString(2);
NpgsqlDate date = reader.GetDate(3);
int duration = reader.GetInt32(4);
double fullPrice = reader.GetDouble(5);
string fio = reader.GetString(6);
string phone = reader.GetString(7);
vouchers.Add(new Voucher(voucherId, routeId, hotel,
new DateTime(date.Year, date.Month, date.Day),
duration, fullPrice,
fio, phone));
}
return(vouchers);
}
}
}
}
public static ObservableCollection <Customer> GetCustomers(string query = "")
{
using (var connection =
new NpgsqlConnection(Configuration.ConnectionString))
{
using (var command = new NpgsqlCommand(
query == "" ? Queries.MainTables.GetCustomers : query, connection))
{
connection.Open();
using (var reader = command.ExecuteReader())
{
if (!reader.HasRows)
{
return(null);
}
ObservableCollection <Customer> collection =
new ObservableCollection <Customer>();
while (reader.Read())
{
int voucherCount = reader.GetInt32(0);
string fio = reader.GetString(1);
string phone = reader.GetString(2);
string address = reader.GetString(3);
NpgsqlDate birthday = reader.GetDate(4);
string status = reader.GetString(5);
collection.Add(new Customer(voucherCount, fio,
phone, address,
new DateTime(birthday.Year, birthday.Month,
birthday.Day), status));
}
return(collection);
}
}
}
}
private static ObservableCollection <SimpleRecord> GetAgencies()
{
using (var connection =
new NpgsqlConnection(Configuration.ConnectionString))
{
using (var command = new NpgsqlCommand(
Queries.Dictionaries.SelectAll(DictionaryKind.Agency), connection))
{
connection.Open();
using (var reader = command.ExecuteReader())
{
if (!reader.HasRows)
{
return(null);
}
ObservableCollection <SimpleRecord> collection =
new ObservableCollection <SimpleRecord>();
while (reader.Read())
{
int agencyId = reader.GetInt32(0);
string name = reader.GetString(1).TrimEnd();
string registration = reader.GetString(2).TrimEnd();
string city = reader.GetString(3).TrimEnd();
string address = reader.GetString(4).TrimEnd();
string ownership = reader.GetString(5).TrimEnd();
string phone = reader.GetString(6).TrimEnd();
NpgsqlDate date = reader.GetDate(7);
collection.Add(new Agency(agencyId, registration,
name,
city, address, ownership, phone, new DateTime(date.Year, date.Month, date.Day)));
}
return(collection);
}
}
}
}
public IEnumerable <Author> SearchAuthors(string signature, string name, NpgsqlDate minDate)
{
List <Author> authors = new List <Author>();
con.Open();
NpgsqlCommand command = new NpgsqlCommand($@"select author_id, name, surname, birthdate, signature from authors join persons on persons.person_id = authors.author_id
where
signature like '%{signature}%' and
name like '%{name}%' and
birthdate > @date" , con);
command.Parameters.Add(new NpgsqlParameter("@date", minDate));
var reader = command.ExecuteReader();
while (reader.Read())
{
authors.Add(ReadAuthor(reader));
}
con.Close();
return(authors);
}
public void SpecialDates()
{
NpgsqlDate date;
DateTime dateTime;
System.Globalization.Calendar calendar = new System.Globalization.GregorianCalendar();
// a date after a leap year.
dateTime = new DateTime(2008, 5, 31);
date = new NpgsqlDate(dateTime);
Assert.AreEqual(dateTime.Day, date.Day);
Assert.AreEqual(dateTime.DayOfWeek, date.DayOfWeek);
Assert.AreEqual(dateTime.DayOfYear, date.DayOfYear);
Assert.AreEqual(calendar.IsLeapYear(2008), date.IsLeapYear);
Assert.AreEqual(dateTime.Month, date.Month);
Assert.AreEqual(dateTime.Year, date.Year);
// A date that is a leap year day.
dateTime = new DateTime(2000, 2, 29);
date = new NpgsqlDate(2000, 2, 29);
Assert.AreEqual(dateTime.Day, date.Day);
Assert.AreEqual(dateTime.DayOfWeek, date.DayOfWeek);
Assert.AreEqual(dateTime.DayOfYear, date.DayOfYear);
Assert.AreEqual(calendar.IsLeapYear(2000), date.IsLeapYear);
Assert.AreEqual(dateTime.Month, date.Month);
Assert.AreEqual(dateTime.Year, date.Year);
// A date that is not in a leap year.
dateTime = new DateTime(1900, 3, 1);
date = new NpgsqlDate(1900, 3, 1);
Assert.AreEqual(dateTime.Day, date.Day);
Assert.AreEqual(dateTime.DayOfWeek, date.DayOfWeek);
Assert.AreEqual(dateTime.DayOfYear, date.DayOfYear);
Assert.AreEqual(calendar.IsLeapYear(1900), date.IsLeapYear);
Assert.AreEqual(dateTime.Month, date.Month);
Assert.AreEqual(dateTime.Year, date.Year);
// a date after a leap year.
date = new NpgsqlDate(-1, 12, 31);
Assert.AreEqual(31, date.Day);
Assert.AreEqual(DayOfWeek.Sunday, date.DayOfWeek);
Assert.AreEqual(366, date.DayOfYear);
Assert.AreEqual(true, date.IsLeapYear);
Assert.AreEqual(12, date.Month);
Assert.AreEqual(-1, date.Year);
}
public void NpgsqlDateMath()
{
NpgsqlDate date;
// add a day to the empty constructor
date = new NpgsqlDate() + new NpgsqlInterval(0, 1, 0);
Assert.AreEqual(2, date.Day);
Assert.AreEqual(DayOfWeek.Tuesday, date.DayOfWeek);
Assert.AreEqual(2, date.DayOfYear);
Assert.AreEqual(false, date.IsLeapYear);
Assert.AreEqual(1, date.Month);
Assert.AreEqual(1, date.Year);
// add a day the same value as the empty constructor
date = new NpgsqlDate(1, 1, 1) + new NpgsqlInterval(0, 1, 0);
Assert.AreEqual(2, date.Day);
Assert.AreEqual(DayOfWeek.Tuesday, date.DayOfWeek);
Assert.AreEqual(2, date.DayOfYear);
Assert.AreEqual(false, date.IsLeapYear);
Assert.AreEqual(1, date.Month);
Assert.AreEqual(1, date.Year);
var diff = new NpgsqlDate(1, 1, 1) - new NpgsqlDate(-1, 12, 31);
Assert.AreEqual(new NpgsqlInterval(0, 1, 0), diff);
// Test of the addMonths method (positive values added)
var dateForTestMonths = new NpgsqlDate(2008, 1, 1);
Assert.AreEqual(dateForTestMonths.AddMonths(0), dateForTestMonths);
Assert.AreEqual(dateForTestMonths.AddMonths(4), new NpgsqlDate(2008, 5, 1));
Assert.AreEqual(dateForTestMonths.AddMonths(11), new NpgsqlDate(2008, 12, 1));
Assert.AreEqual(dateForTestMonths.AddMonths(12), new NpgsqlDate(2009, 1, 1));
Assert.AreEqual(dateForTestMonths.AddMonths(14), new NpgsqlDate(2009, 3, 1));
dateForTestMonths = new NpgsqlDate(2008, 1, 31);
Assert.AreEqual(dateForTestMonths.AddMonths(1), new NpgsqlDate(2008, 2, 29));
Assert.AreEqual(dateForTestMonths.AddMonths(13), new NpgsqlDate(2009, 2, 28));
// Test of the addMonths method (negative values added)
dateForTestMonths = new NpgsqlDate(2009, 1, 1);
Assert.AreEqual(dateForTestMonths.AddMonths(0), dateForTestMonths);
Assert.AreEqual(dateForTestMonths.AddMonths(-4), new NpgsqlDate(2008, 9, 1));
Assert.AreEqual(dateForTestMonths.AddMonths(-12), new NpgsqlDate(2008, 1, 1));
Assert.AreEqual(dateForTestMonths.AddMonths(-13), new NpgsqlDate(2007, 12, 1));
dateForTestMonths = new NpgsqlDate(2009, 3, 31);
Assert.AreEqual(dateForTestMonths.AddMonths(-1), new NpgsqlDate(2009, 2, 28));
Assert.AreEqual(dateForTestMonths.AddMonths(-13), new NpgsqlDate(2008, 2, 29));
}
public IList <Author> SearchAuthors(string signature, string name, NpgsqlDate minDate)
{
return(GetAll().Where(x => x.Signature.Contains(signature) && x.Person.Name.Contains(name) && x.Person.BirthdayDate.HasValue && new NpgsqlDate(x.Person.BirthdayDate.Value) > minDate).ToList());
}
internal static object ToDate(NpgsqlBackendTypeInfo typeInfo, String backendData, Int16 typeSize, Int32 typeModifier)
{
return(NpgsqlDate.Parse(backendData));
}
public Valve(int positioTunnus, string nimitys, string valmistaja, string malli, int koko, int varastoNimike, NpgsqlDate seuraavaHuolto, NpgsqlDate huollettu, int huoltovali, out bool success) : this(positioTunnus, nimitys, valmistaja, malli, koko, varastoNimike, seuraavaHuolto, huollettu, huoltovali)
{
success = false;
}
public Valve(int positioTunnus, string nimitys, string valmistaja, string malli, int koko, int varastoNimike, NpgsqlDate seuraavaHuolto, NpgsqlDate huollettu, int huoltovali)
{
_positioTunnus = positioTunnus;
_nimi = nimitys;
_valmistaja = valmistaja;
_malli = malli;
_koko = koko;
_varastoNimike = varastoNimike;
_seuraavaHuolto = seuraavaHuolto;
_huollettu = huollettu;
_huoltovali = huoltovali;
}
public Dictionary <DateTime, int> GetSynchronizedPhysicalContacts(int userId, IEnumerable <DateTime> dateTimes)
{
Check.CallerLog <CommonCitizenRepository>(Logger, LoggerExecutionPositions.Entrance, $"userId: {userId}, dateTimes: {dateTimes}");
Check.NotNull(userId, nameof(userId));
Check.NotNull(dateTimes, nameof(dateTimes));
var synchedDateTimes = new Dictionary <DateTime, int>();
if (dateTimes.Count() < 1)
{
Check.CallerLog <CommonCitizenRepository>(Logger, LoggerExecutionPositions.Exit, $"dateTimes does not have any item.");
return(synchedDateTimes);
}
using (var connection_ = new NpgsqlConnection(RepoOptions.PgsqlPassword))
{
try
{
var query = $"SELECT id, date, time FROM (SELECT id, date, time FROM physical_contacts WHERE user_id = {userId}) WHERE ";
foreach (var dateTime in dateTimes)
{
var date = NpgsqlDate.ToNpgsqlDate(dateTime);
var time = NpgsqlTimeSpan.ToNpgsqlTimeSpan(dateTime.TimeOfDay);
query += $" (date = {date} AND time = {time}) OR";
}
query = query.TrimEnd('R').TrimEnd('O');
Check.CallerLog <CommonCitizenRepository>(Logger, LoggerExecutionPositions.Body, $"constructed query: {query}");
var command = new NpgsqlCommand(query);
command.Connection = connection_;
command.CommandType = System.Data.CommandType.Text;
command.Prepare();
using (var reader = command.ExecuteReader())
{
Check.CallerLog <CommonCitizenRepository>(Logger, LoggerExecutionPositions.Body, $"reading data from reader");
while (reader.Read())
{
var id = reader.GetInt32(0);
var date = reader.GetDate(1);
var time = reader.GetTimeSpan(2);
var dateTime = new DateTime(date.Year, date.Month, date.Day, time.Hours, time.Minutes, time.Seconds, time.Milliseconds);
synchedDateTimes.Add(dateTime, id);
}
}
}
catch (Exception exception)
{
Check.CallerLog <CommonCitizenRepository>(Logger, LoggerExecutionPositions.Body, $"Exception {exception}", LogLevel.Warning);
if (exception is BackendException)
{
throw exception;
}
throw new BackendException(Convert.ToInt32(HttpStatusCode.InternalServerError), exception.Message);
}
}
Check.CallerLog <CommonCitizenRepository>(Logger, LoggerExecutionPositions.Exit, $"synchedDateTimes: {synchedDateTimes}");
return(synchedDateTimes);
}
internal static object ToDate(NpgsqlBackendTypeInfo typeInfo, byte[] bBackendData, Int16 typeSize, Int32 typeModifier)
{
string backendData = BackendEncoding.UTF8Encoding.GetString(bBackendData);
return(NpgsqlDate.Parse(backendData));
}
static void Main(string[] args)
{
// Venttiililistan luonti
List <Valve> valveList = new List <Valve>();
// Nimikelistan luonti
List <Nimike> nimikeLista = new List <Nimike>();
// Ensimmäisen nimikenumeron asetus numeroksi 300001
int seuraavaNimike = 300001;
// Ohjelman jatkaminen kunnes muutetaan falseksi
bool jatka = true;
// Nimikelistan luonti
List <Nimike> nimikkeet = new List <Nimike>();
// Päivitetään venttiilista tietokannasta
valveList = Sql.selectKaikkiVenttiilit();
// Päivitetään nimikelista tietokannasta
nimikkeet = Sql.selectKaikkiNimikkeet();
// Rullataan 300001:stä nimikkeiden verran eteenpäin, että saadaan seuraava luotava nimike
foreach (Nimike Nimike in nimikkeet)
{
seuraavaNimike++;
}
//konstruktori nimikelistan tulostukselle
void tulostanimikkeet()
{
Console.WriteLine(String.Format("{0,-10} | {1,-15} | {2,-12} | {3,-11} | {4,7} | {5,7} | {6,11}", "Nimike", "Nimi", "Valmistaja", "Myyjä", "Hinta", "Saldo", "Minimisaldo"));
Console.WriteLine();
foreach (Nimike Nimike in nimikkeet)
{
Console.WriteLine(String.Format("{0,-10} | {1,-15} | {2,-12} | {3,-11} | {4,7} | {5,7} | {6,11}", (Nimike.tarkistaNimikeNumero()), (Nimike.tarkistaNimi()), (Nimike.tarkistaValmistaja()), (Nimike.tarkistaMyyja()), (Nimike.tarkistaHinta()), (Nimike.tarkistaSaldo()), (Nimike.tarkistaMinimisaldo())));
}
}
//konstruktori nimikelistan tulostukselle
void tulostaventtiilit()
{
Console.WriteLine(String.Format("{0,-10} | {1,-15} | {2,-12} | {3,-13} | {4,7} | {5,12} | {6,15} | {7,20} | {8,10}", "Nimike", "Nimi", "Valmistaja", "Malli", "Koko", "Varastonimike", "Seuraava huolto", "Huollettu viimeksi", "Huoltoväli"));
Console.WriteLine();
foreach (Valve Valve in valveList)
{
Console.WriteLine(String.Format("{0,-10} | {1,-15} | {2,-12} | {3,-13} | {4,7} | {5,12} | {6,15} | {7,20} | {8,10}", (Valve.tarkistaPositio()), (Valve.tarkistaNimi()), (Valve.tarkistaValmistaja()), (Valve.tarkistaMalli()), (Valve.tarkistaKoko()), (Valve.tarkistaNimike()), (Valve.tarkistaSeuraavahuolto()), (Valve.tarkistaEdellinenHuolto()), (Valve.tarkistaHuoltovali())));
}
}
//Tulostetaan ohjeet ennen looppia
TulostaOhjeet();
//Käytttäjälle näkyvän loopin aloitus
while (jatka)
{
//Loopin aloitus
Console.WriteLine("\nAnna komento ohjeen mukaan, (Ohjeet uudelleen = 9)");
string komento = Console.ReadLine();
//Loopin ohjaus käyttäjän valitsemaan paikkaan
switch (komento)
{
case "1":
// Uuden varastonimikkeen luonti
// Asetetaan nimikenumeroksi tietokannasta haettu seuraava vapaa nimike
int nimikeNumero = seuraavaNimike;
// Lisätään seuraavaa nimikettä varten yksi lisää
seuraavaNimike++;
// Annetaan nimikkeelle nimitys
Console.WriteLine("Anna uuden nimikkeelle nimi: ");
string nimi = Console.ReadLine();
// Annetaan nimikkeelle valmistaja
Console.WriteLine("Anna uuden huoltosarjan valmistaja: ");
string Nvalmistaja = Console.ReadLine();
// Annetaan nimikkeelle myyjä
Console.WriteLine("Anna uuden nimikkeen jälleenmyyjä: ");
string myyja = Console.ReadLine();
// Annetaan nimikkeelle hinta
Console.WriteLine("Anna uuden nimikkeen hinta: ");
try
{
hinta = int.Parse(Console.ReadLine());
}
catch (Exception)
{
Console.WriteLine("Anna hinta uudelleen, vain numerot hyväksytään");
hinta = int.Parse(Console.ReadLine());
}
// Annetaan nimikkeelle saldo, montako niitä on laittaa hyllyyn
Console.WriteLine("Anna nimikkeelle varastosaldo ");
try
{
saldo = int.Parse(Console.ReadLine());
}
catch (Exception)
{
Console.WriteLine("Anna saldo uudelleen, vain numerot hyväksytään");
saldo = int.Parse(Console.ReadLine());
}
// Annetaan nimikkeelle minimisaldo, määrä joka saldoa pitää vähintään olla ennen kuin niitä pitää tilata lisää
Console.WriteLine("Anna nimikkeelle minimisaldo, mikä pitää aina vähintään olla ");
int minimisaldo = int.Parse(Console.ReadLine());
// Luodaan nimike listaan ja tietokantaan
Nimike newNimike = new Nimike(nimikeNumero, nimi, Nvalmistaja, myyja, hinta, saldo, minimisaldo);
Sql.AddNimike(newNimike);
nimikeLista.Add(newNimike);
// Tulostetaan teksti, että kyseinen nimike on luotu
Console.WriteLine($"\nNimike { newNimike.tarkistaNimikeNumero() } luotu.");
break;
case "2":
// Annetaan venttiilille positionumero, jonka käyttäjä itse päättää
Console.WriteLine("Anna uuden venttiilin positio numeroina: ");
try
{
positioTunnus = int.Parse(Console.ReadLine());
}
catch (Exception)
{
Console.WriteLine("Anna positio uudelleen, vain numerot hyväksytään");
positioTunnus = int.Parse(Console.ReadLine());
}
// Annetaan venttiilille nimitys
Console.WriteLine("Anna uuden venttiilin nimitys: ");
string nimitys = Console.ReadLine();
// Annetaan venttiilille valmistaja
Console.WriteLine("Anna uuden venttiilin valmistaja: ");
string valmistaja = Console.ReadLine();
// Annetaan venttiilille malli
Console.WriteLine("Anna uuden venttiilin malli: ");
string malli = Console.ReadLine();
// Annetaan venttiilille koko
Console.WriteLine("Anna uuden venttiilin koko: ");
try
{
koko = int.Parse(Console.ReadLine());
}
catch (Exception)
{
Console.WriteLine("Anna koko uudelleen, vain numerot hyväksytään");
koko = int.Parse(Console.ReadLine());
}
// Annetaan venttiilille huollossa käytettävä varaston nimikenumero
Console.WriteLine("Anna uuden venttiilin tiivisteiden varastonimike: (nimikelistaus 1 ");
int varastoNimike = int.Parse(Console.ReadLine());
if (varastoNimike == 1)
{
tulostanimikkeet();
Console.WriteLine("Anna uuden venttiilin tiivisteiden varastonimike: ");
varastoNimike = int.Parse(Console.ReadLine());
}
NpgsqlDate huollettu = NpgsqlDate.Today;
Console.WriteLine("Anna huoltoväli vuosina: ");
int huoltovali = int.Parse(Console.ReadLine());
NpgsqlDate seuraavaHuolto = huollettu.AddYears(huoltovali);
Valve newValve = new Valve(positioTunnus, nimitys, valmistaja, malli, koko, varastoNimike, seuraavaHuolto, huollettu, huoltovali);
Sql.AddValve(newValve);
valveList.Add(newValve);
Console.WriteLine($"Venttiili { newValve.tarkistaPositio() } luotu.");
break;
case "3":
//Nimikkeiden tulostus taulukkona
{
tulostanimikkeet();
}
break;
case "4":
//Luodaan listaus venttiileistä, jossa muotoillaan tulostusasetukset taulukkomaiseen muotoon
//Ensin tulostetaan otsikot, jonka jälkeen foreachillä haetaan kaikilta venttiileiltä tiedot
Console.WriteLine(String.Format("{0,-10} | {1,-15} | {2,-12} | {3,-13} | {4,7} | {5,12} | {6,15} | {7,20} | {8,10}", "Nimike", "Nimi", "Valmistaja", "Malli", "Koko", "Varastonimike", "Seuraava huolto", "Huollettu viimeksi", "Huoltoväli"));
Console.WriteLine();
foreach (Valve Valve in valveList)
{
Console.WriteLine(String.Format("{0,-10} | {1,-15} | {2,-12} | {3,-13} | {4,7} | {5,12} | {6,15} | {7,20} | {8,10}", (Valve.tarkistaPositio()), (Valve.tarkistaNimi()), (Valve.tarkistaValmistaja()), (Valve.tarkistaMalli()), (Valve.tarkistaKoko()), (Valve.tarkistaNimike()), (Valve.tarkistaSeuraavahuolto()), (Valve.tarkistaEdellinenHuolto()), (Valve.tarkistaHuoltovali())));
}
break;
case "5":
{
Sql.selectKaikkiVenttiilit();
tulostaventtiilit();
Console.WriteLine("Anna poistettavan venttiilin positio ");
int id = int.Parse(Console.ReadLine());
Sql.poistaSql(id);
valveList = Sql.selectKaikkiVenttiilit();
}
break;
case "6":
{
Sql.selectKaikkiNimikkeet();
tulostanimikkeet();
Console.WriteLine("Anna poistettavan nimikkeen numero ");
int id = int.Parse(Console.ReadLine());
Sql.poistaNimike(id);
nimikkeet = Sql.selectKaikkiNimikkeet();
}
break;
case "9":
{
TulostaOhjeet();
}
break;
// Ohjelman lopetus
case "Q":
{
jatka = false;
}
break;
}
}
}
void INpgsqlSimpleTypeHandler <NpgsqlDate> .Write(NpgsqlDate value, NpgsqlWriteBuffer buf, NpgsqlParameter?parameter) => _bclHandler.Write(value, buf, parameter);
int INpgsqlSimpleTypeHandler <NpgsqlDate> .ValidateAndGetLength(NpgsqlDate value, NpgsqlParameter?parameter) => _bclHandler.ValidateAndGetLength(value, parameter);
public static DateTime GetDateTime(NpgsqlDate dt)
{
return((DateTime)dt);
}
