public IList <object[]> GetComplaintsResults(IUnitOfWork uow, DateTime?start = null, DateTime?end = null)
{
ComplaintResult complaintResultAlias = null;
var query = uow.Session.QueryOver <Complaint>()
.Left.JoinAlias(c => c.ComplaintResult, () => complaintResultAlias)
.Where(c => c.Status == ComplaintStatuses.Closed)
;
if (start != null && end != null)
{
query.Where(c => c.CreationDate >= start)
.Where(c => c.CreationDate <= end);
}
var result = query.SelectList(list => list
.SelectGroup(() => complaintResultAlias.Name)
.Select(
Projections.SqlFunction(
new SQLFunctionTemplate(NHibernateUtil.Int32, "COUNT(IFNULL(?1, 0))"),
NHibernateUtil.Int32,
Projections.Property(() => complaintResultAlias.Id)
)
))
.List <object[]>()
;
return(result);
}
public Task <ComplaintResult> GetComplaintByIdAsync(Guid id)
{
_logger.LogInformation("Reading complaint from DB happens here({ComplaintId})", id);
// TODO(abhith): read from DB
var output = new ComplaintResult
{
Id = id,
Name = "Demo Complaint",
Status = ComplaintStatus.Submitted.Name,
ComplaintItems = new List <ComplaintItemDto> {
new ComplaintItemDto
{
Title = "Title 1",
Description = "Some description"
}, new ComplaintItemDto()
{
Title = "Title 2",
Description = "Some description"
}
}
};
return(Task.FromResult(output));
}
public async void AddComplaintOrganization_ExpectedGuidTicketNumber_ThenGetComplaintContact()
{
var httpClient = new HttpClient();
ComplaintAddOrganizationVm complaintAddOrganization = GetComplaintAddOrganization("FullData");
var jsonString = JsonConvert.SerializeObject(complaintAddOrganization);
var httpContent = new StringContent(jsonString, Encoding.UTF8, "application/json");
HttpResponseMessage httpResponseMessage = await httpClient.PostAsync($"{EndPoints.BaseUrl}{EndPoints.ComplaintOrganization}", httpContent);
var strJsonResult = await httpResponseMessage.Content.ReadAsStringAsync();
ComplaintResult complaintResult = JsonConvert.DeserializeObject <ComplaintResult>(strJsonResult);
HttpStatusCode httpStatusCode = httpResponseMessage.StatusCode;
Assert.Equal(HttpStatusCode.OK, httpStatusCode);
HttpResponseMessage httpResponseMessageComplaint = await httpClient.GetAsync($"{EndPoints.BaseUrl}{EndPoints.Complaint}/{complaintResult.complaintId}");
HttpStatusCode httpStatusComplaint = httpResponseMessageComplaint.StatusCode;
Assert.Equal(HttpStatusCode.OK, httpStatusComplaint);
var strJson = await httpResponseMessageComplaint.Content.ReadAsStringAsync();
var complaintByID = JsonConvert.DeserializeObject <ComplaintResult>(strJson);
Assert.IsType <ComplaintResult>(complaintByID);
Assert.NotNull(complaintByID);
}
void HandleComplaint(Complaint packet)
{ // NOTE: all chat messages from this spammer are automatically ignored by the spam reporter until logout in case of chat spam.
// if it's mail spam - ALL mails from this spammer are automatically removed by client
ComplaintResult result = new ComplaintResult();
result.ComplaintType = packet.ComplaintType;
result.Result = 0;
SendPacket(result);
}
private IList <ComplaintGuiltyNode> GetGuilties(ComplaintFilterViewModel filter)
{
Complaint complaintAlias = null;
Subdivision subdivisionAlias = null;
Subdivision subdivisionForEmployeeAlias = null;
Employee employeeAlias = null;
ComplaintGuiltyItem guiltyItemAlias = null;
ComplaintResult complaintResultAlias = null;
QueryNode queryNodeAlias = null;
ComplaintDiscussion discussionAlias = null;
var query = InfoProvider.UoW.Session.QueryOver(() => guiltyItemAlias)
.Left.JoinAlias(() => guiltyItemAlias.Complaint, () => complaintAlias)
.Left.JoinAlias(() => complaintAlias.ComplaintResult, () => complaintResultAlias)
.Left.JoinAlias(() => guiltyItemAlias.Subdivision, () => subdivisionAlias)
.Left.JoinAlias(() => guiltyItemAlias.Employee, () => employeeAlias)
.Left.JoinAlias(() => employeeAlias.Subdivision, () => subdivisionForEmployeeAlias)
;
filter.EndDate = filter.EndDate.Date.AddHours(23).AddMinutes(59);
if (filter.StartDate.HasValue)
{
filter.StartDate = filter.StartDate.Value.Date;
}
QueryOver <ComplaintDiscussion, ComplaintDiscussion> dicussionQuery = null;
if (filter.Subdivision != null)
{
dicussionQuery = QueryOver.Of(() => discussionAlias)
.Select(Projections.Property <ComplaintDiscussion>(p => p.Id))
.Where(() => discussionAlias.Subdivision.Id == filter.Subdivision.Id)
.And(() => discussionAlias.Complaint.Id == complaintAlias.Id);
}
if (filter.StartDate.HasValue)
{
switch (filter.FilterDateType)
{
case DateFilterType.PlannedCompletionDate:
if (dicussionQuery == null)
{
query = query.Where(() => complaintAlias.PlannedCompletionDate <= filter.EndDate)
.And(() => filter.StartDate == null || complaintAlias.PlannedCompletionDate >= filter.StartDate.Value);
}
else
{
dicussionQuery = dicussionQuery
.And(() => filter.StartDate == null || discussionAlias.PlannedCompletionDate >= filter.StartDate.Value)
.And(() => discussionAlias.PlannedCompletionDate <= filter.EndDate);
}
break;
case DateFilterType.ActualCompletionDate:
query = query.Where(() => complaintAlias.ActualCompletionDate <= filter.EndDate)
.And(() => filter.StartDate == null || complaintAlias.ActualCompletionDate >= filter.StartDate.Value);
break;
case DateFilterType.CreationDate:
query = query.Where(() => complaintAlias.CreationDate <= filter.EndDate)
.And(() => filter.StartDate == null || complaintAlias.CreationDate >= filter.StartDate.Value);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
if (dicussionQuery != null)
{
query.WithSubquery.WhereExists(dicussionQuery);
}
if (filter.ComplaintType != null)
{
query = query.Where(() => complaintAlias.ComplaintType == filter.ComplaintType);
}
if (filter.ComplaintStatus != null)
{
query = query.Where(() => complaintAlias.Status == filter.ComplaintStatus);
}
if (filter.Employee != null)
{
query = query.Where(() => complaintAlias.CreatedBy.Id == filter.Employee.Id);
}
if (filter.GuiltyItemVM?.Entity?.GuiltyType != null)
{
var subquery = QueryOver.Of <ComplaintGuiltyItem>()
.Where(g => g.GuiltyType == filter.GuiltyItemVM.Entity.GuiltyType.Value);
switch (filter.GuiltyItemVM.Entity.GuiltyType)
{
case ComplaintGuiltyTypes.None:
case ComplaintGuiltyTypes.Client:
case ComplaintGuiltyTypes.Supplier:
break;
case ComplaintGuiltyTypes.Employee:
if (filter.GuiltyItemVM.Entity.Employee != null)
{
subquery.Where(g => g.Employee.Id == filter.GuiltyItemVM.Entity.Employee.Id);
}
break;
case ComplaintGuiltyTypes.Subdivision:
if (filter.GuiltyItemVM.Entity.Subdivision != null)
{
subquery.Where(g => g.Subdivision.Id == filter.GuiltyItemVM.Entity.Subdivision.Id);
}
break;
default:
break;
}
query.WithSubquery.WhereProperty(() => complaintAlias.Id).In(subquery.Select(x => x.Complaint));
}
if (filter.ComplaintKind != null)
{
query.Where(() => complaintAlias.ComplaintKind.Id == filter.ComplaintKind.Id);
}
var result = query.SelectList(list => list
.SelectGroup(c => c.Complaint.Id)
.Select(() => complaintAlias.Status).WithAlias(() => queryNodeAlias.Status)
.Select(() => complaintResultAlias.Name).WithAlias(() => queryNodeAlias.ResultText)
.Select(Projections.SqlFunction(
new SQLFunctionTemplate(
NHibernateUtil.String,
"GROUP_CONCAT(" +
"CASE ?1 " +
$"WHEN '{nameof(ComplaintGuiltyTypes.Employee)}' THEN IFNULL(CONCAT('Отд: ', ?2), 'Отдел ВВ') " +
$"WHEN '{nameof(ComplaintGuiltyTypes.Subdivision)}' THEN IFNULL(CONCAT('Отд: ', ?3), 'Отдел ВВ') " +
$"WHEN '{nameof(ComplaintGuiltyTypes.Client)}' THEN 'Клиент' " +
$"WHEN '{nameof(ComplaintGuiltyTypes.Supplier)}' THEN 'Поставщик' " +
$"WHEN '{nameof(ComplaintGuiltyTypes.None)}' THEN 'Нет (не рекламация)' " +
"ELSE ?1 " +
"END " +
"ORDER BY ?1 ASC SEPARATOR '\n')"),
NHibernateUtil.String,
Projections.Property(() => guiltyItemAlias.GuiltyType),
Projections.Property(() => subdivisionForEmployeeAlias.Name),
Projections.Property(() => subdivisionAlias.Name)))
.WithAlias(() => queryNodeAlias.GuiltyName))
.TransformUsing(Transformers.AliasToBean <QueryNode>())
.List <QueryNode>();
var groupedResult = result.GroupBy(p => p.GuiltyName, (guiltyName, guiltiesGroup) => new ComplaintGuiltyNode {
GuiltyName = guiltyName,
Count = guiltiesGroup.Count(),
Guilties = guiltiesGroup.ToList()
}).ToList();
//Удаление дублирующихся названий отделов
for (int i = 0; i < groupedResult.Count; i++)
{
if (groupedResult[i].GuiltyName.Contains("\n"))
{
groupedResult[i].GuiltyName = string.Join("\n", groupedResult[i].GuiltyName.Split('\n').Distinct());
}
}
foreach (var item in groupedResult)
{
item.CreateComplaintResultNodes();
}
return(groupedResult);
}
