示例#1
0
		protected void fillData(VotGESOrdersEntities context,List<string> data,OrderObjects par,string level){
			IQueryable<OrderObjects> objects = from OrderObjects o in context.OrderObjects where o.parentID==par.objectID select o;
			data.Add(level+par.objectName);
			foreach (OrderObjects obj in objects){				
				fillData(context, data, obj, level + "=");
			}
		}
		protected void deleteOrderObject(VotGESOrdersEntities context,OrderObjects obj) {
			IQueryable<OrderObjects>childs=(from o in context.OrderObjects where o.parentID == obj.objectID select o);
			foreach (OrderObjects child in childs) {
				deleteOrderObject(context, child);				
			}
			context.DeleteObject(obj);
		}
		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("Ошибка при удалении оборудования, возможно на оборудование (или дочернее оборудование) ссылаются заявки");
			}
		}
示例#4
0
		public void RegisterChangeUser(OrdersUser newUser) {
			Logger.info("Пользователь изменил пользователя", Logger.LoggerSource.usersContext);
			try {
				if (!CurrentUser.AllowEditUsers) {
					throw new DomainException("У вас нет прав редактировать пользователей");
				}
				VotGESOrdersEntities context=new VotGESOrdersEntities();

				IQueryable<Users> users=(from u in context.Users where u.userID == newUser.UserID select u);
				Users user=null;
				if (users.Count()==0) {
					Logger.info("===Новый пользователь", Logger.LoggerSource.usersContext);
					user = new Users();
					user.name = newUser.Name;
					context.Users.AddObject(user);
				} else {
					user = users.First();
				}

				user.fullName = newUser.FullName;
				user.mail = newUser.Mail;
				user.sendAgreeMail = newUser.SendAgreeMail;
				user.sendAllMail = newUser.SendAllMail;
				user.sendCreateMail = newUser.SendCreateMail;
				user.sendAllAgreeMail = newUser.SendAllAgreeMail;
				user.sendAllCreateMail = newUser.SendAllCreateMail;
				user.allowChangeOrder = newUser.AllowChangeOrder;
				user.allowCreateOrder = newUser.AllowCreateOrder;
				user.allowCreateCrashOrder = newUser.AllowCreateCrashOrder;
				user.allowEditUsers = newUser.AllowEditUsers;
				user.allowEditOrders = newUser.AllowEditOrders;
				user.allowEditTree = newUser.AllowEditTree;
				user.allowAgreeOrders = newUser.AllowAgreeOrders;
				user.allowReviewOrder = newUser.AllowReviewOrder;
				user.canReviewCranTask = newUser.CanReviewCranTask;
				user.canReviewCranMZTask = newUser.CanReviewCranMZTask;
				user.canCreateCranTask = newUser.CanCreateCranTask;
				user.canAgreeCranTask = newUser.CanAgreeCranTask;
				user.sendAgreeCranTask = newUser.SendAgreeCranTask;
				user.sendAllCreateCranTask = newUser.SendAllCreateCranTask;
				user.sendAllAgreeCranTask = newUser.SendAllAgreeCranTask;
				user.sendAllCranTask = newUser.SendAllCranTask;
				user.sendOnlyMZCranTask = newUser.SendOnlyMZCranTask;
				
				context.SaveChanges();

				newUser.UserID = user.userID;
				OrdersUser.init();

				Logger.info("===Сохранено", Logger.LoggerSource.usersContext);

			} catch (Exception e) {
				Logger.error(String.Format("===Ошибка при изменении пользователя: {0}", e), Logger.LoggerSource.usersContext);
				if (e is DomainException) {
					throw e;
				}
				throw new DomainException("Ошибка при изменении пользователя");
			}
		}
示例#5
0
		public ActionResult ProcessAllExpiredOrders() {
			VotGESOrdersEntities context=new VotGESOrdersEntities();
			IQueryable<Orders> expiredOrders=from Orders o in context.Orders select o;
			foreach (Orders order in expiredOrders) {
				Order.writeExpired(order);
			}
			context.SaveChanges();
			return View();
		}
