public IHttpActionResult RespondOnRequest(int groupId, int userId, bool respond)
{
var identity = (ClaimsIdentity)User.Identity;
var claims = identity.Claims;
var _userId = int.Parse(claims.Where(c => c.Type == ClaimTypes.NameIdentifier).FirstOrDefault().Value);
var group = requestGroupService.GetGroup(groupId);
if (group.UserId != _userId)
{
return(Unauthorized());
}
var request = new RequestGroup()
{
GroupId = groupId,
UserId = userId
};
try
{
requestGroupService.RespondOnRequest(request, group, respond);
unitOfWork.Commit();
}
catch (Exception)
{
return(BadRequest());
}
return(Ok());
}
//SOS button
private void SosButton_Click(object sender, System.EventArgs e)
{
requestGroupFragment = new RequestGroup(mapHelper.EstimateFares());
requestGroupFragment.Cancelable = false;
var trans = SupportFragmentManager.BeginTransaction();
newTripDetails = new NewTripDetails();
newTripDetails.DestinationAddress = destinationAddress;
newTripDetails.PickupAddress = pickupAddress;
newTripDetails.DestinationLat = destinationLatLng.Latitude;
newTripDetails.DestinationLng = destinationLatLng.Longitude;
newTripDetails.DistanceString = mapHelper.distanceString;
newTripDetails.DistanceValue = mapHelper.distance;
newTripDetails.DurationString = mapHelper.durationstring;
newTripDetails.DurationValue = mapHelper.duration;
newTripDetails.EstimateFare = mapHelper.EstimateFares();
newTripDetails.PickupLat = pickupLocationLatlng.Latitude;
newTripDetails.PickupLng = pickupLocationLatlng.Longitude;
newTripDetails.Timestamp = DateTime.Now;
//group
requestListener = new CreateRequestEventListener(newTripDetails);
requestListener.NoDriverAcceptedRequest += RequestListener_NoDriverAcceptedRequest;
requestListener.DriverAccepted += RequestListener_DriverAccepted;
requestListener.TripUpdates += RequestListener_TripUpdates;
requestListener.CreateSOSRequest();
PhoneDialer.Open("10111");
}
private void loadGridData()
{
loadGridOptions();
DataTable dt = null;
//if (_refreshData || Session["dtGroup_Requests"] == null)
//{
dt = RequestGroup.WorkRequestList_Get(requestGroupID: this.RequestGroupID, typeID: 0, showArchived: _showArchived);
// HttpContext.Current.Session["dtGroup_Requests"] = dt;
//}
//else
//{
// dt = (DataTable)HttpContext.Current.Session["dtGroup_Requests"];
//}
if (dt != null)
{
using (DataTable dtTemp = dt.Clone())
{
this.DCC = dtTemp.Columns;
Page.ClientScript.RegisterArrayDeclaration("_dcc", JsonConvert.SerializeObject(DCC, Newtonsoft.Json.Formatting.None));
}
}
gridRequest.DataSource = dt;
gridRequest.DataBind();
}
private async Task <RequestGroup> AddPriceRowsToRequestsInGroup(RequestGroup requestGroup)
{
var priceRows = await _tolkDbContext.RequestPriceRows.GetRequestPriceRowsForRequestGroup(requestGroup.RequestGroupId).ToListAsync();
requestGroup.Requests.ForEach(r => r.PriceRows = priceRows.Where(p => p.RequestId == r.RequestId).ToList());
return(requestGroup);
}
private void loadGridData()
{
DataTable dt;
if (_refreshData || Session["dtHotlist_Group"] == null)
{
dt = RequestGroup.Hotlist_RequestGroupList_Get(showArchived: _showArchived, myData: _myData);
HttpContext.Current.Session["dtHotlist_Group"] = dt;
}
else
{
dt = (DataTable)HttpContext.Current.Session["dtHotlist_Group"];
}
if (dt != null)
{
this.DCC = dt.Columns;
Page.ClientScript.RegisterArrayDeclaration("_dcc", JsonConvert.SerializeObject(DCC, Newtonsoft.Json.Formatting.None));
InitializeColumnData(ref dt);
dt.AcceptChanges();
int count = dt.Rows.Count;
count = count > 0 ? count - 1 : count; //need to subtract the empty row
spanRowCount.InnerText = count.ToString();
}
grdHotlist.DataSource = dt;
grdHotlist.DataBind();
}
private async Task <RequestGroup> AddRequirementAnswersToRequestsInGroup(RequestGroup requestGroup)
{
var requirementAnswers = await _tolkDbContext.OrderRequirementRequestAnswer.GetRequirementAnswersForRequestsInGroup(requestGroup.RequestGroupId).ToListAsync();
requestGroup.Requests.ForEach(r => r.RequirementAnswers = requirementAnswers.Where(ra => ra.RequestId == r.RequestId).ToList());
return(requestGroup);
}
public AddNewRequestCommandTests()
{
_group = GetRequestGroup();
var groups = new List <RequestGroup>()
{
_group
}.AsQueryable();
_groupSet = new Mock <DbSet <RequestGroup> >();
_groupSet.As <IQueryable <RequestGroup> >().Setup(c => c.Provider).Returns(groups.Provider);
_groupSet.As <IQueryable <RequestGroup> >().Setup(c => c.Expression).Returns(groups.Expression);
_groupSet.As <IQueryable <RequestGroup> >().Setup(c => c.ElementType).Returns(groups.ElementType);
_groupSet.As <IQueryable <RequestGroup> >().Setup(c => c.GetEnumerator()).Returns(groups.GetEnumerator);
_uow = new Mock <IUnitOfWork>();
_uow.Setup(u => u.RequestGroups).Returns(_groupSet.Object);
_factory = new Mock <IRequestFactory>();
_factory.Setup(c => c.Create(It.IsAny <int>(), It.IsAny <string>())).Returns(new Domain.Entities.Request());
_dataFactory = new Mock <IRequestDataFactory>();
_dataFactory.Setup(c => c.Create(It.IsAny <Domain.Entities.Request>())).Returns(new Request());
_subject = new AddNewRequestCommand(_uow.Object, _factory.Object, _dataFactory.Object);
}
public Request[] GetRequests()
{
Request[] requests = new Request[Combination.Count];
int index = 0;
foreach (Entry entry in Combination)
{
RequestGroup group = entry.Group;
Request request = group.Pop();
if (request == null)
{
CleanUpFailure(requests);
return(null);
}
request.ReverseTeams = entry.Reversed;
requests[index] = request;
index++;
}
Game.ApplyPlayerPositions(requests);
return(requests);
}
public async Task AcknowledgeGroup(RequestGroup requestGroup, DateTimeOffset acknowledgeTime, int userId, int?impersonatorId)
{
NullCheckHelper.ArgumentCheckNull(requestGroup, nameof(AcknowledgeGroup), nameof(RequestService));
requestGroup.Requests ??= await _tolkDbContext.Requests.GetRequestsForRequestGroup(requestGroup.RequestGroupId).ToListAsync();
requestGroup.Received(acknowledgeTime, userId, impersonatorId);
}
public void Recieved_Invalid(RequestStatus status)
{
var request = new RequestGroup()
{
Status = status
};
Assert.Throws <InvalidOperationException>(() => request.Received(DateTime.Now, 10));
}
public async Task <RequestGroup> AddListsForRequestGroup(RequestGroup requestGroup)
{
NullCheckHelper.ArgumentCheckNull(requestGroup, nameof(AddListsForRequestGroup), nameof(RequestService));
await AddRequestsWithConfirmationListsToRequestGroup(requestGroup);
await AddPriceRowsToRequestsInGroup(requestGroup);
await AddRequirementAnswersToRequestsInGroup(requestGroup);
return(requestGroup);
}
public void AddNewRequestGroup(AddRequestGroupFromAdminViewModel group)
{
RequestGroup newgroup = new RequestGroup();
newgroup.GroupTitle = group.GroupTitle;
newgroup.IsDeleted = false;
_context.RequestGroups.Add(newgroup);
_context.SaveChanges();
}
public async Task ConfirmGroupCancellation(
RequestGroup requestGroup,
DateTimeOffset confirmedAt,
int userId,
int?impersonatorId)
{
NullCheckHelper.ArgumentCheckNull(requestGroup, nameof(ConfirmGroupCancellation), nameof(RequestService));
requestGroup.ConfirmCancellation(confirmedAt, userId, impersonatorId);
await _tolkDbContext.SaveChangesAsync();
}
private void loadGridData()
{
DataTable dt = null;
if (_refreshData || Session["dtMD_RequestGroup"] == null)
{
dt = RequestGroup.RequestGroupList_Get(includeArchive: true);
HttpContext.Current.Session["dtMD_RequestGroup"] = dt;
}
else
{
dt = (DataTable)HttpContext.Current.Session["dtMD_RequestGroup"];
}
if (dt != null)
{
this.DCC = dt.Columns;
Page.ClientScript.RegisterArrayDeclaration("_dcc", JsonConvert.SerializeObject(DCC, Newtonsoft.Json.Formatting.None));
ListItem item = null;
foreach (DataRow row in dt.Rows)
{
item = ddlQF.Items.FindByValue(row["RequestGroupID"].ToString());
if (item == null)
{
ddlQF.Items.Add(new ListItem(row["RequestGroup"].ToString(), row["RequestGroupID"].ToString()));
}
}
item = ddlQF.Items.FindByValue(_qfID.ToString());
if (item != null)
{
item.Selected = true;
}
InitializeColumnData(ref dt);
dt.AcceptChanges();
if (_qfID != 0 && dt != null && dt.Rows.Count > 0)
{
dt.DefaultView.RowFilter = string.Format(" RequestGroupID = {0}", _qfID.ToString());
dt = dt.DefaultView.ToTable();
}
int count = dt.Rows.Count;
count = count > 0 ? count - 1 : count; //need to subtract the empty row
spanRowCount.InnerText = count.ToString();
}
if (_export && dt != null && CanView)
{
exportExcel(dt);
}
grdMD.DataSource = dt;
grdMD.DataBind();
}
public RequestGroup Post(RequestGroup requestGroup)
{
using (var db = new PtoContext()){
var user = db.User.FirstOrDefault(x => x.id == requestGroup.userId);
requestGroup.user = user;
db.Add(requestGroup);
db.SaveChanges();
//sendNewRequestEmail(user);
}
return(requestGroup);
}
internal static RequestGroupProcessModel GetModelFromRequestGroup(RequestGroup requestGroup, Guid fileGroupKey, long combinedMaxSizeAttachments, bool allowDeclineExtraInterpreter)
{
OrderGroup orderGroup = requestGroup.OrderGroup;
Order order = requestGroup.Requests.First().Order;
return(new RequestGroupProcessModel
{
AllowDeclineExtraInterpreter = allowDeclineExtraInterpreter,
OrderGroupId = requestGroup.OrderGroupId,
RequestGroupId = requestGroup.RequestGroupId,
BrokerId = requestGroup.Ranking.BrokerId,
OrderGroupNumber = orderGroup.OrderGroupNumber,
FileGroupKey = fileGroupKey,
CombinedMaxSizeAttachments = combinedMaxSizeAttachments,
CreatedAt = requestGroup.CreatedAt,
ExpiresAt = requestGroup.ExpiresAt.Value,
OccasionList = new OccasionListModel
{
Occasions = requestGroup.Requests.Where(r => r.Status != RequestStatus.InterpreterReplaced)
.Select(r => OrderOccasionDisplayModel.GetModelFromOrder(r.Order, PriceInformationModel.GetPriceinformationToDisplay(r.Order, alwaysUseOrderPriceRows: false), r)),
AllOccasions = orderGroup.Orders.Select(o => OrderOccasionDisplayModel.GetModelFromOrder(o, request: o.Requests.OrderBy(re => re.RequestId).Last()))
},
HasExtraInterpreter = requestGroup.HasExtraInterpreter,
OrderHasAllowExceedingTravelCost = orderGroup.AllowExceedingTravelCost == BusinessLogic.Enums.AllowExceedingTravelCost.YesShouldBeApproved || orderGroup.AllowExceedingTravelCost == BusinessLogic.Enums.AllowExceedingTravelCost.YesShouldNotBeApproved,
AllowExceedingTravelCost = new RadioButtonGroup {
SelectedItem = orderGroup.FirstOrder.AllowExceedingTravelCost == null ? null : SelectListService.BoolList.Single(e => e.Value == EnumHelper.Parent <AllowExceedingTravelCost, TrueFalse>(orderGroup.FirstOrder.AllowExceedingTravelCost.Value).ToString())
},
CreatorIsInterpreterUser = orderGroup.CreatorIsInterpreterUser.HasValue ? new RadioButtonGroup {
SelectedItem = SelectListService.BoolList.Single(e => e.Value == (orderGroup.CreatorIsInterpreterUser.Value ? TrueFalse.Yes.ToString() : TrueFalse.No.ToString()))
} : null,
AssignmentType = orderGroup.AssignmentType,
CustomerInformationModel = new CustomerInformationModel
{
CreatedBy = orderGroup.CreatedByUser.CompleteContactInformation,
Name = orderGroup.CustomerOrganisation.Name,
UnitName = orderGroup.CustomerUnit?.Name,
DepartmentName = order.UnitName,
InvoiceReference = order.InvoiceReference,
OrganisationNumber = orderGroup.CustomerOrganisation.OrganisationNumber,
PeppolId = orderGroup.CustomerOrganisation.PeppolId,
ReferenceNumber = order.CustomerReferenceNumber
},
Description = order.Description,
LanguageName = orderGroup.LanguageName,
LanguageHasAuthorizedInterpreter = orderGroup.LanguageHasAuthorizedInterpreter,
RankedInterpreterLocationFirstAddressModel = OrderModel.GetInterpreterLocation(order.InterpreterLocations.Single(l => l.Rank == 1)),
RankedInterpreterLocationSecondAddressModel = OrderModel.GetInterpreterLocation(order.InterpreterLocations.SingleOrDefault(l => l.Rank == 2)),
RankedInterpreterLocationThirdAddressModel = OrderModel.GetInterpreterLocation(order.InterpreterLocations.SingleOrDefault(l => l.Rank == 3)),
RegionName = orderGroup.Region.Name,
SpecificCompetenceLevelRequired = orderGroup.SpecificCompetenceLevelRequired,
Status = requestGroup.Status,
});
}
public RequestGroup Patch(RequestGroup requestGroup)
{
using (var db = new PtoContext()){
var entity = db.RequestGroup.FirstOrDefault(x => x.id == requestGroup.id);
if (entity != null)
{
entity.status = requestGroup.status;
db.SaveChanges();
//sendUpdatedRequestEmail(db.User.FirstOrDefault(x => x.id == 90650));
}
}
return(requestGroup);
}
//---------------------------------------------------------------------
private bool ModifyRequestGroup(RequestBatch batch, string group, object[] data)
{
RequestGroup requestGroup = GetRequestGroup(batch, group);
if (requestGroup == null)
{
return(false);
}
requestGroup.datas = data;
return(true);
}
public void AddRequest(Request request)
{
NewRequests = true;
foreach (RequestGroup group in RequestGroups)
{
if (group.Push(request))
{
return;
}
}
NewGroups = true;
RequestGroup newGroup = new RequestGroup(request);
RequestGroups.Add(newGroup);
}
public static string DeleteItem(int itemId, string item)
{
Dictionary <string, string> result = new Dictionary <string, string>()
{
{ "id", itemId.ToString() }
, { "item", item }
, { "exists", "" }
, { "hasDependencies", "" }
, { "deleted", "" }
, { "archived", "" }
, { "error", "" }
};
bool exists = false, hasDependencies = false, deleted = false, archived = false;
string errorMsg = string.Empty;
try
{
//delete
if (itemId == 0)
{
errorMsg = "You must specify an item to delete.";
}
else
{
deleted = RequestGroup.RequestGroup_Delete(itemId, out exists, out hasDependencies, out archived, out errorMsg);
if (hasDependencies && errorMsg.Length == 0)
{
errorMsg = "Record has dependencies and could not be permanently deleted. It has been archived instead.";
}
}
}
catch (Exception ex)
{
LogUtility.LogException(ex);
deleted = false;
errorMsg = ex.Message;
}
result["exists"] = exists.ToString();
result["hasDependencies"] = hasDependencies.ToString();
result["deleted"] = deleted.ToString();
result["archived"] = archived.ToString();
result["error"] = errorMsg;
return(JsonConvert.SerializeObject(result, Formatting.None));
}
public IHttpActionResult PostRequest(RequestGroup request)
{
try
{
var identity = (ClaimsIdentity)User.Identity;
var claims = identity.Claims;
request.UserId = int.Parse(claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value);
requestGroupService.Create(request);
unitOfWork.Commit();
}
catch (Exception)
{
return(BadRequest());
}
return(Ok());
}
//---------------------------------------------------------------------
private RequestGroup GetRequestGroup(RequestBatch batch, string group)
{
if (batch == null)
{
return(null);
}
for (int i = 0; i < batch.groups.Count; ++i)
{
RequestGroup reqeustGroup = batch.groups[i];
if (reqeustGroup.group == group)
{
return(reqeustGroup);
}
}
return(null);
}
//---------------------------------------------------------------------
private RequestGroup PopRequestGroup()
{
RequestBatch batch = LastRequestBatch();
if (batch == null)
{
return(null);
}
RequestGroup group = LastRequestGroup(batch);
batch.groups.Remove(group);
if (batch.groups.Count == 0)
{
m_RequestBatchs.Remove(batch);
}
return(group);
}
public async Task DeclineGroup(
RequestGroup requestGroup,
DateTimeOffset declinedAt,
int userId,
int?impersonatorId,
string message)
{
NullCheckHelper.ArgumentCheckNull(requestGroup, nameof(DeclineGroup), nameof(RequestService));
requestGroup.Requests = await _tolkDbContext.Requests.GetRequestsForRequestGroup(requestGroup.RequestGroupId).ToListAsync();
requestGroup.OrderGroup.Orders = await _tolkDbContext.Orders.GetOrdersForOrderGroup(requestGroup.OrderGroupId).ToListAsync();
requestGroup.OrderGroup.RequestGroups = await _tolkDbContext.RequestGroups.GetRequestGroupsForOrderGroup(requestGroup.OrderGroupId).ToListAsync();
requestGroup.Decline(declinedAt, userId, impersonatorId, message);
await _orderService.CreateRequestGroup(requestGroup.OrderGroup, requestGroup);
_notificationService.RequestGroupDeclinedByBroker(requestGroup);
}
public ActionResult Send(int id)
{
var mbr = db.Members.Find(id, User.Identity.GetUserId());
var r = db.RequestGroup.Find(id, User.Identity.GetUserId());
if (mbr == null && r == null)
{
RequestGroup req = new RequestGroup();
req.GroupId = id;
req.Sent = User.Identity.GetUserId();
db.RequestGroup.Add(req);
db.SaveChanges();
return(RedirectToAction("Index", "Group", new { id }));
}
else
{
return(View());
}
}
//---------------------------------------------------------------------
private bool ModifyMutexRequest(RequestType type, string group, object[] datas)
{
RequestBatch batch = GetRequestBatch(type);
if (batch == null)
{
return(false);
}
RequestGroup requestGroup = GetRequestGroup(batch, group);
if (requestGroup == null)
{
return(false);
}
requestGroup.datas = datas;
return(true);
}
public async Task <IActionResult> ConfirmNoAnswer(int requestGroupId)
{
RequestGroup requestGroup = await GetConfirmedRequestGroup(requestGroupId);
if (requestGroup.Status == RequestStatus.ResponseNotAnsweredByCreator && (await _authorizationService.AuthorizeAsync(User, requestGroup, Policies.View)).Succeeded)
{
try
{
await _requestService.ConfirmGroupNoAnswer(requestGroup, _clock.SwedenNow, User.GetUserId(), User.TryGetImpersonatorId());
return(RedirectToAction("Index", "Home", new { message = "Sammanhållen bokningsförfrågan arkiverad" }));
}
catch (InvalidOperationException ex)
{
_logger.LogError("ConfirmNoAnswer failed for requestgroup, RequestGroupId: {requestGroupId}, message {ex.Message}", requestGroupId, ex.Message);
return(RedirectToAction("Index", "Home", new { errormessage = ex.Message }));
}
}
return(Forbid());
}
public List <RequestGroup> GetPlatformsGroups(int typex, Frequency frequency, DateTime? @from, DateTime?to)
{
using (var db = base.NewDB())
{
var items = db.RequestLogs
.WhereByFromDate(from)
.WhereByToDate(to)
.WhereByType(typex)
.ToGroupedPlatformRequestDtos(frequency)
.OrderBy(x => x.Group)
.ToList();
var min = (from == null ? db.RequestLogs.Min(x => x.Date) : from.Value);
var max = (to == null ? DateTime.Today : to.Value);
if (frequency == Frequency.Hour)
{
max = max.AddHours(DateTime.Now.Hour);
}
if (frequency.CalculateItems(min, max) > 62)
{
throw new Exception("数据太多，请调整频率或者时间段");
}
var platforms = new List <Platform?>();
platforms.Add(null);
platforms.Add(Platform.Android);
platforms.Add(Platform.Ios);
var groups = new List <RequestGroup>();
foreach (var platform in platforms)
{
var typeItems = items.Where(x => x.Platform == platform).ToList();
var group = new RequestGroup(platform);
for (var value = min; value <= max; value = frequency.GetNextTime(value))
{
var valueGroup = value.ToGroupValue(frequency);
var item = typeItems.FirstOrDefault(x => x.Group == valueGroup);
group.Items.Add(new RequestItem(value.ToString(), item == null ? 0 : item.Value));
}
groups.Add(group);
}
return(groups);
}
}
public List<RequestGroup> GetPlatformsGroups(int typex, Frequency frequency, DateTime? @from, DateTime? to)
{
using (var db = base.NewDB())
{
var items = db.RequestLogs
.WhereByFromDate(from)
.WhereByToDate(to)
.WhereByType(typex)
.ToGroupedPlatformRequestDtos(frequency)
.OrderBy(x => x.Group)
.ToList();
var min = (from == null ? db.RequestLogs.Min(x => x.Date) : from.Value);
var max = (to == null ? DateTime.Today : to.Value);
if (frequency == Frequency.Hour)
{
max = max.AddHours(DateTime.Now.Hour);
}
if (frequency.CalculateItems(min, max) > 62)
{
throw new Exception("数据太多，请调整频率或者时间段");
}
var platforms = new List<Platform?>();
platforms.Add(null);
platforms.Add(Platform.Android);
platforms.Add(Platform.Ios);
var groups = new List<RequestGroup>();
foreach (var platform in platforms)
{
var typeItems = items.Where(x => x.Platform == platform).ToList();
var group = new RequestGroup(platform);
for (var value = min; value <= max; value = frequency.GetNextTime(value))
{
var valueGroup = value.ToGroupValue(frequency);
var item = typeItems.FirstOrDefault(x => x.Group == valueGroup);
group.Items.Add(new RequestItem(value.ToString(), item == null ? 0 : item.Value));
}
groups.Add(group);
}
return groups;
}
}
public void OnGet(int id)
{
Group = _userService.GetRequestGroupByID(id);
}
public void AddToCombination(RequestGroup requestGroup, bool reversed)
{
Combination.Add(new Entry(requestGroup, reversed));
}
