public ResponseDTO <CategoriesDTO> CategoriesExecute(RequestDTO <CategoriesDTO> filter)
        {
            var response = new ResponseDTO <CategoriesDTO>();

            try
            {
                switch (filter.OperationType)
                {
                case OperationType.Delete:
                    response.Success = deleteCategory(filter.Item.CategoryIdentifier);
                    break;

                case OperationType.Create:
                    response.Success = createCategory(filter.Item);
                    break;

                case OperationType.Update:
                    response.Success = updateCategory(filter.Item);
                    break;
                }
            }
            catch (Exception exception)
            {
                throw;
            }
            return(response);
        }
示例#2
0
        /// <summary>
        /// Create a new Dungeon Master with the provided information from the API request &
        /// Create Request Objects between the new DM and all active players in the database.
        /// </summary>
        /// <param name="dungeonMaster">Dungeon Master information from the API request</param>
        /// <returns>Newly created Dungeon Master</returns>
        public async Task <DungeonMasterDTO> CreateDungeonMaster(DungeonMasterDTO dungeonMasterDTO)
        {
            DungeonMaster dungeonMaster = DeconstructDTO(dungeonMasterDTO);

            _context.Entry(dungeonMaster).State = EntityState.Added;
            var result = await _context.SaveChangesAsync();

            dungeonMasterDTO = await BuildDTO(dungeonMaster);

            dungeonMasterDTO.ActiveRequests = new List <RequestDTO>();

            var players = await _context.Players.Where(x => x.PartyId == 1).ToListAsync();

            if (players != null)
            {
                foreach (var player in players)
                {
                    RequestDTO newReq = await _request.CreateRequest(player.Id, dungeonMaster.Id);

                    dungeonMasterDTO.ActiveRequests.Add(newReq);
                }
            }
            PartyDTO newParty = new PartyDTO
            {
                DungeonMasterId = dungeonMasterDTO.Id,
                MaxSize         = dungeonMasterDTO.PartySize,
                Full            = false
            };

            dungeonMasterDTO.Party = await _party.CreateParty(newParty);

            dungeonMasterDTO.Id = dungeonMaster.Id;
            return(dungeonMasterDTO);
        }
示例#3
0
        public virtual async Task <IActionResult> Delete([FromBody] RequestDTO request)
        {
            try
            {
                var data = await _service.FindByIdAsync(request.Id);

                if (data == null)
                {
                    return(Json(ResponseExtension.AsResponseDTO <string>(null,
                                                                         (int)HttpStatusCode.NotAcceptable, _globalLocalizer["ItemNotFoundMessage"])));
                }

                await _service.DeleteAsync(request.Id, Token);

                return(Json(ResponseExtension.AsResponseDTO <string>(null,
                                                                     (int)HttpStatusCode.OK, _globalLocalizer["DeleteSuccessMessage"])));
            }
            catch (ValidationServiceException ex)
            {
                return(Json(ResponseExtension.AsResponseDTO <string>(null,
                                                                     (int)HttpStatusCode.NotAcceptable, ex.ToUlHtmlString())));
            }
            catch (ApplicationException ex)
            {
                RollbarLocator.RollbarInstance.Error(ex);
                return(Json(ResponseExtension.AsResponseDTO <string>(null,
                                                                     (int)HttpStatusCode.InternalServerError, ex.ToUlHtmlString())));
            }
            catch (Exception ex)
            {
                RollbarLocator.RollbarInstance.Error(ex);
                return(Json(ResponseExtension.AsResponseDTO <string>(null,
                                                                     (int)HttpStatusCode.InternalServerError, _globalLocalizer["DefaultError"])));
            }
        }
        public void Update(RequestDTO item)
        {
            try
            {
                if (item == null)
                {
                    throw new NullReferenceException("item is null");
                }

                Request request = DB.Requests.Get(item.Id);

                if (request == null)
                {
                    throw new Exception(String.Format("Request (id:{0}) is not found", item.Id));
                }

                request.Description = item.Description;
                request.StateId     = item.StateId;

                DB.Requests.Update(request);
                DB.Save();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message, ex);
            }
        }
        public void Handle(CreateRequestFromMessageCommand message)
        {
            var user = Sender(message);

            if (!IsMessageFromProject(user.Email) && !IsMessageFromTargetProcess(user.Email))
            {
                Data.Attachments = message.Attachments;
                Data.MessageDto  = message.MessageDto;

                Log().Info(string.Format("Creating request from message with id {0} in project {1}", message.MessageDto.ID,
                                         message.ProjectId));

                var requestDto = new RequestDTO
                {
                    OwnerID = message.MessageDto.FromID,
                    Name    = string.IsNullOrEmpty(message.MessageDto.Subject)
                                                                                                                                                ? string.Format("Created from Message with ID {0}", message.MessageDto.ID)
                                                                                                                                                : message.MessageDto.Subject,
                    Description = Utils.TextToHtml(message.MessageDto.Body ?? string.Empty),
                    ProjectID   = message.ProjectId,
                    SourceType  = RequestSourceEnum.Email,
                    IsPrivate   = message.IsPrivate,
                };
                Send(new CreateRequestCommand(requestDto));
            }
            else
            {
                Log().Info(
                    string.Format(
                        "Not creating request from message with id {0} in project {1} because it has been sent by TargetProcess or the project itself",
                        message.MessageDto.ID, message.ProjectId));
                MarkAsComplete();
            }
        }
        public async Task <RequestDTO> GetRequestById(int id)
        {
            var request = await Database.RequestManager.GetById(id);

            RequestDTO result;

            if (request != null)
            {
                result = new RequestDTO
                {
                    Id     = request.Id,
                    Type   = request.Type,
                    Time   = request.Time,
                    Status = request.Status
                };
                result.Sender = new UserDTO
                {
                    Id       = request.Sender.Id,
                    Name     = request.Sender.Name,
                    UserName = request.Sender.ApplicationUser.UserName
                };
                result.Receiver = new UserDTO
                {
                    Id       = request.Receiver.Id,
                    Name     = request.Receiver.Name,
                    UserName = request.Receiver.ApplicationUser.UserName
                };
            }
            else
            {
                result = null;
            }
            return(result);
        }
