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);
}
