private void AvoidSummaryData(string overtime, double?getudoyyyymm)
{
if (getudoyyyymm == null)
{
return;
}
var o = new OverTime();
var timespan_overtime = o.ConvertDispOverTime(overtime);
int i = 0;
if (int.TryParse(overtime.Replace(":", ""), out i))
{
i = i / 100;
}
foreach (var item in this.SummaryAttendance)
{
if (item.GetudoYYYYMM == (int)getudoyyyymm)
{
item.OverTime = timespan_overtime;
item.Is45Over = i >= 45;
item.Is80Over = i >= 80;
return;
}
}
var record = new SummaryAttendanceData();
record.GetudoYYYYMM = (int)getudoyyyymm;
record.OverTime = timespan_overtime;
record.Is45Over = i >= 45;
record.Is80Over = i >= 80;
return;
}
/// <summary>
/// کلیه سرانه های اضافه کار تشویقی, شب کاری تشویقی, تعطیل کار تشویقی را بر می گرداند
/// بر اساس دسترسی کاربر به دپارتمان
/// </summary>
/// <returns>لیست پروکسی سرانه</returns>
public override IList <OverTimeDetail> GetAll()
{
OverTime overTimeAlias = null;
OverTimeDetail overTimeDetailAlias = null;
Department departmentAlias = null;
IList <OverTimeDetail> list = new List <OverTimeDetail>();
IList <decimal> accessableIDs = accessPort.GetAccessibleDeparments();
if (accessableIDs.Count < this.operationBatchSizeValue && this.operationBatchSizeValue < 2100)
{
list = NHSession.QueryOver(() => overTimeDetailAlias)
.JoinAlias(() => overTimeDetailAlias.OverTime, () => overTimeAlias)
.JoinAlias(() => overTimeDetailAlias.Department, () => departmentAlias)
.Where(() => departmentAlias.ID.IsIn(accessableIDs.ToList()) && overTimeAlias.IsActive == true)
.List <OverTimeDetail>();
}
else
{
GTS.Clock.Model.Temp.Temp tempAlias = null;
string operationGUID = this.bTemp.InsertTempList(accessableIDs);
list = NHSession.QueryOver(() => overTimeDetailAlias)
.JoinAlias(() => overTimeDetailAlias.OverTime, () => overTimeAlias)
.JoinAlias(() => overTimeDetailAlias.Department, () => departmentAlias)
.JoinAlias(() => departmentAlias.TempList, () => tempAlias)
.Where(() => tempAlias.OperationGUID == operationGUID && overTimeAlias.IsActive == true)
.List <OverTimeDetail>();
this.bTemp.DeleteTempList(operationGUID);
}
return(list);
}
private void RenderOverTime(OverTime overTime)
{
var item = new ListViewItem(overTime.ID.ToString());
item.SubItems.Add(overTime.EmployeeId.ToString());
item.SubItems.Add(overTime.Employee.EmployeeCode);
item.SubItems.Add(overTime.Employee.EmployeeName);
item.SubItems.Add(overTime.OverTimeDate.ToString("dd/MM/yyyy"));
if (overTime.DayType == 0)
{
item.SubItems.Add("Kerja");
}
else
{
item.SubItems.Add("Libur");
}
item.SubItems.Add(overTime.StartHour);
item.SubItems.Add(overTime.EndHour);
item.SubItems.Add(overTime.Amount.ToString("N0").Replace(",", "."));
lvwData.Items.Add(item);
}
public void Update(OverTime overTime)
{
try
{
using (var em = EntityManagerFactory.CreateInstance(ds))
{
string[] fields = { "MonthPeriod", "YearPeriod", "EmployeeId",
"Branch", "Department", "IsIncludePayroll","IsPaid",
"DayType", "OverTimeDate", "StartHour", "EndHour", "TotalInMinute","TotalInHour",
"Amount", "AmountInWords", "Notes", "CreatedDate", "CreatedBy", "ModifiedDate", "ModifiedBy" };
object[] values = { overTime.MonthPeriod, overTime.YearPeriod, overTime.EmployeeId,
overTime.Branch, overTime.Department,
overTime.IsIncludePayroll == true?1:0, overTime.IsPaid == true?1:0,
overTime.DayType, overTime.OverTimeDate.ToShortDateString(),
overTime.StartHour, overTime.EndHour, overTime.TotalInMinute,overTime.TotalInHour,
overTime.Amount, overTime.AmountInWords,
overTime.Notes, DateTime.Now.ToShortDateString(), Store.ActiveUser, DateTime.Now.ToShortDateString(), Store.ActiveUser };
Query q = new Query().Select(fields).From(tableName).Update(values)
.Where("ID").Equal("{" + overTime.ID + "}");
em.ExecuteNonQuery(q.ToSql());
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 根据申请编号返回加班申请记录
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static OverTime GetOverTimeByID(int id)
{
SqlConnection conn = new SqlConnection(connString);
SqlCommand cmd = new SqlCommand("SELECT * FROM [OverTimes] WHERE [ApplyID] = @ApplyID", conn);
cmd.Parameters.Add("@ApplyID", SqlDbType.Int).Value = id;
conn.Open();
SqlDataReader sdr = cmd.ExecuteReader();
OverTime oi = null;
if (sdr.Read())
{
oi = new OverTime();
oi.staffName = (string)sdr["StaffName"];
oi.department = (string)sdr["Department"];
oi.applyDate = Convert.ToDateTime(sdr["ApplyDate"]);
oi.startDate = Convert.ToDateTime(sdr["StartDate"]);
oi.endDate = Convert.ToDateTime(sdr["EndDate"]);
oi.reason = (string)sdr["Reason"];
oi.ApproveProcess = sdr["ApproveProcess"] == DBNull.Value ? "" : (string)sdr["ApproveProcess"];
}
sdr.Close();
conn.Close();
return(oi);
}
public ActionResult SaveOverTime(OverTime overTime)
{
SaveOverTimeControl uco = new SaveOverTimeControl();
overTime = uco.Save(overTime);
return(View("NewOverTime", overTime));
}
public BedroomState[] states; //The states of the bedroom stored by thier state values.
protected override void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
base.OnSceneLoaded(scene, mode);
ConfigureBedroom();
StartCoroutine(OverTime.ChangeOpacity(fadeImage, 255f, 0f, fadeDuration, null));
}
//查询通过审批的所有申请单
public static DataTable getAllOtPass()
{
Query q = OverTime.Query();
q.AddWhere(OverTime.Columns.IsSubmit, "通过");
return(q.ExecuteDataSet().Tables[0]);
}
protected virtual OverTime GetOverTimeFromReader(IDataReader reader)
{
EntityConverter <OverTime> overTimeEntity = new EntityConverter <OverTime>();
OverTime codeMasterOverTime = overTimeEntity.Convert(reader);
return(codeMasterOverTime);
}
public static DataTable getOverTime(string emName)
{
Query q = OverTime.Query();
q.AddWhere(OverTime.Columns.ApplyEmName, emName);
return(q.ExecuteDataSet().Tables[0]);
}
/// <summary>
/// تایید اضافه کار تشویقی یک دوره(ماه) توسط اداری جهت پرداخت
/// </summary>
/// <param name="year">سال</param>
/// <param name="month">ماه</param>
/// <returns>شناسه رکورد</returns>
public decimal ApproveOverTime(int year, int month)
{
DateTime date;
if (BLanguage.CurrentSystemLanguage == LanguagesName.Parsi)
{
date = Utility.ToMildiDate(String.Format("{0}/{1}/{2}", year, month, 1));
}
else
{
date = new DateTime(year, month, 1);
}
//-----------------------------------------------------------------------
OverTime overTime = this.GetPeriodByDate(date);
overTime.ApprovedDate = DateTime.Now;
overTime.IsApproved = true;
//این دوره هنوز در دیتابیس تعریف نشده
if (overTime == null)
{
return(0);
}
//قبلا تایید شده
if (overTime.IsApproved == true)
{
return(0);
}
overTime = overTimeRepository.Update(overTime);
return(overTime.ID);
}
//数据持久化
internal static void SaveToDb(OverTimeInfo pOverTimeInfo, OverTime pOverTime, bool pIsNew)
{
pOverTime.OverTimeId = pOverTimeInfo.overTimeId;
pOverTime.ApplyDate = pOverTimeInfo.applyDate;
pOverTime.TimeFrom = pOverTimeInfo.timeFrom;
pOverTime.TimeTo = pOverTimeInfo.timeTo;
pOverTime.ApplyEmName = pOverTimeInfo.applyEmName;
pOverTime.Reason = pOverTimeInfo.reason;
pOverTime.IsSubmit = pOverTimeInfo.isSubmit;
pOverTime.TimeSpan = pOverTimeInfo.timeSpan;
pOverTime.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pOverTime.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(OverTimeInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pOverTimeInfo.overTimeId = pOverTime.OverTimeId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(OverTimeInfo)))
{
ResetCache();
}
}
/// <summary>
/// 获得分页列表,无论是否是缓存实体都从数据库直接拿取数据
/// </summary>
/// <param name="pPageIndex">页数</param>
/// <param name="pPageSize">每页列表</param>
/// <param name="pOrderBy">排序</param>
/// <param name="pSortExpression">排序字段</param>
/// <param name="pRecordCount">列表行数</param>
/// <returns>数据分页</returns>
public static List <OverTimeInfo> GetPagedList(int pPageIndex, int pPageSize, SortDirection pOrderBy, string pSortExpression, out int pRecordCount)
{
if (pPageIndex <= 1)
{
pPageIndex = 1;
}
List <OverTimeInfo> list = new List <OverTimeInfo>();
Query q = OverTime.CreateQuery();
q.PageIndex = pPageIndex;
q.PageSize = pPageSize;
q.ORDER_BY(pSortExpression, pOrderBy.ToString());
OverTimeCollection collection = new OverTimeCollection();
collection.LoadAndCloseReader(q.ExecuteReader());
foreach (OverTime overTime in collection)
{
OverTimeInfo overTimeInfo = new OverTimeInfo();
LoadFromDAL(overTimeInfo, overTime);
list.Add(overTimeInfo);
}
pRecordCount = q.GetRecordCount();
return(list);
}
public async Task <IActionResult> Create([Bind("Id,OTDate,OTStartTime,OTEndTime,Status,ApprovedDate,OTTime,Year,FromEmployeeInfoId,ToEmployeeInfoId")] OverTimeViewModel overTime)
{
if (ModelState.IsValid)
{
OverTime ot = new OverTime()
{
OTDate = overTime.OTDate,
OTStartTime = overTime.OTStartTime,
OTEndTime = overTime.OTEndTime,
Status = overTime.Status,
ApprovedDate = overTime.ApprovedDate,
OTTime = overTime.OTTime,
Year = overTime.Year,
FromEmployeeInfoId = overTime.FromEmployeeInfoId,
ToEmployeeInfoId = overTime.ToEmployeeInfoId
};
//_context.Add(overTime);
//await _context.SaveChangesAsync();
await overTimeRepository.Save(ot);
return(RedirectToAction(nameof(Index)));
}
ViewData["FromEmployeeInfoId"] = new SelectList(employeeInfoRepository.GetEmployeeInfoList(), "Id", "Id", overTime.FromEmployeeInfoId);
ViewData["ToEmployeeInfoId"] = new SelectList(employeeInfoRepository.GetEmployeeInfoList(), "Id", "Id", overTime.ToEmployeeInfoId);
return(View(overTime));
}
public async Task <IActionResult> Edit(long id, [Bind("Id,OTDate,OTStartTime,OTEndTime,Status,ApprovedDate,OTTime,Year,FromEmployeeInfoId,ToEmployeeInfoId")] OverTime overTime)
{
if (id != overTime.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
//_context.Update(overTime);
//await _context.SaveChangesAsync();
await overTimeRepository.Update(overTime);
}
catch (DbUpdateConcurrencyException)
{
if (!OverTimeExists(overTime.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FromEmployeeInfoId"] = new SelectList(employeeInfoRepository.GetEmployeeInfoList(), "Id", "Id", overTime.FromEmployeeInfoId);
ViewData["ToEmployeeInfoId"] = new SelectList(employeeInfoRepository.GetEmployeeInfoList(), "Id", "Id", overTime.ToEmployeeInfoId);
return(View(overTime));
}
private void ViewOverTimeDetail(OverTime overTime)
{
txtID.Text = overTime.ID.ToString();
txtEmployeeId.Text = overTime.EmployeeId.ToString();
txtCode.Text = overTime.Employee.EmployeeCode;;
txtName.Text = overTime.Employee.EmployeeName;
dtpDate.Text = overTime.OverTimeDate.ToShortDateString();
if (overTime.DayType == 0)
{
optWorkDay.Checked = true;
}
else
{
optHoliday.Checked = true;
}
string[] startHour = overTime.StartHour.Split(':');
string[] endHour = overTime.EndHour.Split(':');
txtStartHour.Text = startHour[0];
txtStartMinute.Text = startHour[1];
txtEndHour.Text = endHour[0];
txtEndMinute.Text = endHour[1];
lblTotalHour.Text = overTime.TotalInHour;
txtNotes.Text = overTime.Notes;
}
public OverTime Save(OverTime overTime)
{
if (overTime != null)
{
overTime.OverTimeID = "OT0001";
}
return(overTime);
}
/**
* Lower and hide the pillar.
*/
public void Hide()
{
if (hidden)
{
return; //No point in hiding a pillar that is already hidden.
}
StartCoroutine(OverTime.Translate(transform, new Vector3(0, hiddenYDifference, 0), duration, AfterAnimation));
}
/**
* Raise and show the pillar.
*/
public void Show()
{
if (!hidden)
{
return; //No point in showing a pillar that is already being shown.
}
StartCoroutine(OverTime.Translate(transform, new Vector3(0, hiddenYDifference * -1, 0), duration, AfterAnimation));
}
public void OverTimeIsComparableByValue()
{
var overTimeOne = new OverTime(3);
var overtimeTwo = new OverTime(3);
Assert.AreEqual(overTimeOne, overtimeTwo);
Assert.IsTrue(overTimeOne == overtimeTwo);
}
public ActionResult NewOverTime()
{
OverTimeBuilder builder = new OverTimeBuilder();
EOfficeDirector <OverTime> director = new EOfficeDirector <OverTime>();
OverTime form = director.Construct(builder);
return(View(form));
}
public static DataTable getAllApproveOvertime()
{
Query q = OverTime.Query();
q.AddWhere(OverTime.Columns.IsSubmit, "待审");
q.OR(OverTime.Columns.IsSubmit, "通过");
q.OR(OverTime.Columns.IsSubmit, "未通过");
return(q.ExecuteDataSet().Tables[0]);
}
/// <summary>
/// آبجکت دوره بودجه رو بر اساس کلید اصلی بر می گرداند
/// </summary>
/// <param name="Id">کلید اصلی</param>
/// <returns>آبجکت دوره بودجه</returns>
public OverTime GetPeriodById(decimal Id)
{
OverTime overTimeAlias = null;
OverTime item = NHSession.QueryOver(() => overTimeAlias)
.Where(() => overTimeAlias.ID == Id)
.List <OverTime>().SingleOrDefault();
return(item);
}
public void OnMouseDown()
{
//Rotate the cube and call the cube turned event.
rotating = true;
GetComponent <AudioSource> ().Play();
StartCoroutine(OverTime.Rotate(transform, new Vector3(-90, 0, 0), rotationDuration, AfterRotate));
}
/// <summary>
/// آبجکت دوره بودجه رو بر اساس تاریخ بر می گرداند
/// </summary>
/// <param name="date">تاریخ</param>
/// <returns>آبجکت دوره بودجه</returns>
public OverTime GetPeriodByDate(DateTime date)
{
OverTime overTimeAlias = null;
OverTime item = NHSession.QueryOver(() => overTimeAlias)
.Where(() => overTimeAlias.Date == date)
.List <OverTime>().SingleOrDefault();
return(item);
}
private void GetOverTimeById(Guid id)
{
OverTime overTime = overTimeRepository.GetById(id);
if (overTime != null)
{
ViewOverTimeDetail(overTime);
}
}
private void GetLastOverTime()
{
OverTime overTime = overTimeRepository.GetLast(Store.ActiveMonth, Store.ActiveYear);
if (overTime != null)
{
ViewOverTimeDetail(overTime);
}
}
public void testNewOverTime()
{
OverTimeBuilder builder = new OverTimeBuilder();
EOfficeDirector <OverTime> director = new EOfficeDirector <OverTime>();
OverTime actual = director.Construct(builder);
OverTime expected = new OverTime();
expected.ToExpectedObject().ShouldEqual(actual);
}
public void OverTimeWorksWithHashSet()
{
var overTimeOne = new OverTime(3);
var overtimeTwo = new OverTime(3);
var overTimeHashSet = new HashSet <OverTime>();
overTimeHashSet.Add(overTimeOne);
overTimeHashSet.Add(overtimeTwo);
Assert.IsTrue(overTimeHashSet.Count == 1);
}
public bool DeleteOverTime(int id)
{
using (ApplicationDbContext ctx = new ApplicationDbContext())
{
OverTime entity = ctx.OverTimeDays.SingleOrDefault(e => e.OTId == id);
ctx.OverTimeDays.Remove(entity);
return(ctx.SaveChanges() == 1);
}
}
/// <summary>
/// 保存
/// </summary>
public override void Save()
{
if(!m_Loaded)//新增
{
OverTime overTime=new OverTime();
SaveToDb(this, overTime,true);
}
else//修改
{
OverTime overTime=new OverTime(overTimeId);
if(overTime.IsNew)
throw new AppException("该数据已经不存在了");
SaveToDb(this, overTime,false);
}
}
//数据持久化
internal static void SaveToDb(OverTimeInfo pOverTimeInfo, OverTime pOverTime,bool pIsNew)
{
pOverTime.OverTimeId = pOverTimeInfo.overTimeId;
pOverTime.ApplyDate = pOverTimeInfo.applyDate;
pOverTime.TimeFrom = pOverTimeInfo.timeFrom;
pOverTime.TimeTo = pOverTimeInfo.timeTo;
pOverTime.ApplyEmName = pOverTimeInfo.applyEmName;
pOverTime.Reason = pOverTimeInfo.reason;
pOverTime.IsSubmit = pOverTimeInfo.isSubmit;
pOverTime.TimeSpan = pOverTimeInfo.timeSpan;
pOverTime.IsNew=pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pOverTime.Save(UserName);
}
catch(Exception ex)
{
LogManager.getInstance().getLogger(typeof(OverTimeInfo)).Error(ex);
if(ex.Message.Contains("插入重复键"))//违反了唯一键
{
throw new AppException("此对象已经存在");//此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pOverTimeInfo.overTimeId = pOverTime.OverTimeId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(OverTimeInfo)))
{
ResetCache();
}
}
/// <summary>
/// OverTimeApplication
/// </summary>
/// <param name="date"></param>
/// <param name="hours"></param>
/// <param name="userID"></param>
/// <returns></returns>
public bool OverTimeApplication(DateTime date, int hours, string userID)
{
OverTime overTime = new OverTime();
overTime.OverTimeGuid = Guid.NewGuid();
overTime.UserID = userID;
overTime.OnDate = date;
overTime.Hours = hours;
overTime.Status = "Ask";
db.OverTimes.Add(overTime);
var user = db.Users.FirstOrDefault(o => o.UserID == userID);
StringBuilder email = new StringBuilder();
string hourstr = " hours";
if (overTime.Hours == 1)
hourstr = " hour";
hourstr = overTime.Hours.ToString() + hourstr;
//email.Append("Hi Yemol, <br/><br/>");
email.AppendFormat("I am going to overtime {0} hours at {1}.", hourstr, overTime.OnDate.ToShortDateString());
email.AppendFormat(" Could you please approve it?");//<br/><br/>Thanks,<br/><br/><br/>{0}", user.UserName);
t_AlertUser alert = new t_AlertUser();
alert.ABID = 1;
alert.UserID = "yemol";
alert.AUTitle = user.UserName + " OverTime Application";
alert.AUContent = email.ToString();
alert.AUType = 0;
alert.AUStatus = 1;
alert.AUInterval = 0;
alert.AUUnitNum = 0;
alert.AUTime = DateTime.Now;
alert.CreateBy = userID;
alert.CreateDate = DateTime.Now;
db.t_AlertUser.Add(alert);
try
{
db.SaveChanges();
}
catch
{
return false;
}
return true;
}
private void LoadFromId(int overTimeId)
{
if (CachedEntityCommander.IsTypeRegistered(typeof(OverTimeInfo)))
{
OverTimeInfo overTimeInfo=Find(GetList(), overTimeId);
if(overTimeInfo==null)
throw new AppException("未能在缓存中找到相应的键值对象");
Copy(overTimeInfo, this);
}
else
{ OverTime overTime=new OverTime( overTimeId);
if(overTime.IsNew)
throw new AppException("尚未初始化");
LoadFromDAL(this, overTime);
}
}
//从后台获取数据
internal static void LoadFromDAL(OverTimeInfo pOverTimeInfo, OverTime pOverTime)
{
pOverTimeInfo.overTimeId = pOverTime.OverTimeId;
pOverTimeInfo.applyDate = pOverTime.ApplyDate;
pOverTimeInfo.timeFrom = pOverTime.TimeFrom;
pOverTimeInfo.timeTo = pOverTime.TimeTo;
pOverTimeInfo.applyEmName = pOverTime.ApplyEmName;
pOverTimeInfo.reason = pOverTime.Reason;
pOverTimeInfo.isSubmit = pOverTime.IsSubmit;
pOverTimeInfo.timeSpan = pOverTime.TimeSpan;
pOverTimeInfo.Loaded=true;
}
