public ProjectResponse Convert(Project project)
        {
            var projectDto = new ProjectResponse
            {
                Id          = project.Id,
                Name        = project.Name,
                Description = project.Description,
                CreatedOn   = project.CreatedOn.ToString(),
                Completion  = project.Completion.ToString()
            };

            foreach (var ticket in project.Tickets)
            {
                var ticketDtos = new TicketResponse
                {
                    Id          = ticket.Id,
                    Title       = ticket.Title,
                    Description = ticket.Description,
                    Status      = ticket.Status.ToString(),
                    CreatedOn   = ticket.CreatedAt.ToString(),
                    UpdatedOn   = ticket.UpdatedAt.ToString(),
                    Priority    = ticket.Priority.ToString(),
                    Project     = ticket.Project.Name,
                    Submitter   = ticket.Submitter.UserName,
                    Assignee    = ticket.Assignee == null ? "" : ticket.Assignee.UserName
                };

                projectDto.Tickets.Add(ticketDtos);
            }

            return(projectDto);
        }
        private Ticket ConvertTicket(TicketResponse ticketResponse)
        {
            var ticket = new Ticket()
            {
                Id          = ticketResponse.sys_id,
                Title       = ticketResponse.short_description,
                Description = ticketResponse.description,
                Urgency     = StringToUrgency[ticketResponse.urgency],
                State       = StringToTicketState[ticketResponse.state],
                OpenedTime  = DateTime.Parse(ticketResponse.opened_at),
                Number      = ticketResponse.number,
                Provider    = Provider,
            };

            if (!string.IsNullOrEmpty(ticketResponse.close_code))
            {
                if (!string.IsNullOrEmpty(ticketResponse.close_notes))
                {
                    ticket.ResolvedReason = $"{ticketResponse.close_code}:\r\n{ticketResponse.close_notes}";
                }
                else
                {
                    ticket.ResolvedReason = ticketResponse.close_code;
                }
            }
            else
            {
                ticket.ResolvedReason = ticketResponse.close_notes;
            }

            return(ticket);
        }
Example #3
0
        public TicketResponse CreateTicketResponse(TicketResponse response)
        {
            ctx.TicketResponses.Add(response);
            ctx.SaveChanges();

            return(response);
        }
Example #4
0
        public TicketResponse AddTicketResponse(int ticketNumber, string response, bool isClientResponse)
        {
            TicketResponse newResponse = null;

            using (HttpClient http = GetNewHttpClient())
            {
                string             uri         = baseUri + "TicketResponses";
                HttpRequestMessage httpRequest = new HttpRequestMessage(HttpMethod.Post, uri);
                httpRequest.Headers.Add("Accept", "application/json");
                object httpData = new
                { TicketNumber = ticketNumber, ResponseText = response, IsClientResponse = isClientResponse };
                string dataAsJsonString = JsonConvert.SerializeObject(httpData);
                httpRequest.Content = new StringContent(dataAsJsonString, Encoding.UTF8, "application/json");

                HttpResponseMessage httpResponse = http.SendAsync(httpRequest).Result;

                if (httpResponse.IsSuccessStatusCode)
                {
                    string responseContentAsString = httpResponse.Content.ReadAsStringAsync().Result;

                    newResponse = JsonConvert.DeserializeObject <TicketResponse>(responseContentAsString);
                }
                else
                {
                    throw new Exception(httpResponse.StatusCode + " " + httpResponse.ReasonPhrase);
                }

                return(newResponse);
            }
        }
Example #5
0
        public TicketResponse CreateTicketResponse(TicketResponse response)
        {
            ctx.TicketResponses.Add(response);
            ctx.SaveChanges();

            return(response); // 'Id' has been created by the database!
        }
Example #6
0
 internal AuthTicket(TicketResponse Response)
 {
     Account          = Response.Account;
     Ticket           = Response.Ticket;
     DefaultCharacter = Response.DefaultCharacter;
     Characters       = Response.Characters;
 }
        public TicketResponse CreateTicketResponse(TicketResponse ticketResponse)
        {
            context.TicketResponses.Add(ticketResponse);
            context.SaveChanges();

            return(ticketResponse);
        }
