public async Task <RFA> Submit([FromBody] RFA data)
{
data.RaisedBy = User.GetUserId();
data.RaisedByName = User.GetName();
return(await _rfaService.Submit(data));
}
public Model.Request Map(Model.Request request,
Code customerCode,
Code groupCode,
HalalTeam halal,
Premise premise,
Characteristic characteristic,
RFA rfa,
Log log,
Attachment attachment,
RequestLineItem lineItem,
Review review,
ReviewLineItem reviewLineItem,
Characteristic lineItemChar)
{
return(InternalMap(request,
customerCode,
groupCode,
lineItem,
lineItemChar,
halal,
premise,
characteristic,
attachment,
rfa,
log,
review,
reviewLineItem));
}
public async Task <RFA> SubmitRFA(RFA rfa)
{
if (rfa.ID != 0L)
{
return(await Execute(new UpdateRFACommand(rfa, _eventBus)));
}
return(await Execute(new SubmitRFACommand(rfa, _eventBus)));
}
public Task <RFA> Submit(RFA data)
{
return(_requestProvider.BuildUpon(_url)
.Uri("/api/rfa")
.Method(HttpMethod.Post)
.AddInterceptor(new JsonDeserializerInterceptor())
.Content(new JsonContent(data))
.Execute <RFA>());
}
public Model.Request Map(Model.Request request,
Code customerCode = null,
RequestLineItem lineItem = null,
Premise premise = null,
RFA rfa = null,
Characteristic lineItemChar = null)
{
return(InternalMap(request,
customerCode,
lineItem: lineItem,
premise: premise,
rfa: rfa,
lineItemChar: lineItemChar));
}
public async Task <Model.Request> GetRequestByRefID(string refID)
{
var param = new DynamicParameters();
param.Add("@RefID", refID);
var mapper = new RequestMapper();
return((await SqlMapper.QueryAsync(_unitOfWork.Connection,
"GetRequestByRefID",
new[]
{
typeof(Model.Request),
typeof(HalalTeam),
typeof(Premise),
typeof(Characteristic),
typeof(RFA),
typeof(Log),
typeof(Attachment),
typeof(RequestLineItem),
typeof(Review),
typeof(ReviewLineItem),
typeof(Characteristic)
},
obj =>
{
Model.Request re = obj[0] as Model.Request;
HalalTeam ha = obj[1] as HalalTeam;
Premise pr = obj[2] as Premise;
Characteristic ch = obj[3] as Characteristic;
RFA r = obj[4] as RFA;
Log l = obj[5] as Log;
Attachment att = obj[6] as Attachment;
RequestLineItem rli = obj[7] as RequestLineItem;
Review rev = obj[8] as Review;
ReviewLineItem revli = obj[9] as ReviewLineItem;
Characteristic licha = obj[10] as Characteristic;
return mapper.Map(re, null, null, ha, pr, ch, r, l, att, rli, rev, revli, licha);
},
param,
splitOn: "ID,HalalTeamID,PremiseID,CharID,RFAID,LogID,AttID,LineItemID,ReviewID," +
"ReviewLineItemID,LiCharID",
commandType: CommandType.StoredProcedure,
transaction: _unitOfWork.Transaction)).FirstOrDefault());
}
public static DataTable ToRFAData(RFA rfa)
{
DataTable dr = new DataTable();
dr.Columns.Add("Status", typeof(int));
dr.Columns.Add("RaisedBy", typeof(Guid));
dr.Columns.Add("RaisedByName", typeof(string));
dr.Columns.Add("RequestID", typeof(long));
dr.Columns.Add("CreatedOn", typeof(DateTimeOffset));
dr.Columns.Add("DueOn", typeof(DateTimeOffset));
dr.Columns.Add("ModifiedOn", typeof(DateTimeOffset));
dr.Rows.Add(
rfa.Status,
rfa.RaisedBy,
rfa.RaisedByName,
rfa.RequestID,
rfa.CreatedOn?.ToUniversalTime(),
rfa.DueOn?.ToUniversalTime(),
rfa.ModifiedOn?.ToUniversalTime()
);
return(dr);
}
Model.Request InternalMap(Model.Request request,
Code customerCode = null,
Code groupCode = null,
RequestLineItem lineItem = null,
Characteristic lineItemChar = null,
HalalTeam halalTeam = null,
Premise premise = null,
Characteristic characteristic = null,
Attachment attachment = null,
RFA rfa = null,
Log log = null,
Review review = null,
ReviewLineItem reviewLineItem = null)
{
if (!_cache.TryGetValue(request.ID, out Model.Request result))
{
_cache[request.ID] = request;
result = request;
}
if ((customerCode?.ID ?? 0) > 0)
{
result.CustomerCode = customerCode;
}
if ((groupCode?.ID ?? 0) > 0)
{
result.GroupCode = groupCode;
}
RequestLineItem outLineItem = null;
if ((lineItem?.ID ?? 0L) != 0L &&
!_lineItemCache.TryGetValue(lineItem.ID, out outLineItem))
{
if (result.LineItems == null)
{
result.LineItems = new List <RequestLineItem>();
}
result.LineItems.Add(lineItem);
_lineItemCache[lineItem.ID] = lineItem;
outLineItem = lineItem;
}
if (outLineItem != null &&
(lineItemChar?.ID ?? 0L) != 0L &&
!_lineItemCharCache.ContainsKey(lineItemChar.ID))
{
if (outLineItem.Characteristics == null)
{
outLineItem.Characteristics = new List <Characteristic>();
}
_lineItemCharCache[lineItemChar.ID] = lineItemChar;
outLineItem.Characteristics.Add(lineItemChar);
}
if ((halalTeam?.ID ?? 0L) != 0L &&
!_halalCache.ContainsKey(halalTeam.ID))
{
_halalCache[halalTeam.ID] = halalTeam;
if (result.Teams == null)
{
result.Teams = new List <HalalTeam>();
}
result.Teams.Add(halalTeam);
}
if ((premise?.ID ?? 0L) != 0L &&
result.Premises?.FirstOrDefault(e => e.ID == premise.ID) == null)
{
if (result.Premises == null)
{
result.Premises = new List <Premise>();
}
result.Premises.Add(premise);
}
if ((characteristic?.ID ?? 0L) != 0L &&
!_characteristicsCache.ContainsKey(characteristic.ID))
{
_characteristicsCache[characteristic.ID] = characteristic;
if (result.Characteristics == null)
{
result.Characteristics = new List <Characteristic>();
}
result.Characteristics.Add(characteristic);
}
if ((attachment?.ID ?? 0L) != 0L &&
!_attachmentCache.ContainsKey(attachment.ID))
{
_attachmentCache[attachment.ID] = attachment;
if (result.Attachments == null)
{
result.Attachments = new List <Attachment>();
}
result.Attachments.Add(attachment);
}
if ((rfa?.ID ?? 0L) != 0L &&
!_rfaCache.ContainsKey(rfa.ID))
{
_rfaCache[rfa.ID] = rfa;
if (result.RFAs == null)
{
result.RFAs = new List <RFA>();
}
result.RFAs.Add(rfa);
}
if ((log?.ID ?? 0L) != 0L &&
!_logCache.ContainsKey(log.ID))
{
_logCache[log.ID] = log;
if (result.Logs == null)
{
result.Logs = new List <Log>();
}
result.Logs.Add(log);
}
Review outReview = null;
if ((review?.ID ?? 0L) != 0L &&
!_reviewCache.TryGetValue(review.ID, out outReview))
{
if (result.Reviews == null)
{
result.Reviews = new List <Review>();
}
result.Reviews.Add(review);
_reviewCache[review.ID] = review;
outReview = review;
}
if (outReview != null &&
(reviewLineItem?.ID ?? 0L) != 0L &&
!_reviewLineItemCache.ContainsKey(reviewLineItem.ID))
{
_reviewLineItemCache[reviewLineItem.ID] = reviewLineItem;
if (outReview.LineItems == null)
{
outReview.LineItems = new List <ReviewLineItem>();
}
outReview.LineItems.Add(reviewLineItem);
}
return(result);
}
public async Task <RFA> SubmitRFAResponse(RFA rfa)
{
return(await Execute(new SubmitRFAResponseCommand(rfa, _eventBus)));
}
public RFA Map(RFA rfa,
RFALineItem li = null,
Attachment liAtt = null,
RFAReply rep = null,
Attachment repAtt = null,
Log rfaLog = null,
Model.Request request = null)
{
if (!_rfaCache.TryGetValue(rfa.ID, out RFA result))
{
if ((request?.ID ?? 0) > 0)
{
rfa.Request = request;
}
_rfaCache[rfa.ID] = rfa;
result = rfa;
}
if ((rfaLog?.ID ?? 0) != 0 &&
!_rfaLogCache.ContainsKey(rfaLog.ID))
{
_rfaLogCache[rfaLog.ID] = rfaLog;
if (result.Logs == null)
{
result.Logs = new List <Log>();
}
result.Logs.Add(rfaLog);
}
if ((li?.ID ?? 0) != 0)
{
if (!_liCache.TryGetValue(li.ID, out RFALineItem liOut))
{
_liCache[li.ID] = li;
liOut = li;
if (result.LineItems == null)
{
result.LineItems = new List <RFALineItem>();
}
result.LineItems.Add(li);
}
if ((liAtt?.ID ?? 0) != 0 &&
!_liAttCache.ContainsKey(liAtt.ID))
{
if (liOut.Attachments == null)
{
liOut.Attachments = new List <Attachment>();
}
liOut.Attachments.Add(liAtt);
_liAttCache[liAtt.ID] = liAtt;
}
RFAReply repOut = null;
if ((rep?.ID ?? 0) != 0 &&
!_repCache.TryGetValue(rep.ID, out repOut))
{
rep.Attachments = new List <Attachment>();
_repCache[rep.ID] = rep;
repOut = rep;
if (liOut.Replies == null)
{
liOut.Replies = new List <RFAReply>();
}
liOut.Replies.Add(rep);
}
if ((repAtt?.ID ?? 0) != 0 &&
!_repAttCache.ContainsKey(repAtt.ID))
{
repOut.Attachments.Add(repAtt);
_repAttCache[repAtt.ID] = repAtt;
}
}
return(result);
}
public async Task <RFA> SubmitRFAResponse([FromBody] RFA rfa)
{
return(await _rfaservice.SubmitRFAResponse(rfa));
}
public async Task <RFA> Post([FromBody] RFA rfa)
{
return(await _rfaservice.SubmitRFA(rfa));
}
public static DataTable ToRFALineItemData(
RFA rfa,
out DataTable lineitemattachment, out DataTable lineitemreply,
out DataTable lineitemreplyattachments)
{
lineitemattachment = new DataTable();
lineitemreply = new DataTable();
lineitemreplyattachments = new DataTable();
DataTable replyItems = new DataTable();
DataTable lineitemattachments = new DataTable();
DataTable lineReplyAttachments = new DataTable();
DataTable dl = new DataTable();
dl.Columns.Add("Scheme", typeof(int));
dl.Columns.Add("Index", typeof(int));
dl.Columns.Add("ComplianceCategoryID", typeof(long));
dl.Columns.Add("ComplianceCategoryText", typeof(string));
dl.Columns.Add("ComplianceID", typeof(long));
dl.Columns.Add("ComplianceText", typeof(string));
dl.Columns.Add("Remarks", typeof(string));
dl.Columns.Add("RFAID", typeof(long));
dl.Columns.Add("CreatedOn", typeof(DateTimeOffset));
dl.Columns.Add("ModifiedOn", typeof(DateTimeOffset));
dl.Columns.Add("Text", typeof(string));
if (rfa.LineItems != null)
{
foreach (RFALineItem item in rfa.LineItems)
{
dl.Rows.Add(
item.Scheme,
item.Index,
item.ChecklistCategoryID,
item.ChecklistCategoryText,
item.ChecklistID,
item.ChecklistText,
item.Remarks,
item.RFAID,
item.CreatedOn,
item.ModifiedOn);
if (item.Attachments != null)
{
var attachments = ToRFAAttachmentData(item.Attachments.ToList(), item.Index);
if (lineitemattachments != null && lineitemattachments.Rows.Count > 0 &&
attachments != null && attachments.Rows.Count > 0)
{
lineitemattachments.Merge(attachments);
}
else
{
lineitemattachments = attachments;
}
}
if (item.Replies != null && item.Replies.Count > 0)
{
var reply = ToRFALineItemReplyData(item, out lineReplyAttachments);
if (reply != null && reply.Rows.Count > 0)
{
replyItems.Merge(reply);
}
if (lineReplyAttachments != null && lineReplyAttachments.Rows.Count > 0)
{
if (lineitemreplyattachments != null && lineitemreplyattachments.Rows.Count > 0)
{
lineitemreplyattachments.Merge(lineReplyAttachments);
}
else
{
lineitemreplyattachments = lineReplyAttachments;
}
}
}
}
}
lineitemreply = replyItems;
lineitemattachment = lineitemattachments;
return(dl);
}
public async Task <long> InsertRFA(RFA rfa)
{
var rfaParam = new DynamicParameters();
rfaParam.Add("@Status", rfa.Status);
rfaParam.Add("@RaisedBy", rfa.RaisedBy);
rfaParam.Add("@RaisedByName", rfa.RaisedByName);
rfaParam.Add("@DueOn", rfa.DueOn);
rfaParam.Add("@RequestID", rfa.RequestID);
rfaParam.Add("@ID", dbType: DbType.Int64, direction: ParameterDirection.Output);
await SqlMapper.ExecuteAsync(_unitOfWork.Connection,
"InsertRFA",
rfaParam,
commandType : CommandType.StoredProcedure,
transaction : _unitOfWork.Transaction);
var id = rfaParam.Get <long>("@ID");
// Insert lineitem section
if (rfa.LineItems?.Any() ?? false)
{
foreach (var li in rfa.LineItems)
{
var lineItemID = 0L;
var lineItemParam = new DynamicParameters();
lineItemParam.Add("@Scheme", li.Scheme);
lineItemParam.Add("@Index", li.Index);
lineItemParam.Add("@ChecklistCategoryID", li.ChecklistCategoryID);
lineItemParam.Add("@ChecklistCategoryText", li.ChecklistCategoryText);
lineItemParam.Add("@ChecklistID", li.ChecklistID);
lineItemParam.Add("@ChecklistText", li.ChecklistText);
lineItemParam.Add("@Remarks", li.Remarks);
lineItemParam.Add("@RFAID", id);
lineItemParam.Add("@ID", dbType: DbType.Int64, direction: ParameterDirection.Output);
await SqlMapper.ExecuteAsync(_unitOfWork.Connection,
"InsertRFALineItem",
lineItemParam,
commandType : CommandType.StoredProcedure,
transaction : _unitOfWork.Transaction);
lineItemID = lineItemParam.Get <long>("@ID");
// Insert lineitem attachments section
if (li.Attachments?.Any() ?? false)
{
var attachmentsTable = new DataTable();
attachmentsTable.Columns.Add("A", typeof(long));
attachmentsTable.Columns.Add("B", typeof(long));
foreach (var a in li.Attachments)
{
var aParam = DataConverter.Convert(a);
await SqlMapper.ExecuteAsync(_unitOfWork.Connection,
"InsertAttachment",
aParam,
commandType : CommandType.StoredProcedure,
transaction : _unitOfWork.Transaction);
attachmentsTable.Rows.Add(lineItemID, aParam.Get <long>("@ID"));
}
// Insert lineitem attachment mapping entities
var liAttachmentParam = new DynamicParameters();
liAttachmentParam.Add("@IDMappingType", attachmentsTable.AsTableValuedParameter("dbo.IDMappingType"));
await SqlMapper.ExecuteAsync(_unitOfWork.Connection,
"InsertRFALineItemAttachments",
liAttachmentParam,
commandType : CommandType.StoredProcedure,
transaction : _unitOfWork.Transaction);
}
}
}
return(id);
}