示例#6
0
		public ActionResult GetAllObjects() {
			VotGESOrdersEntities context = new VotGESOrdersEntities();
			IQueryable<OrderObjects> objects = from OrderObjects o in context.OrderObjects where o.objectID==0 select o;
			List<string> data = new List<string>();
			fillData(context, data, objects.ToArray()[0], "");
			String str = String.Join("<br>", data);
			Logging.Logger.info(str, Logging.Logger.LoggerSource.client);
			return View();

		}
示例#7
0
		public static void init() {
			allUsers = new List<OrdersUser>();
			context = new VotGESOrdersEntities();

			VotGESOrdersEntities ctx = new VotGESOrdersEntities();
			IQueryable<Users> dbUsers=from u in ctx.Users orderby u.fullName select u;
			foreach (Users dbUser in dbUsers) {
				allUsers.Add(getFromDB(dbUser));
			}
		}
示例#8
0
		public static void init() {
			Logger.info("Чтение списка объектов из БД", Logger.LoggerSource.server);
			allObjects = new Dictionary<int, OrderObject>();
			context = new VotGESOrdersEntities();

			VotGESOrdersEntities ctx = new VotGESOrdersEntities();
			IQueryable<OrderObjects> dbObjects=from oo in ctx.OrderObjects orderby oo.objectName select oo;
			foreach (OrderObjects dbObject in dbObjects) {
				allObjects.Add(dbObject.objectID, getFromDB(dbObject));
			}
			createNames();
			Logger.info("Чтение списка объектов из БД завершено", Logger.LoggerSource.server);
		}
		public void RegisterChangeOrderObject(OrderObject newObj) {
			Logger.info("Пользователь изменил оборудование", Logger.LoggerSource.objectsContext);
			try {
				if (!CurrentUser.AllowEditTree) {
					throw new DomainException("У вас нет прав редактировать оборудование");
				}
				VotGESOrdersEntities context=new VotGESOrdersEntities();

				IQueryable<OrderObjects> objectsDB=(from o in context.OrderObjects where o.objectID == newObj.ObjectID select  o);
				OrderObjects objDB=null;
				if (objectsDB.Count()==0) {
					Logger.info("===Новое оборудование", Logger.LoggerSource.objectsContext);
					objDB = new OrderObjects();
					context.OrderObjects.AddObject(objDB);
				} else {
					objDB = objectsDB.First();
				}
				objDB.objectName = newObj.ObjectName;
				objDB.parentID = newObj.ParentObjectID;
				objDB.showInFullName = newObj.ShowInFullName;

				context.SaveChanges();

				newObj.ObjectID = objDB.objectID;
				newObj.ObjectName = objDB.objectName;
				OrderObject.init();
				newObj.FullName = OrderObject.getByID(newObj.ObjectID).getFullName();
				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("Ошибка при изменении/создании оборудования");
			}
		}
示例#10
0
		public static ReturnMessage AddComment(CranTaskInfo task, string comment) {
			Logger.info("Добавление комментария к заявке на работу крана", Logger.LoggerSource.server);
			try {
				string result = "";
				OrdersUser currentUser = OrdersUser.loadFromCache(HttpContext.Current.User.Identity.Name);
				VotGESOrdersEntities eni = new VotGESOrdersEntities();
				CranTask tbl = new CranTask();

				CranTask tsk = (from t in eni.CranTask where t.Number == task.Number select t).FirstOrDefault();
				if (tsk == null) {
					return new ReturnMessage(false, "Заявка не найдена");
				}
				tbl = tsk;

				if (!string.IsNullOrEmpty(task.AgreeComments))
					task.AgreeComments += "\r\n";
				task.AgreeComments += String.Format("{2} {0}:\r\n   {1}", currentUser.FullName, comment, DateTime.Now.ToString("dd.MM.yyyy HH:mm"));
				tbl.AgreeComment = task.AgreeComments;


				eni.SaveChanges();
				string message = String.Format("Заявка на работу крана \"{0}\" №{1}. Комментарий", task.CranName, task.CranNumber);
				MailContext.sendCranTask(message, new CranTaskInfo(tbl));
				if (Managers != null) {
					if (!Managers.Contains(task.Manager)) {
						Managers.Add(task.Manager);
					}
				}
				else
					ReadManagers();
				return new ReturnMessage(true, "Комментарий добавлен");
			}
			catch (Exception e) {
				Logger.info("Ошибка при создании/изменении заявки на работу крана " + e.ToString(), Logger.LoggerSource.server);
				return new ReturnMessage(false, "ошибка при добавлении комментария");
			}
		}
