Autor Beitrag
Chocoemilio
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 36



BeitragVerfasst: Do 02.08.18 11:11 
Hi

Ich bräuchte mal wieder Hilfe und zwar geht es um Otto.OttoTool_Control DB (siehe EntwicklerEcke Bild).
In der Tabelle sollen per Linq pro spalte alle Personen Gruppiert und aufgezählt werden. So das ich die Namen + die Aufzählung im DataGrid angezeigt bekomme.

ausblenden Quelltext
1:
2:
3:
4:
z.b : packet_list        packing        delivery_note

      Tobias Ruhe 12    Tobias Ruhe 3   Tobias Ruhe 3
      Ferhat Ipek 10    usw.

Ich habe schon was geschrieben das leider nicht richtig funktioniert:

ausblenden C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
var query1 = (from t in temp
                             group t by new { t.packet_list, t.packing, t.delivery_note }
                             into grp
                             select new
                             {
                                 grp.Key.packet_list,
                                 grp.Key.packing,
                                 grp.Key.delivery_note,
                                 Quantity = grp.Count()
                             }).ToList();

Das Ergebnis:
ausblenden Quelltext
1:
2:
3:
4:
5:
packet_list        packing        delivery_note

Tobias Ruhe 9    
Ferhat Ipek 10    
Tobias Ruhe 3    Tobias Ruhe 3   Tobias Ruhe 3


Ich habe einiges problert aber komme auf kein richtiges Ergebnis ?????

Danke schon mal.

Moderiert von user profile iconTh69: Code-Tags hinzugefügt
Einloggen, um Attachments anzusehen!
Th69
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Moderator
Beiträge: 3951
Erhaltene Danke: 812

Win7
C++, C# (VS 2015/17)
BeitragVerfasst: Do 02.08.18 11:29 
Wenn du nur nach Namen sortieren willst, dann gib auch nur t.packet_list beim group by an.

Aber was soll denn dann für packing und delivery_note ausgegeben werden (diese können sich ja je Datensatz unterscheiden)? Ich verstehe deine beiden Tabellenausgaben nicht (welche ich mal in Code-Tags gepackt habe, wegen besserer Formatierung).
Chocoemilio Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 36



BeitragVerfasst: Do 02.08.18 11:42 
Hi

In jeder spalte können unterschiedliche Namen stehen und die verschiedenen Namen sollen per spalte aufgezählt werden.

In dem Bild erkennt man das Tobias Ruhe in der spalte packet_list 12 mal vorkommt und Ferhad 10 mal.

In packing und delivery_note sind jeweils Tobias Ruhe 3 mal vorhanden.

Die zweite Tabelle ist das resultat von der Linq abfrage.
Th69
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Moderator
Beiträge: 3951
Erhaltene Danke: 812

Win7
C++, C# (VS 2015/17)
BeitragVerfasst: Do 02.08.18 11:53 
Achso, dann wirst du aber je Spalte eigene Abfragen dafür schreiben müssen (bzw. Unterabfragen).
Zuerst müßtest du allerdings eine Liste aller verschiedenen Namen erzeugen (falls in den anderen Spalten Namen vorkommen, welche nicht in der ersten Spalte auftauchen).
Chocoemilio Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 36



BeitragVerfasst: Do 02.08.18 13:05 
Ok ok

ich verstehe habe da jetzt was gebastelt und die zahlen stimmen auch aber irgendwie gefällt es mir nicht richtig.
Vielleicht gibt es eine bessere Methode ?????

ausblenden C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
var query1 = (from t in temp
                             group t by new { t.packet_list }
                             into grp
                             select new
                             {
                                 grp.Key.packet_list,
                                 Quantity = grp.Count(),
                                 packing = (from c in temp
                                            group c by new { c.packing }
                                            into grc
                                            select new
                                            {
                                                grc.Key.packing,
                                                Quantity = grc.Count()
                                            }),
                                 delivery_note = (from c in temp
                                            group c by new { c.delivery_note }
                                            into grc
                                            select new
                                            {
                                                grc.Key.delivery_note,
                                                Quantity = grc.Count()
                                            })
                             }).ToList();
