public void FixReportDTO(ReportDTO reportDTO)
{
var reportDAL = reportDTO.ToReportDAL();
_repository.Fix(reportDAL);
reportDTO.Id = reportDAL.Id;
}
public async Task <IActionResult> GenerateReport(string test_id)
{
if (int.TryParse(test_id, out int testIdInt) &&
await testsService.GetByIdAsync(testIdInt) != null)
{
int usersCount = reportService.GetAllTestingUsersCount(testIdInt);
double avg = reportService.GetAvgRate(testIdInt);
int passedCount = reportService.GetPassedCount(testIdInt);
ReportDTO report = new ReportDTO()
{
AllTestingUser = usersCount,
AvgRate = avg,
PassedUserCount = passedCount,
TestId = testIdInt,
CreateDate = DateTime.Now
};
var mapper = new MapperConfiguration(cfg =>
{
cfg.CreateMap <ReportDTO, ReportModel>();
}).CreateMapper();
ReportModel model = mapper.Map <ReportDTO, ReportModel>(report);
await reportService.AddAsync(report);
return(Ok(new { model }));
}
return(BadRequest("Wrong id!"));
}
public void AddSprintReport(ReportDTO report)
{
var DALReport = ToDALConverter(report);
_reportReposirory.Create(DALReport);
report.ID = DALReport.ID;
}
public InteractiveReport(ReportDTO reportDTO)
{
this.TaskId = reportDTO.TaskId;
this.Timestamp = reportDTO.Timestamp;
this.UserID = reportDTO.UserID;
this.Result = ((InteractiveTaskReportDTO)reportDTO).Result;
}
public void DeleteReport_WithInvalidModelId_Returns_NotFoundResult()
{
// Arrange
var profileServiceMock = new Mock <IReportService>();
profileServiceMock.Setup(service => service
.DeleteReportByIdAsync(It.IsAny <int>()))
.Returns(Task.FromResult(false));
var loggerMock = new Mock <ILogger>();
loggerMock.Setup(c => c.Warning(It.IsAny <string>()));
var controller = new ReportsController(profileServiceMock.Object, loggerMock.Object);
var profileDTO = new ReportDTO();
var id = 1;
// Act
var result = controller.DeleteReport(id).GetAwaiter().GetResult();
// Assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result);
Assert.IsAssignableFrom <int>(notFoundObjectResult.Value);
}
public bool delete(ReportDTO pt)
{
string query = string.Empty;
query += "DELETE FROM report WHERE [idrp] = @idrp";;
using (SqlConnection con = new SqlConnection(ConnectionString))
{
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = con;
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = query;
cmd.Parameters.AddWithValue("@idrp", pt.IDRP);
try
{
con.Open();
cmd.ExecuteNonQuery();
con.Close();
con.Dispose();
}
catch (Exception ex)
{
con.Close();
Console.WriteLine(ex);
throw;
}
}
}
return(true);
}
public static async Task <List <ReportBuySell> > PostGenerateReport(ReportDTO dto)
{
HttpResponseMessage response;
using (HttpClient client = new HttpClient())
{
client.BaseAddress = new Uri(DataHolder.ServerAddress);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic");
try
{
response = await client.PostAsJsonAsync("api/reports/generate", dto);
}
catch (HttpRequestException ex)
{
throw new Exception(ex.InnerException.Message);
}
if (response.IsSuccessStatusCode)
{
return(await response.Content.ReadAsAsync <List <ReportBuySell> >());
}
return(null);
}
}
public void UpdateReport_WithUpdateError_Returns_ConflictResult()
{
// Arrange
var profileServiceMock = new Mock <IReportService>();
profileServiceMock.Setup(service => service
.GetReportByIdAsync(It.IsAny <int>()))
.Returns(Task.FromResult(GetReport()));
profileServiceMock.Setup(service => service
.UpdateReportAsync(It.IsAny <ReportDTO>()))
.Returns(Task.FromResult(false));
var loggerMock = new Mock <ILogger>();
loggerMock.Setup(c => c.Warning(It.IsAny <string>()));
var controller = new ReportsController(profileServiceMock.Object, loggerMock.Object);
var profileDTO = new ReportDTO {
Id = 1
};
// Act
var result = controller.UpdateReport(profileDTO).GetAwaiter().GetResult();
// Assert
var conflictResult = Assert.IsType <ConflictResult>(result);
}
public List <ReportDTO> GetReport4(string startDate, string endDate)
{
List <ReportDTO> reports = new List <ReportDTO>();
string query = "SELECT o.BorrowingDate, p.Fee FROM [Order] o JOIN [OrderDetail] od ON od.OrderID = o.OrderID JOIN Payment p ON p.PaymentID=od.PaymentID WHERE o.BorrowingDate BETWEEN cast(@startDate as datetime) AND cast(@endDate as datetime) GROUP BY o.BorrowingDate, p.Fee";
h.AddParametersToCommand(new List <SqlParameter>()
{
new SqlParameter()
{
ParameterName = "@startDate",
Value = startDate
},
new SqlParameter()
{
ParameterName = "@endDate",
Value = endDate
}
});
ReportDTO currentReport;
SqlDataReader reader = h.MyExecuteReader(query);
while (reader.Read())
{
currentReport = new ReportDTO();
currentReport.BorrowingDate = (DateTime)reader["BorrowingDate"];
currentReport.Total = Convert.ToDecimal(reader["Fee"]);
reports.Add(currentReport);
}
reader.Close();
return(reports);
}
public ReportDTO GetReportsByDateRange(DateTime startDate, DateTime endDate)
{
List <ReportItemDTO> dailyReports = new List <ReportItemDTO>();
ReportDTO report = new ReportDTO();
IEnumerable <DateTime> dates = GetDateRange(startDate, endDate);
double income = 0;
int numberOfOffers = 0;
foreach (DateTime date in dates)
{
foreach (BillModel bill in GetByDateCreatedRange(startDate, endDate)) //using previously created method to loop through a list of created bills in a given date range.
{
if (date == bill.BillCreated)
{
dailyReports.Select(x => x.ReportDate = date);
income += bill.Offer.ActionPrice; //using "+=" because there might be multiple bought offers in one day.
}
}
dailyReports.Add(new ReportItemDTO(date, income, numberOfOffers)); //adding report for one day.
income = 0; //must reset it after each daily report
numberOfOffers = 0;
}
report.Reports = dailyReports;
report.SumOfIncomes = dailyReports.Sum(x => x.Income);
return(report);
}
public List <ReportDTO> GetReport3(string startDate, string endDate)
{
List <ReportDTO> reports = new List <ReportDTO>();
string query = "SELECT u.FirstName+' '+u.LastName as UserName,b.BookName, COUNT(*) AS KitapSayisi FROM [OrderDetail] Od JOIN [Order] o ON o.OrderID=od.OrderID JOIN [User] u ON u.UserID= o.UserID JOIN Book b ON b.BookID=od.BookID WHERE o.BorrowingDate BETWEEN cast(@startDate as datetime) AND cast(@endDate as datetime) GROUP BY u.FirstName+' '+u.LastName, b.BookName";
h.AddParametersToCommand(new List <SqlParameter>()
{
new SqlParameter()
{
ParameterName = "@startDate",
Value = startDate
},
new SqlParameter()
{
ParameterName = "@endDate",
Value = endDate
}
});
ReportDTO currentReport;
SqlDataReader reader = h.MyExecuteReader(query);
while (reader.Read())
{
currentReport = new ReportDTO();
currentReport.UserName = reader["UserName"].ToString();
currentReport.BookName = reader["BookName"].ToString();
currentReport.Total = Convert.ToDecimal(reader["KitapSayisi"]);
reports.Add(currentReport);
}
reader.Close();
return(reports);
}
public ReportDTO GetSalesReportByDateAndCategory(DateTime startDate, DateTime endDate, int categoryId)
{
// FIRST: SELECT BY BOTH DATE AND CATEGORY
var prodaja = from b in db.BillsRepository.Get(filter: b => b.offerModel.categoryId == categoryId && b.billCreated >= startDate && b.billCreated <= endDate)
group b by b.billCreated into g
select g.Select(row => row);
// SECOND: GROUP BY DATE
var prodaja2 = from p in prodaja
select new ReportItemDTO()
{
date = p.Select(a => a.billCreated).FirstOrDefault(),
categoryName = p.Select(a => a.offerModel.category.category_name).FirstOrDefault(),
income = p.Select(a => a.offerModel.regular_price).Sum(),
numberOfOffers = p.Select(a => a.offerModel).Count()
};
ReportDTO report = new ReportDTO()
{
reportItems = prodaja2.OrderBy(b => b.date).ToList(),
sumOfIncomes = prodaja2.Select(p => p.income).Sum(),
totalNumberOfSoldOffers = prodaja2.Select(p => p.numberOfOffers).Sum()
};
return(report);
}
public List <ReportDTO> GetMachineReports()
{
var result = new List <ReportDTO>();
ReportDTO reportDTO = null;
var query = @" select Name,Quantity from tbl_Machine m where m.Status=1";
using (var connection = new SqlConnection(ConnectionStrings.ConnectionString))
{
connection.Open();
using (var command = new SqlCommand(query.ToString(), connection))
{
//command.Parameters.AddWithValue("@P_PersonID", personID);
var reader = command.ExecuteReader();
while (reader.Read())
{
reportDTO = new ReportDTO()
{
name = reader.GetStringOrEmpty(0),
count = reader.GetInt32OrDefaultValue(1)
};
result.Add(reportDTO);
}
}
connection.Close();
}
return(result);
}
/// <summary>
/// Обновление отчета.
/// </summary>
public ServiceResultDTO UpdateReport(ReportDTO reportDTO)
{
User user = Database.Users.Get(reportDTO.UserId.Value);
if (user == null)
{
return(new ServiceResultDTO("Пользователь не найден."));
}
Report report = Database.Reports.GetById(reportDTO.Id.Value);
if (report == null)
{
return(new ServiceResultDTO("Отчет с таким Id не найден."));
}
report.UserId = reportDTO.UserId.Value;
report.Note = reportDTO.Note;
report.Hours = reportDTO.Hours.Value;
report.Date = reportDTO.Date.Value;
Database.Reports.Update(report);
Database.Save();
return(new ServiceResultDTO(true));
}
public async Task <IActionResult> Put([FromRoute] Guid id, [FromBody] ReportDTO reportDTO)
{
var report = await _context.Reports.FindAsync(id);
if (report == null)
{
return(NotFound());
}
report.Paragraph1 = await _context.Paragraphs.FindAsync(reportDTO.Paragraph1Id);
report.Paragraph2 = await _context.Paragraphs.FindAsync(reportDTO.Paragraph2Id);
report.Paragraph3 = await _context.Paragraphs.FindAsync(reportDTO.Paragraph3Id);
report.Paragraph4 = await _context.Paragraphs.FindAsync(reportDTO.Paragraph4Id);
report.Paragraph5 = await _context.Paragraphs.FindAsync(reportDTO.Paragraph5Id);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException) when(!ItemExists(id))
{
return(NotFound());
}
return(NoContent());
}
public void UpdateReport_WithNonexistingId_Returns_NotFoundResult()
{
// Arrange
var profileServiceMock = new Mock <IReportService>();
profileServiceMock.Setup(service => service
.GetReportByIdAsync(It.IsAny <int>()))
.Returns(Task.FromResult(GetNullReport()));
var loggerMock = new Mock <ILogger>();
loggerMock.Setup(c => c.Warning(It.IsAny <string>()));
var controller = new ReportsController(profileServiceMock.Object, loggerMock.Object);
var profileDTO = new ReportDTO {
Id = 1
};
// Act
var result = controller.UpdateReport(profileDTO).GetAwaiter().GetResult();
// Assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result);
Assert.IsAssignableFrom <int>(notFoundObjectResult.Value);
}
public void DeleteReport(ReportDTO ReportDto)
{
Report Report = Database.Reports.Get(ReportDto.Id);
Database.Reports.Delete(Report);
Database.Save();
}
public void UpdateReport_WithValidModel_Returns_OkResult()
{
// Arrange
var profileServiceMock = new Mock <IReportService>();
profileServiceMock.Setup(service => service
.GetReportByIdAsync(It.IsAny <int>()))
.Returns(Task.FromResult(GetReport()));
profileServiceMock.Setup(service => service
.UpdateReportAsync(It.IsAny <ReportDTO>()))
.Returns(Task.FromResult(true));
var loggerMock = new Mock <ILogger>();
loggerMock.Setup(c => c.Information(It.IsAny <string>()));
var controller = new ReportsController(profileServiceMock.Object, loggerMock.Object);
var profileDTO = new ReportDTO {
Id = 1
};
// Act
var result = controller.UpdateReport(profileDTO).GetAwaiter().GetResult();
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.IsAssignableFrom <ReportDTO>(okResult.Value);
}
public HttpResponseMessage PostReport([FromBody] ReportDTO reportDTO)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, reportDTO));
}
using (var repo = new ReportRepository())
{
var report = new Report
{
Lat = reportDTO.Location.Lat,
Long = reportDTO.Location.Long,
Type = "Interaction",
Address = reportDTO.Location.Cross_Street,
Narrative = reportDTO.Location.Narrative,
Mode = reportDTO.Mode,
Description = reportDTO.Description,
CreatedOn = DateTime.Now,
Infrastructure = reportDTO.Infrastructure,
Collision = reportDTO.Collision,
PropertyDamage = reportDTO.PropertyDamage,
Injury = reportDTO.Injury,
CollisionModes = string.Join(",", reportDTO.Modes.Other)
};
repo.Add(report);
repo.Commit();
reportDTO.Id = report.Id;
return(Request.CreateResponse(HttpStatusCode.OK, reportDTO));
}
}
public bool edit(ReportDTO rm)
{
string query = string.Empty;
query += "UPDATE report SET [month] = @month, [year] = @year, [roomsum] = @roomsum, [servicesum] = @servicesum, [costsum] = @costsum WHERE [idrp] = @idrp";
using (SqlConnection con = new SqlConnection(ConnectionString))
{
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = con;
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = query;
cmd.Parameters.AddWithValue("@idrp", rm.IDRP);
cmd.Parameters.AddWithValue("@month", rm.MONTH);
cmd.Parameters.AddWithValue("@year", rm.YEAR);
cmd.Parameters.AddWithValue("@roomsum", rm.ROOMSUM);
cmd.Parameters.AddWithValue("@servicesum", rm.SERVICESUM);
cmd.Parameters.AddWithValue("@costsum", rm.COSTSUM);
try
{
con.Open();
cmd.ExecuteNonQuery();
con.Close();
con.Dispose();
}
catch (Exception ex)
{
con.Close();
Console.WriteLine(ex);
throw;
}
}
}
return(true);
}
public IActionResult UpdateReport([FromBody] ReportDTO reportDTO)
{
try
{
if (ModelState.IsValid)
{
ServiceResultDTO serviceResult = reportService.UpdateReport(reportDTO);
if (serviceResult.IsValid == true)
{
return(Json("Отчет успешно обновлен"));
}
else
{
Log.Error(serviceResult.ErrorMessage);
return(BadRequest(serviceResult.ErrorMessage));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
Log.Error(ex.Message + reportDTO.GetValueString());
return(BadRequest("Произошла неизвестная ошибка"));
}
}
public async Task <IEnumerable <ReportDTO> > GetCategoriesWithExpenses(string filterByYear, string userId)
{
var items = await _db.Categories.GetCategoriesWithExpenses(filterByYear, userId);
var categories = new List <ReportDTO>();
foreach (var i in items)
{
var category = new ReportDTO
{
Id = i.Id,
Name = i.Name
};
foreach (var item in i.Expenditures)
{
var expense = new ExpenditureDTO
{
Id = item.Id,
Comment = item.Comment,
Cost = item.Cost,
ExpenseTime = item.ExpenseTime,
CategoryName = i.Name
};
category.Expenses.Add(expense);
}
categories.Add(category);
}
return(categories);
}
public void AddCompletedTask(int reportId, int taskId)
{
if (!taskService.CheckExistence(taskId))
{
throw new NonexistentTask();
}
TaskDTO taskDto = taskService.Get(taskId);
if (taskDto.Status != Task.TaskStatus.Resolved)
{
throw new NonresolvedTask();
}
ReportDTO reportDto = ConvertDalToBbl(repository.GetById(reportId));
if (MyDate.GetDate().Day != reportDto.CreationDate.Day ||
MyDate.GetDate().Month != reportDto.CreationDate.Month ||
MyDate.GetDate().Year != reportDto.CreationDate.Year)
{
throw new TaskTimeIsOver();
}
if (reportDto.GetCompletedTasks().Contains(taskId))
{
throw new TaskAlreadyCompleted();
}
reportDto.AddCompletedTask(taskId);
repository.Update(ConvertBblToDal(reportDto));
}
public IActionResult GetFlaggedComments(int id, int skip, int take)
{
IEnumerable <Comment> flaggedComments = _ideationManager.GetFlaggedComments(id, skip, take);
List <CommentDTO> comments = new List <CommentDTO>();
foreach (Comment comment in flaggedComments)
{
CommentDTO commentDto = new CommentDTO()
{
CommentId = comment.CommentId,
CommentText = comment.CommentText,
DateTime = comment.Created.FormatParasableDate(),
UserFullName = comment.User.GetFullName(),
UserName = comment.User.UserName,
Reports = new List <ReportDTO>()
};
foreach (Report report in comment.Reports)
{
ReportDTO newReport = new ReportDTO()
{
Reason = report.Reason,
ReportId = report.ReportId,
UserFullName = report.User.GetFullName()
};
commentDto.Reports.Add(newReport);
}
comments.Add(commentDto);
}
return(Ok(comments));
}
public async Task <IActionResult> UpdateReport([FromBody] ReportDTO reportDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (reportDTO.Id <= 0)
{
return(BadRequest(reportDTO.Id));
}
var reportFound = await _reportService.GetReportByIdAsync(reportDTO.Id);
if (reportFound == null)
{
_logger.Warning($"{reportDTO.Id} {ReportConstants.REPORT_NOT_FOUND}");
return(NotFound(reportDTO.Id));
}
var success = await _reportService.UpdateReportAsync(reportDTO);
if (!success)
{
_logger.Warning($"{reportDTO.Id} {ReportConstants.UPDATE_REPORT_CONFLICT}");
return(Conflict());
}
_logger.Information($"{reportDTO.Id} {ReportConstants.UPDATE_REPORT_SUCCESS}");
return(Ok(reportDTO));
}
public async Task should_be_able_to_identity_tags_when_only_multiple_tags_are_specified_with_spaces()
{
var repos = Substitute.For <ITagsRepository>();
var provider = Substitute.For <ITagIdentifierProvider>();
provider.GetIdentifiers(Arg.Any <TagIdentifierContext>()).Returns(new ITagIdentifier[0]);
var ctx = Substitute.For <IMessageContext>();
var incident = new IncidentSummaryDTO(1, "Ada");
var report = new ReportDTO
{
ContextCollections = new[]
{ new ContextCollectionDTO("Data", new Dictionary <string, string> {
{ "ErrTags[]", "MyTag" }, { "ErrTags[]", "YourTag" }
}) }
};
var e = new ReportAddedToIncident(incident, report, false);
var sut = new IdentifyTagsFromIncident(repos, provider);
await sut.HandleAsync(ctx, e);
var arguments = repos.ReceivedCalls().First(x => x.GetMethodInfo().Name == "AddAsync")
.GetArguments();
var tags = (Tag[])arguments[1];
tags[0].Name.Should().Be("MyTag");
tags[1].Name.Should().Be("YourTag");
}
private void GetMockedObject(HomeController controller)
{
AccountDTO[] accountDTO = new AccountDTO[] { new AccountDTO {
AccountID = "TestAccountID", AccountName = "Test Account Name"
} };
ReportDTO[] reportDTO = new ReportDTO[] { new ReportDTO {
ReportID = 1, ReportName = "Test Report Name"
} };
NodeDTO[] nodeDTO = new NodeDTO[] { new NodeDTO {
NodeID = "TestNodeID", DisplayValue = "Test Node Name"
} };
Mock <ICertonaService> applicationMock = new Mock <ICertonaService>();
controller.ForesightService = applicationMock.Object;
GetAccountsByUserResponse accountsByUserResponse = new GetAccountsByUserResponse {
Success = true, Accounts = accountDTO
};
GetPanelBarWidthResponse panelBarWidthResponse = new GetPanelBarWidthResponse {
Width = 100
};
GetReportsListResponse reportsListResponse = new GetReportsListResponse {
Reports = reportDTO
};
GetAccountExplorerTreeResponse accountExplorerTreeResponse = new GetAccountExplorerTreeResponse {
Nodes = nodeDTO
};
applicationMock.Setup(p => p.GetAccountsByUser(It.IsAny <GetAccountsByUserRequest>())).Returns(accountsByUserResponse);
applicationMock.Setup(p => p.GetPanelBarWidth(It.IsAny <GetPanelBarWidthRequest>())).Returns(panelBarWidthResponse);
applicationMock.Setup(p => p.GetReportsList(It.IsAny <GetReportsListRequest>())).Returns(reportsListResponse);
applicationMock.Setup(p => p.GetAccountExplorerTree(It.IsAny <GetAccountExplorerTreeRequest>())).Returns(accountExplorerTreeResponse);
}
public void UpdateSprintReport()
{
// Вызовем UpdateDailyReport для всех отчетов
foreach (var reportDTO in GetAllReports())
{
UpdateDailyReport(reportDTO);
}
var sprintReport = new ReportDTO(_repository.Get(_sprintReportId));
foreach (var reportDTO in GetAllReports())
{
var staff = _staffService.GetById(reportDTO.StaffId);
sprintReport.ChangesTasksId.AddRange(_tasksService.FindTasksModifiedByStaffAndDate(staff, DateTime.Now)
.Select(taskDTO => taskDTO.Id).Distinct().ToList());
foreach (var taskId in _tasksService.GetAllTasks().Where(t => t.State == TaskDTO.TaskState.Resolved && t.StaffId == staff.Id).Select(t => t.Id))
{
sprintReport.AddResolveTask(taskId);
}
}
_repository.Update(sprintReport.ToReportDAL());
}
public ReportDTO Get(Guid id)
{
var report = _db.Reports.Include(x => x.MailAccount).FirstOrDefault(X => X.IdMailAccount == id);
if (report == null)
{
return(null);
}
var dto = new ReportDTO
{
IdReport = report.IdReport,
Description = report.Description,
Subject = report.Subject,
IdMailAccount = report.IdMailAccount,
MailAccount = new MailAccountDTO
{
IdMailAccount = report.IdMailAccount,
Description = report.MailAccount.Description,
Server = report.MailAccount.Server,
Port = report.MailAccount.Port,
Username = report.MailAccount.Username,
Password = report.MailAccount.Password,
UseSSL = report.MailAccount.UseSSL
},
Boby = report.Boby,
IsHtml = report.IsHtml
};
return(dto);
}
public int CreateDailyReport(StaffDTO staffDTO)
{
_staffService.FixStaffDTO(staffDTO);
var reportDAL = new ReportDTO(-1, DateTime.Now, staffDTO.Id).ToReportDAL();
_repository.Create(reportDAL);
return(reportDAL.Id);
}
