public DataTable SqlConsulta(string connectionString, string nameRelation, string whereList, string ordersList, string fieldsList)
{
if (string.IsNullOrEmpty(nameRelation))
{
throw new ArgumentException("nameTable");
}
string conditionsOrder = string.Empty;
if (!string.IsNullOrEmpty(whereList))
{
conditionsOrder = " where " + whereList;
}
if (!string.IsNullOrEmpty(ordersList))
{
conditionsOrder = conditionsOrder + " order by " + ordersList;
}
string listFields = fieldsList ?? "*";
string sql = string.Format("select {0} from {1} {2}", listFields, nameRelation, conditionsOrder);
DataTable dt = null;
switch (TypeDataBase.ToLower())
{
case "postgresql":
dt = NpgsqlHelper.ExecuteDataset(connectionString, CommandType.Text, sql).Tables[0];
break;
case "sqlserver":
dt = SqlHelper.ExecuteDataset(connectionString, CommandType.Text, sql).Tables[0];
break;
}
return(dt);
}
public void EditItem(TypeDataBase dateBase)
{
using (StreamWriter sw = new StreamWriter(path, false, System.Text.Encoding.Default))
{
sw.Write((int)dateBase);
}
}
public DataTable ExecuteStoreProcedure(string sqlQuery, params object[] parameterValues)
{
DataTable dt = null;
switch (TypeDataBase.ToLower())
{
case "postgresql":
dt = NpgsqlHelper.ExecuteDataset(ConnectionString, sqlQuery, parameterValues).Tables[0];
break;
case "sqlserver":
dt = SqlHelper.ExecuteDataset(ConnectionString, sqlQuery, parameterValues).Tables[0];
break;
}
return(dt);
}
public IDataReader ExecuteStoreProcedureDr(string sqlQuery, params object[] parameterValues)
{
IDataReader dr = null;
switch (TypeDataBase.ToLower())
{
case "postgresql":
dr = NpgsqlHelper.ExecuteReader(ConnectionString, sqlQuery, parameterValues);
break;
case "sqlserver":
dr = SqlHelper.ExecuteReader(ConnectionString, sqlQuery, parameterValues);
break;
}
return(dr);
}
public DataSet ExecuteStoreProcedureDs(string sqlQuery, params object[] parameterValues)
{
DataSet ds = null;
switch (TypeDataBase.ToLower())
{
case "postgresql":
ds = NpgsqlHelper.ExecuteDataset(ConnectionString, sqlQuery, parameterValues);
break;
case "sqlserver":
ds = SqlHelper.ExecuteDataset(ConnectionString, sqlQuery, parameterValues);
break;
}
return(ds);
}
public UserService(TypeDataBase type)
{
switch (type)
{
case TypeDataBase.File:
_repositoryUser = new UserJsonRepo();
_repositoryAward = new AwardJsonRepo();
_usersAwardsRepo = new UsersAwardsJsonRepo();
break;
case TypeDataBase.RelationalDb:
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, "Illegal type of data base.");
}
}
public void ObtenerDatosServidor()
{
switch (TypeDataBase.ToLower())
{
case "postgresql":
var builderPostgreSql = new NpgsqlConnectionStringBuilder(ConnectionString);
Servidor = builderPostgreSql.Host;
NombreBaseDeDato = builderPostgreSql.Database;
break;
case "sqlserver":
var builderSqlServer = new SqlConnectionStringBuilder(ConnectionString);
Servidor = builderSqlServer.DataSource;
NombreBaseDeDato = builderSqlServer.InitialCatalog;
break;
}
}
public DateTime FechaActualServidor()
{
string sqlQuery = string.Empty;
switch (TypeDataBase.ToLower())
{
case "postgresql":
sqlQuery = "select now() as fechaservidor";
break;
case "sqlserver":
sqlQuery = "select getdate() as fechaservidor";
break;
}
DateTime fechaServidor = (DateTime)NpgsqlHelper.ExecuteScalar(ConnectionString, CommandType.Text, sqlQuery);
return(fechaServidor);
}
public AlumnoManagerDLL(string pstrConn, TypeDataBase pTypeDB)
: base(pstrConn, pTypeDB)
{
}
/// <summary>
/// Representa el contructor de dll del administrador.
/// </summary>
public AutenticationManagerDLL(string pstrConn, TypeDataBase pTypeDB)
: base(pstrConn, pTypeDB)
{
}
public SessionManagerDLL(string pstrConn, TypeDataBase pTypeDB) : base(pstrConn, pTypeDB)
{
}
public BaseDLL(string pStrConn, TypeDataBase pTypeDB)
{
this.con = new DataConnection(pStrConn, pTypeDB);
this.TypeDB = this.con.TypeDB;
}
public CredentialsManagerDLL(string pstrConn, TypeDataBase pTypeDB) : base(pstrConn, pTypeDB)
{
}
/// <summary>
/// Representa el contructor de dll del administrador.
/// </summary>
public DLL(string pstrConn, TypeDataBase pTypeDB)
: base(pstrConn, pTypeDB)
{
}
internal DataConnection(string strConexion, TypeDataBase typeDB)
{
base.TypeDB = typeDB;
this.StringConexion = strConexion;
}
public NivelManagerDLL(string pstrConn, TypeDataBase pTypeDB) : base(pstrConn, pTypeDB)
{
}
public AsistenciaManagerDLL(string pstrConn, TypeDataBase pTypeDB) : base(pstrConn, pTypeDB)
{
}
/// <summary>
/// Representa el contructor de dll del administrador.
/// </summary>
public DocenteManagerDLL(string pstrConn, TypeDataBase pTypeDB) : base(pstrConn, pTypeDB)
{
}
internal DataConnection(string strConexion, TypeDataBase typeDB)
{
base.TypeDB = typeDB;
this.StringConexion = strConexion;
}
public void AssignObject()
{
// -- Make list of selected search types ----------------------------------------------
// -- (Note: I do not mind Linq allocations for editor scripts, only for runtime) -----
selectedTypes = objectSearchSelection
.Where(x => x.Value)
.Select(x => x.Key).ToList(); // @formatter:off
if (selectedTypes.Count == 0)
{
Debug.Log("Could not parse types "); return;
}
var typeString = selectedTypes.Aggregate("", (current, type) => current + $"{type} ");
if (debug)
{
Debug.Log($"Found Types: {typeString}");
}
// -- Check if specific types are selected, or is objects were manually added ---------
// -- (This was starting to become a mess and I need to come back and sort it out) ----
if (objectReferenceList.Count > 0 && selectedTypes.Contains("None"))
{
refSearch = false; objectListOnly = true;
}
else
{
refSearch = true;
}
if (objectReferenceList.Count > 0 || selectedTypes.Contains("Untagged"))
{
getUntagged = true;
}
if (selectedTypes.Count == 1 && selectedTypes.Contains("Untagged"))
{
refSearch = false; getUntagged = true;
}
if (objectReferenceList.Count == 0 && selectedTypes.Contains("None")) // @formatter:on
{
Debug.LogWarning("You must select a type to search for matching objects, " +
"toggle 'Get Non-specific Objects', or place them manually into Object Reference List");
return;
}
if (debug)
{
Debug.Log($"objectReferenceList: {objectReferenceList.Count.ToString()} refSearch: {refSearch.ToString()} getUntagged: {getUntagged.ToString()}");
}
if (refSearch) // -- getUntagged takes the selected searchObjectType
{
referenceScriptableObject = referenceManager.referenceScriptableObjects
.Where(x => selectedTypes.Contains(x.objectType.ToString()))
.ToList();
if (debug)
{
Debug.Log($"Matching Reference ScriptableObjects found for Types: {referenceScriptableObject.Count}"); // @formatter:off
}
// -- If no matching Reference ScriptableObjects were found, return error ---------
if (referenceScriptableObject.Count is 0)
{
Debug.LogError("Could not locate matching Object => Container types"); return;
} // @formatter:on
for (int i = 0; i < selectedTypes.Count; i++)
{
if (selectedTypes[i].Equals("Untagged"))
{
continue;
}
if (debug)
{
Debug.Log($"Getting Type: {selectedTypes[i]}");
}
var objType = GetEnumType(selectedTypes[i]);
if (debug)
{
Debug.Log($"Selected Type: {selectedTypes[i]} Found Type: {objType}");
}
var goList = FindObjectsOfType(objType).ToList();
if (goList.Count == 0)
{
Debug.LogError("No Objects found");
return;
}
var goTypeList = new List <Object>();
for (int j = 0; j < goList.Count; j++)
{
TypeDataBase go = goList[j] as TypeDataBase;
if (debug)
{
Debug.Log($"Object Name: {goList[j].name} : {goList[j].GetType()}");
}
// if (!(go is null)) objectReferenceList.Add(go.gameObject);
if (!(go is null))
{
goTypeList.Add(go.gameObject);
}
}
objectReferenceTypeDict.Add(selectedTypes[i], goTypeList);
}
}
if (getUntagged)
{
var defaultHolder = FindObjectOfType <DefaultObjectHolder>();
var objTransforms = defaultHolder.GetComponentsInChildren <Transform>(); // @formatter:off
if (objTransforms == null)
{
Debug.LogError("Could not locate DefaultObjectHolder Object holder in scene"); return;
} // @formatter:on
var untaggedObjects = new List <Object>();
if (!objectListOnly)
{
untaggedObjects = objTransforms
.Where(x => !x.gameObject.GetComponent <DefaultObjectHolder>())
.Select(x => x.gameObject as Object)
.ToList(); // @formatter:off
if (untaggedObjects.Count == 0)
{
Debug.LogError("Could not locate DefaultObjectHolder Object holder in scene"); return;
}
}
untaggedObjects.AddRange(objectReferenceList);
objectReferenceTypeDict.Add("None", untaggedObjects); // @formatter:on
var defaultContainer = referenceManager.referenceScriptableObjects
.FirstOrDefault(x => x.objectType.ToString() == "None"); // @formatter:off
if (defaultContainer == null)
{
Debug.LogError("Could not locate TypeData_Default Reference ScriptableObject"); return;
}
referenceScriptableObject.Add(defaultContainer); // @formatter:on
if (debug)
{
Debug.Log($"Added {defaultContainer.name} for Untagged objects");
foreach (var untaggedObject in untaggedObjects)
{
Debug.Log(untaggedObject.name);
}
}
}
refTypeKeys = objectReferenceTypeDict.Keys.ToList();
for (var i = 0; i < refTypeKeys.Count; i++)
{
var typeObjects = objectReferenceTypeDict[refTypeKeys[i]];
if (debug)
{
Debug.Log($"{refTypeKeys[i]} : {typeObjects.Count.ToString()}");
}
var refObjectSO = referenceScriptableObject
.FirstOrDefault(x => x.objectType.ToString() == refTypeKeys[i]); // @formatter:off
if (refObjectSO == null)
{
Debug.LogError($"{refTypeKeys[i]} refObjectSO null"); return;
} // @formatter:on
if (debug)
{
Debug.Log($"{refTypeKeys[i]} : {refObjectSO.name}");
}
var refObjectList = refObjectSO.exposedReferenceList;
for (int j = 0; j < typeObjects.Count; j++)
{
var refObject = new ExposedReferenceObject
{
reference = new ExposedReference <GameObject>
{
defaultValue = typeObjects[j],
exposedName = typeObjects[j].name
}
};
refObjectList.Add(refObject);
}
for (int r = 0; r < refObjectList.Count; r++)
{
referenceManager.SetReferenceValue(refObjectList[r].reference.exposedName, refObjectList[r].reference.defaultValue);
}
SaveAssetData(refObjectSO);
}
// for (int r = 0; r < referenceScriptableObject.Count; r++)
// {
// var refObjectList = referenceScriptableObject[r].exposedReferenceList;
// for (int i = 0; i < objectReferenceList.Count; i++)
// {
// var refObject = new ExposedReferenceObject
// {
// reference = new ExposedReference<GameObject>
// {
// defaultValue = objectReferenceList[i],
// exposedName = objectReferenceList[i].name
// }
// };
// refObjectList.Add(refObject);
// }
//
// for (int i = 0; i < refObjectList.Count; i++)
// {
// referenceManager.SetReferenceValue(refObjectList[i].reference.exposedName, refObjectList[i].reference.defaultValue);
// }
//
// SaveAssetData(referenceScriptableObject[r]);
// }
Debug.Log($"✓ Setting Object References for types: [{typeString}] Completed!");
referenceScriptableObject.Clear();
objectReferenceList.Clear();
getUntagged = false;
refSearch = false;
}
/// <summary>
/// Representa el contructor de dll del administrador.
/// </summary>
public DLL(string pstrConn, TypeDataBase pTypeDB) : base(pstrConn, pTypeDB)
{
}
public void Edit(TypeDataBase dateBase)
{
selectedDBModel.EditItem(dateBase);
updateDataBaseMain.UpdateDataBaseMain();
}
public HorarioManagerDLL(string pstrConn, TypeDataBase pTypeDB) : base(pstrConn, pTypeDB)
{
}
public BaseDLL(string pStrConn, TypeDataBase pTypeDB)
{
this.con = new DataConnection(pStrConn, pTypeDB);
this.TypeDB = this.con.TypeDB;
}
public CarreraManagerDLL(string pstrConn, TypeDataBase pTypeDB) : base(pstrConn, pTypeDB)
{
}
public CalificacionManagerDLL(string pstrConn, TypeDataBase pTypeDB) : base(pstrConn, pTypeDB)
{
}
