public Task <IActionResult> FetchAvailableGroupShooter(GroupRequest request)
{
//Recupero l'elemento dal business layer
var entity = BasicLayer.GetGroup(request.GroupId);
//modifica solo se admin o se utente richiedente è lo stesso che ha creato
if (entity == null)
{
return(Task.FromResult <IActionResult>(NotFound()));
}
//Invocazione del service layer
var shooters = BasicLayer.FetchAvailableShooters(entity);
var shooterIds = shooters.Select(s => s.Id).ToList();
var shooterAssociation = BasicLayer.FetchShooterAssociationByShooterIds(shooterIds, entity.MatchId);
var shooterTeams = BasicLayer.FetchTeamsFromShooterIds(shooterIds);
var teamsIds = shooterTeams.Select(x => x.TeamId).ToList();
var teams = BasicLayer.FetchTeamsByIds(teamsIds);
var result = shooters.As(x => ContractUtils.GenerateContract(x,
shooterAssociation.Where(s => s.ShooterId == x.Id).ToList(),
teams.Where(s => shooterTeams.Where(st => st.ShooterId == x.Id).Select(st => st.TeamId).Contains(s.Id))
.ToList()));
//Return contract
return(Reply(result));
}
public void Join(string groupId, string userName, string userId)
{
Request request = new Request
{
CreatedOn = DateTime.UtcNow,
Name = $"{userName} - {DateTime.UtcNow}",
};
GroupRequest existingRequest = this.context.GroupRequests.FirstOrDefault(gr => gr.GroupId == groupId && gr.RequestId == request.Id);
if (existingRequest != null)
{
return;
}
GroupRequest groupRequest = new GroupRequest
{
GroupId = groupId,
RequestId = request.Id,
};
this.context.Requests.Add(request);
this.context.GroupRequests.Add(groupRequest);
this.context.SaveChanges();
}
public async Task Post()
{
// Arrange
var request = new GroupRequest
{
Name = "Group B"
};
// Act
var actionResult = await Controller.Post(request);
// Assert
Assert.IsInstanceOf <OkObjectResult>(actionResult);
var okObjectResult = (OkObjectResult)actionResult;
var value = okObjectResult.Value;
Assert.IsInstanceOf <GroupResponse>(value);
var response = (GroupResponse)value;
Assert.Greater(response.Id, 0);
Assert.AreEqual(request.Name, response.Name);
}
public void CannotUpdateGroupToDuplicateName()
{
var key = "Group_CannotUpdateGroupToDuplicateName";
Helpers.CreateAndLoginGlobal(Fixture.SUGARClient, key);
var groupRequestOne = new GroupRequest
{
Name = key + "_Group1"
};
Fixture.SUGARClient.Group.Create(groupRequestOne);
var groupRequestTwo = new GroupRequest
{
Name = key + "_Group2"
};
var responseTwo = Fixture.SUGARClient.Group.Create(groupRequestTwo);
var updateGroup = new GroupRequest
{
Name = groupRequestOne.Name
};
Assert.Throws <ClientHttpException>(() => Fixture.SUGARClient.Group.Update(responseTwo.Id, updateGroup));
}
public async Task FetchAvailableGroupShooterShouldBeOkHavingElements()
{
var group = Scenario.Groups.FirstOrDefault();
var groupInMatchIds = Scenario.Groups.Where(x => x.MatchId == group.MatchId).Select(x => x.Id).ToList();
var match = Scenario.Matches.FirstOrDefault(x => x.Id == group.MatchId);
var association = Scenario.Associations.FirstOrDefault(x => x.Id == match.AssociationId);
var shootersAlreadyInGroupIds = Scenario.GroupShooters.Where(x => groupInMatchIds.Contains(x.GroupId)).Select(x => x.ShooterId);
var shootersInAssociationIds = Scenario.ShooterAssociations.Where(x => x.AssociationId == association.Id).Select(x => x.ShooterId).ToList();
var shooterIds = shootersInAssociationIds.Count(x => !shootersAlreadyInGroupIds.Contains(x));
var request = new GroupRequest
{
GroupId = group.Id
};
//Invoke del metodo
var response = await Controller.FetchAvailableGroupShooter(request);
//Parsing della risposta e assert
var parsed = ParseExpectedOk <IList <ShooterContract> >(response);
var shooterClassifications = parsed.Data.SelectMany(x => x.Classifications).Count();
var shooterTeams = parsed.Data.SelectMany(x => x.Teams).Count();
Assert.AreEqual(shooterIds, parsed.Data.Count);
Assert.AreNotEqual(0, shooterClassifications);
Assert.AreNotEqual(0, shooterTeams);
}
/// <summary>
/// Update the group with the provided id to now have the provided description.
/// </summary>
/// <param name="id">The Id of the group to update.</param>
/// <param name="description">Description the group should now have.</param>
/// <param name="onComplete">Callback with a GroupResponse result for the newly updated group.</param>
public void UpdateGroupDescription(int id, string description, Action <GroupResponse> onComplete)
{
if (SUGARManager.UserSignedIn)
{
GetGroupById(id,
groupLoaded =>
{
if (groupLoaded != null)
{
var groupRequest = new GroupRequest
{
Name = groupLoaded.Name,
Description = description
};
SUGARManager.client.Group.UpdateAsync(id, groupRequest,
() => GetGroupById(id, onComplete),
exception =>
{
Debug.LogError(exception);
onComplete(null);
});
}
});
}
else
{
onComplete(null);
}
}
//9.2.3 删除群组
public string deleteGroup(QChat_Group qchat)
{
QchatQEDService qqs = new QchatQEDService();
qqs = getQchatQEDService(qchat.username, qchat.password, qchat.deviceID, qchat.urlIp);
//6删除群组
GroupRequest deleteRequest = new GroupRequest();
GroupInfo gi2 = new GroupInfo();
gi2.code = qchat.code;//"gmikym193313";
deleteRequest.groupInfo = gi2;
QedRequest qedr_del = new QedRequest();
qedr_del.groupRequest = deleteRequest;
QedResponse response = qqs.deleteGroup(qedr_del);
GroupResponse companyResponse = response.groupResponse;
StringBuilder sb = new StringBuilder();
if (companyResponse != null)//&& companyResponse.response != null)
{
sb.AppendLine("Response:" + companyResponse.response.description.ToString());
sb.AppendLine("reserve:" + companyResponse.response.reserve);
sb.AppendLine("returnCode:" + companyResponse.response.returnCode);
}
else
{
sb.AppendLine("返回信息为null");
}
Console.WriteLine(sb);
//Console.ReadKey();
return(sb.ToString());
}
/// <summary>
/// Submits a Request to become an expert
/// Date: 4/24/16
/// Author: Chris Schwebach
/// </summary>
/// <param name="groupID, UserID"></param>
/// <returns></returns>
public ActionResult RequestJoinExpert()
{
GroupManager grMangr = new GroupManager();
Group grp = grMangr.RetrieveGroupByName(WebConfigurationManager.AppSettings["ExpertGroup"]);
int groupId = grp.GroupID;
GroupRequest request = new GroupRequest();
request.UserID = RetrieveUserId();
request.RequestDate = DateTime.Now;
request.GroupID = groupId;
GroupManager manager = new GroupManager();
try
{
if (manager.AddGroupMember(request) == 1)
{
return(RedirectToAction("SuccessRequest", "Expert"));
}
}
catch (Exception)
{
//request failed
}
return(RedirectToAction("AlreadyExpert", "Expert"));
}
public static async Task <GraphGroup> CreateGroup(GroupRequest request)
{
var uriEndPoint = $"{Constants.ResourceUrl}/{Constants.GraphApiVersion}/groups";
GraphResponse <GraphGroup> result = null;
var group = new GraphGroup()
{
Description = request.AccountId,
DisplayName = request.AccountName,
GroupTypes = new List <string>()
{
"Unified"
},
MailEnabled = true,
MailNickname = request.AccountId,
SecurityEnabled = false
};
// Create group with Graph API
result = await Client.GetData <GraphGroup>(HttpMethod.Post, uriEndPoint, group).ConfigureAwait(false);
if (!result.IsSuccessfull)
{
throw new Exception($"Error: group not created - API error: {result.Message}");
}
return(result.Data);
}
public void CanUpdateGroup()
{
var key = "Group_CanUpdateGroup";
Helpers.CreateAndLoginGlobal(Fixture.SUGARClient, key);
var groupRequest = new GroupRequest
{
Name = key + "_Group"
};
var response = Fixture.SUGARClient.Group.Create(groupRequest);
var updateRequest = new GroupRequest
{
Name = groupRequest.Name + " Updated"
};
Fixture.SUGARClient.Group.Update(response.Id, updateRequest);
var getGroup = Fixture.SUGARClient.Group.Get(response.Id);
Assert.NotEqual(response.Name, updateRequest.Name);
Assert.Equal(key + "_Group" + " Updated", getGroup.Name);
}
public Task <IActionResult> GetGroup(GroupRequest request)
{
var entity = BasicLayer.GetGroup(request.GroupId);
//verifico validità dell'entità
if (entity == null)
{
return(Task.FromResult <IActionResult>(NotFound()));
}
//var shooters = BasicLayer.FetchShootersByGroupId(entity.Id);
var shooterGroup = BasicLayer.FetchGroupShootersByGroupId(entity.Id);
var shooterIds = shooterGroup.Select(x => x.ShooterId).ToList();
var shooters = BasicLayer.FetchShootersByIds(shooterIds);
var match = BasicLayer.GetMatch(entity.MatchId);
var association = BasicLayer.GetAssociation(match.AssociationId);
var shooterAssociation = BasicLayer.FetchShooterAssociationByShooterIds(shooterIds, entity.MatchId);
var shooterTeams = BasicLayer.FetchTeamsFromShooterIds(shooterIds);
var teamsIds = shooterTeams.Select(x => x.TeamId).ToList();
var teams = BasicLayer.FetchTeamsByIds(teamsIds);
var result = ContractUtils.GenerateContract(entity, match, association, null, shooterGroup, shooters,
shooterAssociation, shooterTeams, teams);
//Serializzazione e conferma
return(Reply(result));
}
public async Task <IActionResult> Post([FromBody] GroupRequest req)
{
try
{
if (req == null)
{
return(new ErrorResult());
}
Group group = new Group
{
GroupName = req.GroupName,
GroupCourse = req.GroupCourse,
};
_unitOfWork.Group.Add(group);
await _unitOfWork.Complete();
return(new MyOkResult((GroupResult)group));
}
catch (Exception ex)
{
return(new ErrorResult(ex.Message));
}
}
public async Task <IHttpActionResult> PostGroup(GroupRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (request.ImageArray != null && request.ImageArray.Length > 0)
{
var stream = new MemoryStream(request.ImageArray);
var guid = Guid.NewGuid().ToString();
var file = string.Format("{0}.jpg", guid);
var folder = "~/Content/Logos";
var fullPath = string.Format("{0}/{1}", folder, file);
var response = FilesHelper.UploadPhoto(stream, folder, file);
if (response)
{
request.Logo = fullPath;
}
}
var group = ToGroup(request);
_db.Groups.Add(group);
await _db.SaveChangesAsync();
// CreateUserAsp(request.Email, "User", request.Password);
return(CreatedAtRoute("DefaultApi", new { id = group.GroupId }, group));
// return CreatedAtRoute("DefaultApi", new { id = user.UserId }, user);
}
public void SendRequest(int groupId, int profileId)
{
var group = GetGroupById(groupId, "requests");
if (group == null)
{
throw new ArgumentException("Group doesn't exist.");
}
if (_memberService.IsMember(profileId, groupId))
{
throw new ArgumentException("You are already a member of this group!");
}
if (!_profileService.ProfileExists(profileId))
{
throw new ArgumentException("Profile with specified profileId doesn't exist!");
}
if (group.Requests.Any(x => x.ProfileId == profileId))
{
throw new ArgumentException("You already sent request for this group!");
}
var req = new GroupRequest
{
GroupId = groupId,
ProfileId = profileId,
};
try
{
_groupRepository.AddRequest(req);
}
catch (Exception)
{
throw new ArgumentException("Database error!");
}
}
private GroupRequest addPersonToGroup(int personId, int seriesId)
{
DataTable groupTable = new DataTable();
GroupRequest groupResult = new GroupRequest();
using (OracleConnection objConn = new OracleConnection(Global.ConnectionString))
{
// Set up the searchPeople command
var command = new OracleCommand("TICKETS_API.insertGroupRequests", objConn)
{
BindByName = true, CommandType = CommandType.StoredProcedure
};
command.Parameters.Add("p_Return", OracleDbType.RefCursor, ParameterDirection.ReturnValue);
command.Parameters.Add("p_PersonId", OracleDbType.Int64, Global.CurrentPerson.person_id, ParameterDirection.Input);
command.Parameters.Add("p_RequestedId", OracleDbType.Int64, personId, ParameterDirection.Input);
command.Parameters.Add("p_SeriesId", OracleDbType.Int64, seriesId, ParameterDirection.Input);
// Execute the query and map the results to models
objConn.Open();
var groupAdapter = new OracleDataAdapter(command);
groupAdapter.Fill(groupTable);
groupResult.group_id = long.Parse(groupTable.Rows[0]["group_id"].ToString());
groupResult.requested_id = long.Parse(groupTable.Rows[0]["requested_id"].ToString());
groupResult.requested_firstname = groupTable.Rows[0]["requested_firstname"].ToString();
groupResult.requested_lastname = groupTable.Rows[0]["requested_lastname"].ToString();
objConn.Close();
}
return(groupResult);
}
public static int UpdateGroupMemberRequest(GroupRequest request)
{
int count = 0;
var conn = DBConnection.GetDBConnection();
string cmdText = "Admin.spAcceptRequest";
var cmd = new SqlCommand(cmdText, conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@GroupID", request.GroupID);
cmd.Parameters.AddWithValue("@UserID", request.UserID);
cmd.Parameters.AddWithValue("@ApprovedID", request.ApprovedBy);
cmd.Parameters.AddWithValue("@ApprovedDate", request.ApprovedDate);
try
{
conn.Open();
count = cmd.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return(count);
}
/// <summary>
/// Poonam Dubey
/// 04/06/2016
/// Function to call DB and insert groupmember request
///
/// Altered by Nicholas King
/// </summary>
/// <param name="reqObj"></param>
/// <returns></returns>
public static int CreateGroupMember(GroupRequest reqObj)
{
string query = @"Admin.spInsertGroupRequest";
int rowCount = 0;
var conn = DBConnection.GetDBConnection();
var cmd = new SqlCommand(query, conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@GroupID", reqObj.GroupID);
cmd.Parameters.AddWithValue("@UserID", reqObj.UserID);
//This Para is not used by the stored procedure
//cmd.Parameters.AddWithValue("@RequestStatus", reqObj.RequestStatus);
cmd.Parameters.AddWithValue("@RequestDate", reqObj.RequestDate);
try
{
conn.Open();
rowCount = cmd.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return(rowCount);
}
public async Task Put_EntityVersion_Conflict()
{
// Arrange
var request = new GroupRequest
{
Name = "Group B"
};
// Act
var actionResult = await Controller.Post(request);
// Assert
Assert.IsInstanceOf <OkObjectResult>(actionResult);
var okObjectResult = (OkObjectResult)actionResult;
var value = okObjectResult.Value;
Assert.IsInstanceOf <GroupResponse>(value);
var response = (GroupResponse)value;
Assert.Greater(response.Id, 0);
Assert.AreEqual(request.Name, response.Name);
// Arrange
var id = response.Id;
request.Name = "Group B+";
request.EntityVersion = response.EntityVersion.Value.AddDays(-1);
// Act
actionResult = await Controller.Put(id, request);
// Assert
Assert.IsInstanceOf <ConflictObjectResult>(actionResult);
var conflictObjectResult = (ConflictObjectResult)actionResult;
value = conflictObjectResult.Value;
Assert.IsInstanceOf <StateResponse>(value);
var stateResponse = (StateResponse)value;
Assert.IsNotEmpty(stateResponse);
Assert.IsTrue(stateResponse.ContainsKey("EntityVersion"));
Assert.AreEqual(Messages.EntityVersion_Conflict, stateResponse["EntityVersion"]);
}
public async Task Put_EntityVersion()
{
// Arrange
var request = new GroupRequest
{
Name = "Group B"
};
// Act
var actionResult = await Controller.Post(request);
// Assert
Assert.IsInstanceOf <OkObjectResult>(actionResult);
var okObjectResult = (OkObjectResult)actionResult;
var value = okObjectResult.Value;
Assert.IsInstanceOf <GroupResponse>(value);
var response = (GroupResponse)value;
Assert.Greater(response.Id, 0);
Assert.AreEqual(request.Name, response.Name);
// Arrange
var id = response.Id;
request.Name = "Group B+";
request.EntityVersion = response.EntityVersion;
// Act
actionResult = await Controller.Put(id, request);
// Assert
Assert.IsInstanceOf <OkObjectResult>(actionResult);
okObjectResult = (OkObjectResult)actionResult;
value = okObjectResult.Value;
Assert.IsInstanceOf <GroupResponse>(value);
response = (GroupResponse)value;
Assert.AreEqual(id, response.Id);
// Assert - Compare
Assert.AreEqual(request.Name, response.Name);
}
public HttpResponseMessage Put([FromBody] GroupRequest groupRequest)
{
var repo = new GroupRepository();
var group = repo.Update(groupRequest);
var code = (group != null) ? HttpStatusCode.OK : HttpStatusCode.BadRequest;
return(Request.CreateResponse(code, group));
}
protected void Page_Load(object sender, EventArgs e)
{
intProfile = Int32.Parse(Request.Cookies["profileid"].Value);
oPage = new Pages(intProfile, dsn);
oRequestItem = new RequestItems(intProfile, dsn);
oApplication = new Applications(intProfile, dsn);
oGroupRequest = new GroupRequest(intProfile, dsn);
oRequest = new Requests(intProfile, dsn);
oFunction = new Functions(intProfile, dsn, intEnvironment);
oDomain = new Domains(intProfile, dsn);
if (Request.QueryString["applicationid"] != null && Request.QueryString["applicationid"] != "")
{
intApplication = Int32.Parse(Request.QueryString["applicationid"]);
}
if (Request.QueryString["pageid"] != null && Request.QueryString["pageid"] != "")
{
intPage = Int32.Parse(Request.QueryString["pageid"]);
}
if (Request.Cookies["application"] != null && Request.Cookies["application"].Value != "")
{
intApplication = Int32.Parse(Request.Cookies["application"].Value);
}
if (Request.QueryString["rid"] != "" && Request.QueryString["rid"] != null)
{
if (!IsPostBack)
{
LoadLists();
}
LoadValues();
int intItem = Int32.Parse(lblItem.Text);
int intApp = oRequestItem.GetItemApplication(intItem);
string strDeliverable = oApplication.Get(intApp, "deliverables_doc");
if (strDeliverable != "")
{
panDeliverable.Visible = true;
btnDeliverable.Attributes.Add("onclick", "return OpenWindow('NEW_WINDOW','" + strDeliverable + "');");
}
if (Request.QueryString["g"] != null && Request.QueryString["g"] != "" && Request.QueryString["d"] != null && Request.QueryString["d"] != "")
{
if (!IsPostBack)
{
LoadObjects();
}
btnNext.Attributes.Add("onclick", "return ValidateText('" + txtTo.ClientID + "','Please enter a group name')" +
" && EnsureGroupScope('" + radDLG.ClientID + "','" + radGG.ClientID + "','" + radUG.ClientID + "')" +
" && EnsureGroupType('" + radS.ClientID + "','" + radD.ClientID + "')" +
";");
}
else
{
btnNext.Enabled = false;
}
btnContinue.Attributes.Add("onclick", "return ValidateText('" + txtFrom.ClientID + "','Please enter a group name')" +
" && ValidateDropDown('" + ddlDomain.ClientID + "','Please select a domain')" +
";");
}
btnCancel1.Attributes.Add("onclick", "return confirm('Are you sure you want to delete this service request?');");
}
public void OnActionExecuting(ActionExecutingContext context)
{
foreach (var argument in context.ActionArguments.Values.Where(v => v is GroupRequest))
{
GroupRequest model = argument as GroupRequest;
_groupValidationService.RequireAuthorizedUserIsGroupMember(model.GroupId);
}
}
private GroupResponse CreateGroup(string key)
{
var groupRequest = new GroupRequest
{
Name = key + "_G"
};
return(Fixture.SUGARClient.Group.Create(groupRequest));
}
public static Group ToGroupModel(this GroupRequest groupContract)
{
return(new Group
{
Name = groupContract.Name,
Description = groupContract.Description,
Private = groupContract.Private
});
}
public IActionResult Create([FromBody] GroupRequest actor)
{
var group = actor.ToGroupModel();
_groupCoreController.Create(group, RequestingId);
var actorContract = group.ToContract();
return(new ObjectResult(actorContract));
}
public Group GetGroup(GroupRequest request)
{
if (!request.GroupID.HasValue)
{
throw new Exception("Group ID not specified");
}
return(GetGroups(request).Groups.FirstOrDefault());
}
public Group GetGroup(int id)
{
var request = new GroupRequest()
{
GroupID = id
};
return(_groupService.GetGroup(request));
}
private Group ToGroup(GroupRequest request)
{
return(new Group
{
Name = request.Name,
Requirements = request.Requirements,
OwnerId = request.OwnerId,
Logo = request.Logo
});
}
public void When_TimetableReceivesOnlyBaseAddress_Then_AddressShouldBeValid()
{
var timetable = new GroupRequest
{
BaseAddress = "https://profs.info.uaic.ro/~orar"
};
string address = timetable.GetAddress();
Assert.AreEqual("https://profs.info.uaic.ro/~orar", address);
}
public void CreateGroupRequest(GroupRequest groupRequest)
{
var oldgroup = GetGroupRequests().Where(g => g.UserId == groupRequest.UserId && g.GroupId == groupRequest.GroupId);
if (oldgroup.Count() == 0)
{
groupRequestRepository.Add(groupRequest);
SaveGroupRequest();
}
}
public void DisplayUsers()
{
TR_AddGroupDetail.Visible = false;
if (Request.QueryString["OrderBy"] == "")
{
OrderBy = "UserName";
}
else
{
OrderBy = Request.QueryString["OrderBy"];
}
GroupRequest req = new GroupRequest();
req.GroupType = m_intGroupType;
req.GroupId = uId;
req.SortOrder = OrderBy;
req.SortDirection = m_strDirection;
req.SearchText = m_strSearchText;
req.PageSize = m_refContentApi.RequestInformationRef.PagingSize;
req.CurrentPage = m_intCurrentPage;
user_list = m_refUserApi.GetUsersNotInGroup(req);
m_intTotalPages = req.TotalPages;
group_data = m_refUserApi.GetUserGroupById(uId);
AddUserToGroupToolBar();
Populate_AddUserToGroupGrid();
}
/// <remarks/>
public void GroupRequestAsync(GroupRequest GroupRequest1) {
this.GroupRequestAsync(GroupRequest1, null);
}
/// <remarks/>
public void GroupRequestAsync(GroupRequest GroupRequest1, object userState) {
if ((this.GroupRequestOperationCompleted == null)) {
this.GroupRequestOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGroupRequestOperationCompleted);
}
this.InvokeAsync("GroupRequest", new object[] {
GroupRequest1}, this.GroupRequestOperationCompleted, userState);
}