Example #8
0
        public TicketResponse CreateTicketResponse(TicketResponse response)
        {
            if (response.Ticket != null)
            {
                string insertStatement = "INSERT INTO TicketResponse([Text], [Date], IsClientResponse, Ticket_TicketNumber)"
                                         + " VALUES (@text, @date, @isClientResponse, @tickedNumber)";

                using (var connection = this.GetConnection())
                {
                    SqlCommand command = new SqlCommand(insertStatement, connection);
                    command.Parameters.AddWithValue("@text", response.Text);
                    command.Parameters.AddWithValue("@date", response.Date.ToString("yyyy-MM-dd HH:mm:ss"));
                    command.Parameters.AddWithValue("@isClientResponse", response.IsClientResponse);
                    command.Parameters.AddWithValue("@tickedNumber", response.Ticket.TicketNumber);

                    //Retrieve primary key 'Id' of inserted response
                    command.CommandText += "; SELECT SCOPE_IDENTITY();";

                    connection.Open();
                    response.Id = Convert.ToInt32(command.ExecuteScalar());
                    connection.Close(); // good practice!
                }
                return(response);
            }
            else
            {
                throw new ArgumentException("The ticketresponse has no ticket attached to it");
            }
        }
        public void InsertForm()
        {
            Guid TicketID = new Guid(Request.QueryString["TicketID"].ToString());

            using (MashadCarpetEntities db = new MashadCarpetEntities())
            {
                TicketResponse t = new TicketResponse();

                t.TicketResponseID = Guid.NewGuid();
                t.fk_TicketID      = TicketID;
                t.ResponseText     = reResponseText.Content;
                t.ResponseDate     = DateTime.Now;

                //t.fk_UserID = new Guid(HttpContext.Current.User.Identity.Name);

                t.fk_UserID = new Guid("ee4edaf0-aad0-4140-a9fe-8b9bcaab6bd3");
                t.IsDelete  = false;

                db.TicketResponse.Add(t);
                db.SaveChanges();

                var m = (from u in db.Tickets where u.TicketID == TicketID select u).FirstOrDefault();
                m.Status = 2;
                db.SaveChanges();

                //SendMail(t.TicketResponseID);
            }
        }
Example #10
0
        public TicketResponse AddTicketResponse(int ticketNumber, string response, bool isClientResponse)
        {
            TicketResponse tr = null;

            using (var http = new HttpClient()) {
                var uri         = baseUri + "TicketResponse";
                var httpRequest = new HttpRequestMessage(HttpMethod.Post, uri);
                //Request data toevoegen aan body, via anonymous object dat je serialiseert naar json-formaat
                object data = new {
                    TicketNumber     = ticketNumber,
                    ResponseText     = response,
                    IsClientResponse = isClientResponse
                };
                var dataAsJsonString = JsonConvert.SerializeObject(data);
                httpRequest.Content = new StringContent(dataAsJsonString, Encoding.UTF8, "application/json");
                //Verwachte content-type van de response meegeven
                httpRequest.Headers.Add("Accept", "application/json");
                //Request versturen en wachten op de response
                var httpResponse = http.SendAsync(httpRequest).Result;
                if (httpResponse.IsSuccessStatusCode)
                {
                    //Body van de response uitlezen als een string
                    var responseContentAsString = httpResponse.Content.ReadAsStringAsync().Result;
                    //Body-string (in json-format) deserializeren (omzetten) naar een TicketResponse-object
                    tr = JsonConvert.DeserializeObject <TicketResponse>(responseContentAsString);
                }
                else
                {
                    throw new Exception(httpResponse.StatusCode + " " + httpResponse.ReasonPhrase);
                }
            }

            return(tr);
        }
