考勤报表生成

最新推荐文章于 2024-09-30 10:07:26 发布
最新推荐文章于 2024-09-30 10:07:26 发布
阅读量393 收藏 2
点赞数
文章标签： ui 数据库 数据结构与算法

需要：根据原始打卡记录生成考勤报表

配置：

       班次-> 由开始时间点，结束时间点， 开始时间区间，结束时间区间组成

       考勤检查方案->由多个班次组成,（属于这个考勤检查方案的人员使用这些班次规则进行统计）

业务:一天多个班次的需要考虑班次之间的连续打卡情况（允许），两次打卡时间间隔需要大于3分钟

代码:

      1.加载前一天全部打卡记录,按时间排序后，过滤掉短时间内的重复打卡记录

      2.遍历每个考勤检测方案。

      2.1.加载该方案下的全部人员，加载员工的当天的全部打卡记录，对方案内的班次配置与员工的打卡记录进行匹配

      2.2.班次间的连续打卡问题需要前溯或后溯进行处理

      2.3.根据匹配情况形成报表

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.OleDb;
using System.Collections;
using F.Studio.Util;
namespace Checking_In.UI
{
    public partial class frmMain : Form
    {

        #region Excel相关操作
        const string C_ExcelConnTmp = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source= {0};Extended Properties='Excel 8.0;HDR=YES;IMEX=1';";
        public string ExcelFile
        {
            get { return @"E:\Net\HR_KQ\9月质量部.xls"; }
        }
        public string Sheet
        {
            get
            {
                return "9月质量部$";
            }
        }
        public string ExcelConnectString
        {
            get
            {
                return string.Format(C_ExcelConnTmp, ExcelFile);
            }
        }

        public new List<TableInfo> Tables
        {
            get;
            private set;
        }
        public ArrayList ExcelSheetName()
        {
            ArrayList al = new ArrayList();
            string strConn;
            strConn = ExcelConnectString;
            OleDbConnection conn = new OleDbConnection(strConn);
            conn.Open();
            DataTable sheetNames = conn.GetOleDbSchemaTable
            (System.Data.OleDb.OleDbSchemaGuid.Tables, new object[] { null, null, null, "TABLE" });
            conn.Close();
            foreach (DataRow dr in sheetNames.Rows)
            {
                al.Add(dr[2]);
            }
            return al;
        }  
        private void LoadExcelTableInfo()
        {

            Tables = new List<TableInfo>();

            var ds = LoadExcelData();

            TableInfo curTable = null;
            for (int i = 1; i < ds.Tables[0].Rows.Count; i++)
            {
                DataRow dr = ds.Tables[0].Rows[i];
                if (string.IsNullOrWhiteSpace(dr["新加"].ToString()))//空表示表信息
                {
                    curTable = new TableInfo();
                    curTable.Name = dr["F2"].ToString().Trim();
                    curTable.Code = dr["p_bs"].ToString().Trim();

                    Tables.Add(curTable);
                    continue;

                }
                var column = new ColumnInfo();
                column.Code = dr["新加"].ToString().Trim();
                string tmp = dr["删除"].ToString();
                if (!string.IsNullOrWhiteSpace(tmp))
                {
                    column.Name = tmp.Trim().Split(" ".ToArray(), StringSplitOptions.RemoveEmptyEntries)[0];
                    column.Comment = tmp.Trim();
                    if (column.Name.Length >= 10)
                    {
                        column.Name = column.Name.Substring(0, 10);
                    }
                    column.NeedSync = true;
                }
                curTable.Columns.Add(column);
            }

        }
        private DataSet LoadExcelData()
        {
            DataSet dsExcelSheet = new DataSet();

            //打开并读取Excel表信息
            OleDbConnection connExecel = new OleDbConnection(ExcelConnectString);
            OleDbDataAdapter dpQualityLevel = new OleDbDataAdapter("SELECT * FROM [" + Sheet + "]", connExecel);

            connExecel.Open();

            dpQualityLevel.Fill(dsExcelSheet);
            connExecel.Close();

            return dsExcelSheet;
        }
        #region Class
        public class TableInfo
        {
            public TableInfo()
            {
                Columns = new List<ColumnInfo>();
            }
            public string Name { get; set; }
            public string Code { get; set; }
            public List<ColumnInfo> Columns { get; set; }

        }
        public class ColumnInfo
        {
            public string Name { get; set; }
            public string Code { get; set; }
            public string Comment { get; set; }
            /// <summary>
            /// 是否需要同步
            /// </summary>
            public bool NeedSync { get; set; }
        }
        #endregion
        #endregion