Th69
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Moderator
Beiträge: 3951
Erhaltene Danke: 812

Win7
C++, C# (VS 2015/17)
BeitragVerfasst: Do 02.08.18 13:48 
Ja, so ähnlich meinte ich es.
Aber müßtest du nicht in den Unterabfragen noch eine Bedingung für grp.Key.packet_list einbauen (denn sonst hast du doch jeweils die gleichen Unterabfragen)?
Chocoemilio Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 36



BeitragVerfasst: Do 02.08.18 14:25 
Ich weiß nicht genau was du meinst ???
Habe auch das Problem das ich auf die Unterabfragen Ergebnisse nicht ran komme ???
Th69
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Moderator
Beiträge: 3951
Erhaltene Danke: 812

Win7
C++, C# (VS 2015/17)
BeitragVerfasst: Do 02.08.18 16:07 
Deine Unterabfragen für packing (sowie delivery_note) sind so für jedes Element grp.Key.packet_list gleich.
Müßtest du nicht so etwas machen:
ausblenden C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
packing = (from c in temp
           where c.packing = grp.Key.packet_list // <- Abfrage auf gleichen Namen
           group c by new { c.packing }
           into grc
           select new
           {
               grc.Key.packing,
               Quantity = grc.Count()
          }),

(bzw. das group by kannst du dann weglassen, da es ja eh nur 1 Gruppe gibt)

PS: So ist jedoch packing eine Liste (wenn auch nur mit 1 Element). Du müßtest also noch .FirstOrDefault() hinzufügen.
Chocoemilio Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 36



BeitragVerfasst: Fr 03.08.18 08:04 
Hi

