public void MailSentSatatus(string QuoteNumber)
{
try
{
QuoteEntity qtEntity = new QuoteEntity();
qtEntity.CarHireDetails = "";
qtEntity.ConsultantName = "";
qtEntity.CostForAdult = "";
qtEntity.CostForAdultType = 0;
qtEntity.CostForChild = "";
qtEntity.CostForChildType = 0;
qtEntity.Excludes = "";
qtEntity.FlightDetails = "";
qtEntity.HotelInfo = "";
qtEntity.Includes = "";
qtEntity.ItineraryDetails = "";
qtEntity.LeadID = 0;
qtEntity.NoOfAdults = 0;
qtEntity.NoOfChildren = 0;
qtEntity.QuoteDate = "";
qtEntity.ToCity = "";
qtEntity.TravelInsurance = "";
qtEntity.AdultTotal = "";
qtEntity.ChildTotal = "";
qtEntity.IsMailSent = "Y";
qtEntity.QuoteNumber = QuoteNumber;
qtEntity.Operation = "U";
string strQuoteNumber = qtBL.CUOperationQuote(qtEntity);
}
catch
{ }
}
public async Task <QuoteEntity> GetQuote()
{
string apiUrl = GetApiUrl();
QuoteEntity quote = await _resourceResolver.RetrieveData <QuoteEntity>(apiUrl);
return(quote);
}
public void UpdateData(QuoteEntity entity)
{
var quoteRecord = context.QuoteContext.FirstOrDefault(q => q.Id == entity.Id);
if (quoteRecord != null)
{
quoteRecord.Value = entity.Value;
}
}
public QuoteEntity GetQuoteEntity()
{
QuoteEntity quote = new QuoteEntity
{
Text = "Nothing is eternal under the moon",
Author = "William Shakespear"
};
return(quote);
}
public void ReturnRequestedQuote_GivenQuoteExists()
{
QuoteEntity foundQuote = GetTestQuote();
SetUpTest(foundQuote);
CommandReceivedEventArgs commandReceivedEventArgs = GetEventArgs(1);
_quoteCommand.Process(_chatClientMock.Object, commandReceivedEventArgs);
_chatClientMock.Verify(x => x.SendMessage(foundQuote.ToString()));
}
private static QuoteEntity GetTestQuote()
{
var foundQuote = new QuoteEntity
{
Text = "Hello world!",
Author = "Brendan",
QuoteId = 1,
DateAdded = new DateTime(2018, 3, 19)
};
return(foundQuote);
}
public void ReturnRequestedQuote_GivenQuoteExists()
{
QuoteEntity foundQuote = GetTestQuote();
SetUpTest(foundQuote);
CommandReceivedEventArgs commandReceivedEventArgs = GetEventArgs(1);
_quoteCommand.Process(_fakeChatClient, commandReceivedEventArgs);
Assert.Equal(foundQuote.ToString(), _fakeChatClient.SentMessage);
}
private void HandleQuoteRequest(IChatClient triggeringClient, int requestQuoteId)
{
QuoteEntity quote = _repository.Single(QuoteEntityPolicy.ByQuoteId(requestQuoteId));
if (quote == null)
{
triggeringClient.SendMessage($"I'm sorry, but we don't have a quote {requestQuoteId}... Yet...");
}
else
{
triggeringClient.SendMessage(quote.ToString());
}
}
private static TableResult InsertQuote(CloudTable table, Quote quote)
{
var id = GetNextId(table);
var quoteEntity = new QuoteEntity(quote, id);
var quoteOperation = TableOperation.InsertOrReplace(quoteEntity);
var result = table.Execute(quoteOperation);
var controlEntity = new ControlEntity(quote, id);
var controlOperation = TableOperation.InsertOrReplace(controlEntity);
return(table.Execute(controlOperation));
}
public IHttpActionResult AddQuote(QuoteRequestModel requestModel)
{
if (ModelState.IsValid)
{
var quoteEntity = new QuoteEntity
{
Value = requestModel.Value
};
_quoteService.AddQuote(quoteEntity);
_hubContext.Clients.Group("add").AddQuote(quoteEntity);
}
return(Ok());
}
public async Task RequestsDataFromAPI()
{
QuoteEntity expected = new QuoteEntity
{
Text = "This is text",
Author = "This is author",
};
resolver.Setup(mock => mock.RetrieveData <QuoteEntity>(It.IsAny <string>())).ReturnsAsync(expected);
QuoteEntity actual = await quotesGateway.GetQuote();
Assert.AreEqual(expected, actual);
}
public void CreateGetUpdateDelete()
{
IQuoteServices qs = ServicesFactory.GetQuoteServices();
IUserServices us = ServicesFactory.GetUserServices();
var user = us.GetUserByEmail("*****@*****.**");
if (user == null)
{
us.Register("*****@*****.**", "123456", "Test User");
user = us.GetUserByEmail("*****@*****.**");
}
//Create quote
var quote = new QuoteEntity()
{
Text = "Test", UserId = user.Id
};
var quoteId = qs.CreateQuote(quote);
Assert.AreNotEqual(quoteId, 0);
//Get quote
var newQuote = qs.GetQuoteById(quoteId);
Assert.IsNotNull(newQuote);
Assert.AreEqual(newQuote.Text, quote.Text);
Assert.AreEqual(newQuote.UserId, quote.UserId);
//Update quote
newQuote.Text = "Test1";
qs.UpdateQuote(newQuote.Id, newQuote);
newQuote = qs.GetQuoteById(quoteId);
Assert.IsNotNull(newQuote);
Assert.AreEqual(newQuote.Text, "Test1");
Assert.AreEqual(newQuote.UserId, quote.UserId);
//Delete quote
qs.DeleteQuote(newQuote.Id);
newQuote = qs.GetQuoteById(quoteId);
Assert.IsNull(newQuote);
}
public QuoteEntity GetQuoteById(int quoteId)
{
var quote = _unitOfWork.QuoteRepository.GetByID(quoteId);
if (quote != null)
{
Mapper.Initialize(cfg => cfg.CreateMap <Quote, QuoteEntity>());
QuoteEntity dto = Mapper.Map <QuoteEntity>(quote);
return(dto);
}
return(null);
}
public IHttpActionResult DeleteQuote(QuoteRequestModel requestModel)
{
if (ModelState.IsValid)
{
var quoteEntity = new QuoteEntity
{
Id = requestModel.Id,
Value = requestModel.Value
};
_quoteService.DeleteQuote(requestModel.Id);
_hubContext.Clients.Group("delete").DeleteQuote(requestModel.Id);
}
return(Ok());
}
public int CreateQuote(QuoteEntity quoteEntity)
{
using (var scope = new TransactionScope())
{
var quote = new Quote()
{
UserId = quoteEntity.UserId,
Text = quoteEntity.Text
};
_unitOfWork.QuoteRepository.Insert(quote);
_unitOfWork.Save();
scope.Complete();
return(quote.Id);
}
}
public async Task <IActionResult> OnGetAsync(Guid?id)
{
if (id == null)
{
return(NotFound());
}
QuoteEntity = await _context.QuoteEntities.FirstOrDefaultAsync(m => m.Id == id);
if (QuoteEntity == null)
{
return(NotFound());
}
return(Page());
}
public async Task <IActionResult> OnPostAsync(Guid?id)
{
if (id == null)
{
return(NotFound());
}
QuoteEntity = await _context.QuoteEntities.FindAsync(id);
if (QuoteEntity != null)
{
_context.QuoteEntities.Remove(QuoteEntity);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public HttpResponseMessage Create([FromBody] QuoteEntity quoteEntity)
{
var basicAuthenticationIdentity = Thread.CurrentPrincipal.Identity as BasicAuthenticationIdentity;
if (basicAuthenticationIdentity != null)
{
var userId = basicAuthenticationIdentity.Id;
quoteEntity.UserId = userId;
var id = _quoteServices.CreateQuote(quoteEntity);
return(Request.CreateResponse(HttpStatusCode.OK, id));
}
return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Not athorized"));
}
public HttpResponseMessage Update(int id, [FromBody] QuoteEntity quoteEntity)
{
var basicAuthenticationIdentity = Thread.CurrentPrincipal.Identity as BasicAuthenticationIdentity;
if (basicAuthenticationIdentity != null)
{
var userId = basicAuthenticationIdentity.Id;
if (id > 0)
{
if (_quoteServices.GetQuoteById(id).UserId == userId)
{
var succ = _quoteServices.UpdateQuote(id, quoteEntity);
return(Request.CreateResponse(HttpStatusCode.OK, succ));
}
}
}
return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Not athorized"));
}
public bool CreateQuote(QuoteCreateModel model)
{
var entity =
new QuoteEntity
{
OwnerId = _userId,
Quote = model.Quote,
Description = model.Description,
KidName = model.KidName,
CreatedUtc = DateTimeOffset.UtcNow
};
using (var ctx = new ApplicationDbContext())
{
ctx.Quotes.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
public int CreateQuoteTemplate(QuoteEntity quoteEntity)
{
Hashtable hashtable = new Hashtable();
hashtable.Add("@ToCity", quoteEntity.ToCity);
hashtable.Add("@FlightDetails", quoteEntity.FlightDetails);
hashtable.Add("@CarHireDetails", quoteEntity.CarHireDetails);
hashtable.Add("@HotelInfo", quoteEntity.HotelInfo);
hashtable.Add("@ItineraryDetails", quoteEntity.ItineraryDetails);
hashtable.Add("@Includes", quoteEntity.Includes);
hashtable.Add("@Excludes", quoteEntity.Excludes);
hashtable.Add("@CostForAdultType", quoteEntity.CostForAdultType);
hashtable.Add("@CostForAdult", quoteEntity.CostForAdult);
hashtable.Add("@NoOfAdults", quoteEntity.NoOfAdults);
hashtable.Add("@CostForChildType", quoteEntity.CostForChildType);
hashtable.Add("@CostForChild", quoteEntity.CostForChild);
hashtable.Add("@NoOfChildren", quoteEntity.NoOfChildren);
hashtable.Add("@TravelInsurance", quoteEntity.TravelInsurance);
hashtable.Add("@ConsultantName", quoteEntity.ConsultantName);
hashtable.Add("@AdultTotal", quoteEntity.AdultTotal);
hashtable.Add("@ChildTotal", quoteEntity.ChildTotal);
hashtable.Add("@IsMailSent", quoteEntity.IsMailSent);
hashtable.Add("@LeadID", quoteEntity.LeadID);
hashtable.Add("@PackageId", quoteEntity.PackageId);
hashtable.Add("@TemplateName", quoteEntity.TemplateName);
if (quoteEntity.QuoteDate != "")
{
hashtable.Add("@QuoteDate", DateTime.ParseExact(quoteEntity.QuoteDate, "dd-MM-yyyy", null));
}
else
{
hashtable.Add("@QuoteDate", DBNull.Value);
}
hashtable.Add("@Operation", quoteEntity.Operation);
hashtable.Add("@QuoteNumber", quoteEntity.QuoteNumber);
hashtable.Add("@IsCustomTemplate", quoteEntity.IsCustomTemplate);
int result = dataUtilities.ExecuteNonQuery("usp_CreateQuoteTemplate", hashtable);
return(result);
}
public override void Process(IChatClient chatClient, CommandReceivedEventArgs eventArgs)
{
string quoteText = eventArgs?.Arguments?.ElementAtOrDefault(0);
string quoteAuthor = eventArgs?.Arguments?.ElementAtOrDefault(1);
// HACK: Replace with ValueGeneratedOnAdd in EF Core after removing in-memory database
int count = _repository.List(QuoteEntityPolicy.All).Count;
var quoteEntity = new QuoteEntity
{
AddedBy = eventArgs?.ChatUser?.DisplayName,
Text = quoteText,
Author = quoteAuthor,
QuoteId = count + 1
};
QuoteEntity updatedEntity = _repository.Create(quoteEntity);
chatClient.SendMessage($"Created quote # {updatedEntity.QuoteId}.");
}
public bool UpdateQuote(int quoteId, QuoteEntity quoteEntity)
{
var success = false;
if (quoteEntity != null)
{
using (var scope = new TransactionScope())
{
var quote = _unitOfWork.QuoteRepository.GetByID(quoteId);
if (quote != null)
{
quote.Text = quoteEntity.Text;
_unitOfWork.QuoteRepository.Update(quote);
_unitOfWork.Save();
scope.Complete();
success = true;
}
}
}
return(success);
}
private void AddNewQuote(IChatClient chatClient, string quoteText, string author, ChatUser chatUser)
{
if (!chatUser.CanUserRunCommand(UserRole.Mod))
{
chatClient.SendMessage($"Please ask a moderator to add this quote, {chatUser.DisplayName}.");
return;
}
int count = _repository.List(QuoteEntityPolicy.All).Count;
var quoteEntity = new QuoteEntity
{
AddedBy = chatUser.DisplayName,
Text = quoteText,
Author = author,
QuoteId = count + 1
};
QuoteEntity updatedEntity = _repository.Create(quoteEntity);
chatClient.SendMessage($"Created quote # {updatedEntity.QuoteId}.");
}
public override string TryToExecute(CommandReceivedEventArgs eventArgs)
{
string quoteText = eventArgs?.Arguments?.ElementAtOrDefault(1);
string author = eventArgs?.Arguments?.ElementAtOrDefault(2);
if (!eventArgs.ChatUser.IsInThisRoleOrHigher(UserRole.Mod))
{
return($"Please ask a moderator to add this quote, {eventArgs.ChatUser.DisplayName}.");
}
int maxQuoteId = _repository.List(QuoteEntityPolicy.All).Max(x => x.QuoteId);
var quoteEntity = new QuoteEntity
{
AddedBy = eventArgs.ChatUser.DisplayName,
Text = quoteText,
Author = author,
QuoteId = maxQuoteId + 1
};
QuoteEntity updatedEntity = _repository.Create(quoteEntity);
return($"Created quote # {updatedEntity.QuoteId}.");
}
public void UpdateQuote(QuoteEntity quote)
{
EcomakDbContext.Quotes.Update(quote);
}
private void SetUpTest(QuoteEntity foundQuote)
{
_repositoryMock.Setup(x => x.Single(It.IsAny <ISpecification <QuoteEntity> >())).Returns(foundQuote);
_quoteCommand = new QuoteCommand(_repositoryMock.Object);
}
private async Task GetQuote(ArticleEntity article)
{
QuoteEntity quote = await QuotesGateway.GetQuote();
article.Quote = quote;
}
public void CreateQuoteTR(QuoteEntity quote)
{
EcomakDbContext.Entry(quote.Tr).State = EntityState.Unchanged;
EcomakDbContext.Quotes.Add(quote);
}
public string CUOperationQuote(QuoteEntity quoteEntity)
{
string strQuoteNumber = string.Empty;
try
{
DataUtilities dtUtil = new DataUtilities();
string strConnection = dtUtil.GetConnectionString();
using (SqlConnection con = new SqlConnection(strConnection))
{
using (SqlCommand cmd = new SqlCommand("usp_CUDQuote", con))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@ToCity", quoteEntity.ToCity);
cmd.Parameters.AddWithValue("@FlightDetails", quoteEntity.FlightDetails);
cmd.Parameters.AddWithValue("@CarHireDetails", quoteEntity.CarHireDetails);
cmd.Parameters.AddWithValue("@HotelInfo", quoteEntity.HotelInfo);
cmd.Parameters.AddWithValue("@ItineraryDetails", quoteEntity.ItineraryDetails);
cmd.Parameters.AddWithValue("@Includes", quoteEntity.Includes);
cmd.Parameters.AddWithValue("@Excludes", quoteEntity.Excludes);
cmd.Parameters.AddWithValue("@CostForAdultType", quoteEntity.CostForAdultType);
cmd.Parameters.AddWithValue("@CostForAdult", quoteEntity.CostForAdult);
cmd.Parameters.AddWithValue("@NoOfAdults", quoteEntity.NoOfAdults);
cmd.Parameters.AddWithValue("@CostForChildType", quoteEntity.CostForChildType);
cmd.Parameters.AddWithValue("@CostForChild", quoteEntity.CostForChild);
cmd.Parameters.AddWithValue("@NoOfChildren", quoteEntity.NoOfChildren);
cmd.Parameters.AddWithValue("@TravelInsurance", quoteEntity.TravelInsurance);
cmd.Parameters.AddWithValue("@ConsultantName", quoteEntity.ConsultantName);
cmd.Parameters.AddWithValue("@AdultTotal", quoteEntity.AdultTotal);
cmd.Parameters.AddWithValue("@ChildTotal", quoteEntity.ChildTotal);
cmd.Parameters.AddWithValue("@IsMailSent", quoteEntity.IsMailSent);
cmd.Parameters.AddWithValue("@LeadID", quoteEntity.LeadID);
cmd.Parameters.AddWithValue("@PackageId", quoteEntity.PackageId);
cmd.Parameters.AddWithValue("@QType", quoteEntity.QType);
if (quoteEntity.QuoteDate != "")
{
cmd.Parameters.AddWithValue("@QuoteDate", DateTime.ParseExact(quoteEntity.QuoteDate, "dd-MM-yyyy", null));
}
else
{
cmd.Parameters.AddWithValue("@QuoteDate", DBNull.Value);
}
cmd.Parameters.AddWithValue("@Operation", quoteEntity.Operation);
cmd.Parameters.AddWithValue("@QuoteNumber", quoteEntity.QuoteNumber);
cmd.Parameters.Add("@ReturnValue", SqlDbType.VarChar, 15);
cmd.Parameters["@ReturnValue"].Direction = ParameterDirection.Output;
con.Open();
cmd.ExecuteNonQuery();
con.Close();
strQuoteNumber = cmd.Parameters["@ReturnValue"].Value.ToString();
}
}
}
catch
{ }
return(strQuoteNumber);
}