        private List<CheckingRule> CheckingRules = new List<CheckingRule>();
        private List<ShiftInfo> ShiftList = new List<ShiftInfo>();
        private List< CheckingInfo> CheckingRecords=null;
        private List<EmpInfo> Emps = new List<EmpInfo>();
        private List<DateTime> Days = new List<DateTime>();
        private List<CheckingRstInfo> Rpt = new List<CheckingRstInfo>();
        public frmMain()
        {
            InitializeComponent();

            #region 上班时间配置配置
            ShiftList.Add(
                new ShiftInfo(){
                    InRule=new CheckingRule() { CheckPoint = "07:00", CheckType = 1, RangBegin = "00:00", RangEnd = "09:00",Title="质量上午进" },
                    OutRule=new CheckingRule() { CheckPoint = "11:00", CheckType = 2, RangBegin = "09:00", RangEnd = "12:00", Title = "质量上午出" },
                    Name="质量早班"
                });
            ShiftList.Add(
                new ShiftInfo(){
                    InRule=new CheckingRule() { CheckPoint = "13:00", CheckType = 1, RangBegin = "12:00", RangEnd = "15:30", Title = "质量下午进" },
                    OutRule=new CheckingRule() { CheckPoint = "17:00", CheckType = 2, RangBegin = "15:30", RangEnd = "17:30", Title = "质量下午出" },
                    Name="质量中班"
                });
            ShiftList.Add(
               new ShiftInfo()
               {
                   InRule = new CheckingRule() { CheckPoint = "18:00", CheckType = 1, RangBegin = "17:30", RangEnd = "19:30", Title = "质量晚上进" },
                   OutRule = new CheckingRule() { CheckPoint = "21:00", CheckType = 2, RangBegin = "19:30", RangEnd = "23:59", Title = "质量晚上出" },
                   Name = "质量晚班"
               });

            #endregion
        }

        private void  LoadData()
        {
            var ds = LoadExcelData();
            var list=new List< CheckingInfo>();
            var index = 0;
            foreach (DataRow item in ds.Tables[0].Rows)
            {
                index++;
                DateTime addtime;
                var dtStr = item["日期时间"].ToString();
                if (!DateTime.TryParse(dtStr, out addtime))
                {
                    Console.WriteLine("异常记录!"+index);
                    continue;
                }

                var it=new CheckingInfo();
                it.Dept = item["部门"].ToString();
                it.EmpNo = item["编号"].ToString();
                it.Name = item["姓名"].ToString();
                it.AddTime = addtime;
                it.RawAddTime = addtime;
                it.MachineNo = item["机器号"].ToString();
                it.CheckType = item["比对方式"].ToString();
                list.Add(it);
            }

            #region 排除间隔过短的记录
            //时间 2分钟
            int count = 0;
            int intervalSeconds = 1800;
            list = list.OrderBy(ent => ent.AddTime).ToList();
            for (int i = 0; i < list.Count;i++ )
            {
                var it = list[i];
                if (it.DelFlag) continue;
                for (var j = i + 1; j < list.Count; j++)
                {
                    
                    var next = list[j];
                    if (next.DelFlag)continue;
                    if( (next.AddTime - it.AddTime).TotalSeconds >intervalSeconds)break;
                    if (next.EmpNo==it.EmpNo)
                    {
                        next.DelFlag = true;
                        Console.WriteLine(next.Name + "," + next.AddTime + "," + next.EmpNo);
                        count++;
                    }
                }
            }
            Console.WriteLine(count);
            
            #endregion
            CheckingRecords =list.Where(ent=>ent.DelFlag==false).OrderBy(ent=>ent.AddTime).ToList();
        }
        private void ExtractEmpAndDate()
        {

            var list = CheckingRecords.GroupBy(ent => ent.EmpNo).ToList();
            foreach (var it in list)
            {
                var emp=new EmpInfo();
                emp.EmpNo = it.Key;
                emp.Name = it.FirstOrDefault().Name;
                emp.Dept = it.FirstOrDefault().Dept;
                Emps.Add(emp);
            }
            var list2 = CheckingRecords.GroupBy(ent => ent.AddTime.Date);
            foreach(var it in list2)
            {
                Days.Add(it.Key);
            }
            Days=  Days.OrderBy(ent => ent.Date).ToList();

        }