示例#7
0
        private void SetQueryParameters(RequestDTO request, Dictionary <string, string> localVarQueryParams)
        {
            if (request.TimezoneOffset != null)
            {
                localVarQueryParams.Add("timezoneOffset",
                                        Configuration.ApiClient.ParameterToString(request.TimezoneOffset)); // query parameter
            }

            if (request.Verbose != null)
            {
                localVarQueryParams.Add("verbose",
                                        Configuration.ApiClient.ParameterToString(request.Verbose)); // query parameter
            }

            if (request.SpellCheck != null)
            {
                localVarQueryParams.Add("spellCheck",
                                        Configuration.ApiClient.ParameterToString(request.SpellCheck)); // query parameter
            }

            if (request.Staging != null)
            {
                localVarQueryParams.Add("staging",
                                        Configuration.ApiClient.ParameterToString(request.Staging)); // query parameter
            }

            // authentication (apiKeyQuery) required
            if (!String.IsNullOrEmpty(Configuration.GetApiKeyWithPrefix("subscription-key")))
            {
                localVarQueryParams["subscription-key"] = Configuration.GetApiKeyWithPrefix("subscription-key");
            }
        }
        public static RequestDTO GetRequest(long requestId)
        {
            try
            {
                using (var ctx = new DAL.tutorDBEntities())
                {
                    var dbRequest = ctx.Requests.FirstOrDefault(x => x.id == requestId);
                    if (dbRequest != null)
                    {
                        var request = new RequestDTO
                        {
                            tutor   = BLL.Data.TutorData.GetTutor(dbRequest.tutorId),
                            student = BLL.Data.StudentData.GetStudent(dbRequest.studentId)
                        };

                        return(request);
                    }
                    throw new Exception($"Запрос не найден");
                }
            }
            catch (Exception ex)
            {
                return(null);
            }
        }
示例#9
0
        public void RespondToRequest_Accept_AccountsAreAddedToEachothersCircle()
        {
            using (var context = new InnerCircleDataContext(ContextOptions))
            {
                /// Arrange
                // Get requestService
                var requestService = new RequestService(context);

                // Create Request to account 2 from 1
                var request = new RequestDTO {
                    SenderId = 1, RecepientId = 2
                };
                requestService.SaveRequest(request);

                /// Act
                // Respond to the request
                requestService.RespondToRequest(1, "Accepted");

                /// Assert
                // Get the Circle Account 1 and 2
                var accountOneCircle = context.Circles.Include(c => c.Members).FirstOrDefault(c => c.AccountId == 1);
                var accountTwoCircle = context.Circles.Include(c => c.Members).FirstOrDefault(c => c.AccountId == 2);

                // Ensure that account1 circle has account 2 as member
                Assert.Contains(accountOneCircle.Members, c => c.AccountId == 2);

                // Ensure that account2 circle has account 1 as member
                Assert.Contains(accountTwoCircle.Members, c => c.AccountId == 1);
            }
        }
