protected void btnAddCycle_Click(object sender, EventArgs e)
{
int index = CycleDal.CycleIDCounts();
string sID = PageControl.GetGuid();
CycleEntity ote = new CycleEntity();
ote.CycleID = sID;
ote.CycleName = "TX";
ote.CycleDesc = "10分钟";
ote.CycleValue = 10;
ote.CycleNote = "分钟计算周期";
ote.CycleCreateTime = DateTime.Now.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss");
ote.CycleModifyTime = ote.CycleCreateTime;
if (CycleDal.Insert(ote))
{
//MessageBox.popupClientMessage(this.Page, "添加成功！", "call();");
}
else
{
MessageBox.popupClientMessage(this.Page, "添加错误！", "call();");
}
gvCycle.EditIndex = index;
BindGrid();
}
/// <summary>
/// Mapea un objeto CycleEntity en un objeto Cycle
/// incluyendo el turno,los horarios del turno y los cursos
/// </summary>
/// <param name="cycleEntity"></param>
/// <returns></returns>
public static Cycle MapIncludingCoursesAndSchedules(CycleEntity cycleEntity)
{
if (cycleEntity is null)
{
return(null);
}
else
{
return(new Cycle
{
Id = cycleEntity.Id,
Name = cycleEntity.Name,
Courses = cycleEntity.CourseEntities
.Select(co => new Course
{
Id = co.Id,
Year = co.Year
}).ToList(),
Shift = new Shift
{
Id = cycleEntity.ShiftEntity.Id,
Description = cycleEntity.ShiftEntity.Description,
Schedules = cycleEntity.ShiftEntity.ScheduleEntities.Select(s => new Schedule
{
Id = s.Id,
Start = s.Start.ToString(@"hh\:mm"),
End = s.End.ToString(@"hh\:mm"),
}).ToList()
}
});
}
}
public CycleEntity[] GetList(CycleEntity entity, int pageIndex, int pageSize, out int rowCount)
{
List <IWhereCondition> conditions = new List <IWhereCondition>();
if (!string.IsNullOrEmpty(entity.CycleName))
{
conditions.Add(new EqualsCondition()
{
FieldName = "CycleName", Value = entity.CycleName
});
}
conditions.Add(new EqualsCondition()
{
FieldName = "ClientID", Value = CurrentUserInfo.ClientID
});
conditions.Add(new EqualsCondition()
{
FieldName = "ClientDistributorID", Value = CurrentUserInfo.ClientDistributorID
});
List <OrderBy> orderbys = new List <OrderBy>();
orderbys.Add(new OrderBy()
{
FieldName = "CreateTime", Direction = OrderByDirections.Asc
});
PagedQueryResult <CycleEntity> pEntity = this._currentDAO.PagedQuery(conditions.ToArray(), orderbys.ToArray(), pageSize, pageIndex);
rowCount = pEntity.RowCount;
return(pEntity.Entities);
}
/// <summary>
/// Actualiza una entidad ciclo
/// </summary>
/// <param name="cycleId">
/// El id del ciclo
/// </param>
/// <exception cref="CycleNameDuplicateEntryException">
/// Lanza GradeNameDuplicateEntryException
/// si el nombre del ciclo ya existe en la base de datos
/// </exception>
/// <returns>
/// Retorna true
/// </returns>
public async Task <bool> Update(CycleEntity cycleEntity)
{
CycleEntity c = await this.Get(cycleEntity.Id);
try
{
c.Name = cycleEntity.Name;
c.ShiftEntity = cycleEntity.ShiftEntity;
await _dbContext.SaveChangesAsync();
_logger.LogInformation("El ciclo se ha actualizado correctamente");
}
catch (DbUpdateException ex)
{
//Si la base de datos lamza un error Unique Constraint por el campo "name"
if (ex.InnerException.Message.Contains("UQ_cycle_name"))
{
_logger.LogWarning("Error: El ciclo no se ha actualizado " +
"porque su nombre ya existe");
throw new CycleNameDuplicateEntryException();
}
//Por cualquier otra razón, se lanza la excepción
else
{
throw ex;
}
}
return(true);
}
/// <summary>
/// Inserta una entidad Ciclo llamando a un procedimiento
/// de la base de datos que:
/// -inserta el nuevo ciclo
/// -inserta un registro por cada uno de los cursos del ciclo
/// -retorna el id del ciclo insertado
/// </summary>
/// <param name="cycleEntity">
/// </param>
/// <exception cref="CycleNameDuplicateEntryException">
/// Lanza CycleNameDuplicateEntryException
/// si el nombre del ciclo ya existe en la base de datos
/// </exception>
/// <returns>
/// Retorna la misma entidad Ciclo con el id generado
/// </returns>
public async Task <CycleEntity> Save(CycleEntity cycleEntity)
{
DbCommand cmd = _dbContext.Database.GetDbConnection().CreateCommand();
try
{
var name = new MySqlParameter("@in_name", cycleEntity.Name);
var shiftId = new MySqlParameter("@in_shift_id", cycleEntity.ShiftEntity.Id);
var totalCourses = new MySqlParameter("@in_courses", cycleEntity.CourseEntities.Count);
var cycleId = new MySqlParameter("@out_cycle_id", SqlDbType.Int);
cycleId.Direction = ParameterDirection.Output;
cmd.CommandText = "insert_new_cyle";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add(name);
cmd.Parameters.Add(shiftId);
cmd.Parameters.Add(totalCourses);
cmd.Parameters.Add(cycleId);
//Al no usar entity framework para esta operacion,
//hay que abrir la conexión a la base de datos
if (cmd.Connection.State != ConnectionState.Open)
{
cmd.Connection.Open();
}
await cmd.ExecuteNonQueryAsync();
//Recupero el id del ciclo guarsado
int id = (int)cmd.Parameters["@out_cycle_id"].Value;
cmd.Connection.Close();
_logger.LogInformation("Nuevo ciclo guardado en la base datos con id: " + id);
cycleEntity.Id = id;
}
catch (DbException ex)
{
cmd.Connection.Close();
//Si la base de datos lamza un error Unique Constraint por el campo "name"
if (ex.InnerException.Message.Contains("UQ_cycle_name"))
{
_logger.LogWarning("El ciclo no se ha guardado " +
"porque su nombre ya existe");
throw new CycleNameDuplicateEntryException();
}
//Por cualquier otra razón, se lanza la excepción
else
{
throw ex;
}
}
return(cycleEntity);
}
/// <summary>
/// Actualiza un ciclo
/// </summary>
/// <param name="cycle">
/// El objeto Cycle con los nuevos datos del ciclo
/// </param>
/// <returns>
/// Retorna true
/// </returns>
public async Task <bool> Update(Cycle cycle)
{
CycleEntity cycleEntity = CycleMapper.Map(cycle);
bool result = await _cycleRepository.Update(cycleEntity);
return(result);
}
private string GetList(NameValueCollection rParams)
{
CycleEntity entity = rParams["form"].DeserializeJSONTo <CycleEntity>();
int pageSize = rParams["limit"].ToInt();
int pageIndex = rParams["page"].ToInt();
int rowCount = 0;
return(string.Format("{{\"totalCount\":{1},\"topics\":{0}}}",
new CycleBLL(CurrentUserInfo).GetList(entity, pageIndex, pageSize, out rowCount).ToJSON(),
rowCount));
}
/// <summary>
/// Crea un nuevo ciclo formativo
/// </summary>
/// <param name="cycle">
/// EL objeto Cycle que contiene los datos sobre el ciclo
/// </param>
/// <exception cref="GradeNameDuplicateEntryException">
/// Lanza GradeNameDuplicateEntryException
/// </exception>
/// <returns>
/// Retorna el objeto Cycle guardado con su id generado
/// </returns>
public async Task <Cycle> Save(Cycle cycle)//Throw GradeNameDuplicateEntryException
{
CycleEntity cycleEntity = CycleMapper.Map(cycle);
cycleEntity = await _cycleRepository.Save(cycleEntity);
cycleEntity = await _cycleRepository
.GetIncludingCoursesAndAssignedSubjects(cycleEntity.Id);
cycle = CycleMapper.MapIncludingCourses(cycleEntity);
return(cycle);
}
/// <summary>
/// Mapea un objeto CycleEntity en un objeto Cycle
/// </summary>
/// <param name="cycleEntity"></param>
/// <returns></returns>
public static Cycle Map(CycleEntity cycleEntity)
{
if (cycleEntity is null)
{
return(null);
}
else
{
return(new Cycle()
{
Id = cycleEntity.Id,
Name = cycleEntity.Name
});
}
}
/// <summary>
/// Mapea un objeto CycleEntity en un objeto Cycle
/// incluyendo el turno del ciclo, los cursos y las
/// asignaturas del los cursos
/// </summary>
/// <param name="cycleEntity"></param>
/// <returns></returns>
public static Cycle MapIncludingCourses(CycleEntity cycleEntity)
{
if (cycleEntity is null)
{
return(null);
}
else
{
return(new Cycle()
{
Id = cycleEntity.Id,
Name = cycleEntity.Name,
Courses = cycleEntity.CourseEntities.Select(c => CourseMapper
.MapIncludingSubjects(c)).ToList(),
Shift = ShiftMapper.Map(cycleEntity.ShiftEntity)
});
}
}
private string Edit(NameValueCollection rParams)
{
string res = "{success:false,msg:'编辑失败'}";
CycleEntity entity = new CycleEntity();
if (!string.IsNullOrEmpty(rParams["id"]))
{
entity = new CycleBLL(CurrentUserInfo).GetByID(rParams["id"]);
}
entity = DataLoader.LoadFrom <CycleEntity>(rParams, entity);
string selectedList = rParams["cycleDetail"];
entity.ClientID = Convert.ToInt32(CurrentUserInfo.ClientID);
entity.ClientDistributorID = Convert.ToInt32(CurrentUserInfo.ClientDistributorID);
new CycleBLL(CurrentUserInfo).Edit(entity, selectedList);
res = "{success:true,msg:'保存成功'}";
return(res);
}
protected void gvCycle_RowUpdating(object sender, GridViewUpdateEventArgs e)
{
string keyid = ((HtmlInputHidden)(gvCycle.Rows[e.RowIndex].Cells[0].FindControl("Cycleid"))).Value;
string eName = ((TextBox)(gvCycle.Rows[e.RowIndex].Cells[1].Controls[0])).Text.ToString().Trim().ToUpper();
string eDesc = ((TextBox)(gvCycle.Rows[e.RowIndex].Cells[2].Controls[0])).Text.ToString().Trim();
string eValue = ((TextBox)(gvCycle.Rows[e.RowIndex].Cells[3].Controls[0])).Text.ToString().Trim();
string eNote = ((TextBox)(gvCycle.Rows[e.RowIndex].Cells[4].Controls[0])).Text.ToString().Trim();
string msg = "";
if (eName == "")
{
msg += "名称不能为空！\r\n";
}
if (!Regex.IsMatch(eValue, "^[0-9]+$"))
{
msg += "周期只能为数字！\r\n";
}
if ((int.Parse(eValue) <= 60 && 60 % int.Parse(eValue) != 0) ||
(int.Parse(eValue) > 60 && int.Parse(eValue) % 60 != 0))
{
msg += "周期只能为分钟的倍数！\r\n";
}
if ((eName != "TN" || eName != "TD") && double.Parse(eValue) == 0)
{
msg += "除TN，TD外，计算周期不能为0";
}
if (msg != "")
{
MessageBox.popupClientMessage(this.Page, msg);
return;
}
if (CycleDal.CycleNameExists(eName, keyid))
{
MessageBox.popupClientMessage(this.Page, "该周期已存在！", "call();");
return;
}
CycleEntity mEntity = new CycleEntity();
mEntity.CycleID = keyid;
mEntity.CycleName = eName;
mEntity.CycleDesc = eDesc;
mEntity.CycleValue = int.Parse(eValue);
mEntity.CycleNote = eNote;
//mEntity.CycleCreateTime = DateTime.Now.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss");
mEntity.CycleModifyTime = DateTime.Now.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss");
if (!CycleDal.Update(mEntity))
{
MessageBox.popupClientMessage(this.Page, "编辑错误！", "call();");
}
else
{
MessageBox.popupClientMessage(this.Page, "编辑成功！", "call();");
gvCycle.EditIndex = -1;
BindGrid();
}
}
/// <summary>
/// 编辑周期信息
/// </summary>
public void Edit(CycleEntity entity, string selectedList)
{
bool isUpdate = false;
isUpdate = (entity.CycleID != null);
CycleDetailEntity[] oldDetailEntity = null;//数据库中的周期详细
if (isUpdate)
{
oldDetailEntity = new CycleDetailDAO(CurrentUserInfo).GetCycleDetailByCID(entity.CycleID.Value);
}
IDbTransaction tran = new TransactionHelper(this.CurrentUserInfo).CreateTransaction();
using (tran.Connection)
{
try
{
#region 周期
if (isUpdate)
{
this._currentDAO.Update(entity, tran);
}
else
{
this._currentDAO.Create(entity, tran);
}
#endregion
#region 周期详细
List <Guid> frontSelectedIDS = new List <Guid>(); //已有的ID
List <int> createList = new List <int>(); //新增的day
foreach (string id in
selectedList.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries))
{
Guid gid;
if (Guid.TryParse(id, out gid))
{
frontSelectedIDS.Add(gid);
}
else
{
createList.Add(int.Parse(id));
}
}
if (isUpdate)
{
//数据库已有id
IEnumerable <Guid> selectedIDS = oldDetailEntity.Select(x => x.CycleDetailID.Value);
//需要新增、删除的id
IEnumerable <Guid> deletedList = selectedIDS.Except(frontSelectedIDS);
//删除
foreach (Guid id in deletedList)
{
Guid detailID = oldDetailEntity.Where(x => x.CycleDetailID == id).Select(x => x.CycleDetailID.Value).ToList()[0];
new CycleDetailBLL(CurrentUserInfo).Delete(detailID, tran);
}
//新增
foreach (int day in createList)
{
CycleDetailEntity detailEntity = new CycleDetailEntity();
detailEntity.CycleID = entity.CycleID;
detailEntity.DayOrder = detailEntity.DayOfCycle = day;
detailEntity.ClientID = Convert.ToInt32(CurrentUserInfo.ClientID);
detailEntity.ClientDistributorID = Convert.ToInt32(CurrentUserInfo.ClientDistributorID);
new CycleDetailDAO(CurrentUserInfo).Create(detailEntity, tran);
}
}
else
{
//新增
foreach (int day in createList)
{
CycleDetailEntity detailEntity = new CycleDetailEntity();
detailEntity.CycleID = entity.CycleID;
detailEntity.DayOrder = detailEntity.DayOfCycle = day;
detailEntity.ClientID = Convert.ToInt32(CurrentUserInfo.ClientID);
detailEntity.ClientDistributorID = Convert.ToInt32(CurrentUserInfo.ClientDistributorID);
new CycleDetailDAO(CurrentUserInfo).Create(detailEntity, tran);
}
}
#endregion
tran.Commit();
}
catch
{
tran.Rollback();
throw;
}
}
}
