public void RegisterEditOrder(Order order, Guid guid) {
			Logger.info("Пользователь отредактировал заявку. Заявка №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
			try {
				OrderTypeEnum type=order.OrderType;
				VotGESOrdersEntities context=new VotGESOrdersEntities();
				Orders orderDB=context.Orders.First(o => o.orderNumber == order.OrderNumber);
				Order prevOrder=new Order(orderDB, currentUser, false, null);
				
				order.checkPremissions(orderDB, currentUser);
				if (order.AllowEditOrder) {
					orderDB.orderLastUpdate = DateTime.Now;

					writeOrderToOrderDB(order, orderDB);
					order.OrderType = type;
					if (prevOrder.OrderType != order.OrderType &&
							!order.OrderIsFixErrorEnter && !order.OrderIsExtend && !order.OrderExtended && !order.OrderAskExtended) {
						if ((order.OrderType == OrderTypeEnum.crash || order.OrderType == OrderTypeEnum.no) &&
							(prevOrder.OrderType == OrderTypeEnum.no || prevOrder.OrderType == OrderTypeEnum.crash) ) {
								orderDB.orderType = order.OrderType.ToString();
						} else if ((order.OrderType == OrderTypeEnum.npl || order.OrderType == OrderTypeEnum.pl) &&
							 (prevOrder.OrderType == OrderTypeEnum.pl || prevOrder.OrderType == OrderTypeEnum.npl)) {
							orderDB.orderType = order.OrderType.ToString();
						} else {
							orderDB.orderType = prevOrder.OrderType.ToString();
						}
					}
										
					if (orderDB.orderReviewed && order.OrderDateReview!=null) {
						orderDB.reviewText = order.ReviewText;
						orderDB.orderDateReview = order.OrderDateReview;
					}

					Logger.info(order.FaktStartDate.ToString(),Logger.LoggerSource.ordersContext);
					if (orderDB.orderOpened && order.FaktStartDate!=null) {
						orderDB.faktStartDate = order.FaktStartDate;
						orderDB.openText = order.OpenText;					
					}
					if (orderDB.orderClosed && order.FaktStopDate!=null) {
						orderDB.faktStopDate = order.FaktStopDate;
						orderDB.closeText = order.CloseText;
					}
					if (orderDB.orderCompleted && order.FaktCompleteDate!=null) {
						orderDB.faktCompleteDate = order.FaktCompleteDate;
						orderDB.completeText = order.CompleteText;
					}
					if (orderDB.orderCanceled) {						
						orderDB.cancelText = order.CancelText;
					}

					orderDB.commentsText = order.CommentsText;
					
					checkOrder(orderDB);
					Order.writeExpired(orderDB);
					context.SaveChanges();
					LastUpdate.save(guid);
					Logger.info("===Заявка отредактирована. Заявка №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
				} else {
					throw new DomainException("Нельзя отменить ввод оборудования");
				}
				order.refreshOrderFromDB(orderDB, currentUser, false, null);
				MailContext.sendMail(String.Format("Заявка №{0}. Заявка отредактирована ({2}) [{1}]", 
					orderDB.orderNumber.ToString(OrderInfo.NFI), order.FullOrderObjectInfo, CurrentUser.FullName),
					order, true, false,prevOrder);
			} catch (Exception e) {
				Logger.error(String.Format("===Ошибка при редактировании заявки №{1}: {0}", e, order.OrderNumber.ToString(OrderInfo.NFI)), Logger.LoggerSource.ordersContext);
				if (e is DomainException) {
					throw e;
				}
				throw new DomainException(String.Format("Ошибка при редактировании заявки №{0}", order.OrderNumber.ToString(OrderInfo.NFI)));
			}
		}
		public void CancelOrder(Order order, Guid guid) {
			Logger.info("Пользователь снял заявку №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
			try {
				VotGESOrdersEntities context=new VotGESOrdersEntities();
				Orders orderDB=context.Orders.First(o => o.orderNumber == order.OrderNumber);
				order.checkPremissions(orderDB, currentUser);
				if (order.AllowCancelOrder) {
					orderDB.orderLastUpdate = DateTime.Now;
					orderDB.orderDateCancel = DateTime.Now;
					orderDB.userCancelOrderID = currentUser.UserID;
					orderDB.cancelText = order.CancelText;
					orderDB.orderCanceled = true;
					orderDB.orderState = OrderStateEnum.canceled.ToString();

					if (order.OrderIsExtend) {
						Logger.info("===Продленная заявка", Logger.LoggerSource.ordersContext);
						Orders parentOrderDB=context.Orders.Include("Users").Where(o => o.orderNumber == order.ParentOrderNumber).First();
						parentOrderDB.orderLastUpdate = DateTime.Now;
						parentOrderDB.orderExtended = false;
						parentOrderDB.orderAskExtended = false;
						parentOrderDB.orderState = OrderStateEnum.opened.ToString();
						parentOrderDB.childOrderNumber = null;

						parentOrderDB.orderCompleted = false;
						parentOrderDB.orderDateComplete = null;
						parentOrderDB.completeText = null;
						parentOrderDB.faktCompleteDate = null;
						parentOrderDB.userCompleteOrderID = null;
						Order.writeExpired(parentOrderDB);
						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, false, false);
					}
					if (order.OrderIsFixErrorEnter) {
						Logger.info("===Аварийная заявка", Logger.LoggerSource.ordersContext);
						Orders parentOrderDB=context.Orders.Include("Users").Where(o => o.orderNumber == order.ParentOrderNumber).First();
						parentOrderDB.orderLastUpdate = DateTime.Now;
						parentOrderDB.orderCompletedWithoutEnter = false;
						parentOrderDB.orderState = OrderStateEnum.closed.ToString();
						parentOrderDB.childOrderNumber = null;

						parentOrderDB.orderCompleted = false;
						parentOrderDB.orderDateComplete = null;
						parentOrderDB.completeText = null;
						parentOrderDB.faktCompleteDate = null;
						parentOrderDB.userCompleteOrderID = null;
						Order.writeExpired(parentOrderDB);
						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, false, false);
					}
					Order.writeExpired(orderDB);
					context.SaveChanges();
					LastUpdate.save(guid);
					Logger.info("===Заявка. Снята заявка №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
				} else {
					throw new DomainException("Нельзя снять заявку");
				}
				order.refreshOrderFromDB(orderDB, currentUser, false, null);
				MailContext.sendMail(String.Format("Заявка №{0}. Заявка снята ({2}) [{1}]", 
					orderDB.orderNumber.ToString(OrderInfo.NFI), order.FullOrderObjectInfo, CurrentUser.FullName), 
					order, false, false);
			} catch (Exception e) {
				Logger.error(String.Format("===Ошибка при снятии заявки №{1}: {0}", e, order.OrderNumber.ToString(OrderInfo.NFI)), Logger.LoggerSource.ordersContext);
				if (e is DomainException) {
					throw e;
				}
				throw new DomainException(String.Format("Ошибка при снятии заявки №{0}", order.OrderNumber.ToString(OrderInfo.NFI)));
			}
		}
		public void RejectCompleteOrder(Order order, Guid guid) {
			Logger.info("Пользователь отменил ввод оборудования. Заявка №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
			try {
				VotGESOrdersEntities context=new VotGESOrdersEntities();
				Orders orderDB=context.Orders.First(o => o.orderNumber == order.OrderNumber);
				order.checkPremissions(orderDB, currentUser);
				if (order.AllowRejectCompleteOrder) {
					orderDB.orderLastUpdate = DateTime.Now;
					orderDB.orderDateComplete = null;
					orderDB.orderCompleted = false;
					orderDB.orderState = OrderStateEnum.closed.ToString();
					orderDB.completeText = null;
					orderDB.userCompleteOrderID = null;
					orderDB.faktCompleteDate = null;
					Order.writeExpired(orderDB);
					context.SaveChanges();
					LastUpdate.save(guid);
					Logger.info("===Отмена ввода оборудования. Заявка №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
				} else {
					throw new DomainException("Нельзя отменить ввод оборудования");
				}
				order.refreshOrderFromDB(orderDB, currentUser, false, null);
				MailContext.sendMail(String.Format("Заявка №{0}. Отмена ввода оборудования ({2}) [{1}]", 
					orderDB.orderNumber.ToString(OrderInfo.NFI),order.FullOrderObjectInfo, CurrentUser.FullName),
					order, false, false);
			} catch (Exception e) {
				Logger.error(String.Format("===Ошибка при отмене ввода оборудования по заявке №{1}: {0}", e, order.OrderNumber.ToString(OrderInfo.NFI)), Logger.LoggerSource.ordersContext);
				if (e is DomainException) {
					throw e;
				}
				throw new DomainException(String.Format("Ошибка при отмене ввода оборудования по заявке №{0}", order.OrderNumber.ToString(OrderInfo.NFI)));
			}
		}
		public void OpenOrder(Order order, Guid guid) {
			Logger.info("Пользователь открыл заявку  №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
			try {
				VotGESOrdersEntities context=new VotGESOrdersEntities();
				Orders orderDB=context.Orders.First(o => o.orderNumber == order.OrderNumber);
				order.checkPremissions(orderDB, currentUser);
				if (order.AllowOpenOrder) {
					orderDB.orderLastUpdate = DateTime.Now;
					orderDB.orderDateOpen = DateTime.Now;
					orderDB.faktStartDate = order.FaktStartDate;
					orderDB.userOpenOrderID = currentUser.UserID;
					orderDB.openText = order.OpenText;
					orderDB.orderOpened = true;
					orderDB.orderState = OrderStateEnum.opened.ToString();
					Order.writeExpired(orderDB);
					context.SaveChanges();
					LastUpdate.save(guid);
					Logger.info("===Заявка открыта. Заявка №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
				} else {
					throw new DomainException("Нельзя открыть заявку");
				}
				order.refreshOrderFromDB(orderDB, currentUser, false, null);
				MailContext.sendMail(String.Format("Заявка №{0}. Заявка открыта ({2}) [{1}]", 
					orderDB.orderNumber.ToString(OrderInfo.NFI), order.FullOrderObjectInfo, CurrentUser.FullName), 
					order, false, false);
			} catch (Exception e) {
				Logger.error(String.Format("===Ошибка при открытии заявки №{1}: {0}", e, order.OrderNumber.ToString(OrderInfo.NFI)), Logger.LoggerSource.ordersContext);
				if (e is DomainException) {
					throw e;
				}
				throw new DomainException(String.Format("Ошибка при открытии заявки №{0}", order.OrderNumber.ToString(OrderInfo.NFI)));
			}
		}
		public void RejectReviewOrder(Order order, Guid guid) {
			Logger.info("Пользователь отменил рассмотрение заявки  №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
			try {
				VotGESOrdersEntities context=new VotGESOrdersEntities();
				Orders orderDB=context.Orders.First(o => o.orderNumber == order.OrderNumber);
				order.checkPremissions(orderDB, currentUser);
				if (order.AllowRejectReviewOrder) {
					orderDB.orderLastUpdate = DateTime.Now;
					orderDB.orderDateReview = null;
					orderDB.orderDateOpen = null;
					orderDB.faktStartDate = null;
					orderDB.userOpenOrderID = null;
					orderDB.orderOpened = false;
					orderDB.userReviewOrderID = null;
					orderDB.reviewText = null;
					orderDB.orderReviewed = false;
					orderDB.orderState = OrderStateEnum.created.ToString();

					if (order.OrderIsExtend) {
						Logger.info("===Продленная заявка", Logger.LoggerSource.ordersContext);
						Orders parentOrderDB=context.Orders.Include("Users").Where(o => o.orderNumber == order.ParentOrderNumber).First();
						parentOrderDB.orderLastUpdate = DateTime.Now;
						parentOrderDB.orderExtended = false;
						parentOrderDB.orderAskExtended = true;
						parentOrderDB.orderState = OrderStateEnum.askExtended.ToString();
						Order.writeExpired(parentOrderDB);
						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, false, false);
					}
					Order.writeExpired(orderDB);
					context.SaveChanges();
					LastUpdate.save(guid);
					Logger.info("===Заявка. Отмена рассмотрения. Заявка №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);

				} else {
					throw new DomainException("Нельзя отменить рассмотрение заявки");
				}
				order.refreshOrderFromDB(orderDB, currentUser, false, null);
				MailContext.sendMail(String.Format("Заявка №{0}. Отмена рассмотрения заявки ({2}) [{1}]", 
					orderDB.orderNumber.ToString(OrderInfo.NFI), order.FullOrderObjectInfo, CurrentUser.FullName),
					order, true, false);
			} catch (Exception e) {
				Logger.error(String.Format("===Ошибка при отмене рассмотрения заявки №{1}: {0}", e, order.OrderNumber.ToString(OrderInfo.NFI)), Logger.LoggerSource.ordersContext);
				if (e is DomainException) {
					throw e;
				}
				throw new DomainException(String.Format("Ошибка при отмене рассмотрения заявки №{0}", order.OrderNumber.ToString(OrderInfo.NFI)));
			}
		}
		public void AcceptOrder(Order order, Guid guid) {
			Logger.info("Пользователь разрешил заявку №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
			try {
				VotGESOrdersEntities context=new VotGESOrdersEntities();
				Orders orderDB=context.Orders.First(o => o.orderNumber == order.OrderNumber);
				order.checkPremissions(orderDB, currentUser);
				if (order.AllowReviewOrder) {
					orderDB.orderLastUpdate = DateTime.Now;
					orderDB.orderDateReview = DateTime.Now;
					orderDB.userReviewOrderID = currentUser.UserID;
					orderDB.reviewText = order.ReviewText;
					orderDB.orderReviewed = true;
					
					orderDB.orderState = OrderStateEnum.accepted.ToString();

					if (order.OrderIsExtend) {
						Logger.info("===Продленная заявка", Logger.LoggerSource.ordersContext);
						Orders parentOrderDB=context.Orders.Where(o => o.orderNumber == order.ParentOrderNumber).First();
						
						orderDB.orderOpened = true;
						orderDB.openText = "Оборудование выведено. Заявка продлена";
						orderDB.userOpenOrderID = AutoUser.UserID;
						orderDB.orderState = OrderStateEnum.opened.ToString();
						orderDB.orderDateOpen = DateTime.Now;
						orderDB.faktStartDate = parentOrderDB.planStopDate;
						parentOrderDB.orderLastUpdate = DateTime.Now;
						parentOrderDB.orderExtended = true;
						parentOrderDB.orderAskExtended = false;
						parentOrderDB.orderState = OrderStateEnum.extended.ToString();
						Order.writeExpired(parentOrderDB);
						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, false, false);
					}
					Order.writeExpired(orderDB);
					context.SaveChanges();
					LastUpdate.save(guid);
					Logger.info("===Заявка разрешена. Заявка №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
				} else {
					throw new DomainException("Нельзя разрешить заявку");
				}
				order.refreshOrderFromDB(orderDB, currentUser, false, null);
				MailContext.sendMail(String.Format("Заявка №{0}. Заявка разрешена ({2}) [{1}]", 
					orderDB.orderNumber.ToString(OrderInfo.NFI), order.FullOrderObjectInfo, CurrentUser.FullName), 
					order, false, false);
			} catch (Exception e) {
				Logger.error(String.Format("===Ошибка при разрешении заявки №{1}: {0}", e, order.OrderNumber.ToString(OrderInfo.NFI)), Logger.LoggerSource.ordersContext);
				if (e is DomainException) {
					throw e;
				}
				throw new DomainException(String.Format("Ошибка при разрешении заявки №{0}", order.OrderNumber.ToString(OrderInfo.NFI)));
			}
		}
		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("Ошибка при создании/изменении заявки");
			}
		}
		public void RegisterAddComment(Order order, String commentText, Guid guid) {
			Logger.info("Пользователь добавил комментарий к заявке. Заявка №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
			try {
				VotGESOrdersEntities context=new VotGESOrdersEntities();
				Orders orderDB=context.Orders.First(o => o.orderNumber == order.OrderNumber);
				order.checkPremissions(orderDB, currentUser);

				addComment(orderDB, commentText);
				Order.writeExpired(orderDB);
				context.SaveChanges();
				LastUpdate.save(guid);
				Logger.info("===Добавлен комментарий. Заявка №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
				
				order.refreshOrderFromDB(orderDB, currentUser, false, null);
				MailContext.sendMail(String.Format("Заявка №{0}. Новый комментарий ({2}) [{1}]", 
					orderDB.orderNumber.ToString(OrderInfo.NFI), order.FullOrderObjectInfo, CurrentUser.FullName),
					order, true, false);
			} catch (Exception e) {
				Logger.error(String.Format("===Ошибка при комментировании заявки №{1}: {0}", e, order.OrderNumber.ToString(OrderInfo.NFI)), Logger.LoggerSource.ordersContext);
				if (e is DomainException) {
					throw e;
				}
				throw new DomainException(String.Format("Ошибка при комментировании заявки №{0}", order.OrderNumber.ToString(OrderInfo.NFI)));
			}
		}