public void Enqueue(EnrollDataModel dataModel)
 {
     enrollQueue.Enqueue(dataModel);
     if (NewEnrollmentEvent != null)
     {
         Task.Factory.StartNew(() => NewEnrollmentEvent(this, EventArgs.Empty));
     }
 }
        private void HandleEnrollment(Object sender, EventArgs args)
        {
            EnrollDataModel dataModel = null;
            bool            result    = enrollQueue.TryDequeue(out dataModel);

            if (!result)
            {
                return;
            }
            try
            {
                int[] templateIDs = null;
                if (dataModel.userDO.Fingers != null &&
                    dataModel.userDO.Fingers.Where(x => (int)VV.DataObjects.FingerDataObject.FindFinger(x.FingerIndex) == dataModel.fingerIndex).FirstOrDefault() != null)
                {
                    templateIDs = dataModel.userDO.Fingers.Where(x => (int)VV.DataObjects.FingerDataObject.FindFinger(x.FingerIndex) == dataModel.fingerIndex).First().Templates.Select(x => x.Id).ToArray();
                }

                UsersEnrollPostbackModel postbackModel;
                for (int i = 0; i < TEMPLATES_PER_FINGER; i++)
                {
                    Proxy.BioConnectAPI.TemplateObject templateDO = bioConnectAPIProxy.GetTemplateObject(dataModel.readerID, dataModel.authorizedToken, dataModel.enrollQuality);
                    if (templateIDs != null && templateIDs.Length > i)
                    {
                        templateDO.Id = templateIDs[i];
                    }
                    templateDO.UserID      = dataModel.userDO.Id;
                    templateDO.FingerIndex = dataModel.fingerIndex;
                    bioConnectAPIProxy.SaveScannedTemplate(templateDO, dataModel.authorizedToken);

                    postbackModel = new UsersEnrollPostbackModel
                    {
                        ReturnCode     = 200,
                        Base64PNGImage = BitmapImageConverter.GetBase64Representation(BitmapImageConverter.GetTemplateImage(templateDO.Data))
                    };
                    PostbackClient.PostbackClient.EnrollPostback(dataModel.callbackUrl, postbackModel);
                }

                postbackModel = new UsersEnrollPostbackModel
                {
                    ReturnCode = 201
                };
                PostbackClient.PostbackClient.EnrollPostback(dataModel.callbackUrl, postbackModel);
            }
            catch (Exception ex)
            {
                UsersEnrollPostbackModel postbackModel = new UsersEnrollPostbackModel
                {
                    ReturnCode    = 500,
                    ReturnMessage = ex.Message
                };
                var response = PostbackClient.PostbackClient.EnrollPostback(dataModel.callbackUrl, postbackModel);
            }
        }
        public IHttpActionResult Enroll(string externalId, [FromBody] UsersEnrollModel model)
        {
            try
            {
                UsersDataObject usersDO = dataAccess.GetUserByExternalID(externalId);
                if (usersDO == null)
                {
                    return(NotFound());
                }

                ClaimsPrincipal user = Request.GetRequestContext().Principal as ClaimsPrincipal;
                if (!user.HasClaim(x => x.Type == ClaimTypes.Name))
                {
                    return(BadRequest("Invalid authentication, please request another access token"));
                }

                Claim username = user.Claims.Where(x => x.Type == ClaimTypes.Name).FirstOrDefault();
                Proxy.BioConnectAPI.SecurityTokenDto authorizedToken = bioConnectAPIProxy.RetrieveSecurityTokenByUsername(username.Value);
                if (authorizedToken == null)
                {
                    return(BadRequest("Invalid authentication, please request another access token"));
                }

                EnrollDataModel dataModel = new EnrollDataModel
                {
                    readerID        = model.deviceID,
                    userDO          = usersDO,
                    enrollQuality   = model.enrollQuality,
                    fingerIndex     = model.fingerIndex,
                    callbackUrl     = model.callbackUrl,
                    authorizedToken = authorizedToken
                };

                enrollmentServer.Enqueue(dataModel);
                return(Content(System.Net.HttpStatusCode.Accepted, String.Format("Starting enrollment process for user: {0}", externalId)));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }