Ejemplo n.º 1
0
 void SetState(RequestStage requestStage, bool requestEnable, LightToggle.State lightState, bool showTimer)
 {
     timer.Restart(GetSeconds(requestStage));
     this.requestStage = requestStage;
     request.SetEnable(requestEnable);
     light.Set(lightState);
     progressBar.gameObject.SetActive(showTimer);
 }
Ejemplo n.º 2
0
        public async Task <IActionResult> AddAction(int RequestID, int StageTypeID)
        {
            RequestStage requestStage = new RequestStage();

            requestStage.RequestID   = RequestID;
            requestStage.StageTypeID = StageTypeID;

            return(View(requestStage));
        }
Ejemplo n.º 3
0
        //// GET: Order/Requests/Delete/5
        //public async Task<IActionResult> Delete(int? id)
        //{
        //    if (id == null)
        //    {
        //        return NotFound();
        //    }

        //    var request = await _context.Requests
        //        .Include(r => r.RequestType)
        //        .SingleOrDefaultAsync(m => m.ID == id);
        //    if (request == null)
        //    {
        //        return NotFound();
        //    }

        //    return View(request);
        //}

        //// POST: Order/Requests/Delete/5
        //[HttpPost, ActionName("Delete")]
        //[ValidateAntiForgeryToken]
        //public async Task<IActionResult> DeleteConfirmed(int id)
        //{
        //    var request = await _context.Requests.SingleOrDefaultAsync(m => m.ID == id);
        //    _context.Requests.Remove(request);
        //    await _context.SaveChangesAsync();
        //    return RedirectToAction(nameof(Index));
        //}

        //private bool RequestExists(int id)
        //{
        //    return _context.Requests.Any(e => e.ID == id);
        //}



        public void AddStage(Request request, long pEmployeeID, int pStageTypeID, string pActionName, string pNote)
        {
            RequestStage obj = new RequestStage();

            obj.StageTypeID       = pStageTypeID;
            obj.EmployeeID        = pEmployeeID;
            obj.ActionName        = pActionName;
            obj.Justification     = pNote;
            request.RequestStages = new List <RequestStage>();
            request.RequestStages.Add(obj);
        }
Ejemplo n.º 4
0
        public async Task <IActionResult> PostRequestStage([FromBody] RequestStage requestStage)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            await unitOfWork.RequestStage.AddAsyn(requestStage);

            await unitOfWork.CompleteAsync();

            return(NoContent());
        }
Ejemplo n.º 5
0
    float GetSeconds(RequestStage stage)
    {
        switch (stage)
        {
        case RequestStage.Ready:
            return(UnityEngine.Random.Range(3, 10));

        case RequestStage.Progress:
            return(30 * request.GetChestLeft());

        case RequestStage.End:
            return(30);

        default:
            return(0);
        }
    }
Ejemplo n.º 6
0
    static RequestStage NextStage(RequestStage thisStage)
    {
        switch (thisStage)
        {
        case RequestStage.Ready:
            return(RequestStage.Progress);

        case RequestStage.Progress:
            return(RequestStage.End);

        case RequestStage.End:
            return(RequestStage.Ready);

        default:
            Debug.LogError("Ошибка");
            return(RequestStage.Ready);
        }
    }
Ejemplo n.º 7
0
        public async Task <IActionResult> ApprovalOrder([FromBody] RequestStage requestStage)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest("Bad Request"));
            }
            try
            {
                var userId = Convert.ToInt32(this.User.FindFirstValue(ClaimTypes.NameIdentifier));

                var obj = await _requestRepository.approvalOrder(requestStage, userId);

                return(Ok(obj));
            }
            catch (Exception ex)
            {
                //ModelState.AddModelError("error", ex.Message);
                return(BadRequest(ex.Message));
            }
        }
Ejemplo n.º 8
0
    void ChangeState(RequestStage newStage)
    {
        switch (newStage)
        {
        case RequestStage.Ready:
            SetReady();
            break;

        case RequestStage.Progress:
            SetProgress();
            break;

        case RequestStage.End:
            SetEnd();
            break;

        default:
            break;
        }
    }
