public void RegisterDeleteOrderObject(OrderObject newObj) {
Logger.info("Пользователь удалил оборудование", Logger.LoggerSource.objectsContext);
try {
if (!CurrentUser.AllowEditTree) {
throw new DomainException("У вас нет прав редактировать оборудование");
}
VotGESOrdersEntities context=new VotGESOrdersEntities();
VotGESOrders.Web.ADONETEntities.Orders orderDB=new Orders();
OrderObjects objDB=(from o in context.OrderObjects where o.objectID == newObj.ObjectID select o).First();
deleteOrderObject(context, objDB);
//context.OrderObjects.DeleteObject(objDB);
context.SaveChanges();
OrderObject.init();
Logger.info("===Сохранено", Logger.LoggerSource.objectsContext);
} catch (Exception e) {
Logger.error(String.Format("===Ошибка при удалении оборудования: {0}", e), Logger.LoggerSource.objectsContext);
if (e is DomainException) {
throw e;
}
throw new DomainException("Ошибка при удалении оборудования, возможно на оборудование (или дочернее оборудование) ссылаются заявки");
}
}
public Order(Orders dbOrder, OrdersUser currentUser, bool readRelated, List<Order> listOrders) {
refreshOrderFromDB(dbOrder, currentUser, readRelated,listOrders);
}
public void checkPremissions(Orders dbOrder, OrdersUser currentUser) {
OrderCreated = dbOrder.orderCreated;
OrderReviewed = dbOrder.orderReviewed;
OrderOpened = dbOrder.orderOpened;
OrderClosed = dbOrder.orderClosed;
OrderCanceled = dbOrder.orderCanceled;
OrderCompleted = dbOrder.orderCompleted;
OrderCompletedWithoutEnter = dbOrder.orderCompletedWithoutEnter;
OrderExtended = dbOrder.orderExtended;
OrderAskExtended = dbOrder.orderAskExtended;
OrderIsExtend = dbOrder.orderIsExtend;
OrderIsFixErrorEnter = dbOrder.orderIsFixErrorEnter;
OrderState = (OrderStateEnum)Enum.Parse(typeof(OrderStateEnum), dbOrder.orderState, true);
OrderType = (OrderTypeEnum)Enum.Parse(typeof(OrderTypeEnum), dbOrder.orderType, true);
OrderCanceledWithoutReview = OrderCanceled && !OrderReviewed;
OrderBanned = OrderState == OrderStateEnum.banned;
int creator=dbOrder.userCreateOrderID;
AllowReviewOrder = currentUser.AllowReviewOrder && OrderState == OrderStateEnum.created;
AllowOpenOrder = currentUser.AllowChangeOrder && OrderState == OrderStateEnum.accepted;
AllowCloseOrder = (currentUser.UserID == creator && OrderState == OrderStateEnum.opened) ||
currentUser.AllowChangeOrder && OrderState == OrderStateEnum.opened;
AllowCompleteWithoutEnterOrder = currentUser.AllowChangeOrder && currentUser.AllowCreateCrashOrder && OrderState == OrderStateEnum.closed;
AllowCompleteOrder = currentUser.AllowChangeOrder && OrderState == OrderStateEnum.closed;
AllowChangeOrder = (currentUser.UserID == creator || currentUser.AllowChangeOrder) && OrderState == OrderStateEnum.created||
(currentUser.AllowChangeOrder && (OrderType==OrderTypeEnum.no||OrderType==OrderTypeEnum.crash)&&OrderState==OrderStateEnum.opened);
AllowExtendOrder = (currentUser.AllowChangeOrder || currentUser.UserID == creator) && OrderState == OrderStateEnum.opened;
AllowCancelOrder = ((currentUser.UserID == creator || currentUser.AllowChangeOrder) &&
(OrderState == OrderStateEnum.created || OrderState == OrderStateEnum.accepted || orderState == OrderStateEnum.opened && OrderIsExtend)) ||
currentUser.AllowChangeOrder && OrderState == OrderStateEnum.opened && orderIsFixErrorEnter;
string[] ids= dbOrder.agreeUsersIDS.Split(';');
AllowCommentOrder = true;
AllowRejectReviewOrder = (currentUser.AllowEditOrders||currentUser.AllowReviewOrder) &&
(OrderState == OrderStateEnum.accepted || OrderState == OrderStateEnum.banned && !OrderIsExtend ||
OrderState==OrderStateEnum.opened && OrderIsExtend);
AllowRejectOpenOrder = (currentUser.AllowEditOrders || currentUser.AllowChangeOrder) && OrderState == OrderStateEnum.opened && !OrderIsExtend && !OrderIsFixErrorEnter &&
!OrderExtended && !OrderAskExtended &&
OrderType != OrderTypeEnum.crash && OrderType != OrderTypeEnum.no;
AllowRejectCloseOrder = (currentUser.AllowEditOrders || currentUser.AllowChangeOrder) && OrderState == OrderStateEnum.closed;
AllowRejectCancelOrder = (currentUser.AllowEditOrders || currentUser.AllowChangeOrder) && OrderState == OrderStateEnum.canceled && !OrderIsExtend && !OrderIsFixErrorEnter;
AllowRejectCompleteOrder = (currentUser.AllowEditOrders || currentUser.AllowChangeOrder) && OrderState == OrderStateEnum.completed;
AllowEditOrder = currentUser.AllowEditOrders;
}
public static void writeExpired(Orders orderDB) {
double koef=10000000.0 * 60.0 * 60.0;
orderDB.expiredOpenHours = null;
orderDB.expiredCloseHours = null;
orderDB.expiredCompleteHours = null;
orderDB.expiredReglamentHours = null;
if (orderDB.orderOpened&&orderDB.faktStartDate.HasValue) {
orderDB.expiredOpenHours = (orderDB.planStartDate.Ticks - orderDB.faktStartDate.Value.Ticks) / koef;
}
if (orderDB.orderClosed && orderDB.faktStopDate.HasValue) {
orderDB.expiredCloseHours = (orderDB.planStopDate.Ticks - orderDB.faktStopDate.Value.Ticks) / koef;
}
if (orderDB.orderCompleted && orderDB.faktCompleteDate.HasValue) {
orderDB.expiredCompleteHours = (orderDB.planStopDate.Ticks - orderDB.faktCompleteDate.Value.Ticks) / koef;
}
DateTime needCreate=orderDB.orderDateCreate;
if (!orderDB.orderIsExtend) {
if (orderDB.orderType == OrderTypeEnum.npl.ToString() || orderDB.orderType == OrderTypeEnum.pl.ToString()) {
if (orderDB.planStartDate.DayOfWeek == DayOfWeek.Monday) {
needCreate = orderDB.planStartDate.AddDays(-3).Date.AddHours(15);
} else if (orderDB.planStartDate.DayOfWeek == DayOfWeek.Sunday) {
needCreate = orderDB.planStartDate.AddDays(-2).Date.AddHours(15);
} else if (orderDB.planStartDate.DayOfWeek == DayOfWeek.Saturday) {
needCreate = orderDB.planStartDate.AddDays(-1).Date.AddHours(15);
}
else {
needCreate = orderDB.planStartDate.AddDays(-1).Date.AddHours(15);
}
} else {
needCreate = orderDB.planStartDate.AddHours(24);
}
}
orderDB.expiredReglamentHours = (needCreate.Ticks - orderDB.orderDateCreate.Ticks) / koef;
}
/// <summary>
/// Создание нового объекта Orders.
/// </summary>
/// <param name="orderNumber">Исходное значение свойства orderNumber.</param>
/// <param name="userCreateOrderID">Исходное значение свойства userCreateOrderID.</param>
/// <param name="orderDateCreate">Исходное значение свойства orderDateCreate.</param>
/// <param name="orderLastUpdate">Исходное значение свойства orderLastUpdate.</param>
/// <param name="planStartDate">Исходное значение свойства planStartDate.</param>
/// <param name="planStopDate">Исходное значение свойства planStopDate.</param>
/// <param name="orderText">Исходное значение свойства orderText.</param>
/// <param name="orderType">Исходное значение свойства orderType.</param>
/// <param name="agreeText">Исходное значение свойства agreeText.</param>
/// <param name="agreeUsersIDS">Исходное значение свойства agreeUsersIDS.</param>
/// <param name="readyTime">Исходное значение свойства readyTime.</param>
/// <param name="orderObjectID">Исходное значение свойства orderObjectID.</param>
/// <param name="orderObjectAddInfo">Исходное значение свойства orderObjectAddInfo.</param>
/// <param name="orderCreated">Исходное значение свойства orderCreated.</param>
/// <param name="orderReviewed">Исходное значение свойства orderReviewed.</param>
/// <param name="orderOpened">Исходное значение свойства orderOpened.</param>
/// <param name="orderClosed">Исходное значение свойства orderClosed.</param>
/// <param name="orderCanceled">Исходное значение свойства orderCanceled.</param>
/// <param name="orderCompleted">Исходное значение свойства orderCompleted.</param>
/// <param name="orderCompletedWithoutEnter">Исходное значение свойства orderCompletedWithoutEnter.</param>
/// <param name="orderExtended">Исходное значение свойства orderExtended.</param>
/// <param name="orderAskExtended">Исходное значение свойства orderAskExtended.</param>
/// <param name="orderIsExtend">Исходное значение свойства orderIsExtend.</param>
/// <param name="orderIsFixErrorEnter">Исходное значение свойства orderIsFixErrorEnter.</param>
/// <param name="orderState">Исходное значение свойства orderState.</param>
public static Orders CreateOrders(global::System.Double orderNumber, global::System.Int32 userCreateOrderID, global::System.DateTime orderDateCreate, global::System.DateTime orderLastUpdate, global::System.DateTime planStartDate, global::System.DateTime planStopDate, global::System.String orderText, global::System.String orderType, global::System.String agreeText, global::System.String agreeUsersIDS, global::System.String readyTime, global::System.Int32 orderObjectID, global::System.String orderObjectAddInfo, global::System.Boolean orderCreated, global::System.Boolean orderReviewed, global::System.Boolean orderOpened, global::System.Boolean orderClosed, global::System.Boolean orderCanceled, global::System.Boolean orderCompleted, global::System.Boolean orderCompletedWithoutEnter, global::System.Boolean orderExtended, global::System.Boolean orderAskExtended, global::System.Boolean orderIsExtend, global::System.Boolean orderIsFixErrorEnter, global::System.String orderState)
{
Orders orders = new Orders();
orders.orderNumber = orderNumber;
orders.userCreateOrderID = userCreateOrderID;
orders.orderDateCreate = orderDateCreate;
orders.orderLastUpdate = orderLastUpdate;
orders.planStartDate = planStartDate;
orders.planStopDate = planStopDate;
orders.orderText = orderText;
orders.orderType = orderType;
orders.agreeText = agreeText;
orders.agreeUsersIDS = agreeUsersIDS;
orders.readyTime = readyTime;
orders.orderObjectID = orderObjectID;
orders.orderObjectAddInfo = orderObjectAddInfo;
orders.orderCreated = orderCreated;
orders.orderReviewed = orderReviewed;
orders.orderOpened = orderOpened;
orders.orderClosed = orderClosed;
orders.orderCanceled = orderCanceled;
orders.orderCompleted = orderCompleted;
orders.orderCompletedWithoutEnter = orderCompletedWithoutEnter;
orders.orderExtended = orderExtended;
orders.orderAskExtended = orderAskExtended;
orders.orderIsExtend = orderIsExtend;
orders.orderIsFixErrorEnter = orderIsFixErrorEnter;
orders.orderState = orderState;
return orders;
}
public void refreshOrderFromDB(Orders dbOrder, OrdersUser currentUser, bool readRelated, List<Order> listOrders) {
if (listOrders != null) {
if (!listOrders.Contains(this)) {
listOrders.Add(this);
}
}
OrderOperation = OrderOperationEnum.none;
checkPremissions(dbOrder, currentUser);
SelOrderObject = OrderObject.getByID(dbOrder.orderObjectID);
OrderNumber = dbOrder.orderNumber;
OrderType = (OrderTypeEnum)Enum.Parse(typeof(OrderTypeEnum), dbOrder.orderType, true);
ReadyTime = dbOrder.readyTime;
CreateText = dbOrder.createText;
ReviewText = dbOrder.reviewText;
OpenText = dbOrder.openText;
CloseText = dbOrder.closeText;
CompleteText = dbOrder.completeText;
CancelText = dbOrder.cancelText;
OrderObjectAddInfo = dbOrder.orderObjectAddInfo;
OrderText = dbOrder.orderText;
AgreeText = dbOrder.agreeText;
AgreeUsersIDSText = dbOrder.agreeUsersIDS;
refreshAgreeUsers();
FaktStartDate = dbOrder.faktStartDate;
FaktStopDate = dbOrder.faktStopDate;
FaktCompleteDate = dbOrder.faktCompleteDate;
PlanStartDate = dbOrder.planStartDate;
PlanStopDate = dbOrder.planStopDate;
OrderDateReview = dbOrder.orderDateReview;
OrderDateClose = dbOrder.orderDateClose;
OrderDateOpen = dbOrder.orderDateOpen;
OrderDateCreate = dbOrder.orderDateCreate;
OrderDateComplete = dbOrder.orderDateComplete;
OrderDateCancel = dbOrder.orderDateCancel;
ExpiredReglamentHours = dbOrder.expiredReglamentHours;
ExpiredOpenHours = dbOrder.expiredOpenHours;
ExpiredCompleteHours = dbOrder.expiredCompleteHours;
ExpiredCloseHours = dbOrder.expiredCloseHours;
OrderIsExpiredClose = ExpiredCloseHours.HasValue && ExpiredCloseHours.Value < 0;
OrderIsExpiredOpen = ExpiredOpenHours.HasValue && ExpiredOpenHours.Value < 0;
OrderIsExpriredComplete = ExpiredCompleteHours.HasValue && ExpiredCompleteHours.Value < 0;
OrderIsExpiredReglament = ExpiredReglamentHours.HasValue && ExpiredReglamentHours.Value < 0;
CommentsText = dbOrder.commentsText;
HasComments = !String.IsNullOrEmpty(CommentsText) || !String.IsNullOrEmpty(CreateText);
UserCreateOrder = OrdersUser.loadFromCache(dbOrder.userCreateOrderID);
if (dbOrder.userReviewOrderID != null) {
UserReviewOrder = OrdersUser.loadFromCache(dbOrder.userReviewOrderID.Value);
}
if (dbOrder.userCloseOrderID != null) {
UserCloseOrder = OrdersUser.loadFromCache(dbOrder.userCloseOrderID.Value);
}
if (dbOrder.userCancelOrderID != null) {
UserCancelOrder = OrdersUser.loadFromCache(dbOrder.userCancelOrderID.Value);
}
if (dbOrder.userOpenOrderID != null) {
UserOpenOrder = OrdersUser.loadFromCache(dbOrder.userOpenOrderID.Value);
}
if (dbOrder.userCompleteOrderID != null) {
UserCompleteOrder = OrdersUser.loadFromCache(dbOrder.userCompleteOrderID.Value);
}
if (OrderExtended || OrderAskExtended ||OrderCompletedWithoutEnter) {
if (readRelated) {
ChildOrder = GetOrder(dbOrder.childOrderNumber.Value, currentUser, readRelated, listOrders);
} else {
ChildOrderNumber = dbOrder.childOrderNumber.Value;
}
} else {
ChildOrderNumber = 0;
}
if (OrderIsExtend||OrderIsFixErrorEnter) {
if (readRelated) {
ParentOrder = GetOrder(dbOrder.parentOrderNumber.Value, currentUser, readRelated, listOrders);
} else {
ParentOrderNumber = dbOrder.parentOrderNumber.Value;
}
} else {
ParentOrderNumber = 0;
}
OrderHasChildOrder = ChildOrderNumber > 0;
OrderHasParentOrder = ParentOrderNumber > 0;
checkTimeToOpen();
}
/// <summary>
/// Устаревший метод для добавления новых объектов в набор EntitySet Orders. Взамен можно использовать метод .Add связанного свойства ObjectSet<T>.
/// </summary>
public void AddToOrders(Orders orders)
{
base.AddObject("Orders", orders);
}
public void RegisterOrder(Order order, Guid guid) {
Logger.info("Пользователь создал/изменил заявку", Logger.LoggerSource.ordersContext);
try {
VotGESOrdersEntities context=new VotGESOrdersEntities();
Order prevOrder=null;
VotGESOrders.Web.ADONETEntities.Orders orderDB=null;
bool isNew=false;
try {
orderDB = context.Orders.First(o => o.orderNumber == order.OrderNumber);
if (orderDB == null)
isNew = true;
}catch{
isNew=true;
}
if (!isNew) {
Order tempOrder=new Order(orderDB, currentUser, false, null);
tempOrder.checkPremissions(orderDB, currentUser);
if (!tempOrder.AllowChangeOrder) {
throw new DomainException("Нельзя изменить заявку");
}
prevOrder=new Order(orderDB, currentUser, false, null);
} else {
orderDB=new Orders();
orderDB.userCreateOrderID = currentUser.UserID;
double maxNumber=1;
double newNumber=1;
try {
if (order.OrderIsExtend || order.OrderIsFixErrorEnter) {
maxNumber = context.Orders.Where(o => Math.Floor(o.orderNumber) == Math.Floor(order.ParentOrderNumber)).Max(o => o.orderNumber);
newNumber = maxNumber + 0.01;
} else {
maxNumber = context.Orders.Max(o => o.orderNumber);
maxNumber = Math.Floor(maxNumber);
newNumber = maxNumber + 1;
}
} catch { }
orderDB.orderNumber = newNumber;
orderDB.orderDateCreate = DateTime.Now;
}
orderDB.orderLastUpdate = DateTime.Now;
orderDB.orderCreated = true;
orderDB.orderState = OrderStateEnum.created.ToString();
orderDB.orderReviewed = false;
orderDB.orderOpened = false;
orderDB.reviewText = null;
orderDB.openText = null;
orderDB.orderDateReview = null;
orderDB.orderDateOpen = null;
orderDB.faktStartDate = null;
orderDB.userOpenOrderID = null;
orderDB.userReviewOrderID = null;
writeOrderToOrderDB(order, orderDB);
if ((order.OrderType == OrderTypeEnum.crash || order.OrderType==OrderTypeEnum.no) && !order.OrderIsExtend) {
Logger.info("===Аварийная/неотложная заявка", Logger.LoggerSource.ordersContext);
orderDB.orderReviewed = true;
orderDB.orderOpened = true;
orderDB.orderDateReview = DateTime.Now;
orderDB.orderDateOpen = DateTime.Now;
orderDB.userReviewOrderID = AutoUser.UserID;
orderDB.userOpenOrderID = AutoUser.UserID;
orderDB.reviewText = order.OrderType == OrderTypeEnum.crash?"Аварийная заявка":"Неотложная заявка";
orderDB.openText = order.OrderType == OrderTypeEnum.crash ? "Аварийная заявка" : "Неотложная заявка";
orderDB.faktStartDate = order.PlanStartDate;
orderDB.orderState = OrderStateEnum.opened.ToString();
}
if (order.OrderIsExtend) {
Logger.info("===Продленная заявка", Logger.LoggerSource.ordersContext);
Orders parentOrderDB=context.Orders.Where(o => o.orderNumber == order.ParentOrderNumber).First();
Order parentOrder=new Order(parentOrderDB, currentUser, false, null);
parentOrder.checkPremissions(parentOrderDB, currentUser);
if (!parentOrder.AllowExtendOrder && isNew) {
throw new DomainException("Заявка уже продлена");
}
if (isNew) {
parentOrderDB.orderDateComplete = DateTime.Now;
parentOrderDB.userCompleteOrderID = currentUser.UserID;
}
orderDB.userCreateOrderID = parentOrderDB.userCreateOrderID;
parentOrderDB.orderLastUpdate = DateTime.Now;
parentOrderDB.orderAskExtended = true;
parentOrderDB.orderState = OrderStateEnum.askExtended.ToString();
parentOrderDB.orderCompleted = true;
parentOrderDB.completeText = "Продление заявки";
parentOrderDB.faktCompleteDate = order.PlanStartDate;
orderDB.orderIsExtend = true;
orderDB.parentOrderNumber = order.ParentOrderNumber;
parentOrderDB.childOrderNumber = orderDB.orderNumber;
Order.writeExpired(parentOrderDB);
Order parentOrderNew=new Order(parentOrderDB, currentUser, false, null);
if (isNew) {
MailContext.sendMail(String.Format("Заявка №{0}. Продление заявки ({2}) [{1}]", parentOrderNew.OrderNumber.ToString(OrderInfo.NFI),
parentOrderNew.FullOrderObjectInfo, CurrentUser.FullName),
parentOrderNew, true, false);
}
}
if (order.OrderIsFixErrorEnter) {
Logger.info("===Заявка закрыта без ввода оборудования", Logger.LoggerSource.ordersContext);
Orders parentOrderDB=context.Orders.Where(o => o.orderNumber == order.ParentOrderNumber).First();
Order parentOrder=new Order(parentOrderDB, currentUser, false, null);
parentOrder.checkPremissions(parentOrderDB, currentUser);
if (!parentOrder.AllowCompleteWithoutEnterOrder&&isNew) {
throw new DomainException("Заявка уже закрыта");
}
orderDB.userCreateOrderID = parentOrderDB.userCreateOrderID;
if (isNew) {
parentOrderDB.orderDateComplete = DateTime.Now;
parentOrderDB.userCompleteOrderID = currentUser.UserID;
}
parentOrderDB.orderLastUpdate = DateTime.Now;
parentOrderDB.orderCompletedWithoutEnter = true;
parentOrderDB.orderCompleted = true;
parentOrderDB.completeText = "Закрытие без ввода оборудования";
parentOrderDB.orderState = OrderStateEnum.completedWithoutEnter.ToString();
parentOrderDB.faktCompleteDate = order.PlanStartDate;
orderDB.orderIsFixErrorEnter = true;
orderDB.parentOrderNumber = order.ParentOrderNumber;
parentOrderDB.childOrderNumber = orderDB.orderNumber;
Order.writeExpired(parentOrderDB);
if (isNew) {
Order parentOrderNew=new Order(parentOrderDB, currentUser, false, null);
MailContext.sendMail(String.Format("Заявка №{0}. Заявка закрыта без ввода оборудования ({2}) [{1}]",
parentOrderNew.OrderNumber.ToString(OrderInfo.NFI), parentOrderNew.FullOrderObjectInfo, CurrentUser.FullName),
parentOrderNew, true, false);
}
}
if (isNew) {
context.Orders.AddObject(orderDB);
}
Order.writeExpired(orderDB);
context.SaveChanges();
Logger.info("===Сохранено", Logger.LoggerSource.ordersContext);
LastUpdate.save(guid);
order.refreshOrderFromDB(orderDB, currentUser,false,null);
MailContext.sendMail(String.Format(isNew ? "Заявка №{0}. Создана новая заявка ({2}) [{1}]" : "Заявка №{0}. Заявка изменена ({2}) [{1}]",
order.OrderNumber.ToString(OrderInfo.NFI), order.FullOrderObjectInfo, CurrentUser.FullName),
order, true, false,prevOrder);
} catch (Exception e) {
Logger.error(String.Format("===Ошибка при создании/изменении заявки: {0}", e), Logger.LoggerSource.ordersContext);
if (e is DomainException) {
throw e;
}
throw new DomainException("Ошибка при создании/изменении заявки");
}
}
protected void writeOrderToOrderDB(Order order, Orders orderDB) {
orderDB.orderText = order.OrderText;
orderDB.agreeText = order.AgreeText;
orderDB.createText = order.CreateText;
orderDB.planStartDate = order.PlanStartDate;
orderDB.planStopDate = order.PlanStopDate;
orderDB.orderType = order.OrderType.ToString();
orderDB.orderObjectID = order.SelOrderObjectID;
orderDB.orderObjectAddInfo = order.OrderObjectAddInfo;
orderDB.readyTime = order.ReadyTime;
orderDB.agreeUsersIDS = order.AgreeUsersIDSText;
}
protected void checkOrder(Orders orderDB) {
if (!orderDB.orderReviewed) {
orderDB.orderDateReview = null;
orderDB.userReviewOrderID = null;
orderDB.reviewText = null;
}
if (!orderDB.orderOpened) {
orderDB.orderDateOpen = null;
orderDB.faktStartDate = null;
orderDB.userOpenOrderID = null;
orderDB.openText = null;
}
if (!orderDB.orderClosed) {
orderDB.orderDateClose = null;
orderDB.faktStopDate = null;
orderDB.userCloseOrderID = null;
orderDB.closeText = null;
}
if (!orderDB.orderCompleted) {
orderDB.orderDateComplete = null;
orderDB.faktCompleteDate = null;
orderDB.userCompleteOrderID = null;
orderDB.completeText = null;
}
if (!orderDB.orderCanceled) {
orderDB.orderDateCancel = null;
orderDB.userCancelOrderID = null;
orderDB.cancelText = null;
}
}
private void addComment(Orders orderDB, string commentText) {
if (!String.IsNullOrEmpty(orderDB.commentsText))
orderDB.commentsText = "\n"+Order.OrderCommentsDelim+"\n" + orderDB.commentsText;
orderDB.commentsText = String.Format("{1,20}[{0}] : {2}", DateTime.Now.ToString("dd.MM.yy HH:mm"), CurrentUser.FullName, commentText) + orderDB.commentsText;
}
