public List <ProcessOrdre> Get()
{
List <ProcessOrdre> Orders = new List <ProcessOrdre>();
using (SqlCommand cmd = new SqlCommand(GET_ALL, SQLConnectionSingleton.Instance.DbConnection))
{
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
ProcessOrdre Order = new ProcessOrdre()
{
ProcessOrderNR = reader.GetInt32(0),
ColumnNR = reader.GetInt32(1),
EndproductNR = reader.GetInt32(2),
EndProductName = reader.GetString(3).ToString(),
ProcessDate = reader.GetDateTime(4),
Process = reader.GetString(5)[0]
};
Orders.Add(Order);
}
reader.Close();
}
return(Orders);
}
public ProcessOrdre Get(int id)
{
ProcessOrdre po = null;
using (SqlCommand cmd = new SqlCommand(GET_ONE, SQLConnectionSingleton.Instance.DbConnection))
{
cmd.Parameters.AddWithValue("@id", id);
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
po = new ProcessOrdre()
{
ProcessOrderNR = reader.GetInt32(0),
ColumnNR = reader.GetInt32(1),
EndproductNR = reader.GetInt32(2),
EndProductName = reader.GetString(3).ToString(),
ProcessDate = reader.GetDateTime(4),
Process = reader.GetString(5)[0]
};
}
reader.Close();
}
return(po);
}
public ProcessOrderArk(int ProcessOrderNummer)
{
using (HttpClient client = new HttpClient())
{
Task <string> response = client.GetStringAsync("http://localhost:54926/api/ProcessOrder/" + ProcessOrderNummer);
ProcessOrdre loaded = JsonConvert.DeserializeObject <ProcessOrdre>(response.Result);
this.ColumnNR = loaded.ColumnNR;
this.EndProductName = loaded.EndProductName;
this.EndproductNR = loaded.EndproductNR;
this.ProcessDate = loaded.ProcessDate.Date;
this.Process = loaded.Process;
activities = new ObservableCollection <ProcessActivity>();
Task <string> Activityresponse = client.GetStringAsync("http://localhost:54926/api/ProcessActivity/" + this.ProcessOrderNR);
List <ProcessActivity> loadedProcessActivities = JsonConvert.DeserializeObject <List <ProcessActivity> >(Activityresponse.Result);
foreach (ProcessActivity Activity in loadedProcessActivities)
{
if (Activity.ActivityID == 10)
{
activities.Add(new EtiketteArkVM(this.ProcessOrderNR));
}
}
}
}
public static bool Post(ProcessOrdre processOrdre)
{
bool sucess = true;
using (HttpClient client = new HttpClient())
{
String SerializedProcessOrdre = JsonConvert.SerializeObject(processOrdre);
StringContent content = new StringContent(SerializedProcessOrdre, Encoding.UTF8, "application/json");
Task <HttpResponseMessage> postAsync = client.PostAsync(URI, content);
HttpResponseMessage resps = postAsync.Result;
if (resps.IsSuccessStatusCode)
{
string jsonResString = resps.Content.ReadAsStringAsync().Result;
sucess = JsonConvert.DeserializeObject <bool>(jsonResString);
}
else
{
sucess = false;
}
}
return(sucess);
}
//Hjælpemetode
private ProcessOrdre ReadProcessOrdre(SqlDataReader reader)
{
ProcessOrdre processOrdre = new ProcessOrdre(reader.GetInt32(0), reader.GetInt32(1), reader.GetDateTime(2));
processOrdre.Kolonne = reader.GetInt32(3);
return(processOrdre);
}
public static bool SaveProcessOrder(ProcessOrdre po)
{
using (HttpClient client = new HttpClient())
{
string JsonString = JsonConvert.SerializeObject(po);
StringContent st = new StringContent(JsonString, Encoding.ASCII, "application/json");
Task <HttpResponseMessage> response = client.PostAsync("http://localhost:54926/api/ProcessOrder", st);
return(response.Result.StatusCode == HttpStatusCode.OK);
}
}
public string DatabaseInputCheck(int processOrdreNr)
{
string result = "";
ProcessOrdre processOrdre = PersistencyProcessOrdre.Get(processOrdreNr);
if (!(processOrdre == null))
{
result = "Procesordre Nummer: Der findes allerede en processordre med dette nummer.";
}
return(result);
}
public static ProcessOrdre Get(int processOrdreNr)
{
ProcessOrdre processOrdre = new ProcessOrdre();
using (HttpClient client = new HttpClient())
{
Task <string> resTask = client.GetStringAsync($"{URI}/{processOrdreNr}");
string jsonStr = resTask.Result;
processOrdre = JsonConvert.DeserializeObject <ProcessOrdre>(jsonStr);
}
return(processOrdre);
}
public bool Post(ProcessOrdre po)
{
using (SqlCommand cmd = new SqlCommand(INSERT, SQLConnectionSingleton.Instance.DbConnection))
{
cmd.Parameters.AddWithValue("@Process", po.Process);
cmd.Parameters.AddWithValue("@ProcessOrderNR", po.ProcessOrderNR);
cmd.Parameters.AddWithValue("@ColumnNR", po.ColumnNR);
cmd.Parameters.AddWithValue("@EndProductNR", po.EndproductNR);
cmd.Parameters.AddWithValue("@EndProductName", po.EndProductName);
cmd.Parameters.AddWithValue("@ProcessDate", po.ProcessDate);
int RowsAffected = cmd.ExecuteNonQuery();
return(RowsAffected == 1);
}
}
public ProcessListingControl()
{
selectedActivities = new List <Models.Activity>();
SaveOrder = new ProcessOrdre()
{
Process = 'p', ProcessDate = DateTime.Now
};
this.InitializeComponent();
PlannedList = FindName("PlanlagteOrdre") as ListView;
AktiveList = FindName("AktiveOrdre") as ListView;
ArkiveredeList = FindName("ArkiveredeOrdre") as ListView;
AktivitetsListe = FindName("AktivitetsListe") as ListView;
EditGrid = FindName("EditGridView") as StackPanel;
SaveGrid = FindName("SaveGridView") as StackPanel;
}
//GETALL: API/ProcessOrdre
public IEnumerable <ProcessOrdre> Get()
{
List <ProcessOrdre> liste = new List <ProcessOrdre>();
SqlConnection connection = new SqlConnection(ConnectionString);
connection.Open();
SqlCommand cmd = new SqlCommand(GETAll, connection);
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
ProcessOrdre processOrdre = ReadProcessOrdre(reader);
liste.Add(processOrdre);
}
connection.Close();
return(liste);
}
//GETONE: api/ProcessOrdre/1
public ProcessOrdre Get(int pONr)
{
ProcessOrdre processOrdre = new ProcessOrdre();
SqlConnection connection = new SqlConnection(ConnectionString);
connection.Open();
SqlCommand cmd = new SqlCommand(GETONE, connection);
cmd.Parameters.AddWithValue("@No", pONr);
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
processOrdre = ReadProcessOrdre(reader);
}
connection.Close();
return(processOrdre);
}
public IEnumerable <ProcessOrdre> Get(DateTime date)
{
List <ProcessOrdre> liste = new List <ProcessOrdre>();
SqlConnection connection = new SqlConnection(ConnectionString);
connection.Open();
SqlCommand cmd = new SqlCommand(GETDATE, connection);
cmd.Parameters.AddWithValue("@Date", date);
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
ProcessOrdre processOrdre = ReadProcessOrdre(reader);
liste.Add(processOrdre);
}
connection.Close();
return(liste);
}
public void Upload()
{
List <string> errormessages = InternalValidate();
if (errormessages.Count() == 0)
{
ProcessOrdre processOrdre = _vM.OpretningProcessOrdre;
Persistency.PersistencyProcessOrdre.Post(processOrdre);
InternalOpen();
}
else
{
string errormessage = "";
foreach (string s in errormessages)
{
errormessage = $"{errormessage}{s} \n";
}
errormessage = $"{errormessage} \n Procesordren blev ikke oprettet. Ingen procesordre blev åbnet.";
MessageDialogHelper.Show(errormessage, "Fejl:");
}
}
public static bool SaveArk(ProcessOrderArk savePo)
{
using (HttpClient client = new HttpClient())
{
ProcessOrdre PO = new ProcessOrdre()
{
ProcessOrderNR = savePo.ProcessOrderNR,
ColumnNR = savePo.ColumnNR,
EndproductNR = savePo.EndproductNR,
EndProductName = savePo.EndProductName,
ProcessDate = savePo.ProcessDate,
Process = savePo.Process
};
string jsonString = JsonConvert.SerializeObject(PO);
StringContent content = new StringContent(jsonString, Encoding.ASCII, "application/json");
Task <HttpResponseMessage> response = client.PutAsync("http://localhost:54926/api/ProcessOrder/" + PO.ProcessOrderNR, content);
return(response.Result.IsSuccessStatusCode);
}
return(true);
}
// POST: api/ProcessOrdre
public bool Post(ProcessOrdre processOrdre)
{
bool retValue;
SqlConnection connection = new SqlConnection(ConnectionString);
connection.Open();
SqlCommand cmd = new SqlCommand(INSERT, connection);
cmd.Parameters.AddWithValue("@Process_Ordre_Nr", processOrdre.ProcessOrdreNr);
cmd.Parameters.AddWithValue("@Faerdigvare_Nr", processOrdre.FaerdigVareNr);
cmd.Parameters.AddWithValue("@Dato", processOrdre.Dato);
cmd.Parameters.AddWithValue("@Kolonne", processOrdre.Kolonne);
int rowsAffected = cmd.ExecuteNonQuery();
retValue = rowsAffected == 1;
connection.Close();
return(retValue);
}
public void TestInitialize()
{
_processOrdreManager = new ProcessOrdreManager();
_processOrdre = new ProcessOrdre(9000000, 1, DateTime.Now);
_processOrdreManager.Delete(_processOrdre.ProcessOrdreNr);
}
protected VMBase(int processOrdre, int faerdigVareNr, DateTime dato)
{
_processOrdre = new ProcessOrdre(processOrdre, faerdigVareNr, dato);
}
// PUT: api/ProcessOrder/5
public bool Put(int id, [FromBody] ProcessOrdre value)
{
return(poMan.Put(value));
}
// POST: api/ProcessOrder
public bool Post([FromBody] ProcessOrdre value)
{
return(poMan.Post(value));
}
// POST: api/ProcessOrdre
public bool Post([FromBody] ProcessOrdre processOrdre)
{
return(manager.Post(processOrdre));
}