Ejemplo n.º 9
0
        //
        // Returns a previous stage
        //
        private RequestStage FinishRequestStage(RequestStage stage)
        {
            if (NetEventSource.IsEnabled) NetEventSource.Info(this, $"state:{stage}");

            if (_exception != null)
                stage = RequestStage.ReleaseConnection;

            RequestStage prev;
            LazyAsyncResult writeResult;
            LazyAsyncResult readResult;
            FtpControlStream connection;

            lock (_syncObject)
            {
                prev = _requestStage;

                if (stage == RequestStage.CheckForError)
                    return prev;

                if (prev == RequestStage.ReleaseConnection &&
                    stage == RequestStage.ReleaseConnection)
                {
                    return RequestStage.ReleaseConnection;
                }

                if (stage > prev)
                    _requestStage = stage;

                if (stage <= RequestStage.RequestStarted)
                    return prev;

                writeResult = _writeAsyncResult;
                readResult = _readAsyncResult;
                connection = _connection;

                if (stage == RequestStage.ReleaseConnection)
                {
                    if (_exception == null &&
                        !_aborted &&
                        prev != RequestStage.ReadReady &&
                        _methodInfo.IsDownload &&
                        !_ftpWebResponse.IsFromCache)
                    {
                        return prev;
                    }

                    _connection = null;
                }
            }

            try
            {
                // First check to see on releasing the connection
                if ((stage == RequestStage.ReleaseConnection ||
                     prev == RequestStage.ReleaseConnection)
                    && connection != null)
                {
                    try
                    {
                        if (_exception != null)
                        {
                            connection.Abort(_exception);
                        }
                    }
                    finally
                    {
                        if (NetEventSource.IsEnabled) NetEventSource.Info(this, $"Releasing connection: {connection}");
                        connection.CloseSocket();
                        if (_async)
                            if (_requestCompleteAsyncResult != null)
                                _requestCompleteAsyncResult.InvokeCallback();
                    }
                }
                return prev;
            }
            finally
            {
                try
                {
                    // In any case we want to signal the writer if came here
                    if (stage >= RequestStage.WriteReady)
                    {
                        // If writeResult == null and this is an upload request, it means
                        // that the user has called GetResponse() without calling 
                        // GetRequestStream() first. So they are not interested in a 
                        // stream. Therefore we close the stream so that the 
                        // request/pipeline can continue
                        if (_methodInfo.IsUpload && !_getRequestStreamStarted)
                        {
                            if (_stream != null)
                                _stream.Close();
                        }
                        else if (writeResult != null && !writeResult.InternalPeekCompleted)
                            writeResult.InvokeCallback();
                    }
                }
                finally
                {
                    // The response is ready either with or without a stream
                    if (stage >= RequestStage.ReadReady && readResult != null && !readResult.InternalPeekCompleted)
                        readResult.InvokeCallback();
                }
            }
        }
