public void ReBuildByWgr(HwgrToWgr wgr, BindingTemplate <BaseTreeItem> lst)
{
if (lst != null)
{
List <BaseTreeItem> detect = new List <BaseTreeItem>();
detect.AddRange(lst);
foreach (BaseTreeItem item in detect)
{
if (!item.IsHwgr && (item as WgrTreeItem).Wgr.WGR_ID == wgr.WGR_ID)
{
lst.Remove(item);
}
}
foreach (HwgrToWgr item in GetWgrHistoty())
{
if (item.BeginTime <= m_filterDate && item.EndTime >= m_filterDate)
{
long parentid = 0;
foreach (BaseTreeItem var in lst)
{
if (var.IsHwgr && (var as HwgrTreeItem).Hwgr.HWGR_ID == item.HWGR_ID)
{
parentid = var.ID;
break;
}
}
lst.Add(new WgrTreeItem(item, parentid));
}
}
lst.ClearRemoveList();
}
}
private void gridView_CustomUnboundColumnData(object sender, DevExpress.XtraGrid.Views.Base.CustomColumnDataEventArgs e)
{
if (m_isHwgr)
{
WorldToHwgr row = gridView.GetRow(e.RowHandle) as WorldToHwgr;
if (e.IsGetData && row != null)
{
if (e.Column == gc_Parent)
{
e.Value = m_context.TakeStoreStructure.GetWorld(row.WorldID).Name;
}
}
}
else
{
HwgrToWgr row = gridView.GetRow(e.RowHandle) as HwgrToWgr;
if (e.IsGetData && row != null)
{
if (e.Column == gc_Parent)
{
e.Value = m_context.TakeStoreStructure.GetHwgr(row).Name;
}
}
}
}
public _HwgrToWgr CreateCopy()
{
HwgrToWgr wth = new HwgrToWgr();
BaseEntity.CopyTo(_entity, wth);
wth.ID = 0;
return(new _HwgrToWgr(wth));
}
public _HwgrToWgr(HwgrToWgr entity)
{
_entity = entity;
if (!_entity.IsNew)
{
_state = RecordState.UnModified;
}
}
public AssignResult WGRToHWGRAssign(long storeID, long hwgr_id, long wgr_id, DateTime beginTime,
DateTime endTime)
{
AssignResult result = new AssignResult();
result.Result = AResult.Error;
using (IDbCommand command = CreateCommand())
{
command.CommandText = "spWGR_HWGR_Assign";
command.CommandType = CommandType.StoredProcedure;
SqlParameter p1 = new SqlParameter("@StoreID", SqlDbType.BigInt, 8);
p1.Value = storeID;
command.Parameters.Add(p1);
SqlParameter p2 = new SqlParameter("@HWGR_ID", SqlDbType.BigInt, 8);
p2.Value = hwgr_id;
command.Parameters.Add(p2);
SqlParameter p3 = new SqlParameter("@WGR_ID", SqlDbType.BigInt, 8);
p3.Value = wgr_id;
command.Parameters.Add(p3);
SqlParameter p4 = new SqlParameter("@BeginTime", SqlDbType.SmallDateTime, 4);
p4.Value = beginTime;
command.Parameters.Add(p4);
SqlParameter p5 = new SqlParameter("@EndTime", SqlDbType.SmallDateTime, 4);
p5.Value = endTime;
command.Parameters.Add(p5);
SqlParameter importResult = new SqlParameter("@result", SqlDbType.Int, 4);
importResult.Direction = ParameterDirection.Output;
command.Parameters.Add(importResult);
using (IDataReader reader = command.ExecuteReader(CommandBehavior.SequentialAccess))
{
List <HwgrToWgr> list = new List <HwgrToWgr>();
while (reader.Read())
{
HwgrToWgr value = new HwgrToWgr();
value.ID = reader.GetInt64(0);
value.StoreID = reader.GetInt64(1);
value.HWGR_ID = reader.GetInt64(2);
value.WGR_ID = reader.GetInt64(3);
value.BeginTime = reader.GetDateTime(4);
value.EndTime = reader.GetDateTime(5);
value.Import = reader.GetBoolean(6);
list.Add(value);
}
reader.NextResult();
int res = (int)importResult.Value;
if (res < 0)
{
result.Result = AResult.Error;
}
result.Data = list;
}
}
_HwgrWgrDao.OnDaoInvalidateWholeCache();
return(result);
}
private void CopyEntity(HwgrToWgr source, HwgrToWgr dest)
{
dest.ID = source.ID;
dest.HWGR_ID = source.HWGR_ID;
dest.WgrName = source.WgrName;
dest.Import = source.Import;
dest.StoreID = source.StoreID;
dest.WGR_ID = source.WGR_ID;
dest.BeginTime = source.BeginTime;
dest.EndTime = source.EndTime;
}
protected void StopWorkingWgr()
{
try
{
dragWgr.EndTime = DateTime.Now;
HwgrToWgr first = ClientEnvironment.HwgrToWgrService.FindById(dragWgr.ID);
first.EndTime = DateTime.Now;
ClientEnvironment.HwgrToWgrService.SaveOrUpdate(first);
}
catch (EntityException ex)
{
XtraMessageBox.Show(ex.Message, ex.GetType().ToString(), MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
internal static Domain.WGR GetWgrEntity(HwgrToWgr hwgr_wgr)
{
Domain.WGR entity = GetWGRByID(hwgr_wgr.ID);
if (entity == null)
{
foreach (Domain.WGR var in Instance.m_diction.Values)
{
if (var.ID == hwgr_wgr.WGR_ID)
{
return(var);
}
}
}
return(entity);
}
protected override void EntityChanged()
{
WorldToHwgr hwgr = Entity as WorldToHwgr;
HwgrToWgr wgr = Entity as HwgrToWgr;
if (hwgr != null)
{
List <WorldToHwgr> list = ClientEnvironment.WorldToHWGRService
.GetWorldToHwgrFiltered(hwgr.StoreID, hwgr.WorldID, hwgr.HWGR_ID);
gridControl.DataSource = list;
lbCaption.Text = string.Format("{0} -> {1} -> {2}",
ClientEnvironment.StoreService.FindById(hwgr.StoreID).Name,
ClientEnvironment.WorldService.FindById(hwgr.WorldID).Name,
ClientEnvironment.HWGRService.FindById(hwgr.HWGR_ID).Name);
}
else if (wgr != null)
{
}
}
public override bool Commit()
{
try
{
HwgrToWgr attach = ClientEnvironment.HwgrToWgrService.CreateEntity();
attach.BeginTime = uc.BeginTime;
attach.EndTime = uc.EndTime;
attach.WGR_ID = (long)EditWgr.EditValue;
attach.Import = false;
attach.StoreID = m_hwgr.ID;
m_entityName = EditWgr.Text;
m_attached = attach = ClientEnvironment.HwgrToWgrService.SaveOrUpdate(attach);
}
catch (EntityException e)
{
ProcessEntityException(e);
return(false);
}
return(true);
}
public override bool Commit()
{
if (IsValid())
{
if (IsModified())
{
HwgrToWgr entity = new HwgrToWgr();
CopyEntity(EntityHwgrToWgr, entity);
entity.WGR_ID = WgrId;
entity.HWGR_ID = HwgrId;
entity.BeginTime = BeginTime;
entity.EndTime = EndTime;
try
{
List <HwgrToWgr> lst = ClientEnvironment.HwgrToWgrService.InsertRelation(entity);
Context.TakeStoreStructure.MergeHwgrToWgr(lst);
CopyEntity(entity, EntityHwgrToWgr);
EntityHwgrToWgr.WgrName = wgrLookUpCtrl.Text;
Modified = true;
return(base.Commit());
}
catch (ValidationException)
{
ErrorMessage(GetLocalized("ErrorDateRangeIntersect"));
return(false);
}
}
else
{
return(base.Commit());
}
}
return(false);
}
public void NewAssignWgrToHwgr()
{
WgrTreeItem item = null;
if (IsWgrFocused)
{
item = FocusedEntity as WgrTreeItem;
}
HwgrToWgr newitem = new HwgrToWgr();
newitem.StoreID = m_context.Store.ID;
if (item != null)
{
newitem.HWGR_ID = item.Wgr.HWGR_ID;
newitem.WGR_ID = item.Wgr.WGR_ID;
newitem.BeginTime = DateTimeHelper.GetNextMonday(DateTime.Today);
newitem.EndTime = DateTimeSql.SmallDatetimeMax;
}
else
{
newitem.BeginTime = DateTime.Today;
newitem.EndTime = DateTimeSql.SmallDatetimeMax;
}
using (FormAssignWgrToHwgr form = new FormAssignWgrToHwgr())
{
form.Context = m_context;
form.Entity = newitem;
if (form.ShowDialog() == DialogResult.OK)
{
treeList.BeginUpdate();
m_context.TakeStoreStructure.ReBuildByWgr(newitem, (treeList.DataSource as BindingTemplate <BaseTreeItem>));
EntityChanged();
treeList.EndUpdate();
}
}
}
public HWGR GetHwgr(HwgrToWgr hwgr)
{
return(HwgrManager.GetHWGRByID(hwgr.HWGR_ID));
}
public Domain.WGR GetWgr(HwgrToWgr hwgr_wgr)
{
return(WgrManager.GetWgrEntity(hwgr_wgr));
}
public WgrTreeItem(HwgrToWgr entity, long parentID)
: base(entity, parentID)
{
ID = _nextID++;
_ishwgr = false;
}
public WgrDateRangeManager(IHwgrWgrDao dao, HwgrToWgr newentity)
: this(dao)
{
_entity = newentity;
}
public override bool Commit()
{
try
{
DateTime begin = BeginTime, end = EndTime;
Utility.AssignWeek(ref begin, ref end);
BeginTime = begin;
EndTime = end;
switch (m_assignEnum)
{
case AssignEnum.ThisHwgrToWgr:
case AssignEnum.ThisWgrToHWGR:
HwgrToWgr assign = ClientEnvironment.HwgrToWgrService.CreateEntity();
assign.BeginTime = BeginTime;
assign.EndTime = EndTime;
assign.HWGR_ID = (long)edParent.EditValue;
assign.Import = false;
assign.StoreID = m_storeID;
assign.WGR_ID = (long)edChild.EditValue;
ClientEnvironment.HwgrToWgrService.Save(assign);
m_assigned = new WgrTreeItem(assign, assign.HWGR_ID);
break;
case AssignEnum.ThisHwgrToWorld:
WorldToHwgr assign2 = ClientEnvironment.WorldToHWGRService.CreateEntity();
assign2.BeginTime = BeginTime;
assign2.EndTime = EndTime;
assign2.HWGR_ID = (long)edChild.EditValue;
assign2.Import = false;
assign2.StoreID = m_storeID;
assign2.WorldID = (Entity as WorldToHwgr).WorldID;
ClientEnvironment.WorldToHWGRService.Save(assign2);
m_assigned = new HwgrTreeItem(assign2, 0);
break;
case AssignEnum.WorldHwgrDisable:
DateTime t1 = timeRange.BeginTime,
t2 = timeRange.EndTime;
Utility.AssignWeek(ref begin, ref end);
timeRange.BeginTime = t1;
timeRange.EndTime = t2;
WorldToHwgr vice = Entity as WorldToHwgr;
WorldToHwgr first = ClientEnvironment.WorldToHWGRService.FindById(vice.ID);
first.BeginTime = timeRange.BeginTime;
first.EndTime = timeRange.EndTime;
ClientEnvironment.WorldToHWGRService.Update(first);
break;
case AssignEnum.HwgrWgrDisable:
HwgrToWgr vice2 = Entity as HwgrToWgr;
Domain.HwgrToWgr first2 = ClientEnvironment.HwgrToWgrService.FindById(vice2.ID);
first2.EndTime = timeRange.EndTime;
first2.BeginTime = timeRange.BeginTime;
ClientEnvironment.HwgrToWgrService.Update(first2);
break;
}
}
catch (ValidationException)
{
XtraMessageBox.Show(Baumax.Localization.Localizer.GetLocalized("InvalidTimeRange"));
return(false);
}/*
* catch (Exception ex)
* {
* XtraMessageBox.Show (ex.Message);
* return false;
* }*/
return(true);
}
public static void FillHwgrToWgr(HwgrToWgr entity)
{
entity.WgrName = Instance.GetWgrName(entity.WGR_ID);
}
