public async Task <int> insert(maintenance_error_list_model model)
        {
            await _context.maintenance_error_lists.AddAsync(model.db);

            _context.SaveChanges();
            return(1);
        }
Example #2
0
        public async Task <int> insert(sys_warehouse_model model)
        {
            await _context.sys_warehouses.AddAsync(model.db);

            _context.SaveChanges();
            return(1);
        }
Example #3
0
        public async Task <int> insert(sys_workstation_model model)
        {
            await _context.sys_workstations.AddAsync(model.db);

            _context.SaveChanges();
            return(1);
        }
        public async Task <int> insert(sys_template_opc_param_model model)
        {
            await _context.sys_template_opc_params.AddAsync(model.db);

            _context.SaveChanges();
            return(1);
        }
Example #5
0
        public async Task <int> insertListError(List <quality_error_check_list_db> listError)
        {
            await _context.quality_error_check_lists.AddRangeAsync(listError);

            _context.SaveChanges();
            return(1);
        }
        public async Task <int> insert(sys_factory_model model)
        {
            await _context.sys_factorys.AddAsync(model.db);

            _context.SaveChanges();
            return(1);
        }
        public async Task <int> insert(sys_department_model model)
        {
            await _context.sys_departments.AddAsync(model.db);

            _context.SaveChanges();
            return(1);
        }
Example #8
0
        public async Task <int> insert(sys_delivery_type_model model)
        {
            await _context.sys_delivery_types.AddAsync(model.db);

            _context.SaveChanges();
            return(1);
        }
        public async Task <int> insert(quality_solution_model model)
        {
            model.db.status_del = 1;
            await _context.quality_solutions.AddAsync(model.db);

            _context.SaveChanges();
            return(1);
        }
Example #10
0
        public async Task <int> insert(maintenance_system_device_detail_model model)
        {
            //model.db.maintenance_period = _context.maintenance_systems.Where(m=>m.id == model.db.id_maintenance_system).Select(m=> m.maintenance_period).SingleOrDefault();
            await _context.maintenance_system_device_details.AddAsync(model.db);

            _context.SaveChanges();
            return(1);
        }
Example #11
0
        public async Task <int> insert(sys_approval_config_model model)
        {
            model.db.step = model.list_item.Select(d => d.db.step_num).Max();
            await _context.sys_approval_configs.AddAsync(model.db);

            _context.SaveChanges();
            saveDetail(model);
            return(1);
        }
        public async Task <int> insert(maintenance_repair_order_model model)
        {
            model.db.repair_status = 1;
            //model.db.maintenance_period = _context.maintenance_systems.Where(m=>m.id == model.db.id_maintenance_system).Select(m=> m.maintenance_period).SingleOrDefault();
            await _context.maintenance_repair_orders.AddAsync(model.db);

            _context.SaveChanges();
            return(1);
        }
