private void repositoryItemCheckEdit1_CheckedChanged(object sender, EventArgs e)
        {
            DevExpress.XtraEditors.CheckEdit CheckEdit1temp = (DevExpress.XtraEditors.CheckEdit)sender;
                  PSP_VolumeBalanceDataSource volumtemp=new PSP_VolumeBalanceDataSource ();
                volumtemp.TypeID =Convert.ToInt32(type);
                volumtemp.Flag = flag;
                IList<PSP_VolumeBalanceDataSource> list = Services.BaseService.GetList<PSP_VolumeBalanceDataSource>("SelectPSP_VolumeBalanceDataSourceByTypeID", volumtemp);
              if (CheckEdit1temp.Checked)
              {
                  for (int i = 0; i < _obj.GetType().GetProperties().Length;i++ )
                      objtemp.GetType().GetProperty(_obj.GetType().GetProperties()[i].Name).SetValue(objtemp,_obj.GetType().GetProperty(_obj.GetType().GetProperties()[i].Name).GetValue(_obj, null), null);
                          foreach (PSP_VolumeBalanceDataSource psptemp in list)
                          {

                              try
                              {
                                  if (psptemp.UID == baseyeartype)
                                      continue;
                                  if (hs[psptemp.Name] != null)
                                  _obj.GetType().GetProperty("L" + hs[psptemp.Name].ToString()).SetValue(_obj, psptemp.Value, null);
                              }
                              catch (Exception ex)
                              {
                                  System.Console.WriteLine(ex.ToString());
                              }

                          }

                rowL6.Visible = true;
                _obj.S1 = "1";
              }
              else
              {
                  //if (list.Count == 5 && hs.Count == 5)
                  //{
                  //    foreach (PSP_VolumeBalanceDataSource psptemp in list)
                  //    {
                  //        try
                  //        {
                  //            _obj.GetType().GetProperty("L" + hs[psptemp.Name].ToString()).SetValue(_obj, 0, null);
                  //        }
                  //        catch (Exception ex)
                  //        {
                  //            System.Console.WriteLine(ex.ToString());
                  //        }

                  //    }

                  //}
                  if (objtemp.Year != 0)
                  {
                      for (int i = 0; i < _obj.GetType().GetProperties().Length; i++)
                          _obj.GetType().GetProperty(objtemp.GetType().GetProperties()[i].Name).SetValue(_obj, objtemp.GetType().GetProperty(_obj.GetType().GetProperties()[i].Name).GetValue(objtemp, null), null);

                  }
                  _obj.S1 = "0";
                  rowL6.Visible = false;
              }
        }
 private int EnsureBaseYear()
 {
     PSP_VolumeBalanceDataSource BaseYeartemp = new PSP_VolumeBalanceDataSource();
     BaseYeartemp.TypeID = Convert.ToInt32(type);
         BaseYeartemp.UID = baseyeartype ;
         BaseYeartemp.Flag = flag;
     PSP_VolumeBalanceDataSource BaseYearrate = (PSP_VolumeBalanceDataSource)Common.Services.BaseService.GetObject("SelectPSP_VolumeBalanceDataSourceByKeyTypeID", BaseYeartemp);
     if (BaseYearrate == null)
     {
         BaseYearrate = new PSP_VolumeBalanceDataSource();
         BaseYearrate.UID = BaseYeartemp.UID;
         BaseYearrate.Value = 1900;
         BaseYearrate.TypeID = Convert.ToInt32(type);
         BaseYearrate.Flag = flag;
         Services.BaseService.Create<PSP_VolumeBalanceDataSource>(BaseYearrate);
         //
     }
     return Convert.ToInt32(BaseYearrate.Value);
 }
        protected bool SaveRecord()
        {
            //����/�޸� ����
            try
            {

                if (IsCreate)
                {
                    Services.BaseService.Create<PSP_VolumeBalance>(_obj);
                }
                else
                {
                    Services.BaseService.Update<PSP_VolumeBalance>(_obj);
                }

            }
            catch (Exception exc)
            {
                Debug.Fail(exc.Message);
                HandleException.TryCatch(exc);
                return false ;
            }
            if (_obj.S1 == "1")
            {
                PSP_VolumeBalance ob = new PSP_VolumeBalance();
                ob.Year = EnsureBaseYear();
                ob.TypeID = type;
                ob.Flag = flag;
                IList<PSP_VolumeBalance> list0 = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeIDAndYear", ob);
                if (list0 != null)
                {
                    if (list0.Count == 1)
                    {
                        list0[0].S1 = "0";
                        Services.BaseService.Update<PSP_VolumeBalance>(list0[0]);
                    }
                }
                PSP_VolumeBalanceDataSource BaseYearrate = new PSP_VolumeBalanceDataSource();
                BaseYearrate.UID = baseyeartype;
                BaseYearrate.Flag = flag;
                BaseYearrate.Value = _obj.Year;
                BaseYearrate.TypeID = Convert.ToInt32(_obj.TypeID);
                Services.BaseService.Update("UpdatePSP_VolumeBalanceDataSource2", BaseYearrate);
            }
            else if (_obj.Year == EnsureBaseYear() /*|| (EnsureBaseYear() == baseyear)*/)
            {
                PSP_VolumeBalance ob = new PSP_VolumeBalance();
                ob.Flag = flag;
                ob.TypeID = type;
                IList<PSP_VolumeBalance> list0 = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", ob);
                if (list0 != null)
                    if (list0.Count > 0)
                        ob = list0[0];
                PSP_VolumeBalanceDataSource BaseYearrate = new PSP_VolumeBalanceDataSource();
                BaseYearrate.Flag = flag;
                BaseYearrate.UID = baseyeartype;
                BaseYearrate.Value = baseyear;
                BaseYearrate.TypeID = Convert.ToInt32(_obj.TypeID);
                Services.BaseService.Update("UpdatePSP_VolumeBalanceDataSource2", BaseYearrate);
                PSP_VolumeBalanceDataSource volumtemp = new PSP_VolumeBalanceDataSource();
                volumtemp.TypeID = Convert.ToInt32(type);
                volumtemp.Flag = flag;
                IList<PSP_VolumeBalanceDataSource> list = Services.BaseService.GetList<PSP_VolumeBalanceDataSource>("SelectPSP_VolumeBalanceDataSourceByTypeID", volumtemp);
                        if (ob != null)
                            if (ob.UID != "")
                                foreach (PSP_VolumeBalanceDataSource psptemp in list)
                                {
                                    if (psptemp.UID == baseyeartype)
                                        continue;
                                    if (hs[psptemp.Name] != null)
                                    ob.GetType().GetProperty("L" + hs[psptemp.Name].ToString()).SetValue(ob, psptemp.Value, null);
                                }
                        try
                        {
                            ob.S1 = "1";
                            Services.BaseService.Update<PSP_VolumeBalance>(ob);
                            isresum = true;
                        }

                        catch (Exception ex)
                        {
                            System.Console.WriteLine(ex.ToString());
                        }

            }
            //�����ѳɹ�
            return true;
        }
