GenRandomMember

# -*- coding: utf-8 -*-
"""
Created on Sat Jun 15 15:03:24 2019

It may be needed to type "pip install Faker" or "conda install Faker" into the
command window prior to running the script



DO NOT IMPORT, This must be run as a __MAIN__ to operrate correctly.

This is the first part of the midterm project. This script creates a file of
random values to be used by the database management program that makes up the
second part of the project.

The script is run, and can take arguments:
    -no <number of members>   ((default value of 1000))
    -fname <filename>    ((default value of memberdata.csv))
No other arguments or formats can be used.

The script uses third parter Faker library as a core develpment for random entries.

Main takes the script arguments for number of members and output file.
Since there is no mention in project requirements that this should append to existing data,
and that doesn't seem to fit the scope of the usage, the script only checks its own
generated data and will not append, but overwrite a file it is targeted at.


As a maximum value of 1,000,000 is a project given, the program will reject a given value
above that maximum and generate nothing, prompting the user to recall the prgram with a valid entry.


@author: Deciliter
"""


##default values = 1000 members into memberdata.csv
def main(NumberOfMembers: int = 1000, filename: str = "memberdata.csv"):
    """
    Creates a file filled with randomized entries for usage in testing part two of the midterm project.
    Uses significant use of Faker library for ease of code writing that results in
    realistic looking data entries instead of strings of random letters and numbers.

    This is not truly needed, but allows for more realistic, and easier testing if
    the data looks like it should in actual usage. It is hard to parse random strings.

    Several of the requirements for data such as dates, names, characters, etc are
    baked into the method of generating them "randomly." As such, most of the values
    are not checked. However, there is technically a chance for the DOB+name to produce
    an exact combo, so this is checked. A fail rejects the whole entry and regenerates
    a replacement without counting that entry.

    """

    #print("running inside")
    #print(NumberOfMembers)

    import csv
    import random
    import datetime
    import re


    #pip install Faker
    from faker import Faker
    fake = Faker()

    #creates main list
    MemberList = []

    monthconvert = dict(Jan='January', Feb='February', Mar='March', Apr='April',
                        May='May', Jun='June', Jul='July', Aug='August', Sep='September',
                        Oct='October', Nov='November', Dec='December')
    DATE_re = r"([a-z-A-Z]+) (\d{1}|\d{2}) ([\d]{4})\Z"

    #loop generates members and appends valid ones to MemberList
    looper = 0
    while looper < NumberOfMembers:
        Member = [] #list to hold gen member until appended to approved list

        MemberNumber = format(looper, "06") #generates the member number, sets format to preceeding zeroes

        #generates names at random
        MemFName = fake.first_name()
        MemMName = fake.first_name()
        MemLName = fake.last_name()

        #generates random adress
        MemAddress = fake.address()
        MemAddress = MemAddress.replace("\n", ", ") #removes newline standard added in faker with ","

        #generates status
        MemStatus = random.choice(["Basic", "Silver", "Gold", "Platinum", "None"])

        #gen starting date starting with earliest possible up to today
        jyear= random.randint(1981,datetime.datetime.now().year-1)
        jmon= random.randint(1,12)
        jday= random.randint(1, 28)
        MemJoin = datetime.date(jyear, jmon, jday)

        #gen birthdate, set such that member must be 18 years at Join Date
        bdays= random.randint(6588,43920) #6588 is 18 years (+ leap year control) in days 43920 is about 120 years
        MemBirth = MemJoin - datetime.timedelta(days=bdays) #subtract age in days from join date

        #generates end date if the member has canceled
        if MemStatus == "None":
            MemEnd = fake.date_between(MemJoin, "today")
