public async Task SaveRequest(RequestDto model)
{
var member = await DbContext.GetMemberByMemberIdAsync(model.CreatedByMember);
var assignedToProvider = await DbContext.GetProviderByProviderIdAsync(model.AssignedProviderId);
var requestProvider = await DbContext.GetProviderByProviderIdAsync(model.RequestProvider.ProviderId);
var request = new Request
{
Comment = model.Comment,
AssignedToProviderId = model.AssignedProviderId,
AssignedToProvider = assignedToProvider,
CreatedByMember = model.CreatedByMember,
CreatedDt = model.CreatedDt,
DueEndDt = model.DueEndDt,
DueStartDt = model.DueStartDt,
MemberCreator = member,
Status = model.Status,
ModifiedDt = DateTime.Now,
RequestDescription = model.RequestDescription,
Id = model.Id,
RequestProvider = requestProvider,
LockedByProvider = model.LockedByProvider,
LockeDt = model.LockeDt,
};
await DbContext.SaveRequest(request);
}
// add new request
public static RequestDto AddNewRequest(RequestDto requestDto)
{
try
{
// converts the URL to a recording format
requestDto.content = "VERSION BUILD = 1005 RECORDER = CR\nURL GOTO = " + requestDto.content + " \nSAVEAS TYPE = HTML FOLDER =D:\\Files FILE =newHtml";
requestDto.recording_stream = Encoding.ASCII.GetBytes(requestDto.content);
Status status = Run(requestDto.content, "");
// Robotic surfing for keeping the initial state of the page
if (status == Status.sOk)
{
// Read the page content
string newPlay = File.ReadAllText("D:\\Files\\newHtml.htm");
// fill in the data
requestDto.file_stream = Encoding.ASCII.GetBytes(newPlay);
requestDto.file_id = RequestDAL.AttachedFile(requestDto.file_stream, ".html");
// add to database
RequestDto requestsDto = RequestDAL.AddNewRequest(requestDto);
return(requestsDto);
}
}
catch (Exception)
{
return(null);
}
return(null);
}
//[ProducesResponseType(StatusCodes.Status201Created)]
public async Task <IActionResult> Post([FromBody] RequestDto request)
{
var sw = Stopwatch.StartNew();
var device = request?.Device;
var location = request?.Location;
if (device == null || location == null)
{
return(BadRequest());
}
//var locationDto = request.GetParamsAsObject<DeviceLocationDto>();
var item = await LocationService.InsertDeviceLocation(device, location);
sw.Stop();
if (item != null)
{
await DeviceLocationHubContext.Clients.All.SendAsync("changeDevicesLocation", new List <DeviceLocationDto>() { item });
}
return(Ok(new ResponseDto()
{
LeadTime = sw.Elapsed,
Message = (item == null || item?.Id > 0) ? "Resources.Resource.MessageRegCoordinate" : "Resources.Resource.MessageNotFound"
}));
}
public void Init()
{
sqlOperationMock = new Mock <ISqlOperation>();
sqlOperationMock.Setup(s => s.Execute(It.IsAny <ExecuteSqlQuery>(), It.IsAny <object[]>())).Returns(1);
sqlOperationMock.Setup(s => s.ExecuteAsync(It.IsAny <ExecuteSqlQuery>(), It.IsAny <object[]>())).Returns(Task.FromResult(1));
sqlOperationMock.Setup(s => s.Select <HubDataDto>(It.IsAny <SelectSqlQuery>(), It.IsAny <object[]>())).Returns(new HubDataDto {
Id = 1
});
sqlOperationMock.Setup(s => s.SelectMultiple <HubDataDto>(It.IsAny <SelectSqlQuery>(), It.IsAny <object[]>())).Returns(new List <HubDataDto> {
new HubDataDto {
Id = 1
}, new HubDataDto {
Id = 2
}
});
sqlOperationFailureMock = new Mock <ISqlOperation>();
sqlOperationFailureMock.Setup(s => s.Execute(It.IsAny <ExecuteSqlQuery>(), It.IsAny <object[]>())).Returns(0);
sqlOperationFailureMock.Setup(s => s.ExecuteAsync(It.IsAny <ExecuteSqlQuery>(), It.IsAny <object[]>())).Returns(Task.FromResult(0));
hubDataDto = new HubDataDto();
requestDto = new RequestDto();
sessionDto = new SessionDto();
sessionReportDto = new SessionReportDto();
}
private bool AddRequestTrace(SignalrRequest signalrRequest, string connectionToken)
{
var sessionObj = _sqlOperation.Select <SessionDto>(SelectSqlQuery.GetSingle_Session_By_ConnectionToken,
connectionToken);
if (sessionObj == null)
{
return(false);
}
var owinRequest = signalrRequest.OwinContext.Request;
var requestEntity = new RequestDto
{
SessionId = sessionObj.SessionId,
OwinRequestId = signalrRequest.OwinRequestId,
RequestUrl = owinRequest.Uri.AbsoluteUri,
RemoteIp = owinRequest.RemoteIpAddress,
RemotePort = owinRequest.RemotePort ?? 0,
ServerIp = owinRequest.LocalIpAddress,
ServerPort = owinRequest.LocalPort ?? 0,
RequestContentType = owinRequest.ContentType,
RequestBody = owinRequest.ReadBody(),
Protocol = owinRequest.Protocol,
QueryString = owinRequest.QueryString.Value,
User = owinRequest.User?.Identity?.Name,
RequestTimeStamp = DateTime.UtcNow.Ticks,
IsWebSocketRequest = signalrRequest.QueryCollection.Transport == "webSockets",
RequestType = signalrRequest.Type.ToString()
};
return(requestEntity.Save(_sqlOperation));
}
public async Task <IActionResult> Desactivar(PersonalGridViewModel modelGrid, int id)
{
try
{
//Construimos el request
var request = new RequestDto <PersonalDto>
{
Registro = new PersonalDto {
IdPersonal = id
},
//Auditoria = User.GetAuditoria()
};
//Invocamos al servicio
await _gestionContenidoService.PersonalDesactivarAsync(request);
//Refrescamos la pagina con los registros actuales
return(await Index(modelGrid));
}
catch (FaultException <ServiceErrorResponseDto> ex)
{
//Como existe excepción de lógica de negocio, lo enviamos al cliente para ser procesado por este
return(Json(HelperJson.ConstruirJson(EnumTipoNotificacion.Advertencia, ex.Detail.Message)));
}
}
public RequestDto GetRequest()
{
var random = new Bogus.Randomizer();
var lorem = new Bogus.DataSets.Lorem();
var subRequest = new Faker <SubRequestDto>()
.RuleFor(first => first.Name, f => lorem.Text())
.RuleFor(first => first.ChildID, f => random.Number(1990, 2030))
.RuleFor(first => first.DateOfBirth, f => f.Date.Recent(100));
var requestDto = new RequestDto()
{
Year = random.Number(1990, 2030),
Denomination1 = lorem.Text(),
Denomination2 = lorem.Text(),
MaritalStatus = random.Word(),
SubRequests = subRequest.Generate(2),
Income = (decimal)random.Number(10000, 2564789),
QualifiedProp = (decimal)random.Number(10000, 2564789),
QualifiedProp2 = (decimal)random.Number(10000, 2564789),
SomeProp = (decimal)random.Number(10000, 2564789),
SomeProp2 = (decimal)random.Number(10000, 2564789),
SomeProp3 = (decimal)random.Number(10000, 2564789),
Shortname = random.Word(),
SomeProp22 = random.Word(),
};
return(requestDto);
}
public static void ThreadFunction(object request)
{
try
{
Log.WriteEntry("ThreadFunction");
RequestDto requestDto = (RequestDto)request;
requestDto.eventLog.WriteEntry("in BL: ThreadFunction");
requestDto.eventLog.WriteEntry("request_id: " + requestDto.request_id.ToString());
bool isDiff = false;
string newPlay = Play(requestDto.recording_stream, requestDto.request_id.ToString(), requestDto.eventLog);
if (newPlay != null)
{
isDiff = Compere(newPlay, Encoding.UTF8.GetString(requestDto.file_stream), requestDto.eventLog);
}
requestDto.eventLog.WriteEntry("isDiff: " + isDiff);
if (isDiff)
{
SendMail(requestDto.userMail, newPlay, requestDto.request_name, requestDto.eventLog);
UpdatHtmlFile(requestDto, newPlay, requestDto.eventLog);
}
}
catch (Exception ex)
{
Log.WriteEntry(ex.ToString());
// throw;
}
}
public async Task Should_upload_file_and_data_on_multipart_form_data()
{
const string text = "Text property";
const int integer = int.MaxValue;
var vector = new[] { "Index 0", "Index 1", "Index 2" };
var uniqueId = Guid.NewGuid();
var request = new RequestDto
{
TextProperty = text,
IntProperty = integer,
ArrayProperty = vector,
UniqueIdProperty = uniqueId,
ListProperty = vector.ToList()
};
var content = new MultipartFormDataContent();
content.Add(Helper.GetByteArrayContent(1_000), "file", "file.csv");
content.AddJsonObject(request);
var response = await _client.PostAsync("/api/upload", content);
var dto = JsonConvert.DeserializeObject <ResponseDto>(await response.Content.ReadAsStringAsync());
dto.Should().NotBeNull();
dto.Request.Should().NotBeNull();
dto.Request.TextProperty.Should().Be(text);
dto.Request.IntProperty.Should().Be(integer);
dto.Request.ArrayProperty.Should().BeEquivalentTo(vector);
dto.Request.ListProperty.Should().BeEquivalentTo(vector.ToList());
dto.Length.Should().BeGreaterOrEqualTo(31000);
}
public async Task <IActionResult> CreateRequest(RequestDto requestDto)
{
BaseOrder baseOrder = new OrderDetailService(_db);
await baseOrder.CreateRequest(requestDto);
return(Ok("Заявка успешно создана"));
}
private void ValidateRequest(RequestDto requestDto, ClaimsPrincipal peerPrincipal)
{
if (requestDto.clientIdentity == null)
{
throw new ArgumentException($"{nameof(requestDto.clientIdentity)} must be provided.");
}
if (requestDto.serverIdentity == null)
{
throw new ArgumentException($"{nameof(requestDto.serverIdentity)} must be provided.");
}
if (requestDto.environment == null)
{
throw new ArgumentException($"{nameof(requestDto.environment)} must be provided.");
}
if (requestDto.roots == null)
{
throw new ArgumentException($"{nameof(requestDto.roots)} must be provided.");
}
if (requestDto.clientIdentity.uuid != Guid.Parse(clientUuid))
{
throw new ArgumentException("UUID in URI does not match UUID in message.");
}
if (requestDto.clientIdentity.uuid != peerPrincipal.GetClaimedUuid())
{
throw new ArgumentException("UUID of client principal does not match UUID in message.");
}
}
public IActionResult SendRequestMail(RequestDto requestDto)
{
var userName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(this.User.FindFirstValue(ClaimTypes.Name));
var company = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(this.User.FindFirstValue(ClaimTypes.GivenName));
var template = $"Hello, Rajat\n\n {userName} from {company} has requested:- ";
var toEmailAddress = new EmailAddress()
{
Name = "OM Phoenix Traders",
Address = "*****@*****.**"
};
var fromEmailAddress = new EmailAddress()
{
Name = userName,
Address = ""
};
var emailMessage = new EmailMessage()
{
ToAddresses = new List <EmailAddress>()
{
toEmailAddress
},
FromAddresses = new List <EmailAddress>()
{
fromEmailAddress
},
Subject = requestDto.RequestType,
Content = template + (requestDto.RequestType == "ServiceRequest" ? requestDto.ServiceCategory : requestDto.PartNumber + " " + requestDto.MachineModel)
};
_emailService.Send(emailMessage);
return(Ok(200));
}
public async Task MakeRequest_BookIsAvailableForRequest_Return_NoFound()
{
var expectedRequestDto = new RequestDto()
{
Id = 1,
RequestDate = new DateTime(1999, 05, 28),
User = new UserDto()
{
Id = 1
},
Book = new BookGetDto()
{
Id = 1
},
Owner = new UserDto()
{
Id = 1
},
ReceiveDate = null
};
_userResolverServiceMock.Setup(x => x.GetUserId()).Returns(1);
var userId = _userResolverServiceMock.Object.GetUserId();
_requestServiceMock.Setup(s => s.MakeAsync(userId, It.IsAny <int>())).ReturnsAsync(expectedRequestDto);
var result = await _requestController.Make(It.IsAny <int>());
result.Should().BeOfType <ActionResult <RequestDto> >();
}
public async Task GetRequestsForBook_BookExists_RequestQueryParamExists_Returns_OkResult()
{
var expectedRequest = new RequestDto()
{
Id = 1,
RequestDate = new DateTime(1999, 05, 28),
User = new UserDto()
{
Id = 1
},
Book = new BookGetDto()
{
Id = 1
},
Owner = new UserDto()
{
Id = 1
},
ReceiveDate = null
};
var queryParameter = new RequestsQueryParams()
{
First = true,
Last = false
};
_requestServiceMock.Setup(s => s.GetByBookAsync(It.IsAny <Expression <Func <Request, bool> > >(), queryParameter))
.ReturnsAsync(expectedRequest);
var result = await _requestController.GetByBook(It.IsAny <int>(), queryParameter);
result.Result.Should().BeOfType <OkObjectResult>();
}
public async Task <RequestDto> CreateNewRequestAsync()
{
var model = HttpContext.Request.Form["requestForm"];
var createrequestDto = JsonConvert.DeserializeObject <CreateRequestDto>(model);
RequestDto request = await _requestAppService.CreateAsync(createrequestDto);
var requestImages = HttpContext.Request.Form.Files;
string path = Path.Combine(ImagesFolderPath, request.Id.ToString());
Directory.CreateDirectory(path);;
int i = 1;
List <string> imagesNameList = new List <string>();
requestImages.ForEach(async(image) =>
{
if (image.Length > 0)
{
var nameSplits = image.FileName.Split(".");
var type = nameSplits[nameSplits.Length - 1];
var imageName = requestImagePrefix + request.Id + "_" + i + "." + type;
var filePath = Path.Combine(path, imageName);
i++;
imagesNameList.Add(imageName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
await image.CopyToAsync(fileStream);
}
}
});
await _requestAppService.AddRequestImagesForRequest(request.Id, imagesNameList);
return(request);
}
//public static RequestDto DeleteRequest(RequestDto requestDto)
//{
// using (var db = new DBContext())
// {
// try
// {
// Request request = Mapper.Map<RequestDto, Request>(requestDto);
// db.Requests.AddOrUpdate(request);
// db.SaveChanges();
// return requestDto;
// }
// catch (Exception ex)
// {
// return new RequestDto
// {
// IsAuthorized = false,
// ErrorMessage = "שגיאה בהתחברות לשרת"
// };
// };
// }
//}
public static RequestDto AddNewRequest(RequestDto requestDto)
{
//GetAllRelevantRequests();
using (var db = new DBContext())
{
try
{
ObjectParameter file_id = new ObjectParameter("file_id", typeof(Guid));
db.attached_file_add(String.Format("{0:dMyyyyHHmmssF}", DateTime.Now) + ".pdf", requestDto.file_stream, file_id);
requestDto.file_id = (Guid)file_id.Value;
db.attached_file_add(String.Format("{0:dMyyyyHHmmssR}", DateTime.Now) + ".pdf", requestDto.recording_stream, file_id);
requestDto.recording_id = (Guid)file_id.Value;
var request = Mapper.Map <RequestDto, Request>(requestDto);
//למחיקה
//request.recording_id = null;
db.Requests.Add(request);
db.SaveChanges();
return(requestDto);
}
catch (Exception ex)
{
return(new RequestDto
{
IsAuthorized = false,
ErrorMessage = "שגיאה בהתחברות לשרת"
});
};
}
}
public static List <RequestDto> DeleteRequest(RequestDto requestDto)
{
using (var db = new DBContext())
{
try
{
Request request = Mapper.Map <RequestDto, Request>(requestDto);
db.Requests.AddOrUpdate(request);
db.SaveChanges();
List <RequestDto> userRequestsDto = new List <RequestDto>();
foreach (var r in db.Requests.Where(r => r.is_relevant == true).ToList())
{
userRequestsDto.Add(Mapper.Map <Request, RequestDto>(r));
}
return(userRequestsDto);
}
catch (Exception ex)
{
return(new List <RequestDto>
{
new RequestDto
{
IsAuthorized = false,
ErrorMessage = "שגיאה בהתחברות לשרת"
}
});
};
}
}
public string Insertempleado([FromBody] EmpleadoDto empleadoDto)
{
EmpleadosBL = new EmpleadosBL();
RequestDto = new RequestDto();
RequestDto = EmpleadosBL.InsertEmpleado(empleadoDto);
return(RequestDto.Message.ToString());
}
public IActionResult Second(RequestDto req)
{
int num;
if (req.arr.Length < 2)
{
return(BadRequest("Invalid Request"));
}
int diff = req.arr[1] = req.arr[0];
for (int i = 1; i < req.arr.Length; i++)
{
if ((req.arr[i] - req.arr[i - 1]) != diff)
{
num = 0;
}
}
num = diff;
if (req.arr.Length > req.K & num != 0)
{
return(Ok(req.arr[req.K - 1]));
}
return(Ok(-1));
}
public void Save(RequestDto model)
{
var userId = repository.UserId;
var requestExists = repository
.All()
.Any(r => r.EmployeeUserId == userId &&
((r.From <= model.From && model.From <= r.To) ||
(r.From <= model.To && model.To <= r.To)));
if (requestExists)
{
throw new Exception(ErrorMessages.ThereIsAlreadyRequestForTheseDatesMessage);
}
var result = repository.FindOrCreate(model.Id);
if (!CanEdit(model.Id))
{
throw new Exception(ErrorMessages.CanNotEditAnotherUserRequest);
}
result.EmployeeUserId = userId;
result.From = model.From;
result.To = model.To;
result.RequestTypeId = model.RequestTypeId;
result.Description = model.Description;
result.IsApproved = false;
repository.Save(result);
}
/// <summary>
/// Método para agregar un empelado
/// </summary>
/// <returns> Objeto de la petición </returns>
public RequestDto InsertTelefono(telefonos telefonos)
{
_dbContextApp = new DbContextApp();
RequestDto request = new RequestDto();
try
{
BaseRepository <telefonos> baseRepositoryTelefonos = new BaseRepository <telefonos>(_dbContextApp);
var insertTelefono = baseRepositoryTelefonos.Insert(telefonos);
if (!Int32.TryParse(insertTelefono, out Int32 result))
{
throw new System.ArgumentException(insertTelefono);
}
request.Result = insertTelefono;
request.RequestStatus = RequestDto.Status.Success;
request.Message = "Telefono empleado creado satisfactoriamente.";
}
catch (Exception ex)
{
request.Exception = ex;
request.Message = "Ocurrió un error al ejecutar la petición.";
}
finally
{
_dbContextApp.Dispose();
}
return(request);
}
public RequestResponseDto Add(RequestDto dto)
{
if (dto == null)
{
return(null);
}
var request = new Notification();
try
{
request.SenderId = dto.SenderId;
request.Title = dto.Title;
request.Content = dto.Content;
request.Type = "request";
db.Notifications.Add(request);
db.SaveChanges();
}
catch
{
return(null);
}
return(Get(request.Id));
}
public string DeleteEmpleado(int Empleado_Id, int Telefono_Id = 0)
{
EmpleadosBL = new EmpleadosBL();
RequestDto = new RequestDto();
RequestDto = EmpleadosBL.DeleteEmpleado(Empleado_Id, Telefono_Id);
return(RequestDto.Message.ToString());
}
public void UpdateWithCourses(int id, RequestDto request)
{
Request requestWithCourses = GetByIdWithCourses(id);
context.Entry(requestWithCourses).CurrentValues.SetValues(request);
//List<Course> courses = context.Set<Course>().ToList();
foreach (Course c in requestWithCourses.Courses)
{
if (!request.Courses.Any(x => x.Id == c.Id))
{
requestWithCourses.Courses.Remove(c);
}
}
foreach (CourseDto course in request.Courses)
{
//MappingHelper.MapCourseDto(course);
Course cou = new Course();
cou.Id = course.Id;
cou.CourseTitle = course.CourseTitle;
cou.CourseDay = course.CourseDay;
cou.CourseTime = course.CourseTime;
cou.CourseFee = course.CourseFee;
cou.CoreCourse = course.CoreCourse;
cou.Professor = course.Professor;
cou.Level = course.Level;
if (!request.Courses.Any(x => x.Id == course.Id))
{
//context.Set<Course>().Attach(course);
//requestWithCourses.Courses.Add(course);
}
}
}
/// <summary>
/// Метод отправляет заявку на email.
/// </summary>
/// <param name="requestDto"></param>
/// <returns></returns>
public async Task SendMessageToEmail(RequestDto requestDto)
{
try {
var emailMessage = new MimeMessage();
emailMessage.From.Add(new MailboxAddress("*****@*****.**"));
emailMessage.To.Add(new MailboxAddress("*****@*****.**"));
emailMessage.Subject = "Новая заявка";
emailMessage.Body = new TextPart(MimeKit.Text.TextFormat.Html)
{
Text = "Имя: " + requestDto.Name + "</br>" +
"E-mail или телефон: " + requestDto.EmailOrNumber + "</br>" +
"Коротко о проекте: " + requestDto.Comment
};
using (var client = new SmtpClient()) {
await client.ConnectAsync("smtp.mail.ru", 2525, MailKit.Security.SecureSocketOptions.StartTls);
await client.AuthenticateAsync("*****@*****.**", "13467982dd");
await client.SendAsync(emailMessage);
await client.DisconnectAsync(true);
}
}
catch (Exception ex) {
throw new Exception(ex.Message.ToString());
}
}
public JsonResult GetListJefes()
{
EmpleadosBL = new EmpleadosBL();
RequestDto = new RequestDto();
RequestDto = EmpleadosBL.GetListJefes();
//if ((string.IsNullOrEmpty((string)RequestDto.Result)))
//{
// ViewBag.viewJefe = false;
//}
if (RequestDto.RequestStatus == RequestDto.Status.Failure)
{
return(new JsonResult()
{
Data = RequestDto, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
return(new JsonResult()
{
Data = RequestDto, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
public JsonResult InsertTelefono(telefonos telefonos)
{
TelefonosBL = new TelefonosBL();
RequestDto = new RequestDto();
if (!ModelState.IsValid)
{
new JsonResult();
}
RequestDto = TelefonosBL.InsertTelefono(telefonos);
if (RequestDto.RequestStatus == RequestDto.Status.Failure)
{
return(new JsonResult()
{
Data = RequestDto, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
return(new JsonResult()
{
Data = RequestDto, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
/// <summary>
/// Método para eliminar la informacion de un empleado
/// </summary>
/// <returns> Objeto de la petición </returns>
public RequestDto DeleteEmpleado(int Empleado_Id, int Telefono_Id = 0)
{
_dbContextApp = new DbContextApp();
RequestDto request = new RequestDto();
TelefonosBL telefonosBL = new TelefonosBL();
if (Telefono_Id != 0)
{
request = telefonosBL.DeleteTelefono(Telefono_Id);
if (!request.Result.Equals(true.ToString()))
{
return(request);
}
}
BaseRepository <empleados> baseRepositoryEmpleados = new BaseRepository <empleados>(_dbContextApp);
request.Result = baseRepositoryEmpleados.Delete(Empleado_Id);
if (!request.Result.Equals(true.ToString()))
{
request.Result = false;
request.Exception = (Exception)request.Result;
request.Message = "Ocurrió un error eliminando el registro.";
}
request.RequestStatus = RequestDto.Status.Success;
request.Message = "Registro eliminado satisfactoriamente.";
return(request);
}
public static RequestDto AddNewRequest(RequestDto requestDto)
{
using (var db = new DBContext())
{
try
{//הצפנה
string a = Encoding.UTF8.GetString(requestDto.recording_stream);
string b = Encrypt_Decrypt.EncryptStringAES(Encoding.UTF8.GetString(requestDto.recording_stream), "onTime123");
requestDto.recording_stream = Encoding.ASCII.GetBytes(Encrypt_Decrypt.EncryptStringAES(Encoding.UTF8.GetString(requestDto.recording_stream), "onTime123"));
// requestDto.recording_stream = Encoding.ASCII.GetBytes(Encrypt_Decrypt.DecryptStringAES(Encoding.UTF8.GetString(requestDto.recording_stream), "onTime123"));
requestDto.file_id = AttachedFile(requestDto.file_stream, ".html");
requestDto.recording_id = AttachedFile(requestDto.recording_stream, ".iim");
var request = Mapper.Map <RequestDto, Request>(requestDto);
//למחיקה
//request.recording_id = null;
db.Requests.Add(request);
db.SaveChanges();
return(requestDto);
}
catch (Exception ex)
{
return(null);
};
}
}
public async Task <List <ScheduledMatchDto> > GetMatches(RequestDto request)
{
//TODO: Refactor
//Convert the list of selected list to the string of filter
var codes = GetCompetitionsCodes(request.LeaguesChecked);
var matchProvider = MatchProvider.Create().With(_httpClient).Build();
var matches = await matchProvider.GetAllMatches("competitions", codes, "dateFrom", request.StartingDate.ToString("yyyy-MM-dd"), "dateTo", request.EndingDate.ToString("yyyy-MM-dd"));
var result = new List <ScheduledMatchDto>();
foreach (var match in matches)
{
Enum.TryParse(match.Status.ToUpper(), out Status state);
ScoreResult scoreResult = new ScoreResult(match.Score.FullTime.HomeTeam, match.Score.FullTime.AwayTeam);
result.Add(new ScheduledMatchDto(
match.HomeTeam.Name,
match.AwayTeam.Name,
match.UtcDate,
state,
scoreResult,
(int)match.Matchday,
new LeagueDto(match.Competition.Name, match.Competition.Area.Name)
));
}
//Filter matches with selected status
result = result.Where(m => request.StatusChecked.Contains(m.Status)).ToList();
return(result);
}
public void AddRequestData(RequestDto data)
{
using (SqlConnection connection = new SqlConnection(_connectionString))
{
SqlCommand cmd = new SqlCommand("spAddRequest", connection)
{
CommandType = CommandType.StoredProcedure
};
cmd.Parameters.AddWithValue("@UserId", data.UserId);
cmd.Parameters.AddWithValue("@ResponseCode", data.ResponseCode);
cmd.Parameters.AddWithValue("@RequestMethod", data.RequestMethod);
cmd.Parameters.AddWithValue("@RequestPath", data.RequestPath);
cmd.Parameters.AddWithValue("@RequestTime", data.RequestTime);
cmd.Parameters.AddWithValue("@ResponseTime", data.ResponseTime);
cmd.Parameters.AddWithValue("@RequestProtocol", data.RequestProtocol);
SqlParameter requestBody = new SqlParameter("@RequestBody", SqlDbType.NVarChar)
{
Value = (object)data.RequestBody ?? DBNull.Value
};
cmd.Parameters.Add(requestBody);
SqlParameter responseBody = new SqlParameter("@ResponseBody", SqlDbType.NVarChar)
{
Value = (object)data.ResponseBody ?? DBNull.Value
};
cmd.Parameters.Add(responseBody);
connection.Open();
cmd.ExecuteNonQuery();
connection.Close();
}
}
public async Task<ServiceResult> SubmitRequest(RequestDto model, MemberDto requestor)
{
var result = new ServiceResult();
try
{
model.CreatedByMember = requestor.MemberId;
if (model.DueEndDt <= model.DueStartDt)
{
result.Success = false;
result.Messages = new List<string> { "End date is bigger than start date. Please change." };
return result;
}
var activeStatuses = new[] { RequestStatus.Locked, RequestStatus.Started, RequestStatus.Pending };
var memberRequests = (await DbContext.GetRequestsByMemberIdAsync(requestor.MemberId)).Where(c => c.Status != RequestStatus.Closed).ToList();
if (memberRequests.Any(memberRequest => (model.DueStartDt >= memberRequest.DueStartDt && model.DueStartDt <= memberRequest.DueEndDt ||
model.DueEndDt > memberRequest.DueStartDt && model.DueEndDt <= memberRequest.DueEndDt) && activeStatuses.Contains(memberRequest.Status)))
{
result.Success = false;
result.Messages = new List<string> { "You have another request with crossing time interval please change time intervals." };
return result;
}
var member = await DbContext.GetMemberByMemberIdAsync(model.CreatedByMember);
var assignedToProvider = await DbContext.GetProviderByProviderIdAsync(model.AssignedProviderId);
var request = new Request
{
Comment = model.Comment,
AssignedToProviderId = model.AssignedProviderId,
AssignedToProvider = assignedToProvider,
CreatedByMember = model.CreatedByMember,
CreatedDt = DateTime.Now,
DueEndDt = model.DueEndDt,
DueStartDt = model.DueStartDt,
MemberCreator = member,
Status = model.Status,
ModifiedDt = DateTime.Now,
RequestDescription = model.RequestDescription,
};
await DbContext.SaveRequest(request);
result.Success = true;
result.Messages = new List<string> { "Your request is successfully submited." };
}
catch (Exception ex)
{
result.Success = false;
result.Messages = new List<string> { "Internal server error.", $"Exception is: {ex.ToString()}" };
}
return result;
}
public async Task<ActionResult> SubmitRequest(RequestDto model)
{
var reult = await _hcSerivice.SubmitRequest(model, await _hcSerivice.GetMemberByUserIdAsync(CurrentUser.Id));
return Json(reult);
}