Пример #4
0
 private double EnsureVolumecalc()
 {
     PSP_VolumeBalanceDataSource BaseYeartemp = new PSP_VolumeBalanceDataSource();
     BaseYeartemp.TypeID = Convert.ToInt32(TypeID);
     BaseYeartemp.Flag = Flag;
     BaseYeartemp.UID = Volumecalc;
     PSP_VolumeBalanceDataSource BaseYearrate = (PSP_VolumeBalanceDataSource)Common.Services.BaseService.GetObject("SelectPSP_VolumeBalanceDataSourceByKeyTypeID", BaseYeartemp);
     if (BaseYearrate == null)
     {
         BaseYearrate = new PSP_VolumeBalanceDataSource();
         BaseYearrate.UID = Volumecalc;
         BaseYearrate.Value = 2;
         BaseYearrate.Flag = Flag;
         BaseYearrate.TypeID = Convert.ToInt32(TypeID);
         Services.BaseService.Create<PSP_VolumeBalanceDataSource>(BaseYearrate);
         //
     }
     return Convert.ToDouble(BaseYearrate.Value);
 }
 private void simpleButton1_Click(object sender, EventArgs e)
 {
     PSP_VolumeBalanceDataSource BaseYeartemp = new PSP_VolumeBalanceDataSource();
     BaseYeartemp.TypeID = Convert.ToInt32(type);
     BaseYeartemp.UID = uid;
     BaseYeartemp.Flag = flag;
     BaseYeartemp.Value =Convert.ToDouble( spinEdit1.Value);
     Services.BaseService.Update<PSP_VolumeBalanceDataSource>(BaseYeartemp);
     this.DialogResult = DialogResult.OK;
     this.Close();
 }
Пример #6
0
        /// <summary>
        /// ɾ���������
        /// </summary>
        public void DeleteObject()
        {
            //��ȡ�������
            PSP_VolumeBalance obj = FocusedObject;
            if (obj == null)
            {
                return;
            }

            //����ȷ��
            if (MsgBox.ShowYesNo(Strings.SubmitDelete) != DialogResult.Yes)
            {
                return;
            }

            //ִ��ɾ������
            try
            {
                Services.BaseService.Delete<PSP_VolumeBalance>(obj);

            }
            catch (Exception exc)
            {
                Debug.Fail(exc.Message);
                HandleException.TryCatch(exc);
                return;
            }

            this.gridView.BeginUpdate();
            //��ס��ǰ����������
            int iOldHandle = this.gridView.FocusedRowHandle;
            //��������ɾ��
            ObjectList.Remove(obj);
            //ˢ�±��
            gridControl.RefreshDataSource();
            //�����µĽ���������
            GridHelper.FocuseRowAfterDelete(this.gridView, iOldHandle);
            this.gridView.EndUpdate();
            if (ObjectList.Count == 0 || EnsureBaseYear() == obj.Year)
            {

                PSP_VolumeBalanceDataSource BaseYearrate = new PSP_VolumeBalanceDataSource();
                BaseYearrate.UID = baseyeartype;
                BaseYearrate.Value = 1990;
                BaseYearrate.TypeID = Convert.ToInt32(obj.TypeID);
                BaseYearrate.Flag = flag;
                Services.BaseService.Update("UpdatePSP_VolumeBalanceDataSource2", BaseYearrate);
            }
        }