#            endshift = datetime.datetime.now()-datetime.datetime(MemJoin.year, MemJoin.month, MemJoin.day)
#            print(MemJoin)
#            print(endshift)
#            timemem = random.randint(0,endshift.days)
#            print(timemem)
#            MemEnd = MemJoin + datetime.timedelta(days=timemem)
        else:
            MemEnd = ""

        #generates renewel date - a bit odd to have a renew date for canceled members, but this section
        # is noted as being mandatory, possibly used to send a message to lapsed members as well?
        MemRenew = fake.date_between("today", "+5y")#future date up to 5 years out

        #generates phone number with no (000) allowed
        #without a list of rules for phone numbers, no real way to guarantee everything is valid
        #I have instead chosen to make the phone number contain the "XXX-555-XXXX" such that
        #all of these numbers are notably fake numbers (555) prefix.
        phone1 = random.randint(100,999) #no 000 area code allowed, this method gets random numbers but retains format
        phone2 = random.randint(1000,9999) #my father's phone number used to end in 0000, but this retains format
        MemPhone = str(phone1)+"555"+str(phone2)

        #generates fake email Unlike the phone numbers, these are all possible
        MemEmail = fake.email()

        #generates notes
        MemNote = fake.sentence()

        #creating entry basis
        Member.append(MemberNumber)
        Member.append(MemFName)
        Member.append(MemMName)
        Member.append(MemLName)
        MemBirth = MemBirth.strftime('%b %d %Y')
        MemBirth_match = re.search(DATE_re, str(MemBirth))
        MemBirth = monthconvert[MemBirth_match.group(1)] + " " + MemBirth_match.group(2) + " " + MemBirth_match.group(3)
        Member.append(MemBirth)
        Member.append(MemAddress)
        Member.append(MemStatus)
        MemJoin = MemJoin.strftime('%b %d %Y')
        MemJoin_match = re.search(DATE_re, str(MemJoin))
        MemJoin = monthconvert[MemJoin_match.group(1)] + " " + MemJoin_match.group(2) + " " + MemJoin_match.group(3)
        Member.append(MemJoin)
        if MemEnd == "": #if check needed to swap str format since this cell is often empty
            Member.append(MemEnd)
        else:
            MemEnd = MemEnd.strftime('%b %d %Y')
            MemEnd_match = re.search(DATE_re, str(MemEnd))
            MemEnd = monthconvert[MemEnd_match.group(1)] + " " + MemEnd_match.group(2) + " " + MemEnd_match.group(3)
            Member.append(MemEnd)
        MemRenew = MemRenew.strftime('%b %d %Y')
        MemRenew_match = re.search(DATE_re, str(MemRenew))
        MemRenew = monthconvert[MemRenew_match.group(1)] + " " + MemRenew_match.group(2) + " " + MemRenew_match.group(3)
        Member.append(MemRenew)
        Member.append(MemPhone)
        Member.append(MemEmail)
        Member.append(MemNote)

        #check that member name/DOB combo is not in use

        index = 0
        Check = 0

        #loops through existing approved list, checks if member exists
        while index < len(MemberList):
            if Member[1:5] == MemberList[index][1:5]:
                Check = 1 #if member exists, need to reject gen value
                break
            index = index+1 #loops through whole list of genned members

        #if member Check failed, need to reject gen value
        if Check == 1:
            del Member #rejects member and I hope serves to reduce memory consumption by deletion
            continue #regenerates member, does not increment counter so it never occured

        MemberList.append(Member) #appends member to approved list

        del Member #deletes temporary member to reduce memory usage

        looper = looper+1 #moves on to next member looping until needed number of people are made



    #used in testing DO NOT USE HUGE OUTPUT WITH NO PROMPT
#    i=0
#    while i < len(MemberList):
#        print(MemberList[i])
#        i=i+1



    #write header and append all approved members to output list
    header = ["Mno", "First name", "MI", "Last name", "DoB", "Address", "Status", "msd", "med", "rdate", "Phone", "Email", "Notes"]
    MemberList.insert(0,header)

    #open file
    with open(filename,"w") as resultout:
        writeCSV = csv.writer(resultout, lineterminator = '\n')
        writeCSV.writerows(MemberList)

    #print(MemberList)
    #testing code
#    i=0
#    while i < len(MemberList):
#        print(MemberList[i])
#        i=i+1
    print(MemberList)

    #close file




import sys

#sys grab arguments

arguments = sys.argv
NumberOfMembers=1000
filename = "memberdata.csv"

#loops through arguments to pull in values to pass to main()
#I wanted to try using Optparse, but I couldn't get it to work with
#the format given for the flags. This method works and will ignore any
#gibberish entered that isn't flagged
i = 0
argcheck =0 #error checker
while i < len(arguments)-1:
    if arguments[i] == "-no":
#            print("no found")
#            print(arguments[i+1])
        try:
            NumberOfMembers = int(arguments[i+1])
        except ValueError:
            print("Please ensure that an integer lower than 1,000,000 has been given for number of members")
            argcheck = 1
    if arguments[i] == "-fname":
#            print("-fnamefound")
#            print(arguments[i+1])
        filename = arguments[i+1]
    i=i+1



#check that number of member arguments is not too long

if NumberOfMembers > 999999:
    print("Number of Members exceeds maximum value")
    argcheck =1 #prevents running of file



#run main only if everything sent is valid
if __name__ == "__main__" and argcheck == 0:
    main(NumberOfMembers, filename)

#main(NumberOfMembers, filename)