public async Task <Cubicle> UpdateAsync(Cubicle item)
{
_context.Cubicles.Update(item);
await _context.SaveChangesAsync();
_context.Entry(item).State = EntityState.Detached;
return(item);
}
public async Task <Cubicle> CreateOneAsync(Cubicle item)
{
await _context.Cubicles.AddAsync(item);
await _context.SaveChangesAsync();
_context.Entry(item).State = EntityState.Detached;
return(item);
}
public string Solve(string[] input)
{
var waitingRoom = new Cubicle(1, 1);
var favoriteNumber = int.Parse(input[0]);
var maze = new Maze(favoriteNumber);
var flooder = new Flooder();
var flooded = flooder.Flood(maze, waitingRoom, 50);
return(flooded.Count.ToString());
}
public string Solve(string[] input)
{
var waitingRoom = new Cubicle(1, 1);
var destination = new Cubicle(31, 39);
var favoriteNumber = int.Parse(input[0]);
var maze = new Maze(favoriteNumber);
var navigator = new Navigator(maze);
var path = navigator.ShortestPath(waitingRoom, destination);
return((path.Count() - 1).ToString());
}
public static GetCubicleDto FromCubicle(Cubicle cubicle)
{
return(new GetCubicleDto()
{
Id = cubicle.Id,
Description = cubicle.Description,
Campus = cubicle.CampusId,
Pavilion = cubicle.Pavilion,
Code = cubicle.Code,
TotalSeats = cubicle.TotalSeats
});
}
public void OnPointerUp(PointerEventData eventData)
{
drag = false;
if (cubicle != null)
{
Cubicle c = cubicle.GetComponent <Cubicle>();
if (c.image != null)
{
RectTransform anotherRect = c.image.GetComponent <RectTransform>();
anotherRect.SetParent(root);
anotherRect.localPosition = new Vector3(anotherRect.localPosition.x, anotherRect.localPosition.y, 0f);
root.sizeDelta = new Vector3(root.sizeDelta.x, root.sizeDelta.y + (rect.sizeDelta.y + 240));
c.image.SetActive(true);
}
else
{
TelarañaManager.instance.images++;
}
c.image = gameObject;
cubicle.GetComponent <RectTransform>().GetChild(0).gameObject.GetComponent <Image>().sprite = image.sprite;
gameObject.SetActive(false);
if (TelarañaManager.instance.images == 4)
{
TelarañaManager.instance.images = 0;
TelarañaManager.instance.SetCircle();
}
}
else
{
rect.SetParent(root);
rect.SetSiblingIndex(lastIndex);
rect.localPosition = new Vector3(rect.localPosition.x, rect.localPosition.y, 0f);
root.sizeDelta = new Vector3(root.sizeDelta.x, root.sizeDelta.y + (rect.sizeDelta.y + 240));
}
}
public override bool PrePerform()
{
if (inventory.Contains <Cubicle>())
{
cubicle = inventory.FindResource <Cubicle>();
target = cubicle.gameObject;
return(true);
}
else
{
throw new Exception("Missing a cubicle here");
}
return(false);
}
public static PendingAndAcceptedCurrentRequestResponseDto FromSharedSpace(
Request request, Cubicle cubicle, Publication publication, Resource resource,
SharedSpace sharedSpace, Constant state, Repository.Dto.Campus campus
)
{
return(new PendingAndAcceptedCurrentRequestResponseDto()
{
Id = request.Id,
CampusName = campus.Name,
CubicleCode = cubicle.Code,
PublicationDescription = publication.Description,
StartTime = sharedSpace.StartTime,
EndTime = sharedSpace.EndTime,
ResourceName = resource == null ? null : resource.Name,
State = state.Name
});
}
public override bool PrePerform()
{
if (GWorld.Instance().Waiting.IsEmpty())
{
return(false);
}
patient = GWorld.Instance().Waiting.Remove();
if (patient == null)
{
return(false);
}
target = patient.gameObject;
cubicle = GWorld.Instance().Cubicles.Remove();
if (cubicle == null)
{
GWorld.Instance().Waiting.Add(patient);
return(false);
}
inventory.AddItem(cubicle);
GWorld.Instance().WorldStates.IncrementState(AgentStates.Waiting, -1);
return(true);
}
public static GetByFiltersResponseDto FromPublicationAndCubicle(Publication publication, Cubicle cubicle)
{
var st = publication.StartTime;
var startTime = new DateTime(st.Year, st.Month, st.Day, st.Hour, st.Minute, st.Second, DateTimeKind.Local);
var et = publication.EndTime;
var endTime = new DateTime(et.Year, et.Month, et.Day, et.Hour, et.Minute, et.Second, DateTimeKind.Local);
return(new GetByFiltersResponseDto
{
Id = publication.Id,
CampusId = cubicle.CampusId,
CubicleCode = cubicle.Code,
Description = publication.Description,
PublicationStartTime = startTime,
PublicationEndTime = endTime
});
}
public async Task <GetCubicleDto> CreateOneAsync(CreateCubicleDto createCubicle)
{
// Validando que el cubiculo no exista en la base de datos
var found = await _cubicleRepository.FindOneByCodeAsync(createCubicle.Code);
if (found != null)
{
throw new BadRequestException($"Cubicle with code {createCubicle.Code} already exists");
}
var resources = new List <Resource>();
foreach (var resourceId in createCubicle.ResourcesIds)
{
// Validando la existencia de cada recurso
var resource = await _resourceRepository.FindOneByIdAsync(resourceId);
if (resource == null)
{
throw new BadRequestException($"Resource with id {resourceId} was not found");
}
// Validando que el recurso no le pertenezca a otro cubículo
if (resource.CubicleId.HasValue)
{
throw new BadRequestException($"The resource with id {resource.Id} already has a Cubicle");
}
resources.Add(resource);
}
// Se valida la existencia del campus
var campus = await _campusRepository.GetOneByIdAsync(createCubicle.CampusId);
if (campus == null)
{
throw new BadRequestException($"CampusId with id {createCubicle.CampusId} was not found");
}
var cubicle = new Cubicle
{
Code = createCubicle.Code,
Description = createCubicle.Description,
CampusId = campus.Id,
Pavilion = createCubicle.PavilionId,
IsActive = createCubicle.IsActive,
CreatedAt = new DateTime(),
UpdatedAt = new DateTime(),
TotalSeats = createCubicle.TotalSeats,
};
await _cubicleRepository.CreateOneAsync(cubicle);
foreach (var resource in resources)
{
resource.CubicleId = cubicle.Id;
await _resourceRepository.UpdateOneByIdAsync(resource.Id, resource);
}
await _context.SaveChangesAsync();
return(GetCubicleDto.FromCubicle(cubicle));
}