Example #11
0
        public IActionResult Post(NewTicketResponseDTO response)
        {
            TicketResponse createdResponse = mgr.AddTicketResponse(response.TicketNumber
                                                                   , response.ResponseText, response.IsClientResponse);

            if (createdResponse == null)
            {
                return(BadRequest("Er is iets misgelopen bij het registreren van het antwoord!"));
            }

            //return CreatedAtAction("Get", new { id = createdResponse.Id }, null);
            //return CreatedAtAction("Get", new { id = createdResponse.Id }, createdResponse); // -> serializing: circulaire referentie!!

            /* Oplossing 'DTO' */
            TicketResponseDTO responseData = new TicketResponseDTO()
            {
                Id                   = createdResponse.Id,
                Text                 = createdResponse.Text,
                Date                 = createdResponse.Date,
                IsClientResponse     = createdResponse.IsClientResponse,
                TicketNumberOfTicket = createdResponse.Ticket.TicketNumber
            };

            return(CreatedAtAction("Get", new { id = responseData.Id }, responseData));
        }
Example #12
0
        public void ReadTicketResponsesOfTicketWithIdOneReturnsAListOfTicketResponses()
        {
            //Arrange
            Ticket testTicket = new Ticket
            {
                Text       = "Test ticket",
                AccountId  = 1,
                DateOpened = DateTime.Now,
                State      = TicketState.Closed,
            };

            TicketResponse tr = new TicketResponse
            {
                Date             = DateTime.Today.AddDays(1),
                IsClientResponse = false,
                Text             = "Answer 1",
                Ticket           = testTicket,
            };
            var id = _repo.CreateTicket(testTicket).TicketNumber;

            _repo.CreateTicketResponse(tr);

            //Act
            List <TicketResponse> result = _repo.ReadTicketResponsesOfTicket(id).ToList();

            //Assert
            Assert.Contains(tr, result);
        }
Example #13
0
		internal AuthTicket(TicketResponse Response)
		{
			Account = Response.Account;
			Ticket = Response.Ticket;
			DefaultCharacter = Response.DefaultCharacter;
			Characters = Response.Characters;
		}
 public void EnviarEmailConfirmacao(TicketMensagemRequest request,
                                    TicketMensagem ticketMensagem,
                                    TicketResponse ticket,
                                    AtendenteEmpresa atendenteEmpresa,
                                    UsuarioCliente usuarioCliente,
                                    List <AtendenteEmpresa> listaAtendentes)
 {
     //Se for mensagem enviada pelo atendimento (suporte) e interno
     if (request.UserType == "S" && request.Interno)
     {
         //Se for nova mensagem interna criada pelo suporte
         Emailer.EnviarEmailInterno(ticket, ticketMensagem, atendenteEmpresa, listaAtendentes);
     }
     else
     {
         if (request.UserType == "S" && !request.Interno)
         {
             //Se for nova mensagem (não interna) criada pelo suporte
             Emailer.EnviarEmailNovaMensagemCliente(ticket, ticketMensagem);
         }
         else
         {
             if (request.UserType == "C")
             {
                 //Se for nova mensagem criada pelo cliente
                 Emailer.EnviarEmailNovaMensagemSuporte(ticket, ticketMensagem, usuarioCliente, listaAtendentes);
             }
         }
     }
 }
        static void Main(string[] args)
        {
            // (1) Ticket validation
            Ticket t1 = new Ticket()
            {
                TicketNumber = 1, AccountId = 1, Text = "",
                State        = TicketState.Open, DateOpened = DateTime.Now
            };

            // (2) HardwareTicket validation
            Ticket t2 = new HardwareTicket()
            {
                TicketNumber = 2, AccountId = 1, DeviceName = "LPT-9876", Text = "text",
                State        = TicketState.Open, DateOpened = DateTime.Now
            };

            // (3) TicketResponse with user-defined validation
            TicketResponse tr = new TicketResponse()
            {
                Id     = 1, Text = "response", IsClientResponse = true, Date = new DateTime(2014, 1, 1),
                Ticket = new Ticket()
                {
                    TicketNumber = 3, AccountId = 1, Text = "text", State = TicketState.Open, DateOpened = new DateTime(2015, 1, 1)
                }
            };

            // Validatie controle
            var errors = new List <ValidationResult>();

            Validator.TryValidateObject(tr, new ValidationContext(tr), errors, validateAllProperties: true);

            Console.ReadLine();
        }
        public TicketResponse ConsultarTicket(Ticket Ticket)
        {
            TicketResponse objTicketResponse = new TicketResponse();

            objTicketResponse.EsValido = false;

            try
            {
                if (string.IsNullOrEmpty(Ticket.Codigo))
                {
                    objTicketResponse.Mensaje = "El código de ticket no es válido.";
                    return(objTicketResponse);
                }

                Ticket objTicket = objTicketDAO.Consultar(Ticket);

                if (string.IsNullOrEmpty(objTicket.Codigo))
                {
                    objTicketResponse.Mensaje = "El ticket no existe.";
                    return(objTicketResponse);
                }
                else
                {
                    objTicketResponse.Mensaje  = "El ticket si existe.";
                    objTicketResponse.EsValido = true;
                    objTicketResponse.Ticket   = objTicket;
                }
            }
            catch (Exception ex)
            {
                objTicketResponse.Mensaje = "Se presentró un error al obtener los datos del ticket. " + ex.Message;
            }

            return(objTicketResponse);
        }
        public TicketResponse CreateTicketResponse(TicketResponse response)
        {
            if (response.Ticket != null)
            {
                string insertStatement = "INSERT INTO TicketResponse([TEXT], [Date], isClientResponse, Ticket_TicketNumber)"
                                         + " VALUES (@Text, @Date, @isClientResponse, @TicketNumber)";

                using (var connection = GetConnection())
                {
                    var insertCommand = new SqlCommand(insertStatement, connection);
                    insertCommand.Parameters.AddWithValue("@Text", response.Text);
                    insertCommand.Parameters.AddWithValue("@Date", response.Date.ToString("yyyy-MM-dd HH:mm:ss"));
                    insertCommand.Parameters.AddWithValue("@isClientResponse", response.IsClientResponse);
                    insertCommand.Parameters.AddWithValue("@TicketNumber", response.Ticket.TicketNumber);

                    insertCommand.CommandText += "; SELECT SCOPE_IDENTITY()"; //gaat primary key ophalen

                    connection.Open();
                    response.Id = Convert.ToInt32(insertCommand.ExecuteScalar());
                    connection.Close();
                }
                return(response);
            }
            else
            {
                throw new ArgumentException("Ticketresponse has no ticket attachted to it!");
            }
        }