        private void Analyze()
        {
            var rpts = new List<CheckingRstInfo>();

            foreach (var day in Days)
            {
                foreach (var emp in Emps)
                {
                   var checklist=  CheckingRecords.Where(ent => ent.AddTime >= day && ent.AddTime <= day.AddHours(23.999) && ent.EmpNo == emp.EmpNo).OrderBy(ent => ent.AddTime).ToList();

                    for(int index=0;index< ShiftList.Count;index++)
                    {
                        var shift=ShiftList[index];
                      #region 按配置进行分析
                
                       var rpt = new CheckingRstInfo() {
                           Date=day,Dept=emp.Dept,EmpNo=emp.EmpNo,
                           ShowInReport=false,Name=emp.Name,
                           IsAbsenteeism=false,InTime="",OutTime="" };
                       rpts.Add(rpt);

                  
                       rpt.RuleTitle = shift.Name;
                      

                       foreach (var rule in new List<CheckingRule>() { shift.InRule, shift.OutRule })
                       {
                           #region 上下班检测
                           DateTime eventTime;
                           var btime = rule.GetTime(day, rule.RangBegin);
                           var etime = rule.GetTime(day, rule.RangEnd);
                           var ptime = rule.GetTime(day, rule.CheckPoint);
                           if (rule.CheckType == 1)//上班
                           {
                               var inTimeList = checklist.Where(ent => ent.AddTime > btime && ent.AddTime <= etime).ToList();
                               if (inTimeList.Count <= 0)
                               {
                                   #region 向前寻找
                                   if (index == 1)
                                   {
                                       var prevTime = rule.GetTime(day, ShiftList[0].OutRule.CheckPoint);
                                       var lista = checklist.Where(ent => ent.AddTime > prevTime && ent.AddTime <= etime).ToList();
                                       if (lista.Count >= 2)
                                       {
                                           var item = lista.OrderBy(ent => ent.AddTime).ToList().LastOrDefault();
                                           inTimeList.Add(item);
                                           checklist.Remove(item);
                                       }
                                   }
                                   else if (index == 2)
                                   {
                                       var prevTime = rule.GetTime(day, ShiftList[1].OutRule.CheckPoint);
                                       var lista = checklist.Where(ent => ent.AddTime > prevTime && ent.AddTime <= etime).ToList();
                                       if (lista.Count >= 2)
                                       {
                                           var item = lista.OrderBy(ent => ent.AddTime).ToList().LastOrDefault();
                                           inTimeList.Add(item);
                                           checklist.Remove(item);
                                       }
                                   }
                                   #endregion
                                   if (inTimeList.Count <= 0)
                                   {
                                       rpt.ShowInReport = true;
                                       rpt.IsAbsenteeism = true;
                                       continue;
                                   }
                               }
                               eventTime = inTimeList.Min(ent => ent.AddTime);
                               rpt.InTime = eventTime.ToString("yyyy-MM-dd HH:mm:ss");
                               var lateMinute = (eventTime - ptime).TotalMinutes;
                               if (lateMinute >= 1)
                               {
                                   rpt.LateMinute = (int)lateMinute;
                                   rpt.ShowInReport = true;
                               }
                           }
                           else if (rule.CheckType == 2)//下班
                           {
                               var outTimeList = checklist.Where(ent => ent.AddTime > btime && ent.AddTime <= etime).ToList();
                               if (outTimeList.Count() <= 0)
                               {
                                   #region 向后寻找
                                   if (index == 0 && ShiftList.Count >= 2)
                                   {
                                       var nextTime = rule.GetTime(day, ShiftList[1].InRule.CheckPoint);
                                       var lista = checklist.Where(ent => ent.AddTime > btime && ent.AddTime <= nextTime).ToList();
                                       if (lista.Count >= 2)
                                       {
                                           var item = lista.OrderBy(ent => ent.AddTime).ToList().FirstOrDefault();
                                           outTimeList.Add(item);
                                           checklist.Remove(item);
                                       }
                                   }
                                   else if (index == 1 && ShiftList.Count >= 3)
                                   {
                                       var nextTime = rule.GetTime(day, ShiftList[2].InRule.CheckPoint);
                                       var lista = checklist.Where(ent => ent.AddTime > btime && ent.AddTime <= nextTime).ToList();
                                       if (lista.Count >= 2)
                                       {
                                           var item = lista.OrderBy(ent => ent.AddTime).ToList().FirstOrDefault();
                                           outTimeList.Add(item);
                                           checklist.Remove(item);
                                       }
                                   }
                                   #endregion
                                   if (outTimeList.Count <= 0)
                                   {
                                       rpt.ShowInReport = true;
                                       rpt.IsAbsenteeism = true;
                                       continue;
                                   }
                               }
                               eventTime = outTimeList.Min(ent => ent.AddTime);
                               rpt.OutTime = eventTime.ToString("yyyy-MM-dd HH:mm:ss");
                               var leaveEarlyMinute = (ptime - eventTime).TotalMinutes;
                               if (leaveEarlyMinute >= 1)
                               {
                                   rpt.LeaveEarlyMinute = (int)leaveEarlyMinute;
                                   rpt.ShowInReport = true;
                               }
                           }
                           #endregion

                       }
                    #endregion

                    }
                }
            }
            var list = rpts.Where(ent => ent.ShowInReport == true).ToList();
            dataGridView1.DataSource = list;
            Rpt = list;
        }
        private void button1_Click(object sender, EventArgs e)
        {
            LoadData();
            ExtractEmpAndDate();
            Analyze();
            button1.Enabled = false;
            //saveFileDialog1.FileName = DateTime.Now.ToString("考勤分析yyMMddHHmmss") + ".xls";
            //if (saveFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.Cancel)
            //{
            //    return;
            //}
            //if (string.IsNullOrWhiteSpace(saveFileDialog1.FileName)) return;
            //var filename = saveFileDialog1.FileName;
            //NPOIUtil.Export(Rpt.ToDataTable(), "打卡记录分析", filename);
            
        }
    }
}
View Code