Example #13
0
        public async Task <int> insert(sys_item_specification_model model)
        {
            model.db.id = 0;
            await _context.sys_item_specifications.AddAsync(model.db);

            _context.SaveChanges();
            syncItem(model.db.id_item);
            return(1);
        }
        public void calculate(DateTime dateFilter, string id_factory, string id_factory_line)
        {
            //get list workstation
            var list_workstation = _context.sys_workstations.Where(d => d.id_sys_factory == id_factory).Where(d => d.id_sys_factory_line == id_factory_line)
                                   .Select(d => d.id).ToList();

            var listadd = new List <production_report_work_done_db>();

            for (int i = 0; i < list_workstation.Count; i++)
            {
                var list_process = _context.production_processes.ToList()
                                   .Where(d => d.id_workstation == list_workstation[i])
                                   .Where(d => CompareDateTime(d.working_date, dateFilter) == 0)
                                   .Select(d => d).AsQueryable();
                var all_quantity_item_done = list_process
                                             .Sum(d => d.quantity_product) ?? 0;
                var all_quantity_item_error = list_process
                                              .Sum(d => d.quantity_error) ?? 0;;
                var all_quantity_item_need = list_process
                                             .Sum(d => d.quantity_need) ?? 0;;
                var workstation_db = _context.sys_workstations.Where(w => w.id == list_workstation[i]).SingleOrDefault();
                var db             = new production_report_work_done_db()
                {
                    date_update             = DateTime.Now,
                    id                      = 0,
                    all_quantity_item_done  = all_quantity_item_done,
                    all_quantity_item_error = all_quantity_item_error,
                    all_quantity_item_need  = all_quantity_item_need,
                    id_factory              = workstation_db.id_sys_factory,
                    id_factory_line         = workstation_db.id_sys_factory_line,
                    create_date             = DateTime.Now,
                    day                     = dateFilter.Day,
                    month                   = dateFilter.Month,
                    year                    = dateFilter.Year,
                    id_workstation          = workstation_db.id,
                };
                listadd.Add(db);
            }
            for (int i = 0; i < listadd.Count; i++)
            {
                var db_need_update = _context.production_report_work_dones.Where(d => d.id_workstation == listadd[i].id_workstation).Where(d => d.day == dateFilter.Day && d.month == dateFilter.Month && d.year == dateFilter.Year).SingleOrDefault();
                if (db_need_update != null)
                {
                    db_need_update.update_date             = DateTime.Now;
                    db_need_update.all_quantity_item_done  = listadd[i].all_quantity_item_done;
                    db_need_update.all_quantity_item_error = listadd[i].all_quantity_item_error;
                    db_need_update.all_quantity_item_need  = listadd[i].all_quantity_item_need;
                    _context.SaveChanges();
                }
                if (db_need_update == null)
                {
                    _context.production_report_work_dones.Add(listadd[i]);
                }
                _context.SaveChanges();
            }
        }
        public int update(production_order_need_supplier_master_model model)
        {
            var db = _context.production_order_items.Where(d => d.id == model.db.id).FirstOrDefault();

            db.id_item_bom_config = model.db.id_item_bom_config;
            db.status_bom         = 2;
            _context.SaveChanges();
            saveDetailProvide(model);
            return(1);
        }
        public int update(List <inventory_item_line_up_model> model)
        {
            var db_receiving_item = _context.inventory_receiving_items.Where(i => i.id == model[0].db.id_receiving_item).SingleOrDefault();

            db_receiving_item.line_up_status = 2;
            deleteInventoryLineUp(model);
            saveInventoryLineUp(model);
            _context.SaveChanges();



            return(1);
        }
        public async Task <int> insert(sys_inventory_position_item_capacity_model model)
        {
            if ((model.db.id_specification ?? 0) != 0)
            {
                var specification = _context.sys_item_specifications.Where(t => t.id == model.db.id_specification).SingleOrDefault();
                model.db.id_unit           = specification.id_unit;
                model.db.id_unit_main      = _context.sys_items.Where(t => t.id == model.db.id_item).Select(t => t.id_unit).SingleOrDefault();
                model.db.conversion_factor = specification.conversion_factor;
            }
            await _context.sys_inventory_position_item_capacitys.AddAsync(model.db);

            _context.SaveChanges();
            return(1);
        }
Example #18
0
        public int sync_approval(string id_record, string id_approval)
        {
            var db = _context.production_orders.Where(d => d.id == id_record).FirstOrDefault();

            db.id_approval = id_approval;
            _context.SaveChanges();
            return(1);
        }
        public int sync_approval(string id_record, string id_approval)
        {
            var db = _context.inventory_receivings.Where(d => d.id == id_record).FirstOrDefault();

            db.id_approval = id_approval;
            _context.SaveChanges();
            return(1);
        }
Example #20
0
        public void changeStatusMaintenance()
        {
            var listDB = _context.maintenance_schedual_system_devices.Where(d => _context.Fn_check_finish_approval(_context.maintenance_processes.Where(p => p.id_schedual_system_device == d.id).Select(t => t.id_approval).SingleOrDefault()) == true)
                         .Select(d => d).ToList();

            listDB.ForEach(item => item.status_maintenance = 2);

            _context.SaveChanges();
        }
Example #21
0
        public int update(production_order_set_up_scheduleModel model)
        {
            saveDetail(model);
            saveDetailProvide(model);
            var db = _context.production_order_items.Where(d => d.id == model.db.id).FirstOrDefault();

            db.status_schedule = 2;
            _context.SaveChanges();

            return(1);
        }
        public async Task <int> insert(sys_item_model model)
        {
            await _context.sys_items.AddAsync(model.db);

            _context.SaveChanges();
            saveDetail(model);
            return(1);
        }
        public async Task <int> insert(sys_vendor_item_model model, sys_vendor_item_history_model modelHistory)
        {
            if ((model.db.id_specification ?? 0) != 0)
            {
                var specification = _context.sys_item_specifications.Where(t => t.id == model.db.id_specification).SingleOrDefault();
                model.db.id_unit           = specification.id_unit;
                model.db.id_unit_main      = _context.sys_items.Where(t => t.id == model.db.id_item).Select(t => t.id_unit).SingleOrDefault();
                model.db.conversion_factor = specification.conversion_factor;
            }
            modelHistory.db.action = "Tạo mới";


            await _context.sys_vendor_item_historys.AddAsync(modelHistory.db);

            await _context.sys_vendor_items.AddAsync(model.db);

            _context.SaveChanges();
            return(1);
        }