Example #18
0
        async Task CreditMilesToClient(Client client, int miles, TicketResponse ticket)
        {
            var bonusMiles = new Mile
            {
                ClientId    = client.Id,
                MilesTypeId = 2,
                Miles       = miles,
                Balance     = miles,
                CreditDate  = DateTime.UtcNow,
                ExpiryDate  = DateTime.UtcNow.AddYears(3),
                Description = $"Miles from flight that landed on {DateTime.UtcNow.AddDays(-1):yyyy-MM-dd}"
            };

            var statusMiles = new Mile
            {
                ClientId    = client.Id,
                MilesTypeId = 1,
                Miles       = miles,
                Balance     = miles,
                CreditDate  = DateTime.UtcNow,
                ExpiryDate  = DateTime.UtcNow.AddYears(3),
                Description = $"Status from flight that landed on {DateTime.UtcNow.AddDays(-1):yyyy-MM-dd}"
            };

            await _mileRepository.CreateAsync(bonusMiles);

            await _mileRepository.CreateAsync(statusMiles);
        }
Example #19
0
        public IHttpActionResult Post(NewTicketResponseDTO response)
        {
            TicketResponse createdResponse = mgr.AddTicketResponse(response.TicketNumber, response.ResponseText, response.IsClientResponse);

            if (createdResponse == null)
            {
                return(BadRequest("Er is iets misgelopen bij het registreren van het antwoord!"));
            }

            //// Circulaire referentie!! (TicketResponse <-> Ticket) -> can't be serialized!!
            //return CreatedAtRoute("DefaultApi",
            //                      new { Controller = "TicketResponse", id = createdResponse.Id },
            //                      createdResponse);

            // Gebruik DTO (Data Transfer Object)
            TicketResponseDTO responseData = new TicketResponseDTO()
            {
                Id                   = createdResponse.Id,
                Text                 = createdResponse.Text,
                Date                 = createdResponse.Date,
                IsClientResponse     = createdResponse.IsClientResponse,
                TicketNumberOfTicket = createdResponse.Ticket.TicketNumber
            };

            return(CreatedAtRoute("DefaultApi",
                                  new { Controller = "TicketResponse", id = responseData.Id },
                                  responseData));
        }
