def signup():
     """
     request (dict):
         {
             "username": str(),
             "password": str()
         }
     """
     try:
         _request = request.get_json(force=True)
         if not _request:
             abort(400)
         p = Person.add(str(_request['username']),
                        str(_request['password']))
         return jsonify(p.to_dict())
     except Exception as e:
         raise e
         return jsonify({'e': e.__str__()}), 500
    def post(self):
        try:
            df = pd.read_csv('listaPersonas.txt', header=None)
            n = df[0].size
            for i in range(n):
                documentNumber = df[0][i]
                surnames = df[1][i].split()
                fatherLastname = " ".join(surnames[:-1])
                motherLastname = surnames[-1]
                names = df[2][i].split()
                flag = int(df[3][i])
                firstName = names[0]
                middleName = " ".join(names[1:])
                documentType = "DNI" if flag == 1 else "CARNET DE EXTRANJERIA"
                #9194 7484
                birthDate = datetime.now() - timedelta(
                    days=random.randint(7484, 9194))
                address = "Av. Universitaria 1801, Lima 15108, Peru"
                nationality = "per"
                randomPlate = "".join(
                    chr(x) for x in
                    [random.randint(ord('A'), ord('Z')) for _ in range(3)])
                randomPlate += "".join(
                    chr(x) for x in
                    [random.randint(ord('0'), ord('9')) for _ in range(3)])
                vehicle1Plate = randomPlate
                randomPlate = "".join(
                    chr(x) for x in
                    [random.randint(ord('A'), ord('Z')) for _ in range(3)])
                randomPlate += "".join(
                    chr(x) for x in
                    [random.randint(ord('0'), ord('9')) for _ in range(3)])
                vehicle2Plate = randomPlate
                gender = "F" if random.randint(0, 1) == 0 else "M"
                person = Person(documentNumber=documentNumber if flag == 1 else
                                ("0000" + str(documentNumber)),
                                documentType=documentType,
                                fatherLastname=fatherLastname,
                                motherLastname=motherLastname,
                                firstName=firstName,
                                middleName=middleName,
                                birthdate=birthDate,
                                address=address,
                                nationality=nationality,
                                vehicle1Plate=vehicle1Plate,
                                vehicle2Plate=vehicle2Plate,
                                gender=gender)
                logging.debug(firstName)
                person.add(person)
                db.session.commit()

            d = {'ok': 'Personas agregadas correctamente'}
            return d, status.HTTP_200_OK
        except SQLAlchemyError as e:
            db.session.rollback()
            response = {'error': str(e)}
            return response, status.HTTP_400_BAD_REQUEST
        except Exception as e:
            db.session.rollback()
            response = {
                'error':
                'An error ocurred. Contact cat-support asap. ' + str(e)
            }
            return response, status.HTTP_400_BAD_REQUEST