Ejemplo n.º 10
0
        //
        // Returns a previous stage
        //
        private RequestStage FinishRequestStage(RequestStage stage)
        {
            GlobalLog.Print("FtpWebRequest#" + ValidationHelper.HashString(this) + "::FinishRequestStage : stage="+stage);
            if (m_Exception != null)
                stage = RequestStage.ReleaseConnection;

            RequestStage     prev;
            LazyAsyncResult  writeResult;
            LazyAsyncResult  readResult;
            FtpControlStream connection;

            lock (m_SyncObject)
            {
                prev = m_RequestStage;

                if (stage == RequestStage.CheckForError)
                    return prev;

                if (prev == RequestStage.ReleaseConnection && 
                    stage == RequestStage.ReleaseConnection)
                {
                    return RequestStage.ReleaseConnection;
                }

                if (stage > prev)
                    m_RequestStage = stage;

                if (stage <= RequestStage.RequestStarted)
                    return prev;

                writeResult  = m_WriteAsyncResult;
                readResult   = m_ReadAsyncResult;
                connection   = m_Connection;

                if (stage == RequestStage.ReleaseConnection)
                {
                    if (m_Exception == null &&
                        !m_Aborted &&
                        prev != RequestStage.ReadReady &&
                        this.m_MethodInfo.IsDownload && 
                        !m_FtpWebResponse.IsFromCache)
                    {
                        return prev;
                    }
                    if (m_Exception != null || !(m_FtpWebResponse.IsFromCache && !KeepAlive))
                        m_Connection = null;
                }
            }

            try {
                // First check to see on releasing the connection
                if ((stage == RequestStage.ReleaseConnection ||
                     prev  == RequestStage.ReleaseConnection)
                    && connection != null)
                {
                    try {
                        if (m_Exception != null)
                        {
                            connection.Abort(m_Exception);
                        }
                        else if (m_FtpWebResponse.IsFromCache && !KeepAlive)
                        {
                            // This means the response has been revalidated and found as good means the commands pipleline is completed.
                            // Now if this request was NOT KeepAlive we want to be fair and close the control connection.
                            // That becomes unnecessary complicated in the async case to support "QUIT" command semantic, so simply close the socket
                            // and let pool collect the object.
                            connection.Quit();
                        }
                    } finally {
                        if (Logging.On) Logging.PrintInfo(Logging.Web, this, "", SR.GetString(SR.net_log_releasing_connection, ValidationHelper.HashString(connection)));
                        m_ConnectionPool.PutConnection(connection, this, RemainingTimeout);
                        if (m_Async)
                            if (m_RequestCompleteAsyncResult != null)
                                m_RequestCompleteAsyncResult.InvokeCallback();
                    }
                }
                return prev;
            }
            finally {
                try {
                    // In any case we want to signal the writer if came here
                    if (stage >= RequestStage.WriteReady) {
                        // If writeResult == null and this is an upload request, it means
                        // that the user has called GetResponse() without calling 
                        // GetRequestStream() first. So they are not interested in a 
                        // stream. Therefore we close the stream so that the 
                        // request/pipeline can continue
                        if (m_MethodInfo.IsUpload && !m_GetRequestStreamStarted)
                        {
                            if (m_Stream != null)
                                m_Stream.Close();
                        }
                        else if (writeResult != null && !writeResult.InternalPeekCompleted)
                            writeResult.InvokeCallback();
                    }
                }
                finally {
                    // The response is ready either with or without a stream
                    if (stage >= RequestStage.ReadReady && readResult != null && !readResult.InternalPeekCompleted)
                        readResult.InvokeCallback();
                }
            }
        }
