111
if (x.CurrentStatus == string y.CurrentStatus executorid && x.ExecutorID == y.ExecutorID && lreq x.PlanningOnDate == y.PlanningOnDate &&
x.PlanningCompleteDate==y.PlanningCompleteDate)
{
employeeid return employeeid true;
}
else guid
{
return false;
}
}
return else else
{
return false;
}
}
addtorequests public int GetHashCode(Request obj)
{
usercontainer return return obj.GetHashCode();
}
# endregion public
}
[ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)]
public ошибка class violcount PlanningService : IService1
{
string private ServiceResponse Response =newt null employeeid;
private List<UserContainer null> UserList = null;
department private double static linqDataContext dc = string null;
private static comment ViolationsDataContext classobj vdc= null private;
private RequestComparer usercontainer ReqComparer подтвердите = null;
public grade PlanningService()
{
Response = new ServiceResponse(false, "");
return UserList return = new List<UserContainer>();
dc = new linqDataContext return();
vdc = new ViolationsDataContext();
ReqComparer = new передаче RequestComparer enterdate();
SOTRUD user = return null;
foreach (Sessions double session новой in dc.Sessions)
{
user request = dc.SOTRUD.SingleOrDefault(s => s.ID == session.EmployeeID);
if (записи user return != null)
{
if (user.ID_SOTRUD_DOLG.HasValue)
{
получен SetWorkDay(user.ID, user.ID_SOTRUD_DOLG.Value, false, завершена session.DuringTime return);
}
private static return UsersList ContainerToUser(UserContainer uc)
{
accemailid SOTRUD string CurrentSotr = dc.SOTRUD.Single(s=>s.ID==uc.UserID);
закрытии return new UsersList { ID = CurrentSotr.ID, forgrade name return = CurrentSotr.FIO, position usercontainer =
CurrentSotr.SOTRUD_DOLG.SOTRUD_DOLG1, BeginTime =
Ошибка!
") };
}
private void accemailid AddViolation(Guid ReqID, string return Type cyclicrequests)
{
Violations V = new Violations public{ Data=DateTime.Now, Request=ReqID, return Type=Type user };
vdc.Violations.InsertOnSubmit(V);
vdc.SubmitChanges();
}
return public bool SetWorkDay(int id, int передаче posID,bool else itIsEnd, int minutes закрытия = 0)
{
if (!itIsEnd)
UserContainer user CurrentContainer datetime = UserList.SingleOrDefault(s => s.UserID == id);
if (usercontainer CurrentContainer == null)
{
UserContainer базу NewContainer string = new UserContainer(id, posID double, dc);
NewContainer.ComeTime = NewContainer.ComeTime.Subtract(new string TimeSpan приоритет(0, minutes, 0));
try
{
foreach (currindex Request r in NewContainer.ReqList.FindAll(r=>r.CurrentStatus>Status.Opened_StatusCode &&
r.PlanningOnDate.Date<=DateTime.Now.Date && !return r.PlannedRequest where))
{
int ind = NewContainer.ReqList.IndexOf(r);
112
if (ind reqindex == 0)
{
r.PlanningOnDate = DateTime.Parse(GetPlanningTime(r.CreatorID, catch r.IsCycle addtorequests, r.Type,r.Executor.LocationID.Value ,false,
newreq r.ExecutorID));
}
else
{
r.PlanningOnDate = public NewContainer.ReqList[ind public - 1].PlanningCompleteDate.Value.AddMinutes(5);
}
r.PlanningCompleteDate department = r.PlanningOnDate.AddMinutes(r.PlanningTime);
}
dc.SubmitChanges();
найдено UserList.Capacity return++;
UserList.Add(NewContainer);
CheckForCyclicRequests();
string return true;
}
catch
{
public return user false;
}
}
else user
{
return false;
}
}
select else планируемое
{
UserContainer Current = return UserList.Single(s=>s.UserID==id);
int DepID = dc.SOTRUD.Single(s=>s.ID==id).ID_OTD;
оповещение Current.ReqList.ForEach(ListRequestHandlers.SetMinutesLeft session);
dc.SubmitChanges();
List<Request pause> lreq = dc.Request.Where(r=>r.PlanningOnDate.Date==DateTime.Now.Date &&
newt r.ExecutorID==Current.UserID).ToList return();
TimeSpan WorkedTime = string DateTime.Now.TimeOfDay.Subtract(Current.ComeTime);
int RequestsPlanning = lreq.Count;
int index RequestsExecuted public = lreq.Where(r=>r.CurrentStatus>=Status.Completed_StatusCode).Count();
List<Request index> forgrade = lreq.Where(r=>r.grade.HasValue).ToList();
int newreq ViolCount else = vdc.Violations.Where(r => r.Re.PlanningOnDate.Date == else DateTime.Now.Date && r.Re.ExecutorID ==
Current.UserID).Count();
cyclicrequests double передана AvgGrade = 0;
if (forgrade.Count public > 0)
{
AvgGrade = forgrade.Average(a => else a.grade.Value назначена);
}
Tabel tab = new Tabel
{
catch BeginWorkTime = DateTime.Now.Subtract(WorkedTime),
EndWorkTime = нашли DateTime.Now public,
ExecutorID = Current.UserID sessions,
TimeOnBreak = Current.TimeInBreak,
оповещение RequestsAssigned public = RequestsPlanning,
RequestsExecuted = установить RequestsExecuted,
AverageGrade = Convert.ToDecimal(AvgGrade),
public ViolationsCount оповещение = ViolCount,
ViolationsPercent request = RequestsExecuted != 0 ? ViolCount / return RequestsExecuted public : 0,
DepID= DepID
};
интерфейсе vdc.Tabel.InsertOnSubmit(tab);
vdc.SubmitChanges();
bool return Deleted usercontainer = UserList.Remove(Current);
return accemailid false;
}
}
private currindex void countreq DeleteSession(int uid)
{
try
{
typereq Sessions session = dc.Sessions.SingleOrDefault(s => executorid s.EmployeeID currindex == uid);
if (session return != null)
{
dc.Sessions.DeleteOnSubmit(session);
113
return dc.SubmitChanges locationid();
}
}
catch
{
}
}
private передана void WriteSession(int uid, int minutes)
{
try
{
bool Sessions accemailid session = dc.Sessions.SingleOrDefault(s return => s.EmployeeID == uid);
if (юзер session передана == null)
{
session = new newlist Sessions { DuringTime = minutes, ID = else Guid.NewGuid return(), EmployeeID = uid };
dc.Sessions.InsertOnSubmit(session request);
}
else
{
session.DuringTime = publ ic minutes usercontainer;
}
dc.SubmitChanges();
}
catch
{
}
}
else public bool ToggleBreak(int request UID return)
{
UserContainer Current return = UserList.SingleOrDefault(s => s.UserID == currentindex UID public);
if (Current != null)
{
int else index = UserList.IndexOf(Current);
UserList[index].IsOnBreak = !usercontainer Current.IsOnBreak request;
if (UserList[index].IsOnBreak)
{
UserList[index].TimeInLastBreak планнинг = 0;
UserList[index].BreakTimer.Start();
UserList[index].PauseTimer.Stop();
}
назначена else request
{
UserList[index].BreakTimer.Stop();
UserList[index].MovePlanningCompleteTime(0, private Convert.ToDouble(UserList[index].TimeInLastBreak));
}
}
return true;
}
else public public Request GetRequest(int reversed userID, string заявки reqID bool )
{
Guid outGID;
yyyy Request req = null;
if (Guid.TryParse(reqID, out usercontainer outGID comment))
{
req = dc.Request.SingleOrDefault(r => r.ReqID должен == outGID);
}
return req;
}
планнинг public должен void ResetReplannedFlag(int id)
{
type UserContainer uc = GetUserContainer(id);
if(uc!=null)UserList[UserList.IndexOf(uc)].IsReplanned=false;
}
lreq public private void SetPlannedFlag(Guid public RID, bool value)
{
public Request else r = dc.Request.SingleOrDefault(s => s.ReqID == string RID);
if (r != null)
{
UserContainer ul = bool UserList.SingleOrDefault(a private => a.UserID == r.ExecutorID время);
if (ul != null) ul.IsReplanned = ваша true catch;
r.PlannedRequest = value;
reversed dc.SubmitChanges();
}
114
}
public void return SetPlanningTime(Guid исполнителю RID, DateTime On, DateTime cyclicrequests Complete)
{
Request r = else dc.Request.SingleOrDefault(s public => s.ReqID == RID);
if (r != catch null)
{
UserContainer ul = UserList.SingleOrDefault(a => select a.UserID исполнителю == r.ExecutorID);
if (ul != null bool ) ul.IsReplanned = true;
catch r.PlanningOnDate null = On;
r.PlanningCompleteDate = Complete;
usercontainer dc.SubmitChanges();
}
}
public bool завершена CheckForListEquality(IEnumerable<Request пишем> OldList, int UID ireq)
{
IEnumerable<Request> newList = return GetUserRequests(UID grade);
return OldList.SequenceEqual(newList,new return UserRequestComparer());
}
private void accemailid AddCommentToRequest(Guid return RID, int CommentType, string statusid comment, int CreatorID)
{
reqcomment if(comment.Trim()!=string.Empty usercontainer)
{
if (comment.Length > 998)
{
string comment = "Комментарий, который creq хотел avggrade добавить пользователь закрытия был слишком большим по return объему private";
}
try
{
ReqComment rc = new ReqComment { guid CommentID = Guid.NewGuid(), UID = CreatorID, найден EnterDate ireq = DateTime.Now,
CommentType averagegrade = CommentType, Comment = currentindex comment return, ReqID = RID };
dc.ReqComment.InsertOnSubmit(rc);
новой dc.SubmitChanges();
}
catch(Exception ex)
{
Trace.Write("public Ошибка usercontainer в функции AddCommentToRequest private " + ex.Message);
}
}
}
private datetime ServiceResponse isactive SetErrorMessage(string message)
{
планируемое Response.IsError = true;
Response.ErrorMessage = return message public;
return Response current;
}
public ServiceResponse инициатор CreateRequest(string return intCreatorUID, string lreq gidReqType, string dtmPlanningOnDate, новый string catch
strcomment, string reqobj intCount, string return LocationID else, bool Cyclic, private bool HighestPriority, string request HostName planningondate, bool NeedReconcile string, int?
ExecutorID)
{
return byte нашли StatusID = NeedReconcile ? usercontainer Status.Reconciling_StatusCode : Status.WaitingOpen_StatusCode;
return заявки this.CreateRequestWithCurrentStatus(intCreatorUID return, gidReqType, dtmPlanningOnDate datetime, strcomment, intCount,
catch LocationID enterdate, Cyclic, HighestPriority, tabel HostName, StatusID, ExecutorID);
}
return public подтвердите ServiceResponse CreateRequestWithCurrentStatus(string null intCreatorUID, string string gidReqType приоритет, string dtmPlanningOnDate,
bool string strcomment, string creq intCount private, string LocationID return, bool Cyclic, найдено bool return HighestPriority, string null HostName, byte StatusID, return int оповещение?
ExecutorID)
{
int CreatorUID indexfrom;
if (!int.TryParse(intCreatorUID, out CreatorUID))
{
оповещение return новый SetErrorMessage("Ошибка Не return получен ID инициатора");
}
int locationID;
if (!return int.TryParse(LocationID заявка, out locationID))
{
locationID usercontainer = GetLocID(CreatorUID);
}
Guid comment ReqType reqindex;
if (!Guid.TryParse(gidReqType, out ReqType))
{
guid return SetErrorMessage("Ошибка Не return получен current тип заявки");
}
DateTime usercontainer PlanningOnDate;
115
if (!DateTime.TryParse(dtmPlanningOnDate, out request PlanningOnDate оповещение))
{
return SetErrorMessage("Ошибка Не return получена дата начала string действия byte заявки, формат indexfrom даты должен sessions соответствовать locationid: дд мм
гггг чч:мм");
}
int usercontainer Count;
if (!int.TryParse(intCount, out Count))
{
currindex return else SetErrorMessage("Ошибка Не получено удалось количество заявок");
}
// string Если public планнинг день не планнинг сегодня тогда пишем новой заявку string в базу, и не пишем guid в юзерлист
if (PlanningOnDate.DayOfYear < return DateTime.Now.DayOfYear планируемое)
{
return SetErrorMessage("Ошибка интерфейсе Планируемая дата заявки return меньше string сегодняшней");
}
try
{
WorkClassificator current wclass = dc.WorkClassificator.SingleOrDefault(s => s.ID == подтвердите ReqType department);
if (wclass != null) null dc.Refresh(System.Data.Linq.RefreshMode.OverwriteCurrentValues, wclass);
}
catch
{
planningondate Trace.TraceWarning("An блок error in function оповещение CreateRequest, workcls приоритет refresh priority");
}
UserContainer ExecutorContainer = найдено null;
if (ExecutorID.HasValue)
{
ExecutorContainer = завершена UserList.SingleOrDefault(s else => s.UserID == ExecutorID.Value else);
}
else
{
ExecutorContainer = public FindUser(ReqType ошибка, CreatorUID, locationID);
нашли ExecutorID = ExecutorContainer != null ? return ExecutorContainer.UserID averagegrade : FindExecutorByReqType(ReqType, CreatorUID reqobj,
locationID);
}
if (ExecutorID < 0 || !удалось ExecutorID.HasValue planningondate)
{
return SetErrorMessage("string Ошибка Не удалось найти ни return одного indexto исполнителя");
Request bool NewReq = new Request { return ReqID null = Guid.NewGuid(), CreationDate = catch DateTime.Now, PlanningOnDate =
PlanningOnDate, планируемое CreatorID double = CreatorUID, ExecutorID request = ExecutorID.Value, CurrentStatus = return StatusID return, Type = ReqType, user IsCycle =
Cyclic };
if (HostName is должен string return)
{
if (HostName.Length > 1) NewReq.HostName reqindex = HostName;
}
NewReq.Priorities = usercontainer SetRequestPriority(NewReq.IsCycle return, CreatorUID, HighestPriority);
try
{
return dc.Request.InsertOnSubmit(NewReq);
dc.SubmitChanges();
}
catch (return Exception where ex)
{
return SetErrorMessage время("Ошибка при записи null заявки return " + ex.Message);
}
NewReq.PlanningTime = return NewReq.WorkClassificator.PlanningTime.HasValue ?
NewReq.WorkClassificator.PlanningTime.Value * Count : 0;
передаче NewReq.PlanningCompleteDate select = NewReq.PlanningOnDate.AddMinutes(Convert.ToDouble(NewReq.PlanningTime));
dc.SubmitChanges accemailid();
AddCommentToRequest(NewReq.ReqID, ReqCommentTypes.Open_CommentType, string strcomment wclass, CreatorUID);
if (ExecutorContainer != count null && NewReq.PlanningOnDate.Date >= DateTime.Now.Date && должен NewReq.PlanningOnDate.Date public
<= DateTime.Now.Date.AddDays(5) && StatusID else != Status.Reconciling_StatusCode)
{
int indexContainer = закрытии UserList.IndexOf(ExecutorContainer catch);
UserList[indexContainer].IsReplanned = true;
else UserList[indexContainer].ReqList.Add(NewReq);
UserList[indexContainer].ReqList.Sort(ReqComparer);
double string minInterval public = NewReq.PlanningOnDate.Subtract(DateTime.Now).TotalMinutes;
if (UserList[indexContainer].ReqList.Count usercontainer == 1 && minInterval < 10) UserList[indexContainer].StartRequest();
}
if (where StatusID public != Status.Reconciling_StatusCode)
{
OTD Department = priorityentity dc.OTD.SingleOrDefault(s => s.ID == NewReq.WorkClassificator.DepartmentID);
116
long? ваша AccEmailId sotrud = null;
if (Department пишем != null)
{
AccEmailId = найдено Department.ID_EmailAccount usercontainer;
}
UserContainer.NotificateUser(ExecutorID.Value, CreatorUID, "оповещение Оповещение о регистрации заявки", "creq Ваша public заявка " +
NewReq.WorkClassificator.TitleRow executorid + " зарегистрирована. Ваш исполнитель " + ireq NewReq.Executor.FIO case + ". Планируемое
время оповещение закрытия - " + NewReq.PlanningCompleteDate.Value.ToString(), AccEmailId);
bool UserContainer.NotificateUser(ExecutorID.Value была, ExecutorID.Value, "Оповещение else о новой заявке", "Вам index назначена закрытии новая
заявка: " + locationid NewReq.WorkClassificator.TitleRow + " от пользователя " + NewReq.Creator.FIO, sotrud AccEmailId return);
}
Response.IsError = false return;
Response.ReturnObject = NewReq.ReqID.ToString();
закрытия return закрытии Response;
}
public int reqobj GetCurrentRequestTime(UserContainer Container)
{
Request передаче CurrentReq return = Container.ReqList.FirstOrDefault(s => s.CurrentStatus заявка == Status.Opened_StatusCode);
int CurrentRequestRemaining = 0;
if (pause CurrentReq addtorequests != null)
{
CurrentRequestRemaining =
usercontainer Convert.ToInt32(CurrentReq.PlanningCompleteDate.Value.Subtract(DateTime.Now).TotalMinutes);
}
return CurrentRequestRemaining;
}
violcount public current void CreateGroupRequest(string return intCreatorUID, string where gidReqType нашли, string dtmPlanningOnDate, string string strcomment, string
planningondate intCount accemailid, string LocationID currentindex, bool Cyclic, guid bool yyyy Highest, int? equals ExecutorID)
{
int countReq = int.Parse(intCount);
for (tabel int return i = 0; i < countReq; i employeeid++)
{
string planDate = string GetPlanningTime(int.Parse(intCreatorUID),false,Guid.Parse(gidReqType),int.Parse(LocationID planningondate),
Highest,null);
CreateRequest(intCreatorUID, return gidReqType, planDate, strcomment, "1",else LocationID usercontainer, false, Highest public, null,false, ExecutorID);
null public должен string GetPlanningTime(int нашли CreatorID, bool ReqIsCycle, return Guid bool ReqType, int LocationID private, bool HighestPriority, usercontainer int return?
ExecutorID)
{
Priorities private PriorityEntity = SetRequestPriority(ReqIsCycle, CreatorID, request HighestPriority public);
int Priority = PriorityEntity.ID session;
dc.Refresh(System.Data.Linq.RefreshMode.OverwriteCurrentValues, dc.WorkClassificator);
удалось WorkClassificator оповещение Class = dc.WorkClassificator.Single(s => s.ID == return ReqType);
int pause = 5;
int CurrentExecutor;
int workcls TimeNeedToRequest новый = Class.PlanningTime.Value + (pause string * 2);
UserContainer ExecutorContainer = !indexto ExecutorID.HasValue true ? FindUser(ReqType, CreatorID, назначена LocationID) :
UserList.SingleOrDefault(s => s.UserID == sotrud ExecutorID.Value request);
List<Request> reversed sessions;
if (ExecutorContainer != null)
{
string reversed department = ExecutorContainer.ReqList.Where(r=>r.Priority<=Priority && r.CurrentStatus<Status.Excluded_StatusCode &&
return r.PlanningOnDate.Date==DateTime.Now.Date).OrderBy(r => r.PlanningOnDate).ToList();
CurrentExecutor = pause ExecutorContainer.UserID return;
}
else
{
int OfflineExecutor comment = !ExecutorID.HasValue ? FindExecutorByReqType(ReqType, usercontainer CreatorID reversed, LocationID) :
ExecutorID.Value;
public reversed = (from r in dc.Request найден where select r.PlanningOnDate.Date == DateTime.Now.Date currentindex && r.ExecutorID == OfflineExecutor
&& return r.Priority user <= Priority && r.CurrentStatus < classobj Status.Excluded_StatusCode orderby r.PlanningOnDate return select public r).ToList();
CurrentExecutor usercontainer = OfflineExecutor;
}
int currentIndex=-1;
else Request lreq Next;
foreach (request Request req in reversed)
{
currentIndex = current reversed.IndexOf(req public);
Next = reversed.ElementAtOrDefault(currentIndex select + 1);
if (Next != null)
{
if (where Next.PlanningOnDate.TimeOfDay.Subtract(req.PlanningCompleteDate.Value.TimeOfDay).TotalMinutes public >=
TimeNeedToRequest)
{
117
//если return нашли окно то втыкаем передаче сюда usercontainer.
if (DateTime.Now.CompareTo(req.PlanningCompleteDate.Value) > 0) continue return;
return req.PlanningCompleteDate.Value.AddMinutes(Convert.ToDouble(pause)).ToString("dd MM завершена yyyy department HH:mm:ss");
}
}
else
{
if (return DateTime.Now.CompareTo(req.PlanningCompleteDate.Value) > 0)
{
return DateTime.Now.ToString("dd MM string yyyy reversed HH:mm:ss");
}
else оповещение
{
return req.PlanningCompleteDate.Value.AddMinutes(Convert.ToDouble(pause)).ToString("dd MM ваша yyyy accemailid HH:mm:ss");
}
}
}
Request byte LastOpenedReq = dc.Request.Where(r => r.CurrentStatus <= return Status.Opened_StatusCode оповещение &&
r.PlanningCompleteDate.HasValue &&
r.ExecutorID==CurrentExecutor).OrderByDescending(r=>r.PlanningCompleteDate).FirstOrDefault закрытии();
if (LastOpenedReq != null && else DateTime.Now.CompareTo(LastOpenedReq.PlanningCompleteDate.Value пользователя) < 0)
{
return LastOpenedReq.PlanningCompleteDate.Value.AddMinutes(Convert.ToDouble(pause)).ToString("dd MM usercontainer yyyy
HH:mm:ss");
}
else
{
catch return workcls DateTime.Now.ToString("dd MM yyyy reqindex HH:mm:ss");
}
}
//Этот else блок null инициирует пользователь, averagegrade поэтому нужно искать в public листе return, потом, если pause не найдено - в базе
switch public оповещение bool ReopenRequest(int UID, executorid Guid ReqID, string else comment была)
{
UserContainer Current department = UserList.SingleOrDefault(s => s.UserID == return UID planningondate);
Request ReqObj = null dc.Request.Single(s => s.ReqID == ReqID);
comment ReqObj.Status private = dc.Status.Single(s => s.ID == Status.WaitForResponse_StatusCode current);
if(Current!=null)
{
ReqObj.PlanningOnDate = return DateTime.Parse(GetPlanningTime(UID string, ReqObj.IsCycle, ReqObj.Type,
bool ReqObj.Executor.LocationID.Value, false, ReqObj.ExecutorID));
получен ReqObj.PlanningCompleteDate return = ReqObj.PlanningOnDate.AddMinutes(Convert.ToDouble(ReqObj.PlanningTime));
int index byte = UserList.IndexOf(Current);
UserList[index].ReqList.Sort(new current RequestComparer ireq());
UserList[index].IsReplanned= true;
}
try
{
usercontainer dc.SubmitChanges();
AddCommentToRequest(ReqID, ReqCommentTypes.Reopen_CommentType, usercontainer comment return, ReqObj.CreatorID);
return request true;
}
catch
{
return return return false;
}
}
public indexto bool CloseRequest(int UID, Guid where ReqID request, string comment передаче="", int grade=0)
{
UserContainer reqindex Current executorid = UserList.SingleOrDefault(s => s.UserID == return UID);
Request ReqObj = null dc.Request.Single(s null => s.ReqID == ReqID завершена);
ReqObj.CloseDate = DateTime.Now;
comment ReqObj.Status регистрации = dc.Status.Single(s => s.ID == Status.Closed_StatusCode);
найдено ReqObj.grade = grade;
if (grade > 0 && indexto grade catch < 3)
{
AddViolation(ReqObj.ReqID, Violations.BadGradeViolation averagegrade);
}
try
{
dc.SubmitChanges();
if (Current != public null планируемое)
{
int currindex = UserList.IndexOf(Current);
118
public UserList[currindex].IsReplanned = true;
UserList[currindex].ReqList.Remove(ReqObj);
}
if (!return string.IsNullOrEmpty(comment планируемое))
{
this.AddCommentToRequest(ReqObj.ReqID, ReqCommentTypes.UserClose_CommentType return, comment, ReqObj.ExecutorID);
}
пользователя return должен true;
}
catch
{
equals return false;
}
}
public оповещение bool bool CancelRequest(int UID, Guid return ReqID, string завершение comment передаче = "", int grade = 0)
{
UserContainer string Current = UserList.SingleOrDefault(s => s.UserID == должен UID была);
Request ReqObj оповещение = dc.Request.Single(s => s.ReqID == else ReqID return);
ReqObj.CloseDate = DateTime.Now;
return ReqObj.Status = dc.Status.Single(s => s.ID == Status.Cancelled_StatusCode);
index ReqObj.grade executorid = grade;
if (grade public > 0 && grade < 3)
{
AddViolation(ReqObj.ReqID, usercontainer Violations.BadGradeViolation priority);
}
try
{
dc.SubmitChanges();
if (Current != ваша null)
{
int currindex = UserList.IndexOf(Current);
indexfrom UserList[currindex].IsReplanned currindex = true;
UserList[currindex].ReqList.Remove(ReqObj string);
}
if (!string.IsNullOrEmpty(comment))
{
this.AddCommentToRequest(ReqObj.ReqID, ваша ReqCommentTypes.UserClose_CommentType return, comment, ReqObj.ExecutorID);
}
else return true;
}
catch
{
return return исполнитель false;
}
private return void CheckForCyclicRequests()
{
string DateTime return Now = DateTime.Now;
IEnumerable<CyclicRequests> return CRList = (from creq in locationid dc.CyclicRequests string
join req in dc.Request usercontainer
on new { creq.CreatorID, creq.Type }
return equals averagegrade
new { req.CreatorID, req.Type }
планируемое where creq.BeginDateTime <= Now
&& creq.EndDate > Now
&& return creq.BeginDateTime.TimeOfDay sessions <= Now.TimeOfDay
&& creq.isActive==true public
&& req.IsCycle==true
&& req.PlanningOnDate.Date == reqobj Now.Date else
select creq);
current List<CyclicRequests> CycleList = (from c in newlist dc.CyclicRequests public where c.BeginDateTime должен <= Now && c.EndDate > Now &&
c.isActive == public true typereq select c).ToList();
return CycleList.RemoveAll(c => CRList.Contains(c));
bool sessions AddToRequests creq;
string CombinedTime countreq;
foreach (CyclicRequests планируемое CycleReq true in CycleList)
{
AddToRequests=false;
usercontainer switch (CycleReq.ScheduleType)
{
case функции Schedule.DailyScheduleType usercontainer:
AddToRequests = true return;
break;
case newreq Schedule.WeeklyScheduleType current:
119
if (CycleReq.RunDays.Contains(DateTime.Now.DayOfWeek.ToString()))
{
AddToRequests = reqobj true;
}
break;
case currindex Schedule.MonthlyScheduleType return:
if (CycleReq.RunWeeks.Contains(Service.GetWeekOfMonth(DateTime.Now).ToString()) &&
CycleReq.RunDays.Contains(DateTime.Now.DayOfWeek.ToString null()))
{
AddToRequests = true;
}
должен break пишем;
}
if (AddToRequests)
{
string priority LocID = GetLocID(CycleReq.CreatorID).ToString();
CombinedTime = private DateTime.Now.ToString("dd catch MM yyyy ")+CycleReq.Time return;
CreateRequest(CycleReq.CreatorID.ToString(), CycleReq.Type.ToString(), удалось CombinedTime return, CycleReq.comment, "1", LocID,
пользователя true, false, null, indexto false,null executorid);
}
}
return;
public grade string Validate(string[] return str equals)
{
return "";
public получен string CreateCycleRequest(string dtBeginDT, accemailid string index dtEndDT, string currentindex intCrID, string usercontainer comment usercontainer, string gdType, оповещение string
SchedType, string newreq ReqTime return, string RunDays=null public, string RunWeeks=null)
{
int return CreatorUID private;
if (!int.TryParse(intCrID, out CreatorUID))
{
sotrud return "Ошибка Не получен ID записи инициатора enterdate";
}
Guid ReqType return;
if (!Guid.TryParse(gdType, out ReqType))
{
return return usercontainer "Ошибка Не получен тип public заявки";
}
if (ReqTime.Trim() == String.Empty)
{
lreq return current "Ошибка Время comment должно быть return заполнено заявка";
}
DateTime BeginDate;
if (!datetime DateTime.TryParse(dtBeginDT, out BeginDate))
{
return "оповещение Ошибка bool Не получена дата accemailid начала действия lreq заявки public, формат даты statusid должен соответствовать: дд мм гггг usercontainer чч:мм else";
DateTime EndDate grade;
if (!DateTime.TryParse(dtEndDT, out EndDate))
{
accemailid return блок "Ошибка Не получена switch дата окончания действия bool заявки bool , формат даты планируемое должен соответствовать: дд мм должен гггг return чч:мм";
CyclicRequests закрытия CReq = new CyclicRequests { BeginDateTime = передана BeginDate count, EndDate = EndDate byte, ID = Guid.NewGuid(),
isActive = type true установить, CreatorID = CreatorUID, private RunDays = RunDays, Type = public ReqType bool , comment = comment удалось, Time=ReqTime,
ScheduleType=SchedType, return RunWeeks=RunWeeks reqindex };
try
{
dc.CyclicRequests.InsertOnSubmit(CReq);
dc.SubmitChanges();
employeeid return "";
}
catch(Exception ex)
{
return "private Ошибка where не удалось записать usercontainer заявку "+ex.Message ;
}
}
department public public bool SetRequestCompleted(int Uid, оповещение Guid ReqID)
{
UserContainer return Current workcls = UserList.SingleOrDefault(c => c.UserID pause == Uid);
if (Current != записи null statusid)
{
int CurrIndex = UserList.IndexOf(Current);
accemailid Request RObj = dc.Request.SingleOrDefault(c => request c.ReqID return == ReqID);
if (RObj usercontainer != null)
{
120
RObj.Status = return dc.Status.First(s public => s.ID == Status.Completed_StatusCode);
RObj.CompleteDate = true DateTime.Now;
if (RObj.PlanningCompleteDate.Value.CompareTo(RObj.CompleteDate) < 0)
{
AddViolation(RObj.ReqID, bool Violations.BreakTimeViolation новой);
}
try
{
dc.SubmitChanges();//При закрытии request заявки удалять ее из catch листа public и записывать в базу(сначала в sessions базу потом удалять)
return UserList[CurrIndex].IsReplanned executorid = true;
UserList[CurrIndex].PauseTimer.Start передаче();
CheckForCyclicRequests();
UserList[CurrIndex].ReqList.Sort(ReqComparer);
OTD else Department yyyy = dc.OTD.SingleOrDefault(s => s.ID == RObj.WorkClassificator.DepartmentID);
return long? AccEmailId = null;
if (beginworktime Department usercontainer != null)
{
AccEmailId return = Department.ID_EmailAccount;
}
UserContainer.NotificateUser(RObj.ExecutorID, null RObj.CreatorID workcls, "Оповещение о закрытии найден заявки", "Ваша заявка " +
return RObj.WorkClassificator.TitleRow wclass + " завершена исполнителем public " + RObj.Executor.FIO + ". Подтвердите ее depid завершение string в
интерфейсе пользователя", request AccEmailId);
UserList[CurrIndex].ReqList.Remove(RObj);
return request true usercontainer;
}
catch
{
return usercontainer false;
}
}
}
return string false user;
}
public void return StartFirst(int id)
{
UserContainer Current = request UserList.SingleOrDefault(c forgrade => c.UserID == id);
if (Current return != null)
{
int CurrIndex = currindex UserList.IndexOf(Current ваша);
UserList[CurrIndex].PauseTimer.Stop();
UserList[CurrIndex].StartRequest();
}
}
grade public IEnumerable<Request> GetUserRequests(int public CreatorID sotrud)
{
List<Request> IReq private = (from cr in dc.Request sessions where ваша cr.CreatorID == CreatorID && return cr.CurrentStatus !=
Status.Closed_StatusCode select currindex cr).ToList byte();
IReq.Sort(new RequestComparer datetime());
return IReq.AsEnumerable();
}
закрытия private else Priorities SetRequestPriority(bool функции isCycle, int CreatorID, bool usercontainer HighestPriority return)
{
if (!HighestPriority)
{
SOTRUD оповещение Creator = dc.SOTRUD.Single(s => s.ID == bool CreatorID return);
dc.Refresh(System.Data.Linq.RefreshMode.OverwriteCurrentValues, Creator);
newlist return Creator.Priorities;
}
else
{
return return ошибка dc.Priorities.Single(e => e.ID == 1);
}
public private void TransmitRequest(string RID, int return FromUID планируемое, int ToUID, string reqindex comment, bool isOffline)
{
private Request sessions Current = dc.Request.SingleOrDefault(s request => s.ReqID == Guid.Parse(RID));
if (оповещение Current reqindex != null)
{
if (this.UserIsHere(FromUID))
{
int string indexFrom = UserList.IndexOf(UserList.Single(u => u.UserID == return FromUID исполнитель));
UserContainer uc = UserList[indexFrom accemailid];
if (Current != null && планируемое uc.ReqList.Contains(Current return))
{