Exemple #3
0
    def post(self):
        try:
            file = request.files['file']
            if file.filename == '':
                response = {'error': 'No selected files'}
                return response, status.HTTP_400_BAD_REQUEST

            if file and allowed_file(file.filename):
                df = None
                # [documentNumber], fatherLastname, motherLastname, name, sex, [birthDate]
                try:
                    df = pd.read_csv(file, header=None)
                except:
                    df = pd.read_excel(file, header=None)

                n = df[0].size

                response = {}
                response['badIndexes'] = []
                response['badReasons'] = []

                for i in range(n):
                    documentNumber = df[0][i]
                    fatherLastname = df[1][i]
                    motherLastname = df[2][i]
                    name = df[3][i]
                    sex = df[4][i]
                    birthDate = df[5][i]
                    logging.debug(df[0][i], df[1][i], df[2][i], df[3][i],
                                  df[4][i], df[5][i])
                    #Obtener firstName y middleName
                    listNames = [x for x in name.split()]
                    firstName = listNames[0]
                    middleName = ""
                    if len(listNames) > 1:
                        middleName = listNames[1]

                    if isinstance(documentNumber, float):
                        if np.isnan(documentNumber):
                            documentNumber = None
                        else:
                            documentNumber = str(int(documentNumber))
                            documentNumber = fixDocumentNumber(documentNumber)
                    else:
                        documentNumber = fixDocumentNumber(documentNumber)

                    logging.debug(birthDate, type(birthDate))

                    if isinstance(birthDate, float):
                        if np.isnan(birthDate):
                            logging.debug("isnan")
                            birthDate = datetime.now() - timedelta(days=7300)

                    if isinstance(birthDate, str):
                        lstDate = birthDate.split("/")
                        dd, mm, yyyy = lstDate[0], lstDate[1], lstDate[2]
                        birthDate = date(yyyy, mm, dd)

                    if not isinstance(birthDate, datetime):
                        birthDate = datetime.now() - timedelta(days=7300)

                    if pd.isnull(birthDate):
                        logging.debug("ES NAT")
                        birthDate = birthDate = datetime.now() - timedelta(
                            days=7300)
                    logging.debug("IMPRIMIENTO BD")
                    logging.debug(birthDate)

                    if documentNumber:
                        blacklist = Blacklist.query.filter_by(
                            documentNumber=documentNumber).first()
                        if blacklist:
                            logging.debug("esta repetido xd")
                            response['badIndexes'].append(i)
                            response['badReasons'].append(
                                "Usuario ya registrado en blacklist")
                        else:
                            blacklist = Blacklist(
                                documentNumber=documentNumber,
                                documentType=getDocumentType(documentNumber),
                                active=1,
                                idBlacklistClassification=1)
                            blacklist.add(blacklist)
                            person = Person.query.filter_by(
                                documentNumber=documentNumber).first()
                            if not person:
                                person = Person(
                                    documentNumber=documentNumber,
                                    documentType=blacklist.documentType,
                                    fatherLastname=fatherLastname,
                                    motherLastname=motherLastname,
                                    firstName=firstName,
                                    middleName=middleName,
                                    birthdate=birthDate,
                                    address=
                                    "Av. Universitaria 1801, Lima 15108, Peru",
                                    nationality="per",
                                    vehicle1Plate="XXX000",
                                    vehicle2Plate="XXX000",
                                    gender="M")
                                person.add(person)
                    else:
                        person = Person.query.filter_by(
                            firstName=firstName,
                            motherLastname=motherLastname,
                            fatherLastname=fatherLastname).first()
                        logging.debug("xd")
                        if person:
                            logging.debug(
                                "Encontro persona, revisando si hay blacklist registrado"
                            )
                            blacklist = Blacklist.query.filter_by(
                                documentNumber=person.documentNumber).first()
                            logging.debug(blacklist)
                            if blacklist:
                                logging.debug("esta repetido xd x2")
                                response['badIndexes'].append(i)
                                response['badReasons'].append(
                                    "Usuario ya registrado en blacklist")
                            else:
                                blacklist = Blacklist(
                                    documentNumber=person.documentNumber,
                                    documentType=person.documentType,
                                    active=1,
                                    idBlacklistClassification=1)
                                blacklist.add(blacklist)
                        else:
                            response['badIndexes'].append(i)
                            response['badReasons'].append(
                                "Usuario sin match en la base de datos")
                logging.debug("todo bien")
                db.session.commit()
                response['ok'] = 'Registros agregados correctamente'
                return response, status.HTTP_200_OK
            else:
                response = {'error': 'Bad file sent. Please check extension.'}
                return response, status.HTTP_400_BAD_REQUEST

        except SQLAlchemyError as e:
            db.session.rollback()
            response = {'error': str(e)}
            return response, status.HTTP_400_BAD_REQUEST

        except Exception as e:
            db.session.rollback()
            response = {'error': str(e)}
            logging.debug(str(e))
            return response, status.HTTP_400_BAD_REQUEST