private void LoadSharedSpaces()
{
EntityListResult <SharedSpace> sharedSpaces = null;
try
{
sharedSpaces = EntityService.GetInstance().Get <SharedSpace>(new SiteContext());
}
catch (Exception)
{
}
if (sharedSpaces == null)
{
SharedSpace defaultSharedSpace = new SharedSpace();
defaultSharedSpace.Id = 1001;
defaultSharedSpace.Name = "Default shared space";
sharedSpaces = new EntityListResult <SharedSpace>();
sharedSpaces.data = new List <SharedSpace>();
sharedSpaces.data.Add(defaultSharedSpace);
sharedSpaces.total_count = 1;
}
FillCombo(cmbSharedSpace, sharedSpaces.data);
//LoadWorkspaces(((SharedSpace)cmbSharedSpace.SelectedItem).Id);
}
public async Task <IActionResult> AddToBasket(ProductToReturnDto product)
{
var service = new SharedSpace(_httpContextAccessor, _mapper);
await service.AddProductToBasket(product);
return(RedirectToAction("Index", "Products"));
}
public async Task <bool> IsAvaliableSharedSpace(SharedSpace sharedResource)
{
// Si el recurso compartido es un asiento, entonces esta disponible
if (!sharedResource.ResourceId.HasValue)
{
return(false);
}
// Se debe comprobar si la hora de inicio es igual
// Si se trata de la misma publicacion tambien
// Y si es un recurso utilizado
var item = await _context.SharedSpaces
.AsNoTracking()
.FirstOrDefaultAsync(s => s.StartTime.Equals(sharedResource.StartTime) &&
s.PublicationId.Equals(sharedResource.PublicationId) &&
s.ResourceId.Equals(sharedResource.ResourceId)
);
if (item == null)
{
return(false);
}
else
{
return(true);
}
}
public async Task <IActionResult> DeleteProduct(int id)
{
ProductToReturnDto product = new ProductToReturnDto();
if (ModelState.IsValid)
{
using (var httpClient = new HttpClient())
{
using (var response = await httpClient.GetAsync($"https://localhost:5001/api/products/getproduct/{id}"))
{
string apiResponse = await response.Content.ReadAsStringAsync();
product = JsonConvert.DeserializeObject <ProductToReturnDto>(apiResponse);
}
}
if (product == null)
{
TempData["msgAccount"] = "Product Not Found";
return(RedirectToAction("Index", "Products"));
}
}
var sharedMethod = new SharedSpace(_httpContextAccessor, _mapper);
TempData["types"] = await sharedMethod.FetchProductTypes();
TempData["brands"] = await sharedMethod.FetchProducBrands();
await PublicMethods();
return(View("DeleteProduct", product));
}
public async Task <SharedSpace> UpdateAsync(SharedSpace sharedResource)
{
_context.SharedSpaces.Update(sharedResource);
await _context.SaveChangesAsync();
_context.Entry(sharedResource).State = EntityState.Detached;
return(sharedResource);
}
public async Task <IActionResult> Index()
{
var service = new SharedSpace(_httpContextAccessor, _mapper);
var result = await service.FetchBasket();
await PublicMethods();
return(View(result));
}
public static SharedSpaceDTO FromRequestEntity(SharedSpace sharedSpace)
{
Console.WriteLine("llego?");
return(new SharedSpaceDTO()
{
ShareSpaceId = sharedSpace.Id,
StartTime = sharedSpace.StartTime,
EndTime = sharedSpace.EndTime,
ResourceId = sharedSpace.ResourceId
});
}
public async Task <bool> answerRequest(AnswerRequestDTO answer)
{
Request request = await requestRepository.GetOneByIdAsync(answer.RequestId);
if (request == null || request.ConstantId != RequestStatus.Waiting)
{
throw new BadRequestException("No existe ese request");
}
if (!answer.answer)
{
request.ConstantId = RequestStatus.Denied;
await requestRepository.UpdateOneAsync(request);
return(true);
}
else
{
if (request.ConstantId != RequestStatus.Waiting)
{
throw new BadRequestException("Esta solicitud ya esta respondida");
}
if (request.SharedSpace.IsOccupied)
{
throw new BadRequestException("Esta ocupado el espacio compartido que se solicita");
}
request.ConstantId = RequestStatus.Accepted;
SharedSpace SharedSpace = await sharedSpaceRepository.FindOneByIdAsync(request.SharedSpace.Id);
foreach (var item in SharedSpace.Requests)
{
if (item.ConstantId == RequestStatus.Waiting)
{
if (item.Id != answer.RequestId)
{
item.ConstantId = RequestStatus.Denied;
}
else
{
item.ConstantId = RequestStatus.Accepted;
}
await requestRepository.UpdateOneAsync(item);
}
}
SharedSpace.IsOccupied = true;
await sharedSpaceRepository.UpdateAsync(SharedSpace);
}
return(true);
}
public async Task <IActionResult> IncrementItemQuantity(int id)
{
var service = new SharedSpace(_httpContextAccessor, _mapper);
var result = await service.FetchBasket();
var item = result.Items.FindIndex(x => x.Id == id);
result.Items[item].Quantity++;
var customerBasket = _mapper.Map <CustomerBasket, CustomerBasketDto>(result);
await service.UpdateBasketMVC(customerBasket);
await PublicMethods();
return(View("Index", result));
}
public async Task <IActionResult> RemoveItem(int id)
{
var service = new SharedSpace(_httpContextAccessor, _mapper);
var result = await service.FetchBasket();
var item = result.Items.Where(x => x.Id == id).FirstOrDefault();
result.Items.Remove(item);
var customerBasket = _mapper.Map <CustomerBasket, CustomerBasketDto>(result);
await service.UpdateBasketMVC(customerBasket);
await PublicMethods();
return(View("Index", result));
}
public async Task <Tuple <object, object, object, object> > PublicMethods()
{
var service = new SharedSpace(_httpContextAccessor, _mapper);
TempData["types"] = await service.FetchProductTypes();
TempData["brands"] = await service.FetchProducBrands();
var basketProducts = await service.FetchBasket();
TempData["basketItems"] = basketProducts.Items.Count;
TempData["role"] = await service.FetchUserRole();
return(Tuple.Create(TempData["types"], TempData["brands"], TempData["basketItems"], TempData["role"]));
}
public static SharedSpaceResponseDto FromEntity(SharedSpace entity)
{
return(new SharedSpaceResponseDto
{
Id = entity.Id,
StartTime = entity.StartTime,
EndTime = entity.EndTime,
CreatedAt = entity.CreatedAt,
UpdatedAt = entity.UpdatedAt,
IsActive = entity.IsActive,
IsOccupied = entity.IsOccupied,
PublicationId = entity.PublicationId,
ResourceId = entity.ResourceId
});
}
public SharedSpace CreateSharedSpace()
{
SharedSpace sharedSpace = new SharedSpace();
sharedSpace.ResourceId = this.ResourceId;
sharedSpace.CreatedAt = DateTime.Now;
sharedSpace.EndTime = this.EndTime;
sharedSpace.CreatedAt = DateTime.Now;
sharedSpace.IsActive = true;
sharedSpace.IsOccupied = false;
sharedSpace.StartTime = this.StartTime;
sharedSpace.UpdatedAt = DateTime.Now;
return(sharedSpace);
}
public async Task <IActionResult> AddProduct()
{
var sharedMethod = new SharedSpace(_httpContextAccessor, _mapper);
TempData["types"] = await sharedMethod.FetchProductTypes();
TempData["brands"] = await sharedMethod.FetchProducBrands();
//var x = await sharedMethod.FetchProducBrands();
//TempData["brandlist"] = x.Select(x => x.Name).FirstOrDefault();
await PublicMethods();
CreateProductBrandSelectlist();
CreateProductTypeSelectlist();
return(View("AddProduct"));
}
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 async Task <IActionResult> CreateOrderMVC(OrderDto input)
{
_httpContextAccessor.HttpContext.Session.SetString("deliveryId", input.DeliveryMethodId.ToString());
var service = new SharedSpace(_httpContextAccessor, _mapper);
var createdModel = await service.CreateOrderMVC(input);
var model = _mapper.Map <Order, OrderToReturnDto>(createdModel);
model.Total = createdModel.GetTotal();
await PublicMethods();
if (createdModel.Id == 0)
{
return(Redirect("https://localhost:44325/"));
}
return(View("Payment", model));
}
public void ShareSpace(string spaceToShare, string emailToShareIt)
{
SharedSpace shareSpace = new SharedSpace();
shareSpace.InvitationCode = Guid.NewGuid().ToString("N");
shareSpace.DateSharedStarted = DateTime.Now;
shareSpace.Expiration = DateTime.Now.AddYears(DefaultShareExpirationInYears);
shareSpace.Active = true;
shareSpace.SpaceName = spaceToShare;
shareSpace.EmailAddress = emailToShareIt;
var sharedSpaces = sharedSpaceGateway.GetSharedSpaces(spaceToShare, emailToShareIt);
if (sharedSpaces.Count() > 0)
{
throw new InvalidOperationException("Cannot share the a space with a user twice.");
}
this.MySpacesShared.Add(shareSpace);
}
public async Task <bool> cancelRequest(CancelRequestDTO cancel)
{
var request = await requestRepository.GetOneByIdAsync(cancel.RequestId);
if (request == null)
{
throw new BadRequestException($"Request with id {cancel.RequestId} was not found");
}
if (request.ConstantId == RequestStatus.Denied)
{
throw new BadRequestException($"Request with id {cancel.RequestId} is denied");
}
if (request.ConstantId == RequestStatus.Confirmed)
{
throw new BadRequestException($"Request with id {cancel.RequestId} is confirmed");
}
if (request.ConstantId == RequestStatus.Canceled)
{
throw new BadRequestException($"Request with id {cancel.RequestId} is canceled");
}
request.ConstantId = RequestStatus.Canceled;
if (request.ConstantId != RequestStatus.Accepted)
{
await requestRepository.UpdateOneAsync(request);
}
else
{
Console.WriteLine("Requeste aceptado");
SharedSpace sharedSpace = await sharedSpaceRepository.FindOneByIdAsync(request.SharedSpaceId);
sharedSpace.IsOccupied = false;
await requestRepository.UpdateOneAsync(request);
await sharedSpaceRepository.UpdateAsync(sharedSpace);
Console.WriteLine("ShareSpace ya no ocupado");
}
return(true);
}
public async Task <Tuple <object, object, object, object> > PublicMethods()
{
var service = new SharedSpace(_httpContextAccessor, _mapper);
TempData["types"] = await service.FetchProductTypes();
TempData["brands"] = await service.FetchProducBrands();
var basketProducts = await service.FetchBasket();
TempData["basketItems"] = basketProducts.Items.Count;
decimal total = 0;
foreach (var pro in basketProducts.Items)
{
total = total + (pro.Price * pro.Quantity);
TempData["total"] = total;
}
return(Tuple.Create(TempData["types"], TempData["brands"], TempData["basketItems"], TempData["total"]));
}
public async Task <IActionResult> CheckoutBasket()
{
var token = _httpContextAccessor.HttpContext.Session.GetString("JWToken");
var basketId = _httpContextAccessor.HttpContext.Session.GetString("basketId");
var email = _httpContextAccessor.HttpContext.Session.GetString("Email");
if (token == null || token == "")
{
TempData["NotLoggedin"] = "You must loggedIn ...";
return(RedirectToAction("Index", "Account"));
}
Address address = new Address();
var deliveryMethods = new List <DeliveryMethod>();
var myModel = new Basket_Order_vm();
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
using (var response = await httpClient.GetAsync("https://localhost:5001/api/account/address"))
{
string apiResponse = await response.Content.ReadAsStringAsync();
address = JsonConvert.DeserializeObject <Address>(apiResponse);
}
}
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
using (var response = await httpClient.GetAsync("https://localhost:5001/api/orders/deliverymethods"))
{
string apiResponse = await response.Content.ReadAsStringAsync();
deliveryMethods = JsonConvert.DeserializeObject <List <DeliveryMethod> >(apiResponse);
ViewData["methods"] = deliveryMethods;
}
}
var service = new SharedSpace(_httpContextAccessor, _mapper);
var myBasket = await service.FetchBasket();
myModel.customerBasketDto = _mapper.Map <CustomerBasket, CustomerBasketDto>(myBasket);
myModel.OrderToReturnDto.ShipToAddress = new Address(address.FirstName, address.LastName, address.Street, address.City, address.State, address.Zipcode);
myModel.OrderToReturnDto.DeliveryMethod = myBasket.DeliveryMethodId.ToString();
myModel.OrderToReturnDto.OrderDate = DateTimeOffset.Now;
myModel.OrderToReturnDto.Status = OrderStatus.Pending.ToString();
myModel.OrderToReturnDto.BuyerEmail = email;
decimal subTotal = 0;
foreach (var item in myBasket.Items)
{
subTotal += item.Price * item.Quantity;
}
myModel.OrderToReturnDto.Subtotal = subTotal;
myModel.OrderToReturnDto.ShippingPrice = 0;
myModel.OrderToReturnDto.Total = subTotal + myModel.OrderToReturnDto.ShippingPrice;
await PublicMethods();
return(View("Index", myModel));
}
public ConsoleSharedSpace(SharedSpace share)
{
_share = share;
}
public PckViewForm()
{
InitializeComponent();
#region shared space information
var consoleSharedSpace = new ConsoleSharedSpace(new SharedSpace());
console = consoleSharedSpace.GetNewConsole();
console.FormClosing += delegate(object sender, FormClosingEventArgs e)
{
e.Cancel = true;
console.Hide();
};
FormClosed += (sender, e) => console.Close();
sharedSpace = SharedSpace.Instance;
sharedSpace.GetObj("PckView", this);
sharedSpace.GetObj("AppDir", Environment.CurrentDirectory);
sharedSpace.GetObj("CustomDir", Environment.CurrentDirectory + "/custom");
sharedSpace.GetObj("SettingsDir", Environment.CurrentDirectory + "/settings");
xConsole.AddLine("Current directory: " + sharedSpace["AppDir"]);
xConsole.AddLine("Custom directory: " + sharedSpace["CustomDir"].ToString());
#endregion
_totalViewPck = new TotalViewPck();
_totalViewPck.Dock = DockStyle.Fill;
DrawPanel.Controls.Add(_totalViewPck);
_totalViewPck.View.DoubleClick += new EventHandler(doubleClick);
_totalViewPck.ViewClicked += new PckViewMouseClicked(viewClicked);
_totalViewPck.XCImageCollectionSet += new XCImageCollectionHandler(v_XCImageCollectionSet);
_totalViewPck.ContextMenu = makeContextMenu();
SaveMenuItem.Visible = false;
sharedSpace["Palettes"] = new Dictionary <string, Palette>();
palMI = new Dictionary <Palette, MenuItem>();
AddPalette(Palette.UFOBattle, miPalette);
AddPalette(Palette.UFOGeo, miPalette);
AddPalette(Palette.UFOGraph, miPalette);
AddPalette(Palette.UFOResearch, miPalette);
AddPalette(Palette.TFTDBattle, miPalette);
AddPalette(Palette.TFTDGeo, miPalette);
AddPalette(Palette.TFTDGraph, miPalette);
AddPalette(Palette.TFTDResearch, miPalette);
currPal = Palette.UFOBattle;
// currPal = Palette.TFTDBattle;
palMI[currPal].Checked = true; // kL_ufoPalette
_totalViewPck.Pal = currPal; // kL_ufoPalette
editor = new Editor(null);
editor.Closing += new CancelEventHandler(editorClosing);
if (editor != null) // kL_ufoPalette
{
editor.Palette = currPal; // kL_ufoPalette
}
RegistryInfo ri = new RegistryInfo(this, "PckView");
ri.AddProperty("FilterIndex");
ri.AddProperty("SelectedPalette");
if (!File.Exists("hq2xa.dll"))
{
miHq2x.Visible = false;
}
loadedTypes = new LoadOfType <IXCImageFile>();
loadedTypes.OnLoad += new LoadOfType <IXCImageFile> .TypeLoadDelegate(loadedTypes_OnLoad);
sharedSpace["ImageMods"] = loadedTypes.AllLoaded;
// loadedTypes.OnLoad += new LoadOfType<IXCFile>.TypeLoadDelegate(sortLoaded);
loadedTypes.LoadFrom(Assembly.GetExecutingAssembly());
loadedTypes.LoadFrom(Assembly.GetAssembly(typeof(XCom.Interfaces.IXCImageFile)));
if (Directory.Exists(sharedSpace["CustomDir"].ToString()))
{
//Console.WriteLine("Custom directory exists: " + sharedSpace["CustomDir"].ToString());
xConsole.AddLine("Custom directory exists: " + sharedSpace["CustomDir"].ToString());
foreach (string s in Directory.GetFiles(sharedSpace["CustomDir"].ToString()))
{
if (s.EndsWith(".dll"))
{
xConsole.AddLine("Loading dll: " + s);
loadedTypes.LoadFrom(Assembly.LoadFrom(s));
}
else if (s.EndsWith(xcProfile.PROFILE_EXT))
{
foreach (xcProfile ip in ImgProfile.LoadFile(s))
{
loadedTypes.Add(ip);
}
}
}
}
osFilter = new OpenSaveFilter();
osFilter.SetFilter(IXCImageFile.Filter.Open);
openDictionary = new Dictionary <int, IXCImageFile>();
saveDictionary = new Dictionary <int, IXCImageFile>();
osFilter.SetFilter(IXCImageFile.Filter.Open);
string filter = loadedTypes.CreateFilter(osFilter, openDictionary);
openFile.Filter = filter;
}
