private void FillSaveParameters(LastSyncEntity lastSync, SqlCeCommand sqlCommand) { SqlCeParameter parameter; parameter = dataAccess.GetNewDataParameter("@entityName", DbType.String); parameter.Value = lastSync.EntityName; if (String.IsNullOrEmpty(lastSync.EntityName)) { parameter.Value = DBNull.Value; } sqlCommand.Parameters.Add(parameter); parameter = dataAccess.GetNewDataParameter("@lastTimestamp", DbType.DateTime); parameter.Value = lastSync.LastTimestamp; sqlCommand.Parameters.Add(parameter); }
public void CheckIsSynchronized() { // if we didn't synchronized since the last disconnection if (ServiceSmart.LastSync.LastTimestamp <= Connection.LastTimeDisconnected) { // get the remote entities that are not saved on the device Collection <ServiceEntity> remoteUpdates = Remote.GetServiceWhere(ServiceEntity.DBTimestamp, ServiceSmart.LastSync.LastTimestamp, false, OperatorType.Greater, Connection.Session); // save the remote entities on the device foreach (ServiceEntity remoteEntity in remoteUpdates) { Local.Save(remoteEntity); } LastSyncEntity now = new LastSyncEntity(); now.LastTimestamp = System.DateTime.Now; now.EntityName = "UtnEmall.Client.Entity.Service"; ServiceSmart.LastSync = now; } }
/// <summary> /// Transfiere un archivo desde el servidor al dispositivo. /// </summary> /// <param name="fileName"> /// El nombre del archivo a transferrir /// </param> public static void TransferFile(string fileName) { if (String.IsNullOrEmpty(fileName)) { throw new ArgumentException( global::PresentationLayer.GeneralResources.FileNameNullArgument); } LastSyncDataAccess syncDataAccess = new LastSyncDataAccess(); // Crear el servicio de transferencia FileTransferServiceClient fileTransfer = new FileTransferServiceClient(BaseForm.ServerBinding, new EndpointAddress(UtnEmall.Client.SmartClientLayer.Connection.ServerUri + "FileTransferService")); // Cargar la información de sincronización Collection <LastSyncEntity> results = syncDataAccess.LoadWhere("entityName", fileName.Substring(fileName.LastIndexOf(@"\", StringComparison.Ordinal) + 1), false, OperatorType.Equal); DownloadRequest request = new DownloadRequest(); request.FileName = Path.GetFileName(fileName); if (results.Count > 0) { request.FileDateTime = results[0].LastTimestamp.Ticks.ToString(CultureInfo.InvariantCulture); } else { request.FileDateTime = DateTime.MinValue.Ticks.ToString(CultureInfo.InvariantCulture); } if (!File.Exists(Path.Combine(Utilities.AppPath, fileName))) { request.FileDateTime = DateTime.MinValue.Ticks.ToString(CultureInfo.InvariantCulture); } // Realizar la transferencia RemoteFileInfo returnInfo = null; try { returnInfo = fileTransfer.DownloadFile(request, UtnEmall.Client.SmartClientLayer.Connection.Session); } catch (TargetInvocationException) { BaseForm.ShowErrorMessage( global::PresentationLayer.GeneralResources.TargetInvocationExceptionMessage, global::PresentationLayer.GeneralResources.ErrorTitle); return; } catch (CommunicationException) { BaseForm.ShowErrorMessage( global::PresentationLayer.GeneralResources.CommunicationException, global::PresentationLayer.GeneralResources.ErrorTitle); return; } FileStream writer = null; if (returnInfo != null) { fileName = Path.Combine(Utilities.AppPath, fileName); // Guardar el archivo a disco try { writer = new FileStream(fileName, FileMode.Create, FileAccess.Write); writer.Write(returnInfo.FileByteStream, 0, returnInfo.FileByteStream.Length); // Guardar la información para futuras sincronizaciones LastSyncEntity fileSync = new LastSyncEntity(); fileSync.EntityName = returnInfo.FileName; fileSync.LastTimestamp = new DateTime(Convert.ToInt64(returnInfo.FileDateTime, CultureInfo.InvariantCulture)); if (File.Exists(fileName) && results.Count > 0) { fileSync.Id = results[0].Id; fileSync.IsNew = false; fileSync.Changed = true; } syncDataAccess.Save(fileSync); } finally { if (writer != null) { writer.Close(); } } } }
/// <summary> /// Función para cargar un LastSyncEntity desde la base de datos. /// </summary> /// <param name="id">El id del registro a cargar</param> /// <param name="loadRelation">Si es true carga las relaciones</param> /// <param name="scope">Estructura interna usada para evitar la referencia circular, debe ser proveida si es llamada desde otro data access</param> /// <returns>La instancia de la entidad</returns> /// <exception cref="UtnEmallDataAccessException"> /// Si una DbException ocurre mientras se accede a la base de datos /// </exception> public LastSyncEntity Load(int id, bool loadRelation, Dictionary <string, IEntity> scope) { // Crea una clave para el objeto de scope interno string scopeKey = id.ToString(NumberFormatInfo.InvariantInfo) + "LastSync"; if (scope != null) { // Si el scope contiene el objeto, este ya fue cargado // retorna el objeto situado en el scope para evitar referencias circulares if (scope.ContainsKey(scopeKey)) { return((LastSyncEntity)scope[scopeKey]); } } else { // Si no existe un scope, crear uno scope = new Dictionary <string, IEntity>(); } LastSyncEntity lastSync = null; // Chequear si la entidad fue ya cargada por el data access actual // y retornar si fue ya cargada if (inMemoryEntities.ContainsKey(id)) { lastSync = inMemoryEntities[id]; // Agregar el objeto actual al scope scope.Add(scopeKey, lastSync); } else { bool closeConnection = false; try { // Abrir una nueva conexión si no es una transaccion if (dbConnection == null || dbConnection.State.CompareTo(ConnectionState.Closed) == 0) { closeConnection = true; dbConnection = dataAccess.GetNewConnection(); dbConnection.Open(); } string cmdText = "SELECT idLastSync, entityName, lastTimestamp, timestamp FROM [LastSync] WHERE idLastSync = @idLastSync"; // Crea el command SqlCeCommand sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction); // Crear el parametro id para la consulta SqlCeParameter parameter = dataAccess.GetNewDataParameter("@idLastSync", DbType.Int32); parameter.Value = id; sqlCommand.Parameters.Add(parameter); // Usar el datareader para cargar desde la base de datos IDataReader reader = sqlCommand.ExecuteReader(); lastSync = new LastSyncEntity(); if (reader.Read()) { // Cargar las filas de la entidad lastSync.Id = reader.GetInt32(0); if (!reader.IsDBNull(1)) { lastSync.EntityName = reader.GetString(1); } lastSync.LastTimestamp = reader.GetDateTime(2); // Agregar el objeto actual al scope scope.Add(scopeKey, lastSync); // Agregar el objeto a la cahce de entidades cargadas inMemoryEntities.Add(lastSync.Id, lastSync); // Lee el timestamp y establece las propiedades nuevo y cambiado lastSync.Timestamp = reader.GetDateTime(3); lastSync.IsNew = false; lastSync.Changed = false; // Cerrar el Reader reader.Close(); // Carga los objetos relacionadoss if required if (loadRelation) { } } else { reader.Close(); } } catch (DbException dbException) { // Relanza la excepcion como una excepcion personalizada throw new UtnEmallDataAccessException(dbException.Message, dbException); } finally { // Cierra la conexión si fue creada dentro de la Función if (closeConnection) { dbConnection.Close(); } } } // Retorna la entidad cargada return(lastSync); }
/// <summary> /// Función que elimina un LastSyncEntity de la base de datos. /// </summary> /// <param name="lastSync">LastSyncEntity a eliminar</param> /// <param name="scope">Estructura interna para evitar problemas de referencia circular.</param> /// <exception cref="ArgumentNullException"> /// Si <paramref name="lastSync"/> no es un <c>LastSyncEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// Si una DbException ocurre cuando se accede a la base de datos /// </exception> public void Delete(LastSyncEntity lastSync, Dictionary <string, IEntity> scope) { if (lastSync == null) { throw new ArgumentException("The argument can't be null"); } try { // Abrir una nueva conexión e inicializar una transacción si es necesario if (!isGlobalTransaction) { dbConnection = dataAccess.GetNewConnection(); dbConnection.Open(); dbTransaction = dbConnection.BeginTransaction(); } // Carga la entidad para garantizar eliminar todos los datos antiguos. lastSync = this.Load(lastSync.Id, true); if (lastSync == null) { throw new UtnEmallDataAccessException("Error al recuperar datos al intentar eliminar."); } // Crea un nuevo command para eliminar string cmdText = "DELETE FROM [LastSync] WHERE idLastSync = @idLastSync"; SqlCeCommand sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction); // Agrega los valores de los parametros SqlCeParameter parameterID = dataAccess.GetNewDataParameter("@idLastSync", DbType.Int32); parameterID.Value = lastSync.Id; sqlCommand.Parameters.Add(parameterID); // Ejecuta el comando sqlCommand.ExecuteNonQuery(); // Elimina los objetos relacionados // Confirma la transacción si se inicio dentro de la función if (!isGlobalTransaction) { dbTransaction.Commit(); } // Eliminamos la entidad de la lista de entidades cargadas en memoria inMemoryEntities.Remove(lastSync.Id); // Eliminamos la entidad del scope if (scope != null) { string scopeKey = lastSync.Id.ToString(NumberFormatInfo.InvariantInfo) + "LastSync"; scope.Remove(scopeKey); } } catch (DbException dbException) { // Anula la transaccion if (!isGlobalTransaction) { dbTransaction.Rollback(); } // Relanza una excepcion personalizada throw new UtnEmallDataAccessException(dbException.Message, dbException); } finally { // Cierra la conexión si fue abierta dentro de la Función if (!isGlobalTransaction) { dbConnection.Close(); dbConnection = null; dbTransaction = null; } } }
/// <summary> /// Función que elimina un LastSyncEntity de la base de datos. /// </summary> /// <param name="lastSync">LastSyncEntity a eliminar</param> /// <exception cref="ArgumentNullException"> /// Si <paramref name="lastSync"/> no es un <c>LastSyncEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// Si una DbException ocurre cuando se accede a la base de datos /// </exception> public void Delete(LastSyncEntity lastSync) { Delete(lastSync, null); }
/// <summary> /// Función que guarda un LastSyncEntity en la base de datos. /// </summary> /// <param name="lastSync">LastSyncEntity a guardar</param> /// <param name="scope">Estructura interna para evitar problemas con referencias circulares</param> /// <exception cref="ArgumentNullException"> /// Si <paramref name="lastSync"/> no es un <c>LastSyncEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// Si una DbException ocurre cuando se accede a la base de datos /// </exception> public void Save(LastSyncEntity lastSync, Dictionary <string, IEntity> scope) { if (lastSync == null) { throw new ArgumentException("The argument can't be null"); } // Crear una clave unica para identificar el objeto dentro del scope interno string scopeKey = lastSync.Id.ToString(NumberFormatInfo.InvariantInfo) + "LastSync"; if (scope != null) { // Si se encuentra dentro del scope lo retornamos if (scope.ContainsKey(scopeKey)) { return; } } else { // Crea un nuevo scope si este no fue enviado scope = new Dictionary <string, IEntity>(); } try { // Crea una nueva conexion y una nueva transaccion si no hay una a nivel superior if (!isGlobalTransaction) { dbConnection = dataAccess.GetNewConnection(); dbConnection.Open(); dbTransaction = dbConnection.BeginTransaction(); } string commandName = ""; bool isUpdate = false; // Verifica si se debe hacer una actualización o una inserción if (lastSync.IsNew || !DataAccessConnection.ExistsEntity(lastSync.Id, "LastSync", "idLastSync", dbConnection, dbTransaction)) { commandName = "INSERT INTO [LastSync] (idLastSync, ENTITYNAME, LASTTIMESTAMP, [TIMESTAMP] ) VALUES( @idLastSync, @entityName,@lastTimestamp, GETDATE()); "; } else { isUpdate = true; commandName = "UPDATE [LastSync] SET entityName = @entityName, lastTimestamp = @lastTimestamp , timestamp=GETDATE() WHERE idLastSync = @idLastSync"; } // Se crea un command SqlCeCommand sqlCommand = dataAccess.GetNewCommand(commandName, dbConnection, dbTransaction); // Agregar los parametros del command . SqlCeParameter parameter; if (!isUpdate && lastSync.Id == 0) { lastSync.Id = DataAccessConnection.GetNextId("idLastSync", "LastSync", dbConnection, dbTransaction); } parameter = dataAccess.GetNewDataParameter("@idLastSync", DbType.Int32); parameter.Value = lastSync.Id; sqlCommand.Parameters.Add(parameter); FillSaveParameters(lastSync, sqlCommand); // Ejecutar el command sqlCommand.ExecuteNonQuery(); scopeKey = lastSync.Id.ToString(NumberFormatInfo.InvariantInfo) + "LastSync"; // Agregar la entidad al scope actual scope.Add(scopeKey, lastSync); // Guarda las colecciones de objetos relacionados. // Guardar objetos relacionados con la entidad actual // Actualizar // Cierra la conexión si fue abierta en la función if (!isGlobalTransaction) { dbTransaction.Commit(); } // Actualizar los campos new y changed lastSync.IsNew = false; lastSync.Changed = false; } catch (DbException dbException) { // Anula la transaccion if (!isGlobalTransaction) { dbTransaction.Rollback(); } // Relanza una excepcion personalizada throw new UtnEmallDataAccessException(dbException.Message, dbException); } finally { // Cierra la conexión si fue inicializada if (!isGlobalTransaction) { dbConnection.Close(); dbConnection = null; dbTransaction = null; } } }
/// <summary> /// Función que guarda un LastSyncEntity en la base de datos. /// </summary> /// <param name="lastSync">LastSyncEntity a guardar</param> /// <exception cref="ArgumentNullException"> /// Si <paramref name="lastSync"/> no es un <c>LastSyncEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// Si una DbException ocurre cuando se accede a la base de datos /// </exception> public void Save(LastSyncEntity lastSync) { Save(lastSync, null); }