示例#11
0
		public static ReturnMessage CreateCranTask(CranTaskInfo task) {
			Logger.info("Создание/изменение заявки на работу крана", Logger.LoggerSource.server);
			try {
				string result = "";
				string message = String.Format("Заявка на работу крана \"{0}\" №", task.CranName);
				OrdersUser currentUser = OrdersUser.loadFromCache(HttpContext.Current.User.Identity.Name);
				VotGESOrdersEntities eni = new VotGESOrdersEntities();
				CranTask tbl = new CranTask();
				if (task.init) {
					Logger.info("Определение номера заявки на кран", Logger.LoggerSource.server);
					tbl.State = "new";
					CranTask tsk = (from t in eni.CranTask orderby t.Number descending select t).FirstOrDefault();
					task.DateCreate = DateTime.Now;
					if (tsk != null) {
						task.Number = tsk.Number + 1;
					}
					else {
						task.Number = 1;
					}
					tbl.Allowed = false;
					tbl.Denied = false;
					tbl.Author = currentUser.Name;
					tbl.DateCreate = task.DateCreate;					
					task.Author = currentUser.FullName;
					eni.CranTask.AddObject(tbl);
					result = "Заявка на кран успешно создана";
				}
				else {
					CranTask tsk = (from t in eni.CranTask where t.Number == task.Number select t).FirstOrDefault();
					if (tsk == null) {
						return new ReturnMessage(false, "Заявка не найдена");
					}
					tbl = tsk;
					result = "Заявка на кран успешно изменена";
				}
				message += task.Number + ". ";

				if ((task.NeedEndDate <= task.NeedStartDate) || (task.Allowed && (task.AllowDateEnd <= task.AllowDateStart))) {
					return new ReturnMessage(false, "Дата окончания заявки больше чем дата начала");
				}

				tbl.Number = task.Number;
				tbl.CranName = task.CranName;
				tbl.AgreeComment = task.AgreeComments;
				tbl.NeedDateStart = task.NeedStartDate;
				tbl.NeedDateEnd = task.NeedEndDate;
				tbl.Comment = task.Comment;
				tbl.Manager = task.Manager;
				tbl.CranNumber = task.CranNumber;
				if (task.AgreeDict != null)
					tbl.AgreeUsersIDS = string.Join(";", task.AgreeDict.Keys);

				if (task.Finished) {
					tbl.State = "finished";
					result = "Заявка на кран завершена";
					tbl.RealDateStart = task.RealDateStart;
					tbl.RealDateEnd = task.RealDateEnd;
					tbl.AuthorFinish = currentUser.Name;
					tbl.Finished = true;
					message += " Заявка завершена";
				}
				else if (task.Allowed) {
					tbl.AllowedDateStart = task.AllowDateStart;
					tbl.AllowedDateEnd = task.AllowDateEnd;
					tbl.RealDateStart = task.AllowDateStart;
					tbl.RealDateEnd = task.AllowDateEnd;
					tbl.Denied = false;
					tbl.Allowed = true;
					tbl.Cancelled = false;
					tbl.State = "allowed";
					task.AuthorAllow = currentUser.FullName;
					result = "Заявка на кран разрешена";
					message += " Заявка разрешена";
				}
				else if (task.Denied) {
					tbl.AllowedDateStart = null;
					tbl.AllowedDateEnd = null;
					tbl.RealDateEnd = null;
					tbl.RealDateStart = null;
					tbl.Allowed = false;
					tbl.Denied = true;
					tbl.Cancelled = false;
					tbl.State = "denied";
					task.AuthorAllow = currentUser.FullName;
					result = "Заявка на кран отклонена";
					message += " Заявка отклонена";
				}
				else if (task.Cancelled) {
					tbl.State = "cancelled";
					tbl.Denied = false;
					tbl.Allowed = false;
					tbl.Cancelled = true;
					tbl.AuthorAllow = null;
					tbl.AllowedDateStart = null;
					tbl.AllowedDateEnd = null;
					tbl.RealDateEnd = null;
					tbl.RealDateStart = null;
					result = "Заявка на кран снята";
					message += " Заявка снята";
				}	else if (!task.init) {
					message += " Заявка изменена";
				}

				if (task.Allowed || task.Denied) {
					tbl.AuthorAllow = currentUser.Name;
				}

				eni.SaveChanges();
				MailContext.sendCranTask(message, new CranTaskInfo(tbl));
				if (Managers != null) {
					if (!Managers.Contains(task.Manager)) {
						Managers.Add(task.Manager);
					}
				}
				else
					ReadManagers();
				return new ReturnMessage(true, result);
			}
			catch (Exception e) {
				Logger.info("Ошибка при создании/изменении заявки на работу крана " + e.ToString(), Logger.LoggerSource.server);
				return new ReturnMessage(false, "Ошибка при создании/изменении заявки на работу крана");
			}
		}
