//----------------- Servicios de Sincronización de Pago y Reversión -----------------//
#region Servicios de Sincronización de Pago y Reversión
public void sendListNumberToServer(LTL_LotteryList pList, List <LND_ListNumberDetail> pNumberDetail)
{
// Llamar al servicio de sincronización con el servidor
ServerConnectionService service = new ServerConnectionService();
ServiceResponseResult responseResult = service.syncListToServer(pList, pNumberDetail, result => processResponseToSendList(result));
//this.processResponseToSendList(responseResult);
}
public static ServiceResponseResult <Person> CanBeTenant(string email, int propertyId)
{
using (var db = new KeysEntities())
{
Login login = db.Login.FirstOrDefault(x => x.Email == email);
var person = login?.Person;
var isTenant = login == null ? false : db.LoginRole.FirstOrDefault(x => x.PersonId == login.Id && x.RoleId == 5) == null ? false : true;
var isInProp = login == null ? false : db.TenantProperty.Where(x => x.TenantId == login.Id && x.PropertyId == propertyId && (x.IsActive ?? false)).Any();
var isSS = login == null ? false : db.LoginRole.FirstOrDefault(x => x.PersonId == login.Id && x.RoleId == 6) == null ? false : true;
var isOwner = login == null ? false : db.LoginRole.FirstOrDefault(x => x.PersonId == login.Id && x.RoleId == 4) == null ? false : true;
var res = new ServiceResponseResult <Person> {
IsSuccess = true
};
res.Result = person;
if (isTenant)
{
if (isInProp)
{
res.IsSuccess = false;
res.ErrorMessage = "Tenant is already in property!";
return(res);
}
}
else
{
if (isOwner || isSS)
{
res.IsSuccess = false;
res.ErrorMessage = "Account already exsists but not a tenant!";
return(res);
}
}
return(res);
}
}
private static void getResponseCallback(IAsyncResult asyncResult)
{
try
{
// Get request parameters
object[] requestParams = (object[])asyncResult.AsyncState;
HttpWebRequest request = (HttpWebRequest)requestParams[0];
Func <ServiceResponseResult, bool> proccessResponse = (Func <ServiceResponseResult, bool>)requestParams[1];
// End the operation
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(asyncResult);
Stream streamResponse = response.GetResponseStream();
StreamReader streamRead = new StreamReader(streamResponse);
string responseBody = streamRead.ReadToEnd();
ServiceResponseResult responseResult = JsonConvert.DeserializeObject <ServiceResponseResult>(responseBody);
Console.WriteLine(responseResult.ToString());
bool result = proccessResponse(responseResult);
// Close the stream object
streamResponse.Close();
streamRead.Close();
// Release the HttpWebResponse
response.Close();
allDone.Set();
}
catch (Exception e)
{
Console.WriteLine("getResponseCallback");
LogService.log(e.Message, e.StackTrace);
throw;
}
}
// Método que procesa un request con el método especificado
public ServiceResponseResult processAsyncHttpRequest(string pUrlEndPoint, Object pJsonObject,
string pHttpMethod, Func <ServiceResponseResult, bool> processResponseFunction)
{
ServiceResponseResult responseResult = null;
try
{
// Serializar objeto json y convertirlo a bits
string jsonString = JsonConvert.SerializeObject(pJsonObject);
// Configurar parámetros del request
byte[] data = UTF8Encoding.UTF8.GetBytes(jsonString);
HttpWebRequest request = WebRequest.Create(pUrlEndPoint) as HttpWebRequest;
request.Timeout = 600 * 1000;
request.Method = pHttpMethod;
request.ContentLength = data.Length;
request.ContentType = "application/json; charset=utf-8";
// Bagin
request.BeginGetRequestStream(new AsyncCallback(getRequestStreamCallback), new object[] { request, jsonString, processResponseFunction });
allDone.WaitOne();
}
catch (Exception e)
{
// Capturar errores en el log
Console.WriteLine("processAsyncHttpRequest");
LogService.log(e.Message, e.StackTrace);
//throw;
}
return(responseResult);
}
// Método que procesa un request con el método especificado
public async Task <ServiceResponseResult> processHttpRequestAsync(string pUrlEndPoint, Object pJsonObject, string pHttpMethod)
{
ServiceResponseResult responseResult = null;
try
{
// Serializar objeto json y convertirlo a bits
string jsonString = JsonConvert.SerializeObject(pJsonObject);
// Configurar parámetros del request
byte[] data = UTF8Encoding.UTF8.GetBytes(jsonString);
HttpWebRequest request = WebRequest.Create(pUrlEndPoint) as HttpWebRequest;
request.Timeout = 600 * 1000;
request.Method = pHttpMethod;
request.ContentLength = data.Length;
request.ContentType = "application/json; charset=utf-8";
// Escribir parámetros del request en post Stream
Stream postStream = request.GetRequestStream();
postStream.Write(data, 0, data.Length);
// Solicitar respuesta de la petición y procesarla
HttpWebResponse response = await request.GetResponseAsync() as HttpWebResponse;
StreamReader reader = new StreamReader(response.GetResponseStream());
// Generar string body de la respuesta
string responseBody = reader.ReadToEnd();
responseResult = JsonConvert.DeserializeObject <ServiceResponseResult>(responseBody);
}
catch (Exception e)
{
// Capturar errores en el log
LogService.log(e.Message, e.StackTrace);
//throw;
}
return(responseResult);
}
public ActionResult RemoveFromWatchlist(int Id, ItemType Type)
{
var login = AccountService.GetLoginByEmail(User.Identity.Name);
var result = new ServiceResponseResult();
if (Type == ItemType.RentalListing)
{
result = TenantService.RemoveFromWatchlist(Id, login);
}
if (Type == ItemType.MarketJob)
{
result = CompanyService.RemoveFromWatchlist(Id, login);
}
if (result.IsSuccess)
{
return(Json(new
{
Success = true,
Message = "IsDeleted",
Updated = true,
}));
}
else
{
return(Json(new { Success = false, Message = result.ErrorMessage }));
}
}
public bool syncDraw_ServerToLocal()
{
bool successProcess = true;
long posId = ParameterService.getSalePointId();
// Realizar sincronización solamente si la sucursal está asignada
if (posId != 0)
{
// Realizar la petición http
ServerConnectionService connection = new ServerConnectionService();
ServiceResponseResult responseResult = connection.getReopenDrawList(posId);
successProcess = this.isValidResponse(responseResult);
if (successProcess)
{
string jsonStringResult = responseResult.result.ToString();
// Obtener array de los id de sorteos reabiertos para la sucursal
JArray jsonArray = JArray.Parse(jsonStringResult);
// Realizar la persistencia de los sorteos reabiertos
LotteryDrawRepository drawRepo = new LotteryDrawRepository();
foreach (var drawId in jsonArray)
{
LTD_LotteryDraw draw = drawRepo.getById((long)drawId);
if (draw != null)
{
draw.LDS_LotteryDrawStatus = SystemConstants.DRAW_STATUS_REOPENED;
drawRepo.save(ref draw);
// Cambiar todos los registros de QR a pendiente
ListService listService = new ListService();
listService.changeListStatusFromQRUpdated(draw, SystemConstants.SYNC_STATUS_PENDING_TO_SERVER);
}
}
}
}
return(successProcess);
}
public static ServiceResponseResult DeleteRentallApllication(int rentalApplicationId)
{
var result = new ServiceResponseResult {
IsSuccess = false
};
using (var db = new KeysEntities())
{
var deleteRentallApllication = db.RentalApplication.Where(x => x.Id == rentalApplicationId).First();
if (deleteRentallApllication == null)
{
var errorMsg = "Cannot locate the Rental application";
result.ErrorMessage = errorMsg;
return(result);
}
else
{
deleteRentallApllication.IsActive = false;
};
try
{
db.SaveChanges();
return(new ServiceResponseResult {
IsSuccess = true
});
}
catch (Exception ex)
{
return(new ServiceResponseResult {
IsSuccess = false, ErrorMessage = _error
});
}
}
}
//--******************** Método Utilizado para servicios *********************--//
public ServiceResponseResult processHttpRequest(string pUrlEndPoint, Object pJsonObject, string pHttpMethod)
{
// Serializar objeto json y convertirlo a bits
string jsonString = JsonConvert.SerializeObject(pJsonObject);
// Configurar parámetros del request
byte[] data = UTF8Encoding.UTF8.GetBytes(jsonString);
HttpWebRequest request = WebRequest.Create(pUrlEndPoint) as HttpWebRequest;
request.Timeout = 1000 * 1000;
request.Method = pHttpMethod;
request.ContentLength = data.Length;
request.ContentType = "application/json; charset=utf-8";
// Escribir parámetros del request en post Stream
Stream postStream = request.GetRequestStream();
postStream.Write(data, 0, data.Length);
// Solicitar respuesta de la petición y procesarla
HttpWebResponse response = request.GetResponse() as HttpWebResponse;
StreamReader reader = new StreamReader(response.GetResponseStream());
// Generar string body de la respuesta
string responseBody = reader.ReadToEnd();
Console.WriteLine(responseBody);
ServiceResponseResult responseResult = JsonConvert.DeserializeObject <ServiceResponseResult>(responseBody);
return(responseResult);
}
// Método para procesar el resultado del envío de la lista al servidor
public bool processResponseToSendList(ServiceResponseResult pResponseResult)
{
//Console.WriteLine("Ejecutando processResponseToSendList...");
bool processDone = false;
if (ServiceValidator.isValidAndNotEmptyServiceResponse(pResponseResult))
{
// Obtener el JSON resultado de la sincronización
String resultString = pResponseResult.result.ToString();
SyncListResult listSyncResult = JsonConvert.DeserializeObject <SyncListResult>(resultString);
long listId = listSyncResult.listNumber;
//Console.WriteLine(listId);
// Cambiar el estado de la lista local a Sincronizado
this.setListCompleteSync(listId);
if (this.appMediator != null)
{
this.appMediator.updateTotalBoxes();
}
processDone = true;
}
else
{
// Error de sincronización
string responseType = pResponseResult == null ? "N/A" : pResponseResult.type;
LogService.logErrorServiceResponse("No se pudo sincronizar la venta", responseType, "Pendiente");
}
return(processDone);
}
public ActionResult DeleteWatchlist(int Id, ItemType Type)
{
var result = new ServiceResponseResult();
if (Type == ItemType.RentalListing)
{
result = PropertyService.DeleteWatchlistItemById(Id);
}
if (Type == ItemType.MarketJob)
{
result = JobService.DeleteWatchlistItemById(Id);
}
if (result.IsSuccess)
{
return(Json(new
{
Success = true,
Message = "IsDeleted",
Updated = true,
}));
}
else
{
return(Json(new { Success = false, Message = result.ErrorMessage }));
}
}
public static ServiceResponseResult DeleteWatchlistItemById(int watchlistId)
{
var result = new ServiceResponseResult {
IsSuccess = false
};
using (var db = new KeysEntities())
{
var watchlist = db.JobWatchList.FirstOrDefault(x => x.Id == watchlistId);
if (watchlist == null)
{
result.IsSuccess = false;
result.ErrorMessage = "Sorry, watchlist not found!";
return(result);
}
db.JobWatchList.Remove(watchlist);
try
{
db.SaveChanges();
return(new ServiceResponseResult {
IsSuccess = true
});
}
catch (Exception ex)
{
return(result);
}
}
}
public static ServiceResponseResult RemoveFromWatchlist(int marketJobId, Login login)
{
using (var db = new KeysEntities())
{
var result = new ServiceResponseResult {
IsSuccess = false
};
var item = db.JobWatchList.FirstOrDefault(x => x.PersonId == login.Id && x.MarketJobId == marketJobId);
if (item == null)
{
result.ErrorMessage = "Item not found!";
return(result);
}
db.JobWatchList.Remove(item);
try
{
db.SaveChanges();
result.IsSuccess = true;
return(result);
}
catch (Exception ex)
{
result.IsSuccess = false;
result.ErrorMessage = "Please try later!";
return(result);
}
}
}
public async Task <bool> processReverseToServerAsync(LTL_LotteryList pListObject)
{
bool successReversion = false;
Console.WriteLine(" - Anulada ");
ServiceResponseResult response = await this.reverseListNumberFromServerAsync(pListObject);
if (ServiceValidator.isValidServiceResponse(response))
{
// Cambiar el estado de la lista local a Sincronizado
this.setListCompleteSync(pListObject);
successReversion = true;
}
else
{
// Error de sincronización
string responseType = response == null ? "N/A" : response.type;
LogService.logErrorServiceResponse("No se pudo sincronizar la reversión", responseType, "Pendiente");
}
if (response != null && response.message == "No se pudo actualizar. El elemento especificado no existe")
{
successReversion = true;
}
return(successReversion);
}
public bool syncPrizeFactor_ServerToLocal()
{
bool successProcess = true;
// Realizar la petición http
ServerConnectionService connection = new ServerConnectionService();
ServiceResponseResult responseResult = connection.getPrizeFactorFromServer();
successProcess = this.isValidResponse(responseResult);
if (successProcess)
{
string jsonStringResult = responseResult.result.ToString();
JsonObjectParser parser = new JsonObjectParser((int)EntityType.PrizeFactor);
// Reemplazar objetos complejos en el json por su id
JArray jsonArray = JArray.Parse(jsonStringResult);
foreach (var item in jsonArray)
{
parser.changeJsonProp(item, "lotteryPointSale");
parser.changeJsonProp(item, "lotteryDrawType");
parser.changeJsonProp(item, "synchronyStatus");
}
// Parsear el json de respuesta
string parsedJsonString = parser.parse(jsonArray.ToString());
// Realizar la persistencia de los cambios
LotteryPrizeFactorRepository prizeFactorRepo = new LotteryPrizeFactorRepository();
prizeFactorRepo.saveList(JsonConvert.DeserializeObject <List <LPF_LotteryPrizeFactor> >(parsedJsonString));
}
return(successProcess);
}
public async Task <ServiceResponseResult> reverseListNumberFromServerAsync(LTL_LotteryList pList)
{
// Llamar al servicio de sincronización con el servidor
ServerConnectionService serverConection = new ServerConnectionService();
ServiceResponseResult response = await serverConection.reverseListToServerAsync(pList);
return(response);
}
public async Task <ServiceResponseResult> syncWinnerNumbersToServerAsync(LTD_LotteryDraw pDraw, string[] pWinningNumberArray)
{
// Llamar al servicio de sincronización con el servidor
ServerConnectionService service = new ServerConnectionService();
ServiceResponseResult responseResult = await service.syncWinnerNumbersToServerAsync(pDraw, pWinningNumberArray);
this.processResponseToClosingDraw(responseResult);
return(responseResult);
}
public async Task <ServiceResponseResult> closeDrawInServerAsync(DateTime pDrawDate, long pGroupId)
{
// Llamar al servicio de sincronización con el servidor
ServerConnectionService service = new ServerConnectionService();
ServiceResponseResult responseResult = await service.closeDrawInServerAsync(pDrawDate, pGroupId);
this.processResponseToClosingDraw(responseResult);
return(responseResult);
}
/// <summary>Generic parameterised method for create all responses with a type param.</summary>
private static ServiceResponse Response(ServiceResponseResult result, ServiceResponseErrorCode errorCode = ServiceResponseErrorCode.NoError, IList <ServiceResponseError> serviceResponseErrors = null)
{
return(new ServiceResponse
{
Result = result,
ErrorCode = errorCode,
Errors = serviceResponseErrors ?? new List <ServiceResponseError>()
});
}
public async Task <ServiceResponseResult> sendListNumberToServerAsync(LTL_LotteryList pList, List <LND_ListNumberDetail> pNumberDetail)
{
// Llamar al servicio de sincronización con el servidor
ServerConnectionService service = new ServerConnectionService();
ServiceResponseResult responseResult = await service.syncListToServerAsync(pList, pNumberDetail);
this.processResponseToSendList(responseResult);
return(responseResult);
}
public void ServiceResponseResult_IsSuccessful_Passes(ServiceResponseResult serviceResponseResult)
{
var srvRes = new ServiceResponse <string>
{
Result = serviceResponseResult
};
srvRes.IsSuccessful().ShouldBeTrue();
}
public void ServiceResponseExtensions_IsSuccessful_ReturnsError(ServiceResponseResult serviceResponseResult)
{
var serRes = new ServiceResponse <string>
{
Message = "some-error-message",
Result = serviceResponseResult
};
serRes.IsSuccessful().ShouldBeFalse();
}
public void ServiceResponseResult_IsSuccessful_False(string errorMessage, ServiceResponseResult result)
{
var srvRes = new ServiceResponse <string>()
{
Message = errorMessage,
Result = result
};
srvRes.IsSuccessful().ShouldBeFalse();
}
public static ServiceResponseResult EditMarketJob(MarketJobModel model, Login login, HttpFileCollectionBase files = null)
{
var result = new ServiceResponseResult {
IsSuccess = false
};
using (var db = new KeysEntities())
{
var files1 = model.MediaFiles;
var editMarketJob = db.TenantJobRequest.Where(x => x.Id == model.Id).FirstOrDefault();
if (editMarketJob == null)
{
var errorMsg = "Cannot locate the Job in the Market Place";
result.ErrorMessage = errorMsg;
return(result);
}
else
{
editMarketJob.JobDescription = model.JobDescription;
editMarketJob.MaxBudget = model.MaxBudget;
if (model.FilesRemoved != null)
{
model.FilesRemoved.ToList().ForEach(x =>
{
var media = db.TenantJobRequestMedia.FirstOrDefault(y => y.Id == x);
if (media != null)
{
db.TenantJobRequestMedia.Remove(media);
MediaService.RemoveMediaFile(media.NewFileName);
}
});
}
var fileList = MediaService.SaveFiles(files, 5 - editMarketJob.TenantJobRequestMedia.Count(), AllowedFileType.Images).NewObject as List <MediaModel>;
if (fileList != null)
{
fileList.ForEach(x => editMarketJob.TenantJobRequestMedia.Add(new TenantJobRequestMedia {
NewFileName = x.NewFileName, OldFileName = x.OldFileName
}));
}
}
try
{
db.SaveChanges();
return(new ServiceResponseResult {
IsSuccess = true
});
}
catch (Exception)
{
return(new ServiceResponseResult {
IsSuccess = false, ErrorMessage = _error
});
}
}
}
public static ServiceResponseResult EditMarketJobQuote(JobQuoteModel quoteModel, Login login, HttpFileCollectionBase files)
{
var result = new ServiceResponseResult {
IsSuccess = false
};
using (var db = new KeysEntities())
{
var editJobQuote = db.JobQuote.Where(x => x.Id == quoteModel.Id).FirstOrDefault();
editJobQuote.Id = quoteModel.Id;
editJobQuote.Note = quoteModel.Note;
editJobQuote.UpdatedOn = DateTime.Now;
if (quoteModel.FilesRemoved != null)
{
quoteModel.FilesRemoved.ToList().ForEach(x =>
{
var media = db.JobQuoteMedia.FirstOrDefault(y => y.Id == x);
if (media != null)
{
db.JobQuoteMedia.Remove(media);
MediaService.RemoveMediaFile(media.FileName);
}
});
}
var mediaFiles = MediaService.SaveFiles(files, 5 - editJobQuote.JobQuoteMedia.Count, AllowedFileType.AllFiles).NewObject as List <MediaModel>;
if (mediaFiles != null)
{
mediaFiles.ForEach(x => editJobQuote.JobQuoteMedia.Add(new JobQuoteMedia
{
FileName = x.NewFileName,
IsActive = true
}));
}
try {
db.SaveChanges();
return(new ServiceResponseResult {
IsSuccess = true
});
}
catch (Exception ex) {
return(new ServiceResponseResult {
IsSuccess = false, ErrorMessage = _error
});
}
}
}
public static ServiceResponseResult AddRentallApllication(RentalApplicationModel model, Login login, HttpFileCollectionBase files = null)
{
using (var db = new KeysEntities())
{
var result = new ServiceResponseResult {
IsSuccess = false
};
if (!TenantService.IsLoginATenant(login))
{
var errorMsg = "Account not tenant!";
result.ErrorMessage = errorMsg;
return(result);
}
var rentalApp = new RentalApplication
{
RentalListingId = model.RentalListingId,
PersonId = login.Id,
TenantsCount = model.TenantsCount,
ApplicationStatusId = 1,
Note = model.Note,
CreatedBy = login.Email,
CreatedOn = DateTime.UtcNow,
UpdatedBy = login.Email,
UpdatedOn = DateTime.UtcNow,
IsActive = true,
};
var mediaFiles = MediaService.SaveFiles(files, 5, AllowedFileType.AllFiles).NewObject as List <MediaModel>;
mediaFiles.ForEach(x => rentalApp.RentalApplicationMedia.Add(new RentalApplicationMedia
{
NewFileName = x.NewFileName,
OldFileName = x.OldFileName,
}));
try
{
db.RentalApplication.Add(rentalApp);
db.SaveChanges();
return(new ServiceResponseResult {
IsSuccess = true
});
}
catch (Exception ex)
{
return(new ServiceResponseResult {
IsSuccess = false, ErrorMessage = _error
});
}
}
}
public static ServiceResponseResult Login(LoginViewModel model)
{
using (var db = new KeysEntities())
{
var result = new ServiceResponseResult
{
IsSuccess = false
};
if (ValidateUser(model.UserName, model.Password))
{
result.IsSuccess = true;
return(result);
}
else
{
var user = db.Login.Where(n => n.UserName == model.UserName).FirstOrDefault();
if (user != null)
{
if (user.IsActive)
{
if (user.LockoutEnabled == true)
{
TimeSpan time = (TimeSpan)((DateTime)user.LockoutEndDateUtc).Subtract(DateTime.Now); // Use current time.
result.ErrorMessage = "Your Account has Timed-Out try again later in " + time.Seconds + " seconds";
result.IsSuccess = false;
return(result);
}
result.IsSuccess = false;
}
else
{
if (user.EmailConfirmed == false)
{
result.ErrorMessage = "Email not activated, Please activate.";
}
else
{
result.ErrorMessage = "Your account has been removed from the system.";
}
return(result);
}
}
result.ErrorMessage = "Incorrect username / password";
return(result);
}
}
}
public static bool isValidServiceResponse(ServiceResponseResult pResponseResult)
{
bool validResponse = true;
if (pResponseResult == null)
{
validResponse = false;
}
else
{
if (pResponseResult.type != "success")
{
validResponse = false;
}
}
return(validResponse);
}
// Método para procesar el resultado del cierre de un sorteo en el servidor
public bool processResponseToClosingDraw(ServiceResponseResult pResponseResult)
{
bool processDone = false;
if (ServiceValidator.isValidServiceResponse(pResponseResult))
//if (ServiceValidator.isValidAndNotEmptyServiceResponse(pResponseResult))
{
processDone = true;
}
else
{
// Error de sincronización
string responseType = pResponseResult == null ? "N/A" : pResponseResult.type;
LogService.logErrorServiceResponse("No se pudo sincronizar el cierre", responseType, "Pendiente");
}
return(processDone);
}
public void reverseListNumberFromServer(LTL_LotteryList pList)
{
// Llamar al servicio de sincronización con el servidor
ServerConnectionService serverConection = new ServerConnectionService();
ServiceResponseResult response = serverConection.reverseListToServer(pList);
if (ServiceValidator.isValidServiceResponse(response))
{
// Cambiar el estado de la lista local a Sincronizado
this.setListCompleteSync(pList);
}
else
{
// Error de sincronización
string responseType = response == null ? "N/A" : response.type;
LogService.logErrorServiceResponse("No se pudo sincronizar la venta", responseType, "Pendiente");
}
}