Example #24
0
        public void remove_approval(techproDefautContext context, string id)
        {
            var remove = context.sys_approval_details.Where(d => d.id_approval == id);

            context.sys_approval_details.RemoveRange(remove);
            var remove1 = context.sys_approvals.Where(d => d.id == id);

            context.sys_approvals.RemoveRange(remove1);
            context.SaveChanges();
        }
Example #25
0
        public async Task <int> insert(quality_item_config_detail_model model)
        {
            model.db.id = 0;
            if (model.db.id_specification != 0)
            {
                var specification = _context.sys_item_specifications.Where(t => t.id == model.db.id_specification).SingleOrDefault();
                model.db.id_unit      = specification.id_unit;
                model.db.id_unit_main = _context.sys_items.Where(t => t.id == model.db.id_item).Select(t => t.id_unit).SingleOrDefault();
            }
            else
            {
                model.db.id_specification = 0;
                model.db.id_unit          = _context.sys_items.Where(t => t.id == model.db.id_item).Select(t => t.id_unit).SingleOrDefault();
                model.db.id_unit_main     = model.db.id_unit;
            }
            await _context.quality_item_config_details.AddAsync(model.db);

            _context.SaveChanges();
            return(1);
        }
Example #26
0
        public async Task <int> insert(sys_factory_line_model model)
        {
            await _context.sys_factory_lines.AddAsync(model.db);

            _context.SaveChanges();
            var db = await _context.sys_factory_lines.Where(t => t.status_del == 1).Where(t => t.status_del == 1).Where(t => t.name == model.db.name).Select(t => t).SingleOrDefaultAsync();

            string id_factory_line = db.id;
            string id_factory      = db.id_factory;

            if (model.list_maintenance_system.Count != 0)
            {
                for (int i = 0; i < model.list_maintenance_system.Count; i++)
                {
                    model.list_maintenance_system[i].id              = 0;
                    model.list_maintenance_system[i].id_factory      = id_factory;
                    model.list_maintenance_system[i].id_factory_line = id_factory_line;
                }
                saveDetailList(model);
            }


            _context.SaveChanges();

            return(1);
        }
Example #27
0
        public int update(production_process_model model, string id_user)
        {
            var db = _context.production_processes.Where(d => d.id == model.db.id).FirstOrDefault();

            db.name = model.db.name;
            var db_workstation = _context.sys_workstations.Where(w => w.id == model.id_workstation).SingleOrDefault();

            db_workstation.id_worker = id_user;
            db.id_worker             = id_user;
            db.status_process        = 2;
            db.id_workstation        = model.id_workstation;

            if (model.status_import.ToString() == null)
            {
                db.status_import = 1;
            }
            if (model.status_import.ToString() != null)
            {
                db.status_import = 2;
            }

            db.update_by   = model.db.update_by;
            db.update_date = model.db.update_date;
            if (model.db.id_business_sale_order != null)
            {
                db.id_customer = _context.business_sale_orders.Where(t => t.id == model.db.id_business_sale_order)
                                 .Select(d => d.id_customer).SingleOrDefault();
            }

            db.quantity_error = model.db.quantity_error;

            db.quantity_product = model.db.quantity_product;

            db.quantity_need = model.db.quantity_need;
            db.note          = model.db.note;

            _context.SaveChanges();

            return(1);
        }
        public int sync_approval(string id_record, string id_approval)
        {
            var db = _context.maintenance_plannings.Where(d => d.id == id_record).FirstOrDefault();

            db.id_approval = id_approval;
            _context.SaveChanges();
            return(1);
        }
Example #29
0
        public async Task <int> save(sys_work_schedule_factory_line_model model, int action)
        {
            if (action == 1)
            {
                await _context.sys_work_schedule_factory_lines.AddAsync(model.db);

                _context.SaveChanges();
            }
            else
            {
                var db = _context.sys_work_schedule_factory_lines.Where(d => d.id == model.db.id).FirstOrDefault();
                db.timeStart_1 = model.db.timeStart_1;
                db.timeStart_2 = model.db.timeStart_2;
                db.timeStart_3 = model.db.timeStart_3;
                db.timeEnd_1   = model.db.timeEnd_1;
                db.timeEnd_2   = model.db.timeEnd_2;
                db.timeEnd_3   = model.db.timeEnd_3;
                _context.SaveChanges();
            }


            return(1);
        }
        public async Task <int> insert(maintenance_process_model model)
        {
            model.db.status_del         = 1;
            model.db.status_maintenance = 2;
            long id_maintenance_schedual_system_device = model.db.id;

            model.db.id_schedual_system_device = id_maintenance_schedual_system_device;
            model.db.id = 0;
            await _context.maintenance_processes.AddAsync(model.db);

            // changeStatusMaintenance(id_maintenance_schedual_system_device);


            _context.SaveChanges();
            saveCheckList(model);
            saveListPeople(model);

            return(1);
        }