示例#12
0
        public void RegisterDeleteUser(OrdersUser newUser)
        {
            Logger.info("Пользователь удалил пользователя", Logger.LoggerSource.usersContext);
            try {
                if (!CurrentUser.AllowEditUsers) {
                    throw new DomainException("У вас нет прав редактировать пользователей");
                }
                VotGESOrdersEntities context=new VotGESOrdersEntities();

                IQueryable<Users> users=(from u in context.Users where u.name.ToLower() == newUser.Name.ToLower() select u);
                Users user=null;
                user = users.First();

                context.DeleteObject(user);

                context.SaveChanges();
                OrdersUser.init();
                Logger.info("===Сохранено", Logger.LoggerSource.usersContext);

            } catch (Exception e) {
                Logger.error(String.Format("===Ошибка при удалении пользователя: {0}", e), Logger.LoggerSource.usersContext);
                if (e is DomainException) {
                    throw e;
                }
                throw new DomainException("Ошибка при удалении пользователя. Возможно на пользователя ссылаются заявки");
            }
        }
示例#13
0
		public void ReloadOrder(Order order) {
			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);
				Logger.info("===Заявка обновлена. Заявка №" + order.OrderNumber.ToString(OrderInfo.NFI), Logger.LoggerSource.ordersContext);
				order.refreshOrderFromDB(orderDB, currentUser, false, null);
			} catch (Exception e) {
				Logger.error(String.Format("===Ошибка при обновлении заявки №{1}: {0}", e, order.OrderNumber.ToString(OrderInfo.NFI)), Logger.LoggerSource.ordersContext);
				throw new DomainException(String.Format("Ошибка при обновлении заявки №{0}", order.OrderNumber.ToString(OrderInfo.NFI)));
			}
		}
