private async Task SavePayment(Payment payment, SqlConnection conn, SqlTransaction tx)
{
DataAccess.StructuredParamValue amounts = null;
if (payment.PersonalAmounts.Count > 0)
{
amounts = new DataAccess.StructuredParamValue(_amountsMetadata, payment.PersonalAmounts.Count);
foreach (PersonalAmount pa in payment.PersonalAmounts)
{
amounts.NewRecord();
amounts.AddInt32(pa.EmployeeId);
amounts.AddDecimal(pa.Amount);
}
}
using (SqlCommand cmd = _sqlServer.GetSpCommand("payment.SavePayment", conn, tx))
{
cmd.AddIntParam("@PlaceId", payment.PlaceId);
cmd.AddIntParam("@EmployeeId", payment.EmployeeId);
cmd.AddIntParam("@ShareSchemeHistoryId", payment.ShareSchemeHistoryId);
cmd.AddTinyIntParam("@Status", (byte)payment.Status);
cmd.AddTinyIntParam("@ReasonToReturn", (byte?)payment.ReasonToReturn);
cmd.AddCharParam("@DataSource", 6, payment.DataSource);
cmd.AddCharParam("@Provider", 6, payment.Provider);
cmd.AddDecimalParam("@OriginalAmount", 18, 2, payment.OriginalAmount);
cmd.AddDecimalParam("@ReceivedAmount", 18, 2, payment.ReceivedAmount);
cmd.AddDecimalParam("@BankCommissionAmount", 18, 2, payment.BankCommissionAmount);
cmd.AddDecimalParam("@AgentCommissionAmount", 18, 2, payment.AgentCommissionAmount);
cmd.AddDecimalParam("@IncomeAmount", 18, 2, payment.IncomeAmount);
cmd.AddDecimalParam("@PayoutAmount", 18, 2, payment.PayoutAmount);
cmd.AddDateTime2Param("@PaymentDateTime", payment.PaymentDateTime);
cmd.AddBitParam("@IsTimeSpecified", payment.IsTimeSpecified);
cmd.AddDateTime2Param("@ArrivalDateTime", payment.ArrivalDateTime);
cmd.AddVarCharParam("@DocumentName", 100, (payment.DocumentId.HasValue ? null : payment.DocumentName));
SqlParameter documentIdParam = cmd.AddIntParam("@DocumentId", payment.DocumentId).InputOutput();
cmd.AddVarCharParam("@DocumentNumber", 40, (payment.DocumentId.HasValue ? null : payment.DocumentNumber));
cmd.AddDateParam("@DocumentDate", (payment.DocumentId.HasValue ? null : payment.DocumentDate));
cmd.AddVarCharParam("@ExternalId", 50, payment.ExternalId);
cmd.AddNVarCharParam("@Fio", 100, payment.Fio);
cmd.AddNVarCharParam("@Address", 150, payment.Address);
cmd.AddNVarCharParam("@Purpose", 150, payment.Purpose);
cmd.AddNVarCharMaxParam("@RawData", payment.RawData);
cmd.AddStructuredParam("@Amounts", "payment.PaymentShare", amounts);
SqlParameter PaymentIdParam = cmd.AddBigIntParam("@PaymentId").Output();
SqlParameter StatusParam = cmd.AddTinyIntParam("@FinalStatus").Output();
await cmd.ExecuteNonQueryAsync();
payment.Id = PaymentIdParam.GetInt64();
payment.Status = (PaymentStatus)StatusParam.GetByte();
if (!payment.DocumentId.HasValue)
{
payment.DocumentId = documentIdParam.GetInt32OrNull();
}
}
}
public async Task <IActionResult> Handle(HttpRequest request, EnterSsRequest data)
{
AuthByKeyResult authResult = this.GetAuthenticationKey(request);
if (!authResult.Result)
{
return(new JsonErrorResult(authResult.ErrorResponse));
}
ErrorResponse validationError = this.ValidateRequest(data);
if (validationError != null)
{
return(new JsonErrorResult(validationError));
}
byte[] securedKey = Guid.NewGuid().ToByteArray();
try
{
using (SqlConnection conn = sqlServer.GetConnection())
{
await conn.OpenAsync();
using (SqlCommand cmd = sqlServer.GetSpCommand("dbo.Employee_EnterSecuredSession", conn))
{
cmd.AddBinaryParam("@PermanentKey", 16, authResult.Key.ToArray());
cmd.AddBinaryParam("@SecuredKey", 16, securedKey);
cmd.AddCharParam("@Phone", 10, data.Phone);
cmd.AddCharParam("@PinCode", 4, data.PinCode);
SqlParameter retValParam = cmd.AddReturnValue();
await cmd.ExecuteNonQueryAsync();
int retVal = retValParam.GetInt32OrDefault();
if (retVal < 0)
{
ErrorResponse errorResponse = this.GetErrorResponse(retVal);
return(new JsonErrorResult(errorResponse));
}
EnterSsResponse response = new EnterSsResponse();
response.SecuredKey = AuthKey.Create(securedKey).ToString() + authResult.Key.ToString();
return(new JsonResult(response));
}
}
}
catch (Exception ex)
{
return(new JsonErrorResult(this.GetExceptionResponse(ex)));
}
}
public async Task <IActionResult> Handle(RegisterRequest data)
{
ErrorResponse validationError = this.ValidateRequest(data);
if (validationError != null)
{
return(new JsonErrorResult(validationError));
}
try
{
byte[] permanentKey = Guid.NewGuid().ToByteArray();
using (SqlConnection conn = sqlServer.GetConnection())
{
await conn.OpenAsync();
using (SqlCommand cmd = sqlServer.GetSpCommand("Employee_Register", conn))
{
cmd.AddNVarCharParam("@FirstName", 50, data.FirstName);
cmd.AddNVarCharParam("@LastName", 50, data.LastName);
cmd.AddCharParam("@Phone", 10, data.Phone);
cmd.AddCharParam("@PinCode", 4, data.PinCode);
cmd.AddUniqueIdentifierParam("@LinkParameter", data.LinkParameter);
cmd.AddIntParam("@PlaceId", data.PlaceToJoinId);
cmd.AddBinaryParam("@PermanentKey", 16, permanentKey);
SqlParameter retValParam = cmd.AddReturnValue();
await cmd.ExecuteNonQueryAsync();
int retVal = retValParam.GetInt32OrDefault();
if (retVal < 0)
{
ErrorResponse errorResponse = this.GetErrorResponse(retVal);
return(new JsonErrorResult(errorResponse));
}
}
}
RegisterResponse response = new RegisterResponse();
response.PermanentKey = AuthKey.Create(permanentKey).ToString();
return(new JsonResult(response));
}
catch (Exception ex)
{
return(new JsonErrorResult(this.GetExceptionResponse(ex)));
}
}
private async Task WriteMessageLog(MessageLog log)
{
try
{
using (SqlConnection conn = this._sqlServer.GetConnection())
{
await conn.OpenAsync();
using (SqlCommand cmd = this._sqlServer.GetSpCommand("telegram.WriteMessageLog", conn))
{
cmd.AddBitParam("@InputMessage", log.InputMessage);
cmd.AddBigIntParam("@TelegramId", log.TelegramId);
cmd.AddCharParam("@Phone", 10, log.Phone);
cmd.AddIntParam("@EmployeeId", log.EmployeeId);
cmd.AddNVarCharMaxParam("@MessageData", log.GetJson());
await cmd.ExecuteNonQueryAsync();
}
}
}
catch (Exception ex)
{
string exStr = ex.ToString();
_logger.LogError(exStr, "Ошибка при сохранениии записи в журнале сообщений");
Helper.SaveDiagMessage(_sqlServer, DiagOptions.Tech, "TelegramHostedService.WriteMessageLog, Ошибка при сохранениии записи в журнале сообщений: " + exStr, _logger);
}
}
public async Task <IActionResult> Handle(LoginRequest data)
{
ErrorResponse validationError = this.ValidateRequest(data);
if (validationError != null)
{
return(new JsonErrorResult(validationError));
}
try
{
using (SqlConnection conn = sqlServer.GetConnection())
{
await conn.OpenAsync();
using (SqlCommand cmd = sqlServer.GetSpCommand("Employee_Login", conn))
{
cmd.AddCharParam("@Phone", 10, data.Phone);
cmd.AddCharParam("@PinCode", 4, data.PinCode);
SqlParameter PermanentKeyParam = cmd.AddBinaryParam("@PermanentKey", 16).Output();
SqlParameter retValParam = cmd.AddReturnValue();
await cmd.ExecuteNonQueryAsync();
int retVal = retValParam.GetInt32OrDefault();
if (retVal < 0)
{
ErrorResponse errorResponse = this.GetErrorResponse(retVal);
return(new JsonErrorResult(errorResponse));
}
LoginResponse response = new LoginResponse();
response.PermanentKey = PermanentKeyParam.Value.ToString();
return(new JsonResult(response));
}
}
}
catch (Exception ex)
{
return(new JsonErrorResult(this.GetExceptionResponse(ex)));
}
}
public async Task <AuthEmployeeByKeyResult> AuthenticateByKey(IHeaderDictionary headers)
{
if (!headers.TryGetValue(KEY_HEADER, out StringValues values) || values.Count == 0)
{
return(new AuthEmployeeByKeyResult
{
Result = false,
ErrorResponse = new ErrorResponse("auth_header_not_set")
});
}
string value = values[0];
if (string.IsNullOrEmpty(value))
{
return(new AuthEmployeeByKeyResult
{
ErrorResponse = new ErrorResponse("auth_header_not_set")
});
}
//byte[] key = ByteArrayToHex.FromHex(value);
if (value.Length != 10)
{
return(new AuthEmployeeByKeyResult
{
ErrorResponse = new ErrorResponse("auth_header_is_incorrect")
});
}
using (SqlConnection conn = this._sql.GetConnection())
{
await conn.OpenAsync();
using (SqlCommand cmd = this._sql.GetCommand("SELECT EmployeeId FROM dbo.EmployeeAuth WHERE PermanentKey = @PermanentKey", conn))
{
cmd.AddCharParam("@PermanentKey", 10, value);
object result = await cmd.ExecuteScalarAsync();
if (result == null)
{
return(new AuthEmployeeByKeyResult
{
ErrorResponse = new ErrorResponse("auth_key_not_found")
});
}
return(new AuthEmployeeByKeyResult
{
Result = true,
EmployeeId = Convert.ToInt32(result)
});
}
}
}
private async Task <bool> CheckForExistingPayment(Payment payment, SqlConnection conn, SqlTransaction tx)
{
using (SqlCommand cmd = _sqlServer.GetSpCommand("payment.CheckForExistingPayment", conn, tx))
{
cmd.AddCharParam("@DataSource", 6, payment.DataSource);
cmd.AddVarCharParam("@DocumentName", 100, payment.DocumentName);
cmd.AddVarCharParam("@ExternalId", 50, payment.ExternalId);
SqlParameter retValParam = cmd.AddReturnValue();
await cmd.ExecuteNonQueryAsync();
int retVal = retValParam.GetInt32OrDefault();
return(retVal == 0);
}
}
public static void AddCharParam(this SqlCommand cmd, string parameterName, char?value)
{
if (value != null)
{
cmd.AddCharParam(parameterName, value.Value);
}
else
{
cmd.Parameters.Add(new SqlParameter
{
ParameterName = parameterName,
Direction = ParameterDirection.Input,
SqlDbType = SqlDbType.Char,
Value = DBNull.Value
});
}
}
public async Task <IActionResult> Handle(SendVcodeRequest data)
{
ErrorResponse validationError = this.ValidateRequest(data);
if (validationError != null)
{
return(new JsonErrorResult(validationError));
}
try
{
Guid verificationId = Guid.NewGuid();
string code = "111111";
using (SqlConnection conn = sqlServer.GetConnection())
{
await conn.OpenAsync();
using (SqlCommand cmd = sqlServer.GetSpCommand("dbo.Employee_RegisterVerificationCode", conn))
{
cmd.AddUniqueIdentifierParam("@VerificationId", verificationId);
cmd.AddCharParam("@Code", 6, code);
SqlParameter retValParam = cmd.AddReturnValue();
await cmd.ExecuteNonQueryAsync();
int retVal = retValParam.GetInt32OrDefault();
if (retVal < 0)
{
ErrorResponse errorResponse = this.GetErrorResponse(retVal);
return(new JsonErrorResult(errorResponse));
}
}
}
// SEND SMS
SendVcodeResponse response = new SendVcodeResponse();
response.VerificationId = verificationId;
return(new JsonResult(response));
}
catch (Exception ex)
{
return(new JsonErrorResult(this.GetExceptionResponse(ex)));
}
}
public async Task <IActionResult> Handle(CheckVcodeRequest data)
{
ErrorResponse validationError = this.ValidateRequest(data);
if (validationError != null)
{
return(new JsonErrorResult(validationError));
}
try
{
using (SqlConnection conn = sqlServer.GetConnection())
{
await conn.OpenAsync();
using (SqlCommand cmd = sqlServer.GetSpCommand("dbo.Employee_CheckVerificationCode", conn))
{
cmd.AddUniqueIdentifierParam("@VerificationId", data.VerificationId);
cmd.AddCharParam("@Code", 6, data.Code);
SqlParameter retValParam = cmd.AddReturnValue();
await cmd.ExecuteNonQueryAsync();
int retVal = retValParam.GetInt32OrDefault();
if (retVal < 0)
{
ErrorResponse errorResponse = this.GetErrorResponse(retVal);
return(new JsonErrorResult(errorResponse));
}
}
}
return(new EmptyResult());
}
catch (Exception ex)
{
return(new JsonErrorResult(this.GetExceptionResponse(ex)));
}
}
public async Task <Employee> SetPhoneAndGetEmployee(long telegramUserId, string phone)
{
if (string.IsNullOrEmpty(phone) || (phone.Length == 12 && !phone.StartsWith("+7")) || (phone.Length == 11 && !phone.StartsWith("7")) || phone.Length < 11 || phone.Length > 12)
{
return(null);
}
if (phone.Length == 12)
{
phone = phone.Substring(2, 10);
}
else
{
phone = phone.Substring(1, 10);
}
using (SqlConnection conn = _sqlServer.GetConnection())
{
await conn.OpenAsync();
using (SqlCommand cmd = _sqlServer.GetSpCommand("telegram.CreateAndGetUserRecord", conn))
{
cmd.AddBigIntParam("@UserId", telegramUserId);
cmd.AddCharParam("@Phone", 10, phone);
using (SqlDataReader dr = await cmd.ExecuteReaderAsync())
{
if (dr.Read())
{
return(AcquireEmployee(telegramUserId, dr));
}
return(null);
}
}
}
}