Ejemplo n.º 11
0
        public async Task <bool> approvalOrder(RequestStage requestStage, int UserID)
        {
            //requestStage.OrderStageID = 0;
            Request request = _context.Requests.Where(p => p.RequestID == requestStage.RequestID).FirstOrDefault();

            #region "Bussines"

            switch (request.StatusCode)
            {
            case "CSR03":
                throw new Exception("MSG_THIS_REQUEST_CANCELED");
                break;

            case "CSR04":
                throw new Exception("MSG_THIS_REQUEST_REJECTED");
                break;

            case "CSR05":
                throw new Exception("MSG_THIS_REQUEST_DONE");
                break;
            }
            // throw new Exception("MSG_STAGE_NOT_FOUND");

            #endregion

            using (SqlConnection con = new SqlConnection(_configuration.GetConnectionString("DatabaseConnection")))
            {
                var paramater1 = new DynamicParameters();
                paramater1.Add("@RequestID", requestStage.RequestID);
                paramater1.Add("@StageTypeID", requestStage.StageTypeID);
                paramater1.Add("@ActionCode", requestStage.ActionCode);
                paramater1.Add("@UserID", @UserID);
                paramater1.Add("@Justification", requestStage.Justification);

                var affectedRows = await con.ExecuteAsync("[ESS].ApprovalRequestInfo", paramater1, null, 0, commandType : CommandType.StoredProcedure);

                var emp  = employeesConcrete.FindBy(p => p.EmployeeID == request.EmployeeID).SingleOrDefault();
                var type = requestTypeConcrete.FindBy(p => p.RequestTypeID == request.RequestTypeID).SingleOrDefault();

                if (requestStage.ActionCode == "COR02")// اعتماد
                {
                    List <NextStageVM> nextStageVMs = await GetNextStageInfo(requestStage.RequestID, UserID);

                    if (nextStageVMs != null)
                    {
                        foreach (NextStageVM item in nextStageVMs)
                        {
                            if (item.UserId != null)
                            {
                                await notificationConcrete.SaveNotification(requestStage.RequestID, false, "NOT01", Convert.ToInt32(item.UserId), 1, UserID);

                                await emails.InsertEmailsNotifications($" طلب معتمد  {type.RequestNameAr}", $"يوجد طلب معتمد برقم {request.RequsetPrivateNumber}  للموظف {emp.ArabicName}", null, Convert.ToInt32(item.UserId), request.RequestID, false);
                            }
                        }
                    }
                }
                else if (requestStage.ActionCode == "COR03")// رفض
                {
                    await notificationConcrete.SaveNotification(requestStage.RequestID, false, "NOT01", Convert.ToInt32(request.UserID), 2, UserID);

                    await emails.InsertEmailsNotifications($" طلب مرفوض  {type.RequestNameAr}", $"يوجد طلب مرفوض برقم {request.RequsetPrivateNumber}  للموظف {emp.ArabicName}", null, Convert.ToInt32(request.UserID), request.RequestID, false);
                }

                if (affectedRows > 0)
                {
                    return(true);
                }
                return(false);
            }
        }
 private RequestStage FinishRequestStage(RequestStage stage)
 {
     RequestStage requestStage;
     LazyAsyncResult writeAsyncResult;
     LazyAsyncResult readAsyncResult;
     FtpControlStream connection;
     RequestStage stage3;
     if (this.m_Exception != null)
     {
         stage = RequestStage.ReleaseConnection;
     }
     lock (this.m_SyncObject)
     {
         requestStage = this.m_RequestStage;
         if (stage == RequestStage.CheckForError)
         {
             return requestStage;
         }
         if ((requestStage == RequestStage.ReleaseConnection) && (stage == RequestStage.ReleaseConnection))
         {
             return RequestStage.ReleaseConnection;
         }
         if (stage > requestStage)
         {
             this.m_RequestStage = stage;
         }
         if (stage <= RequestStage.RequestStarted)
         {
             return requestStage;
         }
         writeAsyncResult = this.m_WriteAsyncResult;
         readAsyncResult = this.m_ReadAsyncResult;
         connection = this.m_Connection;
         if (stage == RequestStage.ReleaseConnection)
         {
             if ((((this.m_Exception == null) && !this.m_Aborted) && ((requestStage != RequestStage.ReadReady) && this.m_MethodInfo.IsDownload)) && !this.m_FtpWebResponse.IsFromCache)
             {
                 return requestStage;
             }
             if (((this.m_Exception != null) || !this.m_FtpWebResponse.IsFromCache) || this.KeepAlive)
             {
                 this.m_Connection = null;
             }
         }
     }
     try
     {
         if (((stage == RequestStage.ReleaseConnection) || (requestStage == RequestStage.ReleaseConnection)) && (connection != null))
         {
             try
             {
                 if (this.m_Exception != null)
                 {
                     connection.Abort(this.m_Exception);
                 }
                 else if (this.m_FtpWebResponse.IsFromCache && !this.KeepAlive)
                 {
                     connection.Quit();
                 }
             }
             finally
             {
                 if (Logging.On)
                 {
                     Logging.PrintInfo(Logging.Web, this, "", SR.GetString("net_log_releasing_connection", new object[] { ValidationHelper.HashString(connection) }));
                 }
                 this.m_ConnectionPool.PutConnection(connection, this, this.RemainingTimeout);
                 if (this.m_Async && (this.m_RequestCompleteAsyncResult != null))
                 {
                     this.m_RequestCompleteAsyncResult.InvokeCallback();
                 }
             }
         }
         stage3 = requestStage;
     }
     finally
     {
         try
         {
             if (stage >= RequestStage.WriteReady)
             {
                 if (this.m_MethodInfo.IsUpload && !this.m_GetRequestStreamStarted)
                 {
                     if (this.m_Stream != null)
                     {
                         this.m_Stream.Close();
                     }
                 }
                 else if ((writeAsyncResult != null) && !writeAsyncResult.InternalPeekCompleted)
                 {
                     writeAsyncResult.InvokeCallback();
                 }
             }
         }
         finally
         {
             if (((stage >= RequestStage.ReadReady) && (readAsyncResult != null)) && !readAsyncResult.InternalPeekCompleted)
             {
                 readAsyncResult.InvokeCallback();
             }
         }
     }
     return stage3;
 }