protected async Task NotifyEntry(Entry entry)
{
try
{
await SNS.PublishAsync(new PublishRequest { PhoneNumber = entry.PhoneNumber, Message = $"Your verification code is '{entry.VerifyCode}'" });
}
catch (Exception e) {}
try
{
await Mailer.SendEmailAsync(new Amazon.SimpleEmail.Model.SendEmailRequest
{
Source = "*****@*****.**",
Destination = new Amazon.SimpleEmail.Model.Destination
{
ToAddresses = new List <string> {
entry.MailAddress
}
},
Message = new Amazon.SimpleEmail.Model.Message
{
Subject = new Amazon.SimpleEmail.Model.Content("dotnetKonf Registration"),
Body = new Amazon.SimpleEmail.Model.Body
{
Html = new Amazon.SimpleEmail.Model.Content($"Your verification code is '{entry.VerifyCode}'"),
Text = new Amazon.SimpleEmail.Model.Content($"Your verification code is '{entry.VerifyCode}'")
}
}
});
}
catch (Exception e) {}
}
public string Publish(BookVM model)
{
var em = MapperService.Map <BookEM>(model);
var json = JsonConvert.SerializeObject(em);
var arn = ConfigurationManager.AppSettings["AWSSNSTopicARN"];
var sns = new SNS();
return(sns.PublishEntity(arn, json, "Book", "Book"));
}
private static Stream HandleException(string id, string snsTopicArn, Exception e)
{
Logger.Log(e);
string snsMessage = SNS.CreateMessage(e.Message, "exception", e.StackTrace);
SNS.SendMessage(snsTopicArn, snsMessage);
return(LambdaResponse.Create(id, e.Message, null));
}
public bool Delete()
{
if (Id == 0)
{
return(false);
}
if (SNS.RemoveDevice(EndpointARN))
{
Deleted = true;
return(Update());
}
return(false);
}
private static NirvanaResult GetNirvanaFailResult(StringBuilder runLog, NirvanaConfig config, ErrorCategory errorCategory, string errorMessage, string stackTrace, string snsTopicArn)
{
string status = GetFailedRunStatus(errorCategory, errorMessage);
if (errorCategory != ErrorCategory.UserError)
{
string snsMessage = SNS.CreateMessage(runLog.ToString(), status, stackTrace);
SNS.SendMessage(snsTopicArn, snsMessage);
}
return(new NirvanaResult
{
id = config.id,
status = status
});
}
public static Stream GetStream(string id, string snsTopicArn, Exception e)
{
Logger.Log(e);
GC.Collect();
string snsMessage = SNS.CreateMessage(e.Message, "exception", e.StackTrace);
SNS.SendMessage(snsTopicArn, snsMessage);
ErrorCategory errorCategory = ExceptionUtilities.ExceptionToErrorCategory(e);
string message = GetMessage(errorCategory, e.Message);
LogUtilities.LogObject("Result", message);
return(SingleResult.Create(id, message, null));
}
private static AnnotationResult HandleException(StringBuilder runLog, AnnotationResult result, Exception e, string snsTopicArn)
{
Logger.Log(e);
result.status = e.Message;
result.errorCategory = ExceptionUtilities.ExceptionToErrorCategory(e);
Logger.WriteLine($"Error Category: {result.errorCategory}");
if (result.errorCategory != ErrorCategory.UserError)
{
string snsMessage = SNS.CreateMessage(runLog.ToString(), result.status, e.StackTrace);
SNS.SendMessage(snsTopicArn, snsMessage);
}
LogUtilities.LogObject("Result", result);
return(result);
}
private ValidationResult HandleException(string id, Exception exception, string snsTopicArn)
{
Logger.Log(exception);
string snsMessage = SNS.CreateMessage(exception.Message, "exception", exception.StackTrace);
SNS.SendMessage(snsTopicArn, snsMessage);
ErrorCategory errorCategory = ExceptionUtilities.ExceptionToErrorCategory(exception);
var errorMessagePrefix = errorCategory == ErrorCategory.UserError ? "User error" : "Nirvana error";
return(new ValidationResult
{
id = id,
status = $"{errorMessagePrefix}: {exception.Message}"
});
}
private static CustomResult HandleException(StringBuilder runLog, CustomResult result, Exception e, string snsTopicArn)
{
Logger.Log(e);
var errorCategory = ExceptionUtilities.ExceptionToErrorCategory(e);
result.status = $"{errorCategory}: {e.Message}";
if (errorCategory != ErrorCategory.UserError)
{
string snsMessage = SNS.CreateMessage(runLog.ToString(), result.status, e.StackTrace);
SNS.SendMessage(snsTopicArn, snsMessage);
}
LogUtilities.LogObject("Result", result);
LambdaUtilities.DeleteTempOutput();
return(result);
}
private void SendPushNotification(string DeviceARN)
{
var message = "Notification";
switch (TypeId)
{
case NotificationType.BookingCancelled:
message = string.Format(Translations.Translate("Booking Cancelled", User.LanguageId), BookingId);
break;
case NotificationType.BookingConfirmed:
message = string.Format(Translations.Translate("Booking Confirmed", User.LanguageId), BookingId);
break;
case NotificationType.NewBooking:
message = string.Format(Translations.Translate("Booking Received", User.LanguageId), BookingId);
break;
case NotificationType.NewReview:
message = string.Format(Translations.Translate("New Review", User.LanguageId), BookingId);
break;
case NotificationType.PaymentReceived:
message = string.Format(Translations.Translate("Payment Received", User.LanguageId), BookingId);
break;
case NotificationType.ServiceComplete:
message = string.Format(Translations.Translate("Booking Completed", User.LanguageId), BookingId);
break;
case NotificationType.ServiceIncomplete:
message = string.Format(Translations.Translate("Booking Not Completed", User.LanguageId), BookingId);
break;
}
var args = new Dictionary <string, object>
{
{ "UserId", UserId },
{ "BookingId", BookingId }
};
SNS.SendMessage(DeviceARN, message, $"app.agrishare.category.{TypeId}", args);
}
public bool Save()
{
var success = false;
var user = User;
if (user != null)
{
UserId = user.Id;
}
User = null;
if (EndpointARN.IsEmpty() && !Token.IsEmpty())
{
if (SNS.AddDevice(Token, out var arn))
{
EndpointARN = arn;
}
else
{
return(false);
}
}
if (Id == 0)
{
success = Add();
}
else
{
success = Update();
}
User = user;
return(success);
}
//@ Process // BuildupCurve_spline()
public bool BuildupCurve_spline(E_TYPE_SPLINE eTypeCurve, float fDivisionWeight)
{
if (m_listCurvepathunit.Count > 0)
{
m_listPath_Spline.Clear();
foreach (CCurvePathUnit flypathUnit in m_listCurvepathunit)
{
if (flypathUnit)
{
m_listPath_Spline.Add(flypathUnit.getPosUnit());
}
}
}
if (m_listPath_Spline.Count < 1)
{
Debug.Log("Cant Buildup CurveList. no Instant Custom Point!!//");
return(false);
}
float fDivisionWeight__ = -1.0f;
if (fDivisionWeight < 0)
{
fDivisionWeight__ = m_fDivisionWeight_LineCurve;
}
else
{
fDivisionWeight__ = m_fDivisionWeight_LineCurve = fDivisionWeight;
} // if(fDivisionWeight < 0)
if (E_TYPE_SPLINE.SPLINE_NULL == eTypeCurve)
{
eTypeCurve = m_typeSplineCurve;
if (E_TYPE_SPLINE.SPLINE_NULL == eTypeCurve)
{
eTypeCurve = DEFLT_TYPE_SPLINECURVE;
}
} // if (E_TYPE_SPLINE.SPLINE_NULL == eTypeCurve)
m_typeSplineCurve = eTypeCurve;
bool bBuildCurve = false;
switch (m_typeSplineCurve)
{
case E_TYPE_SPLINE.SPLINE_ROUNDEDNONUNIFORMSPLINE:
{
RNS __ProcessCurve_rns = new RNS();
foreach (Vector3 v3PntCurve in m_listPath_Spline)
{
__ProcessCurve_rns.AddNode(v3PntCurve);
}
bBuildCurve = __ProcessCurve_rns.BuildSpline_rns();
if (false == bBuildCurve)
{
Debug.Log("FALSE !! __ProcessCurve_rns.BuildSpline_rns()");
return(false);
}
m_ProcessCurve_Activate = __ProcessCurve_rns;
}
break;
case E_TYPE_SPLINE.SPLINE_SMOOTHNONUNIFORMSPLINE:
{
SNS __ProcessCurve_sns = new SNS();
foreach (Vector3 v3PntCurve in m_listPath_Spline)
{
__ProcessCurve_sns.AddNode(v3PntCurve);
}
bBuildCurve = __ProcessCurve_sns.BuildSpline_sns();
if (false == bBuildCurve)
{
Debug.Log("FALSE !! __ProcessCurve_sns.BuildSpline_sns()");
return(false);
}
m_ProcessCurve_Activate = __ProcessCurve_sns;
}
break;
case E_TYPE_SPLINE.SPLINE_TIMEDUNIFORMSPLINE:
{
TNS __ProcessCurve_tns = new TNS();
foreach (Vector3 v3PntCurve in m_listPath_Spline)
{
__ProcessCurve_tns.AddNode(v3PntCurve);
}
bBuildCurve = __ProcessCurve_tns.BuildSpline_tns();
if (false == bBuildCurve)
{
Debug.Log("FALSE !! __ProcessCurve_tns.BuildSpline_tns()");
return(false);
}
m_ProcessCurve_Activate = __ProcessCurve_tns;
}
break;
default:
{
Debug.Log("m_typeSplineCurve is not valid type.");
m_ProcessCurve_Activate = null;
return(false);
}
} // switch(m_typeSplineCurve)
int iCntTime_Division = (int)(m_ProcessCurve_Activate.m_fmaxDistance * fDivisionWeight__ * multiply_adjust_divisionWeight);
m_arrSectionCurve = new Vector3[iCntTime_Division];
//@ First, Last Position are we just knew.
m_arrSectionCurve[0] = m_listPath_Spline[0];
m_arrSectionCurve[iCntTime_Division - 1] = m_listPath_Spline[m_listPath_Spline.Count - 1];
for (int iSeq = 1; iSeq <= iCntTime_Division - 1; ++iSeq)
{
float fT = (float)iSeq / (float)iCntTime_Division;
Vector3 v3PosNew_Curve = new Vector3();
v3PosNew_Curve = m_ProcessCurve_Activate.GetPositionSpline(fT);
m_arrSectionCurve[iSeq] = v3PosNew_Curve;
}
m_bBuildedCurve = true;
return(true);
} // public bool BuildupCurve_spline(E_TYPE_SPLINE eTypeCurve)
public bool SendMessage(string Message, string Category = "", Dictionary <string, object> Params = null)
{
return(SNS.SendMessage(EndpointARN, Message, Category, Params));
}
