private static SendGridMessage CreateMailMessage(ChildDto child, string orchestratorId, string supportEmail, string eventReceiverUrl)
{
var message = new SendGridMessage()
{
Subject = $"SCP - Alert for {child.ChildFirstName } {child.ChildLastName}",
From = new EmailAddress("*****@*****.**")
};
message.AddTo(new EmailAddress(supportEmail));
var strBuilder = new StringBuilder();
strBuilder.AppendLine(
$"We received a gift request from {child.ChildFirstName} {child.ChildLastName} [{child.ChildId}].");
strBuilder.AppendLine();
strBuilder.AppendLine(
$"The requested gift is: {child.CurrentLetter.GiftName } {child.CurrentLetter.GiftBrand }");
strBuilder.AppendLine();
strBuilder.AppendLine(
$"The coefficient of goodness of {child.ChildFirstName } is {child.Goodness}.");
strBuilder.AppendLine();
strBuilder.AppendLine();
strBuilder.AppendLine(
$"To approve the request: {CreateEventReceiverUrl(eventReceiverUrl,orchestratorId,Constants.GiftApprovedEvent)}");
strBuilder.AppendLine();
strBuilder.AppendLine(
$"To decline the request: {CreateEventReceiverUrl(eventReceiverUrl,orchestratorId,Constants.GiftRejectedEvent)}");
strBuilder.AppendLine();
message.AddContent("text/plain", strBuilder.ToString());
return(message);
}
public IActionResult CreateChild(string firstName, string lastName, DateTime dateOfBirth)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var child = new ChildDto()
{
FirstName = firstName,
LastName = lastName,
DateOfBirth = dateOfBirth
};
var childToCreate = AutoMapper.Mapper.Map <Domain.Child>(child);
_iRepo.Add(childToCreate);
if (!_iRepo.Save())
{
return(StatusCode(500, "A problem happend while saving your request."));
}
var createdChild = AutoMapper.Mapper.Map <Models.ChildOnlyDto>(childToCreate);
return(Ok(createdChild));
}
//[HttpGet]
//public IActionResult UpdateChild(int childId)
//{
// var viewModel = new IndexViewModel();
// if (!ModelState.IsValid)
// { return BadRequest(ModelState); }
// ViewBag.firstname = viewModel.FirstName;
// var childFromDb = _iRepo.GetChildById(childId, false, false);
// var childNewData = new ChildDto()
// {
// FirstName = firstName,
// LastName = lastName,
// DateOfBirth = dateOfBirth
// };
// var childToCreate = AutoMapper.Mapper.Map<Domain.Child>(child);
// return PartialView("Index");
//}
//[HttpPut]
public IActionResult UpdateChild(int childId, string firstName, string lastName, DateTime dateOfBirth)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_iRepo.ChildExists(childId))
{
return(NotFound());
}
var childFromDb = _iRepo.GetChildById(childId, false, false);
var childNewData = new ChildDto()
{
Id = childId,
FirstName = firstName,
LastName = lastName,
DateOfBirth = dateOfBirth
};
AutoMapper.Mapper.Map(childNewData, childFromDb);
if (!_iRepo.Save())
{
return(StatusCode(500, "A problem happend while saving your request."));
}
return(Ok("Updaterad"));
}
public static async Task <bool> OrderGift([ActivityTrigger] ChildDto child,
[Table(TableNames.GiftsTable, "Gifts", Connection = "StorageAccount")] CloudTable giftTable,
ILogger log)
{
log.LogInformation($"[START ACTIVITY] --> {Constants.OrderGiftActivityFunction} for {child.ChildId}");
bool retVal = false;
if (child.CurrentLetter != null)
{
try
{
var gift = new GiftRow(child.ChildId);
gift.GiftBrand = child.CurrentLetter.GiftBrand;
gift.GiftName = child.CurrentLetter.GiftName;
gift.IsOrdered = false;
retVal = await giftTable.InsertAsync(gift);
}
catch (Exception ex)
{
log.LogError(ex, $"Error during Order Gift ");
retVal = false;
}
}
return(retVal);
}
protected async Task <int> SetAsDeleted(IEnumerable <string> ids, ChildDto childComment, string rootId)
{
var children = childComment.Comments.Select(c => _mapper.Map <ChildDto, BookChildComment>(c)).ToList();
var path = ids.Skip(1).Select(x => ("Comments", x)).ToList();
return((int)(await _childCommentRepository.SetAsync(
rootId,
new BookChildComment()
{
IsDeleted = true, Text = childComment.Text, Comments = children
},
path
)).ModifiedCount);
}
public static Child ToChildDAL(ChildDto childDto)
{
Child child = new Child()
{
Id = childDto.Id,
Tz = childDto.Tz,
FirstName = childDto.FirstName,
LastName = childDto.LastName,
BornDate = childDto.BornDate,
ParentID = childDto.ParentID,
NumHoursConfirm = childDto.NumHoursConfirm
};
return(child);
}
public static ChildDto ToChildDTO(Child child)
{
ChildDto childDto = new ChildDto()
{
Id = child.Id,
Tz = child.Tz,
FirstName = child.FirstName,
LastName = child.LastName,
BornDate = child.BornDate,
ParentID = child.ParentID,
NumHoursConfirm = child.NumHoursConfirm
};
return(childDto);
}
public static void EditChild(int id, ChildDto child)
{
using (DAL.TafToTafEntities2 db = new DAL.TafToTafEntities2())
{
var editChild = db.Children.FirstOrDefault(ch => ch.Id == id);
if (editChild != null)
{
editChild.FirstName = child.FirstName;
editChild.LastName = child.LastName;
editChild.Tz = child.Tz;
editChild.BornDate = child.BornDate;
editChild.NumHoursConfirm = child.NumHoursConfirm;
editChild.ParentID = child.ParentID;
}
db.SaveChanges();
}
}
public Child SaveChild(Child c)
{
ChildDto childDto = DtoUtils.GetDto(c);
SendRequest(new SaveChildRequest(childDto));
Response response = ReadResponse();
if (response is ErrorResponse)
{
ErrorResponse err = (ErrorResponse)response;
throw new Error(err.Message);
}
SavedChildResponse savedChild = (SavedChildResponse)response;
return(DtoUtils.GetFromDto(savedChild.Child));
}
// PUT: api/Child/5
public IHttpActionResult Put(int id, [FromBody] ChildDto child)
{
try
{
if (child != null)
{
ChildLogic.EditChild(id, child);
return(Ok("nicly"));
}
return(BadRequest("object to edit must have values"));
}
catch (HttpListenerException ex)
{
return(BadRequest(ex.Message));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public static async Task ManageLetter([OrchestrationTrigger] DurableOrchestrationContext context,
ILogger log)
{
log.LogInformation($"[START ORCHESTRATOR] --> LetterManager!");
var letter = context.GetInput <LetterDto>();
ChildDto child = await context.CallActivityWithRetryAsync <ChildDto>(Constants.RetrieveChildActivityFunction,
new RetryOptions(TimeSpan.FromSeconds(1), 10), letter);
if (child == null)
{
return;
}
child.CurrentLetter = letter;
if (child.Goodness >= 5)
{
await context.CallActivityAsync(Constants.OrderGiftActivityFunction, child);
}
else
{
await context.CallActivityAsync(Constants.SendMailToSupportActivityFunction, (context.InstanceId, child));
var approvedGiftEvent = context.WaitForExternalEvent <bool>(Constants.GiftApprovedEvent);
var rejectedGiftEvent = context.WaitForExternalEvent <bool>(Constants.GiftRejectedEvent);
var eventFired = await Task.WhenAny(approvedGiftEvent, rejectedGiftEvent);
if (eventFired == approvedGiftEvent)
{
await context.CallActivityAsync(Constants.OrderGiftActivityFunction, child);
}
else if (eventFired == rejectedGiftEvent)
{
await context.CallActivityAsync(Constants.RetrieveChildActivityFunction, child);
}
}
}
public static async Task <ChildDto> RetrieveChild([ActivityTrigger] LetterDto letter,
[Table(TableNames.ChildrenTable, "Children", Connection = "StorageAccount")] CloudTable childTable,
ILogger log)
{
log.LogInformation($"[START ACTIVITY] --> {Constants.RetrieveChildActivityFunction} for childId={letter.ChildId}");
ChildDto child = null;
try
{
var childRow = await childTable.GetChildByIdAsync(letter.ChildId);
if (childRow == null)
{
childRow = new ChildRow(letter.ChildId);
childRow.FirstName = letter.ChildFirstName;
childRow.LastName = letter.ChildLastName;
childRow.Goodness = 10;
if (!await childTable.InsertAsync(childRow))
{
childRow = null;
}
}
if (childRow != null)
{
child = childRow.ToChildDto();
child.CurrentLetter = letter;
}
}
catch (Exception ex)
{
log.LogError(ex, $"Error during retriving child");
return(null);
}
return(child);
}
public static void InsertChild(DTO.ChildPost child, string kGardenName)
{
using (DAL.TafToTafEntities2 db = new DAL.TafToTafEntities2())
{
int kGardenID = db.KinderGardens.First(kg => kg.Name == kGardenName).Id;
User user = new User()
{
LastName = child.LastName,
FirstName = child.ParentName,
KindUser = 3,
UserName = "******" + "3",
Email = child.ParentEmail,
Password = child.Tz,
};
db.Users.Add(user);
db.SaveChanges();
ChildDto childDto = new ChildDto()
{
FirstName = child.FirstName,
LastName = child.LastName,
BornDate = child.BornDate,
NumHoursConfirm = child.NumHoursConfirm,
Tz = child.Tz,
ParentID = db.Users.First(u => u.Password == child.Tz).Id
};
db.Children.Add(ChildC.ToChildDAL(childDto));
db.ChildKinderGardens.Add(new ChildKinderGarden()
{
ChildID = child.Id,
KindrGardenID = kGardenID,
BeginYear = PublicLogic.CalcBeaginYear(),
EndYear = PublicLogic.CalcEndYear(),
});
db.SaveChanges();
PublicLogic.SendEmail("TLT3", child.Tz, child.ParentEmail);
}
}
private Response HandleRequest(Request request)
{
Response response = null;
if (request is LoginRequest)
{
LoginRequest loginRequest = (LoginRequest)request;
AdminDto dto = loginRequest.User;
logger.Debug("Processing login request by user " + dto.ID);
Admin user = DtoUtils.GetFromDto(dto);
try
{
lock (server)
{
server.Login(user.ID, user.Password, this);
}
return(new OkResponse());
}
catch (Error e)
{
logger.Debug("User " + dto.ID + " already logged in. Disconnecting...");
connected = false;
return(new ErrorResponse(e.Message));
}
}
if (request is LogoutRequest)
{
LogoutRequest logoutRequest = (LogoutRequest)request;
AdminDto dto = logoutRequest.User;
logger.Debug("Processing logout request by user " + dto.ID);
Admin user = DtoUtils.GetFromDto(dto);
try
{
lock (server)
{
server.Logout(user.ID, this);
}
connected = false;
return(new OkResponse());
}
catch (Error e)
{
return(new ErrorResponse(e.Message));
}
}
if (request is SaveChildRequest)
{
SaveChildRequest saveChildRequest = (SaveChildRequest)request;
ChildDto dto = saveChildRequest.Child;
logger.Debug("Processing save request for child ID " + dto.ID);
Child c = DtoUtils.GetFromDto(dto);
try
{
Child result;
lock (server)
{
result = server.SaveChild(c);
}
if (result != null)
{
return(new SavedChildResponse(DtoUtils.GetDto(result)));
}
else
{
return(new ErrorResponse("Child " + c.ID + " could not be saved"));
}
}
catch (Error e)
{
return(new ErrorResponse(e.Message));
}
}
if (request is FilterChildrenRequest)
{
FilterChildrenRequest filterChildrenRequest = (FilterChildrenRequest)request;
string data = filterChildrenRequest.Data;
IList <int> parameters = Parser.ToList(data);
logger.Debug("Processing filter children request for event ID " + parameters[0]);
try
{
Child[] result;
lock (server)
{
result = server.GetFilteredChildren(parameters[0], parameters[1], parameters[2]).ToArray();
}
return(new ListOfChildrenResponse(DtoUtils.GetDto(result)));
}
catch (Error e)
{
return(new ErrorResponse(e.Message));
}
}
if (request is GetEventsRequest)
{
GetEventsRequest getEventsRequest = (GetEventsRequest)request;
logger.Debug("Processing get events request");
try
{
Event[] events;
lock (server)
{
events = server.GetAllEvents().ToArray();
}
return(new ListOfEventsResponse(DtoUtils.GetDto(events)));
}
catch (Error e)
{
return(new ErrorResponse(e.Message));
}
}
if (request is CountChildrenRequest)
{
CountChildrenRequest countChildrenRequest = (CountChildrenRequest)request;
logger.Debug("Processing count children request for event ID " + countChildrenRequest.EventID);
try
{
int count;
lock (server)
{
count = server.CountChildren(countChildrenRequest.EventID);
}
return(new CounterOfChildrenResponse(count));
}
catch (Error e)
{
return(new ErrorResponse(e.Message));
}
}
return(response);
}
public async Task <int> SetAsDeletedProxy(IEnumerable <string> ids, ChildDto childComment, string rootId)
{
return(await base.SetAsDeleted(ids, childComment, rootId));
}
public SaveChildRequest(ChildDto child)
{
this.child = child;
}
public SavedChildResponse(ChildDto child)
{
this.child = child;
}
public NewChildResponse(ChildDto child)
{
this.child = child;
}