示例#10
0
        public void GetRequests_GivenUserWithThreeRequests_ReturnsAllRequests()
        {
            using (var context = new InnerCircleDataContext(ContextOptions))
            {
                /// Arrange
                // Get requestService
                var requestService = new RequestService(context);

                // Create Request to account 2 from 1
                var request = new RequestDTO {
                    SenderId = 1, RecepientId = 2
                };
                requestService.SaveRequest(request);

                // Create another Request to account 2 from 3
                request = new RequestDTO {
                    SenderId = 3, RecepientId = 2
                };
                requestService.SaveRequest(request);

                /// Act
                // Get requests for account one
                var requestsInDB = requestService.GetRequests(1);

                /// Assert
                // Ensure the total requests is one
                Assert.True(requestsInDB.Count == 1);
            }
        }
        public void Execute_Mapping_ShouldConvertEntityToDTO()
        {
            var request = new Request {
                Id           = 1,
                Url          = "Dummy",
                ResponseTime = new TimeSpan(1, 2, 3),
                SentAt       = new DateTime(1, 2, 3, 4, 5, 6),
                StatusCode   = "OK"
            };
            var extected = new RequestDTO {
                Id           = 1,
                Url          = "Dummy",
                ResponseTime = new TimeSpan(1, 2, 3),
                SentAt       = new DateTime(1, 2, 3, 4, 5, 6),
                StatusCode   = HttpStatusCode.OK
            };

            RequestDTO actulal = _mapper.Map <RequestDTO>(request);

            extected.Id.ShouldBe(actulal.Id);
            extected.Url.ShouldBe(actulal.Url);
            extected.ResponseTime.ShouldBe(actulal.ResponseTime);
            extected.SentAt.ShouldBe(actulal.SentAt);
            extected.StatusCode.ShouldBe(actulal.StatusCode);
        }
        public void GetAllRequestsCaseNotEmpty()
        {
            var requests = new List <Request>();

            requests.Add(oneRequest);
            requests.Add(anotherRequest);
            var requestLogicMock = new Mock <IRequestLogic>(MockBehavior.Strict);

            requestLogicMock.Setup(m => m.GetAll()).Returns(requests);
            var requestController = new RequestController(requestLogicMock.Object);
            var requestDTOs       = new List <RequestDTO>();

            foreach (Request req in requests)
            {
                RequestDTO tm = new RequestDTO(req);
                requestDTOs.Add(tm);
            }

            var result   = requestController.Get();
            var okResult = result as OkObjectResult;
            var value    = okResult.Value as List <RequestDTO>;

            requestLogicMock.VerifyAll();
            for (int i = 0; i < requests.Count; i++)
            {
                Assert.AreEqual(value[i], requestDTOs[i]);
            }
        }
示例#13
0
        /// <summary>
        /// Create a new Player Profile for a user in the database
        /// </summary>
        /// <param name="player">Player profile to be added to database</param>
        /// <returns>Newly created player</returns>
        public async Task <PlayerDTO> CreatePlayer(PlayerDTO playerDTO)
        {
            Player player = DeconstructDTO(playerDTO);

            player.PartyId = 1;
            _context.Entry(player).State = EntityState.Added;
            await _context.SaveChangesAsync();

            playerDTO = await BuildDTO(player);

            playerDTO.ActiveRequests = new List <RequestDTO>();
            // TODO: Only get DMs with a party that isn't already full
            var dms = await _context.DungeonMasters.ToListAsync();

            if (dms != null)
            {
                foreach (var dm in dms)
                {
                    RequestDTO newReq = await _request.CreateRequest(player.Id, dm.Id);

                    playerDTO.ActiveRequests.Add(newReq);
                }
            }
            playerDTO.Id = player.Id;
            return(playerDTO);
        }
示例#14
0
        public int PostRequestDTO(RequestDTO requestDTO)
        {
            return(_requestRepository.Add(requestDTO));
            // _requestRepository.Save();

            //return CreatedAtAction("GetRequestDTO", new { id = requestDTO.Id }, requestDTO);
        }
