/// <summary>
/// Asigna cursos a empresa
/// </summary>
/// <param name="empresa"></param>
public void AsignarCursos(Empresa empresa)
{
// -- Recupero empresa existente
var empresaActual = Dalc.GetByID(empresa.EntityID);
// -- Lista de ids de los cursos seleccionados para la empresa
List <long> idsCursosEmpresa = empresa.EmpresaCursos.Select(x => x.Curso.EntityID).ToList();
// -- Lista de ids de cursos que tenia la empresa guardada
List <long> idsCursosEmpresaEnActual = empresaActual.EmpresaCursos.Select(x => x.Curso.EntityID).ToList();
// -- Borro cursos sacados
for (int i = empresaActual.EmpresaCursos.Count - 1; i >= 0; i--)
{
// -- Si el curso no esta contenido
if (!idsCursosEmpresa.Contains(empresaActual.EmpresaCursos[i].Curso.EntityID))
{
// -- Quito el curso
empresaActual.EmpresaCursos.RemoveAt(i);
}
}
// -- Agrego cursos nuevos
foreach (EmpresaCurso empCur in empresa.EmpresaCursos)
{
// -- Si la empresa no tenia el curso
if (!idsCursosEmpresaEnActual.Contains(empCur.Curso.EntityID))
{
// Lo agrego
empresaActual.EmpresaCursos.Add(empCur);
}
}
// -- Actualizo
Dalc.Update(empresaActual);
}
/// <summary>
/// Inserta una nueva diapositiva vista si no existe, o actualiza la fecha si existe
/// </summary>
/// <param name="diapositivaID"></param>
public void AddOrUpdate(Diapositiva diapositiva)
{
// -- Obtengo usuario logueado
var usuarioLogueado = SessionManager.Get <Usuario>(Global.SessionsKeys.USER_SESSION);
DiapositivaVista dv = Dalc.GetByUsuarioAndDiapositiva(diapositiva.EntityID, usuarioLogueado.EntityID);
//si no exista la diapositiva vista creo una nueva
if (dv == null)
{
dv = new DiapositivaVista();
DiapositivaDalc diapositivaDalc = new DiapositivaDalc();
//asigno diapositiva y usuario
dv.Diapositiva = diapositiva;
dv.Usuario = usuarioLogueado;
//actualizo la fecha vista
dv.FechaHoraVista = DateTime.Now;
Dalc.Add(dv);
}
else
{
//actualizo la fecha vista
dv.FechaHoraVista = DateTime.Now;
Dalc.Update(dv);
}
}
public void CargarImagen(Empresa empresa, Stream fileStream, string path, string extension)
{
path += "logoEmpresa" + empresa.EntityID + extension;
var length = Convert.ToInt32(fileStream.Length);
byte[] data = null;
using (var reader = new BinaryReader(fileStream))
{
data = reader.ReadBytes(length);
}
if (File.Exists(path))
{
File.Delete(path);
}
// -- Creo imagen
var file = new FileStream(path, FileMode.Create, FileAccess.Write);
file.Write(data, 0, length);
file.Close();
// -- Obtengo empresa
var empresaActual = Dalc.GetByID(empresa.EntityID);
// -- Actualizo imagen
empresaActual.Imagen = "logoEmpresa" + empresa.EntityID + extension;
// -- Actualizo
Dalc.Update(empresaActual);
}
/// <summary>
/// Delete data row
/// </summary>
/// <param name="r">DataRow to delete</param>
public void Delete(DataRow r)
{
if (r.RowState != DataRowState.Deleted)
{
r.Delete();
}
Dalc.Update(r.Table);
}
/// <summary>
/// Actualiza el estado de un cursousuario
/// </summary>
/// <param name="cursoUsuarioID">id del cursousuario</param>
/// <param name="estadoID">id del nuevo estado</param>
public void ActualizarEstado(long cursoUsuarioID, long estadoID)
{
var cursoUsuario = Dalc.GetByID(cursoUsuarioID);
cursoUsuario.EstadoCurso = new EstadoCurso {
EntityID = estadoID
};
Dalc.Update(cursoUsuario);
}
/// <summary>
/// Agrega curso y carga imagen
/// </summary>
/// <param name="curso"></param>
/// <param name="appPath"></param>
/// <param name="fileStream"></param>
/// <param name="extension"></param>
public void AddCurso(Curso curso, string appPath, Stream fileStream, string extension)
{
// -- Seteo propiedades
curso.Activo = true;
curso.FechaAlta = DateTime.Now;
// -- Cargado false porque aun no se suben archivos
curso.Cargado = false;
// -- Obtengo usuario logueado
var usuarioLogueado = SessionManager.Get <Usuario>(Global.SessionsKeys.USER_SESSION);
//Si el usuario no es administrador del sitio o administrador guardo la empresa
if (usuarioLogueado.Rol.EntityID != Convert.ToInt64(Global.Roles.ADMINISTRADOR) || usuarioLogueado.Rol.EntityID != Convert.ToInt64(Global.Roles.ADMINISTRADOR_SITIO))
{
curso.Empresa = new EmpresaLogic().GetByID(usuarioLogueado.Empresa.EntityID);
}
base.Add(curso);
//Si es diferente de null implica que el curso lo creo una empresa, por lo tanto se lo asigno directamente
if (curso.Empresa != null)
{
AsignarCursoEmpresa(curso.Empresa.EntityID, curso.EntityID);
}
#region Cargo Imagen del curso
appPath += string.Format(ImagenCursoPath, curso.EntityID, extension);
var length = Convert.ToInt32(fileStream.Length);
byte[] data = null;
using (var reader = new BinaryReader(fileStream))
{
data = reader.ReadBytes(length);
}
//-- Si existe imagen con el mismo nombre la sobreescribo
if (File.Exists(appPath))
{
File.Delete(appPath);
}
// -- Creo imagen
var file = new FileStream(appPath, FileMode.Create, FileAccess.Write);
file.Write(data, 0, length);
file.Close();
#endregion
// -- Asigno imagen al curso y actualizo
curso.Imagen = string.Format(ImagenCursoPath, curso.EntityID, extension);
Dalc.Update(curso);
}
public void Set(object fromKey, IEnumerable toKeys)
{
// load existing keys
var currentToKeys = GetToKeys(fromKey);
// remove missed relations
var fromCondition = ComposeFromCondition(fromKey);
var deleteCondition = fromCondition;
var toKeysArr = toKeys.Cast <object>().ToArray();
if (toKeysArr.Length > 0)
{
deleteCondition = new QueryConditionNode((QField)ToFieldName, Conditions.In | Conditions.Not, new QConst(toKeysArr)) & deleteCondition;
}
Dalc.Delete(new Query(RelationSourceName, deleteCondition));
var data = ExtraKeys == null ? new Hashtable() : new Hashtable(new DictionaryWrapper <string, object>(ExtraKeys));
data[FromFieldName] = fromKey;
int pos = 1;
foreach (var toKey in toKeys)
{
data[ToFieldName] = toKey;
if (PositionFieldName != null)
{
data[PositionFieldName] = pos++;
}
if (Contains(toKey, currentToKeys))
{
if (PositionFieldName != null)
{
Dalc.Update(new Hashtable()
{
{ PositionFieldName, data[PositionFieldName] }
},
new Query(RelationSourceName, (QField)ToFieldName == new QConst(toKey) & fromCondition));
}
}
else
{
Dalc.Insert(data, RelationSourceName);
}
}
}
/// <summary>
/// Guarda examen realizado
/// </summary>
/// <param name="preguntas">preguntas</param>
/// <param name="cursoID">id del cursp</param>
/// <returns></returns>
public float GuardarExamenRealizado(List <Pregunta> preguntas, long cursoID)
{
// -- Obtengo usuario logueado
var usuarioLogueado = SessionManager.Get <Usuario>(Global.SessionsKeys.USER_SESSION);
// -- Recupera curso usuario
var cursoUsuario = Dalc.GetByUsuarioAndCurso(usuarioLogueado.EntityID, cursoID);
// -- Recupero curso
CursoDalc cursoDalc = new CursoDalc();
var curso = cursoDalc.GetByID(cursoID);
// -- Cantidad correctas
int cantCorrectas = 0;
// -- Por cada pregunta del curso
foreach (Pregunta pregunta in curso.Preguntas)
{
// -- Obtengo la opcion correcta
Opcion opcionCorrecta = pregunta.Opciones.Where(x => x.Correcta).First();
// -- Obtengo la pregunta de las respondidas
Pregunta preguntaActual = preguntas.Where(x => x.EntityID == pregunta.EntityID).First();
// -- Si la opcion elegida es la correcta(es la unica opcion que se trae de las preguntas contestadas)
if (opcionCorrecta.EntityID == preguntaActual.Opciones.First().EntityID)
{
// -- Sumo una como correcta
cantCorrectas++;
}
}
// Calculo la nota
double nota = (float)cantCorrectas / (float)curso.Preguntas.Count * 100;
// -- La paso a 2 decimales
nota = Math.Round(nota, 2);
// -- Actualizo cursousuario
cursoUsuario.Nota = (float)nota;
cursoUsuario.EstadoCurso = new EstadoCurso {
EntityID = (long)Entities.EstadoCurso.EstadosCursos.EvaluacionRealizada
};
Dalc.Update(cursoUsuario);
return((float)nota);
}
/// <summary>
/// Update data row in dats source
/// </summary>
/// <param name="r">DataRow to update</param>
public void Update(DataRow r)
{
// this is good place to replace 'null' with DBNull
if (r.RowState != DataRowState.Deleted)
{
foreach (DataColumn c in r.Table.Columns)
{
if (c.AllowDBNull && r[c] == null)
{
r[c] = DBNull.Value;
}
}
}
if (r.RowState == DataRowState.Detached)
{
r.Table.Rows.Add(r);
}
Dalc.Update(r.Table);
}
private void SaveInternal(IDictionary data, IFileObject fileObject,
string tableName, string keyFieldName)
{
QueryConditionNode conditions = new QueryConditionNode((QField)keyFieldName,
Conditions.Equal, (QConst)fileObject.Name);
Hashtable recordData = new Hashtable();
int result = Dalc.RecordsCount(new Query(tableName, conditions));
if (result > 0)
{
if (data.Contains(keyFieldName))
{
data.Remove(keyFieldName); // fixed DB bug on update
}
Dalc.Update(new Query(tableName, conditions), data);
}
else
{
Dalc.Insert(tableName, data);
}
}
/// <summary>
/// Update record in data source by primary key
/// </summary>
/// <param name="tableName">data source identifier</param>
/// <param name="pk">primary key values</param>
/// <param name="changeset">column name -> value</param>
public void Update(string tableName, object[] pk, IDictionary <string, object> changeset)
{
DataSet ds = CreateDataSet(tableName);
if (ds == null)
{
throw new Exception("Unknown source name");
}
Query q = new Query(tableName, ComposePkCondition(ds.Tables[tableName], pk));
var t = Dalc.Load(q, ds);
if (t.Rows.Count == 0)
{
throw new Exception("Record does not exist");
}
foreach (DataRow r in t.Rows)
{
foreach (KeyValuePair <string, object> entry in changeset)
{
r[entry.Key] = PrepareValue(entry.Value);
}
}
Dalc.Update(t);
}
/// <summary>
/// Update all modified rows in DataTable
/// </summary>
/// <param name="tbl">DataTable with changed rows</param>
public void Update(DataTable tbl)
{
Dalc.Update(tbl);
}
/// <summary>
/// Agrega curso y carga archivos
/// </summary>
/// <param name="entity"></param>
/// <param name="appPath"></param>
/// <param name="fileStream"></param>
public void AddCurso(Curso entity, string appPath, Stream fileStream)
{
// -- Seteo propiedades
entity.Activo = true;
entity.FechaAlta = DateTime.Now;
// -- Cargado false porque aun no se suben archivos
entity.Cargado = false;
// -- Itero hasta obtener guid no usado
bool flag = true;
while (flag)
{
// -- Obtengo el friendly guid
entity.FilesFolder = GuidEncoder.Encode(Guid.NewGuid());
// -- Obtengo si esta disponible
bool disponible = Dalc.FilePathDisponible(entity.FilesFolder);
if (disponible)
{
// -- Cambio flag
flag = false;
}
}
// -- Obtengo usuario logueado
var usuarioLogueado = SessionManager.Get <Usuario>(Global.SessionsKeys.USER_SESSION);
//Si el usuario no es administrador del sitio o administrador guardo la empresa
if (usuarioLogueado.Rol.EntityID != Convert.ToInt64(Global.Roles.ADMINISTRADOR) || usuarioLogueado.Rol.EntityID != Convert.ToInt64(Global.Roles.ADMINISTRADOR_SITIO))
{
entity.Empresa = new EmpresaLogic().GetByID(usuarioLogueado.Empresa.EntityID);
}
base.Add(entity);
//Si es diferente de null implica que el curso lo creo una empresa, por lo tanto se lo asigno directamente
if (entity.Empresa != null)
{
AsignarCursoEmpresa(entity.Empresa.EntityID, entity.EntityID);
}
#region Creacion de carpeta y subida de archivos
// -- Concateno
appPath += entity.FilesFolder;
// -- Subida de archivos
using (ZipFile zip = ZipFile.Read(fileStream))
{
// -- Creo directorio
System.IO.Directory.CreateDirectory(appPath);
// -- Descomprimo
zip.ExtractAll(appPath);
}
// -- Actualizo el estado de subida
entity.Cargado = true;
Dalc.Update(entity);
#endregion
// -- Copiar archivos en
}