示例#14
0
		public IQueryable<Order> getOrdersUserFilter(OrderFilter filter) {
			Logger.info("Получение списка заказов (фильтр)", Logger.LoggerSource.ordersContext);
			try {
				OrdersUser currentUser=OrdersUser.loadFromCache(HttpContext.Current.User.Identity.Name);
				VotGESOrdersEntities context=new VotGESOrdersEntities();

				List<String> states=filter.OrderStates;
				List<int> users=filter.SelectedUsersArray;
				List<String> orderTypes=filter.OrderTypes;

				List<int> ids=filter.SelectedObjectsArray;
				if (!filter.ShowAllObjectIDs && filter.ShowChildObjects) {
					List<OrderObject> objects=new List<OrderObject>();
					foreach (int id in ids) {
						objects.Add(VotGESOrders.Web.Models.OrderObject.getByID(id));
					}
					foreach (OrderObject obj in objects) {
						obj.appendObjectIDSChildIDS(ids);
					}
				}

				List<int> objectsByName=new List<int>();
				if (!filter.ShowAllObjects) {
					objectsByName = OrderObject.getObjectIDSByFullName(filter.OrderObject);
				}

				IQueryable<Orders> orders= 
				from o in context.Orders
				where
					(filter.ShowAllStates || states.Contains(o.orderState))
					&& (filter.ShowAllTime ||
						(filter.FilterDate == FilterDateType.create && o.orderDateCreate >= filter.DateStart && o.orderDateCreate <= filter.DateEnd) ||
						(filter.FilterDate == FilterDateType.review && o.orderDateReview >= filter.DateStart && o.orderDateReview <= filter.DateEnd) ||
						(filter.FilterDate == FilterDateType.cancel && o.orderDateCancel >= filter.DateStart && o.orderDateCancel <= filter.DateEnd) ||
						(filter.FilterDate == FilterDateType.faktStart && o.faktStartDate >= filter.DateStart && o.faktStartDate <= filter.DateEnd) ||
						(filter.FilterDate == FilterDateType.faktStop && o.faktStopDate >= filter.DateStart && o.faktStopDate <= filter.DateEnd) ||
						(filter.FilterDate == FilterDateType.faktEnter && o.faktCompleteDate >= filter.DateStart && o.faktCompleteDate <= filter.DateEnd) ||
						(filter.FilterDate == FilterDateType.planStart && o.planStartDate >= filter.DateStart && o.planStartDate <= filter.DateEnd) ||
						(filter.FilterDate == FilterDateType.planStop && o.planStopDate >= filter.DateStart && o.planStopDate <= filter.DateEnd))
					&& (filter.ShowAllUsers ||
						(filter.FilterUser == FilterUserType.create && users.Contains(o.userCreateOrderID)) ||
						(filter.FilterUser == FilterUserType.review && users.Contains(o.userReviewOrderID.Value)) ||
						(filter.FilterUser == FilterUserType.cancel && users.Contains(o.userCancelOrderID.Value)) ||
						(filter.FilterUser == FilterUserType.open && users.Contains(o.userOpenOrderID.Value)) ||
						(filter.FilterUser == FilterUserType.close && users.Contains(o.userCloseOrderID.Value)) ||
						(filter.FilterUser == FilterUserType.complete && users.Contains(o.userCompleteOrderID.Value)))
					&& (filter.ShowAllObjectIDs || ids.Contains(o.orderObjectID))
					&& (filter.ShowAllTypes || orderTypes.Contains(o.orderType))
					&& (filter.ShowAllObjects || objectsByName.Contains(o.orderObjectID) || o.orderObjectAddInfo.Contains(filter.OrderObject))
					&& (filter.ShowAllOrderTexts || o.orderText.Contains(filter.OrderText))
					&& (filter.ShowAllNumbers ||
						(o.orderNumber >= filter.StartNumber || filter.StartNumber == 0) &&
						(o.orderNumber <= filter.StopNumber || filter.StopNumber == 0))
					&& (!filter.ShowExpiredOnly ||
						 o.orderClosed && o.planStopDate < o.faktStopDate ||
						 o.orderCompleted && o.planStopDate < o.faktCompleteDate)
				select o;

				List<Order> resultOrders=new List<Order>();
				foreach (Orders orderDB in orders) {
					resultOrders.Add(new Order(orderDB, currentUser, false, null));
				}

				if (filter.ShowRelatedOrders) {
					IEnumerable<double> floorNumbers=from Order o in resultOrders select Math.Floor(o.OrderNumber);
					IEnumerable<double> numbers=from Order o in resultOrders select o.OrderNumber;
					IQueryable<Orders> relOrders=from o in context.Orders where floorNumbers.Contains(Math.Floor(o.orderNumber)) && !numbers.Contains(o.orderNumber) select o;
					foreach (Orders orderDB in relOrders) {
						resultOrders.Add(new Order(orderDB, currentUser, false, null));
					}
				}


				return resultOrders.AsQueryable();
			} catch (Exception e) {
				Logger.error("===Ошибка при получении списка заказов (фильтр) " + e.ToString(), Logger.LoggerSource.ordersContext);
				throw new DomainException(String.Format("Ошибка при получении списка заказов (фильтр)"));
			}
		}
示例#15
0
		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("Ошибка при создании/изменении заявки");
			}
		}
示例#16
0
		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)));
			}
		}
示例#17
0
		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)));
			}
		}
示例#18
0
		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)));
			}
		}
示例#19
0
		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)));
			}
		}
示例#20
0
		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)));
			}
		}
示例#21
0
		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)));
			}
		}
