//No setea valores null //Si se modifico la pk aunque sea natural no la updatea (usea ignora la pk) private void update(Serializable objeto, String primaryKeyPropertyName, String tableName, bool cascadeMode) { String updateQuery = "update " + tableName + " set "; List <SqlParameter> parametros = new List <SqlParameter>(); Dictionary <string, object> propertyValues = getPropertyValues(objeto); foreach (KeyValuePair <string, object> keyValuePair in propertyValues) { if (keyValuePair.Key != primaryKeyPropertyName) { String dataName = objeto.getMapFromKey(keyValuePair.Key); if (dataName != "") { bool isSerializableProperty = typeof(Serializable).IsAssignableFrom(keyValuePair.Value.GetType()); object parametro = keyValuePair.Value; if (isSerializableProperty) { Serializable serializableProperty = (Serializable)keyValuePair.Value; parametro = serializableProperty.getPropertyValue(serializableProperty.getIdPropertyName()); } updateQuery += dataName + "=@" + dataName + ","; DataBase.Instance.agregarParametro(parametros, "@" + dataName, parametro); } } } updateQuery = updateQuery.Remove(updateQuery.Length - 1); updateQuery += " where " + objeto.getMapFromKey(primaryKeyPropertyName) + "=" + objeto.getPkValue(); if (cascadeMode) { List <String> serializablePropertyNames = listSerializableProperties(objeto); foreach (KeyValuePair <string, object> keyValuePair in propertyValues) { //Aca supongo que no puede ser null if (serializablePropertyNames.Contains(keyValuePair.Key)) { Serializable serializableProperty = (Serializable)keyValuePair.Value; update(serializableProperty, serializableProperty.getIdPropertyName(), serializableProperty.getTableName(), cascadeMode); } } } DataBase.Instance.ejecutarConsulta(updateQuery, parametros); foreach (var item in objeto.getOneToManyPropertyNames()) { updateOneToManyProperty(objeto, item, cascadeMode); } }
private object selectById(object id, Type classType) { Serializable objeto = (Serializable)Activator.CreateInstance(classType); IList result = selectByProperty(objeto.getIdPropertyName(), id, classType); return((result.Count > 0) ? result[0] : null); }
private void createOneToManyTables(Serializable objeto) { foreach (var item in objeto.getOneToManyPropertyNames()) { string tableName = objeto.getOneToManyTable(item); if (!existsTable(tableName)) { createOneToManyTable(objeto, item); } else { addOneToManyForeignKey(objeto.getMapFromKey(objeto.getIdPropertyName()), tableName, objeto.getTableName(), objeto.getOneToManyPk(item), objeto.getPropertyType(objeto.getIdPropertyName())); } } }
private void completeOneToManyProperty(Serializable incompleteObject, string propertyName) { Type containingTypeOfProperty = incompleteObject.getOneToManyPropertyType(propertyName); Serializable containingTypeOfPropertyInstance = (Serializable)Activator.CreateInstance(containingTypeOfProperty); string intermediateTable = incompleteObject.getOneToManyTable(propertyName); string currentForeignKey = incompleteObject.getOneToManyFk(propertyName); string currentPrimaryKey = incompleteObject.getOneToManyPk(propertyName); object currentIdValue = incompleteObject.getPkValue(); string expected = "@" + currentPrimaryKey; List <SqlParameter> sqlParameters = new List <SqlParameter>(); DataBase.Instance.agregarParametro(sqlParameters, expected, currentIdValue); string query = "select * from " + intermediateTable + " "; string conditionQuery = "where " + currentPrimaryKey + "=" + expected; if (containingTypeOfPropertyInstance.getTableName() != intermediateTable) { query += "inner join " + containingTypeOfPropertyInstance.getTableName() + " on(" + intermediateTable + "." + currentForeignKey + "=" + containingTypeOfPropertyInstance.getTableName() + "." + containingTypeOfPropertyInstance. getMapFromKey(containingTypeOfPropertyInstance.getIdPropertyName()) + ") "; } query += conditionQuery; Type listType = incompleteObject.getPropertyType(propertyName); object dummyList = Activator.CreateInstance(listType); //Asigno una lista vacia a la propiedad incompleteObject.GetType().GetProperty(propertyName). SetValue(incompleteObject, dummyList); foreach (var item in executeQuery(query, sqlParameters, containingTypeOfProperty)) { List <object> parameters = new List <object> { item }; incompleteObject.GetType().GetProperty(propertyName). PropertyType.GetMethod("Add"). Invoke(incompleteObject.getPropertyValue(propertyName), parameters.ToArray()); } }
private object unSerialize(Dictionary <string, object> dictionary, Type modelClassType) { Serializable objeto = (Serializable)Activator.CreateInstance(modelClassType); Dictionary <string, object> dictionaryAux = copyDictionary(dictionary); foreach (String dataName in dictionary.Keys) { String propertyName = objeto.getMapFromVal(dataName); String keyToRemove = dataName; if (propertyName != "") { Type propertyType = objeto.getPropertyType(propertyName); bool isSerializable = typeof(Serializable).IsAssignableFrom(propertyType); if (dictionary[dataName].ToString() != "")//Esto esta hardcodeado para que no setee cosas en null { if (isSerializable) { Serializable propertyInstance = (Serializable)Activator.CreateInstance(propertyType); keyToRemove = propertyInstance.getMapFromKey(propertyInstance.getIdPropertyName()); object dataValue = dictionaryAux[dataName]; dictionaryAux.Remove(dataName); if (!dictionaryAux.ContainsKey(keyToRemove))//parchado porque rompio en un test diciendo que ya se habia insertado la clave { dictionaryAux.Add(keyToRemove, dataValue); } objeto.GetType().GetProperty(propertyName).SetValue(objeto, unSerialize(dictionaryAux, propertyType)); } else { object dataValue = getCastedValue(dictionary[dataName], objeto.getPropertyType(propertyName)); objeto.GetType().GetProperty(propertyName).SetValue(objeto, dataValue); } dictionaryAux.Remove(keyToRemove); } } } return(objeto); }
private void insertOneToManyProperty(Serializable objeto, string propertyName, bool cascade) { Type propertyType = objeto.getOneToManyPropertyType(propertyName); string propertyTable = ((Serializable)Activator.CreateInstance(propertyType)).getTableName(); string oneToManyTable = objeto.getOneToManyTable(propertyName); string expectedPk = "@" + objeto.getOneToManyPk(propertyName); foreach (var item in (IEnumerable)objeto.getPropertyValue(propertyName)) { Serializable serializableItem = (Serializable)item; string expectedFk = "@" + objeto.getOneToManyFk(propertyName); List <SqlParameter> sqlParameters = new List <SqlParameter>(); DataBase.Instance.agregarParametro(sqlParameters, expectedPk, objeto.getPkValue()); DataBase.Instance.agregarParametro(sqlParameters, expectedFk, serializableItem.getPkValue()); string query = ""; if (propertyTable == oneToManyTable) { if (cascade) { insert(serializableItem, serializableItem.getIdPropertyName(), propertyTable, cascade); } query = "update " + propertyTable + " set " + objeto.getOneToManyPk(propertyName) + "=" + expectedPk + "where " + objeto.getOneToManyFk(propertyName) + "=" + expectedFk; } else { query = "insert into " + oneToManyTable + "(" + objeto.getOneToManyPk(propertyName) + "," + objeto.getOneToManyFk(propertyName) + ") values(" + expectedPk + "," + expectedFk + ")"; } DataBase.Instance.ejecutarConsulta(query, sqlParameters); } }
private void createIncompleteTable(Serializable objeto) { if (existsTable(objeto.getTableName())) { return; } string createQuery = "create table " + objeto.getTableName() + "("; foreach (var item in listProperties(objeto)) { if (!isSerializableProperty(item, objeto)) { String dataType = getDataTypeName(getPropertyType(item, objeto)); if (dataType != "" && objeto.getMapFromKey(item) != "") { createQuery += objeto.getMapFromKey(item) + " " + dataType; if (objeto.getIdPropertyName() == item) { createQuery += " not null primary key"; if (objeto.getPrimaryKeyType() == PrimaryKeyType.SURROGATE) { createQuery += " identity(1,1)"; } } createQuery += ","; } } } createQuery = createQuery.Remove(createQuery.Length - 1); createQuery += ")"; DataBase.Instance.ejecutarConsulta(createQuery); }
private void createOneToManyTable(Serializable objeto, string propertyName) { Type containingTypeOfProperty = objeto.getOneToManyPropertyType(propertyName); Serializable containingTypeOfPropertyInstance = (Serializable)Activator.CreateInstance(containingTypeOfProperty); string pkName = objeto.getOneToManyPk(propertyName); string tableName = objeto.getOneToManyTable(propertyName); string fkName = objeto.getOneToManyFk(propertyName); string pkDataTypeName = getDataTypeName(objeto.GetType(). GetProperty(objeto.getIdPropertyName()).PropertyType); string fkDataTypeName = getDataTypeName(containingTypeOfPropertyInstance.GetType(). GetProperty(containingTypeOfPropertyInstance. getIdPropertyName()).PropertyType); string createQuery = "create table " + tableName + "(" + pkName + " " + pkDataTypeName + " ," + fkName + " " + fkDataTypeName + ", " + "primary key(" + pkName + "," + fkName + "))"; DataBase.Instance.ejecutarConsulta(createQuery); }
internal void updateCascade(Serializable objeto) { update(objeto, objeto.getIdPropertyName(), objeto.getTableName(), true); }
internal void update(Serializable objeto) { update(objeto, objeto.getIdPropertyName(), objeto.getTableName(), false); }
internal void delete(Serializable objeto) { delete(objeto, objeto.getIdPropertyName(), objeto.getTableName()); }
private void insert(Serializable objeto, String primaryKeyPropertyName, String tableName, bool cascade) { String insertQuery = "insert into " + tableName + "("; String valuesString = " values ("; List <SqlParameter> parametros = new List <SqlParameter>(); Dictionary <string, object> propertyValues = getPropertyValues(objeto); foreach (KeyValuePair <string, object> keyValuePair in propertyValues) { if (keyValuePair.Key != primaryKeyPropertyName || objeto.getPrimaryKeyType() == PrimaryKeyType.NATURAL) { String dataName = objeto.getMapFromKey(keyValuePair.Key); if (dataName != "") { insertQuery += dataName + ","; valuesString += "@" + dataName + ","; bool isSerializableProperty = typeof(Serializable).IsAssignableFrom(keyValuePair.Value.GetType()); Serializable serializableProperty = isSerializableProperty ? (Serializable)keyValuePair.Value : null; if (cascade && isSerializableProperty) { insert(serializableProperty, serializableProperty.getIdPropertyName(), serializableProperty.getTableName(), true); } object parametro = isSerializableProperty ? serializableProperty.getPropertyValue( serializableProperty.getIdPropertyName()) : keyValuePair.Value; DataBase.Instance.agregarParametro(parametros, "@" + dataName, parametro); } } } string primaryKeyName = objeto.getMapFromKey(objeto.getIdPropertyName()); insertQuery = insertQuery.Remove(insertQuery.Length - 1); valuesString = valuesString.Remove(valuesString.Length - 1); insertQuery += ") " + "output inserted." + primaryKeyName + valuesString + ")"; object insertResult = DataBase.Instance.ejecutarConsulta( insertQuery, parametros)[0][primaryKeyName]; Type idType = objeto.getPropertyType(objeto.getIdPropertyName()); object idValue = null; if (typeof(Serializable).IsAssignableFrom(idType)) { idValue = objeto.getIdValue(); Serializable serializableId = (Serializable)idValue; serializableId.GetType().GetProperty(serializableId.getIdPropertyName()). SetValue(serializableId, getCastedValue(insertResult, serializableId. getPropertyType(serializableId.getIdPropertyName()))); } else { idValue = getCastedValue(insertResult, idType); } objeto.GetType().GetProperty(objeto.getIdPropertyName()).SetValue(objeto, idValue); foreach (var item in objeto.getOneToManyPropertyNames()) { insertOneToManyProperty(objeto, item, cascade); } }
internal void insertCascade(Serializable objeto) { insert(objeto, objeto.getIdPropertyName(), objeto.getTableName(), true); }
internal void insert(Serializable objeto) { insert(objeto, objeto.getIdPropertyName(), objeto.getTableName(), false); }
private void createForeignKeys(Serializable objeto) { int serializablePropertyCounter = listProperties(objeto).Count(property => isSerializableProperty(property, objeto) && objeto.getMapFromKey(property) != ""); if (serializablePropertyCounter == 0) { return; } bool existsFkEqualToPk = listProperties(objeto).Exists(prop => objeto.getMapFromKey(prop) == objeto.getMapFromKey(objeto.getIdPropertyName()) && typeof(Serializable).IsAssignableFrom(getPropertyType(prop, objeto))); //Este es el caso en el que la pk sea una fk y que solo haya 1 fk if (serializablePropertyCounter == 1 && existsFkEqualToPk) { Type propertyType = getPropertyType(listProperties(objeto).Find(prop => isSerializableProperty(prop, objeto)), objeto); Serializable property = dictionaryObjectsAndTypes[propertyType]; DataBase.Instance.ejecutarConsulta("alter table " + objeto.getTableName() + " add foreign key(" + objeto.getMapFromKey(objeto.getIdPropertyName()) + ") references " + property.getTableName() + "(" + property.getMapFromKey(property.getIdPropertyName()) + ")"); return; } string alterQuery = "alter table " + objeto.getTableName() + " add "; string foreignKeys = ""; foreach (var item in listProperties(objeto)) { Type propertyType = getPropertyType(item, objeto); if (isSerializableProperty(item, objeto) && objeto.getMapFromKey(item) != "") { Serializable property = dictionaryObjectsAndTypes[propertyType]; Type idPropertyType = getPropertyType(property.getIdPropertyName(), property); string primaryKeyProperty = property.getMapFromKey(property.getIdPropertyName()); string foreignKeyProperty = objeto.getMapFromKey(item); string tableNameProperty = property.getTableName(); if (objeto.getMapFromKey(item) != objeto.getMapFromKey(objeto.getIdPropertyName()))//Si es la pk, ya se inserto { alterQuery += foreignKeyProperty + " " + getDataTypeName(idPropertyType) + ","; } foreignKeys += "foreign key(" + foreignKeyProperty + ") references " + tableNameProperty + "(" + primaryKeyProperty + "),"; } } foreignKeys = foreignKeys.Remove(foreignKeys.Length - 1); alterQuery += foreignKeys; DataBase.Instance.ejecutarConsulta(alterQuery); }