1318 lines
48 KiB
C#
1318 lines
48 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Data.SqlClient;
|
|
using De.Lambertz.Portal;
|
|
using System.Security.Principal;
|
|
using De.Lambertz.Tools;
|
|
using System.Data;
|
|
using System.Windows.Forms;
|
|
using System.Reflection;
|
|
|
|
namespace De.Lambertz.ODAL
|
|
{
|
|
/// <summary>
|
|
/// Alle Userabhängigen Informationen werden hie in einem Singelton zur Verfügung gehalten
|
|
/// </summary>
|
|
public class UserSingelton : ISingelton
|
|
{
|
|
private static UserSingelton me = null; //Singelton
|
|
//
|
|
private ODALUser angemeldeterUser = null; //Userinfo des angemeldeten Users
|
|
private Dictionary<int, ODALBereich> bereiche; //Alle Bereiche die dem User zugeordnet sind
|
|
private Dictionary<int, ODALBereich> alleBereiche = null; //Alle Bereiche
|
|
private List<ODALBereich> altBereiche = null;
|
|
private StringBuilder bereichsSQL; //Vorab aufbereitet Bereiche für SQL-Abfragen
|
|
private Dictionary<int, ODALUser> alleUser; //Liste aller User
|
|
private Dictionary<int, ODALUser> alleGesperrtenUser; //Liste aller gesperrten User
|
|
private ODALIni parameter = null; //Parameter des angemeldeten Users
|
|
private List<int> vertretungen = null; //Usernummern die der Angemeldetet Uservertritt
|
|
private Dictionary<int, List<int>> userFirmen = null;
|
|
//
|
|
//NEUE FREIGABE MECHANISMEN:
|
|
private Dictionary<int, FachBereich> fachBereiche = null; // Alle fachbereiche der neuen Bereichslogik
|
|
private String fachBereichsSQL; //Eigene Fachbereiche und FB durch Vertretungen
|
|
//
|
|
static readonly object padlock0 = new object(); //Threadsafe!!
|
|
static readonly object padlock1 = new object(); //Threadsafe!!
|
|
|
|
private UserSingelton(string userName)
|
|
{
|
|
//Der aktuell angemeldete User
|
|
angemeldeterUser = new ODALUser();
|
|
this.angemeldeterUser.Login = userName;
|
|
this.alleUser = new Dictionary<int, ODALUser>();
|
|
this.alleGesperrtenUser = new Dictionary<int, ODALUser>();
|
|
// LADEN mit nur einer Connection die später nicht mehr benötigt wird und daher nicht als Member im Singelton gehalten wird!
|
|
if (this.userInfoLaden())
|
|
{
|
|
parameter = new ODALIni();
|
|
|
|
this.vertretungen = new List<int>();
|
|
this.vertretungen.Add(angemeldeterUser.UserID);
|
|
this.ladenVertreterKette(angemeldeterUser.UserID);
|
|
|
|
this.bereiche = new Dictionary<int, ODALBereich>();
|
|
this.bereichsSQL = new StringBuilder();
|
|
this.bereicheLaden();
|
|
|
|
//NEUE Bereichslogik
|
|
this.alleFachbereicheLaden();
|
|
|
|
this.alleUserFirmenZuordnungenLaden();
|
|
|
|
this.userEintragen();
|
|
}
|
|
else
|
|
{
|
|
// BAUSTELLE noch nicht klar was hier passieren soll .. jedenfalls
|
|
// konnte der User nicht gefunden werden!
|
|
}
|
|
//
|
|
////s.returnConnection();
|
|
// LADEN Ende und abmelden der Connection
|
|
}
|
|
|
|
private void alleUserFirmenZuordnungenLaden()
|
|
{
|
|
this.userFirmen = new Dictionary<int, List<int>>();
|
|
|
|
using (SqlConnection con = new SqlConnection(DBTools.ConnectionStringODAL()))
|
|
{
|
|
con.Open();
|
|
String sql = "select UserNr, FirmenNr from ODAL.AnwenderFirmen";
|
|
SqlCommand cmd = new SqlCommand(sql, con);
|
|
using(SqlDataReader reader = cmd.ExecuteReader())
|
|
{
|
|
while (reader.Read())
|
|
{
|
|
List<int> firmenListe = null;
|
|
if (userFirmen.ContainsKey(reader.GetInt32(0)))
|
|
{
|
|
firmenListe = userFirmen[reader.GetInt32(0)];
|
|
}
|
|
else
|
|
{
|
|
firmenListe = new List<int>();
|
|
userFirmen.Add(reader.GetInt32(0), firmenListe);
|
|
}
|
|
if (!firmenListe.Contains(reader.GetInt32(1)))
|
|
{
|
|
firmenListe.Add(reader.GetInt32(1));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<int> GetFirmenListeFürUser(int userNr)
|
|
{
|
|
List<int> result = null;
|
|
if (userFirmen.ContainsKey(userNr))
|
|
{
|
|
result = userFirmen[userNr];
|
|
}
|
|
else
|
|
{
|
|
result = new List<int>();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public Dictionary<int, FachBereich> FachBereiche
|
|
{
|
|
get { return fachBereiche; }
|
|
set { fachBereiche = value; }
|
|
}
|
|
|
|
public String FachBereichsSQL
|
|
{
|
|
get { return fachBereichsSQL; }
|
|
set { fachBereichsSQL = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Holt die Verbindung zum MSSQL Server
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private SqlConnection getConnection()
|
|
{
|
|
SqlConnection result = null;
|
|
try
|
|
{
|
|
result = new SqlConnection();
|
|
result.ConnectionString = DBTools.ConnectionStringODAL();
|
|
result.Open();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
result = null;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Schliesst die Verbindung zum MSSQL Server
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private void returnConnection(SqlConnection con)
|
|
{
|
|
if (con != null && con.State == ConnectionState.Open)
|
|
{
|
|
con.Close();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Laden "aller" Informationen zum User
|
|
/// </summary>
|
|
/// <param name="con"></param>
|
|
private bool userInfoLaden()
|
|
{
|
|
SqlConnection con = getConnection();
|
|
|
|
bool result = false;
|
|
StringBuilder sql = new StringBuilder();
|
|
sql.Append("select ANWENDER.USERNR, FIRMENNR, NAME, KOSTENSTELLE, ADMIN, FREIGABE, EMAIL, LOGIN, TELEFON, UNTERSCHRIFT, TE, GESPERRT, ERSTELLER, SZBNamen.anwender from ODAL.ANWENDER left join SZBNamen on ANWENDER.USERNR = SZBNamen.userNr"); // WHERE GESPERRT <> 'J'");
|
|
|
|
SqlCommand command = new SqlCommand(sql.ToString(), con);
|
|
SqlDataReader reader = command.ExecuteReader();
|
|
while (reader.Read())
|
|
{
|
|
ODALUser user = new ODALUser();
|
|
user.UserID = DBTools.DBGetInt(reader, 0);
|
|
user.Firma = DBTools.DBGetInt(reader, 1);
|
|
user.Name = DBTools.DBGetString(reader, 2);
|
|
user.Kostenstelle = DBTools.DBGetInt(reader, 3).ToString();
|
|
user.Admin = DBTools.DBGetString(reader, 4) == "J" || DBTools.DBGetString(reader, 4) == "1";
|
|
user.Freigabe = DBTools.DBGetString(reader, 5) == "J" || DBTools.DBGetString(reader, 5) == "1";
|
|
user.EMail = DBTools.DBGetString(reader, 6);
|
|
user.Telefon = DBTools.DBGetString(reader, 8);
|
|
user.Unterschrift = DBTools.DBGetString(reader, 9);
|
|
user.Te = DBTools.DBGetString(reader, 10) == "J" || DBTools.DBGetString(reader, 10) == "1";
|
|
user.DarfBestellungenErstelllen = DBTools.DBGetString(reader, 12) == "J" || DBTools.DBGetString(reader, 12) == "1";
|
|
|
|
if (!reader.IsDBNull(7))
|
|
{
|
|
user.Login = reader.GetString(7).Trim();
|
|
|
|
//Übernehmen der Informationen des angemeldetetn Users
|
|
if (user.Login.Trim().ToUpper() == this.angemeldeterUser.Login.Trim().ToUpper())
|
|
{
|
|
this.angemeldeterUser = user;
|
|
result = true;
|
|
}
|
|
}
|
|
if (DBTools.DBGetString(reader, 11).ToUpper() == "J")
|
|
{
|
|
this.alleGesperrtenUser.Add(user.UserID, user);
|
|
}
|
|
else
|
|
{
|
|
if (!alleUser.ContainsKey(user.UserID))
|
|
{
|
|
alleUser.Add(user.UserID, user);
|
|
}
|
|
}
|
|
}
|
|
if (!result)
|
|
{
|
|
#if DEBUG
|
|
MessageBox.Show("Das Benutzerprofil: " + this.angemeldeterUser.Login + " ist in ODAl nicht vorhanden!", "WARNUNG!", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
|
|
#endif
|
|
}
|
|
reader.Close();
|
|
returnConnection(con);
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Nicht sicher ob das so klappt .. erzwingt das Neuladen der Informationen...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public static UserSingelton ResetInstance(string userName)
|
|
{
|
|
SingeltonManager.GetInstance().UnRegisterSigelton(me);
|
|
me.userAustragen();
|
|
me = null;
|
|
return GetInstance(userName);
|
|
}
|
|
|
|
|
|
public ODALUser GetInfoTo(string userName)
|
|
{
|
|
ODALUser result = null;
|
|
|
|
foreach (ODALUser u in this.alleUser.Values)
|
|
{
|
|
if (u.Name == userName)
|
|
{
|
|
result = u;
|
|
break;
|
|
}
|
|
}
|
|
if (result == null)
|
|
{
|
|
foreach (ODALUser u in this.alleGesperrtenUser.Values)
|
|
{
|
|
if (u.Name == userName)
|
|
{
|
|
result = u;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public ODALUser GetInfoFromLogin(string userLogin)
|
|
{
|
|
ODALUser result = null;
|
|
|
|
foreach (ODALUser u in this.alleUser.Values)
|
|
{
|
|
if (u.Login.ToUpper() == userLogin.ToUpper())
|
|
{
|
|
result = u;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public ODALUser GetInfoTo(int userNr)
|
|
{
|
|
ODALUser result = null;
|
|
|
|
if (this.alleUser.ContainsKey(userNr))
|
|
{
|
|
result = this.alleUser[userNr];
|
|
}
|
|
else if (this.alleGesperrtenUser.ContainsKey(userNr))
|
|
{
|
|
result = this.alleGesperrtenUser[userNr];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hier werden alle Usernummern geladen die der angemeldete User Vertritt
|
|
/// Ebenfalls werden Vertretungen von Vertretungen berücksichtigt.
|
|
/// </summary>
|
|
/// <param name="userNr"></param>
|
|
/// <param name="con"></param>
|
|
private void ladenVertreterKette(int userNr)
|
|
{
|
|
SqlConnection con = getConnection();
|
|
//Vertretungen laden
|
|
StringBuilder sql = new StringBuilder();
|
|
sql.Append("select USERNR from ODAL.VERTRETUNGEN WHERE USERNRV = ");
|
|
sql.Append(userNr);
|
|
sql.Append(" and VON <= ");
|
|
sql.Append(DBTools.Dat(DateTime.Now));
|
|
sql.Append(" and BIS >= ");
|
|
sql.Append(DBTools.Dat(DateTime.Now));
|
|
try
|
|
{
|
|
SqlCommand command = new SqlCommand(sql.ToString(), con);
|
|
SqlDataReader reader = command.ExecuteReader();
|
|
int u;
|
|
while (reader.Read())
|
|
{
|
|
u = DBTools.DBGetInt(reader, 0);
|
|
if (u != 0 && !this.vertretungen.Contains(u)) //Sicherheitsabfrage zur Vermeidung von Endlosschleifen bei Zirkelbezügen der Vertretungen
|
|
{
|
|
//Überprüfen, ob es den zu vertretenden Benutzer noch gibt, ansonsten austragen der Vertretung
|
|
if (this.alleUser.ContainsKey(u) || this.alleGesperrtenUser.ContainsKey(u))
|
|
{
|
|
this.vertretungen.Add(u);
|
|
this.ladenVertreterKette(u);
|
|
}
|
|
else
|
|
{
|
|
this.vertretungLoeschen(u);
|
|
}
|
|
}
|
|
}
|
|
reader.Close();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine(ex.Message);
|
|
throw;
|
|
}
|
|
returnConnection(con);
|
|
}
|
|
|
|
private void vertretungLoeschen(int u)
|
|
{
|
|
SqlConnection con = getConnection();
|
|
//Vertretungen löschen
|
|
StringBuilder sql = new StringBuilder();
|
|
sql.Append("Delete from ODAL.VERTRETUNGEN WHERE USERNRV = ");
|
|
sql.Append(u);
|
|
sql.Append(" or USERNR = ");
|
|
sql.Append(u);
|
|
try
|
|
{
|
|
SqlCommand command = new SqlCommand(sql.ToString(), con);
|
|
command.ExecuteNonQuery();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine(ex.Message);
|
|
throw;
|
|
}
|
|
returnConnection(con);
|
|
}
|
|
|
|
public Dictionary<int, ODALBereich> AlleBereiche
|
|
{
|
|
get
|
|
{
|
|
if (alleBereiche == null)
|
|
{
|
|
alleBereiche = new Dictionary<int, ODALBereich>();
|
|
this.alleBereicheLaden();
|
|
}
|
|
return alleBereiche;
|
|
}
|
|
}
|
|
|
|
public Bereich GetBereichFürID(int bereichid)
|
|
{
|
|
Bereich result =null;
|
|
if (FachBereiche.ContainsKey(bereichid))
|
|
{
|
|
result = this.fachBereiche[bereichid];
|
|
}
|
|
else if(AlleBereiche.ContainsKey(bereichid))
|
|
{
|
|
result = this.alleBereiche[bereichid];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Laden der Bereiche, die direkt und per Vertretung zugewiesen sind!
|
|
/// </summary>
|
|
/// <param name="con"></param>
|
|
private void alleBereicheLaden()
|
|
{
|
|
SqlConnection con = getConnection();
|
|
StringBuilder sql = new StringBuilder();
|
|
//Bereiche für alle User laden (Selbst + Vertretungen)
|
|
sql.Append("select ");
|
|
sql.Append("BEREICHNR, ");
|
|
sql.Append("BEREICH, ");
|
|
sql.Append("S1, ");
|
|
sql.Append("F1, ");
|
|
sql.Append("S2, ");
|
|
sql.Append("F2, ");
|
|
sql.Append("S3, ");
|
|
sql.Append("F3, ");
|
|
sql.Append("TE, ");
|
|
sql.Append("EMAIL, ");
|
|
sql.Append("GESPERRT ");
|
|
sql.Append("from ODAL.BEREICHE ");
|
|
sql.Append("order by BEREICH");
|
|
SqlCommand command = new SqlCommand(sql.ToString(), con);
|
|
SqlDataReader reader = command.ExecuteReader();
|
|
|
|
while (reader.Read())
|
|
{
|
|
int bereichID = DBTools.DBGetInt(reader, 0);
|
|
if (!alleBereiche.ContainsKey(bereichID))
|
|
{
|
|
//Bereich
|
|
ODALBereich bereich = new ODALBereich();
|
|
bereich.ID = bereichID;
|
|
bereich.Bezeichnung = DBTools.DBGetString(reader, 1);
|
|
bereich.Freigabe1 = DBTools.DBGetInt(reader, 2);
|
|
bereich.Freigeber1 = DBTools.DBGetInt(reader, 3);
|
|
bereich.Freigabe2 = DBTools.DBGetInt(reader, 4);
|
|
bereich.Freigeber2 = DBTools.DBGetInt(reader, 5);
|
|
bereich.Freigabe3 = DBTools.DBGetInt(reader, 6);
|
|
bereich.Freigeber3 = DBTools.DBGetInt(reader, 7);
|
|
bereich.TeFreigabeVorFreigabe = DBTools.DBGetInt(reader, 8);
|
|
bereich.EMail = DBTools.DBGetString(reader, 9);
|
|
if (!reader.IsDBNull(10))
|
|
{
|
|
bereich.Gesperrt = reader.GetDateTime(10);
|
|
}
|
|
|
|
alleBereiche.Add(bereichID, bereich);
|
|
}
|
|
}
|
|
reader.Close();
|
|
|
|
|
|
//AltBereicheLaden
|
|
this.altBereiche = new List<ODALBereich>();
|
|
sql = new StringBuilder();
|
|
sql.Append("select ");
|
|
sql.Append("BEREICHNR, ");
|
|
sql.Append("BEREICH, ");
|
|
sql.Append("S1, ");
|
|
sql.Append("F1, ");
|
|
sql.Append("S2, ");
|
|
sql.Append("F2, ");
|
|
sql.Append("S3, ");
|
|
sql.Append("F3, ");
|
|
sql.Append("TE, ");
|
|
sql.Append("EMAIL, ");
|
|
sql.Append("GBIS ");
|
|
sql.Append("from ODAL.BEREICHE_ALT ");
|
|
sql.Append("order by BEREICH");
|
|
command = new SqlCommand(sql.ToString(), con);
|
|
using(reader = command.ExecuteReader())
|
|
{
|
|
while (reader.Read())
|
|
{
|
|
//Bereich
|
|
ODALBereich bereich = new ODALBereich();
|
|
bereich.ID = DBTools.DBGetInt(reader, 0);
|
|
bereich.Bezeichnung = DBTools.DBGetString(reader, 1);
|
|
bereich.Freigabe1 = DBTools.DBGetInt(reader, 2);
|
|
bereich.Freigeber1 = DBTools.DBGetInt(reader, 3);
|
|
bereich.Freigabe2 = DBTools.DBGetInt(reader, 4);
|
|
bereich.Freigeber2 = DBTools.DBGetInt(reader, 5);
|
|
bereich.Freigabe3 = DBTools.DBGetInt(reader, 6);
|
|
bereich.Freigeber3 = DBTools.DBGetInt(reader, 7);
|
|
bereich.TeFreigabeVorFreigabe = DBTools.DBGetInt(reader, 8);
|
|
bereich.EMail = DBTools.DBGetString(reader, 9);
|
|
bereich.GültigBis = DBTools.DBGetDate(reader, 10);
|
|
|
|
altBereiche.Add(bereich);
|
|
}
|
|
}
|
|
|
|
returnConnection(con);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt den zum Zeitpunkt der Bestellung gültigen Bereich zurück wenn vorhanden ODER
|
|
/// </summary>
|
|
/// <param name="bestellung"></param>
|
|
/// <returns></returns>
|
|
public ODALBereich GetBereichFürBestelldatum(ODALBestellung bestellung)
|
|
{
|
|
ODALBereich result = null;
|
|
|
|
if (altBereiche == null)
|
|
{
|
|
Object o = this.AlleBereiche;
|
|
}
|
|
|
|
if (bestellung.FreiVon1 == 0 && bestellung.FreiVon1 == 0 && bestellung.FreiVon1 == 0 && !bestellung.IstFreigegeben())
|
|
{
|
|
result = null;
|
|
}
|
|
else
|
|
{
|
|
foreach (ODALBereich b in altBereiche)
|
|
{
|
|
|
|
if (b.ID == bestellung.Bereich)
|
|
{
|
|
if (b.GültigBis > bestellung.Datum)
|
|
{
|
|
if (result == null || result.GültigBis > b.GültigBis)
|
|
{
|
|
result = b;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (result == null)
|
|
{
|
|
if (bestellung.Bereich < 10000)
|
|
{
|
|
result = alleBereiche[bestellung.Bereich];
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public bool userIsFreigabeBerechtigtAnFachbereich(int fachbereichsId)
|
|
{
|
|
bool result = false;
|
|
if (angemeldeterUser != null)
|
|
{
|
|
result = userIsFreigabeBerechtigtAnFachbereich(angemeldeterUser.UserID, fachbereichsId);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public bool userIsFreigabeBerechtigtAnFachbereich(int userNR, int fachbereichsId)
|
|
{
|
|
bool result = false;
|
|
|
|
if (this.fachBereiche != null)
|
|
{
|
|
foreach (FachBereich fb in this.fachBereiche.Values)
|
|
{
|
|
if (fb.FachFreigeber.Contains(userNR))
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Alle Fachbereiche werden geladen und Freigabeberechtigte angefügt
|
|
/// Anschließend werden alle Zugeordneten User geladen
|
|
/// Anschließend wird das Teil SQL erstellt (Zur Besetllungseinschränkung)
|
|
/// </summary>
|
|
private void alleFachbereicheLaden()
|
|
{
|
|
this.fachBereiche = new Dictionary<int, FachBereich>();
|
|
|
|
String sql = "select BEID, FIRMA, BEZEICHNUNG, FACHMINWERT, TE, TEMINWERT, GÜLTIGBIS, USERID, FIFI, OHNEFREIGABE, [VEREINFACHTEFG], TEXTAUFBEST from ODAL.FACHBEREICHE LEFT JOIN ODAL.FACHBEREICH_FREIGEBER on BEID = FBID order BY BEZEICHNUNG, BEID";
|
|
using (SqlConnection con = new SqlConnection(DBTools.ConnectionStringODAL()))
|
|
{
|
|
con.Open();
|
|
SqlCommand cmd = new SqlCommand(sql, con);
|
|
using (SqlDataReader reader = cmd.ExecuteReader())
|
|
{
|
|
if (reader.HasRows)
|
|
{
|
|
List<int> bereicheImSql = new List<int>();
|
|
FachBereich bereich = null;
|
|
while (reader.Read())
|
|
{
|
|
if (bereich == null || bereich.ID != reader.GetInt32(0))
|
|
{
|
|
bereich = new FachBereich();
|
|
bereich.ID = DBTools.DBGetInt(reader, 0);
|
|
bereich.Firma = DBTools.DBGetInt(reader, 1);
|
|
bereich.Bezeichnung = DBTools.DBGetString(reader, 2);
|
|
bereich.FachMinimumWertgrenze = DBTools.DBGetInt(reader, 3);
|
|
bereich.TEEinbinden = DBTools.DBGetBool(reader, 4);
|
|
bereich.TEMinimumWertgrenze = DBTools.DBGetInt(reader, 5);
|
|
if (!reader.IsDBNull(6))
|
|
{
|
|
bereich.GültigBis = DBTools.DBGetDate(reader, 6);
|
|
}
|
|
if (!reader.IsDBNull(8))
|
|
{
|
|
bereich.FirmenFilter = DBTools.DBGetBool(reader, 8);
|
|
}
|
|
if (!reader.IsDBNull(9))
|
|
{
|
|
bereich.IstFachBereichOhneFreigabe = DBTools.DBGetBool(reader, 9);
|
|
}
|
|
if (!reader.IsDBNull(10))
|
|
{
|
|
bereich.IstFachBereichMitVereinfachterFreigabe = DBTools.DBGetBool(reader, 10);
|
|
}
|
|
if (!reader.IsDBNull(11))
|
|
{
|
|
bereich.KennungZusatzTextAufBestellung = DBTools.DBGetInt(reader, 11);
|
|
}
|
|
|
|
this.fachBereiche.Add(bereich.ID, bereich);
|
|
}
|
|
if (!reader.IsDBNull(7))
|
|
{
|
|
bereich.FachFreigeber.Add(DBTools.DBGetInt(reader, 7));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
this.userZuFachbereichenLaden();
|
|
this.fachBereichsSqlErstellen();
|
|
}
|
|
|
|
private void fachBereichsSqlErstellen()
|
|
{
|
|
StringBuilder tempSql = new StringBuilder("BEREICH in (");
|
|
String token = "";
|
|
foreach (FachBereich fb in this.fachBereiche.Values)
|
|
{
|
|
foreach (int userID in this.vertretungen)
|
|
{
|
|
if (fb.ZugeordneteUser.Contains(userID))
|
|
{
|
|
tempSql.Append(token);
|
|
tempSql.Append(fb.ID);
|
|
|
|
if (String.IsNullOrEmpty(token))
|
|
{
|
|
token = ", ";
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
tempSql.Append(")");
|
|
//
|
|
this.fachBereichsSQL = tempSql.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// User werden den Bereichen zugeordnet
|
|
/// </summary>
|
|
private void userZuFachbereichenLaden()
|
|
{
|
|
String sql = "select ODAL.ANWENDER_X_FACHBEREICH.USERNR, FBID from ODAL.ANWENDER_X_FACHBEREICH left join ODAL.Anwender on ODAL.ANWENDER_X_FACHBEREICH.USERNR = ODAL.Anwender.USERNR where GESPERRT<> 'J' order BY FBID";
|
|
using (SqlConnection con = new SqlConnection(DBTools.ConnectionStringODAL()))
|
|
{
|
|
con.Open();
|
|
SqlCommand cmd = new SqlCommand(sql, con);
|
|
using (SqlDataReader reader = cmd.ExecuteReader())
|
|
{
|
|
while (reader.Read())
|
|
{
|
|
int fbId = DBTools.DBGetInt(reader, 1);
|
|
if (this.fachBereiche.ContainsKey(fbId))
|
|
{
|
|
FachBereich b = this.fachBereiche[fbId];
|
|
int userId = DBTools.DBGetInt(reader, 0);
|
|
if(!b.ZugeordneteUser.Contains(userId))
|
|
{
|
|
b.ZugeordneteUser.Add(userId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
sql = "select ODAL.FACHBEREICH_KONDI.USERID, FBID from ODAL.FACHBEREICH_KONDI left join ODAL.Anwender on ODAL.FACHBEREICH_KONDI.USERid = ODAL.Anwender.USERNR where GESPERRT<> 'J' order BY FBID";
|
|
cmd = new SqlCommand(sql, con);
|
|
using (SqlDataReader reader = cmd.ExecuteReader())
|
|
{
|
|
while (reader.Read())
|
|
{
|
|
int fbId = DBTools.DBGetInt(reader, 1);
|
|
if (this.fachBereiche.ContainsKey(fbId))
|
|
{
|
|
FachBereich b = this.fachBereiche[fbId];
|
|
int userId = DBTools.DBGetInt(reader, 0);
|
|
if (!b.AlternativeKonditionsFreigeber.Contains(userId))
|
|
{
|
|
b.AlternativeKonditionsFreigeber.Add(userId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
sql = "select ODAL.FACHBEREICH_DIREKT_FREI.USERID, FBID from ODAL.FACHBEREICH_DIREKT_FREI left join ODAL.Anwender on ODAL.FACHBEREICH_DIREKT_FREI.USERid = ODAL.Anwender.USERNR where GESPERRT<> 'J' order BY FBID";
|
|
cmd = new SqlCommand(sql, con);
|
|
using (SqlDataReader reader = cmd.ExecuteReader())
|
|
{
|
|
while (reader.Read())
|
|
{
|
|
int fbId = DBTools.DBGetInt(reader, 1);
|
|
if (this.fachBereiche.ContainsKey(fbId))
|
|
{
|
|
FachBereich b = this.fachBereiche[fbId];
|
|
int userId = DBTools.DBGetInt(reader, 0);
|
|
if (!b.VereinfachteFreigabeFreigeber.Contains(userId))
|
|
{
|
|
b.VereinfachteFreigabeFreigeber.Add(userId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Laden der Bereiche, die direkt und per Vertretung zugewiesen sind!
|
|
/// </summary>
|
|
/// <param name="con"></param>
|
|
private void bereicheLaden()
|
|
{
|
|
SqlConnection con = getConnection();
|
|
//Sammeln der Vertretungen für SQL
|
|
StringBuilder vt = new StringBuilder();
|
|
String token = "";
|
|
foreach (int vert in this.vertretungen)
|
|
{
|
|
vt.Append(token);
|
|
vt.Append(vert.ToString());
|
|
if (String.IsNullOrEmpty(token))
|
|
{
|
|
token = ", ";
|
|
}
|
|
}
|
|
|
|
StringBuilder sql = new StringBuilder();
|
|
//Bereiche für alle User laden (Selbst + Vertretungen)
|
|
sql.Append("select ");
|
|
sql.Append("ODAL.BEREICHE.BEREICHNR, ");
|
|
sql.Append("ODAL.BEREICHE.BEREICH, ");
|
|
sql.Append("ODAL.BEREICHE.S1, ");
|
|
sql.Append("ODAL.BEREICHE.F1, ");
|
|
sql.Append("ODAL.BEREICHE.S2, ");
|
|
sql.Append("ODAL.BEREICHE.F2, ");
|
|
sql.Append("ODAL.BEREICHE.S3, ");
|
|
sql.Append("ODAL.BEREICHE.F3, ");
|
|
sql.Append("ODAL.BEREICHE.TE, ");
|
|
sql.Append("ODAL.BEREICHE.EMAIL, ");
|
|
sql.Append("ODAL.ANWENDER_X_BEREICH.USERNR, ");
|
|
sql.Append("ODAL.BEREICHE.GESPERRT ");
|
|
sql.Append("from ODAL.ANWENDER_X_BEREICH left join ODAL.BEREICHE on ODAL.ANWENDER_X_BEREICH.BEREICHNR = ODAL.BEREICHE.BEREICHNR where USERNR in (");
|
|
sql.Append(vt.ToString());
|
|
sql.Append(") order by BEREICH");
|
|
SqlCommand command = new SqlCommand(sql.ToString(), con);
|
|
SqlDataReader reader = command.ExecuteReader();
|
|
|
|
token = "";
|
|
bereichsSQL.Append("BEREICH in (");
|
|
while (reader.Read())
|
|
{
|
|
int bereichID = DBTools.DBGetInt(reader, 0);
|
|
if (!bereiche.ContainsKey(bereichID))
|
|
{
|
|
//SQL
|
|
bereichsSQL.Append(token);
|
|
bereichsSQL.Append(bereichID.ToString());
|
|
if (String.IsNullOrEmpty(token))
|
|
{
|
|
token = ", ";
|
|
}
|
|
//Bereich
|
|
ODALBereich bereich = new ODALBereich();
|
|
bereich.ID = bereichID;
|
|
bereich.Bezeichnung = DBTools.DBGetString(reader, 1);
|
|
bereich.Freigabe1 = DBTools.DBGetInt(reader, 2);
|
|
bereich.Freigeber1 = DBTools.DBGetInt(reader, 3);
|
|
bereich.Freigabe2 = DBTools.DBGetInt(reader, 4);
|
|
bereich.Freigeber2 = DBTools.DBGetInt(reader, 5);
|
|
bereich.Freigabe3 = DBTools.DBGetInt(reader, 6);
|
|
bereich.Freigeber3 = DBTools.DBGetInt(reader, 7);
|
|
bereich.TeFreigabeVorFreigabe = DBTools.DBGetInt(reader, 8);
|
|
bereich.EMail = DBTools.DBGetString(reader, 9);
|
|
bereich.FreigabeBerechtigt = UserIstfreigabeBerechtigt(DBTools.DBGetInt(reader, 10));
|
|
if(!reader.IsDBNull(11))
|
|
{
|
|
bereich.Gesperrt = reader.GetDateTime(11);
|
|
}
|
|
|
|
bereiche.Add(bereichID, bereich);
|
|
}
|
|
else
|
|
{
|
|
ODALBereich b = bereiche[bereichID];
|
|
if (!b.FreigabeBerechtigt)
|
|
{
|
|
b.FreigabeBerechtigt = UserIstfreigabeBerechtigt(DBTools.DBGetInt(reader, 10));
|
|
}
|
|
}
|
|
}
|
|
bereichsSQL.Append(") ");
|
|
reader.Close();
|
|
returnConnection(con);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Überprüft ob der übergebene User die "Freigabeberechtigung" hat.
|
|
/// (Vertretungen werden berücksichtigt)
|
|
/// </summary>
|
|
/// <param name="userNr"></param>
|
|
/// <returns></returns>
|
|
public bool UserIstfreigabeBerechtigt(int userNr)
|
|
{
|
|
bool result = false;
|
|
|
|
if (alleUser.ContainsKey(userNr))
|
|
{
|
|
ODALUser u = alleUser[userNr];
|
|
if (u.Freigabe)
|
|
{
|
|
result = true;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Holt zu der übergebenen User-Nummer das Kennwort.
|
|
/// </summary>
|
|
/// <param name="userNr"></param>
|
|
/// <returns></returns>
|
|
public bool StimmtKennwortÜberein(int userNr, string kennwort)
|
|
{
|
|
bool result = false;
|
|
|
|
SqlConnection con = getConnection();
|
|
string sql = "SELECT PASSWORT from ODAL.ANWENDER where USERNR = " + userNr;
|
|
SqlCommand com = new SqlCommand(sql, con);
|
|
SqlDataReader reader = com.ExecuteReader();
|
|
string pw = null;
|
|
|
|
while (reader.Read())
|
|
{
|
|
pw = this.decrypt(DBTools.DBGetStringUnTrimmed(reader, 0));
|
|
}
|
|
reader.Close();
|
|
returnConnection(con);
|
|
|
|
if (pw == kennwort)
|
|
{
|
|
result = true;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verschlüsselt ein übergebens Paswort
|
|
/// </summary>
|
|
/// <param name="text"></param>
|
|
/// <returns></returns>
|
|
private string encrypt(string text)
|
|
{
|
|
string result;
|
|
int zeichen;
|
|
|
|
result = "";
|
|
for (int i = 0; i < text.Length; i++)
|
|
{
|
|
zeichen = (int)char.Parse(text.Substring(i, 1));
|
|
zeichen = zeichen - 16;
|
|
result = result + (char)zeichen;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Entschlüsselt ein übergebenes Kennwort
|
|
/// </summary>
|
|
/// <param name="text"></param>
|
|
/// <returns></returns>
|
|
private string decrypt(string text)
|
|
{
|
|
string result = "";
|
|
int zeichen;
|
|
|
|
if (String.IsNullOrEmpty(text))
|
|
{
|
|
MessageBox.Show("Kein Kennwort vergeben!");
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < text.Length; i++)
|
|
{
|
|
|
|
zeichen = (int)char.Parse(text.Substring(i, 1));
|
|
zeichen = zeichen + 16;
|
|
result = result + (char)zeichen;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Überprüft ob der angemeldete User an dem übergebenen Bereich
|
|
/// freigabeberechtigt ist.
|
|
/// </summary>
|
|
/// <param name="bereichsID"></param>
|
|
/// <returns></returns>
|
|
public bool freigebeBerechtigtAnBereich(int bereichsID)
|
|
{
|
|
bool result = false;
|
|
|
|
if(this.bereiche.ContainsKey(bereichsID))
|
|
{
|
|
ODALBereich b = this.bereiche[bereichsID];
|
|
if (b.FreigabeBerechtigt)
|
|
{
|
|
result = true;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//Gibt die einzige Instanz dieses Sigeltons heraus
|
|
public static UserSingelton GetInstance()
|
|
{
|
|
if (me == null || ODALParameterSingelton.GetInstance().DirtyUser)
|
|
{
|
|
try
|
|
{
|
|
string name = WindowsIdentity.GetCurrent().Name;
|
|
string[] details = name.Split('\\');
|
|
me = new UserSingelton(details[details.Length - 1]);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
me = null;
|
|
}
|
|
}
|
|
|
|
return me;
|
|
}
|
|
|
|
//Gibt die einzige Instanz dieses Sigeltons heraus
|
|
public static UserSingelton GetInstance(string userName)
|
|
{
|
|
lock (padlock0)
|
|
{
|
|
if (me == null || ODALParameterSingelton.GetInstance().DirtyUser)
|
|
{
|
|
me = new UserSingelton(userName);
|
|
SingeltonManager.GetInstance().RegisterSingelton(me);
|
|
}
|
|
|
|
return me;
|
|
}
|
|
}
|
|
|
|
public int UserID
|
|
{
|
|
get { return this.angemeldeterUser.UserID; }
|
|
}
|
|
|
|
public List<String> ProjektNummernVorgabe
|
|
{
|
|
get { return this.angemeldeterUser.ProjektNummernVorgabe; }
|
|
}
|
|
|
|
public string Name
|
|
{
|
|
get { return this.angemeldeterUser.Name; }
|
|
}
|
|
|
|
public string EMail
|
|
{
|
|
get { return this.angemeldeterUser.EMail; }
|
|
}
|
|
|
|
public string Kostenstelle
|
|
{
|
|
get { return this.angemeldeterUser.Kostenstelle; }
|
|
}
|
|
|
|
public int Firma
|
|
{
|
|
get { return this.angemeldeterUser.Firma; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prüft ob der angemeldete User Adminrechte besitzt
|
|
/// (Vertretungen werden berücksichtigt)
|
|
/// </summary>
|
|
public bool Admin
|
|
{
|
|
get
|
|
{
|
|
bool result = angemeldeterUser.Admin;
|
|
//Falls Vertretungen existieren muss der Admin status von den Vertetenen mit berüpcksichtigt werden
|
|
if (!result && this.vertretungen.Count > 1) //Man ist selbst Mitglied dieser Liste daher >1
|
|
{
|
|
for(int i = 1; i< this.vertretungen.Count; i++)
|
|
{
|
|
int userNr = this.vertretungen[i];
|
|
if (alleUser.ContainsKey(userNr))
|
|
{
|
|
ODALUser u = alleUser[userNr];
|
|
if (u.Admin)
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prüft ob der angemeldete User TE-Rechte besitzt
|
|
/// (Vertretungen werden berücksichtigt)
|
|
/// </summary>
|
|
public bool TE
|
|
{
|
|
get
|
|
{
|
|
bool result = angemeldeterUser.Te;
|
|
//Falls Vertretungen existieren muss der TE status von den Vertetenen mit berüpcksichtigt werden
|
|
if (!result && this.vertretungen.Count > 1) //Man ist selbst Mitglied dieser Liste daher >1
|
|
{
|
|
for (int i = 1; i < this.vertretungen.Count; i++)
|
|
{
|
|
int userNr = this.vertretungen[i];
|
|
if (alleUser.ContainsKey(userNr))
|
|
{
|
|
ODALUser u = alleUser[userNr];
|
|
if (u.Te)
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Überprüft ob der übergebene Name dem angemeldeten User entspricht.
|
|
/// Vertretungen werden berücksichtigt!!!!!
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <returns></returns>
|
|
public bool DasBinIch(string name)
|
|
{
|
|
bool result = false;
|
|
name = name.ToLower();
|
|
foreach (int userNr in this.vertretungen)
|
|
{
|
|
if (alleUser.ContainsKey(userNr))
|
|
{
|
|
if (alleUser[userNr].Name.ToLower() == name)
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!result && alleGesperrtenUser.ContainsKey(userNr))
|
|
{
|
|
if (alleGesperrtenUser[userNr].Name.ToLower() == name)
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public Dictionary<int, ODALBereich> Bereiche
|
|
{
|
|
get { return bereiche; }
|
|
}
|
|
|
|
public string GetBereichsSQL()
|
|
{
|
|
return bereichsSQL.ToString();
|
|
}
|
|
|
|
public ODALIni Parameter
|
|
{
|
|
get { return parameter; }
|
|
}
|
|
|
|
public List<int> Vertretungen
|
|
{
|
|
get { return vertretungen; }
|
|
}
|
|
public Dictionary<int, ODALUser> AlleUser
|
|
{
|
|
get { return alleUser; }
|
|
set { alleUser = value; }
|
|
}
|
|
public Dictionary<int, ODALUser> AlleGesperrtenUser
|
|
{
|
|
get { return alleGesperrtenUser; }
|
|
set { alleGesperrtenUser = value; }
|
|
}
|
|
|
|
public bool AngemeldeterUserDarfBestellungErfassen()
|
|
{
|
|
bool result = false;
|
|
if (angemeldeterUser != null)
|
|
{
|
|
if (angemeldeterUser.DarfBestellungenErstelllen)
|
|
{
|
|
result = true;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Überprüft ob der User bei der Übergebenen Kombination von Parametern
|
|
/// für die NÄCHSTE (nun benötigten Freigabe) freigabeberechtigt ist
|
|
/// </summary>
|
|
/// <param name="f1"></param>
|
|
/// <param name="f2"></param>
|
|
/// <param name="f3"></param>
|
|
/// <param name="bereichsID"></param>
|
|
/// <returns></returns>
|
|
public bool angemeldeterUserDarfNächsteFreigabeErteilen(int f1, int f2, int f3, int bereichsID)
|
|
{
|
|
bool result = false;
|
|
|
|
if (this.Admin)
|
|
{
|
|
result = true;
|
|
}
|
|
else
|
|
{
|
|
if (this.freigebeBerechtigtAnBereich(bereichsID))
|
|
{
|
|
if (f1 == 0)
|
|
{
|
|
if (this.Vertretungen.Contains(this.Bereiche[bereichsID].Freigeber1))
|
|
{
|
|
result = true;
|
|
}
|
|
}
|
|
else if (f2 == 0)
|
|
{
|
|
if (this.Vertretungen.Contains(this.Bereiche[bereichsID].Freigeber2))
|
|
{
|
|
result = true;
|
|
}
|
|
}
|
|
else if (f3 == 0)
|
|
{
|
|
if (this.Vertretungen.Contains(this.Bereiche[bereichsID].Freigeber3))
|
|
{
|
|
result = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public void ManagedKill()
|
|
{
|
|
lock (padlock0)
|
|
{
|
|
if (me != null)
|
|
{
|
|
me.userAustragen();
|
|
}
|
|
me = null;
|
|
}
|
|
}
|
|
|
|
public void ManagedReset(string userName)
|
|
{
|
|
lock (padlock0)
|
|
{
|
|
if (String.IsNullOrEmpty(userName))
|
|
{
|
|
me = null;
|
|
}
|
|
else
|
|
{
|
|
me.userAustragen();
|
|
me = new UserSingelton(userName);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void userEintragen()
|
|
{
|
|
this.userAustragen();
|
|
|
|
SqlConnection con = getConnection();
|
|
StringBuilder sql = new StringBuilder();
|
|
sql.Append("insert into ODAL.AKTIVEODALUSER (TCPIP, LOGDATUM, USERNAME, VERSION) values(");
|
|
sql.Append(DBTools.Txt(this.getIP()));
|
|
sql.Append(", ");
|
|
sql.Append(DBTools.DatTime(DateTime.Now));
|
|
sql.Append(", ");
|
|
sql.Append(DBTools.Txt(this.angemeldeterUser.Login));
|
|
sql.Append(", ");
|
|
sql.Append(DBTools.Txt(this.getVersion()));
|
|
sql.Append(")");
|
|
|
|
SqlCommand com = new SqlCommand(sql.ToString(), con);
|
|
com.ExecuteNonQuery();
|
|
returnConnection(con);
|
|
}
|
|
|
|
private void userAustragen()
|
|
{
|
|
SqlConnection con = getConnection();
|
|
StringBuilder sql = new StringBuilder();
|
|
sql.Append("delete from ODAL.AKTIVEODALUSER where USERNAME = ");
|
|
sql.Append(DBTools.Txt(this.angemeldeterUser.Login));
|
|
SqlCommand com = new SqlCommand(sql.ToString(), con);
|
|
try
|
|
{
|
|
com.ExecuteNonQuery();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//Nothing
|
|
}
|
|
returnConnection(con);
|
|
}
|
|
|
|
private string getVersion()
|
|
{
|
|
string result = "";
|
|
|
|
Version v = Assembly.GetExecutingAssembly().GetName().Version;
|
|
result = "V" + v.Major + "." + v.Minor + "." + v.MajorRevision + "." + v.MinorRevision;
|
|
|
|
return result;
|
|
}
|
|
|
|
public List<ODALBereich> AltBereiche
|
|
{
|
|
get { return altBereiche; }
|
|
set { altBereiche = value; }
|
|
}
|
|
|
|
public void ResetFachbereiche()
|
|
{
|
|
this.alleFachbereicheLaden();
|
|
}
|
|
|
|
private string getIP()
|
|
{
|
|
string result = "";
|
|
|
|
try
|
|
{
|
|
System.Net.IPHostEntry host = System.Net.Dns.GetHostEntry("");
|
|
System.Net.IPAddress myIP = null;
|
|
foreach (System.Net.IPAddress a in host.AddressList)
|
|
{
|
|
if (a.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
|
|
{
|
|
myIP = a;
|
|
break;
|
|
}
|
|
}
|
|
result = myIP.ToString();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
result = "UNKNOWN";
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public ODALUser GetUserFromFullName(string fullName)
|
|
{
|
|
ODALUser result = null;
|
|
foreach (ODALUser u in alleUser.Values)
|
|
{
|
|
if (u.Name == fullName)
|
|
{
|
|
result = u;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
}
|