Example #20
0
        protected void Page_Load(object sender, EventArgs e)
        {
            // Define some configuration options for the QlikView Server
            TicketConfiguration config = new TicketConfiguration()
            {
                GetWebTicketUri = new Uri("http://localhost/QvAJAXZfc/GetWebTicket.aspx")
            };

            // Create a ticket request with userid and groups (semicolon separated)
            TicketRequest request = new TicketRequest()
            {
                UserId = "rikard",
                Groups = new string[] { "PreSales", "Stockholm" }
            };

            // The response will contain the generated ticket, a redirect uri and possible error message
            TicketResponse response = new TicketResponse().GetTicket(request, config);

            if (response.ErrorMessage == null)
            {
                Response.Redirect(response.RedirectUri, true);
            }
            else
            {
                Response.Write("Error: " + response.ErrorMessage);
            }
        }
        public void EditResponseTest()
        {
            TicketResponse temp = NewResponse();

            InsertResponseIntoDatabase(temp);

            //Make sure the insertion worked smoothly.
            Assert.IsTrue(temp.Equals(SelectResponseById(temp.TicketResponseId)), "The created Category and selected Category do not match.  Insertion or selection might have failed");

            //Change the values...
            temp.CreationDate = DateTime.Now;
            temp.Creator      = "me me me!";
            temp.MinsSpent    = 22032;
            temp.Response     = "new Response";
            temp.TicketId     = 33;

            //Peform the update.
            HelpdeskService.UpdateResponse(temp);

            //Create a new instance of the Category object and compare them...
            TicketResponse temp2 = SelectResponseById(temp.TicketResponseId);

            //Make sure they match.
            Assert.IsTrue(temp.Equals(temp2), "The updated Category did not match equality with the prepared Category values in the method.");
        }
        public void ChangeTicket(TicketDTO ticket)
        {
            Ticket t = new Ticket();

            t.AccountId    = ticket.AccountId;
            t.DateOpened   = ticket.DateOpened;
            t.State        = ticket.State;
            t.TicketNumber = ticket.TicketNumber;
            t.Text         = ticket.Text;
            if (ticket.Responses != null)
            {
                foreach (var response in ticket.Responses)
                {
                    TicketResponse rsp = new TicketResponse();
                    rsp.Id = response.Id;
                    rsp.IsClientResponse = response.IsClientResponse;
                    rsp.Date             = response.Date;
                    rsp.Text             = response.Text;
                    rsp.Ticket           = t;
                    t.Responses.Add(rsp);
                }
            }
            else
            {
                t.Responses = new List <TicketResponse>();
            }

            mgr.ChangeTicket(t);
        }