示例#15
0
        public RequestDTO GetRequestDetails(Guid id)
        {
            RequestDTO request   = new RequestDTO();
            Requests   requestDB = _mng.GetRequest(id);

            if (requestDB != null)
            {
                request.Id       = requestDB.id;
                request.CityInfo = new CityInfoDTO()
                {
                    CityName         = requestDB.Cities.name,
                    CityDistrictName = requestDB.CityDistricts.name
                };
                request.ClientInfo = new ClientInfoDTO()
                {
                    Name  = requestDB.ClientPersons.name,
                    Email = requestDB.ClientPersons.email
                };
                request.RecycleResourse = requestDB.RecycledResourses.name;
                request.RecycleWeight   = requestDB.recycleResoursesWeight;
                request.RequestDate     = requestDB.requestDate;
                request.Status          = requestDB.RequestStatuses.name;
                request.TakeOutAddress  = requestDB.takeOutAddress;
                request.TakeOutDate     = requestDB.takeOutDate;
            }
            return(request);
        }
示例#16
0
        public void MakeRequest(RequestDTO request)
        {
            if (request == null)
            {
                throw new ValidationException("Empty request instance argument", "");
            }

            Request newRequest = new Request
            {
                ApartmentClassId = request.ApartmentClassId,
                DateOfArrival    = request.DateOfArrival,
                DaysOfStay       = request.DaysOfStay,
                IsConfirmed      = false,
                IsProcessed      = false,
                IsCanceled       = false,
                NumberOfPlaces   = request.NumberOfPlaces,
                RequestDate      = DateTime.UtcNow,
                UserId           = request.UserId
            };

            try
            {
                DataBase.Requests.Create(newRequest);
                DataBase.Save();
            }
            catch (Exception ex)
            {
                // Залогировать "Exceptin: " + ex.Message + " in RequestService in MakeRequest method"
                throw ex;
            }
        }
示例#17
0
        public void RequestsControllerPostTestWithRanges()
        {
            var type                     = CreateContext();
            var additionalField          = CreateFieldLogicWithRanges(type);
            var RequestId                = Guid.NewGuid();
            var AdditionalFieldValueList = CreateFields(additionalField, RequestId, "01/15/1993");
            var Logic                    = CreateLogic();
            var Controller               = new RequestsController(Logic);

            Request Request = new Request()
            {
                Id                    = RequestId,
                RequestorsName        = "Just Testing",
                RequestorsEmail       = "*****@*****.**",
                RequestorsPhone       = "489498948894",
                TypeId                = type.Id,
                AdditionalFieldValues = AdditionalFieldValueList
            };

            var result        = Controller.Post(RequestDTO.ToModel(Request));
            var createdResult = result as CreatedAtRouteResult;
            var model         = createdResult.Value as RequestDTO;

            Assert.AreEqual(Request.AdditionalFieldValues.Count, model.AdditionalFieldValues.Count);
        }
示例#18
0
        // TODO
        public ResponseDTO CreateMember(RequestDTO<McMember> request)
        {
            ResponseDTO response = new ResponseDTO();
            McMember newMember = request.Inputs.First();

            if (newMember != null)
            {
                // New Member Validation
                if (!string.IsNullOrWhiteSpace(newMember.MemId)
                   && !string.IsNullOrWhiteSpace(newMember.FirstName)
                   && !string.IsNullOrWhiteSpace(newMember.LastName)
                   && newMember.DOB.HasValue)
                {
                    UnitOfWork.MemberRepo.Add(newMember);
                    UnitOfWork.Commit();

                    response.Results = ResponseResults.Success;
                }
                else
                {
                    response = ResponseUtility.CreateErrorResponse(ResponseResults.FailAndNoRetry, MemberExceptions.AddValidationFail);
                }
            }
            else
            {
                response = ResponseUtility.CreateErrorResponse(ResponseResults.FailAndNoRetry, MemberExceptions.InvalidMember);
            }

            return response;
        }
示例#19
0
        public async Task <Guid> Shorten(RequestDTO requestDTO)
        {
            var url = new Url();

            url.ReqUrl = requestDTO.ReqUrl;
            return(await UrlRepository.Shorten(url));
        }
示例#20
0
        public async Task <IActionResult> Calculate([FromBody] CalculateRequest request)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    RequestDTO requestDto = MapForecastRequestViewModel(request);

                    IEnumerable <ForecastResponseDTO> responseDto = await _orchestrator.Orchestration(requestDto);

                    CalculateResponse response = MapForecastResponseDto(responseDto);
                    return(Ok(response));
                }

                var errors = ModelState.Values
                             .SelectMany(x => x.Errors)
                             .Select(x => x.ErrorMessage).ToList();

                return(BadRequest(new CalculateResponse(errors)));
            }
            catch (Exception ex)
            {
                //logging
                return(BadRequest("Exception"));
            }
        }
