public IActionResult Save(PickupPoint pickupPoint)
{
db = new MarketBotDbContext();
//добавление нового
if (pickupPoint != null && pickupPoint.Name != null && pickupPoint.Id < 1)
{
db.PickupPoint.Add(pickupPoint);
db.SaveChanges();
return(RedirectToAction("Index"));
}
//редактирование
if (pickupPoint != null && pickupPoint.Name != null && pickupPoint.Id > 0)
{
//var old = db.PickupPoint.Find(pickupPoint.Id);
db.PickupPoint.Update(pickupPoint);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
return(NotFound());
}
}
private void UpdateDriverNoteWithAirportInformation(PickupPoint pickupPoint, int fee, string terminal)
{
var localize = this.Services().Localize;
var sb = new StringBuilder();
if (Note.Length > 0)
{
sb.AppendLine(Note);
}
sb.Append(localize["BookingAirportDetails"], _pickupAddress.FullAddress, AirlineName, FlightNumber, SelectedPickupPointName);
if (pickupPoint != null && pickupPoint.AdditionalFee != string.Empty && fee > 0)
{
sb.Append(localize["BookingAirportDetailsFee"], pickupPoint.AdditionalFee);
}
if (terminal.HasValue())
{
sb.Append(localize["BookingAirportDetailsTerminal"], terminal);
}
Note = sb.ToString();
}
bool PickupItem(PickupPoint pickupPoint)
{
if (IsHoldingItem())
{
return(false);
}
if (!pickupPoint.GetItem())
{
return(false);
}
currentItem = pickupPoint.GetItem();
pickupPoint.RemoveItem();
currentItem.transform.SetParent(itemHolder);
currentItem.transform.SetPositionAndRotation(itemHolder.transform.position, Quaternion.identity);
currentItem.transform.localScale = Vector3.one;
SpriteRenderer spriteRenderer = currentItem.GetComponent <SpriteRenderer>();
itemSortingOrderCache = spriteRenderer.sortingOrder;
spriteRenderer.sortingOrder = itemHolderSortingOrder;
OnPimPickedUpItemEvent(this, currentItem.GetComponent <Item>());
return(true);
}
public void Init()
{
Airlines = new List <ListItem>
{
new ListItem {
Display = NoAirlines, Id = -1
},
};
AirlineId = -1;
RaisePropertyChanged(() => AirlineName);
var pickupPoint = new PickupPoint()
{
Name = PUCurbSide,
AdditionalFee = string.Empty
};
PickupPointItems = new List <KeyValuePair <int, PickupPoint> >
{
new KeyValuePair <int, PickupPoint>(0, pickupPoint)
};
_pickupPoints = PickupPointItems
.Select(item => new ListItem
{
Display = item.Value.Name,
Id = item.Key
})
.ToList();
SelectedPickupPointsId = 0;
RaisePropertyChanged(() => SelectedPickupPointName);
}
public async Task <int> GetPortIdFromPickupPointId(ReservationWriteResource record)
{
PickupPoint pickupPoint = await context.PickupPoints
.Include(x => x.CoachRoute)
.FirstOrDefaultAsync(x => x.Id == record.PickupPointId);
return(pickupPoint.CoachRoute.PortId);
}
public IActionResult Create()
{
PickupPoint pickupPoint = new PickupPoint
{
Enable = true,
Name = ""
};
return(View("Editor", pickupPoint));
}
void HighlightInteractableTiles(Pim pim, Item item)
{
List <GameObject> gos = GameObject.FindGameObjectsWithTag("PickupPoint").ToList <GameObject>();
List <PickupPoint> pickupPoints = new List <PickupPoint>();
foreach (var go in gos)
{
PickupPoint pickupPoint = go.GetComponent <PickupPoint>();
if (pickupPoint)
{
pickupPoints.Add(pickupPoint);
}
}
foreach (PickupPoint pickupPoint in pickupPoints)
{
//if (pickupPoint.CanDropHere()) {
if (pickupPoint.IsOccupied())
{
GameObject recipesObj = GameObject.FindGameObjectWithTag("Recipes");
Recipes recipes = recipesObj.GetComponent <Recipes>();
GameObject itemObject = pickupPoint.GetItem();
if (itemObject != null)
{
Item anItem = itemObject.GetComponent <Item>();
if (anItem != null)
{
ItemType itemType = anItem.itemType;
Item currentItemObj = currentItem.GetComponent <Item>();
if (currentItem != null)
{
Recipes.Recipe foundRecipe = recipes.GetRecipe(itemType, currentItemObj.itemType);
if (foundRecipe.output != null)
{
GameObject go = Instantiate(mergableEffect, pickupPoint.gameObject.transform.position, Quaternion.identity);
highlightEffectCache.Add(go);
go.transform.SetParent(itemObject.transform);
}
}
}
}
}
else
{
if (pickupPoint.CanDropHere())
{
GameObject go = Instantiate(highlightEffect, pickupPoint.gameObject.transform.position, Quaternion.identity);
highlightEffectCache.Add(go);
}
}
//}
}
}
/// <summary>
/// Deletes a delivery date
/// </summary>
/// <param name="deliveryDate">The delivery date</param>
public virtual void DeletePickupPoint(PickupPoint pickupPoint)
{
if (pickupPoint == null)
{
throw new ArgumentNullException("pickupPoint");
}
_pickupPointsRepository.Delete(pickupPoint);
_cacheManager.RemoveByPattern(PICKUPPOINTS_PATTERN_KEY);
//event notification
_eventPublisher.EntityDeleted(pickupPoint);
}
/// <summary>
/// Updates the pickup point.
/// </summary>
/// <param name="pickupPoint">The pickup point.</param>
/// <returns>The updated pickup point.</returns>
public PickupPoint UpdatePickupPoint(PickupPoint pickupPoint)
{
var existingPickupPoint = this.GetPickupPoint(pickupPoint.Id);
if (existingPickupPoint != null)
{
DataModelUpdater.UpdatePickupPoint(pickupPoint, ref existingPickupPoint);
this.context.PickupPoints.Update(existingPickupPoint);
this.context.SaveChanges();
}
return(existingPickupPoint);
}
/// <summary>
/// Deletes a delivery date
/// </summary>
/// <param name="deliveryDate">The delivery date</param>
public virtual async Task DeletePickupPoint(PickupPoint pickupPoint)
{
if (pickupPoint == null)
{
throw new ArgumentNullException("pickupPoint");
}
await _pickupPointsRepository.DeleteAsync(pickupPoint);
await _cacheManager.RemoveByPattern(PICKUPPOINTS_PATTERN_KEY);
//event notification
await _mediator.EntityDeleted(pickupPoint);
}
void OnPickupPointRecievedItemEvent(PickupPoint pickupPoint, Item item)
{
List <GameObject> destroyTheseObjects = new List <GameObject>();
bool isAlreadyCached = false;
foreach (GameObject highlightedObject in highlightEffectCache)
{
if (highlightedObject == null)
{
destroyTheseObjects.Add(highlightedObject);
}
else
{
if (highlightedObject.transform.parent)
{
if (highlightedObject.transform.parent.gameObject == item.gameObject)
{
isAlreadyCached = true;
break;
}
}
}
}
if (!isAlreadyCached)
{
if (currentItem != null)
{
GameObject recipesObj = GameObject.FindGameObjectWithTag("Recipes");
Recipes recipes = recipesObj.GetComponent <Recipes>();
Item currentItemObj = currentItem.GetComponent <Item>();
Recipes.Recipe foundRecipe = recipes.GetRecipe(item.itemType, currentItemObj.itemType);
if (foundRecipe.output != null)
{
GameObject go = Instantiate(mergableEffect, item.transform.position, Quaternion.identity);
highlightEffectCache.Add(go);
go.transform.SetParent(item.gameObject.transform);
}
}
}
foreach (GameObject go in destroyTheseObjects)
{
highlightEffectCache.Remove(go);
Destroy(go);
}
}
/// <summary>
/// Updates the warehouse
/// </summary>
/// <param name="warehouse">Warehouse</param>
public virtual void UpdatePickupPoint(PickupPoint pickupPoint)
{
if (pickupPoint == null)
{
throw new ArgumentNullException("pickupPoint");
}
_pickupPointsRepository.Update(pickupPoint);
//clear cache
_cacheManager.RemoveByPattern(WAREHOUSES_PATTERN_KEY);
//event notification
_eventPublisher.EntityUpdated(pickupPoint);
}
/// <summary>
/// Inserts a warehouse
/// </summary>
/// <param name="warehouse">Warehouse</param>
public virtual async Task InsertPickupPoint(PickupPoint pickupPoint)
{
if (pickupPoint == null)
{
throw new ArgumentNullException(nameof(pickupPoint));
}
await _pickupPointsRepository.InsertAsync(pickupPoint);
//clear cache
await _cacheBase.RemoveByPrefix(CacheKey.PICKUPPOINTS_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(pickupPoint);
}
/// <summary>
/// Updates the warehouse
/// </summary>
/// <param name="warehouse">Warehouse</param>
public virtual async Task UpdatePickupPoint(PickupPoint pickupPoint)
{
if (pickupPoint == null)
{
throw new ArgumentNullException("pickupPoint");
}
await _pickupPointsRepository.UpdateAsync(pickupPoint);
//clear cache
await _cacheManager.RemoveByPattern(WAREHOUSES_PATTERN_KEY);
//event notification
await _mediator.EntityUpdated(pickupPoint);
}
/// <summary>
/// Inserts a warehouse
/// </summary>
/// <param name="warehouse">Warehouse</param>
public virtual async Task InsertPickupPoint(PickupPoint pickupPoint)
{
if (pickupPoint == null)
{
throw new ArgumentNullException("pickupPoint");
}
await _pickupPointsRepository.InsertAsync(pickupPoint);
//clear cache
_cacheManager.RemoveByPattern(PICKUPPOINTS_PATTERN_KEY);
//event notification
await _eventPublisher.EntityInserted(pickupPoint);
}
IEnumerator SlideItemToPickupPoint(GameObject item, int pickupPointIndex, bool forceIgnoreDropEffect)
{
while (true)
{
if (item == null)
{
break;
}
if (pickupPointIndex >= pickupPoints.Length)
{
break;
}
PickupPoint pickupPoint = pickupPoints[pickupPointIndex];
if (item.transform.position.x >= pickupPoint.transform.position.x)
{
// The current Item have reached the first pickupPoint!
pickupPoint.AddItem(item, forceIgnoreDropEffect);
item = null;
AudioManager.instance.PlaySfx("Blip_Select17");
EZCameraShake.CameraShaker.Instance.ShakeOnce(0.2f, 5.0f, 0.2f, 0.2f);
break;
}
else
{
if (item.transform.position.x >= pickupPoint.transform.position.x - 1)
{
if (pickupPoint.GetItem() != null)
{
int nextPickupPointIndex = pickupPointIndex + 1;
StartCoroutine(SlideItemToPickupPoint(pickupPoint.GetItem(), nextPickupPointIndex, pickupPoint.forceIgnoreDropEffectOnNextPickupPoint));
pickupPoint.RemoveItem();
}
}
Vector3 currentItemPos = item.transform.position;
currentItemPos.x += Time.deltaTime;
item.transform.position = currentItemPos;
}
// Yield execution of this coroutine and return to the main loop until next frame
yield return(null);
}
}
/// <summary>
/// Gets or sets a pickup point address for tax calculation
/// </summary>
/// <param name="pickupPoint">Pickup point</param>
/// <returns>Address</returns>
protected virtual Address LoadPickupPointTaxAddress(PickupPoint pickupPoint)
{
if (pickupPoint == null)
throw new ArgumentNullException(nameof(pickupPoint));
var country = _countryService.GetCountryByTwoLetterIsoCode(pickupPoint.CountryCode);
var state = _stateProvinceService.GetStateProvinceByAbbreviation(pickupPoint.StateAbbreviation, country?.Id);
return new Address
{
CountryId = country?.Id ?? 0,
StateProvinceId = state?.Id ?? 0,
County = pickupPoint.County,
City = pickupPoint.City,
Address1 = pickupPoint.Address,
ZipPostalCode = pickupPoint.ZipPostalCode
};
}
protected virtual async Task InstallPickupPoints()
{
var country = _countryRepository.Table.FirstOrDefault(c => c.ThreeLetterIsoCode == "USA");
var addresspoint = new Address
{
Address1 = "21 West 52nd Street",
City = "New York",
StateProvinceId = country?.StateProvinces.FirstOrDefault(sp => sp.Name == "New York")?.Id,
CountryId = country?.Id,
ZipPostalCode = "10021",
CreatedOnUtc = DateTime.UtcNow,
};
var point = new PickupPoint()
{
Address = addresspoint,
Name = "My Store - New York",
};
await _pickupPointsRepository.InsertAsync(point);
}
/// <summary>
/// Gets or sets a pickup point address for tax calculation
/// </summary>
/// <param name="pickupPoint">Pickup point</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the address
/// </returns>
protected virtual async Task <Address> LoadPickupPointTaxAddressAsync(PickupPoint pickupPoint)
{
if (pickupPoint == null)
{
throw new ArgumentNullException(nameof(pickupPoint));
}
var country = await _countryService.GetCountryByTwoLetterIsoCodeAsync(pickupPoint.CountryCode);
var state = await _stateProvinceService.GetStateProvinceByAbbreviationAsync(pickupPoint.StateAbbreviation, country?.Id);
return(new Address
{
CountryId = country?.Id ?? 0,
StateProvinceId = state?.Id ?? 0,
County = pickupPoint.County,
City = pickupPoint.City,
Address1 = pickupPoint.Address,
ZipPostalCode = pickupPoint.ZipPostalCode
});
}
public void chooseNextPickupPoint()
{
if (actualPickupPoint == null)
{
actualPickupPoint = pickupPoints[Random.Range(0, pickupPoints.Count - 1)];
}
else if (pickupPoints.Count >= 1)
{
PickupPoint farest = pickupPoints[0];
foreach (PickupPoint point in pickupPoints)
{
if (Vector2.Distance(actualPickupPoint.transform.position, farest.transform.position) <
Vector2.Distance(point.transform.position, actualPickupPoint.transform.position))
{
farest = point;
}
}
actualPickupPoint = farest;
}
else
{
// win state
FindObjectOfType <Migician>().EndGameEnable();
return;
}
//debug
//FindObjectOfType<Migician>().EndGameEnable();
actualPickupPoint.transform.Find("rune").GetComponent <SpriteRenderer>().sprite = runes[runes.Count - 1];
runes.RemoveAt(runes.Count - 1);
actualPickupPoint.activatePoint();
}
public static PickupPoint InsertPickUpPoint(string Name)
{
MarketBotDbContext db = new MarketBotDbContext();
try
{
var reapet = db.PickupPoint.Where(p => p.Name == Name).FirstOrDefault();
if (reapet == null)
{
PickupPoint pickupPoint = new PickupPoint
{
Enable = true,
Name = Name
};
db.PickupPoint.Add(pickupPoint);
db.SaveChanges();
return(pickupPoint);;
}
else
{
return(reapet);
}
}
catch
{
return(null);
}
finally
{
db.Dispose();
}
}
bool DropItem(PickupPoint pickupPoint)
{
if (!IsHoldingItem())
{
return(false);
}
if (pickupPoint == null)
{
return(false);
}
if (pickupPoint.GetItem())
{
return(false);
}
if (pickupPoint.AddItem(currentItem, false))
{
currentItem.GetComponent <SpriteRenderer>().sortingOrder = itemSortingOrderCache;
OnPimDroppedItemEvent(this, currentItem.GetComponent <Item>());
currentItem = null;
}
return(true);
}
public static PickupPointModel ToModel(this PickupPoint entity)
{
return(entity.MapTo <PickupPoint, PickupPointModel>());
}
public static PickupPoint ToEntity(this PickupPointModel model, PickupPoint destination)
{
return(model.MapTo(destination));
}
public void Interact()
{
List <GameObject> pickupPoints = GameObject.FindGameObjectsWithTag("PickupPoint").ToList <GameObject>();
pickupPoints = pickupPoints.OrderBy(x => GetDistanceToObject(x)).ToList();
foreach (GameObject pickupPointObj in pickupPoints)
{
PickupPoint pickupPoint = pickupPointObj.GetComponent <PickupPoint>();
if (pickupPoint != null)
{
Collider2D pickupPointCollider = pickupPointObj.GetComponent <Collider2D>();
if (pickupPointCollider != null)
{
bool standingOnPickupPoint = pickupPointCollider.OverlapPoint(transform.position);
if (standingOnPickupPoint)
{
if (pickupPoint.GetItem() != null)
{
if (pickupPoint.CanPickupHere())
{
bool pickedUpItem = PickupItem(pickupPoint);
if (pickedUpItem)
{
AudioManager.instance.PlaySfx("Blip_Select5");
}
else if (!pickedUpItem)
{
if (pickupPoint.MergeItem(currentItem))
{
ClearAllHighlightedTiles(this, currentItem.GetComponent <Item>());
Destroy(currentItem);
currentItem = null;
PickupItem(pickupPoint);
if (currentItem)
{
Item mergedItem = currentItem.GetComponent <Item>();
if (mergedItem)
{
if (mergedItem.itemType.name == "Black Matter")
{
GameObject go = Instantiate(blackMatterMergeEffect, transform.position, Quaternion.identity);
go.transform.SetParent(transform);
AudioManager.instance.PlaySfx("BlackMattert");
}
else
{
GameObject go = Instantiate(successfulMergeEffect, transform.position, Quaternion.identity);
go.transform.SetParent(transform);
AudioManager.instance.PlaySfx("Blip_Select10");
}
}
}
}
}
}
}
else
{
if (pickupPoint.CanDropHere())
{
if (DropItem(pickupPoint))
{
AudioManager.instance.PlaySfx("Blip_Select7");
EZCameraShake.CameraShaker.Instance.ShakeOnce(0.2f, 5.0f, 0.2f, 0.2f);
}
}
}
}
}
}
}
}
/// <summary>
/// Creates the pickup point.
/// </summary>
/// <param name="pickupPoint">The pickup point.</param>
/// <returns>The new pickup point.</returns>
public PickupPoint CreatePickupPoint(PickupPoint pickupPoint)
{
this.context.PickupPoints.Add(pickupPoint);
this.context.SaveChanges();
return(pickupPoint);
}
/// <summary>
/// Updates the pickup point.
/// </summary>
/// <param name="from">From.</param>
/// <param name="to">To.</param>
public static void UpdatePickupPoint(PickupPoint from, ref PickupPoint to)
{
to.WaypointId = from.WaypointId;
to.RouteId = from.RouteId;
to.Active = from.Active;
}
public void UnstockPickupPoint(PickupPoint point)
{
for (int i=0; i<pickupPoints.Count; i++){
if (point == pickupPoints[i]){
networkView.RPC("UnstockRPC", RPCMode.All, pickupPoints[i].pickupPointID);
}
}
}
public void addPickupPoint(PickupPoint point)
{
pickupPoints.Add(point);
}
public void finishedPickupPoint(PickupPoint point)
{
pickupPoints.Remove(point);
point.disablePoint();
chooseNextPickupPoint();
}