Example #23
0
        public override async Task <TicketResponse> ReserveTickets(TicketRequest request, ServerCallContext context)
        {
            var response = new TicketResponse()
            {
                Success = false
            };

            try
            {
                var tickets = await _repository.GetTicketsAsync(request.TicketIds.ToArray());

                if (tickets.Count() == request.TicketIds.Count())
                {
                    // TODO actually reserve, but for demo not necessary
                    response.Success = true;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError("Failed to reserve tickets.", ex);
                response.UserMessage = "Failed to reserve your tickets. Error occurred.";
            }

            return(response);
        }
Example #24
0
        protected void btnSend_Click(object sender, EventArgs e)
        {
            Guid TicketID = new Guid(ViewState["TicketID"].ToString());

            if (HttpContext.Current.User.Identity.IsAuthenticated)
            {
                Guid UserID = new Guid(HttpContext.Current.User.Identity.Name);
                using (MashadCarpetEntities db = new MashadCarpetEntities())
                {
                    TicketResponse t = new TicketResponse();

                    t.TicketResponseID = Guid.NewGuid();
                    t.fk_TicketID      = TicketID;
                    t.fk_UserID        = UserID;
                    t.ResponseText     = txtAnswerText.Text;
                    t.ResponseDate     = DateTime.Now;
                    t.IsDelete         = false;

                    db.TicketResponse.Add(t);
                    db.SaveChanges();
                }
                rptAnswersBind(TicketID);
                txtAnswerText.Text = string.Empty;
            }
        }
Example #25
0
        /// <summary>
        /// Envia una Resumen de Boletas o Comunicaciones de Baja a Sunat
        /// </summary>
        /// <param name="pathFile">Ruta del archivo XML que contiene el resumen</param>
        /// <param name="content">Contenido del archivo</param>
        /// <returns>Retorna un estado booleano que indica si no hubo errores, con un string que contiene el Nro Ticket,
        /// con el que posteriormente, utilizando el método getStatus se puede obtener Constancia de Recepcióno</returns>
        public async Task <TicketResponse> SendSummary(string pathFile, byte[] content)
        {
            var fileToZip     = pathFile + Resources.ExtensionFile;
            var nameOfFileZip = pathFile + Resources.ExtensionZipFile;
            var res           = new TicketResponse();

            try
            {
                var zipBytes = ProcessZip.CompressFile(fileToZip, content);
                var service  = ServiceHelper.GetService <billService>(_config, _url);

                var result = await service.sendSummaryAsync(new sendSummaryRequest(nameOfFileZip, zipBytes));

                res.Ticket  = result.ticket;
                res.Success = true;
            }
            catch (FaultException ex)
            {
                res.Error = GetErrorFromFault(ex);
            }
            catch (Exception er)
            {
                res.Error = new ErrorResponse
                {
                    Description = er.Message
                };
            }
            return(res);
        }
Example #26
0
        public static string PrepareTicketResponse(string ticketRequest)
        {
            string userId = ticketRequest;

            Console.WriteLine($" Ticket input: \n" +
                              $"userId: {userId}\n");

            SaleRepository saleRepository = new SaleRepository();
            List <Sale>    saleResults    = saleRepository.GetUserSales(Convert.ToInt32(userId));

            RouteRepository routeRepository = new RouteRepository();

            string resultString = "";

            foreach (Sale sale in saleResults)
            {
                Route route = routeRepository.Get(sale.route_id);
                List <TrainConnection> result = routeRepository.SearchForTrainConnection(route.departure_date, sale.from_station, sale.to_station);
                decimal  price = 0;
                TimeSpan time  = new TimeSpan();
                TimeSpan hour  = new TimeSpan();

                foreach (TrainConnection r in result)
                {
                    if (r.travel_id == route.id)
                    {
                        price = r.total_price;
                        time  = r.total_duration;
                        hour  = r.departure_hour;
                    }
                }

                string   saleTicketNameAmountPercentage     = saleRepository.GetSaleTicketNameAmountPercentage(sale.id);
                string[] saleTicketNameAmountPercentagArray = saleTicketNameAmountPercentage.Split(',');
                var      ticketName       = saleTicketNameAmountPercentagArray[0];
                var      ticketsAmount    = saleTicketNameAmountPercentagArray[1];
                var      ticketPercentage = saleTicketNameAmountPercentagArray[2];

                var totalPrice = price * (Convert.ToInt32(ticketsAmount)) * (Convert.ToDecimal(ticketPercentage) / 100);
                //(Convert.ToInt32(ticketPercentage) / 100.0) *
                TicketResponse ticketResponse
                    = new TicketResponse(
                          route.train_name.ToString(),
                          sale.from_station,
                          sale.to_station,
                          sale.sale_date.ToString(),
                          route.departure_date.ToString(),
                          hour.ToString(),
                          totalPrice.ToString(),
                          time.ToString(),
                          sale.payment_status.ToString(),
                          ticketName,
                          ticketsAmount);
                resultString += ticketResponse.ToString() + ';';
            }

            resultString = resultString.Remove(resultString.Length - 1, 1);
            return(resultString);
        }
 public TicketResponse CreateTicketResponse(TicketResponse response)
 {
     //De nieuwe response krijgt als PK-waarde een auto-numbering toegewezen...
     //Dit door de hoogste ID van de ticketresponses op de zoeken en daar dan 1 bij op te tellen
     response.Id = responses.Max <TicketResponse>(r => r.Id) + 1;
     responses.Add(response);
     return(response);
 }
        public Option <SharedTicket> TryShareTicket(TicketResponse response)
        {
            var escalatedComments = TaggedComments(response.Comments, response.Audits);

            return(response.IsSharedBecause(Reason) && escalatedComments.Any()
                ? Some(new SharedTicket(Reason, response.WithComments(escalatedComments)))
                : None);
        }
        internal SharedTicket(SharingReason reason, TicketResponse response)
        {
            Id = response.Ticket?.Id
                 ?? throw new ArgumentException("Response does not contain the Ticket ID");

            this.Reason = reason;
            Response    = response;
        }
Example #30
0
        public TicketResponse CreateTicketResponse(TicketResponse response)
        {
            response.Id = ReadTicketResponsesOfTicket(response.Ticket.TicketNumber).ToList().Count;
            //ReadTicket(response.Ticket.TicketNumber).Responses.Add(response);
            //ctx.TicketResponses.Add(response);

            return(response); // 'Id' has been created by the database!
        }
        public void CreateResponseTest()
        {
            TicketResponse temp = NewResponse();

            HelpdeskService.CreateResponse(temp);

            Assert.IsTrue(SelectResponseById(temp.TicketResponseId) != null, "The internal selection query used to verify this test failed to return the a row.");
            Assert.IsTrue(temp.TicketResponseId > 0, "The returned Id from the CreateQueue test did not return a value greater than 0.");
        }
        public void Get_Called_ReturnsTicketResponse()
        {
            // Given
            var response = new TicketResponse { Item = new Ticket { Id = 1 }};
            _client.Setup(b => b.Get<TicketResponse>(It.IsAny<Uri>())).Returns(response);
            var ticketResource = new TicketResource(_client.Object);

            // When
            var result = ticketResource.Get(321);

            // Then
            Assert.That(result, Is.EqualTo(response));
        }
 public abstract void UpdateResponse(TicketResponse response);
        public void Put_TicketHasNoId_ThrowsException()
        {
            // Given
            var response = new TicketResponse { Item = new Ticket { Subject = "blah blah" } };
            var request = new TicketRequest { Item = new Ticket { Subject = "blah blah" } };
            _client.Setup(b => b.Put<TicketResponse>(It.IsAny<Uri>(), request, "application/json")).Returns(response);
            var ticketResource = new TicketResource(_client.Object);

            // When, Then
            Assert.Throws<ArgumentException>(() => ticketResource.Put(request));
        }
        public void Delete_Called_CallsDeleteOnClient()
        {
            // Given
            var response = new TicketResponse { Item = new Ticket { Id = 1 } };
            _client.Setup(b => b.Get<TicketResponse>(It.IsAny<Uri>())).Returns(response);
            var ticketResource = new TicketResource(_client.Object);

            // When
            ticketResource.Delete(321);

            // Then
            _client.Verify(c => c.Delete(It.IsAny<Uri>()));
        }
        public void Put_CalledWithTicket_ReturnsTicketReponse()
        {
            // Given
            var response = new TicketResponse { Item = new Ticket { Subject = "blah blah" } };
            var request = new TicketRequest { Item = new Ticket { Subject = "blah blah", Id = 123 } };
            _client.Setup(b => b.Put<TicketResponse>(It.IsAny<Uri>(), request, "application/json")).Returns(response);
            var ticketResource = new TicketResource(_client.Object);

            // When
            var result = ticketResource.Put(request);

            // Then
            Assert.That(result, Is.EqualTo(response));
        }
        /// <summary>
        /// Creates shiny new queues that are not referenced / altered by other methods.
        /// </summary>
        /// <returns></returns>
        private TicketResponse NewResponse()
        {
            TicketResponse expected = new TicketResponse();
            expected.CreationDate = TestDate;
            expected.Creator = "nblevins";
            expected.MinsSpent = 33;
            expected.Response = "This is my response...";
            expected.TicketId = 1;

            return expected;
        }
 /// <summary>
 /// Helper method to insert values into the database.  If successful, it will set the appropriate row id.
 /// </summary>
 /// <param name="Category"></param>
 private void InsertResponseIntoDatabase(TicketResponse response)
 {
     HelpdeskService.CreateResponse(response);
 }
 public static void CreateResponse(TicketResponse response)
 {
     LoadProviders(); _provider.CreateResponse(response);
 }
 public abstract void CreateResponse(TicketResponse response);