示例#22
0
		public static CranFilter LoadCranTasks(CranFilter Filter = null) {
			Logger.info("Получение списка заявок на кран", Logger.LoggerSource.server);
			if (Managers == null)
				ReadManagers();
			if (Filter == null) {
				Filter = new CranFilter();
				Filter.DateStart = DateTime.Now.Date;
				Filter.DateEnd = DateTime.Now.Date.AddDays(10);
			}
			Filter.Managers = Managers;
			VotGESOrdersEntities eni = new VotGESOrdersEntities();
			List<CranTaskInfo> result = new List<CranTaskInfo>();
			IQueryable<CranTask> data = from t in eni.CranTask
																	where
																		t.NeedDateStart > Filter.DateStart && t.NeedDateStart < Filter.DateEnd ||
																		t.NeedDateEnd > Filter.DateStart && t.NeedDateEnd < Filter.DateEnd ||
																		t.NeedDateStart < Filter.DateStart && t.NeedDateEnd > Filter.DateEnd ||
																		(t.Allowed &&
																		t.AllowedDateStart > Filter.DateStart && t.AllowedDateStart < Filter.DateEnd ||
																		t.AllowedDateEnd > Filter.DateStart && t.AllowedDateEnd < Filter.DateEnd ||
																		t.AllowedDateStart < Filter.DateStart && t.AllowedDateEnd > Filter.DateEnd)
																		orderby t.CranNumber,t.NeedDateStart
																	select t;
			foreach (CranTask tbl in data) {
				result.Add(new CranTaskInfo(tbl));
			}
			foreach (CranTaskInfo task in result) {
				task.hasCrossTasks = false;
				task.crossTasks = "";
				foreach (CranTaskInfo crossTask in result) {
					if (crossTask.Number == task.Number)
						continue;
					if (crossTask.CranNumber != task.CranNumber)
						continue;
					if (task.Denied || crossTask.Denied || task.Cancelled ||crossTask.Cancelled ||task.Finished || crossTask.Finished)
						continue;
					bool crossed = false;

					//Logger.info(String.Format("{0} - {1}",task.Number,crossTask.Number), Logger.LoggerSource.server);
					if (task.Allowed && crossTask.Allowed) {
						if (DatesCross(task.AllowDateStart, task.AllowDateEnd, crossTask.AllowDateStart, crossTask.AllowDateEnd)) {
							crossed = true;
						}

					}
					if (!task.Allowed && crossTask.Allowed) {
						if (DatesCross(task.NeedStartDate, task.NeedEndDate, crossTask.AllowDateStart, crossTask.AllowDateEnd)) {
							crossed = true;
						}
					}
					if (task.Allowed && !crossTask.Allowed) {
						if (DatesCross(task.AllowDateStart, task.AllowDateEnd, crossTask.NeedStartDate, crossTask.NeedEndDate)) {
							crossed = true;
						}
					}
					if (!task.Allowed && !crossTask.Allowed) {
						if (DatesCross(task.NeedStartDate, task.NeedEndDate, crossTask.NeedStartDate, crossTask.NeedEndDate)) {
							crossed = true;
						}
					}
					if (crossed) {
						task.hasCrossTasks = true;
						task.crossTasks += string.IsNullOrEmpty(task.crossTasks) ? crossTask.Number.ToString() : "," + crossTask.Number.ToString();
					}
				}
			}
			Filter.Data = result;
			return Filter;
		}
示例#23
0
		public static Order GetOrder(double oNumber, OrdersUser currentUser, bool readRelated, List<Order> listOrders){
			if (listOrders != null) {
				try{
					return (from Order o in listOrders where o.OrderNumber == oNumber select o).First();
				}
				catch{}
			} 
			Order newOrder=new Order();
			VotGESOrdersEntities context=new VotGESOrdersEntities();
			Orders orderDB=context.Orders.Where(o => o.orderNumber == oNumber).First();
			newOrder.refreshOrderFromDB(orderDB, currentUser, readRelated, listOrders);			
			return newOrder;			
		}
示例#24
0
		public static void ReadManagers() {
			Logger.info("Получение списка ответственных", Logger.LoggerSource.server);
			Managers = new List<string>();
			try {
				VotGESOrdersEntities eni = new VotGESOrdersEntities();
				IQueryable<string> data = (from t in eni.CranTask select t.Manager).Distinct();
				foreach (string name in data) {
					if (!(Managers.Contains(name))) {
						Managers.Add(name);
					}
				}
			}
			catch (Exception e) {
				Logger.info("Ошибка при чтении доступных ответственных " + e.ToString(), Logger.LoggerSource.server);
			}
		}
示例#25
0
		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)));
			}
		}