示例#21
0
        public IActionResult getToken(RequestDTO request)
        {
            Console.WriteLine("Posted");


            var claims = new[]
            {
                new Claim(ClaimTypes.NameIdentifier, "1"),
                new Claim(ClaimTypes.Name, "Jan"),
                new Claim(ClaimTypes.Role, "admin"),
            };


            var key   = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(iconfig["JWT:Key"]));
            var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
            var token = new JwtSecurityToken(
                issuer: "Gakko",
                audience: "Students",
                claims: claims,
                expires: DateTime.Now.AddMinutes(10),
                signingCredentials: creds
                );

            return(Ok(new {
                token = new JwtSecurityTokenHandler().WriteToken(token),
                refreshToken = Guid.NewGuid()
            }));
        }
示例#22
0
 public override void OnAppearing()
 {
     UserDialogs.Instance.ShowLoading();
     Device.BeginInvokeOnMainThread(async () =>
     {
         History.Clear();
         var x = await Requestrepo.GetAllAsync();
         foreach (var item in x)
         {
             var temp = new RequestDTO();
             temp.CarId = item.CarId;
             var car = await Carrepository.GetByIdAsync(item.CarId);
             temp.CarModel = car.Model;
             temp.Price = item.Price;
             temp.AddedDate = item.AddedDate;
             if (item.DriverId > 0)
             {
                 temp.DriverId = item.DriverId;
                 var driver = await DriverRepo.GetByIdAsync((int)item.DriverId);
                 temp.Drivername = driver.Name;
             }
             else
             {
                 temp.Drivername = "No Driver";
             }
             History.Add(temp);
         }
         UserDialogs.Instance.HideLoading();
     });
     base.OnAppearing();
 }
示例#23
0
        public ResponseDTO Do(RequestDTO dto)
        {
            ResponseDTO res;

            if (dto == null)
            {
                res = new ResponseDTO()
                {
                    Success  = false,
                    ErrorMsg = "传入对象为空"
                }
            }
            ;
            try
            {
                ServiceTransfer st = new ServiceTransfer();
                res = st.Do(dto);
            }
            catch (Exception ex)
            {
                res = new ResponseDTO()
                {
                    Success  = false,
                    ErrorMsg = ex.InnerMessage(),
                    Context  = ""
                };
            }
            Log.Info($"{(UserApplication.HasLogin ? employee.Id : "未登录")}:{dto.ServiceName}", dto.Context, res);
            return(res);
        }
示例#24
0
        public void SaveRequest_ValidRequestDTO_RequestIsCreated()
        {
            // Create a new in memory context
            using (var context = new InnerCircleDataContext(ContextOptions))
            {
                /// Arrange
                // Create controller with the new context
                var requestService = new RequestService(context);

                // Create a request DTO for accounts already in db
                var request = new RequestDTO
                {
                    SenderId    = 1,
                    RecepientId = 2,
                };

                /// Act
                requestService.SaveRequest(request);

                /// Assert
                // Get a request from db with values in dto
                var dbRequest = context.Requests.FirstOrDefault(r => r.SenderId == request.SenderId && r.RecepientId == r.RecepientId);

                // Ensure it is not null
                Assert.NotNull(dbRequest);
            }
        }
示例#25
0
        public void Create(RequestDTO item)
        {
            try
            {
                if (item == null)
                {
                    throw new NullReferenceException("item is null");
                }

                Request request = DB.Requests.Get(item.Id);

                if (request != null)
                {
                    throw new Exception(String.Format("Request (id:{0}) already exist", item.Id));
                }

                Request res = new Request
                {
                    CreatedDate = DateTime.Now,
                    Description = item.Description,
                    StateId     = (Int32)RequestStates.New
                };

                DB.Requests.Create(res);
                DB.Save();

                CurrentRequest = res;

                NotifyObserver();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message, ex);
            }
        }
