public ResultResponse<CustomerSummary> Get(CustomerSummarySearchRequest request)
{
var response = new ResultResponse<CustomerSummary>();
try
{
using (var rwplDb = new RWPLLinqDataContext())
{
var queryable = rwplDb.GetTable<CustomerSummary>()
.Where(x => x.CompanyName.Contains(request.CustomerName))
.OrderBy(x => x.CompanyName);
var skipRecord = ((request.PageNo > 0) ? (request.PageNo - 1) * request.PageSize : 0);
response.PageData = queryable.Skip(skipRecord).Take(request.PageSize).ToList();
response.TotalItem = queryable.Count();
if (response.TotalItem > 0)
{
var totalCustomer = queryable.Count();
response.ReportSummary = string.Format("Total Customer : {0}", totalCustomer);
}
response.IsSuccess = true;
}
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Exception = ex;
}
return response;
}
public ResultResponse<DispatchAnalysi> Get(DispatchAnalysiSearchRequest request)
{
var response = new ResultResponse<DispatchAnalysi>();
try
{
using (var rwplDb = new RWPLLinqDataContext())
{
var skipRecord = ((request.PageNo > 0) ? (request.PageNo - 1) * request.PageSize : 0);
var queryable = rwplDb.GetTable<DispatchAnalysi>()
.Where(x => x.Client.Contains(request.Client)
&& x.ItemCode.Contains(request.ItemCode)
&& x.ItemName.Contains(request.ItemName)
//&& (!request.IsSearchByDate ||
// (dispatch.Date >= request.FromDate.Date && dispatch.Date <= request.ToDate.Date))
)
.OrderBy(x => (x.Year*100) + x.Month);
response.PageData = queryable.Skip(skipRecord)
.Take(request.PageSize)
.ToList();
response.TotalItem = queryable.Count();
if (response.TotalItem > 0)
{
var totalClient = queryable.Select(x => x.Client).Distinct().Count();
var totalQtyDispatch = queryable.Select(x => x.TotalDispatchQty).Sum();
response.ReportSummary =
string.Format("Total Client : {0}, Total dispatch Qty : {1}", totalClient, totalQtyDispatch);
}
response.IsSuccess = true;
}
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Exception = ex;
}
return response;
}
public ActionResult FetchPatronDataUsingLcnOrPnr(int orderItemNodeId, string lcn, string pnr, bool cache = true)
{
var json = new ResultResponse();
try
{
var content = _orderItemManager.GetOrderItem(orderItemNodeId);
var eventId = _orderItemManager.GenerateEventId(EVENT_TYPE);
SierraModel sm = null;
if (cache)
{
sm = _patronDataProviderSierraCache.GetPatronInfoFromLibraryCardNumberOrPersonnummer(lcn, pnr);
}
else
{
sm = _patronDataProviderSierra.GetPatronInfoFromLibraryCardNumberOrPersonnummer(lcn, pnr);
}
if (!String.IsNullOrEmpty(sm.id))
{
_orderItemManager.SetPatronData(content.NodeId, JsonConvert.SerializeObject(sm), sm.record_id, sm.ptype, sm.home_library, sm.aff);
_orderItemManager.SaveWithoutEventsAndWithSynchronousReindexing(content.NodeId, false, false);
}
_orderItemManager.AddSierraDataToLog(orderItemNodeId, sm, eventId);
json.Success = true;
json.Message = "Succcessfully loaded Sierra data from \"personnummer\" or library card number.";
}
catch (Exception e)
{
json.Success = false;
json.Message = "Failed to load Sierra data from \"personnummer\" or library card number: " + e.Message;
}
return(Json(json, JsonRequestBehavior.AllowGet));
}
public ResultResponse<ApplicationDataRequest> Get()
{
var response = new ResultResponse<ApplicationDataRequest>();
try
{
using (var rwplDb = new RWPLLinqDataContext())
{
var queryableItems = rwplDb.GetTable<ItemMaster>()
.Where(x => !x.IsDeleted)
.OrderBy(x => x.ItemName);
var queryableCustomers = rwplDb.GetTable<CustomerMaster>()
.Where(x => !x.IsDeleted)
.OrderBy(x => x.CustomerName);
var queryableReelNo = rwplDb.GetTable<InwardMaster>()
.Where(x => !x.IsDeleted)
.OrderBy(x => x.ReelNo);
response.Object = new ApplicationDataRequest()
{
Items = queryableItems.ToList(),
Customers = queryableCustomers.ToList(),
Stocks = queryableReelNo.ToList()
};
response.IsSuccess = true;
}
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Exception = ex;
}
return response;
}
public ActionResult SetArticleAvailableForPickupAtBranch(int nodeId)
{
var res = new ResultResponse();
try
{
var orderItem = _orderItemManager.GetOrderItem(nodeId);
ArticleDelivered pack = new ArticleDelivered();
pack.mail = new OutgoingMailModel(orderItem.OrderId, orderItem.PatronName, orderItem.PatronEmail);
pack.nodeId = nodeId;
var eventId = _orderItemManager.GenerateEventId(EVENT_TYPE);
_orderItemManager.AddLogItem(pack.nodeId, "LEVERERAD", "Leveranstyp: Avhämtas i lånedisken.", eventId, false, false);
_orderItemManager.SetStatus(pack.nodeId, "05:Levererad", eventId, false, false);
// We save everything here first so that we get the new values injected into the message by the template service.
_orderItemManager.SetPatronEmail(pack.nodeId, pack.mail.recipientEmail, eventId);
// Overwrite the message with message from template service so that we get the new values injected.
pack.mail.message = _templateService.GetTemplateData("ArticleAvailableInInfodiskMailTemplate", _orderItemManager.GetOrderItem(pack.nodeId));
_mailService.SendMail(pack.mail);
_orderItemManager.AddLogItem(pack.nodeId, "MAIL_NOTE", "Skickat mail till " + pack.mail.recipientEmail, eventId, false, false);
_orderItemManager.AddLogItem(pack.nodeId, "MAIL", pack.mail.message, eventId);
res.Success = true;
res.Message = "Lyckades leverera.";
}
catch (Exception e)
{
res.Success = false;
res.Message = "Fel vid leveransförsök: " + e.Message;
}
return(Json(res, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Fills the common properties of the RowSet
/// </summary>
private RowSet FillRowSet(RowSet rs, ResultResponse response)
{
if (response != null)
{
if (response.Output.TraceId != null)
{
rs.Info.SetQueryTrace(new QueryTrace(response.Output.TraceId.Value, _session));
}
if (response.Warnings != null)
{
rs.Info.Warnings = response.Warnings;
//Log the warnings
for (var i = 0; i < response.Warnings.Length; i++)
{
var query = "BATCH";
if (_request is QueryRequest queryRequest)
{
query = queryRequest.Query;
}
else if (_parent.Statement is BoundStatement statement)
{
query = statement.PreparedStatement.Cql;
}
RequestExecution.Logger.Warning(
"Received warning ({0} of {1}): \"{2}\" for \"{3}\"", i + 1, response.Warnings.Length, response.Warnings[i], query);
}
}
rs.Info.IncomingPayload = response.CustomPayload;
}
rs.Info.SetTriedHosts(_triedHosts.Keys.ToList());
if (_request is ICqlRequest request)
{
rs.Info.SetAchievedConsistency(request.Consistency);
}
SetAutoPage(rs, _session);
return(rs);
}
public async Task <ResultResponse <string[]> > GetUserAccess(int userId)
{
try
{
var user = await _userRepository.GetAsync(userId);
if (user == null)
{
return(ResultResponse <string[]> .GetBadResponse(StatusCode.NotFound, "Пользователь с таким id не найден"));
}
var rolesIds = (await _userToRolesRepository.GetAsync($"WHERE user_id={userId}")).Select(x => x.role_id);
var roleNames = Array.Empty <string>();
if (rolesIds.Any())
{
roleNames = (await _rolesRepository.GetAsync($"WHERE id IN ({string.Join(",", rolesIds)})")).Select(x => x.name).ToArray();
}
return(ResultResponse <string[]> .GetSuccessResponse(roleNames));
}
catch (Exception ex)
{
_progressLogger.Error(ex, userId, GetType().Name, nameof(ChangePasswordAsync));
return(ResultResponse <string[]> .GetInternalServerErrorResponse());
}
}
public ActionResult Edit(SouvenirStockViewModel model, List <SouvenirItemViewModel> item)
{
if (ModelState.IsValid)
{
model.Update_By = User.Identity.Name;
SouvenirStockRepo.DeleteItem(model.Id);
ResultResponse result = SouvenirStockRepo.Update(model, item);
return(Json(new
{
success = result.Success,
entity = model,
message = result.Message
}, JsonRequestBehavior.AllowGet));
}
else
{
ResultResponse result = SouvenirStockRepo.Update(model, item);
return(Json(new
{
success = false,
message = "Wew"
}, JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// Unlocks OrderItem if locked by current MemberId
/// </summary>
/// <param name="nodeId"></param>
/// <returns></returns>
public ActionResult UnlockOrderItem(int nodeId)
{
// Response JSON
var json = new ResultResponse();
try
{
// Get current member.
int memberId = _memberInfoManager.GetCurrentMemberId(Request, Response);
var orderItem = _orderItemManager.GetOrderItem(nodeId);
if (orderItem.EditedBy == memberId.ToString())
{
_orderItemManager.SetEditedByData(nodeId, "", "");
json.Success = true;
json.Message = "OrderItem unlocked by Current Member.";
}
else if (orderItem.EditedBy == "")
{
json.Success = true;
json.Message = "OrderItem unlocked by current member.";
}
// Notify SignalR clients of the update
_notifier.UpdateOrderItemUpdate(nodeId, memberId.ToString(), new Member(memberId).Text);
}
catch (Exception e)
{
// Return JSON to client
json.Success = false;
json.Message = "Error unlocking OrderItem: " + e.Message;
}
return(Json(json, JsonRequestBehavior.AllowGet));
}
public ActionResult ImportFromData(int orderItemNodeId, string filename, string data)
{
// Json response
var json = new ResultResponse();
try
{
if (String.IsNullOrEmpty(filename))
{
throw new Exception("Not a valid document.");
}
else
{
var orderItem = _orderItemManager.GetOrderItem(orderItemNodeId);
var dataArray = Regex.Split(data, "base64[;,]");
var pattern = new Regex("^data:(.*)[,;]$");
var contentType = pattern.Match(dataArray[0]).Groups[1].Value;
var savedMediaItem = _mediaItemManager.CreateMediaItem(filename, orderItem.NodeId, orderItem.OrderId, new MemoryStream(Convert.FromBase64String(dataArray[1])), contentType);
var eventId = _orderItemManager.GenerateEventId(EVENT_TYPE);
_orderItemManager.AddExistingMediaItemAsAnAttachment(orderItem.NodeId, savedMediaItem.Id, filename, savedMediaItem.Url, eventId);
json.Success = true;
json.Message = savedMediaItem.Id.ToString() + ";" + savedMediaItem.Url;
}
}
catch (Exception e)
{
json.Success = false;
json.Message = "Failed to import document from data: " + e.Message;
}
return(Json(json, JsonRequestBehavior.AllowGet));
}
public ActionResult Save(string id, string chillinText)
{
var json = new ResultResponse();
var chillin = _jsonService.DeserializeObject <ChillinText>(chillinText);
try
{
_chillinTextRepository.Put(id, new ChillinText
{
CheckInNote = chillin.CheckInNote,
CheckOutNote = chillin.CheckOutNote,
StandardTitleText = chillin.StandardTitleText
});
json.Success = true;
json.Message = "Sparade ny text.";
}
catch (Exception e)
{
json.Success = false;
json.Message = "Error: " + e.Message;
}
return(Json(json, JsonRequestBehavior.AllowGet));
}
private void PrintTeamMembers(object result, ResultResponse resultResponse)
{
Console.WriteLine("");
string testName = (new StackTrace()).GetFrame(1).GetMethod().Name;
testName = testName != null ? testName : "";
if (result != null)
{
Console.WriteLine(testName + " executed successfully");
if (result.GetType() == typeof(TeamResponse))
{
var member = (TeamResponse)result;
Console.WriteLine("Member: {0}", member.MemberFirstName + " " + member.MemberLastName);
}
else if (result.GetType() == typeof(TeamResponse[]))
{
var members = (TeamResponse[])result;
foreach (var member in members)
{
Console.WriteLine("Member: {0}", member.MemberFirstName + " " + member.MemberLastName);
}
}
else
{
Console.WriteLine(testName + ": unknown response type");
}
}
else
{
PrintFailResponse(resultResponse, testName);
}
}
public ResultResponse AddOrDeleteDefect(int DefectKey, string DefectName, int CategoryId, int UserID)
{
try
{
accessManager.SqlConnectionOpen(DataBase.QMSDatabase);
ResultResponse result = new ResultResponse();
List <SqlParameter> aParameters = new List <SqlParameter>();
aParameters.Add(new SqlParameter("@DefectKey", DefectKey));
aParameters.Add(new SqlParameter("@DefectName", DefectName));
aParameters.Add(new SqlParameter("@UserId", UserID));
aParameters.Add(new SqlParameter("@CategoryId", CategoryId));
result.isSuccess = accessManager.SaveData("sp_AddOrDeleteDefect", aParameters);
result.msg = "Successful";
return(result);
}
catch (Exception e)
{
throw e;
}
finally
{
accessManager.SqlConnectionClose();
}
}
public ActionResult Edit(PromotionViewModel model, List <PromotionItemViewModel> itemModel, List <PromotionItemFileViewModel> fileModel)
{
model.Update_By = User.Identity.Name;
if (model.Flag_Design == "1")
{
ResultResponse result = PromotionRepo.Update(model, itemModel, fileModel);
return(Json(new
{
success = result.Success,
entity = model,
message = result.Message
}, JsonRequestBehavior.AllowGet));
}
else
{
ResultResponse result2 = PromotionRepo.UpdateCreate3(model, fileModel, model.Id);
return(Json(new
{
success = result2.Success,
entity = model,
message = result2.Message
}, JsonRequestBehavior.AllowGet));
}
}
public ResultResponse CopySilhoutteToStyle(int StyleId, int SilhoutteId, int UserId)
{
try
{
int masterId = 0;
accessManager.SqlConnectionOpen(DataBase.QMSDatabase);
ResultResponse result = new ResultResponse();
List <SqlParameter> aParameters = new List <SqlParameter>();
aParameters.Add(new SqlParameter("@StyleId", StyleId));
aParameters.Add(new SqlParameter("@MasteSilhoutteId", SilhoutteId));
aParameters.Add(new SqlParameter("@UserId", UserId));
masterId = accessManager.SaveDataReturnPrimaryKey("sp_CopyExistingStyle", aParameters);
if (masterId == 0)
{
result.isSuccess = false;
result.msg = "Already A Silhoutte Resigtered In This Style";
}
else
{
result.pk = masterId;
result.isSuccess = true;
result.msg = "Style Copied Succssfully";
}
return(result);
}
catch (Exception e)
{
throw e;
}
finally
{
accessManager.SqlConnectionClose();
}
}
//确认放款成功
public static async Task <bool> ConfirmAdvanceDebt(string url, ConfirmAdvanceDebtRequest request, string logFolderName)
{
HttpResponseMessage httpResponseMesage = new HttpResponseMessage();
try
{
//DebtForBank/SendAdvanceDebt
httpResponseMesage = await InitialHttpClient().PostAsJsonAsync($"{url}MessageFromBank/ConfirmAdvanceDebt", request);
ResultResponse <string> response = await httpResponseMesage.Content.ReadAsAsync <ResultResponse <string> >();
if (response.IsTrue)
{
return(true);
}
return(false);
}
catch (Exception ex)
{
//log记录日志
Logger.LoadData(Path.Combine(logFolderName, "Error.txt"), ex.Message + "---------" + await httpResponseMesage.Content.ReadAsStringAsync() + "----" + request.ToJson());
return(false);
}
}
public IResultResponse BatchImportProduct(int connectorId, int upConnectorId, string productIds)
{
if (string.IsNullOrWhiteSpace(productIds))
{
return(ResultResponse.ExceptionResult("请选择上货商品"));
}
string[] arrIds = productIds.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
try
{
foreach (string id in arrIds)
{
int productId = Utils.ToInt(id);
if (productId > 0)
{
ImportProduct(connectorId, upConnectorId, productId);
}
}
return(ResultResponse.GetSuccessResult("导入商品完毕"));
}
catch (Exception ex)
{
return(ResultResponse.ExceptionResult("导入商品失败:" + ex.Message));
}
}
public static IResultResponse VerifyAccessToken(SysParameter para)
{
string token = para.ToValue("AccessToken");
//解析Token
AccessToken tokenEnt = AccessToken.ParseToken(token);
if (tokenEnt == null || tokenEnt.SellerId <= 0 || tokenEnt.DBId <= 0
)
{
return(ResultResponse.ExceptionResult("Token无效", "", 4004));
}
// 判断token有效期
if (Utils.ToUnixTime(DateTime.Now) > tokenEnt.Expired)
{
return(ResultResponse.ExceptionResult("Token已过期", "", 4004));
}
return(ResultResponse.GetSuccessResult(tokenEnt));
}
public override Task <ResultResponse> UpdateDataRecord(UpdateDataRequest request, ServerCallContext context)
{
ResultResponse response = new ResultResponse()
{
Result = new ResultModel()
};
switch (request.UpdateType.Type)
{
case UpdateTypeEnum.Add:
response.Result.ErrorMessage = AddNewRecord(request.Project);
break;
case UpdateTypeEnum.Edit:
response.Result.ErrorMessage = EditRecord(request.Project);
break;
case UpdateTypeEnum.Delete:
response.Result.ErrorMessage = DeleteRecord(request.Project);
break;
}
return(Task.FromResult <ResultResponse>(response));
}
//
// Folders
#region Folders
public async Task <Folder> CreateFolder(string folderName, string workspaceId = null)
{
if (string.IsNullOrWhiteSpace(folderName))
{
throw new Exception("Folder Name cannot be null or blank");
}
var folder = new Folder(folderName);
var response = new ResultResponse <Folder>();
if (workspaceId == null)
{
response = await this.ExecuteRequest <ResultResponse <Folder>, Folder>(HttpVerb.POST, string.Format("home/folders"), folder);
}
else if (workspaceId != null) // Folders
{
response = await this.ExecuteRequest <ResultResponse <Folder>, Folder>(HttpVerb.POST, string.Format("workspaces/{0}/sheets", workspaceId), folder);
}
response.Result._Client = this;
return(response.Result);
}
public static ResultResponse Delete(int id)
{
ResultResponse result = new ResultResponse();
try
{
using (var db = new MarComContext())
{
M_Menu menu = db.M_Menu.Where(m => m.Id == id).FirstOrDefault();
if (menu != null)
{
menu.Is_Delete = true;
db.SaveChanges();
result.Message = "Data Deleted ! Data menu with code " + menu.Code + " has been deleted";
}
}
}
catch (Exception)
{
result.Success = false;
result.Message = "Delete data not success";
}
return(result);
}
/// <summary>
/// Searches TMDB media by ID as per media Type.
/// </summary>
/// <returns>Returns Search result with its Media Type</returns>
public ResultResponse SearchByIdAsync(int id, string mediaType)
{
object r = null;
if (mediaType == MediaTypes.Movie)
{
r = _serviceClient.GetMovieAsync(id).Result;
}
else if (mediaType == MediaTypes.Collection)
{
r = _serviceClient.GetCollectionAsync(id).Result;
}
else if (mediaType == MediaTypes.Tv)
{
r = _serviceClient.GetTvShowAsync(id).Result;
}
var response = new ResultResponse
{
Result = r,
MediaType = mediaType
};
return(response);
}
private void optimizeIndexes(ResultResponse res)
{
try
{
foreach (var orderItemsIndexer in ExamineManager.Instance.IndexProviderCollection)
{
UmbracoContentIndexer umbracoOrderItemsIndexer = null;
if (orderItemsIndexer is UmbracoContentIndexer)
{
umbracoOrderItemsIndexer = (UmbracoContentIndexer)orderItemsIndexer;
umbracoOrderItemsIndexer.OptimizeIndex();
}
res.Success &= true;
}
}
catch (Exception e)
{
LogHelper.Error <SystemSurfaceController>("Failed to optimize indexes.", e);
res.Success = false;
res.Message += "Failed to optimize indexes. ";
}
}
public IResultResponse GetValidateCode(int connectorId, string codeToken, string verifyCode)
{
ConnectorEntity connector = (ConnectorEntity) new ConnectorBusiness(_dapperFactory).GetEntity("Id=" + connectorId);
if (connector == null || connector.Id == null || connector.Id < 1)
{
return(ResultResponse.ExceptionResult("您尚未成为连接器合作商"));
}
GroupEntity group = (GroupEntity) new GroupBusiness(_dapperFactory).GetEntity("Id=" + connector.GroupId);
string mobile = DES.Encode(string.Format("{0}|{1}|{2}|{3}|{4}|{5}", connector.Mobile, connector.Mobile, connector.Mobile, connector.Mobile, connector.Mobile, connector.Mobile));
IResultResponse res = ApiRequest.GetResponse(group.Domain, "vast.account.supplier.validatecode.get", new Dictionary <string, string>()
{
{ "mobile", mobile },
{ "VerifyCode", verifyCode },
{ "CodeToken", codeToken },
{ "ProprietorId", connector.SellerId.ToString() },
});
if (res.Success)
{
return(ResultResponse.GetSuccessResult(1));
}
return(ResultResponse.ExceptionResult(res.Message));
}
public static ResultResponse Delete(int id)
{
ResultResponse result = new ResultResponse();
try
{
using (var db = new MarComContext())
{
M_Souvenir souvenir = db.M_Souvenir.Where(s => s.Id == id).FirstOrDefault();
if (souvenir != null)
{
souvenir.Is_Delete = true;
db.SaveChanges();
result.Message = "Data Deleted ! Data souvenir with code " + souvenir.Code + " has been deleted";
}
}
}
catch (Exception)
{
result.Success = false;
result.Message = "Delete Data not success";
}
return(result);
}
public ActionResult ReturnItem(int nodeId, string bookId, int status)
{
var json = new ResultResponse();
try
{
if (status == STATUS_FOLIO)
{
_folioService.SetItemToWithdrawn(bookId);
}
var eventId = _orderItemManager.GenerateEventId(BOOK_RETURNED_HOME_EVENT_TYPE);
_orderItemManager.SetStatus(nodeId, "10:Återsänd", eventId);
json.Success = true;
json.Message = "Returnering genomförd.";
}
catch (Exception e)
{
json.Success = false;
json.Message = "Misslyckades med att returnera: " + e.Message;
}
return(Json(json, JsonRequestBehavior.AllowGet));
}
private void PrintFailResponse(ResultResponse resultResponse, string testName)
{
Console.WriteLine(testName + " failed:");
Console.WriteLine("Status: {0}", resultResponse?.Status.ToString() ?? "");
Console.WriteLine("Status code: {0}", resultResponse?.Code.ToString() ?? "");
Console.WriteLine("Exit code: {0}", resultResponse?.ExitCode.ToString() ?? "");
if ((resultResponse?.Messages?.Count ?? 0) > 0)
{
foreach (var message in resultResponse.Messages)
{
if (message.Key != null && (message.Value?.Length ?? 0) > 0)
{
Console.WriteLine("");
Console.WriteLine((message.Key ?? "") + ":");
foreach (var msg in message.Value)
{
Console.WriteLine(" " + msg);
}
}
}
}
}
public Task<ResultResponse<EnvioFicheiroResult>> Post()
{
ResultResponse<EnvioFicheiroResult> resposta = new ResultResponse<EnvioFicheiroResult>();
HttpRequestMessage request = this.Request;
if (!request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.UnsupportedMediaType));
}
UserProfile user = null;
if (WebSecurity.IsAuthenticated)
{
user = usersRepository.GetUserByIDIncludeEntidade(WebSecurity.CurrentUserId);
}
else
{
string username = string.Empty;
IEnumerable<string> headerVals;
if (Request.Headers.TryGetValues("Authorization", out headerVals))
{
string authHeader = headerVals.FirstOrDefault();
char[] delims = { ' ' };
string[] authHeaderTokens = authHeader.Split(new char[] { ' ' });
if (authHeaderTokens[0].Contains("Basic"))
{
string decodedStr = BasicAuthorizeAttribute.DecodeFrom64(authHeaderTokens[1]);
string[] unpw = decodedStr.Split(new char[] { ':' });
username = unpw[0];
}
else
{
if (authHeaderTokens.Length > 1)
username = BasicAuthorizeAttribute.DecodeFrom64(authHeaderTokens[1]);
}
}
user = usersRepository.All.Include("entidade").Single(u => u.UserName == username);
}
if (user == null)
{
resposta.Success = false;
resposta.ErrorMessage += "Erro de autenticação.";
}
//List<ValorSistema> paramSistema = valoresSistemaRepository.All.Where(v => v.tipologia == "ESTADO_FICHEIRO"
// || v.tipologia == "TIPO_NOTIFICACAO"
// || v.tipologia == "PARAM_PASTA_FICHEIROS").ToList();
//List<ValorSistema> estadosFicheiro = paramSistema.Where(v => v.tipologia == "ESTADO_FICHEIRO").ToList();
//List<ValorSistema> tiposNotificao = paramSistema.Where(v => v.tipologia == "TIPO_NOTIFICACAO").ToList();
//ValorSistema pastaUpload = paramSistema.Where(v => v.tipologia == "PARAM_PASTA_FICHEIROS").Single();
List<ValorSistema> estadosFicheiro = valoresSistemaRepository.GetPorTipologia("ESTADO_FICHEIRO");
List<ValorSistema> tiposNotificao = valoresSistemaRepository.GetPorTipologia("TIPO_NOTIFICACAO");
ValorSistema pastaUpload = valoresSistemaRepository.GetPorTipologia("PARAM_PASTA_FICHEIROS").Single();
var root = pastaUpload.valor;
//string root = System.Web.HttpContext.Current.Server.MapPath(destination);
var provider = new MultipartFormDataStreamProvider(root);
if (resposta.Success == false)
{
request.Content.ReadAsMultipartAsync(provider).
ContinueWith<ResultResponse<EnvioFicheiroResult>>(o =>
{ return resposta; });
}
var task = request.Content.ReadAsMultipartAsync(provider).
ContinueWith<ResultResponse<EnvioFicheiroResult>>(o =>
{
try
{
FileInfo finfo = new FileInfo(provider.FileData.First().LocalFileName);
DateTime dataSubmissao = DateTime.Now;
string guid = Guid.NewGuid().ToString();
string filePath = provider.FileData.First().Headers.ContentDisposition.FileName.Replace("\"", "");
filePath = filePath.Substring(filePath.LastIndexOf('\\') + 1);
var filename = Path.GetFileNameWithoutExtension(filePath);
var fileExtension = Path.GetExtension(filePath);
var newFilename = filename + "_" + dataSubmissao.ToString("yyyyMMddHHmmssfff") + fileExtension;
var path = Path.Combine(root, newFilename);
File.Move(finfo.FullName, path);
Ficheiro newFicheiro = new Ficheiro
{
nomeFicheiro = filename,
localizacao = path,
dataUpload = dataSubmissao,
dataAlteracao = dataSubmissao,
entidadeId = user.entidadeId,
estadoId = estadosFicheiro.Where(f => f.valor == "PENDENTE").Single().valorSistemaId,
userName = user.UserName
};
Notificacao notificacao = new Notificacao
{
dataCriacao = DateTime.Now,
entidadeId = user.entidadeId,
tipologiaId = tiposNotificao.Where(f => f.valor == "SUCESSO_RECECAO_FICHEIRO").Single().valorSistemaId,
mensagem = "Ficheiro '" +filename+ "' recebido com sucesso (via WebService)",
};
ficheirosRepository.Insert(newFicheiro);
Entidade entidade = entidadesRepository.Find((int)notificacao.entidadeId);
entidade.notificacoes.Add(notificacao);
entidadesRepository.Save();
notificacoesRepository.Save();
ficheirosRepository.Save();
EnvioFicheiroResult resultado = new EnvioFicheiroResult { dataRecepcao = newFicheiro.dataUpload, nomeFicheiro = filePath, seguradora = entidade.nome };
resposta.Success = true;
resposta.Result = resultado;
return resposta;
}
catch (Exception e)
{
resposta.Success = false;
resposta.ErrorMessage += "Erro na recepção do Ficheiro";
resposta.Result = null;
return resposta;
}
}
);
return task;
}
/// <summary>
/// Uploads event queue to Countly server
/// </summary>
/// <returns>True if success</returns>
private static async Task <bool> UploadEvents()
{
lock (sync)
{
// Allow uploading in one thread only
if (uploadInProgress)
{
return(true);
}
uploadInProgress = true;
}
int eventsCount;
lock (sync)
{
eventsCount = Events.Count;
}
if (eventsCount > 0)
{
ResultResponse resultResponse = await Api.SendEvents(ServerUrl, AppKey, Device.DeviceId, Events.Take(eventsCount).ToList(), (UserDetails.isChanged)?UserDetails : null);
if (resultResponse != null && resultResponse.IsSuccess)
{
int eventsCountToUploadAgain = 0;
UserDetails.isChanged = false;
await SaveUserDetails();
lock (sync)
{
uploadInProgress = false;
try
{
for (int i = eventsCount - 1; i >= 0; i--)
{
Events.RemoveAt(i);
}
}
catch { }
eventsCountToUploadAgain = Events.Count;
}
await Storage.SaveToFile <List <CountlyEvent> >(eventsFilename, Events);
if (eventsCountToUploadAgain > 0)
{
// Upload events added during sync
return(await UploadEvents());
}
else
{
return(true);
}
}
else
{
uploadInProgress = false;
return(false);
}
}
else
{
uploadInProgress = false;
return(true);
}
}
public async Task<object> OriginalAPI()
{
var request = HttpContext.Current.Request;
var api = ProxyApi.Instance;
string token = !string.IsNullOrEmpty(request.Params["token"]) ? request.Params["token"] : string.Empty;
string action = !string.IsNullOrEmpty(request.Params["action"]) ? request.Params["action"].ToLower() : string.Empty;
Game game = null;
ErrorCodes? error = null;
ResultResponse response = null;
int gameId = 0;
int.TryParse(request.Params["gid"], out gameId);
int venviciGid = Convert.ToInt16(ConfigurationManager.AppSettings["VENVICI_GID"]);
if (gameId == venviciGid)
{
//so confuse
game = new Game();
game.id = venviciGid;
game.guid = ConfigurationManager.AppSettings["VENVICI_GUID"];
}
else
game = api.GetGame(gameId).Data;
if (game == null)
error = ErrorCodes.INVALID_GAME_ID;
else if (ConstantValues.LIST_PROXY_ACTION.ContainsKey(action))
{
MethodInfo theMethod = this.GetType().GetMethod(ConstantValues.LIST_PROXY_ACTION[action]);
var apiResponse = await (Task<object>)theMethod.Invoke(this, new object[] { game, token, request });
response = apiResponse.CastObject<ResultResponse>();
}
else
error = ErrorCodes.NON_EXISTING_API;
if (error != null || response == null)
{
response = new ResultResponse
{
success = false,
message = (error != null) ? error.ToErrorMessage() : ErrorCodes.ServerError.ToErrorMessage()
};
}
//Not implemented yet in python
//api.LogApi();
if (response.profile != null && !string.IsNullOrEmpty(response.session))
{
var userCredentialObj = await api.GetUserCredential(response.profile.uid, game.id);
UserCredential userCredential = userCredentialObj.Data;
if (userCredential == null)
{
userCredential = new UserCredential
{
user_id = response.profile.uid,
game_id = game.id,
username = response.profile.account,
session = response.session
};
await api.CreateUserCredential(userCredential);
}
else
{
userCredential.username = response.profile.account;
userCredential.session = response.session;
await api.UpdateUserCredential(userCredential);
}
}
ResultResponse result = ResponseConverter(response);
return result;
}
public ResultResponse <string> RegisterCollaborator(BDHomeFoodContext _context, CollaboratorEntity model)
{
try{
ResultResponse <string> response = new ResultResponse <string>();
char[] s = { ' ' };
string[] slastname;
if (model == null)
{
response.Data = null;
response.Error = true;
response.Message = "Complete los datos";
}
else
{
if (_context.Collaborator.Any(x => x.Email == model.Email))
{
response.Data = null;
response.Error = true;
response.Message = "El correo electronico ya existe";
return(response);
}
if (_context.Collaborator.Any(x => x.Phone == model.Phone))
{
response.Data = null;
response.Error = true;
response.Message = "El número de celular ya existe";
return(response);
}
if (_context.Collaborator.Any(x => x.Username == model.Username))
{
response.Data = null;
response.Error = true;
response.Message = "El nombre de usuario ya existe";
return(response);
}
using (var ts = new TransactionScope()){
Collaborator collaborator = new Collaborator();
_context.Collaborator.Add(collaborator);
collaborator.Names = model.Names;
collaborator.LastNames = model.LastNames;
collaborator.DocumentIdentity = model.DocumentIdentity;
collaborator.Email = model.Email;
collaborator.Phone = model.Phone;
collaborator.BirthDate = model.BirthDate;
//collaborator.Username = model.Username;
slastname = model.LastNames.Split(s, 2, StringSplitOptions.None);
collaborator.Username = model.Names.Substring(0, 1) + slastname[0] + model.Phone.Substring(0, 4);
collaborator.Password = model.Password;
collaborator.CollaboratorTypeId = model.CollaboratorTypeId;
collaborator.State = ConstantHelpers.Estado.Activo;
collaborator.StateActivity = ConstantHelpers.Estado.Activo;
_context.SaveChanges();
ts.Complete();
response.Data = null;
response.Error = false;
response.Message = "Registro satisfactorio";
}
}
return(response);
}catch (Exception ex) {
throw new Exception(ex.Message);
}
}
public ResultResponse<EnvioOcorrenciasResult> Post([FromBody]ReporteOcorrenciasMatricula ocorrencias)
{
ResultResponse<EnvioOcorrenciasResult> resposta = new ResultResponse<EnvioOcorrenciasResult>();
//List<ValorSistema> paramSistema = valoresSistemaRepository.All.Where(v => v.tipologia == "ESTADO_EVENTO_STAGGING"
// || v.tipologia == "OPERACAO_EVENTO"
// || v.tipologia == "PARAM_PASTA_FICHEIROS").ToList();
//List<ValorSistema> estadosEvento = paramSistema.Where(v => v.tipologia == "ESTADO_EVENTO_STAGGING").ToList();
//List<ValorSistema> operacoesEvento = paramSistema.Where(v => v.tipologia == "OPERACAO_EVENTO").ToList();
//ValorSistema pastaUpload = paramSistema.Where(v => v.tipologia == "PARAM_PASTA_FICHEIROS").Single();
List<ValorSistema> estadosEvento = valoresSistemaRepository.GetPorTipologia("ESTADO_EVENTO_STAGGING");
List<ValorSistema> operacoesEvento = valoresSistemaRepository.GetPorTipologia("OPERACAO_EVENTO");
ValorSistema pastaUpload = valoresSistemaRepository.GetPorTipologia("PARAM_PASTA_FICHEIROS").Single();
if (ocorrencias == null || ocorrencias.Ocorrencia == null)
{
resposta.Success = false;
resposta.ErrorMessage = "Erro na recepção de ocorrências. Mensagem mal formada.";
}
UserProfile user = null;
if (WebSecurity.IsAuthenticated)
{
user = usersRepository.GetUserByIDIncludeEntidade(WebSecurity.CurrentUserId);
}
else
{
string username = string.Empty;
IEnumerable<string> headerVals;
if (Request.Headers.TryGetValues("Authorization", out headerVals))
{
string authHeader = headerVals.FirstOrDefault();
char[] delims = { ' ' };
string[] authHeaderTokens = authHeader.Split(new char[] { ' ' });
if (authHeaderTokens[0].Contains("Basic"))
{
string decodedStr = BasicAuthorizeAttribute.DecodeFrom64(authHeaderTokens[1]);
string[] unpw = decodedStr.Split(new char[] { ':' });
username = unpw[0];
}
else
{
if (authHeaderTokens.Length > 1)
username = BasicAuthorizeAttribute.DecodeFrom64(authHeaderTokens[1]);
}
}
user = usersRepository.GetUserByUsernameIncludeEntidade(username);
}
if (user == null)
{
resposta.Success = false;
resposta.ErrorMessage += "Erro de autenticação.";
}
var root = System.Configuration.ConfigurationManager.AppSettings["FilesUploadDestination"];
//string root = System.Web.HttpContext.Current.Server.MapPath(destination);
var provider = new MultipartFormDataStreamProvider(root);
if (resposta.Success == false)
{
return resposta;
}
DateTime dataRecepcao = DateTime.Now;
ReporteOcorrenciasFNMPAS reporteOcorrenciasFNMPAS = new ReporteOcorrenciasFNMPAS(ocorrencias);
reporteOcorrenciasFNMPAS.ordenaOcorrencias();
int nrOcorrencias = 0;
for (int i = 0; i < reporteOcorrenciasFNMPAS.OcorrenciaOrdenada.Count(); i++)
{
ReporteOcorrenciasMatriculaOcorrenciaOrdenada ocorrencia = reporteOcorrenciasFNMPAS.OcorrenciaOrdenada[i];
//evento Duplicado e esmagado com os novos dados. (C M - stagging/producao) (A - producao/stagging)
//Não foi ainda inserido na Base de dados nem houve delete logico do anterior.
//Fazer deletes logicos, e inserções após verificações.
//Anulações podem necessitar logica adicional caso a validação falhe. (duplicar registo em stagging)
EventoStagging evento = new EventoStagging();
int codigoOperacaoId = 0;
switch (ocorrencia.CodigoOperacao)
{
case ReporteOcorrenciasMatriculaOcorrenciaCodigoOperacao.C: codigoOperacaoId = operacoesEvento.Where(o => o.valor == "C").Single().valorSistemaId; break;
case ReporteOcorrenciasMatriculaOcorrenciaCodigoOperacao.M: codigoOperacaoId = operacoesEvento.Where(o => o.valor == "M").Single().valorSistemaId; break;
case ReporteOcorrenciasMatriculaOcorrenciaCodigoOperacao.A: codigoOperacaoId = operacoesEvento.Where(o => o.valor == "A").Single().valorSistemaId; break;
default: codigoOperacaoId = operacoesEvento.Where(o => o.valor == "C").Single().valorSistemaId; break;
}
Ficheiro ficheiroVirtual = new Ficheiro { dataAlteracao = dataRecepcao, dataUpload = dataRecepcao, entidadeId = user.entidadeId };
evento.esmagaDados(ocorrencia, ficheiroVirtual, codigoOperacaoId);
evento.utilizadorReporte = user.UserName;
evento.estadoEventoId = estadosEvento.Where(e => e.valor == "PENDENTE").Single().valorSistemaId;
eventosStaggingRepository.InsertOrUpdate(evento);
nrOcorrencias++;
}
eventosStaggingRepository.Save();
resposta.Success = true;
resposta.Result = new EnvioOcorrenciasResult { dataRecepcao = dataRecepcao, nrOcorrencias = nrOcorrencias, seguradora = user.entidade.nome };
return resposta;
}
public async Task <IActionResult> Delete([FromBody] CategoryModelRequest request)
{
ResultResponse result = await _categoryApplicationService.Delete(request);
return(Response(result));
}
private void BindGridView()
{
_candidateDetailResponse = MethodHelper.GetServiceResponse<CandidateDetail>("api/CandidateApi/Get", _candidateDetailSearchRequest);
dataGridView1.DataSource = _candidateDetailResponse.PageData;
dataGridView1.Columns["ProcessedDate"].DefaultCellStyle.Format = "dd/MM/yyyy";
lblReportStatus.Text = _candidateDetailResponse.TotalItem.ToString(CultureInfo.InvariantCulture);
}
public static void LoginTokenCustomer(IConfiguration _config, Models.Customer customer, ResultResponse <LoginCustomerResponse> response)
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken(customer.Email);
LoginCustomerResponse loginResponse = new LoginCustomerResponse {
Token = token,
CustomerId = customer.CustomerId,
Names = customer.Names,
LastNames = customer.LastNames
};
response.Data = loginResponse;
response.Error = false;
response.Message = "Inicio de sesión satisfactorio";
}
public ResultResponse<ConsultaPrivadaResult> Get(string dataInicio, string horaInicio, string dataFim, string horaFim, string matricula = null, string apolice = null,
bool? avisos = null)
{
//WebSecurity.Login("admin1", "administrador");
ResultResponse<ConsultaPrivadaResult> resposta = new ResultResponse<ConsultaPrivadaResult>();
DateTime dataInicioParsed;
TimeSpan horaInicioParsed;
DateTime dataFimParsed;
TimeSpan horaFimParsed;
DateTime dataHoraInicio;
DateTime dataHoraFim;
//tem data inicio válida - check
if (!DateTime.TryParseExact(dataInicio, "yyyyMMdd", new CultureInfo("pt-PT"), DateTimeStyles.None, out dataInicioParsed))
{
resposta.Success = false;
resposta.ErrorMessage += "Data de início de pesquisa '" + dataInicio + "' inválida";
}
if (!DateTime.TryParseExact(dataFim, "yyyyMMdd", new CultureInfo("pt-PT"), DateTimeStyles.None, out dataFimParsed))
{
resposta.Success = false;
resposta.ErrorMessage += "Data de fim de pesquisa '" + dataFim + "' inválida";
}
if (!TimeSpan.TryParseExact(horaInicio, "hhmmss", new CultureInfo("pt-PT"), TimeSpanStyles.None, out horaInicioParsed))
{
resposta.Success = false;
resposta.ErrorMessage += "Hora de inicio de pesquisa '" + horaInicio + "' inválida";
}
if (!TimeSpan.TryParseExact(horaFim, "hhmmss", new CultureInfo("pt-PT"), TimeSpanStyles.None, out horaFimParsed))
{
resposta.Success = false;
resposta.ErrorMessage += "Hora de fim de pesquisa '" + horaFim + "' inválida";
}
UserProfile user = null;
if (WebSecurity.IsAuthenticated)
{
user = usersRepository.GetUserByIDIncludeEntidade(WebSecurity.CurrentUserId);
}
else
{
string username = string.Empty;
IEnumerable<string> headerVals;
if(Request.Headers.TryGetValues("Authorization", out headerVals))
{
string authHeader = headerVals.FirstOrDefault();
char[] delims = { ' ' };
string[] authHeaderTokens = authHeader.Split(new char[] { ' ' });
if (authHeaderTokens[0].Contains("Basic"))
{
string decodedStr = BasicAuthorizeAttribute.DecodeFrom64(authHeaderTokens[1]);
string[] unpw = decodedStr.Split(new char[] { ':' });
username = unpw[0];
}
else{
if (authHeaderTokens.Length > 1)
username = BasicAuthorizeAttribute.DecodeFrom64(authHeaderTokens[1]);
}
}
user = usersRepository.All.Include("entidade").Single(u => u.UserName == username);
}
if(user == null){
resposta.Success = false;
resposta.ErrorMessage += "Erro de autenticação.";
}
if(resposta.Success == false)
{
return resposta;
}
//try
//{
// user = usersRepository.All.Include("entidade").Single(u => u.UserName == "admin1");
//}
dataHoraInicio = dataInicioParsed.Add(horaInicioParsed);
dataHoraFim = dataFimParsed.Add(horaFimParsed);
Entidade ent = user.entidade;
IQueryable<Apolice> queryApolices;
if (ent.scope.valor == "GLOBAL")
{
queryApolices = apolicesRepository.All.Include("veiculo").Include("tomador").Include("concelho").Include("entidade");
}
else
{
//Seguradoras (Acesso Local)
queryApolices = apolicesRepository.All.Include("veiculo").Include("tomador").Include("concelho").Include("entidade").Where(a => a.entidadeId == ent.entidadeId);
}
queryApolices = queryApolices.Where(a =>((dataHoraInicio >= a.dataInicio && dataHoraInicio <= a.dataFim) ||
(dataHoraFim >= a.dataInicio && dataHoraFim <= a.dataFim) ||
(dataHoraInicio <= a.dataInicio && dataHoraFim >= a.dataFim)));
if (!(apolice == null || apolice == ""))
{
queryApolices = queryApolices.Where(a => a.numeroApolice.Contains(apolice));
}
if (!(matricula == null || matricula == ""))
{
queryApolices = queryApolices.Where(a => a.veiculo.numeroMatricula.Contains(matricula));
}
if (avisos != null && avisos == true)
{
queryApolices = queryApolices.Where(a => a.avisos == true);
}
queryApolices = queryApolices.OrderByDescending(a => a.dataReporte);
List<ConsultaPrivadaItem> apolicesView = new List<ConsultaPrivadaItem>();
foreach (Apolice a in queryApolices.ToList())
{
apolicesView.Add(new ConsultaPrivadaItem
{
numeroApolice = a.numeroApolice,
dataInicio = a.dataInicio,
dataFim = a.dataFim,
numeroMatricula = a.veiculo.numeroMatricula,
categoriaVeiculo = a.veiculo.categoria.codigoCategoriaVeiculo,
marcaVeiculo = a.veiculo.marcaVeiculo,
modeloVeiculo = a.veiculo.modeloVeiculo,
nomeTomador = a.tomador.nome,
identificacaoTomador = a.tomador.numeroIdentificacao,
moradaTomador = a.tomador.morada,
codigoPostalTomador = a.tomador.codigoPostal,
seguradora = a.entidade.nome
});
}
resposta.Result = new ConsultaPrivadaResult { listagem = apolicesView };
return resposta;
}
/// <summary>
/// Uploads sessions queue to Countly server
/// </summary>
/// <returns></returns>
private static async Task <bool> UploadSessions()
{
lock (sync)
{
if (uploadInProgress)
{
return(true);
}
uploadInProgress = true;
}
SessionEvent sessionEvent = null;
lock (sync)
{
if (Sessions.Count > 0)
{
sessionEvent = Sessions[0];
}
}
if (sessionEvent != null)
{
ResultResponse resultResponse = await Api.SendSession(ServerUrl, sessionEvent, (UserDetails.isChanged)?UserDetails : null);
if (resultResponse != null && resultResponse.IsSuccess)
{
UserDetails.isChanged = false;
await SaveUserDetails();
lock (sync)
{
uploadInProgress = false;
try
{
Sessions.RemoveAt(0);
}
catch { }
}
await Storage.SaveToFile <List <SessionEvent> >(sessionsFilename, Sessions);
if (Sessions.Count > 0)
{
return(await UploadSessions());
}
else
{
return(true);
}
}
else
{
uploadInProgress = false;
return(false);
}
}
else
{
uploadInProgress = false;
return(true);
}
}
private ResultResponse ResponseConverter(ResultResponse response)
{
if (response.success)
{
response.status = "Success";
response.Error = "0";
if (response.profile != null)
{
response.profile = Helper.FullFillEmptyFields<Profile>(response.profile);
var profileList = new List<Profile>();
profileList.Add(response.profile);
response.UserData = profileList;
}
if (response.notifications != null && response.notifications.Any())
{
response.list = new List<ResultNotificationModel>();
foreach (var note in response.notifications)
{
ReponseGetNotificationModel noti = JsonHelper.DeserializeObject<ReponseGetNotificationModel>(note.ToString());
if (noti != null)
response.list.Add(new ResultNotificationModel
{
id = noti.id,
addTime = noti.created_at,
state = noti.is_archived ? 1 : 0,
serverID = 1,
goodType = noti.good_type,
goodID = noti.good_id,
goodAmount = noti.good_amount
});
}
}
}
else
{
response.status = "fail";
response.Error = !string.IsNullOrEmpty(response.message)
? response.message
: ErrorCodes.SYSTEM_ERROR.ToErrorMessage();
}
return response;
}
/// <summary>
/// Uploads exceptions queue to Countly server
/// </summary>
/// <returns>True if success</returns>
private static async Task <bool> UploadExceptions()
{
lock (sync)
{
// Allow uploading in one thread only
if (uploadInProgress)
{
return(true);
}
uploadInProgress = true;
}
int exceptionsCount;
lock (sync)
{
exceptionsCount = Exceptions.Count;
}
if (exceptionsCount > 0)
{
ResultResponse resultResponse = await Api.SendException(ServerUrl, AppKey, Device.DeviceId, Exceptions[0]);
if (resultResponse != null && resultResponse.IsSuccess)
{
int exceptionsCountToUploadAgain = 0;
lock (sync)
{
uploadInProgress = false;
try
{
Exceptions.RemoveAt(0);
}
catch { }
exceptionsCountToUploadAgain = Exceptions.Count;
}
SaveExceptions();
if (exceptionsCountToUploadAgain > 0)
{
// Upload next exception
return(await UploadExceptions());
}
else
{
return(true);
}
}
else
{
uploadInProgress = false;
return(false);
}
}
else
{
uploadInProgress = false;
return(false);
}
}
public ResultResponse<ConsultaPublicaResult> Get(string data, string hora, string matricula)
{
ResultResponse<ConsultaPublicaResult> resposta = new ResultResponse<ConsultaPublicaResult>();
DateTime dataParsed;
TimeSpan horaParsed;
DateTime dataHoraPesquisa;
//tem matrícula válida - check
if (matricula == null || !Regex.Match(matricula, "[-\\/?#() A-Za-z0-9]+").Success)
{
resposta.Success = false;
resposta.ErrorMessage += "Número de matrícula '" + matricula + "' inválido.\n";
}
//tem data inicio válida - check
if (!DateTime.TryParseExact(data, "yyyyMMdd", new CultureInfo("pt-PT"), DateTimeStyles.None, out dataParsed))
{
resposta.Success = false;
resposta.ErrorMessage += "Data de pesquisa '" + data + "' inválida";
}
if (!TimeSpan.TryParseExact(hora, "hhmmss", new CultureInfo("pt-PT"), TimeSpanStyles.None, out horaParsed))
{
resposta.Success = false;
resposta.ErrorMessage += "Hora de pesquisa '" + hora + "' inválida";
}
if(resposta.Success == false)
{
return resposta;
}
dataHoraPesquisa = dataParsed.Add(horaParsed);
List<Apolice> apolices = apolicesRepository.All.Include("entidade").Include("veiculo").Where(a => (a.veiculo.numeroMatricula == matricula || a.veiculo.numeroMatriculaCorrigido == matricula) && a.dataInicio <= dataHoraPesquisa && a.dataFim >= dataHoraPesquisa).ToList();
List<ApoliceIsento> isentos = apolicesIsentosRepository.All.Where(i => (i.matricula == matricula || i.matriculaCorrigida == matricula || i.matriculaCorrigida == matricula.Replace("-", "")) && i.dataInicio <= dataHoraPesquisa && i.confidencial == false && i.arquivo == false).ToList();
List<ConsultaPublicaItem> apolicesPublicas = new List<ConsultaPublicaItem>();
foreach (Apolice a in apolices)
{
apolicesPublicas.Add(new ConsultaPublicaItem
{
dataInicio = a.dataInicio,
dataFim = a.dataFim,
marcaVeiculo = a.veiculo.marcaVeiculo,
modeloVeiculo = a.veiculo.modeloVeiculo,
numeroApolice = a.numeroApolice,
seguradora = a.entidade.nome
});
}
foreach (ApoliceIsento i in isentos)
{
if (i.dataFim != null)
{
if (i.dataFim < dataHoraPesquisa)
{
continue;
}
}
ConsultaPublicaItem apoliceToView = new ConsultaPublicaItem
{
dataInicio = i.dataInicio,
seguradora = "Veículo Isento de Seguro"
};
if(i.dataFim != null){
apoliceToView.dataFim = (DateTime)i.dataFim;
}else{
apoliceToView.dataFim = DateTime.Now;
}
apolicesPublicas.Add(apoliceToView);
}
resposta.Result = new ConsultaPublicaResult{ listagem = apolicesPublicas };
return resposta;
}