数据结构

   class CheckingRule
    {
        /// <summary>
        /// 格式00:00
        /// </summary>
        public String CheckPoint { get; set; }
        public String RangBegin { get; set; }
        public String RangEnd { get; set; }
        /// <summary>
        /// 上班:1
        /// 下班:2
        /// 
        /// </summary>
        public int CheckType { get; set; }
        public String Title { get; set; }
       
        public DateTime GetTime(DateTime day,string v)
        {
            var arr= v.Split(":".ToCharArray());
            return day.Date.AddHours(double.Parse(arr[0])).AddMinutes(double.Parse(arr[1]));
        }
    }
View Code 
    class CheckingRstInfo
    {
        public String Name { get; set; }
        public String EmpNo { get; set; }
        public String Dept { get; set; }
        public DateTime Date { get; set; }
        public String InTime { get; set; }
        public String OutTime { get; set; }
        public bool? IsAbsenteeism { get; set; }
        public int LateMinute { get; set; }
        public int LeaveEarlyMinute { get; set; }
        public bool? ShowInReport { get; set; }
        public String RuleTitle { get; set; }
    }
View Code 
using System.Data;
using System.Collections.Generic;
using System.Reflection;
using System;
using System.Collections;
namespace F.Studio.Util
{
    public static class DataTableExtensions
    {
        /// <summary> 
        /// 转化一个DataTable 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="list"></param> 
        /// <returns></returns> 
        public static DataTable ToDataTable<T>(this IEnumerable<T> list, params string[] tableName)
        {
            //创建属性的集合 
            List<PropertyInfo> pList = new List<PropertyInfo>();
            //获得反射的入口 
            Type type = typeof(T);
            string tname = "Table1";
            if (tableName.Length >= 1)
            {
                tname = tableName[0];
            }
            DataTable dt = new DataTable(tname);
            //把所有的public属性加入到集合 并添加DataTable的列 
            Array.ForEach<PropertyInfo>(type.GetProperties(), p =>
            {
                pList.Add(p);
                var theType = p.PropertyType;
                //处理可空类型
                if (theType.IsGenericType && theType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
                {
                    dt.Columns.Add(p.Name, Nullable.GetUnderlyingType(theType));
                }
                else
                {
                    dt.Columns.Add(p.Name, theType);
                }
            });
            foreach (var item in list)
            {
                //创建一个DataRow实例 
                DataRow row = dt.NewRow();
                //给row 赋值 
                pList.ForEach(p =>
                {
                    var v = p.GetValue(item, null);
                    row[p.Name] = v == null ? DBNull.Value : v;

                });
                //加入到DataTable 
                dt.Rows.Add(row);
            }
            return dt;
        }
    }
}
View Code 
    public class CheckingInfo
    {
        public CheckingInfo()
        {
            DelFlag = false;
        }
        public String Dept { get; set; }
        public String Name { get; set; }
        public DateTime AddTime { get; set; }
        public DateTime RawAddTime { get; set; }
        public String MachineNo { get; set; }
        public String EmpNo { get; set; }
        public String CheckType { get; set; }
        public bool DelFlag { get; set; }
    }
View Code

 

weixin_34221073
关注
考勤表生成工具介绍及使用说明
weixin_33700350的博客
11-26 1401
为了方便公司的普通员工，简化每个人每个月的个人考勤记录数据核对工作，特地抽出空余时间制作本考勤表生成工具，以方便本公司广大草根阶层，节省琐碎和无辜的时间浪费！ 一、工具界面 考勤表生成工具的设计界面与使用说明如下图所示： 二、生成结果 生成的 Excel 考勤表结果如下图所示： 三、工具特性 优点： 1、本工具只...
钉钉考勤报表生成工具
zywzdmm的博客
07-30 1456
考勤助手是一款针对钉钉考勤、企业微信考勤报表统计工具软件。用户导入钉钉考勤数据，自动生成企业组织结构图，自动生成员工每月考勤打卡明细表、月度考勤汇总表等
中控考勤原始记录报表生成器
06-24
中控考勤系统中没有直接将员工的原始考勤记录按部门和员工名称列出报表显示的功能。为此我对中控考勤系统的数据库进行了仔细研究部，用ASP程序设计出一个查询员工原始考勤记录的程序，本程序自动生成上个月的每天的每个员工的每一次考勤（一分钟内的重复考勤记录只统计一次）。还可以导出为excel表格。 使用方法： 将“index.asp”和“考勤.exe”复制到中控考勤软件安装目录下。 双击运行“考勤.exe”会自动打开一个考勤报表页面，右键可选择“导出到excel文件”。
考勤生成器(考勤制造,打卡记录生成)
01-31
根据现有数据库中的员工信息,生成指定的打卡记录.可指定产生随机时间的范围,可指定开始,结束日期.可设定节假日.可选择是否生成加班记录. mail : fireinsky@163.com qq: 47720110
oracle怎么获取系统日期减去出生日期_2020年度Excel考勤管理系统，自动出勤统计，报表图表一键显示...
weixin_39570777的博客
12-03 195
Hello大家好，我是帮帮。今天跟大家分享一张Excel2020年度考勤管理系统，自动出勤统计，报表图表一键显示。为了让大家能更稳定的下载模板，我们又开通了全新下载方式(见文章末尾)，以便大家可以轻松获得免费模板和收费模板。メ大家请看范例图片2020年度Excel考勤管理系统套表，点击首页单元格链接，直接跳转目标工作表。メメ取消审阅保护即可查看公式，不要改动，自动生成结果。メメ基础信息表...
学生考勤报表管理小程序
qq_45087676的博客
10-23 1017
该学生考勤管理小程序是给朋友的写的一个小demo，技术含量不高，难度也不大。放出来就是做个日常记录，有需要的小伙伴可以参考。
考勤日报表
12-09
3. **自动化工具**：随着技术的发展，许多企业采用自动化考勤系统，自动记录员工的打卡时间，生成考勤报表，减少人为错误，提高效率。这些系统可能与企业的HRM（人力资源管理系统）整合，提供实时的考勤数据。 4. *...
考勤报表查看工具
10-29
3. 报表生成：根据日期、部门、员工等条件自动生成多维度的考勤报表，如迟到早退统计、缺勤记录、工时统计等，便于管理者快速了解员工的出勤状况。 4. 异常提醒：当出现异常考勤情况时，如连续缺勤、迟到过多等，...
vba模块2生成考勤表_考勤机记录生成考勤统计报告_
10-02
7. **报表生成**：在计算出考勤统计信息后，VBA可以创建新的工作表或区域，格式化单元格，添加图表，以可视化方式展示考勤情况。 8. **自定义函数**：如果需求复杂，可以编写自定义VBA函数，如计算连续缺勤天数，...
php做一个每天的考勤表,教你做一个酷毙的考勤表！|
weixin_36078669的博客
03-20 723
原标题：教你做一个酷毙的考勤表！|60秒get一个HR实用小技巧制作考勤表说容易也容易，随便画个表格，输入年份日期、星期，然后再手工划勾就可以用了。但小薪要介绍的是更智能更漂亮的考勤表！小薪从Excel模板库中(Excel文件 - 新建 - 右侧搜关键词 考勤)，下载了一个款考勤表，做的非常漂亮，看上去很养眼！接下来小薪带大家一起揭开这款员工考勤表的做法秘密~ 1、调色版如果你把这款考勤表复制到一...
asp 考勤程序
02-08
该程序可实现考勤报表界面的考勤管理．可实现与门襟系统和手工生成考勤报表．采用所见所得的交互界面，有审批流程．
时间生成器
04-01
NULL 博文链接：https://zhcl321.iteye.com/blog/1399236
php人事考勤系统,基于PHP&MySQL的考勤系统
weixin_29086203的博客
04-02 719
匿名用户我不确定是否应该用这些更新来编辑问题。但这是我提出的部分解决方案。我会很高兴有人能帮助优化这个更多。所以，我从这段代码开始。SELECT timeidFROM timetableWHERE flag > ?AND semester = ?AND section = ?AND timeid BETWEEN ? AND ?从上面的代码，我可以得到日期的类采取。接下来，我检查一个学生是否在...
自动生成考勤表_37.考勤异常情况提醒与根据打卡记录生成考勤表
weixin_39960793的博客
01-12 6367
根据打卡记录生成考勤表1:指纹考勤机导出的数据，供各部门进行核对，但是导出的数据无法直观的看出是否迟到，早退，请假，加班，所以需要通过加工转换成与考勤表相似的格式，这样核对起来就方便多了。上表是考勤机导出的数据，一是无法直接看出哪一天是正常工作，哪一天周末加班，也无法看出哪些人请了假，哪些人加了班，加了多长时间的班。在初始数据中，区分好哪些人需要在正常工作日计算加班，可以插入一列，录入“...
学生打卡考勤系统
weixin_34395205的博客
11-03 1004
学生打卡考勤系统 --项目前景和目标文档 1.背景 在当今高速发展的信息社会，计算机技术、网络技术对人类的经济生活、社会生活等各方面都产生了巨大的影响，目前不论是企...
excel 处理数据的常用场景之考勤表的制作
最新发布
qq_45726327的博客
09-30 1671
这里我还是把表格分为了三个板块。因为以行做切分，这样也方便表格布局。其实样式的调整，不是最重要的，重要是，我们要实现考勤表的功能出勤记录员工的出勤记录是考勤表的核心功能。通过在表格中输入员工每天的上班时间和下班时间之一，Excel考勤表可以自动计算员工的工作时长，包括您每天的加班时间。可以根据实际情况需要设置工作时间的计算规则，如是否考虑迟到、早退，。考勤统计和报表生成考勤统计是Excel考勤表的重要功能。
考勤工具如何一键生成
woqu365的博客
08-12 1901
企业在传统的管理下，由于企业员工多，导致考勤数据无法准确地、及时地导出处理，这时候就需要考勤管理系统，它是人力资源管理的辅助帮手，让管理者获取实时的考勤信息来进行分析以支持决策，并且传统的管理方式存在众多弊端、人为因素众多，可能有时候会引起员工的不满。 智能考勤模块涉及到的功能比较多，高效的考勤管理是人力资源管理中比较重要的环节，帮助企业要是想灵活管理员工的考勤问题，灵活合理的排班计划，劳动力成本...
人事考勤软件操作指南：从基础设置到报表生成
4. 考勤报表生成：在生成考勤报表前，需补充打卡、请假、转班等单据信息。考勤日报是基础，通过它可以进一步生成其他详细的考勤分析报表。 人事模块： - 员工信息管理是核心，包括部门信息的创建（通过“部门管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值