示例#26
0
        public string ProcessMediaContent(string oRqst)
        {
            ResponseDTO oResp = new ResponseDTO();

            oResp.response = new List <ResponseDTO.Response>();
            RequestDTO oReq = JsonConvert.DeserializeObject <RequestDTO>(oRqst);

            if (oReq != null && oReq.payload != null)
            {
                foreach (RequestDTO.Payload oPyld in oReq.payload)
                {
                    if (oPyld.drm == true && oPyld.episodeCount > 0)
                    {
                        ResponseDTO.Response oRes = new ResponseDTO.Response();
                        if (oPyld.image != null)
                        {
                            oRes.image = oPyld.image.showImage;
                        }
                        else
                        {
                            oRes.image = string.Empty;
                        }
                        oRes.slug  = oPyld.slug;
                        oRes.title = oPyld.title;
                        oResp.response.Add(oRes);
                    }
                }
                if (oResp.response.Count > 0)
                {
                    oResp.status = "success";
                    oResp.error  = null;
                }
            }
            return(JsonConvert.SerializeObject(oResp));
        }
        public RequestDTO RequestDTO([FromBody] RequestDTO request)
        {
            var dbUserRequester = _context.user.Find(request.RequesterID);
            var dbUserRequestee = _context.user.Find(request.RequesteeID);
            var offering        = _context.offering.Find(request.OfferingID);

            if (dbUserRequestee == null || dbUserRequester == null || offering == null)
            {
                return(null);
            }
            try
            {
                var dbRequest = new RequestDTO()
                {
                    RequesteeID = request.RequesteeID,
                    RequesterID = request.RequesterID,
                    OfferingID  = request.OfferingID,
                    Timestamp   = request.Timestamp
                };
                _context.request.Add(dbRequest);
                _context.SaveChanges();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(_context.request.Last());
        }
示例#28
0
        public IHttpActionResult add([FromBody] Request request)
        {
            RequestDTO requestDTO = new RequestDTO();

            string     loginId          = request.senderId.Replace(".", ",");
            FirebaseDB firebaseDB       = new FirebaseDB("https://myshop-b8424.firebaseio.com/");
            FirebaseDB firebaseDBTeams  = firebaseDB.Node("Requests").NodePath(loginId).Node(request.destinationId.Replace(".", ","));
            FirebaseDB firebaseDBTeams2 = firebaseDB.Node("Proposals").NodePath(request.destinationId.Replace(".", ",")).Node(loginId);


            requestDTO.status = request.destinationId.Replace(".", ",");

            dynamic foo = new ExpandoObject();

            foo.status = request.status;

            string           json        = Newtonsoft.Json.JsonConvert.SerializeObject(foo);
            FirebaseResponse getResponse = firebaseDBTeams.Get();

            if (Convert.ToString(getResponse.JSONContent) == "null")
            {
                FirebaseResponse putResponse = firebaseDBTeams.Post(JsonConvert.SerializeObject(json));

                FirebaseResponse putResponse2 = firebaseDBTeams2.Post(JsonConvert.SerializeObject(json));
                return(Ok("Resgistered Successfully"));
            }

            else
            {
                System.Diagnostics.Debug.WriteLine("Already present");
                return(BadRequest("User Already Registered with this Email Id"));
            }
        }
示例#29
0
 public override Task Init(object args)
 {
     UserDialogs.Instance.ShowLoading();
     Task.Run(async () =>
     {
         var x = await Requestrepo.GetAllAsync();
         foreach (var item in x)
         {
             var temp = new RequestDTO();
             temp.CarId = item.CarId;
             var car = await Carrepository.GetByIdAsync(item.CarId);
             temp.CarModel = car.Model;
             temp.Price = item.Price;
             temp.AddedDate = item.AddedDate;
             if (item.DriverId > 0)
             {
                 temp.DriverId = item.DriverId;
                 var driver = await DriverRepo.GetByIdAsync((int)item.DriverId);
                 temp.Drivername = driver.Name;
             }
             else
             {
                 temp.Drivername = "No Driver";
             }
             History.Add(temp);
         }
         UserDialogs.Instance.HideLoading();
     });
     return base.Init(args);
 }
示例#30
0
        public static long SendRequest(RequestDTO request)
        {
            try
            {
                using (var ctx = new DAL.tutorDBEntities())
                {
                    var dbRequest = ctx.Requests.FirstOrDefault(x => x.id == request.id) ?? ctx.Requests.Add(new DAL.Requests());

                    dbRequest.tutorId        = request.tutorId;
                    dbRequest.studentId      = request.studentId;
                    dbRequest.subjectId      = request.subjectId;
                    dbRequest.lessonsTypeId  = request.lessonTypeId;
                    dbRequest.additionalInfo = request.info;
                    dbRequest.status         = request.status;
                    dbRequest.date           = request.date;

                    ctx.SaveChanges();

                    return(dbRequest.id);
                }
            }
            catch (Exception ex)
            {
                throw;
                //return -1;
            }
        }
示例#31
0
        public ResponseDTO <bool> UpdateClass(RequestDTO <AddEditClassRequestDTO> model)
        {
            var entity = _mapper.Map <Class>(model.Data);

            Put(
                entity, true);
            return(Responses.OKUpdated <bool>("Assignment", true));
        }
		private static RequestDTO GetRequestDTO(int index)
		{
			var requestDto = new RequestDTO
			                 	{
			                 		ID = index,
			                 		Name = "Request " + index,
			                 		Description = "Hello, world",
			                 		EntityStateID = 1,
			                 		SourceType = RequestSourceEnum.Email,
			                 		RequestTypeID = 2
			                 	};
			return requestDto;
		}
        public ResponseDTO<ClienteModel> Listar(RequestDTO<ClienteModel> pedido_)
        {
            // Simulamos uma lista de registros
            _resposta.DataExecucao = DateTime.Now;
            _cronometro.Start();

            _resposta.ListModel = new List<ClienteModel>
            {
                new ClienteModel { Codigo = 1, Nome = "Zina", Email = "Zinamen" },
                new ClienteModel { Codigo = 2, Nome = "RachaCuca", Email = "RachaCucamen" }
            };

            _cronometro.Stop();
            _resposta.TempoExecucao = _cronometro.Elapsed;
            _resposta.MensagemProcessamento = "Clientes Recuperados com sucesso";
            _resposta.TipoMensagem = TipoMensagem.Sucesso;

            return _resposta;
        }
        public ResponseDTO<ClienteModel> Cadastrar(RequestDTO<ClienteModel> pedido_)
        {
            // Assim que entrou no serviço já setamos os campos administrativos (rastreamento)
            _resposta.DataExecucao = DateTime.Now;

            // Começou a monitorar, contrar o tempo
            _cronometro.Start();

            if (pedido_.NovoCliente == null)
            {
                _resposta.MensagemProcessamento = "Cliente Vazio";
                _resposta.TipoMensagem = TipoMensagem.Aviso;

                _cronometro.Stop();
                _resposta.TempoExecucao = _cronometro.Elapsed;

                return _resposta;
            }

            if (String.IsNullOrEmpty(pedido_.NovoCliente.Nome))
            {
                _resposta.MensagemProcessamento = "Informe o Nome";
                _resposta.TipoMensagem = TipoMensagem.Aviso;

                _cronometro.Stop();
                _resposta.TempoExecucao = _cronometro.Elapsed;

                return _resposta;
            }

            // Desligou o cronometro (parou de contar)
            _cronometro.Stop();
            // Pegando o tempo de monitoramento, pelo atributo Elapsed;
            _resposta.TempoExecucao = _cronometro.Elapsed;

            _resposta.MensagemProcessamento = "Cadastro com Sucesso";
            _resposta.TipoMensagem = TipoMensagem.Sucesso;

            return _resposta;
        }
示例#35
0
        public ResponseDTO GetAllCaseDocumentsByMember(RequestDTO<McMember> request)
        {
            McMember criteria = request.Inputs.First();

            if (criteria == null)
                throw new ArgumentNullException(CaseDocumentExceptions.InvalidCaseDocument);

            return CaseDocSearchEngine.SearchAll(x => x.McMemberId == criteria.McMemberId);
        }
示例#36
0
        public ResponseDTO UpdateCaseDocumentStatus(RequestDTO<CaseDocument> request)
        {
            ResponseDTO response = new ResponseDTO();

            CaseDocument caseDocumentCriteria = request.Inputs.First();

            if (caseDocumentCriteria != null)
            {
                var modifiedCaseDoc = UnitOfWork.CaseDocumentRepo.GetFirst(x => x.CaseDocumentId == caseDocumentCriteria.CaseDocumentId);

                modifiedCaseDoc.CaseDocumentStatusId = caseDocumentCriteria.CaseDocumentStatusId;
                UnitOfWork.CaseDocumentRepo.Update(modifiedCaseDoc);
                UnitOfWork.Commit();
                response.Results = ResponseResults.Success;

            }
            else
            {
                response = ResponseUtility.CreateErrorResponse(
                                ResponseResults.FailAndNoRetry,
                                new string[] { CaseDocumentExceptions.InvalidCaseDocument }
                                );
            }

            return response;
        }
示例#37
0
        public ResponseDTO GetAllCaseDocumentsBySyncDate(RequestDTO<CaseDocument> request)
        {
            CaseDocument criteria = request.Inputs.First();

            if (criteria == null)
                throw new ArgumentNullException(CaseDocumentExceptions.InvalidCaseDocument);

            return CaseDocSearchEngine.SearchAll(x => x.SyncDate == criteria.SyncDate);
        }
示例#38
0
        public ResponseDTO GetAllCaseDocumentsByProcess(RequestDTO<Process> request)
        {
            Process criteria = request.Inputs.First();

            if (criteria == null)
                throw new ArgumentNullException(CaseDocumentExceptions.InvalidCaseDocument);

            return CaseDocSearchEngine.SearchAll(x => x.ProcessId == criteria.ProcessId);
        }
示例#39
0
        public ResponseDTO GetAllProcessesByMember(RequestDTO<McMember> request)
        {
            McMember criteria = request.Inputs.First();

            if (criteria == null)
                throw new ArgumentNullException(MemberExceptions.InvalidMember);

            return ProcessSearchEngine.Search(x => x.McMemberId == criteria.McMemberId);
        }
示例#40
0
        public ResponseDTO GetAllMembersByName(RequestDTO<McMember> request)
        {
            McMember criteria = request.Inputs.First();

            if (criteria == null)
                throw new ArgumentNullException(MemberExceptions.InvalidMember);

            // Last Name Only
            if (!string.IsNullOrWhiteSpace(criteria.LastName) && string.IsNullOrWhiteSpace(criteria.FirstName))
            {
                return MemberSearchEngine.SearchAll(x => x.LastName.ToLower() == criteria.LastName.Trim().ToLower());
            }
            // First Name Only
            if (string.IsNullOrWhiteSpace(criteria.LastName.ToLower()) && !string.IsNullOrWhiteSpace(criteria.FirstName))
            {
                return MemberSearchEngine.SearchAll(x => x.FirstName.ToLower() == criteria.FirstName.Trim().ToLower());
            }
            // Both
            return MemberSearchEngine.SearchAll(x => x.FirstName.ToLower() == criteria.FirstName.Trim().ToLower()
                                                && x.LastName.ToLower() == criteria.LastName.Trim().ToLower()
                                                );
        }
示例#41
0
        public ResponseDTO GetCaseDocumentById(RequestDTO<CaseDocument> request)
        {
            CaseDocument criteria = request.Inputs.First();

            return CaseDocSearchEngine.Search(x => x == criteria);
        }
示例#42
0
        public ResponseDTO GetCaseDocumentByGuid(RequestDTO<CaseDocument> request)
        {
            CaseDocument criteria = request.Inputs.First();

            if (criteria == null)
                throw new ArgumentNullException(CaseDocumentExceptions.InvalidCaseDocument);

            return CaseDocSearchEngine.Search(x => x.CaseDocumentUid == criteria.CaseDocumentUid);
        }
示例#43
0
        public ResponseDTO GetMemberBySSN(RequestDTO<McMember> request)
        {
            McMember criteria = request.Inputs.First();

            if (criteria == null)
                throw new ArgumentNullException(MemberExceptions.InvalidMember);

            return MemberSearchEngine.Search(x => x.SSN == criteria.SSN);
        }
示例#44
0
        public ResponseDTO GetMemberTypeById(RequestDTO<McMemberType> request)
        {
            McMemberType criteria = request.Inputs.First();

            return MemberTypeSearchEngine.Search(x => x == criteria);
        }
示例#45
0
        public ResponseDTO GetProcessById(RequestDTO<Process> request)
        {
            Process criteria = request.Inputs.First();

            return ProcessSearchEngine.Search(x => x == criteria);
        }
示例#46
0
文件: Reference.cs 项目: unicloud/FRP
 public void AddToRequests(RequestDTO requestDTO)
 {
     base.AddObject("Requests", requestDTO);
 }
示例#47
0
        // TODO
        public ResponseDTO CreateMemberAttribute(RequestDTO<McMemberAttribute> request)
        {
            ResponseDTO response = new ResponseDTO();

            return response;
        }
示例#48
0
        // TODO
        public ResponseDTO UpdateMember(RequestDTO<McMember> request)
        {
            ResponseDTO response = new ResponseDTO();

            return response;
        }
示例#49
0
文件: Reference.cs 项目: unicloud/FRP
 public static RequestDTO CreateRequestDTO(global::System.Guid ID, bool isFinished, global::System.DateTime createDate, int status, global::System.Guid caacDocumentId, global::System.Guid airlinesId, global::System.Collections.ObjectModel.ObservableCollection<ApprovalHistoryDTO> approvalHistories)
 {
     RequestDTO requestDTO = new RequestDTO();
     requestDTO.Id = ID;
     requestDTO.IsFinished = isFinished;
     requestDTO.CreateDate = createDate;
     requestDTO.Status = status;
     requestDTO.CaacDocumentId = caacDocumentId;
     requestDTO.AirlinesId = airlinesId;
     if ((approvalHistories == null))
     {
         throw new global::System.ArgumentNullException("approvalHistories");
     }
     requestDTO.ApprovalHistories = approvalHistories;
     return requestDTO;
 }