def get_rechnung(rechnungsnr):
"""Liefert ein Tupel aus Rechnungskopf und den Positionen"""
if str(rechnungsnr).startswith('RG'):
rechnungsnr = str(rechnungsnr)[2:]
kopf = get_connection().query(['AFK00'],
condition="FKRGNR = %s" % sql_escape(rechnungsnr))
if len(kopf) < 1:
raise RuntimeError('inkonsistente Kopfdaten in AFK00: %r' % kopf)
if len(kopf) > 1:
print 'warning: inkonsistente Kopfdaten in AFK00: FKRGNR = %s' % rechnungsnr
print kopf
kopf = kopf[0]
# TODO: der code schient nciht zu klappen, wenn gar keine Auftragstexte vorhanden sind.
postmp = get_connection().query(['AFU00', 'AAT00'],
condition="FURGNR=%s AND FUAUFN=ATAUFN AND FUAUPO=ATAUPO AND ATTART=8" % sql_escape(rechnungsnr))
# wenn eine Rechnungsposition mehr als einen Rechnungstext hat, ist sie jetzt mehrfach in positionen
# dedupen und spezial felder auseinanderklamuesern
positionen = {}
texte = {}
for line in postmp:
positionen.setdefault(line['auftragsposition'], {}).update(line)
text = line['text'].strip()
if not text.startswith('#:'):
texte.setdefault(line['auftragsposition'], []).append(line['text'])
if text.startswith('#:guid:'):
positionen[line['auftragsposition']]['guid'] = text[7:]
for posnr, textlines in texte.items():
positionen[posnr]['text'] = ' '.join(textlines)
return kopf, positionen.values()
def kbpos2artnr_zugangslager(komminr, posnr):
"""Gibt die Artikelnummer und das ZUGANGS-Lager zu einer bestimmten Position eines Kommissionierbelegs zurück."""
warnings.warn("husoftm.lieferscheine is deprecated, use husoftm2.lieferscheine instead",
DeprecationWarning, stacklevel=2)
# Read auftragsnr_kunde
rows = get_connection().query('ALN00', fields=['LNARTN', 'LNAUFN'],
condition="LNKBNR=%d AND LNBELP=%d" % (int(komminr), int(posnr)))
artnr, auftragsnr = rows[0]['artnr'], rows[0]['auftragsnr']
rows = get_connection().query('AAK00', condition="AKAUFN='%d'" % int(auftragsnr))
return artnr, rows[0]["zugangslager"]
def get_bestellung(bestellnr):
"""Liefert alle Positionen zu einer bestellnr.
>>> bestellungen(43123)
[{kopfdaten},
[{'artnr': u'64114',
'bestellmenge': 300,
'bestellnr': 43042,
'created_by': 62,
'dateifuehrungsschluessel': u'',
'geliefert_kz': 0,
'gelieferte_menge': 0,
'lager': 16,
'liefer_date': datetime.date(2009, 12, 24),
'lieferant': u'90088',
'menge_offen': 300,
'position': 11,
'status': u'',
'streckengeschaeft': 0,
'termin1_date': datetime.date(2009, 12, 24),
'termin2_date': datetime.date(2009, 12, 24),
'updated_by': 62,
'wunsch2_date': datetime.date(2009, 12, 24),
'wunsch_date': None,
'zugang_date': None},
...]
]
"""
kopf = get_connection('bestellungen.get_bestellung').query('EBL00', ordering=['BLBSTN DESC'],
condition="BLSTAT<>'X' AND BLBSTN=%s" % sql_escape(bestellnr))
if len(kopf) != 1:
raise RuntimeError('inkonsistente Kopfdaten in EBL00')
kopf = kursfaktorkorrektur(kopf)[0]
# leer? WTF?
# print get_connection().query('ESL00', condition="SLBSTN=%s" % sql_escape(ponr))
# BZT00 - zusatztexte
# positionen = get_connection().query(['EBP00', 'EWZ00'], ordering=['BPBSTN DESC', 'BPDTLT'],
# condition="WZBSTN=BPBSTN AND WZBSTP=BPBSTP AND BPSTAT<>'X' AND BPBSTN=%s" % sql_escape(ponr))
positionen = get_connection().query(['EBP00'], ordering=['BPBSTN DESC', 'BPDTLT'],
condition="BPSTAT<>'X' AND BPBSTN=%s" % sql_escape(bestellnr))
# detailierte Informationen über den Zugang gibts in EWZ00
# AND BPKZAK=0 to get only the open ones
# Buchungsdaten: SELECT * FROM SMKDIFP/BBU00 WHERE BUBELN = 900003977
# Lagerveraenderung: SELECT * FROM SMKDIFP/XLB00 WHERE LBBSTN = '43072'
# ?: SELECT * FROM EWZ00 WHERE WZBSTN = 43072
return kopf, positionen
def get_auftrag(auftragsnr):
"""Auftrag mit Auftragsnummer auftragsnr ermitteln"""
warnings.warn("husoftm.auftraege is deprecated, use husoftm2.auftraege instead",
DeprecationWarning, stacklevel=2)
rows = get_connection().query('AAK00',
condition="AKSTAT<>'X' AND AKAUFN=%s" % sql_escape(auftragsnr))
if len(rows) != 1:
raise RuntimeError('inkonsistente Kopfdaten in AAK00 für Auftragsnr %s' % auftragsnr)
kopf = rows[0]
positionen = get_connection().query(['AAP00'], ordering=['APAUFN DESC', 'APDTLT'],
condition="APSTAT<>'X' AND APAUFN=%s" % sql_escape(auftragsnr))
return kopf, positionen
def bestellungen():
"""Liefert eine liste mit allen bestellten aber nicht stornierten Wareneingängen.
>>> bestellungen()
[{'artnr': u'64114',
'bestellmenge': 300,
'bestellnr': 43042,
'created_by': 62,
'dateifuehrungsschluessel': u'',
'geliefert_kz': 0,
'gelieferte_menge': 0,
'lager': 16,
'liefer_date': datetime.date(2009, 12, 24),
'lieferant': u'90088',
'menge_offen': 300,
'position': 11,
'status': u'',
'streckengeschaeft': 0,
'termin1_date': datetime.date(2009, 12, 24),
'termin2_date': datetime.date(2009, 12, 24),
'updated_by': 62,
'wunsch2_date': datetime.date(2009, 12, 24),
'wunsch_date': None,
'zugang_date': None},
...]
"""
warnings.warn("misc.bestellungen() is deprecated use module bestellungen instead", DeprecationWarning, stacklevel=2)
# detailierte Informationen gibts in EWZ00
rows = get_connection().query("EBP00", ordering=["BPBSTN DESC", "BPDTLT"], condition="BPSTAT<>'X'")
# AND BPKZAK=0 to get only the open ones
return rows
def komponentenaufloesung(mengenliste):
"""Löst Artikel in ihre Komponenten auf.
>>> komponentenaufloesung([(5, '00049'), (4, '00537')])
[(5, u'A42438'), (5, u'A42439'), (5, u'A42440'), (10, u'A42441'), (4, u'42050/A'), (12, u'42051/A'), (4, u'42052/A')]
>>> komponentenaufloesung([(2, '00001')])
[(2, '00001')]
Achtung: Diese Funktion implementiert mehrere Tage caching
"""
ret = []
for menge, artnr in mengenliste:
# check if we have a cached result
memc = caching.get_cache()
rows = memc.get('husoftm.komponentencache.%r' % (artnr))
if rows == None: # empty lists are cached too, so check against None here
rows = get_connection().query(['ASK00'], fields=['SKLFNR', 'SKKART', 'SKMENG'],
condition="SKARTN='%s'" % artnr)
memc.set('husoftm.komponentencache.%r' % (artnr), rows, 60 * 60 * 72) # 4 d
if not rows:
# kein Setartikel
ret.append((menge, artnr))
else:
for row in rows:
ret.append((menge * row['menge_im_set'], row['komponenten_artnr']))
return ret
def name(sachbearbeiternr):
"""Returns the name"""
rows = get_connection().query('XSB00', fields=['SBNAME'], condition="SBSBNR = %s" % sql_quote(sachbearbeiternr))
if len(rows) == 0:
raise ValueError("Kein Sachbearbeiter mit Nummer %s" % sachbearbeiternr)
return rows[0][0]
def kbpos2artnr_lager(komminr, posnr):
"""Gibt die Artikelnummer und das Abgangs-Lager zu einer bestimmten Position eines Kommissionierbelegs zurück."""
warnings.warn("husoftm.lieferscheine is deprecated, use husoftm2.lieferscheine instead",
DeprecationWarning, stacklevel=2)
rows = get_connection().query('ALN00', fields=['LNARTN', 'LNLGNR'],
condition="LNKBNR=%d AND LNBELP=%d" % (int(komminr), int(posnr)))
return rows[0]['artnr'], rows[0]['lager']
def get_offene_auftraege(lager=100):
"""Liefert eine Liste offener Aufträge OHNE UMLAGERUNGEN.
Ported to connection2 from MoftS.lib.mofts.client.as400.py to be used in logistik/versandauslastung
"""
# TODO: merge w/ auftragsmengen_alle_artikel()
mappings = {
'APARTN': 'artnr',
# das kann bei ueberlieferungen zu negativen werten fuehren
# und ist bei auftraegen mit mengenaenderungen gelegentlich 0 - siehe Case 227:
'APMNG-APMNGF-APMNGG': 'menge',
'APMNG': 'bestellmenge',
'AKKDNR': 'kundennummer',
'AKAUFN': 'auftragsnummer',
'APDTLT': 'liefer_date',
'AKAUFA': 'art'}
fields = mappings.keys()
condition = "AKAUFN=APAUFN AND APKZVA=0 AND AKKZVA=0 AND AKAUFA<>'U' AND AKSTAT<>'X' AND APSTAT<>'X' AND APLGNR=%s" % lager
rows = get_connection().query(['AAP00', 'AAK00'],
fields=fields,
condition=condition,
ordering='APDTLT',
#grouping=['APARTN', 'APDTLT'], # das funktioniert nicht
querymappings=mappings)
return rows
def abgabepreisbasis(artnr):
"""Gibt eine Liste mit den durchschnittlichen Rechnungspreisen pro Monat zurück.
Liefert eine Liste von 4-Tuples
(datum, AVG(preis), menge, gesammtpreis)
[ ...
(datetime.date(2009, 2, 10), 32.95, 2, 65.90),
(datetime.date(2009, 10, 19), 17.44, 2, 34.88)]
"""
condition = (
"FKRGNR=FURGNR" # JOIN
" AND FKAUFA<>'U'" # Keine Umlagerung
" AND FKSTAT<>'X'" # nicht gelöscht
" AND FKDTFA > 0" # Druckdatum nicht leer
" AND FUKZRV=2" # ?
" AND FURGNI<>0" # ?
" AND FKFORM=' '" # ?
" AND FURGNR<>0" # es gibt eine Rechnungsnummer
" AND FUPNET>0" # keine Gutschriften
" AND FKMJBU>'10412'" # keine legacy Daten
" AND FUARTN=%s") # nur bestimmten Artikel beachten
rows = get_connection().query(['AFU00', 'AFK00'], fields=['FKDTFA', 'SUM(FUMNG)', 'SUM(FUPNET)', 'COUNT(FKRGNR)'],
condition=condition % (sql_quote(artnr)),
ordering='FKDTFA', grouping='FKDTFA',
querymappings={'SUM(FUMNG)': 'menge', 'SUM(FUPNET)': 'nettopreis', 'COUNT(FKRGNR)': 'rechnungen', 'FKDTFA': 'rechnung_date'})
ret = []
for row in rows:
menge = as400_2_int(row['menge'])
if menge:
ret.append((row['rechnung_date'], float(row['nettopreis']) / float(row['menge']), menge, float(row['nettopreis'])))
ret.sort()
return ret
def get_lieferscheinnrs_for_lager(lager):
"Liefert eine Liste mit allen nicht voll ausgelieferten Lieferscheinnummern für ein Lager."""
warnings.warn("husoftm.lieferscheine is deprecated, use husoftm2.lieferscheine instead",
DeprecationWarning, stacklevel=2)
rows = get_connection().query("ALK00", fields=["LKLFSN"],
condition="LKLGNR=%r AND LKLFSN>0 AND LKKZVA=0 AND LKSTAT <> 'X'" % lager)
return sorted(set((int(row[0]) for row in rows)))
def auftragsmengen(artnr, lager=None):
"""Liefert eine Liste offener Aufträge für einen Artikel OHNE UMLAGERUNGEN.
>>> auftragsmengen(14865)
{datetime.date(2009, 3, 2): 340,
datetime.date(2009, 4, 1): 300,
datetime.date(2009, 5, 4): 260,
datetime.date(2009, 6, 2): 300}
"""
condition = (
"AKAUFN=APAUFN"
" AND AKAUFA<>'U'" # kein Umlagerungsauftrag
" AND APARTN=%s" # Artikelnummer
" AND APSTAT<>'X'" # Position nicht logisch gelöscht
" AND APKZVA=0" # Position nicht als 'voll ausgeliefert' markiert
" AND (APMNG-APMNGF) > 0" # (noch) zu liefernde menge ist positiv
" AND AKSTAT<>'X'" # Auftrag nicht logisch gelöscht
" AND AKKZVA=0") # Auftrag nicht als 'voll ausgeliefert' markiert
if lager:
# Achtung, hier gibt es KEIN Lager 0 in der Tabelle. D.h. APLGNR=0 gibt nix
condition = condition + (" AND APLGNR=%d" % lager)
rows = get_connection().query(['AAP00', 'AAK00'], fields=['APDTLT', 'SUM(APMNG-APMNGF)'],
condition=condition % (sql_quote(artnr)),
ordering='APDTLT', grouping='APDTLT',
querymappings={'SUM(APMNG-APMNGF)': 'menge_offen', 'APDTLT': 'liefer_date'})
return dict([(x['liefer_date'], as400_2_int(x['menge_offen'])) for x in rows if x['menge_offen'] > 0])
def get_artikel(artnr=None, ean=None):
"""Returns articles for artnr and/or ean, depending on what parameter is not None.
Use both parameters if ean is not unique, like in the following example.
This function can be used to check if an EAN and article number fit to each other.
Non-unique example:
>>> a = get_artikel(artnr='76095')
>>> b = get_artikel(artnr=None, ean=a.ean)
RuntimeError: Ergebnis nicht eindeutig für: Artnr None && EAN 4005998760956L"""
cond1 = "ARARTN=%s" % sql_quote(artnr)
cond2 = "AREAN=%s" % sql_quote(ean)
if artnr and ean:
condition = cond1 + " AND " + cond2
elif artnr:
condition = cond1
elif ean:
condition = cond2
else:
raise RuntimeError("Artikelabfrage ohne EAN und Artnr nicht möglich.")
rows = get_connection().query(['XAR00'], condition=condition)
rowcount = len(rows)
if rowcount > 1:
raise RuntimeError("Ergebnis nicht eindeutig für: Artnr %r && EAN %r" % (artnr, ean))
elif rowcount == 0:
return None
return Artikel().fill_from_softm(rows[0])
def auftraege(mindate=None, maxdate=None, additional_conditions=None, limit=None):
"""
Alle Aufträge ermitteln
additional_conditions kann SQL-Bedingungen enthalten, die
die Auftragssuche einschränken.
TODO: Wenn Datum in additional_conditions, dann Datumsfelder überprüfen und ggf. konvertieren
"""
warnings.warn("husoftm.auftraege is deprecated, use husoftm2.auftraege instead",
DeprecationWarning, stacklevel=2)
conditions = ["AKSTAT<>'X'"]
if mindate and maxdate:
conditions.append("AKDTER BETWEEN %s AND %s" % (date2softm(mindate), date2softm(maxdate)))
elif mindate:
conditions.append("AKDTER > %s" % date2softm(mindate))
elif maxdate:
conditions.append("AKDTER < %s" % date2softm(maxdate))
# You should REALLY know what you are doing!
if additional_conditions:
conditions.extend(additional_conditions)
condition = " AND ".join(conditions)
rows = get_connection().query('AAK00', ordering=['AKAUFN DESC', 'AKDTLT'], condition=condition, limit=limit)
return rows
def verkaufspreis(artnr, kundennr, bestelldatum=datetime.date.today()):
"""
Verkaufspreis in Abh. von kundennr und artnr ermitteln.
Höchste Priorität hat der für einen Kunden hinterlegt Preis.
Zweithöchste Prio hat der für die Preisliste (Kundengruppe) hinterlegte Preis
Niedrigste Prio hat der Listenpreis aus den Artikelstammdaten.
Rückgabe ist ein dict mit Preis und Herkunft des Preises.
>>> verkaufspreis('04711', 99954)
{'preis': Decimal('14.00'), 'herkunft': 'Preisliste 95'}
>>> verkaufspreis('04711', 98000)
{'preis': Decimal('13.65'), 'herkunft': 'Listenpreis'}
>>> verkaufspreis('04711', 94763)
{'preis': Decimal('13.00'), 'herkunft': 'Kundenpreis'}
"""
# Kundennr als Zeichenkette
kundennr_str = sql_quote("%8s" % int(kundennr))
date_str = sql_quote(date2softm(bestelldatum))
artnr_str = sql_quote(artnr)
# 1. Preis für Kunde hinterlegt?
condition = ("PNSANR=PRSANR and PRANW='A' and PRSTAT=' ' and PNSTAT=' ' AND "
"PRARTN = %s and PRDTBI >= %s AND PRDTVO <= %s" % (artnr_str, date_str, date_str))
condition_kunde = condition + " AND PRKDNR = %s" % kundennr_str
rows = get_connection().query(['XPN00', 'XPR00'], fields=["PNPRB"], ordering='PRDTVO', condition=condition_kunde)
if rows:
return dict(preis=rows[0][0], herkunft='Kundenpreis')
# 2. Preis aus Preislistennr. des Kunden ermitteln
kdgruppe = get_connection().query('XXA00', fields='XAKGRP', condition='XAKDNR = %s' % kundennr_str)
if kdgruppe and kdgruppe[0][0]:
kdgruppe = kdgruppe[0][0]
condition_gruppe = condition + " AND PRPRLK = %s" % sql_quote(kdgruppe)
rows = get_connection().query(['XPN00', 'XPR00'], ordering='PRDTVO', condition=condition_gruppe)
if rows:
return dict(preis=rows[0]['preis'], herkunft='Preisliste %s' % kdgruppe)
# 3. Listenpreis aus Artikelstammdaten
return dict(preis=preis(artnr), herkunft='Listenpreis')
def get_zugaenge_warenvereinnahmungsnr_simple(bestellnr, warenvereinnahmungsnr):
"""Liefert alle Warenzugaenge zu einer Bestellnummer und zug. Warenvereinnahmungsnummer.
Sammelt *nicht* alle Daten zu einer Bestellung, sondern nur die jeweils gelieferten Positionen.
"""
rows = get_connection().query('EWZ00', condition="WZBSTN=%s and WZWVNR=%s" %
(sql_quote(bestellnr), sql_quote(warenvereinnahmungsnr)))
return rows
def _umlagermenge_helper(artnr, lager=100):
""" Ermittelt wieviel Umlagerungen für einen oder alle Artikel unterwegs sind.
Parmeter:
- artnr - 0 oder None -> alle Artikel, die sich in der Umlagerung befinden auflisten,
sonst die gesuchte Artikelnummer
- lager - Das Lager, an das die Umlagerungen unterwegs sind (default 100)
Rueckgabe:
- Wenn eine Artikelnummer angegeben wird, dann eine Menge als int
- Wenn keine Artikelnummer angegeben wird, dann alle Artikeln die sich
zu dem gegebenen Zugangslager (lager) unterwegs sind.
"""
# This is just a private helper funcion, which should only be called by umlagermenge and
# umlagermengen. The reason therefore is, that this function has different return types, depending
# on the artnr you provide. umlagermenge and umlagermengen are wrappers around this function.
# Das Auslieferungslager steht in AKLGN1, Das Ziellager steht in AKLGN2
# In APLGNR steht AUCH das Abgangslager
tables = ['AAP00', 'AAK00']
condition = (
"AKAUFN=APAUFN"
" AND AKAUFA='U'" # Umlagerungsauftrag
" AND APSTAT<>'X'" # Position nicht logisch gelöscht
" AND APKZVA=0" # Position nicht als 'voll ausgeliefert' markiert
#" AND (APMNG-APMNGF-APMNGG) > 0" # (noch) zu liefernde menge ist positiv
" AND AKSTAT<>'X'" # Auftrag nicht logisch gelöscht
" AND AKKZVA=0") # Auftrag nicht als 'voll ausgeliefert' markiert
fields = ['SUM(APMNG)']
grouping = []
if lager:
# Zugangslager
condition += " AND AKLGN2=%d" % int(lager)
if artnr:
# Artikelnummer
condition += " AND APARTN=%s" % sql_quote(artnr)
else:
fields.insert(0, 'APARTN')
grouping = ['APARTN']
rows = get_connection().query(tables=tables, fields=fields, querymappings={}, condition=condition,
grouping=grouping)
if not artnr:
# Wenn kein bestimmter Artikel abgefragt wird, dann das Abfrageergebnis in ein dict umwandeln
ret = {}
for artnr, menge in rows:
ret[artnr] = as400_2_int(menge)
return ret
else:
if rows and rows[0] and rows[0][0]:
return as400_2_int(rows[0][0])
return 0
def auftraege_for_kunde(kundennr, limit=None):
"""Alle Aufträge für eine Kundennummer ermitteln"""
warnings.warn("husoftm.auftraege is deprecated, use husoftm2.auftraege instead",
DeprecationWarning, stacklevel=2)
condition = "AKKDNR = %s" % sql_quote(pad('AKKDNR', kundennr))
rows = get_connection().query('AAK00', ordering=['AKAUFN DESC', 'AKDTLT'],
condition=condition, limit=limit)
return rows
def auftragsnr_to_rechnungsnr(auftragsnr):
"""Liefert eine Liste mit Rechnungsnummern zurück, die zu einer Auftragsnummer gehören.
Die Nummern werden gemäss https://cybernetics.hudora.biz/intern/trac/wiki/NummernKreise
mit dem Prefix RG zurückgegeben."""
rows = get_connection().query(['AFK00'], fields=['FKRGNR'],
condition="FKAUFN = %s" % (sql_quote(auftragsnr)))
return [("RG%s" % r[0]) for r in rows]
def kommibelege_for_auftrag(auftragsnr):
"""Return all Kommibeleg objects for a given auftragsnr"""
warnings.warn("husoftm.lieferscheine is deprecated, use husoftm2.lieferscheine instead",
DeprecationWarning, stacklevel=2)
conditions = ["LKAUFS = %s" % sql_quote(auftragsnr), "LKLFSN = 0"]
condition = " AND ".join(conditions)
rows = get_connection().query(["ALK00"], condition=condition)
return [Kommibeleg(row['kommissionierbelegnr']) for row in rows]
def alle_lieferanten():
"""Gibt alle Lieferantennummer zurück.
>>> alle_lieferanten() #doctest: +ELLIPSIS
['40000', '50000', '50001', ... '99999']
"""
rows = get_connection().query(['XXA00'], fields=['XALINR'], condition=("XASTAT=' ' and XALINR<>''"))
return sorted([x[0] for x in rows])
def auftraege_for_artnr(artnr, additional_conditions=None, limit=None):
"""Alle Aufträge zu einer Artikelnummer"""
warnings.warn("husoftm.auftraege is deprecated, use husoftm2.auftraege instead",
DeprecationWarning, stacklevel=2)
conditions = ['AAK00.AKAUFN = ALN00.LNAUFN', 'ALN00.LNARTN=%s' % sql_quote(artnr)]
if additional_conditions:
conditions.extend(additional_conditions)
condition = " AND ".join(conditions)
rows = get_connection().query(['AAK00', 'ALN00'], condition=condition,
ordering=['AKAUFN DESC', 'AKDTLT'], limit=limit)
return rows
def get_auftragnr(guid):
"""
Gibt die Auftragsnr zu einem GUID zurück, sofern vorhanden.
"""
warnings.warn("husoftm.auftraege is deprecated, use husoftm2.auftraege instead",
DeprecationWarning, stacklevel=2)
condition = "ATTX60 = %s AND ATAUPO = 0 AND ATTART = 8" % sql_quote("#:guid:" + guid)
rows = get_connection().query('AAT00', fields=['ATAUFN'], condition=condition)
if rows:
return rows[0][0]
return None
def get_guid(auftragsnr):
"""
Gibt den GUID zu einer Auftragsnr zurück, sofern vorhanden.
"""
warnings.warn("husoftm.auftraege is deprecated, use husoftm2.auftraege instead",
DeprecationWarning, stacklevel=2)
condition = "ATTX60 LIKE %s AND ATAUFN = %s AND ATAUPO = 0 AND ATTART = 8" % (sql_quote("#:guid:%%"),
sql_quote(auftragsnr))
rows = get_connection().query('AAT00', fields=['ATTX60'], condition=condition)
if rows:
return rows[0][0].replace('#:guid:', '')
return ''
def get_bestellungen_artnr(artnr):
"""Liefert alle Warenzugaenge einer Artikelnummer."""
# BZT00 - zusatztexte
positionen = get_connection('bestellungen.get_bestellungen_artnr').query(['EBP00', 'EBL00'], ordering=['BPDTLT'],
condition="BLBSTN=BPBSTN AND BLSTAT<>'X' AND BPSTAT<>'X' AND BPARTN=%s" % sql_quote(artnr))
ret = []
for position in positionen:
position['_zugaenge'] = [x for x in get_zugaenge_bestellnr(position['bestellnr'])
if x['artnr'] == artnr]
for zugang in position['_zugaenge']:
# Buchungsdaten
buchungen = get_connection().query('BBU00',
condition='BUBELN=%s' % sql_escape(zugang['rechnungsnr']))
zugang['_fibubuchungen'] = kursfaktorkorrektur(buchungen, umdrehen=False)
position['_lager_stapelschnittstelle'] = get_connection().query(
'ESL00', condition="SLBSTN=%s AND SLBSTP=%s AND SLARTN=%s"
% (sql_escape(position['bestellnr']), sql_escape(position['bestellpos']), sql_escape(artnr)))
ret.append(position)
# ?: SELECT * FROM EWZ00 WHERE WZBSTN = 43072
return kursfaktorkorrektur(ret)
def buchdurchschnittspreis(artnr):
"""Gibt den (aktuellen) Buchdurchschnittspreis für einen Artikel zurück.
>>> buchdurchschnittspreis('04711')
13.65
"""
rows = get_connection().query('XLF00', fields=['LFPRBD'],
condition="LFLGNR=0 AND LFARTN=%s AND LFSTAT<>'X'" % sql_quote(artnr))
if rows:
return _auf_zwei_stellen(rows[0][0])
else:
return Decimal()
def _get_zugaenge_helper(rows):
"""Sammelt daten zu einer Bestellung aus verschiedenen Tabellen."""
rows = kursfaktorkorrektur(rows, 'kurs_zugang', 'kursfaktor_zugang')
ret = []
for row in rows:
lagerbuchungen = []
if row['lagerbewegung_rechnung']:
buchung = get_connection('_get_zugaenge_helper').query('XLB00',
condition="LBSANR=%s" % sql_escape(row['lagerbewegung_rechnung']))
if len(buchung) > 1:
raise RuntimeError('mehr als einen XLB Satz zu einem EWZ Satz: %r' % buchung)
buchung = kursfaktorkorrektur(buchung)[0]
lagerbuchungen.append(buchung)
if row['lagerbewegung_zugang'] and row['lagerbewegung_zugang'] != row['lagerbewegung_rechnung']:
buchung = get_connection('_get_zugaenge_helper').query('XLB00',
condition="LBSANR=%s" % sql_escape(row['lagerbewegung_zugang']))
if len(buchung) > 1:
raise RuntimeError('mehr als einen XLB Satz zu einem EWZ Satz: %r' % buchung)
lagerbuchungen.append(kursfaktorkorrektur(buchung)[0])
row['_lagerbuchungen'] = lagerbuchungen
ret.append(row)
return ret
def preis(artnr):
"""Gibt den (aktuellen) Listenpreis für einen Artikel zurück.
>>> preis('04711')
13.65
"""
rows = get_connection().query('XAR00', fields=['ARPREV'],
condition="ARARTN=%s AND ARSTAT<>'X'" % sql_quote(artnr))
if rows:
return _auf_zwei_stellen(rows[0][0])
else:
return 0
def name(lieferantennr):
"""Liefert den Namen zu einer Lieferantennummer zurück.
>>> name('99999')
'Blocklieferant'
"""
assert isinstance(lieferantennr, basestring)
rows = get_connection().query(['XXA00'],
condition=("XASTAT=' ' and XALINR LIKE %s" % sql_quote('%%%s' % lieferantennr)))
if rows:
return rows[0]['name1']
return None
def buchbestand(artnr, lager=0):
"""Gibt den Buchbestand eines Artikels für ein Lager zurück oder (lager=0) für alle Lager
>>> buchbestand('14600')
2345
"""
rows = get_connection().query('XLF00', fields=['LFMGLP'],
condition="LFLGNR=%d AND LFARTN=%s AND LFMGLP<>0 AND LFSTAT<>'X'" % (int(lager),
sql_quote(artnr)))
if rows:
return as400_2_int(rows[0][0])
return 0