ja Danke ich verstehe aber leider kriege ich die Daten nicht so raus wie ich möchte :-(.

Naja dann nehme ich den langen Weg und bestell mir eine neue Liste.

Danke nochmal für die Hilfe
Chocoemilio Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 36



BeitragVerfasst: Fr 03.08.18 15:14 
Die fertige Liste:

ausblenden volle Höhe C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
private void anzeige_Click(object sender, RoutedEventArgs e)
        {
            int count = 0;
            int count1 = 0;
            int count2 = 0;
            int count3 = 0;
            int count4 = 0;
            int count5 = 0;
            string[] allpacketListEmployee = new string[1];
            string[] allpackedUpEmployee = new string[1];
            string[] alldeliveryNoteEmployee = new string[1];
            string[] allcardboardLabelsEmployee = new string[1];
            string[] allpalletsEmployee = new string[1];
            string[] alldeliveryInsideEmployee = new string[1];

            DateTime date1 = DateTime.Now;
            DateTime date2 = DateTime.Now;

            if (vonDatum.Text != Convert.ToString(date1.ToString("d")) && bisDatum.Text != Convert.ToString(date2.ToString("d")) || vonDatum.Text != Convert.ToString(date1.ToString("d")) && bisDatum.Text == Convert.ToString(date2.ToString("d")) ||
                vonDatum.Text == Convert.ToString(date1.ToString("d")) && bisDatum.Text != Convert.ToString(date2.ToString("d")) || vonDatum.Text == Convert.ToString(date1.ToString("d")) && bisDatum.Text == Convert.ToString(date2.ToString("d")))
            {
                //Die Daten werden an das DataGrid zur Darstellung gesendet
                var temp = ottoDataSetControlTableAdapter.GetDataBy(vonDatum.SelectedDate, bisDatum.SelectedDate);

                List<MitarbeiterAnsichtCount> query = (from t in temp
                                                       orderby t.packetDate
                                                       select new MitarbeiterAnsichtCount
                                                       (
                                                           t.ova,
                                                           t.packet_list,
                                                           t.packing,
                                                           t.delivery_note,
                                                           t.cardboard_labels,
                                                           t.pallets,
                                                           t.delivery_inside
                                                        )).ToList();


                //Aufzählung
                foreach (MitarbeiterAnsichtCount i in query)
                {
                    //Kommissionierer
                    if (i.packetListEmployee != "")
                    {
                        if (!allpacketListEmployee.Contains(i.packetListEmployee))
                        {
                            allpacketListEmployee[count] = i.packetListEmployee;
                            count++;
                            //Array wird immer um ein Element vergrößert
                            Array.Resize(ref allpacketListEmployee, allpacketListEmployee.Length + 1);
                        }
                    }
                    //Verpacker
                    if (i.packedUpEmployee != "")
                    {
                        if (!allpackedUpEmployee.Contains(i.packedUpEmployee))
                        {
                            allpackedUpEmployee[count1] = i.packedUpEmployee;
                            count1++;
                            //Array wird immer um ein Element vergrößert
                            Array.Resize(ref allpackedUpEmployee, allpackedUpEmployee.Length + 1);
                        }
                    }
                    //Lieferschein
                    if (i.deliveryNoteEmployee != "")
                    {
                        if (!alldeliveryNoteEmployee.Contains(i.deliveryNoteEmployee))
                        {
                            alldeliveryNoteEmployee[count2] = i.deliveryNoteEmployee;
                            count2++;
                            //Array wird immer um ein Element vergrößert
                            Array.Resize(ref alldeliveryNoteEmployee, alldeliveryNoteEmployee.Length + 1);
                        }
                    }
                    //Kartonetiketten
                    if (i.cardboardLabelsEmployee != "")
                    {
                        if (!allcardboardLabelsEmployee.Contains(i.cardboardLabelsEmployee))
                        {
                            allcardboardLabelsEmployee[count3] = i.cardboardLabelsEmployee;
                            count3++;
                            //Array wird immer um ein Element vergrößert
                            Array.Resize(ref allcardboardLabelsEmployee, allcardboardLabelsEmployee.Length + 1);
                        }
                    }
                    //Paletten Label
                    if (i.palletsEmployee != "")
                    {
                        if (!allpalletsEmployee.Contains(i.palletsEmployee))
                        {
                            allpalletsEmployee[count4] = i.palletsEmployee;
                            count4++;
                            //Array wird immer um ein Element vergrößert
                            Array.Resize(ref allpalletsEmployee, allpalletsEmployee.Length + 1);
                        }
                    }
                    //Lieferschein Innen
                    if (i.deliveryInsideEmployee != "")
                    {
                        if (!alldeliveryInsideEmployee.Contains(i.deliveryInsideEmployee))
                        {
                            alldeliveryInsideEmployee[count5] = i.deliveryInsideEmployee;
                            count5++;
                            //Array wird immer um ein Element vergrößert
                            Array.Resize(ref alldeliveryInsideEmployee, alldeliveryInsideEmployee.Length + 1);
                        }
                    }
                }

                List<MitarbeiterAnsichtCount> employeeList2 = new List<MitarbeiterAnsichtCount>();
                List<MitarbeiterAnsichtCount>[] employeeList3 = new List<MitarbeiterAnsichtCount>[count + count1 + count2 + count3 + count4 + count5 + count6];

                //Mitarbeiter überwachung Zählungen
                //Kommissionierer
                for (int i = 0; i < count; i++)
                {
                    employeeList3[i] = query.Where(x => x.packetListEmployee.Equals(allpacketListEmployee[i])).ToList();
                    //kwList2 wird initialisiert
                    employeeList2.Add(new MitarbeiterAnsichtCount());

                    if (i == count - 1)
                    {
                        break;
                    }
                }
                //Einpacker
                for (int i = count; i < count1 + count; i++)
                {
                    employeeList3[i] = query.Where(x => x.packedUpEmployee.Equals(allpackedUpEmployee[i - count])).ToList();
                    //kwList2 wird initialisiert
                    employeeList2.Add(new MitarbeiterAnsichtCount());

                    if (i == count1)
                    {
                        break;
                    }
                }
                //Lieferschein
                for (int i = count + count1; i < count2 + count1 + count; i++)
                {
                    employeeList3[i] = query.Where(x => x.deliveryNoteEmployee.Equals(alldeliveryNoteEmployee[i - count - count1])).ToList();
                    //kwList2 wird initialisiert
                    employeeList2.Add(new MitarbeiterAnsichtCount());

                    if (i == count2)
                    {
                        break;
                    }
                }
                //Kartonetiketten
                for (int i = count + count1 + count2; i < count3 + count2 + count1 + count; i++)
                {
                    employeeList3[i] = query.Where(x => x.cardboardLabelsEmployee.Equals(allcardboardLabelsEmployee[i - count - count1 - count2])).ToList();
                    //kwList2 wird initialisiert
                    employeeList2.Add(new MitarbeiterAnsichtCount());

                    if (i == count3)
                    {
                        break;
                    }
                }
                //Paletten Label
                for (int i = count + count1 + count2 + count3; i < count4 + count3 + count2 + count1 + count; i++)
                {
                    employeeList3[i] = query.Where(x => x.palletsEmployee.Equals(allpalletsEmployee[i - count - count1 - count2 - count3])).ToList();
                    //kwList2 wird initialisiert
                    employeeList2.Add(new MitarbeiterAnsichtCount());

                    if (i == count4)
                    {
                        break;
                    }
                }
                //Lieferschein Innen
                for (int i = count + count1 + count2 + count3 + count4; i < count5 + count4 + count3 + count2 + count1 + count; i++)
                {
                    employeeList3[i] = query.Where(x => x.deliveryInsideEmployee.Equals(alldeliveryInsideEmployee[i - count - count1 - count2 - count3 - count4])).ToList();
                    //kwList2 wird initialisiert
                    employeeList2.Add(new MitarbeiterAnsichtCount());

                    if (i == count5)
                    {
                        break;
                    }
                }

                //Alle Kommissionierer und Verpacker werden nochmal in den Listen gesamt Summiert
                for (int i = 0; i < employeeList3.Length; i++)
                {
                    if (employeeList3[i] != null)
                    {
                        for (int j = 0; j < employeeList3[i].Count; j++)
                        {
                            //employeeList2[i].reciptCount++;
                            if (i < count)
                            {
                                employeeList2[i].packetListEmployee = employeeList3[i][j].packetListEmployee;
                                employeeList2[i].packetListCount++;
                            }
                            else if (i < count + count1)
                            {
                                employeeList2[i].packedUpEmployee = employeeList3[i][j].packedUpEmployee;
                                employeeList2[i].packedUpCount++;
                            }
                            else if (i < count + count1 + count2)
                            {
                                employeeList2[i].deliveryNoteEmployee = employeeList3[i][j].packedUpEmployee;
                                employeeList2[i].deliveryNoteCount++;
                            }
                            else if (i < count + count1 + count2 + count3)
                            {
                                employeeList2[i].cardboardLabelsEmployee = employeeList3[i][j].packedUpEmployee;
                                employeeList2[i].cardboardLabelsCount++;
                            }
                            else if (i < count + count1 + count2 + count3 + count4)
                            {
                                employeeList2[i].palletsEmployee = employeeList3[i][j].packedUpEmployee;
                                employeeList2[i].palletsCount++;
                            }
                            else if (i < count + count1 + count2 + count3 + count4 + count5)
                            {
                                employeeList2[i].packedUpEmployee = employeeList3[i][j].packedUpEmployee;
                                employeeList2[i].packedUpCount++;
                            }
                        }
                    }
                }

                if (temp.Count > 0)
                {
                    dataGrid.ItemsSource = null;

                    //Die Daten werden an das DataGrid zur Darstellung gesendet
                    dataGrid.ItemsSource = employeeList2.OrderBy(x => x.packedUpEmployee);
                }
                else
                {
                    MessageBox.Show("Es wurden keine Daten gefunden!""Info!", MessageBoxButton.OK, MessageBoxImage.Information);
                }
            }
            else
            {
                MessageBox.Show("Datum Anzeige ist nicht korrekt!""Achtung!", MessageBoxButton.OK, MessageBoxImage.Warning);
            }
        }


So das Ergebnis sieht man im Dateianhang: Mitarbeiterübersicht.

Ich hätte noch zwei Fragen:

Wie könnte ich die Liste noch verändern das die gleichen Namen in einer reihe stehen ???
Vielleicht noch jemand eine Idee den Code kleiner zu halten ????

Danke schon mal
Einloggen, um Attachments anzusehen!
Frühlingsrolle
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2236
Erhaltene Danke: 417

[Win NT] 5.1 x86 6.1 x64
[Delphi] 7 PE, 2006, 10.1 Starter, Lazarus - [C#] VS Exp 2012 - [Android API 15] VS Com 2015, Eclipse, AIDE - [C++] Builder 10.1
BeitragVerfasst: Fr 03.08.18 23:03 
Guten Abend Chocoemilio,

von außen sieht die Anwendung Hui aus, und von innen (Code) Pfui. Der eine oder andere Tippfehler hat sich auch eingeschlichen, wie "Liferant".
Wenn du es besser machen möchtest, mit weniger Code und pflegeleicht, dann lege dir bitte eine Lieferanten/Mitarbeiter-Klasse an, in der der Name, der Bereich/die Tätigkeit, sowie das Datum (von, bis) usw. des Lieferanten/Mitarbeiters enthalten ist.
Damit kannst du, wie gehabt, eine Liste erstellen und dein Vorhaben umsetzen, übersichtlicher und mit weniger Aufwand.

_________________
„Politicians are put there to give you the idea that you have freedom of choice. You don’t. You have no choice. You have owners. They own you. They own everything." (George Denis Patrick Carlin)

Für diesen Beitrag haben gedankt: Chocoemilio
Th69
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Moderator
Beiträge: 3951
Erhaltene Danke: 812

Win7
C++, C# (VS 2015/17)
BeitragVerfasst: Sa 04.08.18 08:39 
Da muß ich Frühlingsrolle recht geben, dein Code ist echt nicht gut (ich befürchte, daß du diesen auch noch für ein Produkt einsetzt - und nicht nur ein privates Projekt).

Zuersteinmal grobe design-technische Mängel:
- da du WPF benutzt, solltest du auch MVVM einsetzen (also ein passendes ViewModel verwenden und mittels eines Command anbinden)
- das Aufbereiten der Daten sollte in einer Logik-Klasse passieren (anscheinend hat euer Projekt keine vernünftige Architektur nach der gängigen 3-Schichten Architektur)!

Und nun noch einige konkrete Tipps zu deinem Code:
- der ganze Code ist viel zu lang für eine Methode (unterteile diese in kleinere Methoden, insbesondere da du immer wieder ähnlichen Code, z.B. bei den Schleifen, verwendest)
- eigene Mitarbeiterklasse
- verwende List<string> anstatt Arrays (string[]) (weiter unten benutzt du diese ja auch - so brauchst du dich um das Vergrößern der Arrays nicht (mehr) zu kümmern)
- die "Aufzählung"-Schleife würde auch per LINQ umsetzbar sein
- die ganzen count-Berechnungen erscheinen mir auch optimierungsbedürftig
- ...

Wenn du den Code in einer eigenen Logik-Klasse untergebracht hast, so kannst du dann auch sehr einfach dafür einen Unit-Test schreiben, der dann die Korrektheit abprüft.

Für diesen Beitrag haben gedankt: Chocoemilio
Chocoemilio Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 36



BeitragVerfasst: Fr 10.08.18 06:53 
Hi

Ja danke, das der Code schlecht ist weiß ich, es musste nur schnell gehen und nach Hilfe gefragt hatte ich ja.
Das Projekt habe ich nicht geschrieben sondern übernommen und die haben kein MVVM verwendet, muss auch mit DataSet arbeiten. Ungewohnt auch für mich.
Alles umschreiben da fehlt die Zeit, würde lieber mit der Entity Frameworke arbeiten.
Ich möchte den Code auf jeden Fall noch verbessern.

Werde das beherzigen und danach melde ich mich nochmal.

Danke
Chocoemilio Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 36



BeitragVerfasst: Fr 10.08.18 11:34 
Hey


So habe den code jetzt verkleinert aber jetzt bin ich wieder an meinem Problem. Das Gruppieren mit Linq ????

Ein Name kann in jeder spalte vorhanden sein und diese sollen gruppiert werden, so wie die Anzahl der Zählung.
Alle gleichen Namen sollen in einer Zeile stehen.

ausblenden C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
List<MitarbeiterLieferant> query1 = (from t in employeeList2
                                                     group t by new {t.packetListEmployee, t.packedUpEmployee, t.deliveryNoteEmployee, t.cardboardLabelsEmployee,
                                                     t.palletsEmployee, t.deliveryInsideEmployee} into g
                                                    select new MitarbeiterLieferant
                                                    (
                                                        g.Key.packetListEmployee,
                                                        g.Key.packedUpEmployee,
                                                        g.Key.deliveryNoteEmployee,
                                                        g.Key.cardboardLabelsEmployee,
                                                        g.Key.palletsEmployee,
                                                        g.Key.deliveryInsideEmployee
                                                    )).ToList();


Weiter komme ich nicht und habe auch keine Ahnung wie ???
Chocoemilio Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 36



BeitragVerfasst: Mo 13.08.18 11:32 
Hi

Habe das jetzt so gelöst, der Alte Quellcode ist weg und dafür habe ich eine Stored-Procedure geschrieben.
Wollte das eigentlich mit linq machen. Mache ich auch noch :-)

ausblenden volle Höhe SQL-Anweisung
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
SELECT 
      `name`,
      (SELECT 
              COUNT(packet_list)
          FROM
              Otto.OttoTool_Control oc
          WHERE
              u.`name` = oc.`packet_list`
                  AND packetDate BETWEEN date_from AND date_to) packet_list,
      (SELECT 
              COUNT(packing)
          FROM
              Otto.OttoTool_Control oc
          WHERE
              u.`name` = oc.`packing`
                  AND packingDate BETWEEN date_from AND date_to) packing,
      (SELECT 
              COUNT(delivery_note)
          FROM
              Otto.OttoTool_Control oc
          WHERE
              u.`name` = oc.`delivery_note`
                  AND deliveryNoteDate BETWEEN date_from AND date_to) delivery_note,
      (SELECT 
              COUNT(cardboard_labels)
          FROM
              Otto.OttoTool_Control oc
          WHERE
              u.`name` = oc.`cardboard_labels`
                  AND cardbordLabelsDate BETWEEN date_from AND date_to) cardboard_labels,
      (SELECT 
              COUNT(pallets)
          FROM
              Otto.OttoTool_Control oc
          WHERE
              u.`name` = oc.`pallets`
                  AND palletsDate BETWEEN date_from AND date_to) pallets,
      (SELECT 
              COUNT(delivery_inside)
          FROM
              Otto.OttoTool_Control oc
          WHERE
              u.`name` = oc.`delivery_inside`
                  AND deliveryInsideDate BETWEEN date_from AND date_to) delivery_inside
  FROM
      AzManager.Users u
          LEFT JOIN
      Otto.OttoTool_Control oc ON oc.packet_list = u.name
  WHERE
      (allow_fbatool_packing = 'Y'
          OR allow_fbatool_printing = 'Y'
          OR allow_fbatool_labeling = 'Y')
  GROUP BY u.name
  ORDER BY u.`name`;


Moderiert von user profile iconTh69: C#- durch SQL-Tags ersetzt